Upload api.py

api.py

@@ -1,224 +1,226 @@
-from __future__ import annotations
-from fastapi import FastAPI, UploadFile, File, Form, BackgroundTasks, HTTPException
-from fastapi.responses import JSONResponse, FileResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pathlib import Path
-import shutil
-import uvicorn
-import json
-import uuid
-from datetime import datetime
-from typing import Dict
-from enum import Enum
-import os
-
-from video_processing import process_video_pipeline
-from casting_loader import ensure_chroma, build_faces_index, build_voices_index
-from narration_system import NarrationSystem
-from llm_router import load_yaml, LLMRouter
-from character_detection import detect_characters_from_video
-
-app = FastAPI(title="Veureu Engine API", version="0.2.0")
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-ROOT = Path("/tmp/veureu")
-ROOT.mkdir(parents=True, exist_ok=True)
-TEMP_ROOT = Path("/tmp/temp")
-TEMP_ROOT.mkdir(parents=True, exist_ok=True)
-VIDEOS_ROOT = Path("/tmp/data/videos")
-VIDEOS_ROOT.mkdir(parents=True, exist_ok=True)
-
-# Sistema de jobs asíncronos
-class JobStatus(str, Enum):
-    QUEUED = "queued"
-    PROCESSING = "processing"
-    DONE = "done"
-    FAILED = "failed"
-
-jobs: Dict[str, dict] = {}
-
-@app.get("/")
-def root():
-    return {"ok": True, "service": "veureu-engine"}
-
-@app.post("/process_video")
-async def process_video(
-    video_file: UploadFile = File(...),
-    config_path: str = Form("config.yaml"),
-    out_root: str = Form("results"),
-    db_dir: str = Form("chroma_db"),
-):
-    tmp_video = ROOT / video_file.filename
-    with tmp_video.open("wb") as f:
-        shutil.copyfileobj(video_file.file, f)
-    result = process_video_pipeline(str(tmp_video), config_path=config_path, out_root=out_root, db_dir=db_dir)
-    return JSONResponse(result)
-
-@app.post("/create_initial_casting")
-async def create_initial_casting(
-    background_tasks: BackgroundTasks,
-    video: UploadFile = File(...),
-    epsilon: float = Form(...),
-    min_cluster_size: int = Form(...),
-):
-    """
-    Crea un job para procesar el vídeo de forma asíncrona.
-    Devuelve un job_id inmediatamente.
-    """
-    # Guardar vídeo en carpeta de datos
-    video_name = Path(video.filename).stem
-    dst_video = VIDEOS_ROOT / f"{video_name}.mp4"
-    with dst_video.open("wb") as f:
-        shutil.copyfileobj(video.file, f)
-
-    # Crear job_id único
-    job_id = str(uuid.uuid4())
-    
-    # Inicializar el job
-    jobs[job_id] = {
-        "id": job_id,
-        "status": JobStatus.QUEUED,
-        "video_path": str(dst_video),
-        "video_name": video_name,
-        "epsilon": float(epsilon),
-        "min_cluster_size": int(min_cluster_size),
-        "created_at": datetime.now().isoformat(),
-        "results": None,
-        "error": None
-    }
-    
-    print(f"[{job_id}] Job creado para vídeo: {video_name}")
-    
-    # Iniciar procesamiento en background
-    background_tasks.add_task(process_video_job, job_id)
-    
-    # Devolver job_id inmediatamente
-    return {"job_id": job_id}
-
-@app.get("/jobs/{job_id}/status")
-def get_job_status(job_id: str):
-    """
-    Devuelve el estado actual de un job.
-    El UI hace polling de este endpoint cada 5 segundos.
-    """
-    if job_id not in jobs:
-        raise HTTPException(status_code=404, detail="Job not found")
-    
-    job = jobs[job_id]
-    
-    # Normalizar el estado a string
-    status_value = job["status"].value if isinstance(job["status"], JobStatus) else str(job["status"])
-    response = {"status": status_value}
-
-    # Incluir resultados si existen (evita condiciones de carrera)
-    if job.get("results") is not None:
-        response["results"] = job["results"]
-
-    # Incluir error si existe
-    if job.get("error"):
-        response["error"] = job["error"]
-    
-    return response
-
-@app.get("/files/{video_name}/{char_id}/{filename}")
-def serve_character_file(video_name: str, char_id: str, filename: str):
-    """
-    Sirve archivos estáticos de personajes (imágenes).
-    Ejemplo: /files/dif_catala_1/char1/representative.jpg
-    """
-    file_path = TEMP_ROOT / video_name / char_id / filename
-    
-    if not file_path.exists():
-        raise HTTPException(status_code=404, detail="File not found")
-    
-    return FileResponse(file_path)
-
-def process_video_job(job_id: str):
-    """
-    Procesa el vídeo de forma asíncrona.
-    Esta función se ejecuta en background.
-    """
-    try:
-        job = jobs[job_id]
-        print(f"[{job_id}] Iniciando procesamiento...")
-        
-        # Cambiar estado a processing
-        job["status"] = JobStatus.PROCESSING
-        
-        video_path = job["video_path"]
-        video_name = job["video_name"]
-        epsilon = job["epsilon"]
-        min_cluster_size = job["min_cluster_size"]
-        
-        # Crear estructura de carpetas
-        base = TEMP_ROOT / video_name
-        base.mkdir(parents=True, exist_ok=True)
-        
-        print(f"[{job_id}] Directorio base: {base}")
-        
-        # Detección real de personajes usando el código de Ana
-        try:
-            print(f"[{job_id}] Iniciando detección de personajes...")
-            result = detect_characters_from_video(
-                video_path=video_path,
-                output_base=str(base),
-                epsilon=epsilon,
-                min_cluster_size=min_cluster_size,
-                video_name=video_name
-            )
-            
-            print(f"[{job_id}] DEBUG - result completo: {result}")
-            
-            characters = result.get("characters", [])
-            analysis_path = result.get("analysis_path", "")
-            
-            print(f"[{job_id}] Personajes detectados: {len(characters)}")
-            for char in characters:
-                print(f"[{job_id}]   - {char['name']}: {char['num_faces']} caras")
-            
-            # Enriquecer info de personajes con listado real de imágenes disponibles
-            try:
-                import glob, os
-                for ch in characters:
-                    folder = ch.get("folder")
-                    face_files = []
-                    if folder and os.path.isdir(folder):
-                        # soportar patrones face_* y extensiones jpg/png
-                        patterns = ["face_*.jpg", "face_*.png"]
-                        files = []
-                        for pat in patterns:
-                            files.extend(glob.glob(os.path.join(folder, pat)))
-                        # si no hay face_*, tomar cualquier jpg/png para no dejar vacío
-                        if not files:
-                            files.extend(glob.glob(os.path.join(folder, "*.jpg")))
-                            files.extend(glob.glob(os.path.join(folder, "*.png")))
-                        # normalizar nombres de fichero relativos
-                        face_files = sorted({os.path.basename(p) for p in files})
-                        # Garantizar que representative.(jpg|png) esté el primero si existe
-                        for rep_name in ("representative.jpg", "representative.png"):
-                            rep_path = os.path.join(folder, rep_name)
-                            if os.path.exists(rep_path):
-                                if rep_name in face_files:
-                                    face_files.remove(rep_name)
-                                face_files.insert(0, rep_name)
-                    ch["face_files"] = face_files
-                    # Ajustar num_faces si hay discrepancia
-                    if face_files:
-                        ch["num_faces"] = len(face_files)
-            except Exception as _e:
-                print(f"[{job_id}] WARN - No se pudo enumerar face_files: {_e}")
-
-            # Guardar resultados primero y luego marcar como completado (evita carreras)
-            job["results"] = {
-                "characters": characters,
-                "num_characters": len(characters),
-                "analysis_path": analysis_path,
+from pipelines.audiodescription import generate as ad_generate
+
+from __future__ import annotations
+from fastapi import FastAPI, UploadFile, File, Form, BackgroundTasks, HTTPException
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pathlib import Path
+import shutil
+import uvicorn
+import json
+import uuid
+from datetime import datetime
+from typing import Dict
+from enum import Enum
+import os
+
+from video_processing import process_video_pipeline
+from casting_loader import ensure_chroma, build_faces_index, build_voices_index
+from narration_system import NarrationSystem
+from llm_router import load_yaml, LLMRouter
+from character_detection import detect_characters_from_video
+
+app = FastAPI(title="Veureu Engine API", version="0.2.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+ROOT = Path("/tmp/veureu")
+ROOT.mkdir(parents=True, exist_ok=True)
+TEMP_ROOT = Path("/tmp/temp")
+TEMP_ROOT.mkdir(parents=True, exist_ok=True)
+VIDEOS_ROOT = Path("/tmp/data/videos")
+VIDEOS_ROOT.mkdir(parents=True, exist_ok=True)
+
+# Sistema de jobs asíncronos
+class JobStatus(str, Enum):
+    QUEUED = "queued"
+    PROCESSING = "processing"
+    DONE = "done"
+    FAILED = "failed"
+
+jobs: Dict[str, dict] = {}
+
+@app.get("/")
+def root():
+    return {"ok": True, "service": "veureu-engine"}
+
+@app.post("/process_video")
+async def process_video(
+    video_file: UploadFile = File(...),
+    config_path: str = Form("config.yaml"),
+    out_root: str = Form("results"),
+    db_dir: str = Form("chroma_db"),
+):
+    tmp_video = ROOT / video_file.filename
+    with tmp_video.open("wb") as f:
+        shutil.copyfileobj(video_file.file, f)
+    result = process_video_pipeline(str(tmp_video), config_path=config_path, out_root=out_root, db_dir=db_dir)
+    return JSONResponse(result)
+
+@app.post("/create_initial_casting")
+async def create_initial_casting(
+    background_tasks: BackgroundTasks,
+    video: UploadFile = File(...),
+    epsilon: float = Form(...),
+    min_cluster_size: int = Form(...),
+):
+    """
+    Crea un job para procesar el vídeo de forma asíncrona.
+    Devuelve un job_id inmediatamente.
+    """
+    # Guardar vídeo en carpeta de datos
+    video_name = Path(video.filename).stem
+    dst_video = VIDEOS_ROOT / f"{video_name}.mp4"
+    with dst_video.open("wb") as f:
+        shutil.copyfileobj(video.file, f)
+
+    # Crear job_id único
+    job_id = str(uuid.uuid4())
+    
+    # Inicializar el job
+    jobs[job_id] = {
+        "id": job_id,
+        "status": JobStatus.QUEUED,
+        "video_path": str(dst_video),
+        "video_name": video_name,
+        "epsilon": float(epsilon),
+        "min_cluster_size": int(min_cluster_size),
+        "created_at": datetime.now().isoformat(),
+        "results": None,
+        "error": None
+    }
+    
+    print(f"[{job_id}] Job creado para vídeo: {video_name}")
+    
+    # Iniciar procesamiento en background
+    background_tasks.add_task(process_video_job, job_id)
+    
+    # Devolver job_id inmediatamente
+    return {"job_id": job_id}
+
+@app.get("/jobs/{job_id}/status")
+def get_job_status(job_id: str):
+    """
+    Devuelve el estado actual de un job.
+    El UI hace polling de este endpoint cada 5 segundos.
+    """
+    if job_id not in jobs:
+        raise HTTPException(status_code=404, detail="Job not found")
+    
+    job = jobs[job_id]
+    
+    # Normalizar el estado a string
+    status_value = job["status"].value if isinstance(job["status"], JobStatus) else str(job["status"])
+    response = {"status": status_value}
+
+    # Incluir resultados si existen (evita condiciones de carrera)
+    if job.get("results") is not None:
+        response["results"] = job["results"]
+
+    # Incluir error si existe
+    if job.get("error"):
+        response["error"] = job["error"]
+    
+    return response
+
+@app.get("/files/{video_name}/{char_id}/{filename}")
+def serve_character_file(video_name: str, char_id: str, filename: str):
+    """
+    Sirve archivos estáticos de personajes (imágenes).
+    Ejemplo: /files/dif_catala_1/char1/representative.jpg
+    """
+    file_path = TEMP_ROOT / video_name / char_id / filename
+    
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    return FileResponse(file_path)
+
+def process_video_job(job_id: str):
+    """
+    Procesa el vídeo de forma asíncrona.
+    Esta función se ejecuta en background.
+    """
+    try:
+        job = jobs[job_id]
+        print(f"[{job_id}] Iniciando procesamiento...")
+        
+        # Cambiar estado a processing
+        job["status"] = JobStatus.PROCESSING
+        
+        video_path = job["video_path"]
+        video_name = job["video_name"]
+        epsilon = job["epsilon"]
+        min_cluster_size = job["min_cluster_size"]
+        
+        # Crear estructura de carpetas
+        base = TEMP_ROOT / video_name
+        base.mkdir(parents=True, exist_ok=True)
+        
+        print(f"[{job_id}] Directorio base: {base}")
+        
+        # Detección real de personajes usando el código de Ana
+        try:
+            print(f"[{job_id}] Iniciando detección de personajes...")
+            result = detect_characters_from_video(
+                video_path=video_path,
+                output_base=str(base),
+                epsilon=epsilon,
+                min_cluster_size=min_cluster_size,
+                video_name=video_name
+            )
+            
+            print(f"[{job_id}] DEBUG - result completo: {result}")
+            
+            characters = result.get("characters", [])
+            analysis_path = result.get("analysis_path", "")
+            
+            print(f"[{job_id}] Personajes detectados: {len(characters)}")
+            for char in characters:
+                print(f"[{job_id}]   - {char['name']}: {char['num_faces']} caras")
+            
+            # Enriquecer info de personajes con listado real de imágenes disponibles
+            try:
+                import glob, os
+                for ch in characters:
+                    folder = ch.get("folder")
+                    face_files = []
+                    if folder and os.path.isdir(folder):
+                        # soportar patrones face_* y extensiones jpg/png
+                        patterns = ["face_*.jpg", "face_*.png"]
+                        files = []
+                        for pat in patterns:
+                            files.extend(glob.glob(os.path.join(folder, pat)))
+                        # si no hay face_*, tomar cualquier jpg/png para no dejar vacío
+                        if not files:
+                            files.extend(glob.glob(os.path.join(folder, "*.jpg")))
+                            files.extend(glob.glob(os.path.join(folder, "*.png")))
+                        # normalizar nombres de fichero relativos
+                        face_files = sorted({os.path.basename(p) for p in files})
+                        # Garantizar que representative.(jpg|png) esté el primero si existe
+                        for rep_name in ("representative.jpg", "representative.png"):
+                            rep_path = os.path.join(folder, rep_name)
+                            if os.path.exists(rep_path):
+                                if rep_name in face_files:
+                                    face_files.remove(rep_name)
+                                face_files.insert(0, rep_name)
+                    ch["face_files"] = face_files
+                    # Ajustar num_faces si hay discrepancia
+                    if face_files:
+                        ch["num_faces"] = len(face_files)
+            except Exception as _e:
+                print(f"[{job_id}] WARN - No se pudo enumerar face_files: {_e}")
+
+            # Guardar resultados primero y luego marcar como completado (evita carreras)
+            job["results"] = {
+                "characters": characters,
+                "num_characters": len(characters),
+                "analysis_path": analysis_path,
                 "base_dir": str(base)
             }
             job["status"] = JobStatus.DONE
@@ -257,6 +259,35 @@ def process_video_job(job_id: str):
         jobs[job_id]["status"] = JobStatus.FAILED
         jobs[job_id]["error"] = str(e)
 
+@app.post("/generate_audiodescription")
+async def generate_audiodescription(video: UploadFile = File(...)):
+    try:
+        import uuid
+        job_id = str(uuid.uuid4())
+        vid_name = video.filename or f"video_{job_id}.mp4"
+        base = BASE_TEMP_DIR / Path(vid_name).stem
+        base.mkdir(parents=True, exist_ok=True)
+        # Save temp mp4
+        video_path = base / vid_name
+        with open(video_path, "wb") as f:
+            f.write(await video.read())
+
+        # Run MVP pipeline
+        result = ad_generate(str(video_path), base)
+
+        return {
+            "status": "done",
+            "results": {
+                "une_srt": result.get("une_srt", ""),
+                "free_text": result.get("free_text", ""),
+                "artifacts": result.get("artifacts", {}),
+            },
+        }
+    except Exception as e:
+        import traceback
+        print(f"/generate_audiodescription error: {e}\n{traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=str(e))
+
 @app.post("/load_casting")
 async def load_casting(
     faces_dir: str = Form("identities/faces"),