Upload 3 files

api_client.py

@@ -0,0 +1,303 @@
+# api_client.py  (UI - Space "veureu")
+import os
+import requests
+import base64
+import zipfile
+import io
+from typing import Iterable, Dict, Any
+
+class APIClient:
+    """
+    Cliente para 'engine':
+      POST /jobs                       -> {"job_id": "..."}
+      GET  /jobs/{job_id}/status       -> {"status": "queued|processing|done|failed", ...}
+      GET  /jobs/{job_id}/result       -> JobResult {"book": {...}, "une": {...}, ...}
+    """
+    def __init__(self, base_url: str, use_mock: bool = False, data_dir: str | None = None, token: str | None = None, timeout: int = 180):
+        self.base_url = base_url.rstrip("/")
+        # La URL para el servicio TTS es la misma que la base_url para los Spaces de HF
+        self.tts_url = self.base_url
+        self.use_mock = use_mock
+        self.data_dir = data_dir
+        self.timeout = timeout
+        self.session = requests.Session()
+        # Permite inyectar el token del engine via secret/var en el Space UI
+        token = token or os.getenv("API_SHARED_TOKEN")
+        if token:
+            self.session.headers.update({"Authorization": f"Bearer {token}"})
+
+    # ---- modo real (engine) ----
+    def _post_jobs(self, video_path: str, modes: Iterable[str]) -> Dict[str, Any]:
+        url = f"{self.base_url}/jobs"
+        files = {"file": (os.path.basename(video_path), open(video_path, "rb"), "application/octet-stream")}
+        data = {"modes": ",".join(modes)}
+        r = self.session.post(url, files=files, data=data, timeout=self.timeout)
+        r.raise_for_status()
+        return r.json()  # {"job_id": ...}
+
+    def _get_status(self, job_id: str) -> Dict[str, Any]:
+        url = f"{self.base_url}/jobs/{job_id}/status"
+        r = self.session.get(url, timeout=self.timeout)
+        r.raise_for_status()
+        return r.json()
+
+    def _get_result(self, job_id: str) -> Dict[str, Any]:
+        url = f"{self.base_url}/jobs/{job_id}/result"
+        r = self.session.get(url, timeout=self.timeout)
+        r.raise_for_status()
+        return r.json()  # JobResult (book/une/... según engine)
+
+    # ---- API que usa streamlit_app.py ----
+    def process_video(self, video_path: str, modes: Iterable[str]) -> Dict[str, Any]:
+        """Devuelve {"job_id": "..."}"""
+        if self.use_mock:
+            return {"job_id": "mock-123"}
+        return self._post_jobs(video_path, modes)
+
+    def get_job(self, job_id: str) -> Dict[str, Any]:
+        """
+        La UI espera algo del estilo:
+          {"status":"done","results":{"book":{...},"une":{...}}}
+        Adaptamos la respuesta de /result del engine a ese contrato.
+        """
+        if self.use_mock:
+            # resultado inmediato de prueba
+            return {
+                "status": "done",
+                "results": {
+                    "book": {"text": "Text d'exemple (book)", "mp3_bytes": b""},
+                    "une":  {"srt": "1\n00:00:00,000 --> 00:00:01,000\nExemple UNE\n", "mp3_bytes": b""},
+                }
+            }
+
+        # Opción 1: si quieres chequear estado primero
+        st = self._get_status(job_id)
+        if st.get("status") in {"queued", "processing"}:
+            return {"status": st.get("status", "queued")}
+
+        res = self._get_result(job_id)
+        # 'res' viene como JobResult del engine: {"book": {...}, "une": {...}, ...}
+        # La UI consume 'results' con claves "book"/"une"; si tus claves ya son iguales, pasa directo:
+        results = {}
+        if "book" in res:
+            results["book"] = {
+                "text": res["book"].get("text"),
+                # si sirves URLs en el engine, podrías mapear "book_mp3_url" a descarga directa;
+                # la UI actual espera "mp3_bytes" sólo en mock, así que lo dejamos fuera.
+            }
+        if "une" in res:
+            results["une"] = {
+                "srt": res["une"].get("srt"),
+            }
+        # Si res incluye "characters"/"metrics", la UI también los guarda:
+        for k in ("book", "une"):
+            if k in res:
+                if "characters" in res[k]:
+                    results[k]["characters"] = res[k]["characters"]
+                if "metrics" in res[k]:
+                    results[k]["metrics"] = res[k]["metrics"]
+
+        status = "done" if results else st.get("status", "unknown")
+        return {"status": status, "results": results}
+
+
+    def tts_matxa(self, text: str, voice: str = "central/grau") -> dict:
+        """
+        Llama al space 'tts' para sintetizar audio.
+
+        Args:
+            text (str): Texto a sintetizar.
+            voice (str): Voz de Matxa a usar (p.ej. 'central/alvocat').
+
+        Returns:
+            dict: {'mp3_data_url': 'data:audio/mpeg;base64,...'}
+        """
+        if not self.tts_url:
+            raise ValueError("La URL del servei TTS no està configurada (API_TTS_URL)")
+
+        url = f"{self.tts_url.rstrip('/')}/tts/text"
+        data = {
+            "texto": text,
+            "voice": voice,
+            "formato": "mp3"
+        }
+        
+        try:
+            r = requests.post(url, data=data, timeout=self.timeout)
+            r.raise_for_status()
+            
+            # Devolver los bytes directamente para que el cliente los pueda concatenar
+            return {"mp3_bytes": r.content}
+
+        except requests.exceptions.RequestException as e:
+            print(f"Error cridant a TTS: {e}")
+            # Devolvemos un diccionario con error para que la UI lo muestre
+            return {"error": str(e)}
+
+
+    def rebuild_video_with_ad(self, video_path: str, srt_path: str) -> dict:
+        """
+        Llama al space 'tts' para reconstruir un vídeo con audiodescripció a partir de un SRT.
+        El servidor devuelve un ZIP, y de ahí extraemos el MP4 final.
+        """
+        if not self.tts_url:
+            raise ValueError("La URL del servei TTS no està configurada (API_TTS_URL)")
+
+        url = f"{self.tts_url.rstrip('/')}/tts/srt"
+        
+        try:
+            files = {
+                'video': (os.path.basename(video_path), open(video_path, 'rb'), 'video/mp4'),
+                'srt': (os.path.basename(srt_path), open(srt_path, 'rb'), 'application/x-subrip')
+            }
+            data = {"include_final_mp4": 1}
+            
+            r = requests.post(url, files=files, data=data, timeout=self.timeout * 5)
+            r.raise_for_status()
+            
+            # El servidor devuelve un ZIP, lo procesamos en memoria
+            with zipfile.ZipFile(io.BytesIO(r.content)) as z:
+                # Buscamos el archivo .mp4 dentro del ZIP
+                for filename in z.namelist():
+                    if filename.endswith('.mp4'):
+                        video_bytes = z.read(filename)
+                        return {"video_bytes": video_bytes}
+            
+            # Si no se encuentra el MP4 en el ZIP
+            return {"error": "No se encontró el archivo de vídeo MP4 en la respuesta del servidor."}
+
+        except requests.exceptions.RequestException as e:
+            print(f"Error cridant a la reconstrucció de vídeo: {e}")
+            return {"error": str(e)}
+        except zipfile.BadZipFile:
+            return {"error": "La respuesta del servidor no fue un archivo ZIP válido."}
+
+
+    def create_initial_casting(self, video_path: str = None, video_bytes: bytes = None, video_name: str = None, epsilon: float = 0.5, min_cluster_size: int = 2) -> dict:
+        """
+        Llama al endpoint del space 'engine' para crear el 'initial casting'.
+
+        Envía el vídeo recién importado como archivo y los parámetros de clustering.
+        
+        Args:
+            video_path: Path to video file (if reading from disk)
+            video_bytes: Video file bytes (if already in memory)
+            video_name: Name for the video file
+            epsilon: Clustering epsilon parameter
+            min_cluster_size: Minimum cluster size parameter
+        """
+        url = f"{self.base_url}/create_initial_casting"
+        try:
+            # Prepare file data
+            if video_bytes:
+                filename = video_name or "video.mp4"
+                files = {
+                    "video": (filename, video_bytes, "video/mp4"),
+                }
+            elif video_path:
+                with open(video_path, "rb") as f:
+                    files = {
+                        "video": (os.path.basename(video_path), f.read(), "video/mp4"),
+                    }
+            else:
+                return {"error": "Either video_path or video_bytes must be provided"}
+            
+            data = {
+                "epsilon": str(epsilon),
+                "min_cluster_size": str(min_cluster_size),
+            }
+            r = self.session.post(url, files=files, data=data, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return r.json() if r.headers.get("content-type", "").startswith("application/json") else {"ok": True}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+        except Exception as e:
+            return {"error": f"Unexpected error: {str(e)}"}
+
+    def generate_audio_from_text_file(self, text_content: str, voice: str = "central/grau") -> dict:
+        """
+        Genera un único MP3 a partir de un texto largo, usando el endpoint de SRT.
+        1. Convierte el texto en un SRT falso.
+        2. Llama a /tts/srt con el SRT.
+        3. Extrae el 'ad_master.mp3' del ZIP resultante.
+        """
+        if not self.tts_url:
+            raise ValueError("La URL del servei TTS no està configurada (API_TTS_URL)")
+
+        # 1. Crear un SRT falso en memoria
+        srt_content = ""
+        start_time = 0
+        for i, line in enumerate(text_content.strip().split('\n')):
+            line = line.strip()
+            if not line:
+                continue
+            # Asignar 5 segundos por línea, un valor simple
+            end_time = start_time + 5
+            
+            def format_time(seconds):
+                h = int(seconds / 3600)
+                m = int((seconds % 3600) / 60)
+                s = int(seconds % 60)
+                ms = int((seconds - int(seconds)) * 1000)
+                return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
+
+            srt_content += f"{i+1}\n"
+            srt_content += f"{format_time(start_time)} --> {format_time(end_time)}\n"
+            srt_content += f"{line}\n\n"
+            start_time = end_time
+
+        if not srt_content:
+            return {"error": "El texto proporcionado estaba vacío o no se pudo procesar."}
+
+        # 2. Llamar al endpoint /tts/srt
+        url = f"{self.tts_url.rstrip('/')}/tts/srt"
+        try:
+            files = {
+                'srt': ('fake_ad.srt', srt_content, 'application/x-subrip')
+            }
+            data = {"voice": voice, "ad_format": "mp3"}
+            
+            r = requests.post(url, files=files, data=data, timeout=self.timeout * 5)
+            r.raise_for_status()
+
+            # 3. Extraer 'ad_master.mp3' del ZIP
+            with zipfile.ZipFile(io.BytesIO(r.content)) as z:
+                for filename in z.namelist():
+                    if filename == 'ad_master.mp3':
+                        mp3_bytes = z.read(filename)
+                        return {"mp3_bytes": mp3_bytes}
+            
+            return {"error": "No se encontró 'ad_master.mp3' en la respuesta del servidor."}
+
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Error llamando a la API de SRT: {e}"}
+        except zipfile.BadZipFile:
+            return {"error": "La respuesta del servidor no fue un archivo ZIP válido."}
+
+
+    def tts_long_text(self, text: str, voice: str = "central/grau") -> dict:
+        """
+        Llama al endpoint '/tts/text_long' para sintetizar un texto largo.
+        La API se encarga de todo el procesamiento.
+        """
+        if not self.tts_url:
+            raise ValueError("La URL del servei TTS no està configurada (API_TTS_URL)")
+
+        url = f"{self.tts_url.rstrip('/')}/tts/text_long"
+        data = {
+            "texto": text,
+            "voice": voice,
+            "formato": "mp3"
+        }
+        
+        try:
+            # Usamos un timeout más largo por si el texto es muy extenso
+            r = requests.post(url, data=data, timeout=self.timeout * 10)
+            r.raise_for_status()
+            return {"mp3_bytes": r.content}
+
+        except requests.exceptions.RequestException as e:
+            print(f"Error cridant a TTS per a text llarg: {e}")
+            return {"error": str(e)}
+
+

app.py

@@ -0,0 +1,705 @@
+import os
+import io
+import json
+import yaml
+import shutil
+import sqlite3
+import sys
+from pathlib import Path
+try:
+    import tomllib
+except ModuleNotFoundError:  # Py<3.11
+    import tomli as tomllib
+import streamlit as st
+# from moviepy.editor import VideoFileClip
+
+from database import set_db_path, init_schema, get_user, create_user, update_user_password, create_video, update_video_status, list_videos, get_video, get_all_users, upsert_result, get_results, add_feedback, get_feedback_for_video, get_feedback_stats
+from api_client import APIClient
+from utils import ensure_dirs, save_bytes, save_text, human_size, get_project_root
+
+from scripts.client_generate_av import generate_free_ad_mp3, generate_une_ad_video
+
+# --- Rutas y Configuración Inicial ---
+PROJECT_ROOT = get_project_root()
+
+# Copia de seguridad de la base de datos y vídeos a un directorio escribible en HF Spaces
+if os.getenv("SPACE_ID") is not None:
+    os.environ["STREAMLIT_DATA_DIRECTORY"] = "/tmp/.streamlit"
+    Path("/tmp/.streamlit").mkdir(parents=True, exist_ok=True)
+    
+    # Limpiar archivos temporales antiguos para evitar llenar el disco
+    import glob
+    import time
+    temp_files = glob.glob("/tmp/*")
+    current_time = time.time()
+    for f in temp_files:
+        try:
+            if os.path.isfile(f) and current_time - os.path.getmtime(f) > 3600:  # Archivos > 1 hora
+                os.remove(f)
+                print(f"Archivo temporal eliminado: {f}")
+        except Exception as e:
+            pass  # Ignorar errores de permisos
+
+
+    # static_videos = Path(__file__).parent / "videos"
+    # runtime_videos = PROJECT_ROOT / "videos"
+    # if not runtime_videos.exists():
+    #     shutil.copytree(static_videos, runtime_videos, dirs_exist_ok=True)
+
+# --- Config ---
+def _load_yaml(path="config.yaml") -> dict:
+    with open(path, "r", encoding="utf-8") as f:
+        cfg = yaml.safe_load(f) or {}
+    # interpolación sencilla de ${VARS} si las usas en el YAML
+    def _subst(s: str) -> str:
+        return os.path.expandvars(s) if isinstance(s, str) else s
+
+    # aplica sustitución en los campos que te interesan
+    if "api" in cfg:
+        cfg["api"]["base_url"] = _subst(cfg["api"].get("base_url", ""))
+        cfg["api"]["token"]    = _subst(cfg["api"].get("token", ""))
+
+    if "storage" in cfg and "root_dir" in cfg["storage"]:
+        cfg["storage"]["root_dir"] = _subst(cfg["storage"]["root_dir"])
+
+    if "sqlite" in cfg and "path" in cfg["sqlite"]:
+        cfg["sqlite"]["path"] = _subst(cfg["sqlite"]["path"])
+
+    return cfg
+
+CFG = _load_yaml("config.yaml")
+
+# Ajuste de variables según tu esquema YAML
+DATA_DIR = CFG.get("storage", {}).get("root_dir", "data")
+BACKEND_BASE_URL = CFG.get("api", {}).get("base_url", "http://localhost:8000")
+USE_MOCK = bool(CFG.get("app", {}).get("use_mock", False))  # si no la tienes en el yaml, queda False
+API_TOKEN = CFG.get("api", {}).get("token") or os.getenv("API_SHARED_TOKEN")
+
+os.makedirs(DATA_DIR, exist_ok=True)
+ensure_dirs(DATA_DIR)
+DB_PATH = os.path.join(DATA_DIR, "app.db")
+set_db_path(DB_PATH)
+
+
+init_schema()
+
+# --- Helper de logging ---
+def log(msg):
+    """Helper para escribir logs que aparezcan en el container de HF Spaces"""
+    sys.stderr.write(f"{msg}\n")
+    sys.stderr.flush()
+
+def create_default_users_if_needed():
+    """Asegura que existan los usuarios por defecto y sus contraseñas esperadas (texto plano)."""
+    log("Sincronizando usuarios por defecto...")
+    users_to_create = [
+        ("verd", "verd123", "verd"),
+        ("groc", "groc123", "groc"),
+        ("taronja", "taronja123", "taronja"),
+        ("blau", "blau123", "blau"),
+    ]
+    for username, password, role in users_to_create:
+        try:
+            row = get_user(username)
+            if row:
+                update_user_password(username, password)
+                log(f"Usuario '{username}' actualizado (password reset).")
+            else:
+                create_user(username, password, role)
+                log(f"Usuario '{username}' creado.")
+        except Exception as e:
+            log(f"Error sincronizando usuario {username}: {e}")
+
+create_default_users_if_needed()
+
+# --- LOG DE DIAGNÓSTICO: COMPROBAR ESTADO DE LA BD ---
+
+log("\n--- DIAGNÓSTICO DE BASE DE DATOS ---")
+log(f"Ruta de la BD en uso: {DB_PATH}")
+try:
+    all_users = get_all_users()
+    if all_users:
+        log("Usuarios encontrados en la BD al arrancar:")
+        # Convertimos las filas a diccionarios para una mejor visualización
+        users_list = [dict(user) for user in all_users]
+        log(str(users_list))
+    else:
+        log("La tabla de usuarios está vacía.")
+except Exception as e:
+    log(f"Error al intentar leer los usuarios de la BD: {e}")
+log("--- FIN DIAGNÓSTICO ---\n")
+# --- FIN LOG DE DIAGNÓSTICO ---
+
+api = APIClient(BACKEND_BASE_URL, use_mock=USE_MOCK, data_dir=DATA_DIR, token=API_TOKEN)
+
+# Diagnóstico de configuración de API
+log(f"\n--- CONFIGURACIÓN DE API ---")
+log(f"BACKEND_BASE_URL: {BACKEND_BASE_URL}")
+log(f"API_TOKEN configurado: {'Sí' if API_TOKEN else 'No'}")
+log(f"USE_MOCK: {USE_MOCK}")
+log(f"--- FIN CONFIGURACIÓN ---\n")
+
+st.set_page_config(page_title="Veureu — Audiodescripció", page_icon="🎬", layout="wide")
+
+# Configurar Streamlit para aceptar archivos más grandes
+try:
+    import streamlit.web.server.server as server
+    # Aumentar el límite de tamaño de archivo
+    server.UPLOAD_FILE_SIZE_LIMIT = 50 * 1024 * 1024  # 50MB
+    log("Límite de subida configurado a 50MB en server")
+except Exception as e:
+    log(f"No se pudo configurar límite de subida en server: {e}")
+
+# Verificar configuración actual
+try:
+    import streamlit.config as st_config
+    max_upload = st_config.get_option("server.maxUploadSize")
+    log(f"Configuración actual maxUploadSize: {max_upload}MB")
+except Exception as e:
+    log(f"No se pudo leer configuración: {e}")
+
+# --- Session: auth ---
+# print("Usuarios disponibles:", get_all_users()) # Descomentar para depurar
+if "user" not in st.session_state:
+    st.session_state.user = None  # dict with {username, role, id(optional)}
+
+def require_login():
+    if not st.session_state.user:
+        st.info("Por favor, inicia sesión para continuar.")
+        login_form()
+        st.stop()
+
+def verify_password(password: str, stored_password: str) -> bool:
+    """Verifica la contraseña como texto plano."""
+    return password == stored_password
+        
+# --- Sidebar (only after login) ---
+role = st.session_state.user["role"] if st.session_state.user else None
+with st.sidebar:
+    st.title("Veureu")
+    if st.session_state.user:
+        st.write(f"Usuari: **{st.session_state.user['username']}** (rol: {st.session_state.user['role']})")
+        if st.button("Tancar sessió"):
+            st.session_state.user = None
+            st.rerun()
+    if st.session_state.user:
+        page = st.radio("Navegació", ["Analitzar audio-descripcions","Processar vídeo nou","Estadístiques"], index=0)
+        log(f"Página seleccionada: {page}")
+    else:
+        page = None
+
+# --- Pre-login screen ---
+if not st.session_state.user:
+    st.title("Veureu — Audiodescripció")
+    def login_form():
+        st.subheader("Inici de sessió")
+        username = st.text_input("Usuari")
+        password = st.text_input("Contrasenya", type="password")
+        if st.button("Entrar", type="primary"):
+            row = get_user(username)
+
+            # --- LOGS DE DEPURACIÓN ---
+            log("\n--- INTENTO DE LOGIN ---")
+            log(f"Usuario introducido: '{username}'")
+            # No mostramos la contraseña por seguridad, pero confirmamos que no está vacía
+            log(f"Contraseña introducida: {'Sí' if password else 'No'}")
+
+            if row:
+                log(f"Usuario encontrado en BD: '{row['username']}'")
+                stored_pw = (row["password_hash"] or "")
+                log(f"Password almacenado (longitud): {len(stored_pw)}")
+                is_valid = verify_password(password, stored_pw)
+                log(f"Resultado de verify_password: {is_valid}")
+            else:
+                log("Usuario no encontrado en la BD.")
+                is_valid = False
+            
+            log("--- FIN INTENTO DE LOGIN ---\n")
+            # --- FIN LOGS DE DEPURACIÓN ---
+
+            if is_valid:
+                st.session_state.user = {"id": row["id"], "username": row["username"], "role": row["role"]}
+                st.success(f"Benvingut/da, {row['username']}")
+                st.rerun()
+            else:
+                st.error("Credencials invàlides")
+    login_form()
+    st.stop()
+
+# --- Pages ---
+if page == "Processar vídeo nou":
+    log("\n=== ACCESO A PÁGINA 'Processar vídeo nou' ===")
+    require_login()
+    if role != "verd":
+        log("ERROR: Usuario sin permisos para procesar vídeos")
+        st.error("No tens permisos per processar nous vídeos. Canvia d'usuari o sol·licita permisos.")
+        st.stop()
+
+    log("Usuario autorizado, mostrando interfaz de subida")
+    st.header("Processar un nou clip de vídeo")
+
+    # Inicializar el estado de la página si no existe
+    if 'video_uploaded' not in st.session_state:
+        st.session_state.video_uploaded = None
+        log("Estado 'video_uploaded' inicializado")
+    if 'characters_detected' not in st.session_state:
+        st.session_state.characters_detected = None
+        log("Estado 'characters_detected' inicializado")
+    if 'characters_saved' not in st.session_state:
+        st.session_state.characters_saved = False
+        log("Estado 'characters_saved' inicializado")
+
+    # --- 1. Subida del vídeo ---
+    MAX_SIZE_MB = 10  # Reducido a 10MB para evitar llenar el disco en HF Spaces
+    MAX_DURATION_S = 120  # Reducido a 2 minutos
+
+    log("Mostrando widget de subida de archivo...")
+    
+    # Verificar configuración de Streamlit
+    import streamlit.config as st_config
+    try:
+        max_size = st_config.get_option("server.maxUploadSize")
+        log(f"Configuración maxUploadSize: {max_size}MB")
+    except Exception as e:
+        log(f"No se pudo leer maxUploadSize: {e}")
+    
+    uploaded_file = st.file_uploader(
+        "Puja un clip de vídeo (MP4, < 10MB, < 2 minuts)", 
+        type=["mp4"], 
+        key="video_uploader",
+        help="Selecciona un archivo MP4 de tu dispositivo. Máximo 10MB."
+    )
+    log(f"Widget renderizado. Archivo subido: {uploaded_file is not None}")
+    
+    # Debug: Mostrar información del archivo si existe
+    if uploaded_file is not None:
+        log(f"¡ARCHIVO DETECTADO! Nombre: {uploaded_file.name}, Tamaño: {uploaded_file.size}")
+    else:
+        log("No hay archivo subido todavía")
+        # Mostrar mensaje de ayuda en la interfaz
+        st.info("ℹ️ **Instrucciones:**\n1. Haz clic en 'Browse files'\n2. Selecciona un archivo MP4 (< 10MB)\n3. Espera a que se cargue (puede tardar unos segundos)")
+        st.warning("⚠️ **Nota**: Si el archivo no se detecta después de seleccionarlo, puede haber un problema con la configuración de Hugging Face Spaces.")
+
+    # Mostrar estado de depuración solo si no hay archivo o si hay un problema
+    if uploaded_file is None and st.session_state.video_uploaded is None:
+        with st.expander("🔍 Debug Info", expanded=False):
+            st.write(f"**Archivo subido:** {uploaded_file is not None}")
+            st.info("ℹ️ No se ha seleccionado ningún archivo todavía")
+            st.write(f"**Estado video_uploaded:** {st.session_state.video_uploaded}")
+    
+    if uploaded_file is not None:
+        log(f"\n--- SUBIDA DE VÍDEO INICIADA (archivo detectado) ---")
+        log(f"Nombre del archivo: {uploaded_file.name}")
+        log(f"Tamaño del archivo: {uploaded_file.size} bytes ({uploaded_file.size / (1024*1024):.2f} MB)")
+        log(f"Tipo MIME: {uploaded_file.type}")
+        
+        # Resetear el estado si se sube un nuevo archivo
+        if st.session_state.video_uploaded is None or uploaded_file.name != st.session_state.video_uploaded.get('original_name'):
+            log(f"Nuevo archivo detectado, reseteando estado...")
+            st.session_state.video_uploaded = {'original_name': uploaded_file.name, 'status': 'validating'}
+            st.session_state.characters_detected = None
+            st.session_state.characters_saved = False
+
+        # --- Validación y Procesamiento ---
+        if st.session_state.video_uploaded['status'] == 'validating':
+            log(f"Validando archivo...")
+            is_valid = True
+            error_messages = []
+            
+            # 1. Validar tamaño
+            if uploaded_file.size > MAX_SIZE_MB * 1024 * 1024:
+                error_msg = f"El vídeo supera el límit de {MAX_SIZE_MB}MB. Tamaño actual: {uploaded_file.size / (1024*1024):.2f}MB"
+                log(f"ERROR: {error_msg}")
+                st.error(error_msg)
+                st.warning("💡 **Consejo**: Reduce el tamaño del vídeo o usa un clip más corto.")
+                error_messages.append(error_msg)
+                is_valid = False
+            else:
+                log(f"✓ Tamaño válido: {uploaded_file.size / (1024*1024):.2f} MB")
+            
+            # 2. Validar que el archivo no esté vacío
+            if uploaded_file.size == 0:
+                error_msg = "El archivo está vacío."
+                log(f"ERROR: {error_msg}")
+                st.error(error_msg)
+                error_messages.append(error_msg)
+                is_valid = False
+
+            if is_valid:
+                try:
+                    with st.spinner("Processant el vídeo..."):
+                        log("Leyendo bytes del archivo...")
+                        # Guardar el buffer en memoria para enviarlo al engine
+                        video_bytes = uploaded_file.getbuffer().tobytes()
+                        log(f"✓ Bytes leídos correctamente: {len(video_bytes)} bytes")
+                        
+                        video_name = Path(uploaded_file.name).stem
+                        log(f"Nombre del vídeo (sin extensión): {video_name}")
+                        
+                        # Actualizar estado con los bytes del video
+                        st.session_state.video_uploaded.update({
+                            'status': 'processed',
+                            'video_bytes': video_bytes,
+                            'video_name': f"{video_name}.mp4",
+                            'was_truncated': False
+                        })
+                        log(f"✓ Estado actualizado correctamente")
+                        log(f"--- FIN SUBIDA DE VÍDEO (ÉXITO) ---\n")
+                        st.rerun()
+                except Exception as e:
+                    error_msg = f"Error al procesar el vídeo: {str(e)}"
+                    log(f"ERROR CRÍTICO: {error_msg}")
+                    log(f"Tipo de error: {type(e).__name__}")
+                    import traceback
+                    log(f"Traceback completo:\n{traceback.format_exc()}")
+                    log(f"--- FIN SUBIDA DE VÍDEO (ERROR) ---\n")
+                    st.error(error_msg)
+                    st.session_state.video_uploaded = None
+            else:
+                log(f"Validación fallida. Errores: {error_messages}")
+                log(f"--- FIN SUBIDA DE VÍDEO (VALIDACIÓN FALLIDA) ---\n")
+                st.session_state.video_uploaded = None
+
+    # --- Mensajes de estado ---
+    if st.session_state.video_uploaded and st.session_state.video_uploaded['status'] == 'processed':
+        st.success(f"✅ Vídeo '{st.session_state.video_uploaded['original_name']}' pujat i processat correctament.")
+        
+        # Mostrar info del vídeo procesado
+        with st.expander("📊 Informació del vídeo", expanded=False):
+            st.write(f"**Nombre:** {st.session_state.video_uploaded['original_name']}")
+            st.write(f"**Tamaño:** {len(st.session_state.video_uploaded.get('video_bytes', [])) / (1024*1024):.2f} MB")
+            st.write(f"**Estado:** Processat i llest per detectar personatges")
+        
+        if st.session_state.video_uploaded['was_truncated']:
+            st.warning(f"El vídeo s'ha truncat a {MAX_DURATION_S // 60} minuts.")
+
+    # --- 2. Detección de personajes ---
+    st.markdown("---")
+    col1, col2 = st.columns([1, 3])
+    # Sliders a la derecha del botón
+    with col2:
+        epsilon = st.slider("sensibitivity (épsilon)", 0.0, 2.0, 0.5, 0.1, key="epsilon_slider")
+        min_cluster_size = st.slider("mínimum cluster size", 1, 5, 2, 1, key="min_cluster_slider")
+    # Botón a la izquierda
+    with col1:
+        detect_button_disabled = st.session_state.video_uploaded is None
+        if st.button("Detectar Personatges", disabled=detect_button_disabled):
+            log(f"\n--- DETECCIÓN DE PERSONAJES INICIADA ---")
+            log(f"Estado del vídeo: {st.session_state.video_uploaded}")
+            
+            with st.spinner("Detectant personatges..."):
+                # Llamar al endpoint del engine para crear el casting inicial
+                try:
+                    video_bytes = st.session_state.video_uploaded.get('video_bytes') if st.session_state.video_uploaded else None
+                    video_name = st.session_state.video_uploaded.get('video_name') if st.session_state.video_uploaded else None
+                    
+                    # NO logear los bytes del vídeo (son binarios y ensucian el log)
+                    log(f"Video bytes disponibles: {len(video_bytes) if video_bytes else 0} bytes")
+                    log(f"Nombre del vídeo: {video_name}")
+                    
+                    if not video_bytes:
+                        error_msg = "No s'ha trobat el vídeo pujat en memòria."
+                        log(f"ERROR: {error_msg}")
+                        st.error(error_msg)
+                    else:
+                        # Verificar configuración antes de llamar
+                        log(f"BACKEND_BASE_URL: {BACKEND_BASE_URL}")
+                        log(f"API_TOKEN configurado: {'Sí' if API_TOKEN else 'No'}")
+                        
+                        if BACKEND_BASE_URL == "http://localhost:8000" or not BACKEND_BASE_URL:
+                            error_msg = "⚠️ **Error de configuració**: La URL del servei 'engine' no està configurada correctament."
+                            log(f"ERROR: {error_msg}")
+                            st.error(error_msg)
+                            st.info(f"URL actual: `{BACKEND_BASE_URL}`\n\nConfigura la variable d'entorn `API_BASE_URL` amb la URL pública del Space 'engine'.")
+                        else:
+                            log(f"Llamando a create_initial_casting...")
+                            log(f"Parámetros: epsilon={st.session_state.get('epsilon_slider', epsilon)}, min_cluster_size={int(st.session_state.get('min_cluster_slider', min_cluster_size))}")
+                            
+                            resp = api.create_initial_casting(
+                                video_bytes=video_bytes,
+                                video_name=video_name,
+                                epsilon=st.session_state.get("epsilon_slider", epsilon),
+                                min_cluster_size=int(st.session_state.get("min_cluster_slider", min_cluster_size)),
+                            )
+                            
+                            log(f"Respuesta recibida: {resp}")
+                            
+                            if isinstance(resp, dict) and resp.get("error"):
+                                error_msg = resp['error']
+                                log(f"ERROR en la respuesta: {error_msg}")
+                                st.error(f"❌ **Error en 'create_initial_casting'**: {error_msg}")
+                                if "403" in error_msg or "Forbidden" in error_msg:
+                                    st.warning("**Possible causes:**\n- El Space 'engine' no està accessible públicament\n- El token d'API no és correcte\n- CORS bloquejat")
+                                elif "Connection" in error_msg or "timeout" in error_msg:
+                                    st.warning(f"**No s'ha pogut connectar** amb el servei engine a: `{BACKEND_BASE_URL}`")
+                            else:
+                                log(f"✓ Casting inicial creado con éxito")
+                                st.success("✅ Casting inicial creat. S'han generat subcarpetes a 'temp/<uploaded-video>/*'.")
+                except Exception as e:
+                    error_msg = f"❌ Error inesperat: {e}"
+                    log(f"ERROR CRÍTICO: {error_msg}")
+                    log(f"Tipo de error: {type(e).__name__}")
+                    import traceback
+                    log(f"Traceback completo:\n{traceback.format_exc()}")
+                    st.error(error_msg)
+                finally:
+                    log(f"--- FIN DETECCIÓN DE PERSONAJES ---\n")
+                    
+                # Datos de ejemplo para mostrar UI (mientras no tengamos retorno estructurado)
+                # NOTA: Comentado temporalmente porque placeholder.png no existe
+                # st.session_state.characters_detected = [
+                #     {"id": "char1", "image_path": "init_data/placeholder.png", "description": "Dona amb cabell ros i ulleres"},
+                #     {"id": "char2", "image_path": "init_data/placeholder.png", "description": "Home amb barba i barret"},
+                # ]
+                # st.session_state.characters_saved = False
+
+    # --- 3. Formularios de personajes ---
+    if st.session_state.characters_detected:
+        st.subheader("Personatges detectats")
+        for char in st.session_state.characters_detected:
+            with st.form(key=f"form_{char['id']}"):
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.image(char['image_path'], width=150)
+                
+                with col2:
+                    st.caption(char['description'])
+                    st.text_input("Nom del personatge", key=f"name_{char['id']}")
+                    st.form_submit_button("Cercar")
+        
+        st.markdown("---_**")
+
+        # --- 4. Guardar y Generar ---
+        col1, col2, col3 = st.columns([1,1,2])
+        with col1:
+            if st.button("Desar", type="primary"):
+                # Aquí iría la lógica para guardar los nombres de los personajes
+                st.session_state.characters_saved = True
+                st.success("Personatges desats correctament.")
+
+        with col2:
+            if st.session_state.characters_saved:
+                st.button("Generar Audiodescripció")
+
+elif page == "Analitzar audio-descripcions":
+    require_login()
+    st.header("Analitzar audio-descripcions")
+    
+    # En HF Spaces, los videos están en el repo (read-only), no en /tmp/data
+    if os.getenv("SPACE_ID") is not None:
+        base_dir = Path(__file__).resolve().parent / "videos"
+    else:
+        base_dir = PROJECT_ROOT / "videos"
+
+    if not base_dir.exists():
+        st.info("No s'ha trobat la carpeta **videos**. Crea-la i afegeix-hi subcarpetes amb els teus vídeos.")
+        st.stop()
+
+    carpetes = [p.name for p in sorted(base_dir.iterdir()) if p.is_dir() and p.name != 'completed']
+    if not carpetes:
+        st.info("No s'ha trobat la carpeta **videos**. Crea-la i afegeix-hi subcarpetes amb els teus vídeos.")
+        st.stop()
+
+    # --- Lógica de Estado y Selección ---
+
+    # Detectar si el vídeo principal ha cambiado para resetear el estado secundario
+    if 'current_video' not in st.session_state:
+        st.session_state.current_video = None
+
+    # Widget de selección de vídeo
+    seleccio = st.selectbox("Selecciona un vídeo (carpeta):", carpetes, index=None, placeholder="Tria una carpeta…")
+
+    if seleccio != st.session_state.current_video:
+        st.session_state.current_video = seleccio
+        # Forzar reseteo de los widgets dependientes
+        # No establecemos a None, dejamos que el widget se inicialice
+        st.session_state.add_ad_checkbox = False
+        if 'version_selector' in st.session_state:
+            del st.session_state['version_selector'] # Forzar reinicio completo del widget
+        st.rerun()
+
+    if not seleccio:
+        st.stop()
+
+    vid_dir = base_dir / seleccio
+    mp4s = sorted(vid_dir.glob("*.mp4"))
+
+    # --- Dibujado de la Interfaz ---
+    col_video, col_txt = st.columns([2, 1], gap="large")
+
+    with col_video:
+        # Selección de versión
+        subcarpetas_ad = [p.name for p in sorted(vid_dir.iterdir()) if p.is_dir()]
+        default_index_sub = subcarpetas_ad.index("Salamandra") if "Salamandra" in subcarpetas_ad else 0
+        subcarpeta_seleccio = st.selectbox(
+            "Selecciona una versió d'audiodescripció:", subcarpetas_ad,
+            index=default_index_sub if subcarpetas_ad and 'version_selector' not in st.session_state else 0,
+            placeholder="Tria una versió…" if subcarpetas_ad else "No hi ha versions",
+            key="version_selector"
+        )
+
+        # Lógica de vídeo AD
+        video_ad_path = vid_dir / subcarpeta_seleccio / "une_ad.mp4" if subcarpeta_seleccio else None
+        is_ad_video_available = video_ad_path is not None and video_ad_path.exists()
+
+        # Checkbox
+        add_ad_video = st.checkbox("Afegir audiodescripció", disabled=not is_ad_video_available, key="add_ad_checkbox")
+
+        # Decidir qué vídeo mostrar
+        video_to_show = None
+        if add_ad_video and is_ad_video_available:
+            video_to_show = video_ad_path
+        elif mp4s:
+            video_to_show = mp4s[0]
+
+        if video_to_show:
+            st.video(str(video_to_show))
+        else:
+            st.warning("No s'ha trobat cap fitxer **.mp4** a la carpeta seleccionada.")
+
+        st.markdown("---")
+
+        # Sección de ACCIONES
+        st.markdown("#### Accions")
+        c1, c2 = st.columns(2)
+        with c1:
+            if st.button("Reconstruir àudio amb narració lliure", use_container_width=True, key="rebuild_free_ad"):
+                if seleccio and subcarpeta_seleccio:
+                    with st.spinner("Generant àudio de la narració lliure..."):
+                        result = generate_free_ad_mp3(seleccio, subcarpeta_seleccio, api, PROJECT_ROOT)
+                        if result.get("status") == "success":
+                            st.success(f"Àudio generat amb èxit: {result.get('path')}")
+                        else:
+                            st.error(f"Error: {result.get('reason', 'Desconegut')}")
+                else:
+                    st.warning("Selecciona un vídeo i una versió.")
+
+        with c2:
+            if st.button("Reconstruir vídeo amb audiodescripció", use_container_width=True, key="rebuild_video_ad"):
+                if seleccio and subcarpeta_seleccio:
+                    with st.spinner("Reconstruint el vídeo... Aquesta operació pot trigar."):
+                        result = generate_une_ad_video(seleccio, subcarpeta_seleccio, api, PROJECT_ROOT)
+                        if result.get("status") == "success":
+                            st.success(f"Vídeo generat amb èxit: {result.get('path')}")
+                            st.info("Pots visualitzar-lo activant la casella 'Afegir audiodescripció'.")
+                        else:
+                            st.error(f"Error: {result.get('reason', 'Desconegut')}")
+                else:
+                    st.warning("Selecciona un vídeo i una versió.")
+
+
+    # --- Columna Derecha (Editor de texto y guardado) ---
+    with col_txt:
+        tipus_ad_options = ["narració lliure", "UNE-153010"]
+        tipus_ad_seleccio = st.selectbox("Fitxer d'audiodescripció a editar:", tipus_ad_options)
+        
+        ad_filename = "free_ad.txt" if tipus_ad_seleccio == "narració lliure" else "une_ad.srt"
+        
+        # Cargar el contenido del fichero seleccionado
+        text_content = ""
+        ad_path = None
+        if subcarpeta_seleccio:
+            ad_path = vid_dir / subcarpeta_seleccio / ad_filename
+            if ad_path.exists():
+                try:
+                    text_content = ad_path.read_text(encoding="utf-8")
+                except Exception:
+                    text_content = ad_path.read_text(errors="ignore")
+            else:
+                st.info(f"No s'ha trobat el fitxer **{ad_filename}**.")
+        else:
+            # Eliminada la nota de advertencia
+            pass
+
+        # Área de texto para edición
+        new_text = st.text_area(f"Contingut de {tipus_ad_seleccio}", value=text_content, height=500, key=f"editor_{seleccio}_{subcarpeta_seleccio}_{ad_filename}")
+
+        # Botón de guardado
+        if st.button("Desar canvis", use_container_width=True, type="primary"):
+            if ad_path:
+                try:
+                    save_text(ad_path, new_text)
+                    st.success(f"Fitxer **{ad_filename}** desat correctament.")
+                    # El st.rerun() ya se encarga de recargar el estado desde el fichero guardado.
+                    # La línea que modificaba el session_state directamente ha sido eliminada para evitar el error.
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"No s'ha pogut desar el fitxer: {e}")
+            else:
+                st.error("No s'ha seleccionat una ruta de fitxer vàlida per desar.")
+
+        # Controles de reproducción de narración
+        free_ad_mp3_path = vid_dir / subcarpeta_seleccio / "free_ad.mp3" if seleccio and subcarpeta_seleccio else None
+        can_play_free_ad = free_ad_mp3_path is not None and free_ad_mp3_path.exists()
+
+        if st.button("▶️ Reproduir narració lliure", use_container_width=True, disabled=not can_play_free_ad, key="play_button_editor"):
+            if can_play_free_ad:
+                st.audio(str(free_ad_mp3_path), format="audio/mp3")
+            else:
+                st.warning("No s'ha trobat el fitxer 'free_ad.mp3'. Reconstrueix l'àudio primer.")
+
+
+    st.markdown("---")
+    st.subheader("Avaluació de la qualitat de l'audiodescripció")
+
+    c1, c2, c3 = st.columns(3)
+    with c1:
+        transcripcio = st.slider("Transcripció", 1, 10, 7)
+        identificacio = st.slider("Identificació de personatges", 1, 10, 7)
+    with c2:
+        localitzacions = st.slider("Localitzacions", 1, 10, 7)
+        activitats = st.slider("Activitats", 1, 10, 7)
+    with c3:
+        narracions = st.slider("Narracions", 1, 10, 7)
+        expressivitat = st.slider("Expressivitat", 1, 10, 7)
+
+    comments = st.text_area("Comentaris (opcional)", placeholder="Escriu els teus comentaris lliures…", height=120)
+
+    role = st.session_state.user["role"]
+    can_rate = role in ("verd", "groc", "blau")
+
+    if not can_rate:
+        st.info("El teu rol no permet enviar valoracions.")
+    else:
+        if st.button("Enviar valoració", type="primary", use_container_width=True):
+            try:
+                add_feedback_ad(
+                    video_name=seleccio,
+                    user_id=st.session_state.user["id"],
+                    transcripcio=transcripcio,
+                    identificacio=identificacio,
+                    localitzacions=localitzacions,
+                    activitats=activitats,
+                    narracions=narracions,
+                    expressivitat=expressivitat,
+                    comments=comments or None
+                )
+                st.success("Gràcies! La teva valoració s'ha desat correctament.")
+            except Exception as e:
+                st.error(f"S'ha produït un error en desar la valoració: {e}")
+
+
+elif page == "Estadístiques":
+    require_login()
+    st.header("Estadístiques")
+
+    from database import get_feedback_ad_stats
+    stats = get_feedback_ad_stats()  # medias por vídeo + avg_global
+    if not stats:
+        st.caption("Encara no hi ha valoracions.")
+        st.stop()
+
+    import pandas as pd
+    df = pd.DataFrame(stats, columns=stats[0].keys())
+    ordre = st.radio("Ordre de rànquing", ["Descendent (millors primer)", "Ascendent (pitjors primer)"], horizontal=True)
+    if ordre.startswith("Asc"):
+        df = df.sort_values("avg_global", ascending=True)
+    else:
+        df = df.sort_values("avg_global", ascending=False)
+
+    st.subheader("Rànquing de vídeos")
+    st.dataframe(
+        df[["video_name","n","avg_global","avg_transcripcio","avg_identificacio","avg_localitzacions","avg_activitats","avg_narracions", "avg_expressivitat"]],
+        use_container_width=True
+    )
+

test_connection.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""
+Script de diagnóstico para verificar la conexión entre demo y engine
+"""
+import requests
+import os
+
+# Configura aquí la URL de tu Space engine
+ENGINE_URL = os.getenv("API_BASE_URL", "https://veureu-engine.hf.space")
+
+print("=" * 60)
+print("DIAGNÓSTICO DE CONEXIÓN: demo → engine")
+print("=" * 60)
+print(f"\n1. URL configurada: {ENGINE_URL}")
+
+# Test 1: Verificar que el endpoint raíz responde
+print("\n2. Probando endpoint raíz (GET /)...")
+try:
+    response = requests.get(f"{ENGINE_URL}/", timeout=10)
+    print(f"   ✅ Status: {response.status_code}")
+    print(f"   ✅ Respuesta: {response.json()}")
+except requests.exceptions.ConnectionError as e:
+    print(f"   ❌ Error de conexión: {e}")
+    print("   → El Space puede estar en modo 'sleeping' o la URL es incorrecta")
+except requests.exceptions.Timeout:
+    print(f"   ❌ Timeout: El servidor no respondió en 10 segundos")
+except Exception as e:
+    print(f"   ❌ Error: {e}")
+
+# Test 2: Verificar el endpoint /create_initial_casting
+print("\n3. Probando endpoint /create_initial_casting (POST)...")
+try:
+    # Crear un video de prueba muy pequeño (1 byte)
+    files = {
+        "video": ("test.mp4", b"x", "video/mp4"),
+    }
+    data = {
+        "epsilon": "0.5",
+        "min_cluster_size": "2",
+    }
+    response = requests.post(
+        f"{ENGINE_URL}/create_initial_casting",
+        files=files,
+        data=data,
+        timeout=30
+    )
+    print(f"   ✅ Status: {response.status_code}")
+    if response.status_code == 200:
+        print(f"   ✅ Respuesta: {response.json()}")
+    else:
+        print(f"   ⚠️  Respuesta: {response.text[:200]}")
+except requests.exceptions.HTTPError as e:
+    print(f"   ❌ Error HTTP {e.response.status_code}: {e.response.text[:200]}")
+    if e.response.status_code == 403:
+        print("   → Error 403: Verifica que el Space 'engine' sea público")
+        print("   → O configura API_SHARED_TOKEN con un token válido")
+    elif e.response.status_code == 422:
+        print("   → Error 422: Los parámetros no son válidos (esto es normal con video fake)")
+except Exception as e:
+    print(f"   ❌ Error: {e}")
+
+print("\n" + "=" * 60)
+print("RECOMENDACIONES:")
+print("=" * 60)
+print("1. Verifica que la URL sea exactamente tu Space engine en HF")
+print("2. Asegúrate de que el Space 'engine' esté en estado 'Running'")
+print("3. Si el Space está 'sleeping', abrelo en el navegador para activarlo")
+print("4. Verifica que ambos Spaces sean públicos (o configura token)")
+print("=" * 60)