Delete .history

.history/.dockerignore_20251111094015

@@ -1,22 +0,0 @@
-__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

@@ -1,26 +0,0 @@
-__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

@@ -1,143 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,135 +0,0 @@
-# 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

@@ -1,135 +0,0 @@
-# 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

@@ -1,114 +0,0 @@
----
-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

@@ -1,114 +0,0 @@
----
-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

@@ -1,114 +0,0 @@
----
-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

@@ -1,40 +0,0 @@
----
-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

@@ -1,193 +0,0 @@
-# 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

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

.history/app/colorize_model_20251111094002.py

@@ -1,154 +0,0 @@
-"""
-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

@@ -1,176 +0,0 @@
-"""
-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

@@ -1,195 +0,0 @@
-"""
-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

@@ -1,33 +0,0 @@
-"""
-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

@@ -1,265 +0,0 @@
-"""
-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

@@ -1,273 +0,0 @@
-"""
-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

@@ -1,273 +0,0 @@
-"""
-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

@@ -1,24 +0,0 @@
-#!/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

@@ -1,17 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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
-