Update app.py

app.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
 """
-🎨 FaceFusion API для Hugging Face Spaces
+🎨 FaceFusion API для Hugging Face Spaces — ИСПРАВЛЕННЫЕ АРГУМЕНТЫ
 ✅ CPU оптимизация + высокое качество замены лица
-✅ inswapper_128 + gfpgan + proper masking
-✅ Таймаут 10 минут для CPU
+✅ Правильные названия моделей для FaceFusion 3.x
 """
 
 import os, sys, tempfile, subprocess, logging, shutil, uuid, time, json
 from pathlib import Path
-from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, File, UploadFile, HTTPException
 from fastapi.responses import Response, JSONResponse
 
 # 🔥 Настройка логирования
@@ -19,7 +19,31 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-app = FastAPI(title="FaceFusion CPU API", version="1.0")
+# 🔥 Lifespan вместо @app.on_event (исправление DeprecationWarning)
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Startup/shutdown events"""
+    logger.info("🚀 FaceFusion CPU API starting...")
+    logger.info(f"📁 Cache dir: {CACHE_DIR}")
+    logger.info(f"⚙️ Config: swapper={CONFIG['face_swapper']}, enhancer={CONFIG['face_enhancer']}")
+    
+    # Предзагрузка моделей
+    try:
+        logger.info("📦 Pre-downloading models...")
+        preload_cmd = ["python", str(FACEFUSION_PY), "force-download", "--execution-provider", "cpu"]
+        result = subprocess.run(preload_cmd, capture_output=True, text=True, cwd=FACEFUSION_DIR, timeout=120)
+        if result.returncode == 0:
+            logger.info("✅ Models pre-downloaded")
+        else:
+            logger.warning(f"⚠️ Pre-download: {result.stderr[-200:]}")
+    except Exception as e:
+        logger.warning(f"⚠️ Could not pre-download: {e}")
+    
+    logger.info("✅ API ready!")
+    yield
+    logger.info("👋 API shutting down...")
+
+app = FastAPI(title="FaceFusion CPU API", version="1.0", lifespan=lifespan)
 
 # 🔥 Пути
 FACEFUSION_DIR = Path("/facefusion")
@@ -30,100 +54,81 @@ CACHE_DIR.mkdir(parents=True, exist_ok=True)
 # 🔥 Проверка установки
 if not FACEFUSION_PY.exists():
     logger.error(f"❌ FaceFusion not found at {FACEFUSION_PY}")
-    raise RuntimeError("FaceFusion not installed — check Dockerfile")
+    raise RuntimeError("FaceFusion not installed")
 
-# 🔥 ОПТИМАЛЬНЫЕ НАСТРОЙКИ ДЛЯ CPU + КАЧЕСТВО
+# 🔥 ОПТИМАЛЬНЫЕ НАСТРОЙКИ ДЛЯ CPU + КАЧЕСТВО (ИСПРАВЛЕННЫЕ НАЗВАНИЯ)
 CONFIG = {
-    # Модель замены лица (единственная стабильная для CPU)
-    "face_swapper": "inswapper_128",
+    # Модель замены лица
+    "face_swapper": "inswapper_128",  # ✅ Доступна в твоей версии
     
-    # Улучшение лица (gfpgan легче codeformer, но даёт хорошее качество)
-    "face_enhancer": "gfpgan",
-    "face_enhancer_blend": 75,  # 75% blending для естественного вида
+    # Модель улучшения лица — ИСПРАВЛЕНО: gfpgan_1.4 вместо gfpgan
+    "face_enhancer": "gfpgan_1.4",  # ✅ Правильное название!
+    "face_enhancer_blend": 75,
     
-    # Маски для лучшего blending
+    # Маски
     "face_mask_types": ["box", "occlusion"],
-    "face_mask_blur": 0.6,      # Мягкие края маски
-    "face_mask_padding": [10, 10, 10, 10],  # Отступы маски [top, right, bottom, left]
+    "face_mask_blur": 0.6,
+    "face_mask_padding": [10, 10, 10, 10],
     
-    # Разрешение (512-768 оптимально для CPU, 1024 слишком медленно)
+    # Разрешение
     "output_image_resolution": 768,
     
-    # CPU оптимизация
-    "execution_providers": ["cpu"],
-    "cpu_threads": 4,           # 4 потока — баланс скорости/RAM
-    "cpu_thread_count": 4,
+    # CPU — ИСПРАВЛЕНО: execution-provider (единственное число!)
+    "execution_provider": "cpu",  # ✅ Не "execution-providers"!
+    "execution_thread_count": 4,
     
     # Прочее
-    "skip_download": True,      # Не качать модели каждый раз
-    "log_level": "error",       # Меньше логов = быстрее
-    "timeout_seconds": 600,     # 10 минут для CPU
+    "skip_download": True,
+    "log_level": "error",
+    "timeout_seconds": 600,
 }
 
-# 🔥 Кэширование моделей
 os.environ["FACEFUSION_CACHE"] = str(CACHE_DIR)
-os.environ["OMP_NUM_THREADS"] = str(CONFIG["cpu_threads"])
+os.environ["OMP_NUM_THREADS"] = str(CONFIG["execution_thread_count"])
 
 @app.get("/")
 async def root():
-    return {
-        "service": "FaceFusion CPU API",
-        "status": "running",
-        "config": {k: v for k, v in CONFIG.items() if k != "face_mask_padding"}
-    }
+    return {"service": "FaceFusion CPU API", "status": "running"}
 
 @app.get("/health")
 async def health():
-    """Health check для Render/HF"""
-    return {"status": "ok", "cache_size_mb": sum(f.stat().st_size for f in CACHE_DIR.rglob('*')) / 1024 / 1024}
+    return {"status": "ok"}
 
-@app.get("/debug/cli")
-async def debug_cli():
-    """Показывает доступные CLI аргументы FaceFusion"""
+@app.get("/debug/args")
+async def debug_args():
+    """Показывает доступные аргументы FaceFusion"""
     try:
         result = subprocess.run(
             ["python", str(FACEFUSION_PY), "headless-run", "--help"],
             capture_output=True, text=True, cwd=FACEFUSION_DIR, timeout=30
         )
-        # Извлекаем только аргументы связанные с face_swapper
         lines = result.stdout.split('\n')
-        relevant = [l.strip() for l in lines if 'face-swapper' in l.lower() or 'processor' in l.lower() or 'execution' in l.lower()]
-        return {"available_args": relevant[:20], "full_help_available": True}
+        relevant = [l.strip() for l in lines if any(kw in l.lower() for kw in ['face-swapper', 'face-enhancer', 'execution', 'processor'])]
+        return {"available_args": relevant[:30]}
     except Exception as e:
         return {"error": str(e)}
 
 @app.post("/swap")
 async def swap_face(
-    source: UploadFile = File(..., description="Фото лица (источник)"),
-    target: UploadFile = File(..., description="Целевое изображение"),
-    enhance: bool = True  # Параметр: включать ли улучшение лица
+    source: UploadFile = File(...),
+    target: UploadFile = File(...),
+    enhance: bool = True
 ):
-    """
-    Замена лица с высоким качеством на CPU
-    
-    Args:
-        source: Фото лица для замены (анфас, хорошее освещение)
-        target: Изображение куда вставить лицо
-        enhance: Включить GFPGAN улучшение (True = лучше качество, но медленнее)
-    """
     temp_dir = None
     start_time = time.time()
     
     try:
-        # 🔥 Создаём временную директорию
         temp_dir = tempfile.mkdtemp(prefix="ff_")
         source_path = Path(temp_dir) / "source.jpg"
         target_path = Path(temp_dir) / "target.jpg"
         output_path = Path(temp_dir) / "output.png"
         
-        logger.info(f"📥 New request: source={source.filename}, target={target.filename}, enhance={enhance}")
+        logger.info(f"📥 Request: source={source.filename}, enhance={enhance}")
         
-        # Сохраняем файлы
         source_path.write_bytes(await source.read())
         target_path.write_bytes(await target.read())
-        logger.info(f"📁 Files saved: {source_path.stat().st_size}b + {target_path.stat().st_size}b")
         
-        # 🔥 Формируем CLI команду с ОПТИМАЛЬНЫМИ аргументами для CPU+качество
+        # 🔥 Формируем CLI команду с ИСПРАВЛЕННЫМИ аргументами
         cmd = [
             "python", str(FACEFUSION_PY),
             "headless-run",
@@ -134,16 +139,16 @@ async def swap_face(
             "--output-path", str(output_path),
             
             # Процессоры
-            "--processors", "face_swapper" + (f" face_enhancer" if enhance else ""),
+            "--processors", "face_swapper" + (" face_enhancer" if enhance else ""),
             
             # Модель замены лица
             "--face-swapper-model", CONFIG["face_swapper"],
             
-            # Модель улучшения (если включено)
+            # Модель улучшения — ИСПРАВЛЕНО: gfpgan_1.4
             *(["--face-enhancer-model", CONFIG["face_enhancer"],
                "--face-enhancer-blend", str(CONFIG["face_enhancer_blend"])] if enhance else []),
             
-            # Маски для качественного blending
+            # Маски
             "--face-mask-types", *CONFIG["face_mask_types"],
             "--face-mask-blur", str(CONFIG["face_mask_blur"]),
             "--face-mask-padding", *map(str, CONFIG["face_mask_padding"]),
@@ -151,32 +156,27 @@ async def swap_face(
             # Разрешение
             "--output-image-resolution", str(CONFIG["output_image_resolution"]),
             
-            # CPU оптимизация
-            "--execution-providers", *CONFIG["execution_providers"],
-            "--execution-thread-count", str(CONFIG["cpu_thread_count"]),
+            # CPU — ИСПРАВЛЕНО: execution-provider (единственное!)
+            "--execution-provider", CONFIG["execution_provider"],
+            "--execution-thread-count", str(CONFIG["execution_thread_count"]),
             
             # Прочее
             "--skip-download" if CONFIG["skip_download"] else None,
             "--log-level", CONFIG["log_level"],
         ]
         
-        # Убираем None значения
+        # Убираем None
         cmd = [arg for arg in cmd if arg is not None]
         
-        logger.info(f"🚀 Running FaceFusion (enhance={enhance})...")
+        logger.info(f"🚀 Running FaceFusion...")
         logger.info(f"   Command: {' '.join(cmd)}")
         
-        # 🔥 Запускаем процесс
         process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            cwd=str(FACEFUSION_DIR),
-            env={**os.environ, "OMP_NUM_THREADS": str(CONFIG["cpu_threads"])}
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            text=True, cwd=str(FACEFUSION_DIR),
+            env={**os.environ, "OMP_NUM_THREADS": str(CONFIG["execution_thread_count"])}
         )
         
-        # Ждём с таймаутом
         try:
             stdout, stderr = process.communicate(timeout=CONFIG["timeout_seconds"])
         except subprocess.TimeoutExpired:
@@ -188,19 +188,15 @@ async def swap_face(
         elapsed = time.time() - start_time
         logger.info(f"⏱️ Processing time: {elapsed:.1f}s")
         
-        # Логируем вывод
-        if stdout and CONFIG["log_level"] == "debug":
-            logger.debug(f"📋 STDOUT: {stdout[-500:]}")
         if stderr:
             logger.info(f"📋 STDERR: {stderr[-300:]}")
         
-        # 🔥 Проверяем результат
         if process.returncode != 0:
             error_msg = stderr.strip()[-400:] if stderr else "Unknown error"
             logger.error(f"❌ FaceFusion failed (code {process.returncode}): {error_msg}")
             raise HTTPException(500, f"FaceFusion error: {error_msg}")
         
-        # Ищем выходной файл (может быть с другим расширением)
+        # Ищем выходной файл
         result_file = None
         for ext in [".png", ".jpg", ".jpeg", ".webp"]:
             candidate = output_path.with_suffix(ext)
@@ -208,8 +204,7 @@ async def swap_face(
                 result_file = candidate
                 break
         
-        if not result_file or not result_file.exists():
-            # Попробуем найти любой image в output директории
+        if not result_file:
             for f in Path(temp_dir).glob("output*"):
                 if f.suffix.lower() in [".png", ".jpg", ".jpeg", ".webp"]:
                     result_file = f
@@ -218,102 +213,20 @@ async def swap_face(
         if not result_file:
             raise HTTPException(500, "Output image not created")
         
-        # 🔥 Читаем и возвращаем результат
         image_data = result_file.read_bytes()
-        result_size = len(image_data)
+        logger.info(f"✅ Success! Returned {len(image_data) / 1024:.1f}KB in {elapsed:.1f}s")
         
-        logger.info(f"✅ Success! Returned {result_size / 1024:.1f}KB in {elapsed:.1f}s")
-        
-        return Response(
-            content=image_data,
-            media_type="image/png",
-            headers={
-                "X-Processing-Time": f"{elapsed:.1f}",
-                "X-Result-Size": str(result_size),
-                "Cache-Control": "no-store"
-            }
-        )
+        return Response(content=image_data, media_type="image/png", headers={"Cache-Control": "no-store"})
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.exception(f"💥 Unexpected error: {type(e).__name__}: {e}")
+        logger.exception(f"💥 Unexpected error: {e}")
         raise HTTPException(500, f"Internal error: {str(e)[:200]}")
-        
     finally:
-        # 🔥 Очистка временных файлов
         if temp_dir and Path(temp_dir).exists():
-            try:
-                shutil.rmtree(temp_dir, ignore_errors=True)
-                logger.debug(f"🧹 Cleaned temp dir: {temp_dir}")
-            except Exception as e:
-                logger.warning(f"⚠️ Could not clean temp dir: {e}")
-
-@app.post("/swap/batch")
-async def swap_batch(
-    source: UploadFile = File(...),
-    targets: list[UploadFile] = File(...),
-    enhance: bool = True
-):
-    """
-    Обработка нескольких целевых изображений за один запрос
-    (полезно для генерации нескольких вариантов)
-    """
-    if len(targets) > 5:
-        raise HTTPException(400, "Maximum 5 target images per batch")
-    
-    results = []
-    for i, target in enumerate(targets):
-        try:
-            # Создаём fake Request для повторного использования swap_face
-            from starlette.datastructures import UploadFile as SFUploadFile
-            result = await swap_face(
-                source=source,
-                target=target,
-                enhance=enhance
-            )
-            results.append({"index": i, "status": "ok", "size": len(result.body)})
-        except Exception as e:
-            results.append({"index": i, "status": "error", "error": str(e)[:100]})
-    
-    return JSONResponse(content={"batch_results": results})
-
-# 🔥 Pre-warm: загрузка моделей при старте (опционально)
-@app.on_event("startup")
-async def startup():
-    logger.info("🚀 FaceFusion CPU API starting...")
-    logger.info(f"📁 Cache dir: {CACHE_DIR}")
-    logger.info(f"⚙️ Config: swapper={CONFIG['face_swapper']}, enhancer={CONFIG['face_enhancer']}, resolution={CONFIG['output_image_resolution']}")
-    
-    # 🔥 Предзагрузка моделей (чтобы первый запрос не таймаутил)
-    try:
-        logger.info("📦 Pre-downloading models...")
-        preload_cmd = [
-            "python", str(FACEFUSION_PY),
-            "force-download",
-            "--execution-providers", "cpu"
-        ]
-        result = subprocess.run(
-            preload_cmd,
-            capture_output=True, text=True,
-            cwd=FACEFUSION_DIR, timeout=120
-        )
-        if result.returncode == 0:
-            logger.info("✅ Models pre-downloaded")
-        else:
-            logger.warning(f"⚠️ Pre-download warning: {result.stderr[-200:]}")
-    except Exception as e:
-        logger.warning(f"⚠️ Could not pre-download models: {e}")
-    
-    logger.info("✅ API ready!")
+            shutil.rmtree(temp_dir, ignore_errors=True)
 
 if __name__ == "__main__":
     import uvicorn
-    # 🔥 Запуск на порту 7860 (требование HF Spaces)
-    uvicorn.run(
-        app,
-        host="0.0.0.0",
-        port=7860,
-        log_level="info",
-        timeout_keep_alive=300  # 5 минут keep-alive для долгих запросов
-    )
+    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info", timeout_keep_alive=300)