Upload 8 files

Dockerfile.txt

@@ -0,0 +1,56 @@
+# ──────────────────────────────────────────────────────────────────────────────
+# Stage 1 — dependency builder
+# Compiles packages that need build-essential (e.g. insightface C extensions).
+# Keeps the final image lean by not shipping compilers to production.
+# ──────────────────────────────────────────────────────────────────────────────
+FROM python:3.11-slim AS builder
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential \
+        libglib2.0-0 \
+        libgl1 \
+        libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+
+# Install into /install so we can copy just the packages to the final stage
+RUN pip install --no-cache-dir --prefix=/install -r requirements.txt
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Stage 2 — runtime image (no compilers, smaller attack surface)
+# ──────────────────────────────────────────────────────────────────────────────
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Runtime system libs only
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        libglib2.0-0 \
+        libgl1 \
+        libgomp1 \
+        wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy pre-built Python packages from the builder stage
+COPY --from=builder /install /usr/local
+
+# Copy application source
+COPY . .
+
+# ── PORT fix ──────────────────────────────────────────────────────────────────
+# NEVER use JSON exec-form with $PORT:
+#   CMD ["uvicorn", "main:app", "--port", "$PORT"]   ← shell never runs, $PORT
+#                                                        is passed literally
+#
+# Instead, use start.sh which runs in a real shell AFTER Railway injects $PORT.
+# ─────────────────────────────────────────────────────────────────────────────
+COPY start.sh /start.sh
+RUN chmod +x /start.sh
+
+EXPOSE 8000
+
+CMD ["/start.sh"]

ai_service.py

@@ -0,0 +1,54 @@
+"""
+ai_service.py
+=============
+Google GenAI wrapper.
+Supports both SDKs so the app works regardless of which is installed:
+  - google-genai       (new unified SDK)  → preferred
+  - google-generativeai (legacy SDK)      → fallback
+"""
+from __future__ import annotations
+
+import os
+
+# Try new SDK first
+try:
+    from google import genai as _genai_new
+    _NEW_SDK = True
+except ImportError:
+    _NEW_SDK = False
+
+# Try legacy SDK as fallback
+try:
+    import google.generativeai as _genai_legacy
+    _LEGACY_SDK = True
+except ImportError:
+    _LEGACY_SDK = False
+
+
+def generate_ai_response(prompt: str) -> str:
+    """Return a Gemini text response, or a safe error string (never raises)."""
+
+    if not _NEW_SDK and not _LEGACY_SDK:
+        return "AI not available (neither google-genai nor google-generativeai is installed)."
+
+    api_key = os.getenv("GEMINI_API_KEY")
+    if not api_key:
+        return "AI not configured (GEMINI_API_KEY env var is missing)."
+
+    try:
+        if _NEW_SDK:
+            # New unified SDK (google-genai)
+            client = _genai_new.Client(api_key=api_key)
+            response = client.models.generate_content(
+                model="gemini-1.5-flash",
+                contents=prompt,
+            )
+            return response.text
+        else:
+            # Legacy SDK (google-generativeai)
+            _genai_legacy.configure(api_key=api_key)
+            model = _genai_legacy.GenerativeModel("gemini-1.5-flash")
+            return model.generate_content(prompt).text
+
+    except Exception as exc:
+        return f"AI error: {exc}"

download_model.py

@@ -0,0 +1,41 @@
+"""
+Download inswapper_128.onnx model for face swapping.
+Run this once before starting the server: python download_model.py
+"""
+
+import os
+import urllib.request
+from pathlib import Path
+
+MODEL_DIR = Path(__file__).parent / "models"
+MODEL_DIR.mkdir(exist_ok=True)
+
+MODEL_PATH = MODEL_DIR / "inswapper_128.onnx"
+MODEL_URL  = "https://huggingface.co/kaizma/face-swap-inswapper/resolve/main/inswapper_128.onnx"
+
+def download():
+    if MODEL_PATH.exists():
+        print(f"✅ Model already exists at {MODEL_PATH}")
+        return
+
+    print(f"Downloading inswapper_128.onnx (~500MB)...")
+    print(f"From: {MODEL_URL}")
+    print(f"To:   {MODEL_PATH}")
+    print("")
+
+    def progress(count, block_size, total_size):
+        pct = count * block_size * 100 // total_size
+        print(f"\r  Progress: {pct}%", end="", flush=True)
+
+    try:
+        urllib.request.urlretrieve(MODEL_URL, MODEL_PATH, reporthook=progress)
+        print(f"\n✅ Download complete!")
+    except Exception as e:
+        print(f"\n❌ Download failed: {e}")
+        print("\nManual download:")
+        print(f"  1. Go to: https://huggingface.co/deepinsight/inswapper")
+        print(f"  2. Download inswapper_128.onnx")
+        print(f"  3. Place it in: {MODEL_DIR}")
+
+if __name__ == "__main__":
+    download()

face_service.py

@@ -0,0 +1,58 @@
+"""
+face_service.py
+===============
+InsightFace wrapper — lazy loading + guarded import.
+
+The analyser is created on first call to get_analyser(), not at module import.
+This means the server starts instantly even if the buffalo_l model pack
+hasn't been downloaded yet.
+"""
+from __future__ import annotations
+
+_face_analyser = None
+
+# Guard: don't crash at import time if insightface isn't installed
+try:
+    import insightface  # noqa: F401 — availability check only
+    _AVAILABLE = True
+except ImportError:
+    _AVAILABLE = False
+
+
+def get_analyser():
+    """
+    Return the FaceAnalysis instance, initialising it on first call.
+    Thread-safety note: fine for single-worker Railway deployments.
+    """
+    global _face_analyser
+
+    if not _AVAILABLE:
+        raise RuntimeError(
+            "insightface is not installed. "
+            "Add it to requirements.txt and redeploy."
+        )
+
+    if _face_analyser is None:
+        from insightface.app import FaceAnalysis
+        print("⏳ Initialising FaceAnalysis (buffalo_l)…", flush=True)
+        _face_analyser = FaceAnalysis(
+            name="buffalo_l",
+            providers=["CPUExecutionProvider"],
+        )
+        _face_analyser.prepare(ctx_id=0, det_size=(640, 640))
+        print("✅ FaceAnalysis ready", flush=True)
+
+    return _face_analyser
+
+
+def process_face(data: dict) -> dict:
+    """
+    Face detection stub — replace the body with your real processing logic.
+    Returns a safe error dict instead of raising, so /face never returns 500.
+    """
+    try:
+        analyser = get_analyser()
+        # TODO: decode image from data["image_b64"], run analyser.get(img), etc.
+        return {"status": "ready", "faces_detected": "processing"}
+    except Exception as exc:
+        return {"error": str(exc)}

main.py

@@ -0,0 +1,349 @@
+"""
+Face Swap + Gemini API
+======================
+Merged from python-api/main.py + python-api/python-api/main.py
+All Railway deployment fixes applied.
+
+Endpoints
+─────────
+GET  /            → health check
+GET  /health      → health check (alias)
+POST /swap        → InsightFace face-swap (lazy-loaded, won't block startup)
+POST /gemini/generate → Gemini multimodal generation (legacy SDK)
+POST /ai          → Gemini text generation (new SDK, from ai_service)
+POST /face        → face detection stub (from face_service)
+"""
+
+from __future__ import annotations
+
+import base64
+import os
+import sys
+import gc
+
+# Silence chatty libraries BEFORE imports
+os.environ["ORT_LOGGING_LEVEL"] = "3"
+os.environ["KMP_WARNINGS"] = "0"
+os.environ["INSIGHTFACE_HOME"] = "/tmp/models"
+os.environ["PYTHONUNBUFFERED"] = "1"
+
+import traceback
+import logging
+import warnings
+from pathlib import Path
+from typing import Optional
+
+logging.getLogger("onnxruntime").setLevel(logging.ERROR)
+logging.getLogger("insightface").setLevel(logging.ERROR)
+warnings.filterwarnings("ignore")
+
+# print(">>> NEW VERSION DEPLOYED - Python AI API starting up", flush=True)
+
+import numpy as np
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+# Service modules (your original files, also fixed)
+from ai_service import generate_ai_response
+from face_service import process_face
+
+# ── App ───────────────────────────────────────────────────────────────────────
+
+app = FastAPI(title="Face Swap + Gemini API", version="2.0.0")
+
+# Allow requests from any origin (Netlify, localhost, etc.)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global exception handler — always return JSON, never bare HTML 500 pages
+@app.exception_handler(Exception)
+async def _global_exc_handler(request: Request, exc: Exception) -> JSONResponse:
+    # traceback.print_exc(file=sys.stderr)
+    return JSONResponse(
+        status_code=500,
+        content={"error": str(exc) or "Internal server error"},
+    )
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# InsightFace — optional, guarded import
+# ─────────────────────────────────────────────────────────────────────────────
+
+MODEL_DIR    = Path(__file__).parent / "models"
+SWAPPER_PATH = MODEL_DIR / "inswapper_128.onnx"
+
+# Module-level handles — populated at startup
+_face_analyser = None
+_face_swapper  = None
+_celeb_cache: dict[str, object] = {}
+
+try:
+    import cv2                        # noqa: F401 — import check only
+    import insightface                # noqa: F401
+    _INSIGHTFACE_AVAILABLE = True
+    
+    from insightface.app import FaceAnalysis
+    from insightface.model_zoo import get_model
+    
+    # print("⏳ Loading FaceAnalysis (buffalo_sc) once globally...", flush=True)
+    _face_analyser = FaceAnalysis(
+        name='buffalo_sc',
+        providers=["CPUExecutionProvider"]
+    )
+    _face_analyser.prepare(
+        ctx_id=-1,
+        det_size=(192, 192)
+    )
+    # print("✅ FaceAnalysis ready", flush=True)
+
+except ImportError:
+    _INSIGHTFACE_AVAILABLE = False
+    print("⚠️  insightface/cv2 not installed — /swap will return 503", file=sys.stderr)
+except Exception as e:
+    print(f"❌ Error loading models at startup: {e}", flush=True)
+
+
+def _load_inswapper():
+    """Lazily load inswapper model if not already loaded."""
+    global _face_swapper
+    if _face_swapper is not None:
+        return _face_swapper
+    
+    from insightface.model_zoo import get_model
+    swapper_path = "/app/models/inswapper_128.onnx"
+    if not os.path.exists(swapper_path):
+        swapper_path = str(MODEL_DIR / "inswapper_128.onnx")
+
+    # print(f"⏳ Loading inswapper lazily from: {swapper_path}", flush=True)
+    _face_swapper = get_model(
+        swapper_path,
+        providers=["CPUExecutionProvider"]
+    )
+    # if _face_swapper:
+    #     print("✅ Inswapper ready", flush=True)
+    # else:
+    #     print("❌ Inswapper failed to load (returned None)", flush=True)
+    #     raise HTTPException(500, "Failed to load inswapper model")
+    
+    return _face_swapper
+
+
+# ── Image helpers (your original code, unchanged) ─────────────────────────────
+
+def b64_to_img(b64: str) -> "np.ndarray":
+    import cv2
+    if "," in b64:
+        b64 = b64.split(",", 1)[1]
+    data = base64.b64decode(b64)
+    arr  = np.frombuffer(data, np.uint8)
+    img  = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+    if img is None:
+        raise ValueError("Could not decode image")
+    
+    # Optimization: shrink incoming images to prevent OOM
+    h, w = img.shape[:2]
+    max_size = 720
+    if max(h, w) > max_size:
+        scale = max_size / max(h, w)
+        img = cv2.resize(
+            img,
+            (int(w * scale), int(h * scale))
+        )
+        
+    return img
+
+
+def img_to_b64(img: "np.ndarray", quality: int = 85) -> str:
+    import cv2
+    _, buf = cv2.imencode(".jpg", img, [cv2.IMWRITE_JPEG_QUALITY, quality])
+    return base64.b64encode(buf).decode()
+
+
+def best_face(analyser, img: "np.ndarray"):
+    faces = analyser.get(img)
+    if not faces:
+        return None
+    return max(faces, key=lambda f: (f.bbox[2] - f.bbox[0]) * (f.bbox[3] - f.bbox[1]))
+
+
+# ── Pydantic models ───────────────────────────────────────────────────────────
+
+class SwapRequest(BaseModel):
+    source_key: str
+    source_b64: Optional[str] = None
+    target_b64: str
+    quality: int = 55
+
+
+class AIRequest(BaseModel):
+    prompt: str
+
+
+class GeminiPart(BaseModel):
+    text: Optional[str] = None
+    inlineData: Optional[dict] = None
+
+
+class GeminiRequest(BaseModel):
+    systemInstruction: str
+    parts: list[GeminiPart]
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Routes
+# ─────────────────────────────────────────────────────────────────────────────
+
+# ── Health ────────────────────────────────────────────────────────────────────
+
+@app.get("/")
+@app.get("/health")
+def health():
+    face_models_in_memory = _face_analyser is not None and _face_swapper is not None
+    return {
+        "status": "ok",
+        # NOTE: models are lazy-loaded on first /swap POST, so this is False
+        # until the first swap request.  We separately expose server_ready=True
+        # so the frontend can distinguish "server up but models not yet warm"
+        # from "server unreachable".
+        "models_loaded": face_models_in_memory,
+        # Always True while the server is running — frontend uses this for the
+        # reachability check instead of models_loaded.
+        "server_ready": True,
+        "insightface_available": _INSIGHTFACE_AVAILABLE,
+        "cached_faces": list(_celeb_cache.keys()),
+        "gemini_configured": bool(os.getenv("GEMINI_API_KEY")),
+    }
+
+
+@app.get("/debug")
+def debug():
+    return {
+        "models_folder_exists": os.path.exists("/app/models"),
+        "models": os.listdir("/app/models") if os.path.exists("/app/models") else "not found",
+        "inswapper_exists": os.path.exists("/app/models/inswapper_128.onnx")
+    }
+
+
+# ── Face swap (your original logic, now loaded globally) ─────────────────────
+
+@app.post("/swap")
+async def swap(req: SwapRequest):
+    global _face_analyser
+    if _face_analyser is None:
+        raise HTTPException(503, "FaceAnalysis model is not loaded on this server.")
+    
+    # Lazy load swapper
+    swapper = _load_inswapper()
+
+    # 1. Cache celebrity face if not already done
+    if req.source_key not in _celeb_cache:
+        if not req.source_b64:
+            raise HTTPException(400, "source_b64 required for first call with this key")
+        src_img = b64_to_img(req.source_b64)
+        face    = best_face(_face_analyser, src_img)
+        if face is None:
+            raise HTTPException(422, "No face detected in source image")
+        _celeb_cache[req.source_key] = face
+
+    source_face = _celeb_cache[req.source_key]
+
+    # 2. Decode target frame
+    if not req.target_b64:
+        raise HTTPException(400, "target_b64 required")
+    target_img   = b64_to_img(req.target_b64)
+    target_faces = _face_analyser.get(target_img)
+
+    # 3. No face in target → return original unchanged
+    if not target_faces:
+        return {"swapped": False, "frame": img_to_b64(target_img, req.quality)}
+
+    # 4. Swap the largest detected face
+    target_face = max(
+        target_faces,
+        key=lambda f: (f.bbox[2] - f.bbox[0]) * (f.bbox[3] - f.bbox[1]),
+    )
+    result = swapper.get(target_img, target_face, source_face, paste_back=True)
+    
+    # Free memory after heavy processing
+    gc.collect()
+    
+    return {"swapped": True, "frame": img_to_b64(result, req.quality)}
+
+
+# ── Gemini multimodal (your original /gemini/generate endpoint, fixed) ────────
+
+@app.post("/gemini/generate")
+async def generate_gemini(req: GeminiRequest):
+    # Guard: package must be installed
+    try:
+        import google.generativeai as genai
+    except ImportError:
+        raise HTTPException(503, "google-generativeai is not installed.")
+
+    api_key = os.getenv("GEMINI_API_KEY")
+    if not api_key:
+        raise HTTPException(500, "GEMINI_API_KEY is not configured on Railway.")
+
+    genai.configure(api_key=api_key)
+
+    # FIX: gemini-3.1-pro-preview does not exist — use env var or safe default
+    model_name = os.getenv("GEMINI_MODEL", "gemini-1.5-pro")
+    model = genai.GenerativeModel(model_name)
+
+    try:
+        # Build content parts (your original logic, unchanged)
+        from google.generativeai import types
+        content_parts = []
+        for p in req.parts:
+            if p.text:
+                content_parts.append(types.Part(text=p.text))
+            elif p.inlineData:
+                m_type = p.inlineData.get("mimeType") or p.inlineData.get("mime_type")
+                m_data = p.inlineData.get("data")
+                if m_type and m_data:
+                    content_parts.append(
+                        types.Part(
+                            inline_data=types.Blob(
+                                mime_type=m_type,
+                                data=m_data,
+                            )
+                        )
+                    )
+
+        response = model.generate_content(
+            contents=content_parts,
+            generation_config=genai.GenerationConfig(temperature=0.1),
+            system_instruction=req.systemInstruction,
+        )
+        return {"text": getattr(response, "text", str(response))}
+
+    except Exception as exc:
+        raise HTTPException(500, str(exc)) from exc
+
+
+# ── Simple AI text endpoint (from your original python-api/main.py) ───────────
+
+@app.post("/ai")
+def ai(req: AIRequest):
+    """Thin wrapper around ai_service.generate_ai_response."""
+    return {"result": generate_ai_response(req.prompt)}
+
+
+# ── Face stub endpoint (from your original python-api/main.py) ───────────────
+@app.post("/face")
+def face(data: dict):
+    """Thin wrapper around face_service.process_face."""
+    return {"result": process_face(data)}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port, access_log=False)

railway.toml

@@ -0,0 +1,12 @@
+[build]
+builder = "dockerfile"
+dockerfilePath = "Dockerfile.txt"
+
+[deploy]
+# startCommand is intentionally NOT set here.
+# Railway will use the CMD from the Dockerfile (start.sh).
+# Setting startCommand would override start.sh and re-introduce the $PORT bug.
+restartPolicyType = "on_failure"
+restartPolicyMaxRetries = 3
+healthcheckPath = "/health"
+healthcheckTimeout = 30

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+google-genai
+insightface
+onnxruntime
+opencv-python-headless
+numpy
+python-multipart
+google-generativeai

start.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+set -e
+
+PORT="${PORT:-8080}"
+
+mkdir -p models
+
+if [ ! -f models/inswapper_128.onnx ]; then
+  wget -q -O models/inswapper_128.onnx \
+  "https://huggingface.co/kaizma/face-swap-inswapper/resolve/main/inswapper_128.onnx"
+fi
+
+exec uvicorn main:app \
+    --host 0.0.0.0 \
+    --port "${PORT}" \
+    --workers 1 \
+    --no-access-log \
+    --log-level warning \
+    --timeout-keep-alive 30