Upload 8 files

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.11-slim
+
+# Paquetes básicos (ffmpeg si planeas procesar audio)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential ffmpeg curl git && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install -U pip && pip install -r requirements.txt
+
+COPY . .
+
+# Crea directorios de trabajo y datos
+RUN mkdir -p /app/data/uploads /app/data/results
+
+# Puerto dinámico de HF Spaces
+ENV PORT=7860
+
+# Arranque
+CMD ["bash", "-lc", "uvicorn api:app --host 0.0.0.0 --port ${PORT:-7860}"]

README.md

@@ -0,0 +1,10 @@
+---
+title: Veureu Engine
+emoji: 📉
+colorFrom: red
+colorTo: blue
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

api.py

@@ -0,0 +1,167 @@
+# api.py — versión corregida (orden de definición)
+
+import os
+import uuid
+from fastapi import FastAPI, UploadFile, File, Form, Depends, Header, HTTPException, APIRouter
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from typing import Optional
+from models_job import JobCreate, JobStatus, JobResult
+from queue_manager import job_store, job_queue, start_worker, UPLOAD_DIR
+from worker import process_job
+from pydantic import BaseModel
+import subprocess
+import tempfile
+import base64
+import requests
+
+API_SHARED_TOKEN = os.environ.get("API_SHARED_TOKEN")
+UI_SPACE_URL = os.environ.get("UI_SPACE_URL")  # ej: https://org-tu--ui--space.hf.space
+
+# ---------- Matxa - Alvocat (router) ----------
+router = APIRouter()
+
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+MATXA_TTS_URL = os.getenv("MATXA_TTS_URL", "").strip()
+INFERENCE_URL = "https://api-inference.huggingface.co/models/projecte-aina/matxa-alvocat"
+
+class TTSRequest(BaseModel):
+    text: str
+
+@router.post("/tts/matxa")
+def tts_matxa(req: TTSRequest):
+    text = (req.text or "").strip()
+    if not text:
+        raise HTTPException(status_code=400, detail="Empty text")
+
+    try:
+        if MATXA_TTS_URL:
+            headers = {}
+            if HF_TOKEN:
+                headers["Authorization"] = f"Bearer {HF_TOKEN}"
+            resp = requests.post(
+                MATXA_TTS_URL,
+                headers=headers,
+                json={"text": text},
+                timeout=60,
+            )
+            if resp.status_code != 200:
+                raise HTTPException(status_code=502, detail=f"Space TTS error: {resp.text}")
+
+            if resp.headers.get("content-type", "").startswith("audio/"):
+                audio_bytes = resp.content
+                b64 = base64.b64encode(audio_bytes).decode("utf-8")
+                return {"mp3_data_url": f"data:audio/mpeg;base64,{b64}"}
+            else:
+                data = resp.json()
+                if "audio" in data and isinstance(data["audio"], str) and data["audio"].startswith("data:audio"):
+                    return {"mp3_data_url": data["audio"]}
+                elif "audio_b64" in data:
+                    audio_bytes = base64.b64decode(data["audio_b64"])
+                    b64 = base64.b64encode(audio_bytes).decode("utf-8")
+                    return {"mp3_data_url": f"data:audio/mpeg;base64,{b64}"}
+                else:
+                    audio_bytes = data.get("bytes")
+                    if isinstance(audio_bytes, str):
+                        audio_bytes = base64.b64decode(audio_bytes)
+                    b64 = base64.b64encode(audio_bytes).decode("utf-8")
+                    return {"mp3_data_url": f"data:audio/mpeg;base64,{b64}"}
+
+        else:
+            if not HF_TOKEN:
+                raise HTTPException(status_code=500, detail="HF_TOKEN not set")
+            headers = {
+                "Authorization": f"Bearer {HF_TOKEN}",
+                "Accept": "audio/mpeg",
+            }
+            resp = requests.post(
+                INFERENCE_URL,
+                headers=headers,
+                json={"inputs": text},
+                timeout=60,
+            )
+            if resp.status_code != 200:
+                raise HTTPException(status_code=502, detail=f"Inference API error: {resp.text}")
+
+            audio_bytes = resp.content
+            b64 = base64.b64encode(audio_bytes).decode("utf-8")
+            return {"mp3_data_url": f"data:audio/mpeg;base64,{b64}"}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ---------- FastAPI app principal ----------
+app = FastAPI(title="Veureu AD – API Space")
+
+# CORS (restringe a tu UI Space si pasas UI_SPACE_URL)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[UI_SPACE_URL] if UI_SPACE_URL else ["*"],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Lanza el worker al arrancar
+start_worker(process_job)
+
+# -------- Auth sencilla por token compartido --------
+def check_auth(authorization: Optional[str] = Header(None)):
+    if not API_SHARED_TOKEN:
+        return True
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(401, "Missing token")
+    if authorization.split(" ", 1)[1] != API_SHARED_TOKEN:
+        raise HTTPException(403, "Invalid token")
+    return True
+
+# -------- Rutas "jobs" --------
+@app.get("/")
+def read_root():
+    return {"message": "Hello World"}
+
+@app.post("/jobs")
+async def create_job(
+    mode: str = Form(default="both"),
+    video_file: Optional[UploadFile] = File(default=None),
+    video_url: Optional[str] = Form(default=None),
+    _auth=Depends(check_auth),
+):
+    if not video_file and not video_url:
+        raise HTTPException(400, "Debe enviarse un 'video_file' o un 'video_url'.")
+    job_id = str(uuid.uuid4())
+    local_path = None
+    if video_file:
+        os.makedirs(UPLOAD_DIR, exist_ok=True)
+        save_path = os.path.join(UPLOAD_DIR, f"{job_id}_{video_file.filename}")
+        with open(save_path, "wb") as f:
+            f.write(await video_file.read())
+        local_path = save_path
+    st = JobStatus(job_id=job_id, status="queued", progress=0, message="En cola")
+    job_store.set_status(job_id, st)
+    job_queue.put({"job_id": job_id, "mode": mode, "local_path": local_path, "video_url": video_url})
+    return {"job_id": job_id}
+
+@app.get("/jobs/{job_id}/status", response_model=JobStatus)
+def get_status(job_id: str, _auth=Depends(check_auth)):
+    st = job_store.get_status(job_id)
+    if not st:
+        raise HTTPException(404, "Job no encontrado")
+    return st
+
+@app.get("/jobs/{job_id}/result", response_model=JobResult)
+def get_result(job_id: str, _auth=Depends(check_auth)):
+    res = job_store.get_result(job_id)
+    if not res:
+        st = job_store.get_status(job_id)
+        if st and st.status != "completed":
+            raise HTTPException(409, "El job no ha terminado")
+        raise HTTPException(404, "Resultado no encontrado")
+    return res
+
+# <<< AHORA SÍ >>>
+app.include_router(router)
+
+

config.example.yaml

@@ -0,0 +1,9 @@
+api:
+  cors_origin: "https://org-tu--ui--space.hf.space"
+worker:
+  tgi_base_url: ""
+  inference_endpoint_url: ""
+  inference_model_id: ""
+storage:
+  uploads_dir: "/app/data/uploads"
+  results_dir: "/app/data/results"

models_job.py

@@ -0,0 +1,31 @@
+# models_job.py
+from pydantic import BaseModel, Field, HttpUrl
+from typing import Optional, List, Dict, Any
+
+class JobCreate(BaseModel):
+    mode: str = Field(default="both", description="book|une|both")
+    video_url: Optional[str] = Field(default=None, description="URL/Ruta del vídeo si no se sube archivo")
+
+class CharacterItem(BaseModel):
+    name: str
+    screen_time_sec: float
+
+class Metrics(BaseModel):
+    wer: Optional[float] = None
+    der: Optional[float] = None
+    ux: Optional[float] = None
+
+class JobStatus(BaseModel):
+    job_id: str
+    status: str  # queued|processing|completed|failed
+    progress: int = 0
+    message: Optional[str] = None
+
+class JobResult(BaseModel):
+    job_id: str
+    source_filename: str
+    duration_sec: Optional[float] = None
+    characters: List[CharacterItem] = []
+    book: Optional[Dict[str, Any]] = None     # {text, mp3_url}
+    une: Optional[Dict[str, Any]] = None      # {srt, mp3_url}
+    metrics: Optional[Metrics] = None

queue_manager.py

@@ -0,0 +1,65 @@
+# queue_manager.py
+import os
+import threading
+import queue
+import time
+from typing import Dict, Any
+from models_job import JobStatus, JobResult
+
+UPLOAD_DIR = os.environ.get("UPLOAD_DIR", "/app/data/uploads")
+RESULTS_DIR = os.environ.get("RESULTS_DIR", "/app/data/results")
+
+class JobStore:
+    """
+    Almacena estados y resultados en memoria.
+    Para producción: sustituir por Redis / DB persistente si lo necesitas.
+    """
+    def __init__(self):
+        self.status: Dict[str, JobStatus] = {}
+        self.result: Dict[str, JobResult] = {}
+        self.lock = threading.Lock()
+
+    def set_status(self, job_id: str, status: JobStatus):
+        with self.lock:
+            self.status[job_id] = status
+
+    def get_status(self, job_id: str) -> JobStatus | None:
+        with self.lock:
+            return self.status.get(job_id)
+
+    def set_result(self, job_id: str, result: JobResult):
+        with self.lock:
+            self.result[job_id] = result
+
+    def get_result(self, job_id: str) -> JobResult | None:
+        with self.lock:
+            return self.result.get(job_id)
+
+job_store = JobStore()
+job_queue: "queue.Queue[Dict[str, Any]]" = queue.Queue()
+
+def worker_loop(process_fn):
+    while True:
+        job = job_queue.get()
+        if job is None:
+            break
+        try:
+            process_fn(job)
+        except Exception as e:
+            # Marca como failed
+            st = job_store.get_status(job["job_id"])
+            if st:
+                st.status = "failed"
+                st.message = f"Error: {e}"
+                st.progress = 0
+                job_store.set_status(job["job_id"], st)
+        finally:
+            job_queue.task_done()
+
+_worker_thread = None
+
+def start_worker(process_fn):
+    global _worker_thread
+    if _worker_thread is None or not _worker_thread.is_alive():
+        _worker_thread = threading.Thread(target=worker_loop, args=(process_fn,), daemon=True)
+        _worker_thread.start()

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+pydantic==2.9.2
+python-multipart==0.0.9
+requests==2.32.3
+huggingface_hub==0.25.2

worker.py

@@ -0,0 +1,133 @@
+# worker.py
+import os
+import time
+import uuid
+import requests
+from typing import Dict, Any, Optional
+from queue_manager import job_store, UPLOAD_DIR, RESULTS_DIR
+from models_job import JobStatus, JobResult, CharacterItem, Metrics
+
+HF_TOKEN = os.environ.get("HF_TOKEN")  # opcional
+TGI_BASE_URL = os.environ.get("TGI_BASE_URL")  # ej: https://org-tgi--space.hf.space
+INFERENCE_ENDPOINT_URL = os.environ.get("INFERENCE_ENDPOINT_URL")
+INFERENCE_MODEL_ID = os.environ.get("INFERENCE_MODEL_ID")  # p.ej. "meta-llama/Llama-3.1-8B-Instruct"
+
+def _auth_headers_json() -> Dict[str, str]:
+    headers = {"Content-Type": "application/json"}
+    if HF_TOKEN:
+        headers["Authorization"] = f"Bearer {HF_TOKEN}"
+    return headers
+
+def _call_tgi(prompt: str) -> str:
+    """
+    Ejemplo para TGI /v1/chat/completions (ajusta al formato de tu TGI).
+    """
+    if not TGI_BASE_URL:
+        # si no hay TGI configurado, devuelve texto de demo
+        return f"[DEMO] Respuesta generada para: {prompt[:60]}..."
+    url = f"{TGI_BASE_URL.rstrip('/')}/v1/chat/completions"
+    payload = {
+        "model": "tgi",  # no siempre necesario
+        "messages": [{"role": "user", "content": prompt}],
+        "max_tokens": 256
+    }
+    r = requests.post(url, headers=_auth_headers_json(), json=payload, timeout=120)
+    r.raise_for_status()
+    data = r.json()
+    # Ajusta según la respuesta de tu TGI
+    return data["choices"][0]["message"]["content"]
+
+def _call_inference_api(prompt: str) -> str:
+    """
+    Ejemplo para Inference API serverless.
+    """
+    if not INFERENCE_MODEL_ID:
+        return f"[DEMO] Inference API no configurado; prompt: {prompt[:60]}..."
+    url = f"https://api-inference.huggingface.co/models/{INFERENCE_MODEL_ID}"
+    r = requests.post(url, headers=_auth_headers_json(), json={"inputs": prompt, "parameters": {"max_new_tokens": 128}}, timeout=120)
+    r.raise_for_status()
+    out = r.json()
+    if isinstance(out, list) and out and "generated_text" in out[0]:
+        return out[0]["generated_text"]
+    return str(out)
+
+def _call_inference_endpoint(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Ejemplo para Inference Endpoint dedicado.
+    """
+    if not INFERENCE_ENDPOINT_URL:
+        return {"text": "[DEMO] Endpoint no configurado"}
+    r = requests.post(INFERENCE_ENDPOINT_URL, headers=_auth_headers_json(), json=payload, timeout=120)
+    r.raise_for_status()
+    return r.json()
+
+def _fake_extract_characters() -> list[CharacterItem]:
+    return [
+        CharacterItem(name="Alice", screen_time_sec=312.5),
+        CharacterItem(name="Bob", screen_time_sec=288.0),
+    ]
+
+def process_job(job: Dict[str, Any]):
+    """
+    job = {
+      "job_id": str,
+      "mode": "book"|"une"|"both",
+      "local_path": "/app/data/uploads/xxx.mp4"  (si es subida),
+      "video_url": "https://..."                (si es por URL)
+    }
+    """
+    job_id = job["job_id"]
+    mode = job.get("mode", "both")
+    src_filename = os.path.basename(job.get("local_path") or job.get("video_url") or f"{job_id}.mp4")
+
+    # Marca a processing
+    st = JobStatus(job_id=job_id, status="processing", progress=5, message="Iniciando procesamiento…")
+    job_store.set_status(job_id, st)
+
+    # (1) Descarga si viene por URL (demo omite; implementa si lo necesitas)
+    local_path = job.get("local_path")
+    if not local_path and job.get("video_url"):
+        # Aquí descargarías el vídeo a local_path
+        # local_path = os.path.join(UPLOAD_DIR, f"{job_id}_{src_filename}")
+        # requests.get(... stream ...) -> write file
+        pass
+
+    # (2) ASR / Diarización / Preparaciones etc. (simulación)
+    time.sleep(1)
+    st.progress = 20; st.message = "Extrayendo transcripción/diálogos…"; job_store.set_status(job_id, st)
+    # Aquí llamarías a tus pipelines reales (Whisper, diarización, etc.)
+
+    # (3) Generación “libro” con LLM (demo)
+    book_text = None; book_mp3_url = None
+    if mode in ("book","both"):
+        prompt = "Genera una audiodescripción tipo libro con diálogos condensados del vídeo."
+        book_text = _call_tgi(prompt) if TGI_BASE_URL else _call_inference_api(prompt)
+        # Si sintetizas audio, guarda mp3 y pon su URL accesible (por simplicidad omitimos)
+        book_mp3_url = None
+        st.progress = 60; st.message = "Generando texto Libro…"; job_store.set_status(job_id, st)
+
+    # (4) Generación UNE (SRT + audio) (demo)
+    une_srt = None; une_mp3_url = None
+    if mode in ("une","both"):
+        # Genera un SRT mínimo de ejemplo
+        une_srt = "1\n00:00:00,000 --> 00:00:03,000\n[Audiodescripción UNE de ejemplo]\n"
+        une_mp3_url = None
+        st.progress = 80; st.message = "Generando SRT UNE…"; job_store.set_status(job_id, st)
+
+    # (5) Personajes, métricas (demo)
+    chars = _fake_extract_characters()
+    metrics = Metrics(wer=0.07, der=0.12, ux=4.3)
+
+    time.sleep(1)
+    st.progress = 100; st.message = "Completado"; st.status = "completed"; job_store.set_status(job_id, st)
+
+    result = JobResult(
+        job_id=job_id,
+        source_filename=src_filename,
+        duration_sec=None,
+        characters=chars,
+        book={"text": book_text, "mp3_url": book_mp3_url} if book_text or book_mp3_url else None,
+        une={"srt": une_srt, "mp3_url": une_mp3_url} if une_srt or une_mp3_url else None,
+        metrics=metrics
+    )
+    job_store.set_result(job_id, result)