Initial commit: Colorize API with Firebase App Check integration

.dockerignore

@@ -0,0 +1,22 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.venv/
+*.egg-info/
+dist/
+build/
+.git
+.gitignore
+*.md
+.DS_Store
+uploads/*
+results/*
+*.log
+.env
+.vscode
+.idea
+

.gitignore

@@ -0,0 +1,28 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+.venv/
+*.egg-info/
+dist/
+build/
+.eggs/
+*.log
+.env
+.venv
+uploads/
+results/
+*.jpg
+*.jpeg
+*.png
+.vscode/
+.idea/
+.DS_Store
+colorize-662df-firebase-adminsdk-fbsvc-e080668793.json
+text-guided-image-colorization/
+.history/
+

.history/.dockerignore_20251111094015

@@ -0,0 +1,22 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.venv/
+*.egg-info/
+dist/
+build/
+.git
+.gitignore
+*.md
+.DS_Store
+uploads/*
+results/*
+*.log
+.env
+.vscode
+.idea
+

.history/.gitignore_20251111094027

@@ -0,0 +1,26 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+.venv/
+*.egg-info/
+dist/
+build/
+.eggs/
+*.log
+.env
+.venv
+uploads/
+results/
+*.jpg
+*.jpeg
+*.png
+.vscode/
+.idea/
+.DS_Store
+colorize-662df-firebase-adminsdk-fbsvc-e080668793.json
+

.history/DEPLOYMENT_20251111094442.md

@@ -0,0 +1,143 @@
+# Deployment Guide
+
+## Quick Start
+
+### 1. Copy Firebase Credentials
+
+Copy your Firebase Admin SDK JSON file to the project root:
+```bash
+# Windows
+copy C:\Colorize\colorize-662df-firebase-adminsdk-fbsvc-e080668793.json .
+
+# Linux/Mac
+cp /path/to/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json .
+```
+
+**Important**: For Hugging Face Spaces, you should add this as a secret instead of committing it to the repository.
+
+### 2. Deploy to Hugging Face Spaces
+
+```bash
+# Initialize git repository
+git init
+git add .
+git commit -m "Deploy Colorize API"
+
+# Add Hugging Face remote
+git remote add origin https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+
+# Push to Hugging Face
+git push -u origin main
+```
+
+### 3. Configure Hugging Face Space Secrets
+
+1. Go to your Space: https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+2. Navigate to Settings → Secrets
+3. Add a new secret:
+   - **Name**: `FIREBASE_CREDENTIALS`
+   - **Value**: Paste the entire contents of your Firebase Admin SDK JSON file
+
+### 4. Update Dockerfile for Secrets (Optional)
+
+If you want to use the secret, you can modify the Dockerfile to create the file from the secret:
+
+```dockerfile
+# Add this before the CMD line
+RUN if [ -n "$FIREBASE_CREDENTIALS" ]; then \
+    echo "$FIREBASE_CREDENTIALS" > colorize-662df-firebase-adminsdk-fbsvc-e080668793.json; \
+    fi
+```
+
+## Testing Locally
+
+### Run with Docker
+
+```bash
+# Build image
+docker build -t colorize-api .
+
+# Run container
+docker run -p 7860:7860 \
+  -v $(pwd)/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json:/app/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json \
+  colorize-api
+```
+
+### Run without Docker
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run API
+uvicorn app.main:app --host 0.0.0.0 --port 7860
+```
+
+## API Endpoints
+
+Once deployed, your API will be available at:
+- `https://logicgoinfotechspaces-colorize.hf.space/health` - Health check
+- `https://logicgoinfotechspaces-colorize.hf.space/colorize` - Colorize image
+- `https://logicgoinfotechspaces-colorize.hf.space/upload` - Upload image
+
+## Frontend Integration Example
+
+```javascript
+// Initialize Firebase
+import { initializeApp } from "firebase/app";
+import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
+
+const firebaseConfig = {
+  apiKey: "AIzaSyBIB6rcfyyqy5niERTXWvVD714Ter4Vx68",
+  authDomain: "colorize-662df.firebaseapp.com",
+  projectId: "colorize-662df",
+  storageBucket: "colorize-662df.firebasestorage.app",
+  messagingSenderId: "69166278311",
+  appId: "1:69166278311:web:0e8c50b8dd8627aaeadd82",
+  measurementId: "G-58CC2J8XKX"
+};
+
+const app = initializeApp(firebaseConfig);
+const appCheck = initializeAppCheck(app, {
+  provider: new ReCaptchaEnterpriseProvider('YOUR_RECAPTCHA_SITE_KEY'),
+  isTokenAutoRefreshEnabled: true
+});
+
+// Colorize image function
+async function colorizeImage(file) {
+  const { getToken } = await import('firebase/app-check');
+  const token = await getToken(appCheck);
+  
+  const formData = new FormData();
+  formData.append('file', file);
+  
+  const response = await fetch('https://logicgoinfotechspaces-colorize.hf.space/colorize', {
+    method: 'POST',
+    headers: {
+      'X-Firebase-AppCheck': token.token
+    },
+    body: formData
+  });
+  
+  return await response.json();
+}
+```
+
+## Troubleshooting
+
+### Model Not Loading
+
+- Check Hugging Face Space logs
+- Verify model ID: `rsortino/ColorizeNet`
+- Ensure sufficient disk space (models can be large)
+
+### Firebase App Check Failing
+
+- Verify credentials are correctly set as a secret
+- Check that App Check is enabled in Firebase Console
+- Ensure reCAPTCHA Enterprise is set up
+
+### Port Issues
+
+Hugging Face Spaces automatically handles port 7860. The Dockerfile is configured for this.
+

.history/Dockerfile_20251111094013

@@ -0,0 +1,41 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create directories for uploads and results
+RUN mkdir -p uploads results
+
+# Expose port
+EXPOSE 8000
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV BASE_URL=http://localhost:8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:8000/health')" || exit 1
+
+# Run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
+

.history/Dockerfile_20251111094238

@@ -0,0 +1,42 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create directories for uploads and results
+RUN mkdir -p uploads results
+
+# Expose port (Hugging Face Spaces uses port 7860)
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV BASE_URL=${SPACE_HOST}
+ENV PORT=7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health', timeout=5)" || exit 1
+
+# Run the application
+CMD uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}

.history/Dockerfile_20251111094448

@@ -0,0 +1,46 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create directories for uploads and results
+RUN mkdir -p uploads results
+
+# Handle Firebase credentials from environment variable (for Hugging Face Spaces secrets)
+# This allows the credentials to be passed as a secret and written to file at runtime
+RUN echo '#!/bin/bash\nif [ -n "$FIREBASE_CREDENTIALS" ]; then echo "$FIREBASE_CREDENTIALS" > colorize-662df-firebase-adminsdk-fbsvc-e080668793.json; fi\nexec "$@"' > /entrypoint.sh && chmod +x /entrypoint.sh
+
+# Expose port (Hugging Face Spaces uses port 7860)
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV BASE_URL=${SPACE_HOST}
+ENV PORT=7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health', timeout=5)" || exit 1
+
+# Run the application
+CMD uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}

.history/Dockerfile_20251111094450

@@ -0,0 +1,49 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create directories for uploads and results
+RUN mkdir -p uploads results
+
+# Handle Firebase credentials from environment variable (for Hugging Face Spaces secrets)
+# This allows the credentials to be passed as a secret and written to file at runtime
+RUN echo '#!/bin/bash\nif [ -n "$FIREBASE_CREDENTIALS" ]; then echo "$FIREBASE_CREDENTIALS" > colorize-662df-firebase-adminsdk-fbsvc-e080668793.json; fi\nexec "$@"' > /entrypoint.sh && chmod +x /entrypoint.sh
+
+# Expose port (Hugging Face Spaces uses port 7860)
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV BASE_URL=${SPACE_HOST}
+ENV PORT=7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health', timeout=5)" || exit 1
+
+# Set entrypoint
+ENTRYPOINT ["/entrypoint.sh"]
+
+# Run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "${PORT:-7860}"]

.history/Dockerfile_20251111094456

@@ -0,0 +1,49 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create directories for uploads and results
+RUN mkdir -p uploads results
+
+# Handle Firebase credentials from environment variable (for Hugging Face Spaces secrets)
+# This allows the credentials to be passed as a secret and written to file at runtime
+RUN echo '#!/bin/bash\nif [ -n "$FIREBASE_CREDENTIALS" ]; then echo "$FIREBASE_CREDENTIALS" > colorize-662df-firebase-adminsdk-fbsvc-e080668793.json; fi\nexec "$@"' > /entrypoint.sh && chmod +x /entrypoint.sh
+
+# Expose port (Hugging Face Spaces uses port 7860)
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV BASE_URL=${SPACE_HOST}
+ENV PORT=7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health', timeout=5)" || exit 1
+
+# Set entrypoint
+ENTRYPOINT ["/entrypoint.sh"]
+
+# Run the application (port will be set via environment variable)
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}"]

.history/Dockerfile_20251111094522

@@ -0,0 +1,49 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create directories for uploads and results
+RUN mkdir -p uploads results
+
+# Handle Firebase credentials from environment variable (for Hugging Face Spaces secrets)
+# This allows the credentials to be passed as a secret and written to file at runtime
+RUN echo '#!/bin/bash\nif [ -n "$FIREBASE_CREDENTIALS" ]; then echo "$FIREBASE_CREDENTIALS" > colorize-662df-firebase-adminsdk-fbsvc-e080668793.json; fi\nexec "$@"' > /entrypoint.sh && chmod +x /entrypoint.sh
+
+# Expose port (Hugging Face Spaces uses port 7860)
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV BASE_URL=${SPACE_HOST}
+ENV PORT=7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health', timeout=5)" || exit 1
+
+# Set entrypoint
+ENTRYPOINT ["/entrypoint.sh"]
+
+# Run the application (port will be set via environment variable)
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}"]

.history/README_20251111094025.md

@@ -0,0 +1,135 @@
+# Colorize Image API
+
+FastAPI-based image colorization service using ColorizeNet model with Firebase App Check integration.
+
+## Features
+
+- 🖼️ Image upload and colorization
+- 🔒 Firebase App Check authentication
+- 🐳 Docker support
+- 🚀 Hugging Face Spaces deployment ready
+- 📥 Download URLs for browser access
+
+## API Endpoints
+
+### Health Check
+```
+GET /health
+```
+Returns the health status of the API and model.
+
+### Upload Image
+```
+POST /upload
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Uploads an image and returns the image URL.
+
+### Colorize Image
+```
+POST /colorize
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Colorizes a grayscale image and returns the result URL.
+
+### Download Result
+```
+GET /download/{file_id}
+Headers: X-Firebase-AppCheck: <token>
+```
+Downloads the colorized image by file ID.
+
+### Get Result (Public)
+```
+GET /results/{filename}
+```
+Public endpoint to access colorized images in browser.
+
+## Setup
+
+### Local Development
+
+1. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Place Firebase credentials file:
+```
+colorize-662df-firebase-adminsdk-fbsvc-e080668793.json
+```
+
+3. Run the application:
+```bash
+uvicorn app.main:app --reload
+```
+
+### Docker
+
+1. Build the image:
+```bash
+docker build -t colorize-api .
+```
+
+2. Run the container:
+```bash
+docker run -p 8000:8000 \
+  -v $(pwd)/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json:/app/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json \
+  colorize-api
+```
+
+### Hugging Face Spaces
+
+1. Push to Hugging Face Space:
+```bash
+git init
+git add .
+git commit -m "Initial commit"
+git remote add origin https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+git push -u origin main
+```
+
+## Environment Variables
+
+- `ENABLE_APP_CHECK`: Enable/disable Firebase App Check (default: true)
+- `FIREBASE_CREDENTIALS_PATH`: Path to Firebase credentials JSON file
+- `BASE_URL`: Base URL for the API (for generating download URLs)
+- `MODEL_ID`: Hugging Face model ID (default: rsortino/ColorizeNet)
+- `NUM_INFERENCE_STEPS`: Number of inference steps (default: 20)
+
+## Firebase App Check Setup
+
+1. Initialize Firebase App Check in your frontend:
+```javascript
+import { initializeApp } from "firebase/app";
+import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
+
+const app = initializeApp(firebaseConfig);
+const appCheck = initializeAppCheck(app, {
+  provider: new ReCaptchaEnterpriseProvider('your-recaptcha-site-key'),
+  isTokenAutoRefreshEnabled: true
+});
+```
+
+2. Include the token in API requests:
+```javascript
+const token = await appCheck.getToken();
+fetch('/colorize', {
+  method: 'POST',
+  headers: {
+    'X-Firebase-AppCheck': token.token
+  },
+  body: formData
+});
+```
+
+## Model
+
+This API uses the `rsortino/ColorizeNet` model from Hugging Face for image colorization.
+
+## License
+
+MIT
+

.history/README_20251111094115.md

@@ -0,0 +1,135 @@
+# Colorize Image API
+
+FastAPI-based image colorization service using ColorizeNet model with Firebase App Check integration.
+
+## Features
+
+- 🖼️ Image upload and colorization
+- 🔒 Firebase App Check authentication
+- 🐳 Docker support
+- 🚀 Hugging Face Spaces deployment ready
+- 📥 Download URLs for browser access
+
+## API Endpoints
+
+### Health Check
+```
+GET /health
+```
+Returns the health status of the API and model.
+
+### Upload Image
+```
+POST /upload
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Uploads an image and returns the image URL.
+
+### Colorize Image
+```
+POST /colorize
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Colorizes a grayscale image and returns the result URL.
+
+### Download Result
+```
+GET /download/{file_id}
+Headers: X-Firebase-AppCheck: <token>
+```
+Downloads the colorized image by file ID.
+
+### Get Result (Public)
+```
+GET /results/{filename}
+```
+Public endpoint to access colorized images in browser.
+
+## Setup
+
+### Local Development
+
+1. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Place Firebase credentials file:
+```
+colorize-662df-firebase-adminsdk-fbsvc-e080668793.json
+```
+
+3. Run the application:
+```bash
+uvicorn app.main:app --reload
+```
+
+### Docker
+
+1. Build the image:
+```bash
+docker build -t colorize-api .
+```
+
+2. Run the container:
+```bash
+docker run -p 8000:8000 \
+  -v $(pwd)/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json:/app/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json \
+  colorize-api
+```
+
+### Hugging Face Spaces
+
+1. Push to Hugging Face Space:
+```bash
+git init
+git add .
+git commit -m "Initial commit"
+git remote add origin https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+git push -u origin main
+```
+
+## Environment Variables
+
+- `ENABLE_APP_CHECK`: Enable/disable Firebase App Check (default: true)
+- `FIREBASE_CREDENTIALS_PATH`: Path to Firebase credentials JSON file
+- `BASE_URL`: Base URL for the API (for generating download URLs)
+- `MODEL_ID`: Hugging Face model ID (default: rsortino/ColorizeNet)
+- `NUM_INFERENCE_STEPS`: Number of inference steps (default: 20)
+
+## Firebase App Check Setup
+
+1. Initialize Firebase App Check in your frontend:
+```javascript
+import { initializeApp } from "firebase/app";
+import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
+
+const app = initializeApp(firebaseConfig);
+const appCheck = initializeAppCheck(app, {
+  provider: new ReCaptchaEnterpriseProvider('your-recaptcha-site-key'),
+  isTokenAutoRefreshEnabled: true
+});
+```
+
+2. Include the token in API requests:
+```javascript
+const token = await appCheck.getToken();
+fetch('/colorize', {
+  method: 'POST',
+  headers: {
+    'X-Firebase-AppCheck': token.token
+  },
+  body: formData
+});
+```
+
+## Model
+
+This API uses the `rsortino/ColorizeNet` model from Hugging Face for image colorization.
+
+## License
+
+MIT
+

.history/README_20251111094339.md

@@ -0,0 +1,114 @@
+---
+title: Colorize Image API
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
+sdk: docker
+sdk_version: 1.0.0
+app_file: Dockerfile
+pinned: false
+license: mit
+---
+
+# Colorize Image API
+
+FastAPI-based image colorization service using ColorizeNet model with Firebase App Check integration.
+
+## Features
+
+- 🖼️ Image upload and colorization
+- 🔒 Firebase App Check authentication
+- 🐳 Docker deployment
+- 📥 Download URLs for browser access
+
+## API Endpoints
+
+### Health Check
+```
+GET /health
+```
+Returns the health status of the API and model.
+
+### Upload Image
+```
+POST /upload
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Uploads an image and returns the image URL.
+
+### Colorize Image
+```
+POST /colorize
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Colorizes a grayscale image and returns the result URL.
+
+### Download Result
+```
+GET /download/{file_id}
+Headers: X-Firebase-AppCheck: <token>
+```
+Downloads the colorized image by file ID.
+
+### Get Result (Public)
+```
+GET /results/{filename}
+```
+Public endpoint to access colorized images in browser.
+
+## Setup
+
+### Environment Variables
+
+Set these in your Hugging Face Space secrets:
+
+- `FIREBASE_CREDENTIALS_PATH`: Path to Firebase credentials JSON file (or set as secret)
+- `ENABLE_APP_CHECK`: Enable/disable Firebase App Check (default: true)
+- `MODEL_ID`: Hugging Face model ID (default: rsortino/ColorizeNet)
+- `NUM_INFERENCE_STEPS`: Number of inference steps (default: 20)
+
+### Firebase App Check Setup
+
+1. Initialize Firebase App Check in your frontend:
+```javascript
+import { initializeApp } from "firebase/app";
+import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
+
+const firebaseConfig = {
+  apiKey: "AIzaSyBIB6rcfyyqy5niERTXWvVD714Ter4Vx68",
+  authDomain: "colorize-662df.firebaseapp.com",
+  projectId: "colorize-662df",
+  storageBucket: "colorize-662df.firebasestorage.app",
+  messagingSenderId: "69166278311",
+  appId: "1:69166278311:web:0e8c50b8dd8627aaeadd82",
+  measurementId: "G-58CC2J8XKX"
+};
+
+const app = initializeApp(firebaseConfig);
+const appCheck = initializeAppCheck(app, {
+  provider: new ReCaptchaEnterpriseProvider('your-recaptcha-site-key'),
+  isTokenAutoRefreshEnabled: true
+});
+```
+
+2. Include the token in API requests:
+```javascript
+const token = await appCheck.getToken();
+fetch('https://your-space.hf.space/colorize', {
+  method: 'POST',
+  headers: {
+    'X-Firebase-AppCheck': token.token
+  },
+  body: formData
+});
+```
+
+## Model
+
+This API uses the `rsortino/ColorizeNet` model from Hugging Face for image colorization.
+
+## License
+
+MIT

.history/README_20251111094352.md

@@ -0,0 +1,114 @@
+---
+title: Colorize Image API
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
+sdk: docker
+sdk_version: 1.0.0
+app_file: Dockerfile
+pinned: false
+license: mit
+---
+
+# Colorize Image API
+
+FastAPI-based image colorization service using ColorizeNet model with Firebase App Check integration.
+
+## Features
+
+- 🖼️ Image upload and colorization
+- 🔒 Firebase App Check authentication
+- 🐳 Docker deployment
+- 📥 Download URLs for browser access
+
+## API Endpoints
+
+### Health Check
+```
+GET /health
+```
+Returns the health status of the API and model.
+
+### Upload Image
+```
+POST /upload
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Uploads an image and returns the image URL.
+
+### Colorize Image
+```
+POST /colorize
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Colorizes a grayscale image and returns the result URL.
+
+### Download Result
+```
+GET /download/{file_id}
+Headers: X-Firebase-AppCheck: <token>
+```
+Downloads the colorized image by file ID.
+
+### Get Result (Public)
+```
+GET /results/{filename}
+```
+Public endpoint to access colorized images in browser.
+
+## Setup
+
+### Environment Variables
+
+Set these in your Hugging Face Space secrets:
+
+- `FIREBASE_CREDENTIALS_PATH`: Path to Firebase credentials JSON file (or set as secret)
+- `ENABLE_APP_CHECK`: Enable/disable Firebase App Check (default: true)
+- `MODEL_ID`: Hugging Face model ID (default: rsortino/ColorizeNet)
+- `NUM_INFERENCE_STEPS`: Number of inference steps (default: 20)
+
+### Firebase App Check Setup
+
+1. Initialize Firebase App Check in your frontend:
+```javascript
+import { initializeApp } from "firebase/app";
+import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
+
+const firebaseConfig = {
+  apiKey: "AIzaSyBIB6rcfyyqy5niERTXWvVD714Ter4Vx68",
+  authDomain: "colorize-662df.firebaseapp.com",
+  projectId: "colorize-662df",
+  storageBucket: "colorize-662df.firebasestorage.app",
+  messagingSenderId: "69166278311",
+  appId: "1:69166278311:web:0e8c50b8dd8627aaeadd82",
+  measurementId: "G-58CC2J8XKX"
+};
+
+const app = initializeApp(firebaseConfig);
+const appCheck = initializeAppCheck(app, {
+  provider: new ReCaptchaEnterpriseProvider('your-recaptcha-site-key'),
+  isTokenAutoRefreshEnabled: true
+});
+```
+
+2. Include the token in API requests:
+```javascript
+const token = await appCheck.getToken();
+fetch('https://your-space.hf.space/colorize', {
+  method: 'POST',
+  headers: {
+    'X-Firebase-AppCheck': token.token
+  },
+  body: formData
+});
+```
+
+## Model
+
+This API uses the `rsortino/ColorizeNet` model from Hugging Face for image colorization.
+
+## License
+
+MIT

.history/README_20251111094522.md

@@ -0,0 +1,114 @@
+---
+title: Colorize Image API
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
+sdk: docker
+sdk_version: 1.0.0
+app_file: Dockerfile
+pinned: false
+license: mit
+---
+
+# Colorize Image API
+
+FastAPI-based image colorization service using ColorizeNet model with Firebase App Check integration.
+
+## Features
+
+- 🖼️ Image upload and colorization
+- 🔒 Firebase App Check authentication
+- 🐳 Docker deployment
+- 📥 Download URLs for browser access
+
+## API Endpoints
+
+### Health Check
+```
+GET /health
+```
+Returns the health status of the API and model.
+
+### Upload Image
+```
+POST /upload
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Uploads an image and returns the image URL.
+
+### Colorize Image
+```
+POST /colorize
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Colorizes a grayscale image and returns the result URL.
+
+### Download Result
+```
+GET /download/{file_id}
+Headers: X-Firebase-AppCheck: <token>
+```
+Downloads the colorized image by file ID.
+
+### Get Result (Public)
+```
+GET /results/{filename}
+```
+Public endpoint to access colorized images in browser.
+
+## Setup
+
+### Environment Variables
+
+Set these in your Hugging Face Space secrets:
+
+- `FIREBASE_CREDENTIALS_PATH`: Path to Firebase credentials JSON file (or set as secret)
+- `ENABLE_APP_CHECK`: Enable/disable Firebase App Check (default: true)
+- `MODEL_ID`: Hugging Face model ID (default: rsortino/ColorizeNet)
+- `NUM_INFERENCE_STEPS`: Number of inference steps (default: 20)
+
+### Firebase App Check Setup
+
+1. Initialize Firebase App Check in your frontend:
+```javascript
+import { initializeApp } from "firebase/app";
+import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
+
+const firebaseConfig = {
+  apiKey: "AIzaSyBIB6rcfyyqy5niERTXWvVD714Ter4Vx68",
+  authDomain: "colorize-662df.firebaseapp.com",
+  projectId: "colorize-662df",
+  storageBucket: "colorize-662df.firebasestorage.app",
+  messagingSenderId: "69166278311",
+  appId: "1:69166278311:web:0e8c50b8dd8627aaeadd82",
+  measurementId: "G-58CC2J8XKX"
+};
+
+const app = initializeApp(firebaseConfig);
+const appCheck = initializeAppCheck(app, {
+  provider: new ReCaptchaEnterpriseProvider('your-recaptcha-site-key'),
+  isTokenAutoRefreshEnabled: true
+});
+```
+
+2. Include the token in API requests:
+```javascript
+const token = await appCheck.getToken();
+fetch('https://your-space.hf.space/colorize', {
+  method: 'POST',
+  headers: {
+    'X-Firebase-AppCheck': token.token
+  },
+  body: formData
+});
+```
+
+## Model
+
+This API uses the `rsortino/ColorizeNet` model from Hugging Face for image colorization.
+
+## License
+
+MIT

.history/README_HF_20251111094029.md

@@ -0,0 +1,40 @@
+---
+title: Colorize Image API
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
+sdk: docker
+sdk_version: 1.0.0
+app_file: Dockerfile
+pinned: false
+license: mit
+---
+
+# Colorize Image API
+
+FastAPI-based image colorization service using ColorizeNet model with Firebase App Check integration.
+
+## Features
+
+- Image upload and colorization
+- Firebase App Check authentication
+- Docker deployment
+- Download URLs for browser access
+
+## API Endpoints
+
+- `GET /health` - Health check
+- `POST /upload` - Upload image
+- `POST /colorize` - Colorize image
+- `GET /download/{file_id}` - Download result
+- `GET /results/{filename}` - Public result access
+
+## Setup
+
+The API requires Firebase credentials. Place your Firebase Admin SDK JSON file in the root directory as:
+`colorize-662df-firebase-adminsdk-fbsvc-e080668793.json`
+
+## Model
+
+Uses `rsortino/ColorizeNet` from Hugging Face for image colorization.
+

.history/SETUP_20251111094412.md

@@ -0,0 +1,193 @@
+# Setup Guide for Colorize API
+
+## Prerequisites
+
+1. Python 3.10+
+2. Docker (for containerized deployment)
+3. Firebase Admin SDK credentials file
+4. Hugging Face account with access to the Colorize Space
+
+## Local Development Setup
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Firebase Credentials
+
+Copy your Firebase Admin SDK JSON file to the project root:
+- Source: `C:\Colorize\colorize-662df-firebase-adminsdk-fbsvc-e080668793.json`
+- Destination: `colorize-662df-firebase-adminsdk-fbsvc-e080668793.json`
+
+Or set the path in environment variable:
+```bash
+export FIREBASE_CREDENTIALS_PATH=/path/to/your/firebase-credentials.json
+```
+
+### 3. Run the API
+
+```bash
+uvicorn app.main:app --reload --port 7860
+```
+
+The API will be available at `http://localhost:7860`
+
+## Docker Setup
+
+### 1. Build the Docker Image
+
+```bash
+docker build -t colorize-api .
+```
+
+### 2. Run the Container
+
+```bash
+docker run -p 7860:7860 \
+  -v $(pwd)/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json:/app/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json \
+  -e BASE_URL=http://localhost:7860 \
+  colorize-api
+```
+
+## Hugging Face Spaces Deployment
+
+### 1. Prepare Your Repository
+
+```bash
+# Initialize git repository
+git init
+git add .
+git commit -m "Initial commit: Colorize API with Firebase App Check"
+```
+
+### 2. Set Up Hugging Face Space
+
+1. Go to https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+2. If the space doesn't exist, create a new Docker space
+
+### 3. Add Firebase Credentials as Secret
+
+In Hugging Face Space settings:
+1. Go to Settings → Secrets
+2. Add a new secret:
+   - Name: `FIREBASE_CREDENTIALS`
+   - Value: Contents of your Firebase Admin SDK JSON file
+
+### 4. Update Dockerfile for Secrets (if needed)
+
+The Dockerfile will automatically use the credentials file if it exists. For Hugging Face Spaces, you may need to create the file from secrets:
+
+```dockerfile
+# Add this to Dockerfile if using HF secrets
+RUN echo "$FIREBASE_CREDENTIALS" > colorize-662df-firebase-adminsdk-fbsvc-e080668793.json || true
+```
+
+### 5. Push to Hugging Face
+
+```bash
+git remote add origin https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+git push -u origin main
+```
+
+## Testing the API
+
+### Health Check
+
+```bash
+curl http://localhost:7860/health
+```
+
+### Upload Image (with App Check token)
+
+```bash
+curl -X POST http://localhost:7860/upload \
+  -H "X-Firebase-AppCheck: YOUR_APP_CHECK_TOKEN" \
+  -F "file=@path/to/image.jpg"
+```
+
+### Colorize Image (with App Check token)
+
+```bash
+curl -X POST http://localhost:7860/colorize \
+  -H "X-Firebase-AppCheck: YOUR_APP_CHECK_TOKEN" \
+  -F "file=@path/to/grayscale_image.jpg"
+```
+
+## Frontend Integration
+
+### Initialize Firebase App Check
+
+```javascript
+import { initializeApp } from "firebase/app";
+import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
+
+const firebaseConfig = {
+  apiKey: "AIzaSyBIB6rcfyyqy5niERTXWvVD714Ter4Vx68",
+  authDomain: "colorize-662df.firebaseapp.com",
+  projectId: "colorize-662df",
+  storageBucket: "colorize-662df.firebasestorage.app",
+  messagingSenderId: "69166278311",
+  appId: "1:69166278311:web:0e8c50b8dd8627aaeadd82",
+  measurementId: "G-58CC2J8XKX"
+};
+
+const app = initializeApp(firebaseConfig);
+
+// Initialize App Check
+const appCheck = initializeAppCheck(app, {
+  provider: new ReCaptchaEnterpriseProvider('YOUR_RECAPTCHA_SITE_KEY'),
+  isTokenAutoRefreshEnabled: true
+});
+
+// Get token and make API call
+async function colorizeImage(imageFile) {
+  const token = await appCheck.getToken();
+  
+  const formData = new FormData();
+  formData.append('file', imageFile);
+  
+  const response = await fetch('https://your-space.hf.space/colorize', {
+    method: 'POST',
+    headers: {
+      'X-Firebase-AppCheck': token.token
+    },
+    body: formData
+  });
+  
+  const result = await response.json();
+  console.log('Colorized image URL:', result.download_url);
+  return result;
+}
+```
+
+## Troubleshooting
+
+### Model Loading Issues
+
+If the ColorizeNet model fails to load:
+1. Check your internet connection (model downloads from Hugging Face)
+2. Verify you have sufficient disk space
+3. Check logs for specific error messages
+
+### Firebase App Check Issues
+
+If App Check verification fails:
+1. Verify your Firebase credentials file is correct
+2. Check that App Check is enabled in Firebase Console
+3. Ensure the token is being sent in the `X-Firebase-AppCheck` header
+
+### Port Issues
+
+Hugging Face Spaces uses port 7860 by default. Make sure your Dockerfile exposes this port.
+
+## Environment Variables
+
+- `FIREBASE_CREDENTIALS_PATH`: Path to Firebase Admin SDK JSON file
+- `ENABLE_APP_CHECK`: Enable/disable Firebase App Check (true/false)
+- `BASE_URL`: Base URL for generating download URLs
+- `PORT`: Port to run the API on (default: 7860)
+- `MODEL_ID`: Hugging Face model ID (default: rsortino/ColorizeNet)
+- `NUM_INFERENCE_STEPS`: Number of inference steps (default: 20)
+

.history/app/__init___20251111094026.py

@@ -0,0 +1,2 @@
+# Colorize API Package
+

.history/app/colorize_model_20251111094002.py

@@ -0,0 +1,154 @@
+"""
+ColorizeNet model wrapper for image colorization
+"""
+import logging
+import torch
+import numpy as np
+from PIL import Image
+import cv2
+from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
+from diffusers.utils import load_image
+from transformers import pipeline
+
+logger = logging.getLogger(__name__)
+
+class ColorizeModel:
+    """Wrapper for ColorizeNet model"""
+    
+    def __init__(self, model_id: str = "rsortino/ColorizeNet"):
+        """
+        Initialize the ColorizeNet model
+        
+        Args:
+            model_id: Hugging Face model ID for ColorizeNet
+        """
+        self.model_id = model_id
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info("Using device: %s", self.device)
+        
+        try:
+            # Load ControlNet model
+            self.controlnet = ControlNetModel.from_pretrained(
+                model_id,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+            )
+            
+            # Load Stable Diffusion pipeline with ControlNet
+            self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+                "runwayml/stable-diffusion-v1-5",
+                controlnet=self.controlnet,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                safety_checker=None,
+                requires_safety_checker=False
+            )
+            
+            self.pipe.to(self.device)
+            
+            # Enable memory efficient attention if available
+            if hasattr(self.pipe, "enable_xformers_memory_efficient_attention"):
+                try:
+                    self.pipe.enable_xformers_memory_efficient_attention()
+                except:
+                    pass
+            
+            logger.info("ColorizeNet model loaded successfully")
+        except Exception as e:
+            logger.error("Error loading ColorizeNet model: %s", str(e))
+            # Fallback: try alternative loading method
+            try:
+                self.pipe = pipeline(
+                    "image-to-image",
+                    model=model_id,
+                    device=0 if self.device == "cuda" else -1
+                )
+                logger.info("ColorizeNet model loaded using pipeline")
+            except Exception as e2:
+                logger.error("Failed to load model with pipeline: %s", str(e2))
+                raise
+    
+    def preprocess_image(self, image: Image.Image) -> Image.Image:
+        """
+        Preprocess image for colorization
+        
+        Args:
+            image: PIL Image
+            
+        Returns:
+            Preprocessed PIL Image
+        """
+        # Convert to grayscale if needed
+        if image.mode != "L":
+            # Convert to grayscale
+            image = image.convert("L")
+        
+        # Convert back to RGB (grayscale image with 3 channels)
+        image = image.convert("RGB")
+        
+        # Resize to standard size (512x512 for SD models)
+        image = image.resize((512, 512), Image.Resampling.LANCZOS)
+        
+        return image
+    
+    def colorize(self, image: Image.Image, num_inference_steps: int = 20) -> Image.Image:
+        """
+        Colorize a grayscale image
+        
+        Args:
+            image: PIL Image (grayscale or color)
+            num_inference_steps: Number of inference steps
+            
+        Returns:
+            Colorized PIL Image
+        """
+        try:
+            # Preprocess image
+            control_image = self.preprocess_image(image)
+            original_size = image.size
+            
+            # Prepare prompt for colorization
+            prompt = "colorize this black and white image, high quality, detailed, vibrant colors"
+            negative_prompt = "black and white, grayscale, monochrome, low quality, blurry"
+            
+            # Generate colorized image
+            if hasattr(self.pipe, "__call__"):
+                # Use ControlNet pipeline
+                result = self.pipe(
+                    prompt=prompt,
+                    image=control_image,
+                    negative_prompt=negative_prompt,
+                    num_inference_steps=num_inference_steps,
+                    guidance_scale=7.5,
+                    controlnet_conditioning_scale=1.0
+                )
+                
+                if isinstance(result, dict) and "images" in result:
+                    colorized = result["images"][0]
+                elif isinstance(result, list) and len(result) > 0:
+                    colorized = result[0]
+                else:
+                    colorized = result
+            else:
+                # Use pipeline directly
+                colorized = self.pipe(
+                    control_image,
+                    prompt=prompt,
+                    num_inference_steps=num_inference_steps
+                )
+            
+            # Ensure we have a PIL Image
+            if not isinstance(colorized, Image.Image):
+                if isinstance(colorized, np.ndarray):
+                    colorized = Image.fromarray(colorized)
+                else:
+                    raise ValueError("Unexpected output type from model")
+            
+            # Resize back to original size
+            if original_size != (512, 512):
+                colorized = colorized.resize(original_size, Image.Resampling.LANCZOS)
+            
+            return colorized
+            
+        except Exception as e:
+            logger.error("Error during colorization: %s", str(e))
+            raise
+

.history/app/colorize_model_20251111094219.py

@@ -0,0 +1,176 @@
+"""
+ColorizeNet model wrapper for image colorization
+"""
+import logging
+import torch
+import numpy as np
+from PIL import Image
+import cv2
+from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, StableDiffusionXLControlNetPipeline
+from diffusers.utils import load_image
+from transformers import pipeline
+from huggingface_hub import hf_hub_download
+
+logger = logging.getLogger(__name__)
+
+class ColorizeModel:
+    """Wrapper for ColorizeNet model"""
+    
+    def __init__(self, model_id: str = "rsortino/ColorizeNet"):
+        """
+        Initialize the ColorizeNet model
+        
+        Args:
+            model_id: Hugging Face model ID for ColorizeNet
+        """
+        self.model_id = model_id
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info("Using device: %s", self.device)
+        self.dtype = torch.float16 if self.device == "cuda" else torch.float32
+        
+        try:
+            # Try loading as ControlNet with Stable Diffusion
+            logger.info("Attempting to load ColorizeNet as ControlNet...")
+            try:
+                # Load ControlNet model
+                self.controlnet = ControlNetModel.from_pretrained(
+                    model_id,
+                    torch_dtype=self.dtype
+                )
+                
+                # Try SDXL first, fallback to SD 1.5
+                try:
+                    self.pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
+                        "stabilityai/stable-diffusion-xl-base-1.0",
+                        controlnet=self.controlnet,
+                        torch_dtype=self.dtype,
+                        safety_checker=None,
+                        requires_safety_checker=False
+                    )
+                    logger.info("Loaded with SDXL base model")
+                except:
+                    self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+                        "runwayml/stable-diffusion-v1-5",
+                        controlnet=self.controlnet,
+                        torch_dtype=self.dtype,
+                        safety_checker=None,
+                        requires_safety_checker=False
+                    )
+                    logger.info("Loaded with SD 1.5 base model")
+                
+                self.pipe.to(self.device)
+                
+                # Enable memory efficient attention if available
+                if hasattr(self.pipe, "enable_xformers_memory_efficient_attention"):
+                    try:
+                        self.pipe.enable_xformers_memory_efficient_attention()
+                        logger.info("XFormers memory efficient attention enabled")
+                    except Exception as e:
+                        logger.warning("Could not enable XFormers: %s", str(e))
+                
+                logger.info("ColorizeNet model loaded successfully as ControlNet")
+                self.model_type = "controlnet"
+                
+            except Exception as e:
+                logger.warning("Failed to load as ControlNet: %s", str(e))
+                # Fallback: try as image-to-image pipeline
+                logger.info("Trying to load as image-to-image pipeline...")
+                self.pipe = pipeline(
+                    "image-to-image",
+                    model=model_id,
+                    device=0 if self.device == "cuda" else -1,
+                    torch_dtype=self.dtype
+                )
+                logger.info("ColorizeNet model loaded using image-to-image pipeline")
+                self.model_type = "pipeline"
+                
+        except Exception as e:
+            logger.error("Failed to load ColorizeNet model: %s", str(e))
+            raise RuntimeError(f"Could not load ColorizeNet model: {str(e)}")
+    
+    def preprocess_image(self, image: Image.Image) -> Image.Image:
+        """
+        Preprocess image for colorization
+        
+        Args:
+            image: PIL Image
+            
+        Returns:
+            Preprocessed PIL Image
+        """
+        # Convert to grayscale if needed
+        if image.mode != "L":
+            # Convert to grayscale
+            image = image.convert("L")
+        
+        # Convert back to RGB (grayscale image with 3 channels)
+        image = image.convert("RGB")
+        
+        # Resize to standard size (512x512 for SD models)
+        image = image.resize((512, 512), Image.Resampling.LANCZOS)
+        
+        return image
+    
+    def colorize(self, image: Image.Image, num_inference_steps: int = 20) -> Image.Image:
+        """
+        Colorize a grayscale image
+        
+        Args:
+            image: PIL Image (grayscale or color)
+            num_inference_steps: Number of inference steps
+            
+        Returns:
+            Colorized PIL Image
+        """
+        try:
+            # Preprocess image
+            control_image = self.preprocess_image(image)
+            original_size = image.size
+            
+            # Prepare prompt for colorization
+            prompt = "colorize this black and white image, high quality, detailed, vibrant colors"
+            negative_prompt = "black and white, grayscale, monochrome, low quality, blurry"
+            
+            # Generate colorized image
+            if hasattr(self.pipe, "__call__"):
+                # Use ControlNet pipeline
+                result = self.pipe(
+                    prompt=prompt,
+                    image=control_image,
+                    negative_prompt=negative_prompt,
+                    num_inference_steps=num_inference_steps,
+                    guidance_scale=7.5,
+                    controlnet_conditioning_scale=1.0
+                )
+                
+                if isinstance(result, dict) and "images" in result:
+                    colorized = result["images"][0]
+                elif isinstance(result, list) and len(result) > 0:
+                    colorized = result[0]
+                else:
+                    colorized = result
+            else:
+                # Use pipeline directly
+                colorized = self.pipe(
+                    control_image,
+                    prompt=prompt,
+                    num_inference_steps=num_inference_steps
+                )
+            
+            # Ensure we have a PIL Image
+            if not isinstance(colorized, Image.Image):
+                if isinstance(colorized, np.ndarray):
+                    colorized = Image.fromarray(colorized)
+                else:
+                    raise ValueError("Unexpected output type from model")
+            
+            # Resize back to original size
+            if original_size != (512, 512):
+                colorized = colorized.resize(original_size, Image.Resampling.LANCZOS)
+            
+            return colorized
+            
+        except Exception as e:
+            logger.error("Error during colorization: %s", str(e))
+            raise
+

.history/app/colorize_model_20251111094231.py

@@ -0,0 +1,195 @@
+"""
+ColorizeNet model wrapper for image colorization
+"""
+import logging
+import torch
+import numpy as np
+from PIL import Image
+import cv2
+from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, StableDiffusionXLControlNetPipeline
+from diffusers.utils import load_image
+from transformers import pipeline
+from huggingface_hub import hf_hub_download
+
+logger = logging.getLogger(__name__)
+
+class ColorizeModel:
+    """Wrapper for ColorizeNet model"""
+    
+    def __init__(self, model_id: str = "rsortino/ColorizeNet"):
+        """
+        Initialize the ColorizeNet model
+        
+        Args:
+            model_id: Hugging Face model ID for ColorizeNet
+        """
+        self.model_id = model_id
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info("Using device: %s", self.device)
+        self.dtype = torch.float16 if self.device == "cuda" else torch.float32
+        
+        try:
+            # Try loading as ControlNet with Stable Diffusion
+            logger.info("Attempting to load ColorizeNet as ControlNet...")
+            try:
+                # Load ControlNet model
+                self.controlnet = ControlNetModel.from_pretrained(
+                    model_id,
+                    torch_dtype=self.dtype
+                )
+                
+                # Try SDXL first, fallback to SD 1.5
+                try:
+                    self.pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
+                        "stabilityai/stable-diffusion-xl-base-1.0",
+                        controlnet=self.controlnet,
+                        torch_dtype=self.dtype,
+                        safety_checker=None,
+                        requires_safety_checker=False
+                    )
+                    logger.info("Loaded with SDXL base model")
+                except:
+                    self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+                        "runwayml/stable-diffusion-v1-5",
+                        controlnet=self.controlnet,
+                        torch_dtype=self.dtype,
+                        safety_checker=None,
+                        requires_safety_checker=False
+                    )
+                    logger.info("Loaded with SD 1.5 base model")
+                
+                self.pipe.to(self.device)
+                
+                # Enable memory efficient attention if available
+                if hasattr(self.pipe, "enable_xformers_memory_efficient_attention"):
+                    try:
+                        self.pipe.enable_xformers_memory_efficient_attention()
+                        logger.info("XFormers memory efficient attention enabled")
+                    except Exception as e:
+                        logger.warning("Could not enable XFormers: %s", str(e))
+                
+                logger.info("ColorizeNet model loaded successfully as ControlNet")
+                self.model_type = "controlnet"
+                
+            except Exception as e:
+                logger.warning("Failed to load as ControlNet: %s", str(e))
+                # Fallback: try as image-to-image pipeline
+                logger.info("Trying to load as image-to-image pipeline...")
+                self.pipe = pipeline(
+                    "image-to-image",
+                    model=model_id,
+                    device=0 if self.device == "cuda" else -1,
+                    torch_dtype=self.dtype
+                )
+                logger.info("ColorizeNet model loaded using image-to-image pipeline")
+                self.model_type = "pipeline"
+                
+        except Exception as e:
+            logger.error("Failed to load ColorizeNet model: %s", str(e))
+            raise RuntimeError(f"Could not load ColorizeNet model: {str(e)}")
+    
+    def preprocess_image(self, image: Image.Image) -> Image.Image:
+        """
+        Preprocess image for colorization
+        
+        Args:
+            image: PIL Image
+            
+        Returns:
+            Preprocessed PIL Image
+        """
+        # Convert to grayscale if needed
+        if image.mode != "L":
+            # Convert to grayscale
+            image = image.convert("L")
+        
+        # Convert back to RGB (grayscale image with 3 channels)
+        image = image.convert("RGB")
+        
+        # Resize to standard size (512x512 for SD models)
+        image = image.resize((512, 512), Image.Resampling.LANCZOS)
+        
+        return image
+    
+    def colorize(self, image: Image.Image, num_inference_steps: int = 20) -> Image.Image:
+        """
+        Colorize a grayscale image
+        
+        Args:
+            image: PIL Image (grayscale or color)
+            num_inference_steps: Number of inference steps
+            
+        Returns:
+            Colorized PIL Image
+        """
+        try:
+            # Preprocess image
+            control_image = self.preprocess_image(image)
+            original_size = image.size
+            
+            # Prepare prompt for colorization
+            prompt = "colorize this black and white image, high quality, detailed, vibrant colors, natural colors"
+            negative_prompt = "black and white, grayscale, monochrome, low quality, blurry, desaturated"
+            
+            # Generate colorized image based on model type
+            if self.model_type == "controlnet":
+                # Use ControlNet pipeline
+                result = self.pipe(
+                    prompt=prompt,
+                    image=control_image,
+                    negative_prompt=negative_prompt,
+                    num_inference_steps=num_inference_steps,
+                    guidance_scale=7.5,
+                    controlnet_conditioning_scale=1.0,
+                    generator=torch.Generator(device=self.device).manual_seed(42)
+                )
+                
+                if isinstance(result, dict) and "images" in result:
+                    colorized = result["images"][0]
+                elif isinstance(result, list) and len(result) > 0:
+                    colorized = result[0]
+                else:
+                    colorized = result
+            else:
+                # Use pipeline directly
+                result = self.pipe(
+                    control_image,
+                    prompt=prompt,
+                    num_inference_steps=num_inference_steps
+                )
+                
+                if isinstance(result, dict) and "images" in result:
+                    colorized = result["images"][0]
+                elif isinstance(result, list) and len(result) > 0:
+                    colorized = result[0]
+                else:
+                    colorized = result
+            
+            # Ensure we have a PIL Image
+            if not isinstance(colorized, Image.Image):
+                if isinstance(colorized, np.ndarray):
+                    # Handle numpy array
+                    if colorized.dtype != np.uint8:
+                        colorized = (colorized * 255).astype(np.uint8)
+                    if len(colorized.shape) == 3 and colorized.shape[2] == 3:
+                        colorized = Image.fromarray(colorized, 'RGB')
+                    else:
+                        colorized = Image.fromarray(colorized)
+                elif torch.is_tensor(colorized):
+                    # Handle torch tensor
+                    colorized = colorized.cpu().permute(1, 2, 0).numpy()
+                    colorized = (colorized * 255).astype(np.uint8)
+                    colorized = Image.fromarray(colorized, 'RGB')
+                else:
+                    raise ValueError(f"Unexpected output type: {type(colorized)}")
+            
+            # Resize back to original size
+            if original_size != (512, 512):
+                colorized = colorized.resize(original_size, Image.Resampling.LANCZOS)
+            
+            return colorized
+            
+        except Exception as e:
+            logger.error("Error during colorization: %s", str(e))
+            raise
+

.history/app/config_20251111094005.py

@@ -0,0 +1,33 @@
+"""
+Configuration settings for the application
+"""
+import os
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    """Application settings"""
+    
+    # Firebase settings
+    ENABLE_APP_CHECK: bool = os.getenv("ENABLE_APP_CHECK", "true").lower() == "true"
+    FIREBASE_CREDENTIALS_PATH: str = os.getenv(
+        "FIREBASE_CREDENTIALS_PATH",
+        "colorize-662df-firebase-adminsdk-fbsvc-e080668793.json"
+    )
+    
+    # API settings
+    BASE_URL: str = os.getenv("BASE_URL", "http://localhost:8000")
+    
+    # Model settings
+    MODEL_ID: str = os.getenv("MODEL_ID", "rsortino/ColorizeNet")
+    NUM_INFERENCE_STEPS: int = int(os.getenv("NUM_INFERENCE_STEPS", "20"))
+    
+    # Storage settings
+    UPLOAD_DIR: str = os.getenv("UPLOAD_DIR", "uploads")
+    RESULT_DIR: str = os.getenv("RESULT_DIR", "results")
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+
+settings = Settings()
+

.history/app/main_20251111093950.py

@@ -0,0 +1,265 @@
+"""
+FastAPI application for image colorization using ColorizeNet model
+with Firebase App Check integration
+"""
+import os
+import uuid
+import logging
+from pathlib import Path
+from typing import Optional
+from fastapi import FastAPI, File, UploadFile, HTTPException, Depends, Request
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import firebase_admin
+from firebase_admin import credentials, app_check
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+import io
+
+from app.colorize_model import ColorizeModel
+from app.config import settings
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Colorize API",
+    description="Image colorization API using ColorizeNet model",
+    version="1.0.0"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize Firebase Admin SDK
+firebase_cred_path = os.getenv("FIREBASE_CREDENTIALS_PATH", "colorize-662df-firebase-adminsdk-fbsvc-e080668793.json")
+if os.path.exists(firebase_cred_path):
+    cred = credentials.Certificate(firebase_cred_path)
+    firebase_admin.initialize_app(cred)
+    logger.info("Firebase Admin SDK initialized")
+else:
+    logger.warning("Firebase credentials file not found. App Check will be disabled.")
+    firebase_admin.initialize_app()
+
+# Create directories
+UPLOAD_DIR = Path("uploads")
+RESULT_DIR = Path("results")
+UPLOAD_DIR.mkdir(exist_ok=True)
+RESULT_DIR.mkdir(exist_ok=True)
+
+# Mount static files for serving results
+app.mount("/results", StaticFiles(directory="results"), name="results")
+
+# Initialize ColorizeNet model
+colorize_model = None
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the colorization model on startup"""
+    global colorize_model
+    try:
+        logger.info("Loading ColorizeNet model...")
+        colorize_model = ColorizeModel()
+        logger.info("ColorizeNet model loaded successfully")
+    except Exception as e:
+        logger.error("Failed to load ColorizeNet model: %s", str(e))
+        raise
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    global colorize_model
+    if colorize_model:
+        del colorize_model
+    logger.info("Application shutdown")
+
+# Firebase App Check verification
+async def verify_app_check(request: Request):
+    """Verify Firebase App Check token"""
+    if not settings.ENABLE_APP_CHECK:
+        return True
+    
+    app_check_token = request.headers.get("X-Firebase-AppCheck")
+    if not app_check_token:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing App Check token"
+        )
+    
+    try:
+        # Verify the App Check token
+        app_check_claims = app_check.verify_token(app_check_token)
+        logger.info("App Check token verified for: %s", app_check_claims.get("app_id"))
+        return True
+    except Exception as e:
+        logger.warning("App Check token verification failed: %s", str(e))
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid App Check token"
+        )
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "model_loaded": colorize_model is not None
+    }
+
+@app.post("/upload")
+async def upload_image(
+    file: UploadFile = File(...),
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Upload an image and return the uploaded image URL
+    """
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File must be an image")
+    
+    # Generate unique filename
+    file_id = str(uuid.uuid4())
+    file_extension = Path(file.filename).suffix or ".jpg"
+    filename = f"{file_id}{file_extension}"
+    filepath = UPLOAD_DIR / filename
+    
+    # Save uploaded file
+    try:
+        contents = await file.read()
+        with open(filepath, "wb") as f:
+            f.write(contents)
+        logger.info("Image uploaded: %s", filename)
+        
+        # Return the URL to access the uploaded image
+        base_url = os.getenv("BASE_URL", "http://localhost:8000")
+        image_url = f"{base_url}/uploads/{filename}"
+        
+        return {
+            "success": True,
+            "image_id": file_id,
+            "image_url": image_url,
+            "filename": filename
+        }
+    except Exception as e:
+        logger.error("Error uploading image: %s", str(e))
+        raise HTTPException(status_code=500, detail=f"Error uploading image: {str(e)}")
+
+@app.post("/colorize")
+async def colorize_image(
+    file: UploadFile = File(...),
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Colorize an uploaded grayscale image using ColorizeNet
+    Returns the colorized image URL
+    """
+    if colorize_model is None:
+        raise HTTPException(status_code=503, detail="Colorization model not loaded")
+    
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File must be an image")
+    
+    try:
+        # Read image
+        contents = await file.read()
+        image = Image.open(io.BytesIO(contents))
+        
+        # Convert to RGB if needed
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        
+        # Colorize the image
+        logger.info("Colorizing image...")
+        colorized_image = colorize_model.colorize(image)
+        
+        # Save colorized image
+        file_id = str(uuid.uuid4())
+        result_filename = f"{file_id}.jpg"
+        result_filepath = RESULT_DIR / result_filename
+        
+        colorized_image.save(result_filepath, "JPEG", quality=95)
+        logger.info("Colorized image saved: %s", result_filename)
+        
+        # Return URLs
+        base_url = os.getenv("BASE_URL", "http://localhost:8000")
+        download_url = f"{base_url}/results/{result_filename}"
+        api_download_url = f"{base_url}/download/{file_id}"
+        
+        return {
+            "success": True,
+            "result_id": file_id,
+            "download_url": download_url,
+            "api_download_url": api_download_url,
+            "filename": result_filename
+        }
+    except Exception as e:
+        logger.error("Error colorizing image: %s", str(e))
+        raise HTTPException(status_code=500, detail=f"Error colorizing image: {str(e)}")
+
+@app.get("/download/{file_id}")
+async def download_result(
+    file_id: str,
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Download the colorized image by file ID
+    """
+    result_filepath = RESULT_DIR / f"{file_id}.jpg"
+    
+    if not result_filepath.exists():
+        raise HTTPException(status_code=404, detail="Result not found")
+    
+    return FileResponse(
+        result_filepath,
+        media_type="image/jpeg",
+        filename=f"colorized_{file_id}.jpg"
+    )
+
+@app.get("/results/{filename}")
+async def get_result_file(filename: str):
+    """
+    Serve result files directly (public endpoint for browser access)
+    """
+    result_filepath = RESULT_DIR / filename
+    
+    if not result_filepath.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    return FileResponse(
+        result_filepath,
+        media_type="image/jpeg"
+    )
+
+@app.get("/uploads/{filename}")
+async def get_upload_file(filename: str):
+    """
+    Serve uploaded files directly
+    """
+    upload_filepath = UPLOAD_DIR / filename
+    
+    if not upload_filepath.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    return FileResponse(
+        upload_filepath,
+        media_type="image/jpeg"
+    )
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+

.history/app/main_20251111094327.py

@@ -0,0 +1,273 @@
+"""
+FastAPI application for image colorization using ColorizeNet model
+with Firebase App Check integration
+"""
+import os
+import uuid
+import logging
+from pathlib import Path
+from typing import Optional
+from fastapi import FastAPI, File, UploadFile, HTTPException, Depends, Request
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import firebase_admin
+from firebase_admin import credentials, app_check
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+import io
+
+from app.colorize_model import ColorizeModel
+from app.config import settings
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Colorize API",
+    description="Image colorization API using ColorizeNet model",
+    version="1.0.0"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize Firebase Admin SDK
+firebase_cred_path = os.getenv("FIREBASE_CREDENTIALS_PATH", "colorize-662df-firebase-adminsdk-fbsvc-e080668793.json")
+if os.path.exists(firebase_cred_path):
+    try:
+        cred = credentials.Certificate(firebase_cred_path)
+        firebase_admin.initialize_app(cred)
+        logger.info("Firebase Admin SDK initialized")
+    except Exception as e:
+        logger.warning("Failed to initialize Firebase: %s", str(e))
+        firebase_admin.initialize_app()
+else:
+    logger.warning("Firebase credentials file not found. App Check will be disabled.")
+    try:
+        firebase_admin.initialize_app()
+    except:
+        pass
+
+# Create directories
+UPLOAD_DIR = Path("uploads")
+RESULT_DIR = Path("results")
+UPLOAD_DIR.mkdir(exist_ok=True)
+RESULT_DIR.mkdir(exist_ok=True)
+
+# Mount static files for serving results
+app.mount("/results", StaticFiles(directory="results"), name="results")
+app.mount("/uploads", StaticFiles(directory="uploads"), name="uploads")
+
+# Initialize ColorizeNet model
+colorize_model = None
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the colorization model on startup"""
+    global colorize_model
+    try:
+        logger.info("Loading ColorizeNet model...")
+        colorize_model = ColorizeModel()
+        logger.info("ColorizeNet model loaded successfully")
+    except Exception as e:
+        logger.error("Failed to load ColorizeNet model: %s", str(e))
+        # Don't raise - allow health check to work even if model fails
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    global colorize_model
+    if colorize_model:
+        del colorize_model
+    logger.info("Application shutdown")
+
+# Firebase App Check verification
+async def verify_app_check(request: Request):
+    """Verify Firebase App Check token"""
+    if not settings.ENABLE_APP_CHECK:
+        return True
+    
+    app_check_token = request.headers.get("X-Firebase-AppCheck")
+    if not app_check_token:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing App Check token"
+        )
+    
+    try:
+        # Verify the App Check token
+        app_check_claims = app_check.verify_token(app_check_token)
+        logger.info("App Check token verified for: %s", app_check_claims.get("app_id"))
+        return True
+    except Exception as e:
+        logger.warning("App Check token verification failed: %s", str(e))
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid App Check token"
+        )
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "model_loaded": colorize_model is not None
+    }
+
+@app.post("/upload")
+async def upload_image(
+    file: UploadFile = File(...),
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Upload an image and return the uploaded image URL
+    """
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File must be an image")
+    
+    # Generate unique filename
+    file_id = str(uuid.uuid4())
+    file_extension = Path(file.filename).suffix or ".jpg"
+    filename = f"{file_id}{file_extension}"
+    filepath = UPLOAD_DIR / filename
+    
+    # Save uploaded file
+    try:
+        contents = await file.read()
+        with open(filepath, "wb") as f:
+            f.write(contents)
+        logger.info("Image uploaded: %s", filename)
+        
+        # Return the URL to access the uploaded image
+        base_url = os.getenv("BASE_URL", os.getenv("SPACE_HOST", "http://localhost:7860"))
+        image_url = f"{base_url}/uploads/{filename}"
+        
+        return {
+            "success": True,
+            "image_id": file_id,
+            "image_url": image_url,
+            "filename": filename
+        }
+    except Exception as e:
+        logger.error("Error uploading image: %s", str(e))
+        raise HTTPException(status_code=500, detail=f"Error uploading image: {str(e)}")
+
+@app.post("/colorize")
+async def colorize_image(
+    file: UploadFile = File(...),
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Colorize an uploaded grayscale image using ColorizeNet
+    Returns the colorized image URL
+    """
+    if colorize_model is None:
+        raise HTTPException(status_code=503, detail="Colorization model not loaded")
+    
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File must be an image")
+    
+    try:
+        # Read image
+        contents = await file.read()
+        image = Image.open(io.BytesIO(contents))
+        
+        # Convert to RGB if needed
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        
+        # Colorize the image
+        logger.info("Colorizing image...")
+        colorized_image = colorize_model.colorize(image)
+        
+        # Save colorized image
+        file_id = str(uuid.uuid4())
+        result_filename = f"{file_id}.jpg"
+        result_filepath = RESULT_DIR / result_filename
+        
+        colorized_image.save(result_filepath, "JPEG", quality=95)
+        logger.info("Colorized image saved: %s", result_filename)
+        
+        # Return URLs
+        base_url = os.getenv("BASE_URL", os.getenv("SPACE_HOST", "http://localhost:7860"))
+        download_url = f"{base_url}/results/{result_filename}"
+        api_download_url = f"{base_url}/download/{file_id}"
+        
+        return {
+            "success": True,
+            "result_id": file_id,
+            "download_url": download_url,
+            "api_download_url": api_download_url,
+            "filename": result_filename
+        }
+    except Exception as e:
+        logger.error("Error colorizing image: %s", str(e))
+        raise HTTPException(status_code=500, detail=f"Error colorizing image: {str(e)}")
+
+@app.get("/download/{file_id}")
+async def download_result(
+    file_id: str,
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Download the colorized image by file ID
+    """
+    result_filepath = RESULT_DIR / f"{file_id}.jpg"
+    
+    if not result_filepath.exists():
+        raise HTTPException(status_code=404, detail="Result not found")
+    
+    return FileResponse(
+        result_filepath,
+        media_type="image/jpeg",
+        filename=f"colorized_{file_id}.jpg"
+    )
+
+@app.get("/results/{filename}")
+async def get_result_file(filename: str):
+    """
+    Serve result files directly (public endpoint for browser access)
+    """
+    result_filepath = RESULT_DIR / filename
+    
+    if not result_filepath.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    return FileResponse(
+        result_filepath,
+        media_type="image/jpeg"
+    )
+
+@app.get("/uploads/{filename}")
+async def get_upload_file(filename: str):
+    """
+    Serve uploaded files directly
+    """
+    upload_filepath = UPLOAD_DIR / filename
+    
+    if not upload_filepath.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    return FileResponse(
+        upload_filepath,
+        media_type="image/jpeg"
+    )
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", "7860"))
+    uvicorn.run(app, host="0.0.0.0", port=port)

.history/app/main_20251111094522.py

@@ -0,0 +1,273 @@
+"""
+FastAPI application for image colorization using ColorizeNet model
+with Firebase App Check integration
+"""
+import os
+import uuid
+import logging
+from pathlib import Path
+from typing import Optional
+from fastapi import FastAPI, File, UploadFile, HTTPException, Depends, Request
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import firebase_admin
+from firebase_admin import credentials, app_check
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+import io
+
+from app.colorize_model import ColorizeModel
+from app.config import settings
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Colorize API",
+    description="Image colorization API using ColorizeNet model",
+    version="1.0.0"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize Firebase Admin SDK
+firebase_cred_path = os.getenv("FIREBASE_CREDENTIALS_PATH", "colorize-662df-firebase-adminsdk-fbsvc-e080668793.json")
+if os.path.exists(firebase_cred_path):
+    try:
+        cred = credentials.Certificate(firebase_cred_path)
+        firebase_admin.initialize_app(cred)
+        logger.info("Firebase Admin SDK initialized")
+    except Exception as e:
+        logger.warning("Failed to initialize Firebase: %s", str(e))
+        firebase_admin.initialize_app()
+else:
+    logger.warning("Firebase credentials file not found. App Check will be disabled.")
+    try:
+        firebase_admin.initialize_app()
+    except:
+        pass
+
+# Create directories
+UPLOAD_DIR = Path("uploads")
+RESULT_DIR = Path("results")
+UPLOAD_DIR.mkdir(exist_ok=True)
+RESULT_DIR.mkdir(exist_ok=True)
+
+# Mount static files for serving results
+app.mount("/results", StaticFiles(directory="results"), name="results")
+app.mount("/uploads", StaticFiles(directory="uploads"), name="uploads")
+
+# Initialize ColorizeNet model
+colorize_model = None
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the colorization model on startup"""
+    global colorize_model
+    try:
+        logger.info("Loading ColorizeNet model...")
+        colorize_model = ColorizeModel()
+        logger.info("ColorizeNet model loaded successfully")
+    except Exception as e:
+        logger.error("Failed to load ColorizeNet model: %s", str(e))
+        # Don't raise - allow health check to work even if model fails
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    global colorize_model
+    if colorize_model:
+        del colorize_model
+    logger.info("Application shutdown")
+
+# Firebase App Check verification
+async def verify_app_check(request: Request):
+    """Verify Firebase App Check token"""
+    if not settings.ENABLE_APP_CHECK:
+        return True
+    
+    app_check_token = request.headers.get("X-Firebase-AppCheck")
+    if not app_check_token:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing App Check token"
+        )
+    
+    try:
+        # Verify the App Check token
+        app_check_claims = app_check.verify_token(app_check_token)
+        logger.info("App Check token verified for: %s", app_check_claims.get("app_id"))
+        return True
+    except Exception as e:
+        logger.warning("App Check token verification failed: %s", str(e))
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid App Check token"
+        )
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "model_loaded": colorize_model is not None
+    }
+
+@app.post("/upload")
+async def upload_image(
+    file: UploadFile = File(...),
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Upload an image and return the uploaded image URL
+    """
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File must be an image")
+    
+    # Generate unique filename
+    file_id = str(uuid.uuid4())
+    file_extension = Path(file.filename).suffix or ".jpg"
+    filename = f"{file_id}{file_extension}"
+    filepath = UPLOAD_DIR / filename
+    
+    # Save uploaded file
+    try:
+        contents = await file.read()
+        with open(filepath, "wb") as f:
+            f.write(contents)
+        logger.info("Image uploaded: %s", filename)
+        
+        # Return the URL to access the uploaded image
+        base_url = os.getenv("BASE_URL", os.getenv("SPACE_HOST", "http://localhost:7860"))
+        image_url = f"{base_url}/uploads/{filename}"
+        
+        return {
+            "success": True,
+            "image_id": file_id,
+            "image_url": image_url,
+            "filename": filename
+        }
+    except Exception as e:
+        logger.error("Error uploading image: %s", str(e))
+        raise HTTPException(status_code=500, detail=f"Error uploading image: {str(e)}")
+
+@app.post("/colorize")
+async def colorize_image(
+    file: UploadFile = File(...),
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Colorize an uploaded grayscale image using ColorizeNet
+    Returns the colorized image URL
+    """
+    if colorize_model is None:
+        raise HTTPException(status_code=503, detail="Colorization model not loaded")
+    
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File must be an image")
+    
+    try:
+        # Read image
+        contents = await file.read()
+        image = Image.open(io.BytesIO(contents))
+        
+        # Convert to RGB if needed
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        
+        # Colorize the image
+        logger.info("Colorizing image...")
+        colorized_image = colorize_model.colorize(image)
+        
+        # Save colorized image
+        file_id = str(uuid.uuid4())
+        result_filename = f"{file_id}.jpg"
+        result_filepath = RESULT_DIR / result_filename
+        
+        colorized_image.save(result_filepath, "JPEG", quality=95)
+        logger.info("Colorized image saved: %s", result_filename)
+        
+        # Return URLs
+        base_url = os.getenv("BASE_URL", os.getenv("SPACE_HOST", "http://localhost:7860"))
+        download_url = f"{base_url}/results/{result_filename}"
+        api_download_url = f"{base_url}/download/{file_id}"
+        
+        return {
+            "success": True,
+            "result_id": file_id,
+            "download_url": download_url,
+            "api_download_url": api_download_url,
+            "filename": result_filename
+        }
+    except Exception as e:
+        logger.error("Error colorizing image: %s", str(e))
+        raise HTTPException(status_code=500, detail=f"Error colorizing image: {str(e)}")
+
+@app.get("/download/{file_id}")
+async def download_result(
+    file_id: str,
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Download the colorized image by file ID
+    """
+    result_filepath = RESULT_DIR / f"{file_id}.jpg"
+    
+    if not result_filepath.exists():
+        raise HTTPException(status_code=404, detail="Result not found")
+    
+    return FileResponse(
+        result_filepath,
+        media_type="image/jpeg",
+        filename=f"colorized_{file_id}.jpg"
+    )
+
+@app.get("/results/{filename}")
+async def get_result_file(filename: str):
+    """
+    Serve result files directly (public endpoint for browser access)
+    """
+    result_filepath = RESULT_DIR / filename
+    
+    if not result_filepath.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    return FileResponse(
+        result_filepath,
+        media_type="image/jpeg"
+    )
+
+@app.get("/uploads/{filename}")
+async def get_upload_file(filename: str):
+    """
+    Serve uploaded files directly
+    """
+    upload_filepath = UPLOAD_DIR / filename
+    
+    if not upload_filepath.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    return FileResponse(
+        upload_filepath,
+        media_type="image/jpeg"
+    )
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", "7860"))
+    uvicorn.run(app, host="0.0.0.0", port=port)

.history/deploy_20251111094342.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+# Deployment script for Hugging Face Spaces
+
+echo "Deploying to Hugging Face Space..."
+
+# Initialize git if not already
+if [ ! -d ".git" ]; then
+    git init
+fi
+
+# Add all files
+git add .
+
+# Commit changes
+git commit -m "Deploy Colorize API with Firebase App Check"
+
+# Add Hugging Face remote (replace with your space URL)
+git remote add origin https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize || git remote set-url origin https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+
+# Push to Hugging Face
+git push -u origin main
+
+echo "Deployment complete!"
+

.history/requirements_20251111094007.txt

@@ -0,0 +1,17 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+pillow==10.1.0
+torch==2.1.0
+torchvision==0.16.0
+transformers==4.35.0
+diffusers==0.24.0
+accelerate==0.25.0
+opencv-python==4.8.1.78
+numpy==1.24.3
+firebase-admin==6.2.0
+pydantic-settings==2.1.0
+huggingface-hub==0.19.4
+safetensors==0.4.2
+xformers==0.0.23.post1; sys_platform != "darwin"
+

.history/requirements_20251111094419.txt

@@ -0,0 +1,16 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+pillow==10.1.0
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.30.0
+diffusers>=0.21.0
+accelerate>=0.20.0
+opencv-python-headless==4.8.1.78
+numpy>=1.24.0
+firebase-admin>=6.0.0
+pydantic-settings>=2.0.0
+huggingface-hub>=0.16.0
+safetensors>=0.3.0
+

.history/requirements_20251111094503.txt

@@ -0,0 +1,17 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+requests>=2.31.0
+pillow==10.1.0
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.30.0
+diffusers>=0.21.0
+accelerate>=0.20.0
+opencv-python-headless==4.8.1.78
+numpy>=1.24.0
+firebase-admin>=6.0.0
+pydantic-settings>=2.0.0
+huggingface-hub>=0.16.0
+safetensors>=0.3.0
+

.history/requirements_20251111094522.txt

@@ -0,0 +1,17 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+requests>=2.31.0
+pillow==10.1.0
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.30.0
+diffusers>=0.21.0
+accelerate>=0.20.0
+opencv-python-headless==4.8.1.78
+numpy>=1.24.0
+firebase-admin>=6.0.0
+pydantic-settings>=2.0.0
+huggingface-hub>=0.16.0
+safetensors>=0.3.0
+

DEPLOYMENT.md

@@ -0,0 +1,143 @@
+# Deployment Guide
+
+## Quick Start
+
+### 1. Copy Firebase Credentials
+
+Copy your Firebase Admin SDK JSON file to the project root:
+```bash
+# Windows
+copy C:\Colorize\colorize-662df-firebase-adminsdk-fbsvc-e080668793.json .
+
+# Linux/Mac
+cp /path/to/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json .
+```
+
+**Important**: For Hugging Face Spaces, you should add this as a secret instead of committing it to the repository.
+
+### 2. Deploy to Hugging Face Spaces
+
+```bash
+# Initialize git repository
+git init
+git add .
+git commit -m "Deploy Colorize API"
+
+# Add Hugging Face remote
+git remote add origin https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+
+# Push to Hugging Face
+git push -u origin main
+```
+
+### 3. Configure Hugging Face Space Secrets
+
+1. Go to your Space: https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+2. Navigate to Settings → Secrets
+3. Add a new secret:
+   - **Name**: `FIREBASE_CREDENTIALS`
+   - **Value**: Paste the entire contents of your Firebase Admin SDK JSON file
+
+### 4. Update Dockerfile for Secrets (Optional)
+
+If you want to use the secret, you can modify the Dockerfile to create the file from the secret:
+
+```dockerfile
+# Add this before the CMD line
+RUN if [ -n "$FIREBASE_CREDENTIALS" ]; then \
+    echo "$FIREBASE_CREDENTIALS" > colorize-662df-firebase-adminsdk-fbsvc-e080668793.json; \
+    fi
+```
+
+## Testing Locally
+
+### Run with Docker
+
+```bash
+# Build image
+docker build -t colorize-api .
+
+# Run container
+docker run -p 7860:7860 \
+  -v $(pwd)/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json:/app/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json \
+  colorize-api
+```
+
+### Run without Docker
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run API
+uvicorn app.main:app --host 0.0.0.0 --port 7860
+```
+
+## API Endpoints
+
+Once deployed, your API will be available at:
+- `https://logicgoinfotechspaces-colorize.hf.space/health` - Health check
+- `https://logicgoinfotechspaces-colorize.hf.space/colorize` - Colorize image
+- `https://logicgoinfotechspaces-colorize.hf.space/upload` - Upload image
+
+## Frontend Integration Example
+
+```javascript
+// Initialize Firebase
+import { initializeApp } from "firebase/app";
+import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
+
+const firebaseConfig = {
+  apiKey: "AIzaSyBIB6rcfyyqy5niERTXWvVD714Ter4Vx68",
+  authDomain: "colorize-662df.firebaseapp.com",
+  projectId: "colorize-662df",
+  storageBucket: "colorize-662df.firebasestorage.app",
+  messagingSenderId: "69166278311",
+  appId: "1:69166278311:web:0e8c50b8dd8627aaeadd82",
+  measurementId: "G-58CC2J8XKX"
+};
+
+const app = initializeApp(firebaseConfig);
+const appCheck = initializeAppCheck(app, {
+  provider: new ReCaptchaEnterpriseProvider('YOUR_RECAPTCHA_SITE_KEY'),
+  isTokenAutoRefreshEnabled: true
+});
+
+// Colorize image function
+async function colorizeImage(file) {
+  const { getToken } = await import('firebase/app-check');
+  const token = await getToken(appCheck);
+  
+  const formData = new FormData();
+  formData.append('file', file);
+  
+  const response = await fetch('https://logicgoinfotechspaces-colorize.hf.space/colorize', {
+    method: 'POST',
+    headers: {
+      'X-Firebase-AppCheck': token.token
+    },
+    body: formData
+  });
+  
+  return await response.json();
+}
+```
+
+## Troubleshooting
+
+### Model Not Loading
+
+- Check Hugging Face Space logs
+- Verify model ID: `rsortino/ColorizeNet`
+- Ensure sufficient disk space (models can be large)
+
+### Firebase App Check Failing
+
+- Verify credentials are correctly set as a secret
+- Check that App Check is enabled in Firebase Console
+- Ensure reCAPTCHA Enterprise is set up
+
+### Port Issues
+
+Hugging Face Spaces automatically handles port 7860. The Dockerfile is configured for this.
+

Dockerfile

@@ -0,0 +1,49 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create directories for uploads and results
+RUN mkdir -p uploads results
+
+# Handle Firebase credentials from environment variable (for Hugging Face Spaces secrets)
+# This allows the credentials to be passed as a secret and written to file at runtime
+RUN echo '#!/bin/bash\nif [ -n "$FIREBASE_CREDENTIALS" ]; then echo "$FIREBASE_CREDENTIALS" > colorize-662df-firebase-adminsdk-fbsvc-e080668793.json; fi\nexec "$@"' > /entrypoint.sh && chmod +x /entrypoint.sh
+
+# Expose port (Hugging Face Spaces uses port 7860)
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV BASE_URL=${SPACE_HOST}
+ENV PORT=7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health', timeout=5)" || exit 1
+
+# Set entrypoint
+ENTRYPOINT ["/entrypoint.sh"]
+
+# Run the application (port will be set via environment variable)
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}"]

README.md

@@ -0,0 +1,114 @@
+---
+title: Colorize Image API
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
+sdk: docker
+sdk_version: 1.0.0
+app_file: Dockerfile
+pinned: false
+license: mit
+---
+
+# Colorize Image API
+
+FastAPI-based image colorization service using ColorizeNet model with Firebase App Check integration.
+
+## Features
+
+- 🖼️ Image upload and colorization
+- 🔒 Firebase App Check authentication
+- 🐳 Docker deployment
+- 📥 Download URLs for browser access
+
+## API Endpoints
+
+### Health Check
+```
+GET /health
+```
+Returns the health status of the API and model.
+
+### Upload Image
+```
+POST /upload
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Uploads an image and returns the image URL.
+
+### Colorize Image
+```
+POST /colorize
+Headers: X-Firebase-AppCheck: <token>
+Body: multipart/form-data with image file
+```
+Colorizes a grayscale image and returns the result URL.
+
+### Download Result
+```
+GET /download/{file_id}
+Headers: X-Firebase-AppCheck: <token>
+```
+Downloads the colorized image by file ID.
+
+### Get Result (Public)
+```
+GET /results/{filename}
+```
+Public endpoint to access colorized images in browser.
+
+## Setup
+
+### Environment Variables
+
+Set these in your Hugging Face Space secrets:
+
+- `FIREBASE_CREDENTIALS_PATH`: Path to Firebase credentials JSON file (or set as secret)
+- `ENABLE_APP_CHECK`: Enable/disable Firebase App Check (default: true)
+- `MODEL_ID`: Hugging Face model ID (default: rsortino/ColorizeNet)
+- `NUM_INFERENCE_STEPS`: Number of inference steps (default: 20)
+
+### Firebase App Check Setup
+
+1. Initialize Firebase App Check in your frontend:
+```javascript
+import { initializeApp } from "firebase/app";
+import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
+
+const firebaseConfig = {
+  apiKey: "AIzaSyBIB6rcfyyqy5niERTXWvVD714Ter4Vx68",
+  authDomain: "colorize-662df.firebaseapp.com",
+  projectId: "colorize-662df",
+  storageBucket: "colorize-662df.firebasestorage.app",
+  messagingSenderId: "69166278311",
+  appId: "1:69166278311:web:0e8c50b8dd8627aaeadd82",
+  measurementId: "G-58CC2J8XKX"
+};
+
+const app = initializeApp(firebaseConfig);
+const appCheck = initializeAppCheck(app, {
+  provider: new ReCaptchaEnterpriseProvider('your-recaptcha-site-key'),
+  isTokenAutoRefreshEnabled: true
+});
+```
+
+2. Include the token in API requests:
+```javascript
+const token = await appCheck.getToken();
+fetch('https://your-space.hf.space/colorize', {
+  method: 'POST',
+  headers: {
+    'X-Firebase-AppCheck': token.token
+  },
+  body: formData
+});
+```
+
+## Model
+
+This API uses the `rsortino/ColorizeNet` model from Hugging Face for image colorization.
+
+## License
+
+MIT

README_HF.md

@@ -0,0 +1,40 @@
+---
+title: Colorize Image API
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
+sdk: docker
+sdk_version: 1.0.0
+app_file: Dockerfile
+pinned: false
+license: mit
+---
+
+# Colorize Image API
+
+FastAPI-based image colorization service using ColorizeNet model with Firebase App Check integration.
+
+## Features
+
+- Image upload and colorization
+- Firebase App Check authentication
+- Docker deployment
+- Download URLs for browser access
+
+## API Endpoints
+
+- `GET /health` - Health check
+- `POST /upload` - Upload image
+- `POST /colorize` - Colorize image
+- `GET /download/{file_id}` - Download result
+- `GET /results/{filename}` - Public result access
+
+## Setup
+
+The API requires Firebase credentials. Place your Firebase Admin SDK JSON file in the root directory as:
+`colorize-662df-firebase-adminsdk-fbsvc-e080668793.json`
+
+## Model
+
+Uses `rsortino/ColorizeNet` from Hugging Face for image colorization.
+

SETUP.md

@@ -0,0 +1,193 @@
+# Setup Guide for Colorize API
+
+## Prerequisites
+
+1. Python 3.10+
+2. Docker (for containerized deployment)
+3. Firebase Admin SDK credentials file
+4. Hugging Face account with access to the Colorize Space
+
+## Local Development Setup
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Firebase Credentials
+
+Copy your Firebase Admin SDK JSON file to the project root:
+- Source: `C:\Colorize\colorize-662df-firebase-adminsdk-fbsvc-e080668793.json`
+- Destination: `colorize-662df-firebase-adminsdk-fbsvc-e080668793.json`
+
+Or set the path in environment variable:
+```bash
+export FIREBASE_CREDENTIALS_PATH=/path/to/your/firebase-credentials.json
+```
+
+### 3. Run the API
+
+```bash
+uvicorn app.main:app --reload --port 7860
+```
+
+The API will be available at `http://localhost:7860`
+
+## Docker Setup
+
+### 1. Build the Docker Image
+
+```bash
+docker build -t colorize-api .
+```
+
+### 2. Run the Container
+
+```bash
+docker run -p 7860:7860 \
+  -v $(pwd)/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json:/app/colorize-662df-firebase-adminsdk-fbsvc-e080668793.json \
+  -e BASE_URL=http://localhost:7860 \
+  colorize-api
+```
+
+## Hugging Face Spaces Deployment
+
+### 1. Prepare Your Repository
+
+```bash
+# Initialize git repository
+git init
+git add .
+git commit -m "Initial commit: Colorize API with Firebase App Check"
+```
+
+### 2. Set Up Hugging Face Space
+
+1. Go to https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+2. If the space doesn't exist, create a new Docker space
+
+### 3. Add Firebase Credentials as Secret
+
+In Hugging Face Space settings:
+1. Go to Settings → Secrets
+2. Add a new secret:
+   - Name: `FIREBASE_CREDENTIALS`
+   - Value: Contents of your Firebase Admin SDK JSON file
+
+### 4. Update Dockerfile for Secrets (if needed)
+
+The Dockerfile will automatically use the credentials file if it exists. For Hugging Face Spaces, you may need to create the file from secrets:
+
+```dockerfile
+# Add this to Dockerfile if using HF secrets
+RUN echo "$FIREBASE_CREDENTIALS" > colorize-662df-firebase-adminsdk-fbsvc-e080668793.json || true
+```
+
+### 5. Push to Hugging Face
+
+```bash
+git remote add origin https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+git push -u origin main
+```
+
+## Testing the API
+
+### Health Check
+
+```bash
+curl http://localhost:7860/health
+```
+
+### Upload Image (with App Check token)
+
+```bash
+curl -X POST http://localhost:7860/upload \
+  -H "X-Firebase-AppCheck: YOUR_APP_CHECK_TOKEN" \
+  -F "file=@path/to/image.jpg"
+```
+
+### Colorize Image (with App Check token)
+
+```bash
+curl -X POST http://localhost:7860/colorize \
+  -H "X-Firebase-AppCheck: YOUR_APP_CHECK_TOKEN" \
+  -F "file=@path/to/grayscale_image.jpg"
+```
+
+## Frontend Integration
+
+### Initialize Firebase App Check
+
+```javascript
+import { initializeApp } from "firebase/app";
+import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
+
+const firebaseConfig = {
+  apiKey: "AIzaSyBIB6rcfyyqy5niERTXWvVD714Ter4Vx68",
+  authDomain: "colorize-662df.firebaseapp.com",
+  projectId: "colorize-662df",
+  storageBucket: "colorize-662df.firebasestorage.app",
+  messagingSenderId: "69166278311",
+  appId: "1:69166278311:web:0e8c50b8dd8627aaeadd82",
+  measurementId: "G-58CC2J8XKX"
+};
+
+const app = initializeApp(firebaseConfig);
+
+// Initialize App Check
+const appCheck = initializeAppCheck(app, {
+  provider: new ReCaptchaEnterpriseProvider('YOUR_RECAPTCHA_SITE_KEY'),
+  isTokenAutoRefreshEnabled: true
+});
+
+// Get token and make API call
+async function colorizeImage(imageFile) {
+  const token = await appCheck.getToken();
+  
+  const formData = new FormData();
+  formData.append('file', imageFile);
+  
+  const response = await fetch('https://your-space.hf.space/colorize', {
+    method: 'POST',
+    headers: {
+      'X-Firebase-AppCheck': token.token
+    },
+    body: formData
+  });
+  
+  const result = await response.json();
+  console.log('Colorized image URL:', result.download_url);
+  return result;
+}
+```
+
+## Troubleshooting
+
+### Model Loading Issues
+
+If the ColorizeNet model fails to load:
+1. Check your internet connection (model downloads from Hugging Face)
+2. Verify you have sufficient disk space
+3. Check logs for specific error messages
+
+### Firebase App Check Issues
+
+If App Check verification fails:
+1. Verify your Firebase credentials file is correct
+2. Check that App Check is enabled in Firebase Console
+3. Ensure the token is being sent in the `X-Firebase-AppCheck` header
+
+### Port Issues
+
+Hugging Face Spaces uses port 7860 by default. Make sure your Dockerfile exposes this port.
+
+## Environment Variables
+
+- `FIREBASE_CREDENTIALS_PATH`: Path to Firebase Admin SDK JSON file
+- `ENABLE_APP_CHECK`: Enable/disable Firebase App Check (true/false)
+- `BASE_URL`: Base URL for generating download URLs
+- `PORT`: Port to run the API on (default: 7860)
+- `MODEL_ID`: Hugging Face model ID (default: rsortino/ColorizeNet)
+- `NUM_INFERENCE_STEPS`: Number of inference steps (default: 20)
+

app/__init__.py

@@ -0,0 +1,2 @@
+# Colorize API Package
+

app/colorize_model.py

@@ -0,0 +1,195 @@
+"""
+ColorizeNet model wrapper for image colorization
+"""
+import logging
+import torch
+import numpy as np
+from PIL import Image
+import cv2
+from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, StableDiffusionXLControlNetPipeline
+from diffusers.utils import load_image
+from transformers import pipeline
+from huggingface_hub import hf_hub_download
+
+logger = logging.getLogger(__name__)
+
+class ColorizeModel:
+    """Wrapper for ColorizeNet model"""
+    
+    def __init__(self, model_id: str = "rsortino/ColorizeNet"):
+        """
+        Initialize the ColorizeNet model
+        
+        Args:
+            model_id: Hugging Face model ID for ColorizeNet
+        """
+        self.model_id = model_id
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info("Using device: %s", self.device)
+        self.dtype = torch.float16 if self.device == "cuda" else torch.float32
+        
+        try:
+            # Try loading as ControlNet with Stable Diffusion
+            logger.info("Attempting to load ColorizeNet as ControlNet...")
+            try:
+                # Load ControlNet model
+                self.controlnet = ControlNetModel.from_pretrained(
+                    model_id,
+                    torch_dtype=self.dtype
+                )
+                
+                # Try SDXL first, fallback to SD 1.5
+                try:
+                    self.pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
+                        "stabilityai/stable-diffusion-xl-base-1.0",
+                        controlnet=self.controlnet,
+                        torch_dtype=self.dtype,
+                        safety_checker=None,
+                        requires_safety_checker=False
+                    )
+                    logger.info("Loaded with SDXL base model")
+                except:
+                    self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+                        "runwayml/stable-diffusion-v1-5",
+                        controlnet=self.controlnet,
+                        torch_dtype=self.dtype,
+                        safety_checker=None,
+                        requires_safety_checker=False
+                    )
+                    logger.info("Loaded with SD 1.5 base model")
+                
+                self.pipe.to(self.device)
+                
+                # Enable memory efficient attention if available
+                if hasattr(self.pipe, "enable_xformers_memory_efficient_attention"):
+                    try:
+                        self.pipe.enable_xformers_memory_efficient_attention()
+                        logger.info("XFormers memory efficient attention enabled")
+                    except Exception as e:
+                        logger.warning("Could not enable XFormers: %s", str(e))
+                
+                logger.info("ColorizeNet model loaded successfully as ControlNet")
+                self.model_type = "controlnet"
+                
+            except Exception as e:
+                logger.warning("Failed to load as ControlNet: %s", str(e))
+                # Fallback: try as image-to-image pipeline
+                logger.info("Trying to load as image-to-image pipeline...")
+                self.pipe = pipeline(
+                    "image-to-image",
+                    model=model_id,
+                    device=0 if self.device == "cuda" else -1,
+                    torch_dtype=self.dtype
+                )
+                logger.info("ColorizeNet model loaded using image-to-image pipeline")
+                self.model_type = "pipeline"
+                
+        except Exception as e:
+            logger.error("Failed to load ColorizeNet model: %s", str(e))
+            raise RuntimeError(f"Could not load ColorizeNet model: {str(e)}")
+    
+    def preprocess_image(self, image: Image.Image) -> Image.Image:
+        """
+        Preprocess image for colorization
+        
+        Args:
+            image: PIL Image
+            
+        Returns:
+            Preprocessed PIL Image
+        """
+        # Convert to grayscale if needed
+        if image.mode != "L":
+            # Convert to grayscale
+            image = image.convert("L")
+        
+        # Convert back to RGB (grayscale image with 3 channels)
+        image = image.convert("RGB")
+        
+        # Resize to standard size (512x512 for SD models)
+        image = image.resize((512, 512), Image.Resampling.LANCZOS)
+        
+        return image
+    
+    def colorize(self, image: Image.Image, num_inference_steps: int = 20) -> Image.Image:
+        """
+        Colorize a grayscale image
+        
+        Args:
+            image: PIL Image (grayscale or color)
+            num_inference_steps: Number of inference steps
+            
+        Returns:
+            Colorized PIL Image
+        """
+        try:
+            # Preprocess image
+            control_image = self.preprocess_image(image)
+            original_size = image.size
+            
+            # Prepare prompt for colorization
+            prompt = "colorize this black and white image, high quality, detailed, vibrant colors, natural colors"
+            negative_prompt = "black and white, grayscale, monochrome, low quality, blurry, desaturated"
+            
+            # Generate colorized image based on model type
+            if self.model_type == "controlnet":
+                # Use ControlNet pipeline
+                result = self.pipe(
+                    prompt=prompt,
+                    image=control_image,
+                    negative_prompt=negative_prompt,
+                    num_inference_steps=num_inference_steps,
+                    guidance_scale=7.5,
+                    controlnet_conditioning_scale=1.0,
+                    generator=torch.Generator(device=self.device).manual_seed(42)
+                )
+                
+                if isinstance(result, dict) and "images" in result:
+                    colorized = result["images"][0]
+                elif isinstance(result, list) and len(result) > 0:
+                    colorized = result[0]
+                else:
+                    colorized = result
+            else:
+                # Use pipeline directly
+                result = self.pipe(
+                    control_image,
+                    prompt=prompt,
+                    num_inference_steps=num_inference_steps
+                )
+                
+                if isinstance(result, dict) and "images" in result:
+                    colorized = result["images"][0]
+                elif isinstance(result, list) and len(result) > 0:
+                    colorized = result[0]
+                else:
+                    colorized = result
+            
+            # Ensure we have a PIL Image
+            if not isinstance(colorized, Image.Image):
+                if isinstance(colorized, np.ndarray):
+                    # Handle numpy array
+                    if colorized.dtype != np.uint8:
+                        colorized = (colorized * 255).astype(np.uint8)
+                    if len(colorized.shape) == 3 and colorized.shape[2] == 3:
+                        colorized = Image.fromarray(colorized, 'RGB')
+                    else:
+                        colorized = Image.fromarray(colorized)
+                elif torch.is_tensor(colorized):
+                    # Handle torch tensor
+                    colorized = colorized.cpu().permute(1, 2, 0).numpy()
+                    colorized = (colorized * 255).astype(np.uint8)
+                    colorized = Image.fromarray(colorized, 'RGB')
+                else:
+                    raise ValueError(f"Unexpected output type: {type(colorized)}")
+            
+            # Resize back to original size
+            if original_size != (512, 512):
+                colorized = colorized.resize(original_size, Image.Resampling.LANCZOS)
+            
+            return colorized
+            
+        except Exception as e:
+            logger.error("Error during colorization: %s", str(e))
+            raise
+

app/config.py

@@ -0,0 +1,33 @@
+"""
+Configuration settings for the application
+"""
+import os
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    """Application settings"""
+    
+    # Firebase settings
+    ENABLE_APP_CHECK: bool = os.getenv("ENABLE_APP_CHECK", "true").lower() == "true"
+    FIREBASE_CREDENTIALS_PATH: str = os.getenv(
+        "FIREBASE_CREDENTIALS_PATH",
+        "colorize-662df-firebase-adminsdk-fbsvc-e080668793.json"
+    )
+    
+    # API settings
+    BASE_URL: str = os.getenv("BASE_URL", "http://localhost:8000")
+    
+    # Model settings
+    MODEL_ID: str = os.getenv("MODEL_ID", "rsortino/ColorizeNet")
+    NUM_INFERENCE_STEPS: int = int(os.getenv("NUM_INFERENCE_STEPS", "20"))
+    
+    # Storage settings
+    UPLOAD_DIR: str = os.getenv("UPLOAD_DIR", "uploads")
+    RESULT_DIR: str = os.getenv("RESULT_DIR", "results")
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+
+settings = Settings()
+

app/main.py

@@ -0,0 +1,273 @@
+"""
+FastAPI application for image colorization using ColorizeNet model
+with Firebase App Check integration
+"""
+import os
+import uuid
+import logging
+from pathlib import Path
+from typing import Optional
+from fastapi import FastAPI, File, UploadFile, HTTPException, Depends, Request
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import firebase_admin
+from firebase_admin import credentials, app_check
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+import io
+
+from app.colorize_model import ColorizeModel
+from app.config import settings
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Colorize API",
+    description="Image colorization API using ColorizeNet model",
+    version="1.0.0"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize Firebase Admin SDK
+firebase_cred_path = os.getenv("FIREBASE_CREDENTIALS_PATH", "colorize-662df-firebase-adminsdk-fbsvc-e080668793.json")
+if os.path.exists(firebase_cred_path):
+    try:
+        cred = credentials.Certificate(firebase_cred_path)
+        firebase_admin.initialize_app(cred)
+        logger.info("Firebase Admin SDK initialized")
+    except Exception as e:
+        logger.warning("Failed to initialize Firebase: %s", str(e))
+        firebase_admin.initialize_app()
+else:
+    logger.warning("Firebase credentials file not found. App Check will be disabled.")
+    try:
+        firebase_admin.initialize_app()
+    except:
+        pass
+
+# Create directories
+UPLOAD_DIR = Path("uploads")
+RESULT_DIR = Path("results")
+UPLOAD_DIR.mkdir(exist_ok=True)
+RESULT_DIR.mkdir(exist_ok=True)
+
+# Mount static files for serving results
+app.mount("/results", StaticFiles(directory="results"), name="results")
+app.mount("/uploads", StaticFiles(directory="uploads"), name="uploads")
+
+# Initialize ColorizeNet model
+colorize_model = None
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the colorization model on startup"""
+    global colorize_model
+    try:
+        logger.info("Loading ColorizeNet model...")
+        colorize_model = ColorizeModel()
+        logger.info("ColorizeNet model loaded successfully")
+    except Exception as e:
+        logger.error("Failed to load ColorizeNet model: %s", str(e))
+        # Don't raise - allow health check to work even if model fails
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    global colorize_model
+    if colorize_model:
+        del colorize_model
+    logger.info("Application shutdown")
+
+# Firebase App Check verification
+async def verify_app_check(request: Request):
+    """Verify Firebase App Check token"""
+    if not settings.ENABLE_APP_CHECK:
+        return True
+    
+    app_check_token = request.headers.get("X-Firebase-AppCheck")
+    if not app_check_token:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing App Check token"
+        )
+    
+    try:
+        # Verify the App Check token
+        app_check_claims = app_check.verify_token(app_check_token)
+        logger.info("App Check token verified for: %s", app_check_claims.get("app_id"))
+        return True
+    except Exception as e:
+        logger.warning("App Check token verification failed: %s", str(e))
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid App Check token"
+        )
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "model_loaded": colorize_model is not None
+    }
+
+@app.post("/upload")
+async def upload_image(
+    file: UploadFile = File(...),
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Upload an image and return the uploaded image URL
+    """
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File must be an image")
+    
+    # Generate unique filename
+    file_id = str(uuid.uuid4())
+    file_extension = Path(file.filename).suffix or ".jpg"
+    filename = f"{file_id}{file_extension}"
+    filepath = UPLOAD_DIR / filename
+    
+    # Save uploaded file
+    try:
+        contents = await file.read()
+        with open(filepath, "wb") as f:
+            f.write(contents)
+        logger.info("Image uploaded: %s", filename)
+        
+        # Return the URL to access the uploaded image
+        base_url = os.getenv("BASE_URL", os.getenv("SPACE_HOST", "http://localhost:7860"))
+        image_url = f"{base_url}/uploads/{filename}"
+        
+        return {
+            "success": True,
+            "image_id": file_id,
+            "image_url": image_url,
+            "filename": filename
+        }
+    except Exception as e:
+        logger.error("Error uploading image: %s", str(e))
+        raise HTTPException(status_code=500, detail=f"Error uploading image: {str(e)}")
+
+@app.post("/colorize")
+async def colorize_image(
+    file: UploadFile = File(...),
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Colorize an uploaded grayscale image using ColorizeNet
+    Returns the colorized image URL
+    """
+    if colorize_model is None:
+        raise HTTPException(status_code=503, detail="Colorization model not loaded")
+    
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File must be an image")
+    
+    try:
+        # Read image
+        contents = await file.read()
+        image = Image.open(io.BytesIO(contents))
+        
+        # Convert to RGB if needed
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        
+        # Colorize the image
+        logger.info("Colorizing image...")
+        colorized_image = colorize_model.colorize(image)
+        
+        # Save colorized image
+        file_id = str(uuid.uuid4())
+        result_filename = f"{file_id}.jpg"
+        result_filepath = RESULT_DIR / result_filename
+        
+        colorized_image.save(result_filepath, "JPEG", quality=95)
+        logger.info("Colorized image saved: %s", result_filename)
+        
+        # Return URLs
+        base_url = os.getenv("BASE_URL", os.getenv("SPACE_HOST", "http://localhost:7860"))
+        download_url = f"{base_url}/results/{result_filename}"
+        api_download_url = f"{base_url}/download/{file_id}"
+        
+        return {
+            "success": True,
+            "result_id": file_id,
+            "download_url": download_url,
+            "api_download_url": api_download_url,
+            "filename": result_filename
+        }
+    except Exception as e:
+        logger.error("Error colorizing image: %s", str(e))
+        raise HTTPException(status_code=500, detail=f"Error colorizing image: {str(e)}")
+
+@app.get("/download/{file_id}")
+async def download_result(
+    file_id: str,
+    verified: bool = Depends(verify_app_check)
+):
+    """
+    Download the colorized image by file ID
+    """
+    result_filepath = RESULT_DIR / f"{file_id}.jpg"
+    
+    if not result_filepath.exists():
+        raise HTTPException(status_code=404, detail="Result not found")
+    
+    return FileResponse(
+        result_filepath,
+        media_type="image/jpeg",
+        filename=f"colorized_{file_id}.jpg"
+    )
+
+@app.get("/results/{filename}")
+async def get_result_file(filename: str):
+    """
+    Serve result files directly (public endpoint for browser access)
+    """
+    result_filepath = RESULT_DIR / filename
+    
+    if not result_filepath.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    return FileResponse(
+        result_filepath,
+        media_type="image/jpeg"
+    )
+
+@app.get("/uploads/{filename}")
+async def get_upload_file(filename: str):
+    """
+    Serve uploaded files directly
+    """
+    upload_filepath = UPLOAD_DIR / filename
+    
+    if not upload_filepath.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    return FileResponse(
+        upload_filepath,
+        media_type="image/jpeg"
+    )
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", "7860"))
+    uvicorn.run(app, host="0.0.0.0", port=port)

deploy.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+# Deployment script for Hugging Face Spaces
+
+echo "Deploying to Hugging Face Space..."
+
+# Initialize git if not already
+if [ ! -d ".git" ]; then
+    git init
+fi
+
+# Add all files
+git add .
+
+# Commit changes
+git commit -m "Deploy Colorize API with Firebase App Check"
+
+# Add Hugging Face remote (replace with your space URL)
+git remote add origin https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize || git remote set-url origin https://huggingface.co/spaces/LogicGoInfotechSpaces/Colorize
+
+# Push to Hugging Face
+git push -u origin main
+
+echo "Deployment complete!"
+

requirements.txt

@@ -0,0 +1,17 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+requests>=2.31.0
+pillow==10.1.0
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.30.0
+diffusers>=0.21.0
+accelerate>=0.20.0
+opencv-python-headless==4.8.1.78
+numpy>=1.24.0
+firebase-admin>=6.0.0
+pydantic-settings>=2.0.0
+huggingface-hub>=0.16.0
+safetensors>=0.3.0
+