Upload 35 files

page_modules/analyze_audiodescriptions.py

@@ -47,6 +47,25 @@ def _load_labels_from_config() -> Dict[str, str]:
     }
 
 
+def _find_best_file_for_version(vid_dir: Path, version: str, filename: str) -> Optional[Path]:
+    """Busca un fitxer dins de temp/media/<sha1>/<version>/<subtype> amb prioritat.
+
+    Ordre de cerca de subtipus: "HITL OK" -> "HITL Test" -> "Original" -> arrel de <version>.
+    """
+
+    preferred_subtypes = ["HITL OK", "HITL Test", "Original"]
+    for subtype in preferred_subtypes:
+        candidate = vid_dir / version / subtype / filename
+        if candidate.exists():
+            return candidate
+
+    legacy = vid_dir / version / filename
+    if legacy.exists():
+        return legacy
+
+    return None
+
+
 def load_eval_values(vid_dir: Path, version: str, eval_content: Optional[str] = None) -> Optional[Dict[str, int]]:
     """Carga los valores de evaluación desde eval (DB o CSV) si existe.
     
@@ -587,18 +606,35 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
                 # Determinar versió i llegir UNE/free per a la inserció detallada
                 version = subcarpeta_seleccio or "MoE"
                 video_dir = base_media_dir / selected_sha1
-                une_path = video_dir / version / "une_ad.srt"
-                free_path = video_dir / version / "free_ad.txt"
+
+                une_path = _find_best_file_for_version(video_dir, version, "une_ad.srt")
+                free_path = _find_best_file_for_version(video_dir, version, "free_ad.txt")
 
                 try:
-                    une_ad_text = une_path.read_text(encoding="utf-8") if une_path.exists() else ""
+                    une_ad_text = (
+                        une_path.read_text(encoding="utf-8")
+                        if une_path is not None and une_path.exists()
+                        else ""
+                    )
                 except Exception:
-                    une_ad_text = une_path.read_text(errors="ignore") if une_path.exists() else ""
+                    une_ad_text = (
+                        une_path.read_text(errors="ignore")
+                        if une_path is not None and une_path.exists()
+                        else ""
+                    )
 
                 try:
-                    free_ad_text = free_path.read_text(encoding="utf-8") if free_path.exists() else ""
+                    free_ad_text = (
+                        free_path.read_text(encoding="utf-8")
+                        if free_path is not None and free_path.exists()
+                        else ""
+                    )
                 except Exception:
-                    free_ad_text = free_path.read_text(errors="ignore") if free_path.exists() else ""
+                    free_ad_text = (
+                        free_path.read_text(errors="ignore")
+                        if free_path is not None and free_path.exists()
+                        else ""
+                    )
 
                 user_name = (
                     st.session_state.user.get("username")

persistent_data_gate.py

@@ -2,6 +2,7 @@ import os
 import shutil
 import zipfile
 import io
+import runpy
 from pathlib import Path
 from typing import Optional
 
@@ -142,10 +143,12 @@ def ensure_temp_databases(base_dir: Path, api_client) -> None:
 
     # Verificació opcional: llistar estat de demo/data/db i demo/temp/db al log
     try:
-        from scripts.verify_temp_dbs import run_verification as _run_db_verification
-
-        print("[ensure_temp_databases] Executant verificador de BDs (demo/scripts/verify_temp_dbs.py)...")
-        _run_db_verification()
+        script_path = base_dir / "scripts" / "verify_temp_dbs.py"
+        if script_path.exists():
+            print("[ensure_temp_databases] Executant verificador de BDs (scripts/verify_temp_dbs.py)...")
+            runpy.run_path(str(script_path), run_name="__main__")
+        else:
+            print(f"[ensure_temp_databases] verify_temp_dbs.py no trobat a {script_path}")
     except Exception as _e_ver:
         print(f"[ensure_temp_databases] Error executant verificador de BDs: {_e_ver}")
 

scripts/build_audiodescriptions_db.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from pathlib import Path
+import sqlite3
+import csv
+import json
+from typing import Optional
+
+from engine.finetuning.video_analysis import analyze_srt, embed_srt_sentences
+
+BASE_DEMO = Path(__file__).resolve().parent.parent
+MEDIA_ROOT = BASE_DEMO / "data" / "media"
+DB_PATH = BASE_DEMO / "temp" / "audiodescriptions.db"
+
+VALID_VERSIONS = ["MoE", "Salamandra", "HITL"]
+
+
+def read_text_file(path: Path) -> Optional[str]:
+    if not path.exists():
+        return None
+    try:
+        return path.read_text(encoding="utf-8")
+    except Exception:
+        try:
+            return path.read_text(errors="ignore")
+        except Exception:
+            return None
+
+
+def read_eval_csv(path: Path) -> Optional[str]:
+    if not path.exists():
+        return None
+    try:
+        # Guardamos el CSV entero como texto para poderlo reutilizar tal cual
+        return path.read_text(encoding="utf-8")
+    except Exception:
+        try:
+            return path.read_text(errors="ignore")
+        except Exception:
+            return None
+
+
+def summarize_free_ad(text: Optional[str], max_chars: int = 280) -> str:
+    if not text:
+        return ""
+    s = " ".join(text.split())  # normalizar espacios y saltos de línea
+    if len(s) <= max_chars:
+        return s
+    return s[: max_chars - 3] + "..."
+
+
+def ensure_schema(conn: sqlite3.Connection) -> None:
+    cur = conn.cursor()
+    cur.execute(
+        """
+        CREATE TABLE IF NOT EXISTS audiodescriptions (
+            sha1sum      TEXT NOT NULL,
+            version      TEXT NOT NULL,
+            une_ad       TEXT,
+            free_ad      TEXT,
+            eval         TEXT,
+            srt_duration REAL,
+            ad_ratio     REAL,
+            words_pm     REAL,
+            speakers_pm  REAL,
+            blocks_pm    REAL,
+            description  TEXT,
+            embedding    TEXT,
+            PRIMARY KEY (sha1sum, version)
+        );
+        """
+    )
+    conn.commit()
+
+
+def main() -> None:
+    print(f"MEDIA_ROOT: {MEDIA_ROOT} (exists={MEDIA_ROOT.exists()})")
+    if not MEDIA_ROOT.exists():
+        raise SystemExit("❌ No s'ha trobat demo/data/media")
+
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    ensure_schema(conn)
+
+    cur = conn.cursor()
+
+    total_rows = 0
+    for video_dir in sorted(MEDIA_ROOT.iterdir()):
+        if not video_dir.is_dir():
+            continue
+        sha1sum = video_dir.name
+
+        for version in VALID_VERSIONS:
+            version_dir = video_dir / version
+            if not version_dir.exists() or not version_dir.is_dir():
+                continue
+
+            une_path = version_dir / "une_ad.srt"
+            free_path = version_dir / "free_ad.txt"
+            eval_path = version_dir / "eval.csv"
+
+            une_ad = read_text_file(une_path)
+            free_ad = read_text_file(free_path)
+            eval_csv = read_eval_csv(eval_path)
+
+            if une_ad is None and free_ad is None and eval_csv is None:
+                # Nada que indexar para esta versión
+                continue
+
+            # Analizar SRT si existe
+            srt_duration = ad_ratio = words_pm = speakers_pm = blocks_pm = None
+            if une_ad:
+                try:
+                    metrics = analyze_srt(une_ad)
+                    srt_duration = float(metrics.get("duration_sec", 0.0))
+                    ad_ratio = float(metrics.get("ad_time_ratio", 0.0))
+                    words_pm = float(metrics.get("words_per_min", 0.0))
+                    speakers_pm = float(metrics.get("speakers_blocks_per_min", 0.0))
+                    blocks_pm = float(metrics.get("blocks_per_min", 0.0))
+                except Exception as e:
+                    print(f"[WARN] Error analitzant SRT per {sha1sum}/{version}: {e}")
+
+            # Resumen del free_ad
+            description = summarize_free_ad(free_ad)
+
+            # Embedding del SRT (puede fallar si no están instalados los deps)
+            embedding_json = None
+            if une_ad:
+                try:
+                    emb_info = embed_srt_sentences(une_ad)
+                    embeddings = emb_info.get("embeddings") or []
+                    # Guardamos como JSON; puede ser muy grande pero sirve para prototipo
+                    embedding_json = json.dumps(embeddings)
+                except Exception as e:
+                    print(f"[WARN] Error generant embeddings per {sha1sum}/{version}: {e}")
+
+            cur.execute(
+                """
+                INSERT OR REPLACE INTO audiodescriptions (
+                    sha1sum, version, une_ad, free_ad, eval,
+                    srt_duration, ad_ratio, words_pm, speakers_pm, blocks_pm,
+                    description, embedding
+                ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?);
+                """,
+                (
+                    sha1sum,
+                    version,
+                    une_ad,
+                    free_ad,
+                    eval_csv,
+                    srt_duration,
+                    ad_ratio,
+                    words_pm,
+                    speakers_pm,
+                    blocks_pm,
+                    description,
+                    embedding_json,
+                ),
+            )
+            total_rows += 1
+
+    conn.commit()
+    conn.close()
+
+    print(f"✅ audiodescriptions.db generat a {DB_PATH} amb {total_rows} files.")
+
+
+if __name__ == "__main__":
+    main()

scripts/debug_audiodescriptions_db.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+import sqlite3
+
+BASE = Path(__file__).resolve().parent.parent
+ADB = BASE / "temp" / "audiodescriptions.db"
+
+print(f"AUDIODESCRIPTIONS_DB: {ADB} (exists={ADB.exists()})")
+
+if not ADB.exists():
+    raise SystemExit("❌ audiodescriptions.db no existeix")
+
+conn = sqlite3.connect(str(ADB))
+conn.row_factory = sqlite3.Row
+cur = conn.cursor()
+
+print("\n[SCHEMA] PRAGMA table_info(audiodescriptions):")
+try:
+    cur.execute("PRAGMA table_info(audiodescriptions)")
+    for row in cur.fetchall():
+        # row: (cid, name, type, notnull, dflt_value, pk)
+        print(f"  - cid={row['cid']}, name={row['name']}, type={row['type']}, notnull={row['notnull']}, pk={row['pk']}")
+except Exception as e:
+    print("Error llegint esquema:", e)
+
+print("\n[DATA] Primeres 10 files de audiodescriptions:")
+try:
+    cur.execute("SELECT * FROM audiodescriptions LIMIT 10")
+    rows = cur.fetchall()
+    for r in rows:
+        print("  -", dict(r))
+except Exception as e:
+    print("Error llegint dades:", e)
+
+conn.close()

scripts/debug_videos_and_media.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+import sqlite3
+
+BASE = Path(__file__).resolve().parent.parent
+VIDEOS_DB = BASE / "temp" / "videos.db"
+MEDIA_DIR = BASE / "temp" / "media"
+
+print(f"VIDEOS_DB: {VIDEOS_DB} (exists={VIDEOS_DB.exists()})")
+if VIDEOS_DB.exists():
+    conn = sqlite3.connect(str(VIDEOS_DB))
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+    try:
+        # Llistar només les columnes que ens interessen ara mateix
+        cur.execute("SELECT video_name, sha1sum FROM videos")
+        rows = cur.fetchall()
+        print("\n[VIDEOS.DB] Registres (video_name, sha1sum):")
+        for r in rows:
+            print(f"  - video_name={r['video_name']!r}, sha1sum={r['sha1sum']!r}")
+    except Exception as e:
+        print("Error llegint videos.db:", e)
+    finally:
+        conn.close()
+else:
+    print("videos.db no existeix")
+
+print(f"\nMEDIA_DIR: {MEDIA_DIR} (exists={MEDIA_DIR.exists()})")
+if MEDIA_DIR.exists():
+    subdirs = [p.name for p in sorted(MEDIA_DIR.iterdir()) if p.is_dir()]
+    print("[MEDIA] Subcarpetes a demo/temp/media:")
+    for name in subdirs:
+        print("  -", name)
+else:
+    print("Directori media no existeix")

scripts/explore_data.py

@@ -0,0 +1,88 @@
+import os
+import sqlite3
+from typing import Dict, Any
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+TEMP_DIR = os.path.join(BASE_DIR, "temp")
+
+
+def analyze_db(db_path: str) -> Dict[str, Any]:
+    """Devuelve un dict con info de todas las tablas de un fichero SQLite."""
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+
+    cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
+    tables = [r[0] for r in cur.fetchall()]
+
+    db_info: Dict[str, Any] = {}
+
+    for table in tables:
+        # columnas de la tabla
+        cur.execute(f"PRAGMA table_info(\"{table}\")")
+        cols = [r[1] for r in cur.fetchall()]
+
+        table_info: Dict[str, Any] = {"n_rows": 0, "columns": {}}
+
+        # número de registros
+        cur.execute(f"SELECT COUNT(*) AS n FROM \"{table}\"")
+        n_rows = cur.fetchone()[0]
+        table_info["n_rows"] = n_rows
+
+        for col in cols:
+            # número de nulos
+            cur.execute(
+                f"SELECT COUNT(*) AS n_null FROM \"{table}\" WHERE \"{col}\" IS NULL"
+            )
+            n_null = cur.fetchone()[0]
+            null_pct = (n_null / n_rows * 100.0) if n_rows > 0 else 0.0
+
+            # número de valores distintos
+            cur.execute(
+                f"SELECT COUNT(DISTINCT \"{col}\") AS n_distinct FROM \"{table}\""
+            )
+            n_distinct = cur.fetchone()[0]
+
+            table_info["columns"][col] = {
+                "null_pct": null_pct,
+                "n_distinct": n_distinct,
+            }
+
+        db_info[table] = table_info
+
+    conn.close()
+    return db_info
+
+
+def main() -> None:
+    print(f"Analizando ficheros .db en: {TEMP_DIR}")
+
+    for fname in sorted(os.listdir(TEMP_DIR)):
+        if not fname.endswith(".db"):
+            continue
+
+        db_path = os.path.join(TEMP_DIR, fname)
+        print("\n" + "=" * 80)
+        print(f"Base de datos: {fname}")
+        print("=" * 80)
+
+        db_info = analyze_db(db_path)
+
+        if not db_info:
+            print("  (Sin tablas de usuario)")
+            continue
+
+        for table_name, tinfo in db_info.items():
+            print(f"\nTabla: {table_name}")
+            print(f"  Nº registros: {tinfo['n_rows']}")
+            print("  Campos:")
+            for col, cinfo in tinfo["columns"].items():
+                print(
+                    f"    - {col}: "
+                    f"{cinfo['n_distinct']} valores distintos, "
+                    f"{cinfo['null_pct']:.2f}% nulos"
+                )
+
+
+if __name__ == "__main__":
+    main()

scripts/generate_media_sha1sums.py

@@ -0,0 +1,72 @@
+import hashlib
+import csv
+from pathlib import Path
+
+
+BASE = Path(__file__).resolve().parent.parent / "temp" / "media"
+
+
+def sha1_of_file(path: Path, buf_size: int = 65536) -> str:
+    """Calcula el SHA1 de un fichero binario."""
+
+    h = hashlib.sha1()
+    with path.open("rb") as f:
+        while True:
+            chunk = f.read(buf_size)
+            if not chunk:
+                break
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def main() -> None:
+    if not BASE.exists():
+        raise SystemExit(f"No existe la carpeta {BASE}")
+
+    rows: list[tuple[str, str]] = []
+    subdirs = sorted(p for p in BASE.iterdir() if p.is_dir())
+
+    # 1) Calcular SHA1 y guardar filas para el CSV
+    for d in subdirs:
+        video_path = d / "video.mp4"
+        if not video_path.exists():
+            print(f"[WARN] No se encontró video.mp4 en {d}, se omite esta carpeta.")
+            continue
+
+        digest = sha1_of_file(video_path)
+        print(f"{d.name} -> {digest}")
+        rows.append((d.name, digest))
+
+    if not rows:
+        print("[INFO] No se han encontrado carpetas con video.mp4, nada que hacer.")
+        return
+
+    # 2) Escribir CSV con mapping carpeta original -> sha1sum
+    csv_path = BASE / "sha1sums.csv"
+    with csv_path.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow(["folder_name", "sha1sum"])
+        writer.writerows(rows)
+
+    print(f"[INFO] CSV generado en {csv_path}")
+
+    # 3) Renombrar carpetas a su sha1sum
+    #    Si dos carpetas tienen el mismo sha1, se deja la segunda sin renombrar.
+    for old_name, digest in rows:
+        old_path = BASE / old_name
+        new_path = BASE / digest
+        if not old_path.exists():
+            print(f"[INFO] Carpeta {old_path} ya no existe, se omite.")
+            continue
+        if new_path.exists():
+            print(
+                f"[ERROR] Ya existe {new_path}, posible colisión de SHA1 o renombrado previo. "
+                f"No se renombra {old_path}."
+            )
+            continue
+        print(f"Renombrando {old_path} -> {new_path}")
+        old_path.rename(new_path)
+
+
+if __name__ == "__main__":
+    main()

scripts/init_casting_scenarios.py

@@ -6,7 +6,7 @@ from typing import Iterable, Tuple
 
 BASE_DIR = Path(__file__).resolve().parent.parent
 DATA_DIR = BASE_DIR / "data"
-VIDEOS_DIR = DATA_DIR / "videos"
+VIDEOS_DIR = DATA_DIR / "media"
 
 CASTING_DB_PATH = DATA_DIR / "casting.db"
 SCENARIOS_DB_PATH = DATA_DIR / "scenarios.db"
@@ -84,7 +84,7 @@ def populate_single_table(
 ) -> int:
     """Rellena una tabla (casting o scenarios) a partir dels CSV per vídeo.
 
-    Recorre demo/data/videos/<video_name>, busca <csv_filename> y un .mp4,
+    Recorre demo/data/media/<video_name>, busca <csv_filename> y un .mp4,
     calcula sha1sum del vídeo y genera un registre por cada fila del CSV.
     """
 

scripts/init_feedback_demo.py

@@ -6,7 +6,7 @@ from typing import Dict
 
 BASE_DIR = Path(__file__).resolve().parent.parent
 DATA_DIR = BASE_DIR / "data"
-VIDEOS_DIR = DATA_DIR / "videos"
+VIDEOS_DIR = DATA_DIR / "media"
 DB_PATH = DATA_DIR / "feedback.db"
 
 SLIDER_CAPTIONS = [
@@ -99,7 +99,7 @@ def parse_eval_csv(csv_path: Path) -> Dict[str, int]:
 
 def migrate() -> None:
     if not VIDEOS_DIR.exists():
-        print(f"[INFO] No existe demo/data/videos, nada que hacer.")
+        print(f"[INFO] No existe demo/data/media, nada que hacer.")
         return
 
     conn = ensure_db()

scripts/inspect_audiodescriptions.py

@@ -0,0 +1,88 @@
+"""Inspecta el contingut de demo/temp/audiodescriptions.db.
+
+Mostra:
+- Si el fitxer existeix
+- Nombre total de files
+- Parelles (sha1sum, version)
+- Resultats de consultes parametritzades vs literals per a uns sha1sum/version de mostra
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+
+DB_PATH = Path(__file__).resolve().parent.parent / "temp" / "audiodescriptions.db"
+
+SAMPLE_SHA1S = (
+    "8ff4b2aaccfeee31ecc59b96e1ae90273de78864",
+    "3df04d2b7df70210fcceb7b9d9a35731bb43a39c",
+    "150f0d2abfe26602e38dc3cc1a0030d16c8ed0a2",
+)
+SAMPLE_VERSIONS = ("Salamandra", "MoE")
+
+
+def main() -> None:
+    print(f"DB path: {DB_PATH}")
+    if not DB_PATH.exists():
+        print("❌ DB file does not exist")
+        return
+
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+
+    cur.execute("SELECT COUNT(*) FROM audiodescriptions")
+    total = cur.fetchone()[0]
+    print(f"Total rows: {total}")
+    
+    # Ver esquema de la tabla
+    cur.execute("PRAGMA table_info(audiodescriptions)")
+    columns = cur.fetchall()
+    print("Columns:", [col[1] for col in columns])
+
+    cur.execute(
+        "SELECT sha1sum, version FROM audiodescriptions ORDER BY sha1sum, version"
+    )
+    pairs = [dict(row) for row in cur.fetchall()]
+    print("Pairs:")
+    print(json.dumps(pairs, ensure_ascii=False, indent=2))
+
+    for sha1 in SAMPLE_SHA1S:
+        for version in SAMPLE_VERSIONS:
+            cur.execute(
+                "SELECT COUNT(*) FROM audiodescriptions WHERE sha1sum=? AND version=?",
+                (sha1, version),
+            )
+            count_param = cur.fetchone()[0]
+
+            cur.execute(
+                "SELECT COUNT(*) FROM audiodescriptions WHERE sha1sum=:sha AND version=:ver",
+                {"sha": sha1, "ver": version},
+            )
+            count_named = cur.fetchone()[0]
+
+            cur.execute(
+                f"SELECT COUNT(*) FROM audiodescriptions WHERE sha1sum='{sha1}' AND version='{version}'"
+            )
+            count_literal = cur.fetchone()[0]
+            
+            # Test con LOWER() - igual que la función (sin updated_at/created_at)
+            cur.execute(
+                "SELECT * FROM audiodescriptions WHERE sha1sum = ? AND LOWER(version) = LOWER(?) ORDER BY rowid DESC LIMIT 1",
+                (sha1, version),
+            )
+            rows_lower = cur.fetchall()
+            count_lower = len(rows_lower)
+
+            print(
+                f"sha1={sha1} version={version} -> param={count_param} "
+                f"named={count_named} literal={count_literal} SELECT*_LOWER={count_lower}"
+            )
+
+    conn.close()
+
+
+if __name__ == "__main__":
+    main()

scripts/migrate_audiodescriptions.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+import sqlite3
+from pathlib import Path
+from typing import Set, Dict, List
+
+# Este script se guarda como demo/scripts/migrate_audiodescriptions.py
+# BASE_DIR apunta a la carpeta demo/
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+DB_REL_PATHS = [
+    Path("temp") / "audiodescriptions.db",
+    Path("data") / "audiodescriptions.db",
+]
+
+
+def get_existing_columns(conn, table_name: str) -> Set[str]:
+    cur = conn.execute(f"PRAGMA table_info({table_name})")
+    cols = {row[1] for row in cur.fetchall()}  # row[1] = nombre de columna
+    return cols
+
+
+def ensure_columns(conn, table_name: str, columns_sql: Dict[str, str]) -> None:
+    """Asegura que existen las columnas indicadas (si no, hace ALTER TABLE).
+
+    columns_sql: nombre_columna -> sentencia ALTER TABLE ADD COLUMN ...
+    """
+    existing = get_existing_columns(conn, table_name)
+    for col_name, alter_sql in columns_sql.items():
+        if col_name not in existing:
+            print(f"  - Añadiendo columna {col_name}...")
+            conn.execute(alter_sql)
+        else:
+            print(f"  - Columna {col_name} ya existe, se omite.")
+
+
+def copy_free_ad_into_new_columns(conn, table_name: str, target_columns: List[str]) -> None:
+    """Actualiza cada columna destino con el valor actual de free_ad."""
+    set_clause = ", ".join(f"{col} = free_ad" for col in target_columns)
+    sql = f"UPDATE {table_name} SET {set_clause}"
+    print(f"  - Ejecutando: {sql}")
+    conn.execute(sql)
+
+
+def migrate_db(db_path: Path) -> None:
+    full_path = BASE_DIR / db_path
+    if not full_path.exists():
+        print(f"[AVISO] DB no encontrada, se omite: {full_path}")
+        return
+
+    print(f"\n=== Migrando BD: {full_path} ===")
+    conn = sqlite3.connect(full_path)
+    try:
+        conn.isolation_level = None  # manejo manual de transacciones
+        conn.execute("BEGIN")
+
+        table_name = "audiodescriptions"
+
+        # 1) Asegurar columnas nuevas con los nombres finales
+        columns_sql: Dict[str, str] = {
+            "ok_une_ad":    f"ALTER TABLE {table_name} ADD COLUMN ok_une_ad TEXT",
+            "test_une_ad":  f"ALTER TABLE {table_name} ADD COLUMN test_une_ad TEXT",
+            "ok_free_ad":   f"ALTER TABLE {table_name} ADD COLUMN ok_free_ad TEXT",
+            "test_free_ad": f"ALTER TABLE {table_name} ADD COLUMN test_free_ad TEXT",
+        }
+        ensure_columns(conn, table_name, columns_sql)
+
+        # 2) Copiar free_ad a las cuatro columnas nuevas
+        target_cols: List[str] = ["ok_une_ad", "test_une_ad", "ok_free_ad", "test_free_ad"]
+        copy_free_ad_into_new_columns(conn, table_name, target_cols)
+
+        conn.execute("COMMIT")
+        print(f"✔ Migración completada en: {full_path}")
+    except Exception as e:
+        print(f"❌ Error en {full_path}: {e}")
+        try:
+            conn.execute("ROLLBACK")
+        except Exception:
+            pass
+    finally:
+        conn.close()
+
+
+def main() -> None:
+    print("Script de migración de audiodescriptions.db")
+    print("Añade columnas ok_une_ad, test_une_ad, ok_free_ad, test_free_ad")
+    print("y copia free_ad en todas ellas.\n")
+
+    for rel in DB_REL_PATHS:
+        migrate_db(rel)
+
+
+if __name__ == "__main__":
+    main()

scripts/migrate_audiodescriptions_info_ad.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+import sqlite3
+from pathlib import Path
+from typing import List
+
+# Este script se debe guardar como:
+# demo/scripts/migrate_audiodescriptions_info_ad.py
+# BASE_DIR apunta a la carpeta demo/
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+DB_REL_PATHS: List[Path] = [
+    Path("temp") / "audiodescriptions.db",
+    Path("data") / "audiodescriptions.db",
+]
+
+
+def add_info_ad_column(db_path: Path) -> None:
+    full_path = BASE_DIR / db_path
+    if not full_path.exists():
+        print(f"[AVISO] DB no encontrada, se omite: {full_path}")
+        return
+
+    print(f"\n=== Migrando BD: {full_path} ===")
+    conn = sqlite3.connect(full_path)
+    try:
+        conn.isolation_level = None
+        conn.execute("BEGIN")
+
+        # Comprobar columnas existentes en la tabla audiodescriptions
+        cur = conn.execute("PRAGMA table_info(audiodescriptions)")
+        cols = {row[1] for row in cur.fetchall()}  # row[1] = nombre columna
+
+        if "info_ad" in cols:
+            print("  - Columna info_ad ya existe, no se hace nada.")
+        else:
+            print("  - Añadiendo columna info_ad...")
+            conn.execute("ALTER TABLE audiodescriptions ADD COLUMN info_ad TEXT")
+
+        conn.execute("COMMIT")
+        print(f"✔ Migración completada en: {full_path}")
+    except Exception as e:
+        print(f"❌ Error en {full_path}: {e}")
+        try:
+            conn.execute("ROLLBACK")
+        except Exception:
+            pass
+    finally:
+        conn.close()
+
+
+def main() -> None:
+    print("Script de migración: añadir columna info_ad a audiodescriptions.db\n")
+    for rel in DB_REL_PATHS:
+        add_info_ad_column(rel)
+
+
+if __name__ == "__main__":
+    main()

scripts/publish_monthly_digest.py

@@ -1,7 +1,7 @@
 import argparse
 from datetime import datetime, timezone
 
-from aws_qldb import qldb_manager
+from compliance_client import compliance_client
 
 
 def _current_period_utc() -> str:
@@ -14,7 +14,7 @@ def main() -> None:
     parser = argparse.ArgumentParser(
         description=(
             "Publica el digest mensual de autorizaciones en Polygon "
-            "usando aws_qldb.qldb_manager (modo simulado por ahora)."
+            "usando el microservicio 'compliance' (ComplianceClient)."
         )
     )
     parser.add_argument(
@@ -26,8 +26,8 @@ def main() -> None:
     args = parser.parse_args()
 
     period = args.period or _current_period_utc()
-    print(f"[DIGEST] Publicando digest para el período {period}...")
-    tx_hash = qldb_manager.publish_monthly_digest_to_polygon(period)
+    print(f"[DIGEST] Publicando digest para el período {period} via compliance...")
+    tx_hash = compliance_client.publish_monthly_digest(period)
 
     if tx_hash:
         print(f"[DIGEST] Digest publicado correctamente. Tx hash: {tx_hash}")

scripts/test_full_refinement_via_api.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import argparse
+import difflib
+import os
+import sqlite3
+from pathlib import Path
+
+import requests
+
+
+BASE_DEMO = Path(__file__).resolve().parent.parent
+DB_PATH = BASE_DEMO / "temp" / "audiodescriptions.db"
+DEFAULT_API_URL = "http://localhost:8000/apply_refinement"
+
+
+def load_une_ad(sha1sum: str, version: str) -> str:
+    if not DB_PATH.exists():
+        raise SystemExit(f"❌ No s'ha trobat la base de dades: {DB_PATH}")
+
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    try:
+        cur = conn.cursor()
+        row = cur.execute(
+            "SELECT une_ad FROM audiodescriptions WHERE sha1sum=? AND version=?",
+            (sha1sum, version),
+        ).fetchone()
+        if not row or not row["une_ad"]:
+            raise SystemExit(
+                f"❌ No s'ha trobat une_ad per sha1sum={sha1sum}, version={version} a audiodescriptions.db"
+            )
+        return row["une_ad"]
+    finally:
+        conn.close()
+
+
+def show_diff(initial_srt: str, refined_srt: str) -> None:
+    initial_lines = initial_srt.splitlines()
+    refined_lines = refined_srt.splitlines()
+
+    diff = difflib.unified_diff(
+        initial_lines,
+        refined_lines,
+        fromfile="initial_une_ad.srt",
+        tofile="refined_une_ad.srt",
+        lineterm="",
+    )
+    for line in diff:
+        print(line)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Prova de la pipeline completa de refinement (reflection + reflexion + introspection) "
+            "via l'endpoint /apply_refinement."
+        )
+    )
+    parser.add_argument("sha1sum", type=str, help="SHA1 del vídeo")
+    parser.add_argument("version", type=str, help="Versió de la AD (p.ex. Salamandra, MoE, HITL)")
+    parser.add_argument(
+        "--api-url",
+        type=str,
+        default=DEFAULT_API_URL,
+        help=f"URL de l'endpoint apply_refinement (per defecte: {DEFAULT_API_URL})",
+    )
+    parser.add_argument(
+        "--no-reflection",
+        action="store_true",
+        help="Desactiva el pas de reflection per a aquesta prova",
+    )
+    parser.add_argument(
+        "--no-reflexion",
+        action="store_true",
+        help="Desactiva el pas de reflexion per a aquesta prova",
+    )
+    parser.add_argument(
+        "--no-introspection",
+        action="store_true",
+        help="Desactiva el pas d'introspection per a aquesta prova",
+    )
+    args = parser.parse_args()
+
+    token = os.getenv("API_SHARED_TOKEN")
+    if not token:
+        print("⚠️ Variable d'entorn API_SHARED_TOKEN no definida; es farà la crida sense token.")
+
+    initial_srt = load_une_ad(args.sha1sum, args.version)
+
+    payload = {
+        "token": token,
+        "sha1sum": args.sha1sum,
+        "version": args.version,
+        "reflection_enabled": not args.no_reflection,
+        "reflexion_enabled": not args.no_reflexion,
+        "introspection_enabled": not args.no_introspection,
+    }
+
+    print(f"Cridant {args.api_url} amb payload: { {k: v for k, v in payload.items() if k != 'token'} }")
+
+    resp = requests.post(args.api_url, json=payload)
+    if resp.status_code != 200:
+        print(f"❌ Error {resp.status_code} des de l'API: {resp.text}")
+        raise SystemExit(1)
+
+    data = resp.json()
+    refined_srt = data.get("refined_srt", "")
+    if not refined_srt:
+        print("⚠️ Resposta sense camp 'refined_srt'. JSON complet:")
+        print(data)
+        raise SystemExit(1)
+
+    print("\n===== DIFF entre SRT inicial i SRT refinat via API =====")
+    show_diff(initial_srt, refined_srt)
+
+
+if __name__ == "__main__":
+    main()

scripts/test_introspection_only_on_db_srt.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import argparse
+import difflib
+import sqlite3
+from pathlib import Path
+
+import yaml
+
+from engine.refinement.multiagent_refinement import execute_refinement
+
+
+BASE_DEMO = Path(__file__).resolve().parent.parent
+DB_PATH = BASE_DEMO / "temp" / "audiodescriptions.db"
+CONFIG_PATH = BASE_DEMO / "temp" / "introspection_only.yaml"
+
+
+def ensure_introspection_only_config() -> Path:
+    """Crea (o sobrescribe) un config.yaml mínimo con solo introspection activado."""
+
+    cfg = {
+        "refinement": {
+            "reflection_enabled": False,
+            "reflexion_enabled": False,
+            "introspection_enabled": True,
+        }
+    }
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with CONFIG_PATH.open("w", encoding="utf-8") as f:
+        yaml.safe_dump(cfg, f, allow_unicode=True)
+    return CONFIG_PATH
+
+
+def load_srt_from_db(sha1sum: str | None = None, version: str | None = None) -> tuple[str, str, str]:
+    """Carga un UNE SRT desde audiodescriptions.db.
+
+    Si no se especifican sha1sum/version, toma la primera fila con une_ad no nulo.
+    Devuelve (sha1sum, version, une_ad).
+    """
+
+    if not DB_PATH.exists():
+        raise SystemExit(f"❌ No s'ha trobat la base de dades: {DB_PATH}")
+
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    try:
+        cur = conn.cursor()
+        if sha1sum and version:
+            row = cur.execute(
+                "SELECT sha1sum, version, une_ad FROM audiodescriptions WHERE sha1sum=? AND version=?",
+                (sha1sum, version),
+            ).fetchone()
+        else:
+            row = cur.execute(
+                "SELECT sha1sum, version, une_ad FROM audiodescriptions WHERE une_ad IS NOT NULL LIMIT 1",
+            ).fetchone()
+
+        if not row or not row["une_ad"]:
+            raise SystemExit("❌ No s'ha trobat cap registre amb une_ad a audiodescriptions.db")
+
+        return row["sha1sum"], row["version"], row["une_ad"]
+    finally:
+        conn.close()
+
+
+def show_diff(initial_srt: str, refined_srt: str) -> None:
+    initial_lines = initial_srt.splitlines()
+    refined_lines = refined_srt.splitlines()
+
+    diff = difflib.unified_diff(
+        initial_lines,
+        refined_lines,
+        fromfile="initial_une_ad.srt",
+        tofile="introspected_une_ad.srt",
+        lineterm="",
+    )
+    for line in diff:
+        print(line)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Prova del pas d'introspection sobre un SRT de audiodescriptions.db (sense reflection/reflexion).",
+    )
+    parser.add_argument("--sha1sum", type=str, default=None, help="SHA1 del vídeo (opcional)")
+    parser.add_argument("--version", type=str, default=None, help="Versió de la AD (opcional)")
+    args = parser.parse_args()
+
+    cfg_path = ensure_introspection_only_config()
+
+    sha1sum, version, une_ad = load_srt_from_db(args.sha1sum, args.version)
+    print(f"Usant registre sha1sum={sha1sum}, version={version} de {DB_PATH}")
+
+    refined = execute_refinement(une_ad, config_path=cfg_path)
+
+    print("\n===== DIFF entre SRT inicial i SRT després d'introspection =====")
+    show_diff(une_ad, refined)
+
+
+if __name__ == "__main__":
+    main()

scripts/test_reflection_only_on_db_srt.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import argparse
+import difflib
+import sqlite3
+from pathlib import Path
+
+import yaml
+
+from engine.refinement.multiagent_refinement import execute_refinement
+
+
+BASE_DEMO = Path(__file__).resolve().parent.parent
+DB_PATH = BASE_DEMO / "temp" / "audiodescriptions.db"
+CONFIG_PATH = BASE_DEMO / "temp" / "reflection_only.yaml"
+
+
+def ensure_reflection_only_config() -> Path:
+    """Crea (o sobrescribe) un config.yaml mínimo con solo reflection activado."""
+
+    cfg = {
+        "refinement": {
+            "reflection_enabled": True,
+            "reflexion_enabled": False,
+            "introspection_enabled": False,
+        }
+    }
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with CONFIG_PATH.open("w", encoding="utf-8") as f:
+        yaml.safe_dump(cfg, f, allow_unicode=True)
+    return CONFIG_PATH
+
+
+def load_srt_from_db(sha1sum: str | None = None, version: str | None = None) -> tuple[str, str, str]:
+    """Carga un UNE SRT desde audiodescriptions.db.
+
+    Si no se especifican sha1sum/version, toma la primera fila con une_ad no nulo.
+    Devuelve (sha1sum, version, une_ad).
+    """
+
+    if not DB_PATH.exists():
+        raise SystemExit(f"❌ No s'ha trobat la base de dades: {DB_PATH}")
+
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    try:
+        cur = conn.cursor()
+        if sha1sum and version:
+            row = cur.execute(
+                "SELECT sha1sum, version, une_ad FROM audiodescriptions WHERE sha1sum=? AND version=?",
+                (sha1sum, version),
+            ).fetchone()
+        else:
+            row = cur.execute(
+                "SELECT sha1sum, version, une_ad FROM audiodescriptions WHERE une_ad IS NOT NULL LIMIT 1",
+            ).fetchone()
+
+        if not row or not row["une_ad"]:
+            raise SystemExit("❌ No s'ha trobat cap registre amb une_ad a audiodescriptions.db")
+
+        return row["sha1sum"], row["version"], row["une_ad"]
+    finally:
+        conn.close()
+
+
+def show_diff(initial_srt: str, refined_srt: str) -> None:
+    initial_lines = initial_srt.splitlines()
+    refined_lines = refined_srt.splitlines()
+
+    diff = difflib.unified_diff(
+        initial_lines,
+        refined_lines,
+        fromfile="initial_une_ad.srt",
+        tofile="reflected_une_ad.srt",
+        lineterm="",
+    )
+    for line in diff:
+        print(line)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Prova del pas de reflection sobre un SRT de audiodescriptions.db (sense reflexion/introspection).",
+    )
+    parser.add_argument("--sha1sum", type=str, default=None, help="SHA1 del vídeo (opcional)")
+    parser.add_argument("--version", type=str, default=None, help="Versió de la AD (opcional)")
+    args = parser.parse_args()
+
+    cfg_path = ensure_reflection_only_config()
+
+    sha1sum, version, une_ad = load_srt_from_db(args.sha1sum, args.version)
+    print(f"Usant registre sha1sum={sha1sum}, version={version} de {DB_PATH}")
+
+    refined = execute_refinement(une_ad, config_path=cfg_path)
+
+    print("\n===== DIFF entre SRT inicial i SRT després de reflection =====")
+    show_diff(une_ad, refined)
+
+
+if __name__ == "__main__":
+    main()

scripts/test_reflexion_only_on_db_srt.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import argparse
+import difflib
+import sqlite3
+from pathlib import Path
+
+import yaml
+
+from engine.refinement.multiagent_refinement import execute_refinement
+
+
+BASE_DEMO = Path(__file__).resolve().parent.parent
+DB_PATH = BASE_DEMO / "temp" / "audiodescriptions.db"
+CONFIG_PATH = BASE_DEMO / "temp" / "reflexion_only.yaml"
+
+
+def ensure_reflexion_only_config() -> Path:
+    """Crea (o sobrescribe) un config.yaml mínimo con solo reflexion activado."""
+
+    cfg = {
+        "refinement": {
+            "reflection_enabled": False,
+            "reflexion_enabled": True,
+            "introspection_enabled": False,
+        }
+    }
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with CONFIG_PATH.open("w", encoding="utf-8") as f:
+        yaml.safe_dump(cfg, f, allow_unicode=True)
+    return CONFIG_PATH
+
+
+def load_srt_from_db(sha1sum: str | None = None, version: str | None = None) -> tuple[str, str, str]:
+    """Carga un UNE SRT desde audiodescriptions.db.
+
+    Si no se especifican sha1sum/version, toma la primera fila con une_ad no nulo.
+    Devuelve (sha1sum, version, une_ad).
+    """
+
+    if not DB_PATH.exists():
+        raise SystemExit(f"❌ No s'ha trobat la base de dades: {DB_PATH}")
+
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    try:
+        cur = conn.cursor()
+        if sha1sum and version:
+            row = cur.execute(
+                "SELECT sha1sum, version, une_ad FROM audiodescriptions WHERE sha1sum=? AND version=?",
+                (sha1sum, version),
+            ).fetchone()
+        else:
+            row = cur.execute(
+                "SELECT sha1sum, version, une_ad FROM audiodescriptions WHERE une_ad IS NOT NULL LIMIT 1",
+            ).fetchone()
+
+        if not row or not row["une_ad"]:
+            raise SystemExit("❌ No s'ha trobat cap registre amb une_ad a audiodescriptions.db")
+
+        return row["sha1sum"], row["version"], row["une_ad"]
+    finally:
+        conn.close()
+
+
+def show_diff(initial_srt: str, refined_srt: str) -> None:
+    initial_lines = initial_srt.splitlines()
+    refined_lines = refined_srt.splitlines()
+
+    diff = difflib.unified_diff(
+        initial_lines,
+        refined_lines,
+        fromfile="initial_une_ad.srt",
+        tofile="reflexioned_une_ad.srt",
+        lineterm="",
+    )
+    for line in diff:
+        print(line)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Prova del pas de 'reflexion' sobre un SRT de audiodescriptions.db (sense reflection/introspection).",
+    )
+    parser.add_argument("--sha1sum", type=str, default=None, help="SHA1 del vídeo (opcional)")
+    parser.add_argument("--version", type=str, default=None, help="Versió de la AD (opcional)")
+    args = parser.parse_args()
+
+    cfg_path = ensure_reflexion_only_config()
+
+    sha1sum, version, une_ad = load_srt_from_db(args.sha1sum, args.version)
+    print(f"Usant registre sha1sum={sha1sum}, version={version} de {DB_PATH}")
+
+    refined = execute_refinement(une_ad, config_path=cfg_path)
+
+    print("\n===== DIFF entre SRT inicial i SRT després de reflexion =====")
+    show_diff(une_ad, refined)
+
+
+if __name__ == "__main__":
+    main()

scripts/train_introspection.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from engine.refinement.introspection import (
+    FEW_SHOT_PATH,
+    RULES_PATH,
+    train_introspection_rules,
+)
+
+
+def _count_nonempty_blocks(path: Path) -> int:
+    """Compta aproximadament quants blocs d'exemple hi ha en un fitxer.
+
+    Per a ``few_shot_examples.txt`` comptem línies que comencen per ``# sha1sum=``.
+    Per a ``rules.txt`` comptem línies no buides.
+    """
+
+    if not path.exists():
+        return 0
+    try:
+        text = path.read_text(encoding="utf-8")
+    except Exception:
+        return 0
+
+    if path.name == "few_shot_examples.txt":
+        return sum(1 for line in text.splitlines() if line.lstrip().startswith("# sha1sum="))
+    return sum(1 for line in text.splitlines() if line.strip())
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Entrena les regles d'introspecció a partir de les correccions HITL "
+            "emmagatzemades a demo/temp/audiodescriptions.db."
+        )
+    )
+    parser.add_argument(
+        "--max-examples",
+        type=int,
+        default=None,
+        help=(
+            "Nombre màxim de parelles (MoE/Salamandra, HITL) a processar. "
+            "Per defecte es processen totes."
+        ),
+    )
+    args = parser.parse_args()
+
+    train_introspection_rules(max_examples=args.max_examples)
+
+    n_examples = _count_nonempty_blocks(FEW_SHOT_PATH)
+    n_rules = _count_nonempty_blocks(RULES_PATH)
+
+    print(
+        f"✅ Entrenament d'introspection completat. "
+        f"Few-shot examples: {n_examples}, regles: {n_rules}."
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/train_reflexion.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from engine.refinement.reflexion import (
+    REFLEXION_CSV_PATH,
+    REFLEXION_MODEL_PATH,
+    train_reflexion_model,
+)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Entrena el model KNN de 'reflexion' a partir de les parelles "
+            "(MoE/Salamandra, HITL) a demo/temp/audiodescriptions.db."
+        )
+    )
+    parser.add_argument(
+        "--max-examples",
+        type=int,
+        default=None,
+        help=(
+            "Nombre màxim de mostres d'entrenament a processar. "
+            "Per defecte es processen totes."
+        ),
+    )
+    args = parser.parse_args()
+
+    train_reflexion_model(max_examples=args.max_examples)
+
+    n_rows = 0
+    if REFLEXION_CSV_PATH.exists():
+        try:
+            text = REFLEXION_CSV_PATH.read_text(encoding="utf-8")
+            # descomptar la capçalera
+            n_rows = max(0, len([l for l in text.splitlines() if l.strip()]) - 1)
+        except Exception:
+            n_rows = 0
+
+    model_str = "creat" if REFLEXION_MODEL_PATH.exists() else "no creat"
+
+    print(
+        f"✅ Entrenament de reflexion completat. "
+        f"Mostres al CSV: {n_rows}, fitxer de model: {model_str} ({REFLEXION_MODEL_PATH})."
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/update_audiodescriptions_json_ad.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from pathlib import Path
+import sqlite3
+from typing import Iterable, Optional
+
+import json
+
+
+BASE_DEMO = Path(__file__).resolve().parent.parent
+MEDIA_ROOT = BASE_DEMO / "data" / "media"
+DB_PATHS = [
+    BASE_DEMO / "data" / "audiodescriptions.db",
+    BASE_DEMO / "temp" / "audiodescriptions.db",
+]
+
+
+def read_preprocess_json(sha1sum: str) -> Optional[str]:
+    """Lee el fichero preprocess.json para un sha1sum dado.
+
+    Devuelve el contenido en texto plano (UTF-8) o None si no existe o hay
+    errores de lectura.
+    """
+
+    video_dir = MEDIA_ROOT / sha1sum
+    path = video_dir / "preprocess.json"
+    if not path.exists():
+        return None
+
+    try:
+        # Leemos tal cual el JSON para que quede guardado como texto
+        return path.read_text(encoding="utf-8")
+    except Exception:
+        try:
+            return path.read_text(errors="ignore")
+        except Exception:
+            return None
+
+
+def ensure_json_ad_column(conn: sqlite3.Connection) -> None:
+    """Añade la columna info_ad si no existe todavía en audiodescriptions.
+
+    (Nom antic json_ad, mantingut per compatibilitat del nom de la funció.)
+    """
+
+    cur = conn.cursor()
+    cur.execute("PRAGMA table_info(audiodescriptions);")
+    cols = [row[1] for row in cur.fetchall()]
+    target_col = "info_ad"
+    if target_col not in cols:
+        cur.execute(f"ALTER TABLE audiodescriptions ADD COLUMN {target_col} TEXT;")
+        conn.commit()
+
+
+def update_db(path: Path) -> None:
+    """Actualiza una base de datos audiodescriptions.db añadiendo info_ad.
+
+    - Asegura que existe la columna info_ad.
+    - Para cada sha1sum presente en la tabla, intenta leer
+      demo/data/media/<sha1sum>/preprocess.json i guarda el seu contingut a info_ad.
+    """
+
+    if not path.exists():
+        print(f"[INFO] {path} no existe, se omite.")
+        return
+
+    print(f"[INFO] Actualitzant {path} ...")
+
+    conn = sqlite3.connect(str(path))
+    conn.row_factory = sqlite3.Row
+    try:
+        ensure_json_ad_column(conn)
+        cur = conn.cursor()
+
+        # Obtener todos los sha1sum distintos presentes en la tabla
+        cur.execute("SELECT DISTINCT sha1sum FROM audiodescriptions;")
+        rows = cur.fetchall()
+        total = len(rows)
+        print(f"  - {total} sha1sum diferents trobats.")
+
+        updated_rows = 0
+        for idx, row in enumerate(rows, start=1):
+            sha1sum = row["sha1sum"]
+            json_text = read_preprocess_json(sha1sum)
+
+            if json_text is None:
+                # No hi ha preprocess.json per a aquest sha1sum; deixem info_ad a NULL
+                print(f"    [{idx}/{total}] {sha1sum}: preprocess.json no trobat, s'omet.")
+                continue
+
+            cur.execute(
+                "UPDATE audiodescriptions SET info_ad = ? WHERE sha1sum = ?;",
+                (json_text, sha1sum),
+            )
+            updated_rows += cur.rowcount
+            print(f"    [{idx}/{total}] {sha1sum}: json_ad actualitzat per {cur.rowcount} files.")
+
+        conn.commit()
+        print(f"[OK] {path}: {updated_rows} files actualitzades amb info_ad.")
+    finally:
+        conn.close()
+
+
+def main() -> None:
+    print(f"MEDIA_ROOT: {MEDIA_ROOT} (exists={MEDIA_ROOT.exists()})")
+    if not MEDIA_ROOT.exists():
+        raise SystemExit("❌ No s'ha trobat demo/data/media")
+
+    for db_path in DB_PATHS:
+        update_db(db_path)
+
+
+if __name__ == "__main__":
+    main()

scripts/verify_temp_dbs.py

@@ -0,0 +1,87 @@
+"""Verificador de BDs de la demo (para usar desde el Space demo).
+
+Muestra qué ficheros .db existen en:
+- demo/data/db
+- demo/temp/db
+
+Se puede ejecutar como script independiente o invocado desde el código
+para dejar trazas en el log.
+"""
+
+from pathlib import Path
+import yaml
+
+# Este archivo vive en demo/scripts, así que la raíz de demo es el padre
+DEMO_ROOT = Path(__file__).resolve().parent.parent
+
+
+def read_data_origin() -> str:
+    cfg_path = DEMO_ROOT / "config.yaml"
+    if not cfg_path.exists():
+        return "(config.yaml no encontrado)"
+    try:
+        with cfg_path.open("r", encoding="utf-8") as f:
+            cfg = yaml.safe_load(f) or {}
+        app_cfg = cfg.get("app", {}) or {}
+        return str(app_cfg.get("data_origin", "internal")).lower()
+    except Exception as e:
+        return f"(error leyendo config.yaml: {e})"
+
+
+def list_dbs(path: Path) -> list[str]:
+    if not path.exists():
+        return []
+    return sorted(str(p.name) for p in path.glob("*.db"))
+
+
+def run_verification() -> None:
+    """Ejecuta la verificación y escribe por stdout.
+
+    Pensado para ser llamado desde ensure_temp_databases para dejar
+    trazas en el log del Space demo.
+    """
+    data_origin = read_data_origin()
+    data_db_dir = DEMO_ROOT / "data" / "db"
+    temp_db_dir = DEMO_ROOT / "temp" / "db"
+
+    print("=== Verificación de BDs demo (invocada desde Space demo) ===")
+    print(f"Raíz demo:       {DEMO_ROOT}")
+    print(f"data_origin:     {data_origin}")
+    print(f"data/db dir:     {data_db_dir}")
+    print(f"temp/db dir:     {temp_db_dir}")
+    print()
+
+    data_dbs = list_dbs(data_db_dir)
+    temp_dbs = list_dbs(temp_db_dir)
+
+    print("-- demo/data/db --")
+    if data_dbs:
+        for name in data_dbs:
+            print(f"  - {name}")
+    else:
+        print("  (sin .db)")
+    print()
+
+    print("-- demo/temp/db --")
+    if temp_dbs:
+        for name in temp_dbs:
+            print(f"  - {name}")
+    else:
+        print("  (sin .db)")
+    print()
+
+    missing_in_temp = [n for n in data_dbs if n not in temp_dbs]
+    if missing_in_temp:
+        print("Ficheros presentes en data/db pero NO en temp/db:")
+        for n in missing_in_temp:
+            print(f"  - {n}")
+    else:
+        print("Todos los .db de data/db están también en temp/db (o no hay .db)")
+
+
+def main() -> None:
+    run_verification()
+
+
+if __name__ == "__main__":
+    main()

scripts/video_analysis.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import List, Optional, Dict, Any
+
+
+TIME_RE = re.compile(
+    r"(?P<start>\d{2}:\d{2}:\d{2}[,\.]\d{3})\s*-->\s*(?P<end>\d{2}:\d{2}:\d{2}[,\.]\d{3})"
+)
+
+
+@dataclass
+class SRTBlock:
+    index: int
+    start: float  # seconds
+    end: float    # seconds
+    text: str
+
+
+def _parse_timestamp(ts: str) -> float:
+    """Convierte 'HH:MM:SS,mmm' o 'HH:MM:SS.mmm' a segundos (float)."""
+    ts = ts.replace(",", ".")
+    h, m, s = ts.split(":")
+    seconds, millis = (s.split("." ) + ["0"])[:2]
+    td = timedelta(
+        hours=int(h),
+        minutes=int(m),
+        seconds=int(seconds),
+        milliseconds=int(millis.ljust(3, "0")),
+    )
+    return td.total_seconds()
+
+
+def _parse_srt(srt_text: str) -> List[SRTBlock]:
+    """Parsea texto SRT en una lista de bloques SRTBlock."""
+    srt_text = srt_text.replace("\r\n", "\n").replace("\r", "\n")
+    chunks = [c.strip() for c in re.split(r"\n\s*\n", srt_text) if c.strip()]
+    blocks: List[SRTBlock] = []
+
+    for chunk in chunks:
+        lines = chunk.split("\n")
+        idx_line = 0
+        index = None
+
+        if lines and lines[0].strip().isdigit():
+            index = int(lines[0].strip())
+            idx_line = 1
+
+        time_match = None
+        time_line_idx = None
+        for i in range(idx_line, min(idx_line + 3, len(lines))):
+            m = TIME_RE.search(lines[i])
+            if m:
+                time_match = m
+                time_line_idx = i
+                break
+
+        if not time_match or time_line_idx is None:
+            continue
+
+        start = _parse_timestamp(time_match.group("start"))
+        end = _parse_timestamp(time_match.group("end"))
+        if index is None:
+            index = len(blocks) + 1
+
+        text = "\n".join(lines[time_line_idx + 1 :]).strip()
+        blocks.append(SRTBlock(index=index, start=start, end=end, text=text))
+
+    return blocks
+
+
+def analyze_srt(
+    srt_text: str,
+    *,
+    ad_markers: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    """Analiza un SRT y devuelve métricas básicas.
+
+    Métricas devueltas:
+      - duration_sec: duración total estimada del vídeo (segundos)
+      - words_per_min: número de palabras por minuto
+      - speakers_blocks_per_min: número de bloques de diálogo por minuto
+      - ad_time_ratio: porcentaje (0..1) del tiempo total con bloques marcados como AD
+      - blocks_per_min: número total de bloques por minuto
+
+    Heurísticas:
+      - Se asume que la duración del vídeo es el final del último bloque.
+      - Un "bloque de AD" es aquel cuya primera línea contiene alguno de los
+        marcadores indicados en `ad_markers` (por ejemplo: "[AD]", "AD:", "(AD)").
+    """
+
+    blocks = _parse_srt(srt_text)
+    if not blocks:
+        return {
+            "duration_sec": 0.0,
+            "words_per_min": 0.0,
+            "speakers_blocks_per_min": 0.0,
+            "ad_time_ratio": 0.0,
+            "blocks_per_min": 0.0,
+        }
+
+    duration_sec = max(b.end for b in blocks)
+    duration_min = max(duration_sec / 60.0, 1e-6)
+
+    # Palabras totales
+    total_words = 0
+    for b in blocks:
+        total_words += len(b.text.split())
+
+    # Bloques considerados de "hablante" (no AD)
+    if ad_markers is None:
+        ad_markers = ["[AD]", "AD:", "(AD)"]
+
+    def is_ad_block(block: SRTBlock) -> bool:
+        first_line = (block.text.splitlines() or [""])[0].strip().upper()
+        for mk in ad_markers:
+            if mk.upper() in first_line:
+                return True
+        return False
+
+    ad_time = 0.0
+    speech_blocks = 0
+    for b in blocks:
+        if is_ad_block(b):
+            ad_time += max(0.0, b.end - b.start)
+        else:
+            speech_blocks += 1
+
+    words_per_min = total_words / duration_min
+    speakers_blocks_per_min = speech_blocks / duration_min
+    blocks_per_min = len(blocks) / duration_min
+    ad_time_ratio = ad_time / duration_sec if duration_sec > 0 else 0.0
+
+    return {
+        "duration_sec": float(duration_sec),
+        "words_per_min": float(words_per_min),
+        "speakers_blocks_per_min": float(speakers_blocks_per_min),
+        "ad_time_ratio": float(ad_time_ratio),
+        "blocks_per_min": float(blocks_per_min),
+    }
+
+
+def embed_srt_sentences(
+    srt_text: str,
+    *,
+    model_name: str = "sentence-transformers/all-MiniLM-L6-v2",
+) -> Dict[str, Any]:
+    """Devuelve embeddings para las frases de un SRT.
+
+    Args:
+        srt_text: Contenido completo del archivo SRT como string.
+        model_name: Nombre del modelo de sentence-transformers a usar.
+
+    Returns:
+        Diccionario con:
+          - "model_name": nombre del modelo utilizado
+          - "sentences": lista de strings (una por bloque)
+          - "embeddings": lista de listas de floats con los embeddings
+
+    NOTA: Requiere instalar `sentence-transformers` y un backend de PyTorch
+    compatible. Si no está instalado, lanzará ImportError.
+    """
+
+    blocks = _parse_srt(srt_text)
+    sentences = [b.text.replace("\n", " ").strip() for b in blocks if b.text.strip()]
+
+    if not sentences:
+        return {"model_name": model_name, "sentences": [], "embeddings": []}
+
+    try:
+        from sentence_transformers import SentenceTransformer
+    except ImportError as exc:
+        raise ImportError(
+            "sentence-transformers no está instalado. "
+            "Instala la dependencia para poder generar embeddings."
+        ) from exc
+
+    model = SentenceTransformer(model_name)
+    embs = model.encode(sentences, convert_to_numpy=False)
+
+    embeddings = [list(map(float, vec)) for vec in embs]
+
+    return {
+        "model_name": model_name,
+        "sentences": sentences,
+        "embeddings": embeddings,
+    }