4.41.3

Dockerfile

@@ -1,145 +1,145 @@
 # ===============================
-# Optimized Dockerfile for Hugging Face Spaces
-# PyTorch 2.5.1 + CUDA 12.1 (SAM2 compatible versions)
+# Hugging Face Space — Stable Dockerfile
+# CUDA 12.1.1 + PyTorch 2.5.1 (cu121) + Gradio 4.41.3
+# SAM2 installed from source; MatAnyone via pip (repo)
 # ===============================
 
-# Base image with CUDA 12.1.1
 FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
 
-# Environment variables
+# ---- Environment (runtime hygiene) ----
 ENV DEBIAN_FRONTEND=noninteractive \
     PYTHONUNBUFFERED=1 \
     PYTHONDONTWRITEBYTECODE=1 \
     PIP_NO_CACHE_DIR=1 \
     PIP_DISABLE_PIP_VERSION_CHECK=1 \
     TORCH_CUDA_ARCH_LIST="7.5 8.0 8.6+PTX" \
-    CUDA_VISIBLE_DEVICES="0"
-
-# Create non-root user
+    CUDA_VISIBLE_DEVICES="0" \
+    # Threads (fixes libgomp warnings)
+    OMP_NUM_THREADS=4 \
+    OPENBLAS_NUM_THREADS=1 \
+    MKL_NUM_THREADS=1 \
+    NUMEXPR_NUM_THREADS=1 \
+    # Caches inside repo volume (stable on Spaces)
+    HF_HOME=/home/user/app/.hf \
+    TORCH_HOME=/home/user/app/.torch \
+    # Gradio port coherency (HF proxy)
+    GRADIO_SERVER_PORT=7860
+
+# ---- Non-root user ----
 RUN useradd -m -u 1000 user
 ENV HOME=/home/user
 WORKDIR $HOME/app
 
-# Install system dependencies in a single layer
+# ---- System deps ----
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    git \
-    ffmpeg \
-    wget \
-    python3 \
-    python3-pip \
-    python3-venv \
-    python3-dev \
-    build-essential \
-    gcc \
-    g++ \
-    pkg-config \
-    libffi-dev \
-    libssl-dev \
-    libc6-dev \
-    libgl1-mesa-glx \
-    libglib2.0-0 \
-    libsm6 \
-    libxext6 \
-    libxrender1 \
-    libgomp1 \
-    && rm -rf /var/lib/apt/lists/*
-
-# Set up Python environment
-RUN python3 -m pip install --no-cache-dir --upgrade pip setuptools wheel
-
-# Install PyTorch 2.5.1 (SAM2 minimum requirement)
-RUN python3 -m pip install --no-cache-dir \
-    torch==2.5.1 \
-    torchvision==0.20.1 \
-    torchaudio==2.5.1 \
-    && python3 -c "import torch; print(f'PyTorch version: {torch.__version__}'); print(f'CUDA available: {torch.cuda.is_available()}'); print(f'CUDA version: {torch.version.cuda if torch.cuda.is_available() else \"N/A\"}'); print(f'cuDNN version: {torch.backends.cudnn.version() if torch.cuda.is_available() else \"N/A\"}')"
-
-# Copy requirements files first for better caching
-COPY --chown=user requirements.txt ./
-
-# Install Python dependencies
+    git ffmpeg wget curl \
+    python3 python3-pip python3-venv python3-dev \
+    build-essential gcc g++ pkg-config \
+    libffi-dev libssl-dev libc6-dev \
+    libgl1-mesa-glx libglib2.0-0 libsm6 libxext6 libxrender1 libgomp1 \
+ && rm -rf /var/lib/apt/lists/*
+
+# ---- Python bootstrap ----
+RUN python3 -m pip install --upgrade pip setuptools wheel
+
+# ---- Install PyTorch (CUDA 12.1 wheels) ----
+# Using the official cu121 wheel index keeps runtime aligned with base image
+RUN python3 -m pip install --no-cache-dir --index-url https://download.pytorch.org/whl/cu121 \
+      torch==2.5.1 torchvision==0.20.1 torchaudio==2.5.1 \
+ && python3 - <<'PY'
+import torch
+print("PyTorch:", torch.__version__)
+print("CUDA available:", torch.cuda.is_available())
+print("torch.version.cuda:", getattr(torch.version, "cuda", None))
+try:
+    import torchaudio, torchvision
+    print("torchaudio:", torchaudio.__version__)
+    import torchvision as tv; print("torchvision:", tv.__version__)
+except Exception as e:
+    print("aux libs check:", e)
+PY
+
+# ---- Copy deps first (better caching) ----
+COPY --chown=user:user requirements.txt ./
+
+# ---- Install remaining Python deps ----
+# (requirements.txt contains gradio==4.41.3 and libs; NOT the SAM2 repo)
 RUN python3 -m pip install --no-cache-dir -r requirements.txt
 
-# Install MatAnyone with retry logic and fallback dependencies
-RUN echo "Installing problematic dependencies first..." && \
-    python3 -m pip install --no-cache-dir chardet charset-normalizer && \
-    echo "Installing MatAnyone..." && \
+# ---- MatAnyone (pip install from repo with retry) ----
+RUN echo "Installing MatAnyone..." && \
     (python3 -m pip install --no-cache-dir -v git+https://github.com/pq-yang/MatAnyone@main#egg=matanyone || \
-     (echo "Retrying MatAnyone installation..." && \
+     (echo "Retrying MatAnyone..." && \
       python3 -m pip install --no-cache-dir -v git+https://github.com/pq-yang/MatAnyone@main#egg=matanyone)) && \
-    python3 -c "import matanyone; print('MatAnyone import successful')"
+    python3 -c "import matanyone; print('MatAnyone import OK')"
 
-# Copy application code
-COPY --chown=user . .
+# ---- App code ----
+COPY --chown=user:user . .
 
-# Install SAM2
-RUN echo "Installing SAM2..." && \
+# ---- SAM2 from source (editable) ----
+# Keep SAM2 out of requirements.txt to avoid duplicate installs
+RUN echo "Installing SAM2 (editable)..." && \
     git clone --depth=1 https://github.com/facebookresearch/segment-anything-2.git third_party/sam2 && \
-    cd third_party/sam2 && \
-    python3 -m pip install --no-cache-dir -e .
+    cd third_party/sam2 && python3 -m pip install --no-cache-dir -e .
 
-# Set up environment variables - IMPORTANT: Disable bytecode generation
+# ---- App env ----
 ENV PYTHONPATH=/home/user/app:/home/user/app/third_party:/home/user/app/third_party/sam2 \
     FFMPEG_BIN=ffmpeg \
     THIRD_PARTY_SAM2_DIR=/home/user/app/third_party/sam2 \
     ENABLE_MATANY=1 \
     SAM2_DEVICE=cuda \
     MATANY_DEVICE=cuda \
-    OMP_NUM_THREADS=1 \
     TF_CPP_MIN_LOG_LEVEL=2 \
-    SAM2_CHECKPOINT=/home/user/app/checkpoints/sam2_hiera_large.pt \
-    PYTHONDONTWRITEBYTECODE=1
-
-# Create checkpoints directory
-RUN mkdir -p /home/user/app/checkpoints
-
-# Note: SAM2 model will be downloaded at runtime via lazy loading
+    SAM2_CHECKPOINT=/home/user/app/checkpoints/sam2_hiera_large.pt
 
-# Fix permissions thoroughly
-RUN chown -R user:user /home/user/app && \
+# ---- Create writable dirs (caches + checkpoints) ----
+RUN mkdir -p /home/user/app/checkpoints /home/user/app/.hf /home/user/app/.torch && \
+    chown -R user:user /home/user/app && \
     chmod -R 755 /home/user/app && \
     find /home/user/app -type d -exec chmod 755 {} \; && \
     find /home/user/app -type f -exec chmod 644 {} \; && \
-    chmod +x /home/user/app/ui.py
+    chmod +x /home/user/app/ui.py || true
 
-# Health check
-HEALTHCHECK --interval=30s --timeout=5s --retries=3 CMD python3 -c "import torch; print(f'PyTorch: {torch.__version__}, CUDA: {torch.cuda.is_available()}')"
+# ---- Healthcheck (lightweight) ----
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 CMD python3 - <<'PY' || exit 1
+import torch, sys
+print(f"torch {torch.__version__} | cuda {getattr(torch.version,'cuda',None)} | ok={torch.cuda.is_available()}")
+PY
 
-# Run as non-root user
+# ---- Runtime ----
 USER user
 EXPOSE 7860
 
-# Start the application with comprehensive debugging and no bytecode compilation
 CMD ["sh", "-c", "\
-    echo '===========================================' && \
-    echo '=== BACKGROUNDFX PRO CONTAINER STARTUP ===' && \
-    echo '===========================================' && \
-    echo 'Timestamp:' $(date) && \
-    echo 'Current directory:' $(pwd) && \
-    echo 'Current user:' $(whoami) && \
-    echo 'User ID:' $(id) && \
-    echo '' && \
-    echo '=== FILE SYSTEM CHECK ===' && \
-    echo 'Files in app directory:' && \
-    ls -la && \
-    echo '' && \
-    echo '=== UI.PY VERIFICATION ===' && \
-    if [ -f ui.py ]; then \
-        echo '✅ ui.py found' && \
-        echo 'File size:' $(wc -c < ui.py) 'bytes' && \
-        echo 'File permissions:' $(ls -l ui.py) && \
-        echo 'Testing Python imports...' && \
-        python3 -B -c 'import gradio; print(\"✅ Gradio:\", gradio.__version__)' && \
-        python3 -B -c 'import torch; print(\"✅ Torch:\", torch.__version__)' && \
-        echo 'Testing ui.py import...' && \
-        python3 -B -c 'import sys; sys.path.insert(0, \".\"); import ui; print(\"✅ ui.py imports successfully\")' && \
-        echo '✅ All checks passed!'; \
-    else \
-        echo '❌ ERROR: ui.py not found!' && \
-        exit 1; \
-    fi && \
-    echo '' && \
-    echo '=== STARTING APPLICATION ===' && \
-    echo 'Launching ui.py with bytecode disabled...' && \
-    python3 -B -u ui.py \
-"]
+  echo '===========================================' && \
+  echo '=== BACKGROUNDFX PRO CONTAINER STARTUP ===' && \
+  echo '===========================================' && \
+  echo 'Timestamp:' $(date) && \
+  echo 'Current directory:' $(pwd) && \
+  echo 'Current user:' $(whoami) && \
+  echo 'User ID:' $(id) && \
+  echo '' && \
+  echo '=== FILE SYSTEM CHECK ===' && \
+  echo 'Files in app directory:' && \
+  ls -la && \
+  echo '' && \
+  echo '=== UI.PY VERIFICATION ===' && \
+  if [ -f ui.py ]; then \
+      echo '✅ ui.py found' && \
+      echo 'File size:' $(wc -c < ui.py) 'bytes' && \
+      echo 'File permissions:' $(ls -l ui.py) && \
+      echo 'Testing Python imports...' && \
+      python3 -B -c 'import gradio; print(\"✅ Gradio:\", gradio.__version__)' && \
+      python3 -B -c 'import torch; print(\"✅ Torch:\", torch.__version__)' && \
+      echo 'Testing ui.py import...' && \
+      python3 -B -c 'import sys; sys.path.insert(0, \".\"); import ui; print(\"✅ ui.py imports successfully\")' && \
+      echo '✅ All checks passed!'; \
+  else \
+      echo '❌ ERROR: ui.py not found!' && \
+      exit 1; \
+  fi && \
+  echo '' && \
+  echo '=== STARTING APPLICATION ===' && \
+  echo 'Launching ui.py with bytecode disabled...' && \
+  python3 -B -u ui.py \
+"]

requirements.txt

@@ -1,7 +1,7 @@
 # ===== Core Dependencies =====
-# PyTorch is installed in Dockerfile with CUDA 12.1 - UPDATED FOR SAM2 COMPATIBILITY
+# PyTorch is installed in Dockerfile with CUDA 12.1 — REQUIRED for SAM2
 # torch==2.5.1
-# torchvision==0.20.0
+# torchvision==0.20.1
 # torchaudio==2.5.1
 
 # ===== Base Dependencies =====
@@ -28,6 +28,7 @@ einops>=0.6.0,<0.9.0
 timm>=0.9.0,<1.1.0
 pyyaml>=6.0.0,<7.0.0
 matplotlib>=3.5.0,<4.0.0
+iopath>=0.1.10,<0.2.0
 
 # ===== MatAnyone Dependencies =====
 # MatAnyone is installed separately in Dockerfile
@@ -35,7 +36,7 @@ kornia>=0.7.0,<0.8.0
 tqdm>=4.60.0,<5.0.0
 
 # ===== UI and API =====
-gradio>=5.0.0,<6.0.0
+gradio==4.41.3
 
 # ===== Helpers and Utilities =====
 huggingface-hub>=0.20.0,<1.0.0
@@ -55,6 +56,6 @@ loguru>=0.6.0,<1.0.0
 # File handling
 python-multipart>=0.0.5,<1.0.0
 
-# Web server
+# Web server (if you use your own API endpoints besides Gradio)
 uvicorn>=0.20.0,<1.0.0
-fastapi>=0.95.0,<1.0.0
+fastapi>=0.110.0,<0.116.0

ui.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-BackgroundFX Pro — Main UI Application
+BackgroundFX Pro — Main UI Application (Gradio 4.41.3)
 Clean, focused main file that coordinates the application
 """
 
@@ -36,40 +36,53 @@
 import torch
 import gradio as gr
 
-# Import our modules
+# Import our modules (logger + probe + interface factory live here)
 from ui_core_functionality import startup_probe, logger
 from ui_core_interface import create_interface
 
-# ===============================================================================
+
+# =======================================================================
 # MAIN APPLICATION
-# ===============================================================================
+# =======================================================================
 
 def main():
     """Main application entry point"""
     try:
-        # Run startup probe
+        # Fast sanity check for writable FS etc.
         startup_probe()
-        
-        # Create and launch interface
+
+        # Log versions for quick triage
         logger.info("🚀 Launching Gradio interface...")
+        logger.info("Gradio=%s | torch=%s | cu=%s | cuda_available=%s",
+                    getattr(gr, "__version__", "?"),
+                    torch.__version__,
+                    getattr(torch.version, "cuda", None),
+                    torch.cuda.is_available())
+
+        # Build interface
         demo = create_interface()
-        
-        # Fixed queue configuration for Gradio 5.46.0
-        demo.queue()
-        
+
+        # --- Gradio 4.x runtime settings ---
+        # Keep queue small (prevents RAM spikes) and single-thread the server.
+        demo.queue(max_size=2)
+
+        # Bind to the Space-provided port (avoids proxy kills)
+        port = int(os.environ.get("PORT", os.environ.get("GRADIO_SERVER_PORT", "7860")))
         demo.launch(
             server_name="0.0.0.0",
-            server_port=7860,
+            server_port=port,
             share=False,
-            show_api=True,
+            show_api=False,     # safer on public Spaces
             show_error=True,
             quiet=False,
-            debug=True
+            debug=False,
+            max_threads=1       # 4.x: prefer max_threads over concurrency_count
         )
-        
+
     except Exception as e:
-        logger.error(f"❌ Application startup failed: {e}")
+        logger.error("❌ Application startup failed: %s", e)
         raise
 
+
 if __name__ == "__main__":
-    main()
+    main()

ui_core_functionality.py

@@ -2,7 +2,7 @@
 """
 BackgroundFX Pro — Core Functionality
 All processing logic, utilities, background generators, and handlers
-Enhanced with ChatGPT's file safety and error handling improvements
+Enhanced with file safety, robust logging, and runtime diagnostics.
 """
 
 import os
@@ -28,103 +28,171 @@
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
 import cv2
-import gradio as gr
-import importlib.metadata
 
-# Get paths from main module
-APP_ROOT = Path(__file__).resolve().parent
+# ==============================================================================
+# PATHS & ENV
+# ==============================================================================
+
+# Repo root (…/app)
+APP_ROOT = Path(__file__).resolve().parent.parent
 DATA_ROOT = APP_ROOT / "data"
-TMP_ROOT = APP_ROOT / "tmp"
-JOB_ROOT = TMP_ROOT / "backgroundfx_jobs"
-
-# Configure logging
-logger = logging.getLogger("ui")
-if not logger.handlers:
-    h = logging.StreamHandler()
-    h.setFormatter(logging.Formatter("[%(asctime)s] %(levelname)s: %(message)s"))
-    logger.addHandler(h)
-logger.setLevel(logging.INFO)
-
-# ===============================================================================
-# STARTUP VALIDATION
-# ===============================================================================
+TMP_ROOT  = APP_ROOT / "tmp"
+JOB_ROOT  = TMP_ROOT / "backgroundfx_jobs"
+
+for p in (DATA_ROOT, TMP_ROOT, JOB_ROOT, APP_ROOT / ".hf", APP_ROOT / ".torch"):
+    p.mkdir(parents=True, exist_ok=True)
+
+# Cache dirs (stable on Spaces)
+os.environ.setdefault("HF_HOME", str(APP_ROOT / ".hf"))
+os.environ.setdefault("TORCH_HOME", str(APP_ROOT / ".torch"))
+
+# Quiet BLAS/OpenMP spam (in case ui.py wasn’t first)
+os.environ.setdefault("OMP_NUM_THREADS", "4")
+os.environ.setdefault("OPENBLAS_NUM_THREADS", "1")
+os.environ.setdefault("MKL_NUM_THREADS", "1")
+os.environ.setdefault("NUMEXPR_NUM_THREADS", "1")
+os.environ.setdefault("PYTHONFAULTHANDLER", "1")
+
+# ==============================================================================
+# LOGGING + DIAGNOSTICS (console + file + heartbeat)
+# ==============================================================================
+
+# Line-buffer logs so Space UI shows them promptly
+try:
+    sys.stdout.reconfigure(line_buffering=True)
+    sys.stderr.reconfigure(line_buffering=True)
+except Exception:
+    pass
+
+LOG_FILE = DATA_ROOT / "run.log"
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout),
+              logging.FileHandler(LOG_FILE, encoding="utf-8")],
+    force=True,
+)
+logger = logging.getLogger("bgfx")
+
+# Faulthandler (native crashes -> stacks)
+try:
+    import faulthandler, signal  # type: ignore
+    faulthandler.enable(all_threads=True)
+    if hasattr(signal, "SIGUSR1"):
+        faulthandler.register(signal.SIGUSR1, file=sys.stderr, all_threads=True)
+except Exception as e:
+    logger.warning("faulthandler setup skipped: %s", e)
 
 def _disk_stats(p: Path) -> str:
-    """Get disk usage statistics for a path"""
     try:
         total, used, free = shutil.disk_usage(str(p))
-        to_mb = lambda x: x // (1024 * 1024)
-        return f"disk(total={to_mb(total)}MB, used={to_mb(used)}MB, free={to_mb(free)}MB)"
+        mb = lambda x: x // (1024 * 1024)
+        return f"disk(total={mb(total)}MB, used={mb(used)}MB, free={mb(free)}MB)"
     except Exception:
         return "disk(n/a)"
 
+def _cgroup_limit_bytes():
+    for fp in ("/sys/fs/cgroup/memory.max", "/sys/fs/cgroup/memory/memory.limit_in_bytes"):
+        try:
+            s = Path(fp).read_text().strip()
+            if s and s != "max":
+                return int(s)
+        except Exception:
+            pass
+
+def _rss_bytes():
+    try:
+        for line in Path("/proc/self/status").read_text().splitlines():
+            if line.startswith("VmRSS:"):
+                return int(line.split()[1]) * 1024
+    except Exception:
+        return None
+
+def _heartbeat():
+    lim = _cgroup_limit_bytes()
+    while True:
+        rss = _rss_bytes()
+        logger.info(
+            "HEARTBEAT | rss=%s MB | limit=%s MB | %s",
+            f"{rss//2**20}" if rss else "n/a",
+            f"{lim//2**20}" if lim else "n/a",
+            _disk_stats(APP_ROOT),
+        )
+        time.sleep(2)
+
+# Start heartbeat as a daemon thread (only once)
+try:
+    threading.Thread(target=_heartbeat, name="heartbeat", daemon=True).start()
+except Exception as e:
+    logger.warning("heartbeat skipped: %s", e)
+
+import atexit
+@atexit.register
+def _on_exit():
+    logger.info("PROCESS EXITING (atexit) — if you don't see this, it was a hard kill (OOM/SIGKILL)")
+
+# ==============================================================================
+# STARTUP VALIDATION
+# ==============================================================================
+
 def startup_probe():
     """Comprehensive startup probe - validates system readiness"""
     try:
         logger.info("🚀 BACKGROUNDFX PRO STARTUP PROBE")
-        logger.info(f"���� Working directory: {os.getcwd()}")
-        logger.info(f"🐍 Python executable: {sys.executable}")
-        
-        # Write probe (critical - fail fast if can't write)
+        logger.info("📁 Working directory: %s", os.getcwd())
+        logger.info("🐍 Python executable: %s", sys.executable)
+
+        # Write probe (fail fast if not writable)
         probe_file = TMP_ROOT / "startup_probe.txt"
         probe_file.write_text("startup_test_ok", encoding="utf-8")
         assert probe_file.read_text(encoding="utf-8") == "startup_test_ok"
-        logger.info(f"✅ WRITE PROBE OK: {probe_file} | {_disk_stats(APP_ROOT)}")
-        
+        logger.info("✅ WRITE PROBE OK: %s | %s", probe_file, _disk_stats(APP_ROOT))
         probe_file.unlink(missing_ok=True)
-        
+
         # GPU/Torch status
         try:
-            logger.info(f"🔧 Torch version: {torch.__version__}")
-            if hasattr(torch.version, 'cuda') and torch.version.cuda:
-                logger.info(f"🔧 CUDA version: {torch.version.cuda}")
-            
+            logger.info("🔧 Torch=%s | cu=%s | cuda_available=%s",
+                        torch.__version__, getattr(torch.version, "cuda", None), torch.cuda.is_available())
             if torch.cuda.is_available():
                 gpu_count = torch.cuda.device_count()
-                gpu_name = torch.cuda.get_device_name(0) if gpu_count > 0 else "Unknown"
-                gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1e9
-                logger.info(f"🔥 GPU Available: {gpu_name} ({gpu_count} devices)")
-                logger.info(f"💾 GPU Memory: {gpu_memory:.1f}GB")
+                name = torch.cuda.get_device_name(0) if gpu_count else "Unknown"
+                vram_gb = torch.cuda.get_device_properties(0).total_memory / (1024**3) if gpu_count else 0
+                logger.info("🔥 GPU Available: %s (%d device(s)) — VRAM %.1f GB", name, gpu_count, vram_gb)
             else:
-                logger.warning("⚠️  No GPU available - using CPU only")
+                logger.warning("⚠️  No GPU available — using CPU")
         except Exception as e:
-            logger.warning(f"⚠️  Torch check failed: {e}")
-        
+            logger.warning("⚠️  Torch check failed: %s", e)
+
         # Directory verification
-        required_dirs = ['checkpoints', 'models', 'utils']
-        for dir_name in required_dirs:
-            dir_path = APP_ROOT / dir_name
-            if dir_path.exists():
-                logger.info(f"✅ Directory found: {dir_name}")
-            else:
-                logger.warning(f"⚠️  Missing directory: {dir_name}")
-        
-        # Job directory test
-        test_job_dir = JOB_ROOT / "startup_test_job"
-        test_job_dir.mkdir(parents=True, exist_ok=True)
-        test_file = test_job_dir / "test.tmp"
-        test_file.write_text("job_isolation_test")
-        assert test_file.read_text() == "job_isolation_test"
-        logger.info(f"✅ Job isolation directory ready: {JOB_ROOT}")
-        
-        shutil.rmtree(test_job_dir, ignore_errors=True)
-        
-        # Environment summary
-        logger.info("🌍 Environment:")
-        logger.info(f"  • OMP_NUM_THREADS: {os.environ.get('OMP_NUM_THREADS', 'unset')}")
-        logger.info(f"  • HF_HOME: {os.environ.get('HF_HOME', 'default')}")
-        logger.info(f"  • TORCH_HOME: {os.environ.get('TORCH_HOME', 'default')}")
-        
-        logger.info("🎯 Startup probe completed successfully - system ready!")
-        
+        for d in ("checkpoints", "models", "utils"):
+            dp = APP_ROOT / d
+            logger.info("✅ Directory %s: %s", d, "OK" if dp.exists() else "MISSING")
+
+        # Job dir isolation test
+        test_job = JOB_ROOT / "startup_test_job"
+        test_job.mkdir(parents=True, exist_ok=True)
+        tfile = test_job / "test.tmp"
+        tfile.write_text("job_isolation_test")
+        assert tfile.read_text() == "job_isolation_test"
+        logger.info("✅ Job isolation directory ready: %s", JOB_ROOT)
+        shutil.rmtree(test_job, ignore_errors=True)
+
+        # Env summary
+        logger.info("🌍 Env: OMP_NUM_THREADS=%s | HF_HOME=%s | TORCH_HOME=%s",
+                    os.environ.get("OMP_NUM_THREADS", "unset"),
+                    os.environ.get("HF_HOME", "default"),
+                    os.environ.get("TORCH_HOME", "default"))
+
+        logger.info("🎯 Startup probe completed — system ready!")
+
     except Exception as e:
-        logger.error(f"❌ STARTUP PROBE FAILED: {e}")
-        logger.error(f"📊 Disk stats: {_disk_stats(APP_ROOT)}")
-        raise RuntimeError(f"Startup probe failed - system not ready: {e}") from e
+        logger.error("❌ STARTUP PROBE FAILED: %s", e)
+        logger.error("📊 %s", _disk_stats(APP_ROOT))
+        raise RuntimeError(f"Startup probe failed — system not ready: {e}") from e
 
-# ===============================================================================
-# CHATGPT ENHANCED FILE SAFETY UTILITIES
-# ===============================================================================
+# ==============================================================================
+# FILE SAFETY UTILITIES
+# ==============================================================================
 
 def new_tmp_path(suffix: str) -> Path:
     """Generate safe temporary path within TMP_ROOT"""
@@ -136,8 +204,8 @@ def atomic_write_bytes(dst: Path, data: bytes):
     try:
         with open(tmp, "wb") as f:
             f.write(data)
-        tmp.replace(dst)  # atomic on same filesystem
-        logger.debug(f"✅ Atomic write completed: {dst}")
+        tmp.replace(dst)  # atomic on same FS
+        logger.debug("✅ Atomic write: %s", dst)
     except Exception as e:
         if tmp.exists():
             tmp.unlink(missing_ok=True)
@@ -155,35 +223,36 @@ def place_uploaded(in_path: str, sub="uploads") -> Path:
     target_dir.mkdir(exist_ok=True, parents=True)
     out = target_dir / safe_name(Path(in_path).name)
     shutil.copy2(in_path, out)
-    logger.info(f"📁 Uploaded file placed: {out}")
+    logger.info("📁 Uploaded file placed: %s", out)
     return out
 
 def tmp_video_path(ext=".mp4") -> Path:
-    """Generate temporary video path"""
     return new_tmp_path(ext)
 
 def tmp_image_path(ext=".png") -> Path:
-    """Generate temporary image path"""
     return new_tmp_path(ext)
 
 def run_safely(fn: Callable, *args, **kwargs):
     """Execute function with comprehensive error logging"""
     try:
         return fn(*args, **kwargs)
-    except Exception as e:
+    except Exception:
         logger.error("PROCESSING FAILED\n%s", "".join(traceback.format_exc()))
         logger.error("CWD=%s | DATA_ROOT=%s | TMP_ROOT=%s | %s",
-                      os.getcwd(), DATA_ROOT, TMP_ROOT, _disk_stats(APP_ROOT))
-        logger.error("Env: OMP_NUM_THREADS=%s | CUDA=%s | torch=%s | cu=%s",
-                      os.environ.get("OMP_NUM_THREADS"),
-                      os.environ.get("CUDA_VISIBLE_DEVICES", "default"),
-                      torch.__version__,
-                      torch.version.cuda)
+                     os.getcwd(), DATA_ROOT, TMP_ROOT, _disk_stats(APP_ROOT))
+        try:
+            logger.error("Env: OMP_NUM_THREADS=%s | CUDA=%s | torch=%s | cu=%s",
+                         os.environ.get("OMP_NUM_THREADS"),
+                         os.environ.get("CUDA_VISIBLE_DEVICES", "default"),
+                         torch.__version__,
+                         getattr(torch.version, "cuda", None))
+        except Exception:
+            pass
         raise
 
-# ===============================================================================
+# ==============================================================================
 # SYSTEM UTILITIES
-# ===============================================================================
+# ==============================================================================
 
 def get_device():
     """Get optimal device for processing"""
@@ -198,7 +267,7 @@ def clear_gpu_memory():
             gc.collect()
             logger.info("🧹 GPU memory cleared")
     except Exception as e:
-        logger.warning(f"⚠️ GPU cleanup warning: {e}")
+        logger.warning("GPU cleanup warning: %s", e)
 
 def safe_file_operation(operation: Callable, *args, max_retries: int = 3, **kwargs):
     """Safely execute file operations with retries"""
@@ -210,119 +279,87 @@ def safe_file_operation(operation: Callable, *args, max_retries: int = 3, **kwar
             last_error = e
             if attempt < max_retries - 1:
                 time.sleep(0.1 * (attempt + 1))
-                logger.warning(f"File operation retry {attempt + 1}: {e}")
+                logger.warning("File op retry %d: %s", attempt + 1, e)
             else:
-                logger.error(f"File operation failed after {max_retries} attempts: {e}")
+                logger.error("File op failed after %d attempts: %s", max_retries, e)
     raise last_error
 
-# ===============================================================================
+# ==============================================================================
 # BACKGROUND GENERATORS
-# ===============================================================================
+# ==============================================================================
 
 def generate_ai_background(prompt: str, width: int, height: int) -> Image.Image:
-    """Generate AI background using prompt-based styling"""
+    """Generate AI-like background using prompt cues (procedural)"""
     try:
-        logger.info(f"Generating AI background: '{prompt}' ({width}x{height})")
-        
-        # Create base image
+        logger.info("Generating AI background: '%s' (%dx%d)", prompt, width, height)
         img = np.zeros((height, width, 3), dtype=np.uint8)
-        
-        # Analyze prompt for style/color cues
         prompt_lower = prompt.lower()
-        
-        if any(word in prompt_lower for word in ['city', 'urban', 'futuristic', 'cyberpunk']):
-            # Dark cityscape style
+
+        if any(w in prompt_lower for w in ('city', 'urban', 'futuristic', 'cyberpunk')):
             for i in range(height):
-                ratio = i / height
-                r = int(20 + 80 * ratio)
-                g = int(30 + 100 * ratio)  
-                b = int(60 + 120 * ratio)
+                r = int(20 + 80 * (i / height))
+                g = int(30 + 100 * (i / height))
+                b = int(60 + 120 * (i / height))
                 img[i, :] = [r, g, b]
-                
-        elif any(word in prompt_lower for word in ['beach', 'tropical', 'ocean', 'sea']):
-            # Beach/ocean style
+        elif any(w in prompt_lower for w in ('beach', 'tropical', 'ocean', 'sea')):
             for i in range(height):
-                ratio = i / height
-                r = int(135 + 120 * ratio)
-                g = int(206 + 49 * ratio)
-                b = int(235 + 20 * ratio)
+                r = int(135 + 120 * (i / height))
+                g = int(206 + 49 * (i / height))
+                b = int(235 + 20 * (i / height))
                 img[i, :] = [r, g, b]
-                
-        elif any(word in prompt_lower for word in ['forest', 'jungle', 'nature', 'green']):
-            # Forest style
+        elif any(w in prompt_lower for w in ('forest', 'jungle', 'nature', 'green')):
             for i in range(height):
-                ratio = i / height
-                r = int(34 + 105 * ratio)
-                g = int(139 + 30 * ratio)
-                b = int(34 - 15 * ratio)
+                r = int(34 + 105 * (i / height))
+                g = int(139 + 30 * (i / height))
+                b = int(34 - 15 * (i / height))
                 img[i, :] = [max(0, r), max(0, g), max(0, b)]
-                
-        elif any(word in prompt_lower for word in ['space', 'galaxy', 'stars', 'cosmic']):
-            # Space style
+        elif any(w in prompt_lower for w in ('space', 'galaxy', 'stars', 'cosmic')):
             for i in range(height):
-                ratio = i / height
-                r = int(10 + 50 * ratio)
-                g = int(0 + 30 * ratio)
-                b = int(30 + 100 * ratio)
+                r = int(10 + 50 * (i / height))
+                g = int(0 + 30 * (i / height))
+                b = int(30 + 100 * (i / height))
                 img[i, :] = [r, g, b]
-                
-        elif any(word in prompt_lower for word in ['desert', 'sand', 'canyon']):
-            # Desert style
+        elif any(w in prompt_lower for w in ('desert', 'sand', 'canyon')):
             for i in range(height):
-                ratio = i / height
-                r = int(238 + 17 * ratio)
-                g = int(203 + 52 * ratio)
-                b = int(173 + 82 * ratio)
+                r = int(238 + 17 * (i / height))
+                g = int(203 + 52 * (i / height))
+                b = int(173 + 82 * (i / height))
                 img[i, :] = [min(255, r), min(255, g), min(255, b)]
-                
         else:
-            # Generic colorful gradient based on prompt mood
-            colors = [(255, 182, 193), (255, 218, 185), (176, 224, 230)]  # Soft colors
+            colors = [(255, 182, 193), (255, 218, 185), (176, 224, 230)]
             color = colors[len(prompt) % len(colors)]
-            
             for i in range(height):
-                ratio = i / height
-                r = int(color[0] * (1 - ratio * 0.3))
-                g = int(color[1] * (1 - ratio * 0.3))
-                b = int(color[2] * (1 - ratio * 0.3))
-                img[i, :] = [r, g, b]
-        
-        # Add some texture/noise for more interesting look
+                t = 1 - (i / height) * 0.3
+                img[i, :] = [int(color[0] * t), int(color[1] * t), int(color[2] * t)]
+
         noise = np.random.randint(-15, 15, (height, width, 3))
         img = np.clip(img.astype(np.int16) + noise, 0, 255).astype(np.uint8)
-        
         return Image.fromarray(img)
-        
+
     except Exception as e:
-        logger.warning(f"AI background generation failed: {e}, using fallback")
+        logger.warning("AI background generation failed: %s — using fallback", e)
         return create_gradient_background("sunset", width, height)
 
 def create_gradient_background(gradient_type: str, width: int, height: int) -> Image.Image:
-    """Create gradient background"""
     img = np.zeros((height, width, 3), dtype=np.uint8)
-    
     gradients = {
         "sunset": [(255, 165, 0), (128, 64, 128)],
-        "ocean": [(0, 100, 255), (30, 144, 255)],
+        "ocean":  [(0, 100, 255), (30, 144, 255)],
         "forest": [(34, 139, 34), (139, 69, 19)],
-        "sky": [(135, 206, 235), (206, 235, 255)]
+        "sky":    [(135, 206, 235), (206, 235, 255)],
     }
-    
     if gradient_type in gradients:
-        start_color, end_color = gradients[gradient_type]
+        start, end = gradients[gradient_type]
         for i in range(height):
-            ratio = i / height
-            r = int(start_color[0] * (1 - ratio) + end_color[0] * ratio)
-            g = int(start_color[1] * (1 - ratio) + end_color[1] * ratio)
-            b = int(start_color[2] * (1 - ratio) + end_color[2] * ratio)
+            r = int(start[0] * (1 - i/height) + end[0] * (i/height))
+            g = int(start[1] * (1 - i/height) + end[1] * (i/height))
+            b = int(start[2] * (1 - i/height) + end[2] * (i/height))
             img[i, :] = [r, g, b]
     else:
         img.fill(128)
-    
     return Image.fromarray(img)
 
 def create_solid_background(color: str, width: int, height: int) -> Image.Image:
-    """Create solid color background"""
     color_map = {
         "white": (255, 255, 255), "black": (0, 0, 0), "red": (255, 0, 0),
         "green": (0, 255, 0), "blue": (0, 0, 255), "yellow": (255, 255, 0),
@@ -333,77 +370,62 @@ def create_solid_background(color: str, width: int, height: int) -> Image.Image:
     return Image.new("RGB", (width, height), rgb)
 
 def download_unsplash_image(query: str, width: int, height: int) -> Image.Image:
-    """Download image from Unsplash"""
     try:
         url = f"https://source.unsplash.com/{width}x{height}/?{query}"
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
-        
-        image = Image.open(io.BytesIO(response.content))
-        if image.size != (width, height):
-            image = image.resize((width, height), Image.Resampling.LANCZOS)
-        
-        return image.convert("RGB")
+        resp = requests.get(url, timeout=10)
+        resp.raise_for_status()
+        img = Image.open(io.BytesIO(resp.content))
+        if img.size != (width, height):
+            img = img.resize((width, height), Image.Resampling.LANCZOS)
+        return img.convert("RGB")
     except Exception as e:
-        logger.warning(f"Failed to download Unsplash image: {e}")
+        logger.warning("Unsplash download failed: %s", e)
         return create_solid_background("gray", width, height)
 
-# ===============================================================================
-# VIDEO PROCESSING UTILITIES
-# ===============================================================================
+# ==============================================================================
+# VIDEO UTILITIES
+# ==============================================================================
 
 def get_video_info(video_path: str) -> Dict[str, Any]:
-    """Get video information using OpenCV"""
     try:
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
             raise ValueError("Cannot open video file")
-        
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        duration = frame_count / fps if fps > 0 else 0
-        
+        fps   = cap.get(cv2.CAP_PROP_FPS)
+        frames= int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        w     = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        h     = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         cap.release()
-        
-        return {
-            "fps": fps, "frame_count": frame_count, "width": width,
-            "height": height, "duration": duration
-        }
+        return {"fps": fps, "frame_count": frames, "width": w, "height": h,
+                "duration": (frames / fps if fps > 0 else 0)}
     except Exception as e:
-        logger.error(f"Failed to get video info: {e}")
+        logger.error("get_video_info failed: %s", e)
         return {"fps": 30.0, "frame_count": 0, "width": 1920, "height": 1080, "duration": 0}
 
 def extract_frame(video_path: str, frame_number: int) -> Optional[np.ndarray]:
-    """Extract specific frame from video"""
     try:
         cap = cv2.VideoCapture(video_path)
         cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
         ret, frame = cap.read()
         cap.release()
-        
         if ret:
             return cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
         return None
     except Exception as e:
-        logger.error(f"Failed to extract frame: {e}")
+        logger.error("extract_frame failed: %s", e)
         return None
 
 def ffmpeg_safe_call(inp: Path, out: Path, extra=()):
-    """Safe FFmpeg call with proper path quoting"""
-    cmd = ["ffmpeg", "-y", "-hide_banner", "-loglevel", "error",
-           "-i", str(inp), *extra, str(out)]
-    logger.info("FFMPEG: %s", " ".join(cmd))
+    cmd = ["ffmpeg", "-y", "-hide_banner", "-loglevel", "error", "-i", str(inp), *extra, str(out)]
+    logger.info("FFMPEG %s", " ".join(cmd))
     subprocess.run(cmd, check=True, timeout=300)
 
-# ===============================================================================
+# ==============================================================================
 # PROGRESS TRACKING
-# ===============================================================================
+# ==============================================================================
 
 class ProgressTracker:
     """Thread-safe progress tracking for video processing"""
-    
     def __init__(self):
         self.current_step = ""
         self.progress = 0.0
@@ -411,101 +433,92 @@ def __init__(self):
         self.processed_frames = 0
         self.start_time = time.time()
         self.lock = threading.Lock()
-        
+
     def update(self, step: str, progress: float = None):
-        """Update progress safely"""
         with self.lock:
             self.current_step = step
             if progress is not None:
                 self.progress = max(0.0, min(1.0, progress))
-                
+
     def update_frames(self, processed: int, total: int = None):
-        """Update frame processing progress"""
         with self.lock:
             self.processed_frames = processed
             if total is not None:
                 self.total_frames = total
             if self.total_frames > 0:
                 self.progress = self.processed_frames / self.total_frames
-                
+
     def get_status(self) -> Dict[str, Any]:
-        """Get current status safely"""
         with self.lock:
             elapsed = time.time() - self.start_time
             eta = 0
             if self.progress > 0.01:
                 eta = elapsed * (1.0 - self.progress) / self.progress
-                
             return {
                 "step": self.current_step, "progress": self.progress,
                 "processed_frames": self.processed_frames, "total_frames": self.total_frames,
                 "elapsed": elapsed, "eta": eta
             }
 
-# Global progress tracker
+# Global tracker
 progress_tracker = ProgressTracker()
 
-# ===============================================================================
-# SAFE FILE OPERATIONS (ENHANCED)
-# ===============================================================================
+# ==============================================================================
+# SAFE FILE OPS
+# ==============================================================================
 
 def create_job_directory() -> Path:
-    """Create unique job directory for processing"""
     job_id = str(uuid.uuid4())[:8]
     job_dir = JOB_ROOT / f"job_{job_id}_{int(time.time())}"
     job_dir.mkdir(parents=True, exist_ok=True)
-    logger.info(f"📁 Created job directory: {job_dir}")
+    logger.info("📁 Created job directory: %s", job_dir)
     return job_dir
 
 def atomic_file_write(filepath: Path, content: bytes):
-    """Write file atomically to prevent corruption"""
     temp_path = filepath.with_suffix(f"{filepath.suffix}.tmp")
     try:
         with open(temp_path, 'wb') as f:
             f.write(content)
         temp_path.rename(filepath)
-        logger.debug(f"✅ Atomic write completed: {filepath}")
+        logger.debug("✅ Atomic write: %s", filepath)
     except Exception as e:
         if temp_path.exists():
             temp_path.unlink(missing_ok=True)
         raise e
 
 def safe_download(url: str, filepath: Path, max_size: int = 500 * 1024 * 1024):
-    """Safely download file with size checks"""
     temp_path = filepath.with_suffix(f"{filepath.suffix}.download")
-    
     try:
-        response = requests.get(url, stream=True, timeout=30)
-        response.raise_for_status()
-        
-        content_length = response.headers.get('content-length')
-        if content_length and int(content_length) > max_size:
-            raise ValueError(f"File too large: {content_length} bytes")
-        
+        r = requests.get(url, stream=True, timeout=30)
+        r.raise_for_status()
+        cl = r.headers.get('content-length')
+        if cl and int(cl) > max_size:
+            raise ValueError(f"File too large: {cl} bytes")
+
         downloaded = 0
         with open(temp_path, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192):
+            for chunk in r.iter_content(chunk_size=8192):
                 if chunk:
                     downloaded += len(chunk)
                     if downloaded > max_size:
                         raise ValueError(f"Download exceeded size limit: {downloaded} bytes")
                     f.write(chunk)
-        
+
         if not temp_path.exists() or temp_path.stat().st_size == 0:
             raise ValueError("Download resulted in empty file")
-            
+
         temp_path.rename(filepath)
-        logger.info(f"✅ Download completed: {filepath} ({downloaded} bytes)")
-        
+        logger.info("✅ Downloaded: %s (%d bytes)", filepath, downloaded)
+
     except Exception as e:
         if temp_path.exists():
             temp_path.unlink(missing_ok=True)
-        logger.error(f"❌ Download failed: {e}")
+        logger.error("❌ Download failed: %s", e)
         raise
 
-# ===============================================================================
+# ==============================================================================
 # ENHANCED PIPELINE INTEGRATION
-# ===============================================================================
+# ==============================================================================
 
 def process_video_pipeline(
     video_path: str,
@@ -516,100 +529,75 @@ def process_video_pipeline(
     progress_callback: Optional[Callable] = None
 ) -> str:
     """Process video using the two-stage pipeline with enhanced safety and monitoring"""
-    
-    # Wrap entire function with ChatGPT's safe execution wrapper
+
     def _inner_process():
         logger.info("=" * 60)
-        logger.info("=== ENHANCED TWO-STAGE PIPELINE (WITH CHATGPT SAFETY) ===")
+        logger.info("=== ENHANCED TWO-STAGE PIPELINE (WITH SAFETY) ===")
         logger.info("=" * 60)
-        
-        # Pre-flight checks with enhanced validation
-        logger.info(f"DEBUG: Video path: {video_path}")
-        logger.info(f"DEBUG: Video exists: {Path(video_path).exists()}")
-        logger.info(f"DEBUG: Video file size: {Path(video_path).stat().st_size if Path(video_path).exists() else 'N/A'} bytes")
-        logger.info(f"DEBUG: Job directory: {job_dir}")
-        logger.info(f"DEBUG: Job directory writable: {os.access(job_dir, os.W_OK)}")
-        logger.info(f"DEBUG: Background image size: {background_image.size if background_image else 'None'}")
-        logger.info(f"DEBUG: Background type: {background_type}")
-        logger.info(f"DEBUG: Disk space: {_disk_stats(APP_ROOT)}")
-        
-        # Safely handle uploaded video
+
+        logger.info("DEBUG video_path=%s exists=%s size=%s bytes",
+                    video_path, Path(video_path).exists(),
+                    (Path(video_path).stat().st_size if Path(video_path).exists() else "N/A"))
+        logger.info("DEBUG job_dir=%s writable=%s", job_dir, os.access(job_dir, os.W_OK))
+        logger.info("DEBUG bg_image=%s bg_type=%s | %s",
+                    (background_image.size if background_image else None),
+                    background_type, _disk_stats(APP_ROOT))
+
         if not Path(video_path).exists():
             raise FileNotFoundError(f"Video file not found: {video_path}")
-            
-        # Create safe video path within our controlled environment
+
+        # Copy into controlled area
         safe_video_path = place_uploaded(video_path, "videos")
-        logger.info(f"DEBUG: Safe video path: {safe_video_path}")
-        
-        # Import with error context
-        logger.info("DEBUG: Attempting to import two-stage pipeline...")
+        logger.info("DEBUG safe_video_path=%s", safe_video_path)
+
+        logger.info("DEBUG importing two-stage pipeline…")
         try:
             from two_stage_pipeline import process_two_stage as pipeline_process
-            logger.info("✓ Two-stage pipeline imported successfully")
+            logger.info("✓ two-stage pipeline import OK")
         except ImportError as e:
-            logger.error(f"Failed to import two-stage pipeline: {e}")
+            logger.error("Import two_stage_pipeline failed: %s", e)
             raise
-        
-        progress_tracker.update("Initializing enhanced two-stage pipeline...")
-        
-        # Enhanced progress callback with stage monitoring and memory tracking
+
+        progress_tracker.update("Initializing enhanced two-stage pipeline…")
+
         current_stage = {"stage": "init", "start_time": time.time()}
-        
+
         def safe_progress_callback(step: str, progress: float = None):
             try:
-                current_time = time.time()
-                elapsed = current_time - current_stage["start_time"]
-                
-                # Stage detection with timing
-                if "Stage 1" in step:
-                    if current_stage["stage"] != "stage1":
-                        current_stage["stage"] = "stage1"
-                        current_stage["start_time"] = current_time
-                        logger.info("🔄 STAGE TRANSITION: Entering Stage 1 (SAM2)")
-                        logger.info(f"Memory before Stage 1: {_disk_stats(APP_ROOT)}")
-                        
-                elif "Stage 2" in step:
-                    if current_stage["stage"] != "stage2":
-                        stage1_duration = current_time - current_stage["start_time"]
-                        current_stage["stage"] = "stage2"
-                        current_stage["start_time"] = current_time
-                        logger.info("🔄 STAGE TRANSITION: Entering Stage 2 (Composition)")
-                        logger.info(f"Stage 1 completed in {stage1_duration:.1f}s")
-                        logger.info(f"Memory after Stage 1: {_disk_stats(APP_ROOT)}")
-                        
-                elif "Done" in step:
-                    if current_stage["stage"] != "complete":
-                        stage2_duration = current_time - current_stage["start_time"]
-                        current_stage["stage"] = "complete"
-                        logger.info("🔄 STAGE TRANSITION: Pipeline Complete")
-                        logger.info(f"Stage 2 completed in {stage2_duration:.1f}s")
-                        logger.info(f"Final memory: {_disk_stats(APP_ROOT)}")
-                
-                logger.info(f"PROGRESS [{current_stage['stage'].upper()}] ({elapsed:.1f}s): {step} ({progress})")
+                now = time.time()
+                elapsed = now - current_stage["start_time"]
+
+                if "Stage 1" in step and current_stage["stage"] != "stage1":
+                    current_stage["stage"] = "stage1"
+                    current_stage["start_time"] = now
+                    logger.info("🔄 Entering Stage 1 (SAM2) | %s", _disk_stats(APP_ROOT))
+                elif "Stage 2" in step and current_stage["stage"] != "stage2":
+                    d1 = now - current_stage["start_time"]
+                    current_stage["stage"] = "stage2"
+                    current_stage["start_time"] = now
+                    logger.info("🔄 Entering Stage 2 (Composition) — Stage 1 time %.1fs | %s", d1, _disk_stats(APP_ROOT))
+                elif "Done" in step and current_stage["stage"] != "complete":
+                    d2 = now - current_stage["start_time"]
+                    current_stage["stage"] = "complete"
+                    logger.info("🔄 Pipeline complete — Stage 2 time %.1fs | %s", d2, _disk_stats(APP_ROOT))
+
+                logger.info("PROGRESS [%s] (%.1fs): %s (%s)",
+                            current_stage['stage'].upper(), elapsed, step, progress)
                 progress_tracker.update(step, progress)
-                
+
                 if progress_callback:
-                    if progress is not None:
-                        progress_callback(f"Progress: {progress:.1%} - {step}")
-                    else:
-                        progress_callback(step)
-                        
-                # Memory warning if Stage 1 takes too long
+                    progress_callback(f"Progress: {progress:.1%} - {step}" if progress is not None else step)
+
                 if current_stage["stage"] == "stage1" and elapsed > 15:
-                    logger.warning(f"⚠️ Stage 1 running for {elapsed:.1f}s - monitoring for memory issues")
-                    
+                    logger.warning("⚠️ Stage 1 running for %.1fs — monitoring memory", elapsed)
+
             except Exception as e:
-                logger.error(f"Progress callback error: {e}")
-        
-        # Validation with enhanced error context
+                logger.error("Progress callback error: %s", e)
+
         if background_image is None:
             raise ValueError("Background image is required")
-            
-        logger.info("DEBUG: Pre-pipeline validation complete")
-        logger.info(f"DEBUG: Job dir contents before: {list(job_dir.iterdir()) if job_dir.exists() else 'does not exist'}")
-        
-        # Call two-stage pipeline with safe paths
-        logger.info("DEBUG: Calling two-stage pipeline with enhanced monitoring...")
+
+        logger.info("DEBUG: calling two-stage pipeline…")
         result_path = pipeline_process(
             video_path=str(safe_video_path),
             background_image=background_image,
@@ -617,50 +605,43 @@ def safe_progress_callback(step: str, progress: float = None):
             progress=safe_progress_callback,
             use_matany=True
         )
-        
-        logger.info(f"DEBUG: Pipeline returned: {result_path}")
-        logger.info(f"DEBUG: Result path type: {type(result_path)}")
-        
-        # Post-processing validation with enhanced checks
+
+        logger.info("DEBUG: pipeline returned %s (%s)", result_path, type(result_path))
+
         if result_path:
             result_file = Path(result_path)
-            logger.info(f"DEBUG: Result file exists: {result_file.exists()}")
+            logger.info("DEBUG: result exists=%s", result_file.exists())
             if result_file.exists():
-                file_size = result_file.stat().st_size
-                logger.info(f"DEBUG: Result file size: {file_size} bytes")
-                if file_size == 0:
+                size = result_file.stat().st_size
+                logger.info("DEBUG: result size=%d bytes", size)
+                if size == 0:
                     raise RuntimeError("Pipeline produced empty output file")
-            logger.info(f"DEBUG: Job dir contents after: {list(job_dir.iterdir())}")
-            
-            # Verify the output is a valid video
-            try:
-                cap = cv2.VideoCapture(str(result_file))
-                if cap.isOpened():
-                    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-                    logger.info(f"DEBUG: Output video frame count: {frame_count}")
-                    cap.release()
-                else:
-                    logger.warning("⚠️ Output file may not be a valid video")
-            except Exception as e:
-                logger.warning(f"⚠️ Could not verify output video: {e}")
-        
+
+                # Quick validity check
+                try:
+                    cap = cv2.VideoCapture(str(result_file))
+                    if cap.isOpened():
+                        frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+                        logger.info("DEBUG: output frame_count=%d", frames)
+                        cap.release()
+                    else:
+                        logger.warning("⚠️ Output may not be a valid video (cannot open)")
+                except Exception as e:
+                    logger.warning("⚠️ Could not verify output video: %s", e)
+
         if not result_path or not Path(result_path).exists():
-            raise RuntimeError("Two-stage pipeline processing failed - no output produced")
-            
+            raise RuntimeError("Two-stage pipeline failed — no output produced")
+
         logger.info("=" * 60)
-        logger.info(f"✅ ENHANCED TWO-STAGE PIPELINE COMPLETED: {result_path}")
+        logger.info("✅ ENHANCED TWO-STAGE PIPELINE COMPLETED: %s", result_path)
         logger.info("=" * 60)
         return result_path
-    
-    # Execute with ChatGPT's comprehensive error wrapper
+
     try:
         return run_safely(_inner_process)
     except Exception as e:
-        # Enhanced error cleanup
-        logger.error("🧹 Performing error cleanup...")
+        logger.error("🧹 Error cleanup…")
         clear_gpu_memory()
-        
-        # Additional error context
-        logger.error(f"Job directory state: {list(job_dir.iterdir()) if job_dir.exists() else 'does not exist'}")
-        
-        raise
+        logger.error("Job dir state: %s",
+                     (list(job_dir.iterdir()) if job_dir.exists() else "does not exist"))
+        raise

ui_core_interface.py

@@ -30,16 +30,12 @@ def handle_custom_background_upload(image: Optional[Image.Image]) -> Tuple[Optio
     """Handle custom background image upload"""
     if image is None:
         return None, "No image uploaded"
-    
     try:
         if image.mode != "RGB":
             image = image.convert("RGB")
-        
         status = f"✅ Custom background uploaded: {image.size[0]}x{image.size[1]}"
         logger.info(status)
-        
         return image, status
-        
     except Exception as e:
         error_msg = f"❌ Background upload failed: {str(e)}"
         logger.error(error_msg)
@@ -48,7 +44,6 @@ def handle_custom_background_upload(image: Optional[Image.Image]) -> Tuple[Optio
 def handle_background_type_change(bg_type: str):
     """Handle background type selection - show/hide relevant controls"""
     logger.info(f"🎨 Background type changed to: {bg_type}")
-    
     if bg_type == "upload":
         return (
             gr.update(visible=True, label="Upload Custom Background Image"),
@@ -59,10 +54,9 @@ def handle_background_type_change(bg_type: str):
         prompt_placeholder = {
             "ai_generate": "Describe the scene: 'futuristic city', 'tropical beach', 'mystical forest'...",
             "gradient": "Choose style: 'sunset', 'ocean', 'forest', 'sky'",
-            "solid": "Choose color: 'red', 'blue', 'green', 'white', 'black'...", 
+            "solid": "Choose color: 'red', 'blue', 'green', 'white', 'black'...",
             "unsplash": "Search query: 'mountain landscape', 'city skyline', 'nature'..."
         }
-        
         return (
             gr.update(visible=False),
             gr.update(visible=True, placeholder=prompt_placeholder.get(bg_type, "Enter your prompt...")),
@@ -73,24 +67,19 @@ def handle_video_upload(video_file) -> Tuple[Optional[str], str]:
     """Handle video file upload"""
     if video_file is None:
         return None, "No video file provided"
-    
     try:
         job_dir = create_job_directory()
-        
-        video_path = job_dir / "input_video.mp4"
-        safe_file_operation(
-            lambda src, dst: shutil.copy2(src, dst),
-            video_file, video_path
-        )
-        
+        # Preserve original extension if possible
+        src_path = Path(video_file)
+        ext = src_path.suffix if src_path.suffix else ".mp4"
+        video_path = job_dir / f"input_video{ext}"
+        safe_file_operation(lambda src, dst: shutil.copy2(src, dst), str(src_path), str(video_path))
+
         info = get_video_info(str(video_path))
         duration_text = f"{info['duration']:.1f}s"
-        
         status = f"✅ Video uploaded: {info['width']}x{info['height']}, {info['fps']:.1f}fps, {duration_text}"
         logger.info(status)
-        
         return str(video_path), status
-        
     except Exception as e:
         error_msg = f"❌ Video upload failed: {str(e)}"
         logger.error(error_msg)
@@ -100,53 +89,41 @@ def handle_background_generation(bg_type: str, bg_prompt: str, video_path: str)
     """Handle background generation (for non-upload types)"""
     if not video_path:
         return None, "No video loaded"
-    
     if bg_type == "upload":
         return None, "Use the upload field above for custom backgrounds"
-    
+
     try:
         info = get_video_info(video_path)
         width, height = info['width'], info['height']
-        
+
         if bg_type == "ai_generate":
             background = generate_ai_background(bg_prompt, width, height)
             status = f"✅ Generated AI background: '{bg_prompt}'"
-            
+
         elif bg_type == "gradient":
             gradients = ["sunset", "ocean", "forest", "sky"]
-            gradient_type = gradients[0]
-            if any(g in bg_prompt.lower() for g in gradients):
-                for g in gradients:
-                    if g in bg_prompt.lower():
-                        gradient_type = g
-                        break
-            
+            gradient_type = next((g for g in gradients if g in bg_prompt.lower()), gradients[0])
             background = create_gradient_background(gradient_type, width, height)
             status = f"✅ Generated {gradient_type} gradient background"
-            
+
         elif bg_type == "solid":
             colors = ["white", "black", "red", "green", "blue", "yellow", "purple", "orange", "pink", "gray"]
-            color = "white"
-            for c in colors:
-                if c in bg_prompt.lower():
-                    color = c
-                    break
-            
+            color = next((c for c in colors if c in bg_prompt.lower()), "white")
             background = create_solid_background(color, width, height)
             status = f"✅ Generated {color} solid background"
-            
+
         elif bg_type == "unsplash":
-            query = bg_prompt if bg_prompt.strip() else "nature"
+            query = bg_prompt.strip() or "nature"
             background = download_unsplash_image(query, width, height)
             status = f"✅ Downloaded background from Unsplash: '{query}'"
-            
+
         else:
             background = create_solid_background("gray", width, height)
             status = "✅ Generated default gray background"
-        
+
         logger.info(status)
         return background, status
-        
+
     except Exception as e:
         error_msg = f"❌ Background generation failed: {str(e)}"
         logger.error(error_msg)
@@ -162,17 +139,16 @@ def handle_video_processing(
     """Handle complete video processing"""
     if not video_path:
         return None, "❌ No video provided"
-    
     if not background_image:
         return None, "❌ No background provided"
-    
+
     try:
         progress(0, "Starting video processing...")
         logger.info("🎬 Starting video processing")
-        
+
         job_dir = create_job_directory()
         progress_tracker.update("Creating job directory...")
-        
+
         def update_progress(message: str):
             try:
                 status = progress_tracker.get_status()
@@ -181,7 +157,7 @@ def update_progress(message: str):
                 logger.info(f"Progress: {progress_val:.1%} - {message}")
             except Exception as e:
                 logger.warning(f"Progress update failed: {e}")
-        
+
         result_path = process_video_pipeline(
             video_path=video_path,
             background_image=background_image,
@@ -190,38 +166,31 @@ def update_progress(message: str):
             job_dir=job_dir,
             progress_callback=update_progress
         )
-        
+
         progress(1.0, "Processing complete!")
-        
         clear_gpu_memory()
-        
-        status = f"✅ Video processing completed successfully!"
+
+        status = "✅ Video processing completed successfully!"
         logger.info(status)
-        
         return result_path, status
-        
+
     except Exception as e:
         error_msg = f"❌ Processing failed: {str(e)}"
         logger.error(error_msg)
-        logger.error(f"Traceback: {traceback.format_exc()}")
-        
+        logger.error("Traceback: %s", traceback.format_exc())
         clear_gpu_memory()
-        
         return None, error_msg
 
 def handle_preview_generation(video_path: str, frame_number: int = 0) -> Tuple[Optional[Image.Image], str]:
     """Generate preview frame from video"""
     if not video_path:
         return None, "No video loaded"
-    
     try:
         frame = extract_frame(video_path, frame_number)
         if frame is None:
             return None, "Failed to extract frame"
-        
         preview_image = Image.fromarray(frame)
         return preview_image, f"✅ Preview generated (frame {frame_number})"
-        
     except Exception as e:
         error_msg = f"❌ Preview generation failed: {str(e)}"
         logger.error(error_msg)
@@ -233,7 +202,7 @@ def handle_preview_generation(video_path: str, frame_number: int = 0) -> Tuple[O
 
 def create_interface():
     """Create the main Gradio interface"""
-    
+
     custom_css = """
     .container { max-width: 1200px; margin: auto; }
     .header { text-align: center; margin-bottom: 30px; }
@@ -241,23 +210,24 @@ def create_interface():
     .status { font-family: monospace; font-size: 12px; }
     .progress-bar { margin: 10px 0; }
     """
-    
+
     with gr.Blocks(
         title="BackgroundFX Pro",
         css=custom_css,
-        theme=gr.themes.Soft()
+        theme=gr.themes.Soft(),
+        analytics_enabled=False,   # keep things quiet/stable on 4.x
     ) as demo:
-        
+
         gr.HTML("""
         <div class="header">
             <h1>🎬 BackgroundFX Pro</h1>
             <p>Professional AI-powered video background replacement using SAM2 and MatAnyone</p>
         </div>
         """)
-        
+
         video_path_state = gr.State(value=None)
         background_image_state = gr.State(value=None)
-        
+
         with gr.Row():
             with gr.Column(scale=1):
                 with gr.Group():
@@ -272,28 +242,35 @@ def create_interface():
                         interactive=False,
                         height=300
                     )
+                    # NEW: a fixed preview status box (hidden)
+                    preview_status = gr.Textbox(
+                        label="Preview Status",
+                        interactive=False,
+                        visible=False,
+                        elem_classes=["status"]
+                    )
                     video_status = gr.Textbox(
                         label="Video Status",
                         interactive=False,
                         elem_classes=["status"]
                     )
-                
+
                 with gr.Group():
                     gr.HTML("<h3>🎨 Background Selection</h3>")
-                    
+
                     gr.HTML("""
                     <div style='background: #f0f8ff; padding: 10px; border-radius: 5px; margin-bottom: 15px;'>
                         <b>Choose your background method:</b><br>
                         • <b>Upload:</b> Use your own image<br>
-                        • <b>AI Generate:</b> Create with AI prompt<br>  
+                        • <b>AI Generate:</b> Create with AI prompt<br>
                         • <b>Gradient/Solid/Unsplash:</b> Quick generation
                     </div>
                     """)
-                    
+
                     background_type = gr.Radio(
                         choices=[
                             ("📤 Upload Image", "upload"),
-                            ("🤖 AI Generate", "ai_generate"), 
+                            ("🤖 AI Generate", "ai_generate"),
                             ("🌈 Gradient", "gradient"),
                             ("🎯 Solid Color", "solid"),
                             ("📸 Unsplash Photo", "unsplash")
@@ -301,7 +278,7 @@ def create_interface():
                         label="Background Type",
                         value="upload"
                     )
-                    
+
                     custom_bg_upload = gr.Image(
                         label="Upload Custom Background",
                         type="pil",
@@ -309,62 +286,62 @@ def create_interface():
                         height=250,
                         visible=True
                     )
-                    
+
                     background_prompt = gr.Textbox(
                         label="Background Prompt",
-                        placeholder="AI: 'futuristic city', 'tropical beach' | Gradient: 'sunset', 'ocean' | Solid: 'red', 'blue' | Unsplash: 'mountain landscape'",
+                        placeholder=("AI: 'futuristic city', 'tropical beach' | Gradient: 'sunset', 'ocean' | "
+                                     "Solid: 'red', 'blue' | Unsplash: 'mountain landscape'"),
                         value="futuristic city skyline at sunset",
                         visible=False
                     )
-                    
+
                     generate_bg_btn = gr.Button(
                         "Generate Background",
                         variant="secondary",
-                        visible=False
+                        # (remove size=..., not guaranteed in 4.41.x)
                     )
-                    
+
                     background_preview = gr.Image(
                         label="Background Preview",
                         interactive=False,
                         height=300
                     )
-                    
+
                     background_status = gr.Textbox(
                         label="Background Status",
                         interactive=False,
                         elem_classes=["status"]
                     )
-            
+
             with gr.Column(scale=1):
                 with gr.Group():
                     gr.HTML("<h3>⚡ Processing</h3>")
-                    
+
                     process_btn = gr.Button(
                         "🚀 Process Video",
                         variant="primary",
-                        size="lg"
                     )
-                    
+
                     processing_status = gr.Textbox(
                         label="Processing Status",
                         interactive=False,
                         elem_classes=["status"]
                     )
-                
+
                 with gr.Group():
                     gr.HTML("<h3>📽️ Results</h3>")
-                    
+
                     result_video = gr.Video(
                         label="Processed Video",
                         height=400
                     )
-                    
-                    download_btn = gr.Button(
+
+                    # NEW: real downloadable output
+                    download_btn = gr.DownloadButton(
                         "📥 Download Result",
-                        variant="secondary",
                         visible=False
                     )
-        
+
         with gr.Accordion("🔧 System Information", open=False):
             system_info = gr.HTML(f"""
             <div class="system-info">
@@ -375,14 +352,14 @@ def create_interface():
                 <p><strong>App Root:</strong> {APP_ROOT}</p>
             </div>
             """)
-        
+
         # Event Handlers
         background_type.change(
             fn=handle_background_type_change,
             inputs=[background_type],
             outputs=[custom_bg_upload, background_prompt, generate_bg_btn]
         )
-        
+
         custom_bg_upload.change(
             fn=handle_custom_background_upload,
             inputs=[custom_bg_upload],
@@ -392,7 +369,7 @@ def create_interface():
             inputs=[background_image_state],
             outputs=[background_preview]
         )
-        
+
         video_upload.change(
             fn=handle_video_upload,
             inputs=[video_upload],
@@ -400,9 +377,9 @@ def create_interface():
         ).then(
             fn=handle_preview_generation,
             inputs=[video_path_state],
-            outputs=[video_preview, gr.Textbox(visible=False)]
+            outputs=[video_preview, preview_status]   # FIX: use a real, pre-defined component
         )
-        
+
         generate_bg_btn.click(
             fn=handle_background_generation,
             inputs=[background_type, background_prompt, video_path_state],
@@ -412,20 +389,21 @@ def create_interface():
             inputs=[background_image_state],
             outputs=[background_preview]
         )
-        
+
         process_btn.click(
             fn=handle_video_processing,
             inputs=[
                 video_path_state,
-                background_image_state, 
+                background_image_state,
                 background_type,
                 background_prompt
             ],
             outputs=[result_video, processing_status]
         ).then(
-            fn=lambda video: gr.update(visible=video is not None),
+            # FIX: wire the download button (set value=path and visible accordingly)
+            fn=lambda path: gr.update(value=path, visible=bool(path)),
             inputs=[result_video],
             outputs=[download_btn]
         )
-    
-    return demo
+
+    return demo

utils/paths.py

@@ -0,0 +1,29 @@
+# utils/paths.py
+from pathlib import Path
+import os, re, uuid, shutil
+
+APP_ROOT = Path(__file__).resolve().parents[1]
+DATA_ROOT = APP_ROOT / "data"
+TMP_ROOT  = APP_ROOT / "tmp"
+for p in (DATA_ROOT, TMP_ROOT, APP_ROOT / ".hf", APP_ROOT / ".torch"):
+    p.mkdir(parents=True, exist_ok=True)
+
+os.environ.setdefault("HF_HOME", str(APP_ROOT / ".hf"))
+os.environ.setdefault("TORCH_HOME", str(APP_ROOT / ".torch"))
+
+def safe_name(name: str, default="file"):
+    base = re.sub(r"[^A-Za-z0-9._-]+", "_", (name or default))
+    return (base or default)[:120]
+
+def job_dir(prefix="job"):
+    d = DATA_ROOT / f"{prefix}-{uuid.uuid4().hex[:8]}"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+def disk_stats(p: Path = APP_ROOT) -> str:
+    try:
+        total, used, free = shutil.disk_usage(str(p))
+        mb = lambda x: x // (1024 * 1024)
+        return f"disk(total={mb(total)}MB, used={mb(used)}MB, free={mb(free)}MB)"
+    except Exception:
+        return "disk(n/a)"

utils/perf_tuning.py

@@ -0,0 +1,21 @@
+# utils/perf_tuning.py
+import os, logging
+try:
+    import cv2
+except Exception:
+    cv2 = None
+import torch
+
+def apply():
+    os.environ.setdefault("OMP_NUM_THREADS", "4")
+    if cv2:
+        try:
+            cv2.setNumThreads(4)
+        except Exception as e:
+            logging.info("cv2 threads not set: %s", e)
+    if torch.cuda.is_available():
+        torch.backends.cudnn.benchmark = True
+        try:
+            logging.info("CUDA device %s — cuDNN benchmark ON", torch.cuda.get_device_name(0))
+        except Exception:
+            logging.info("CUDA available — cuDNN benchmark ON")