Upload 4 files

api_client.py

@@ -176,11 +176,208 @@ class APIClient:
 
 
     def import_databases(self) -> dict:
-        url = f"{self.base_url}/import_databases"
+        """Descarga todas las BDs del engine (/data/db) como ZIP.
+
+        Endpoint: GET /db/download_all_db_files
+        Retorna: {"zip_bytes": bytes} o {"error": str}
+        """
+
+        token = os.getenv("API_ENGINE_VEUREU", "")
+        url = f"{self.base_url}/db/download_all_db_files"
         try:
-            r = self.session.post(url, timeout=self.timeout * 2)
+            r = self.session.get(url, params={"token": token}, timeout=self.timeout * 2)
             r.raise_for_status()
-            return r.json()
+            # El endpoint devuelve un ZIP binario
+            return {"zip_bytes": r.content}
+        except requests.exceptions.RequestException as e:
+            print(f"[import_databases] Error: {e}")
+            return {"error": str(e)}
+
+
+    # --- Initial transcription (generate_initial_srt_and_info + downloads) ---
+
+    def generate_initial_srt_and_info(self, sha1sum: str) -> dict:
+        """Lanza el pipeline inicial de transcripció al engine.
+
+        Endpoint: POST /transcription/generate_initial_srt_and_info
+        Params: sha1, token (HF_TOKEN)
+        """
+
+        url = f"{self.base_url}/transcription/generate_initial_srt_and_info"
+        hf_token = os.getenv("HF_TOKEN")
+        params: dict[str, Any] = {"sha1": sha1sum}
+        if hf_token:
+            params["token"] = hf_token
+
+        try:
+            r = self.session.post(url, params=params, timeout=self.timeout * 10)
+            r.raise_for_status()
+            # El backend pot retornar text pla o JSON; ho encapsulem sempre com dict
+            if r.headers.get("content-type", "").startswith("application/json"):
+                body = r.json()
+            else:
+                body = {"srt": r.text or ""}
+            body.setdefault("status", "ok")
+            return body
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+    def download_initial_srt(self, sha1sum: str) -> dict:
+        """Descarrega l'initial.srt generat pel pipeline inicial.
+
+        Endpoint: GET /transcription/download_initial_srt
+        """
+
+        url = f"{self.base_url}/transcription/download_initial_srt"
+        hf_token = os.getenv("HF_TOKEN")
+        params: dict[str, Any] = {"sha1": sha1sum}
+        if hf_token:
+            params["token"] = hf_token
+
+        try:
+            r = self.session.get(url, params=params, timeout=self.timeout * 5)
+            r.raise_for_status()
+            # El backend retorna un fitxer de text (SRT)
+            return {"text": r.text or ""}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+    def download_initial_info(self, sha1sum: str) -> dict:
+        """Descarrega l'info.json inicial associat al vídeo.
+
+        Endpoint: GET /transcription/download_initial_info
+        """
+
+        url = f"{self.base_url}/transcription/download_initial_info"
+        hf_token = os.getenv("HF_TOKEN")
+        params: dict[str, Any] = {"sha1": sha1sum}
+        if hf_token:
+            params["token"] = hf_token
+
+        try:
+            r = self.session.get(url, params=params, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return {"text": r.text or ""}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+
+    # --- Salamandra pipeline (result.srt + free_narration.txt) ---
+
+    def generate_salamandra_result(self, sha1sum: str) -> dict:
+        """Orquestra la generació dels fitxers de sortida de Salamandra.
+
+        Endpoint: POST /salamandra/generate_salamadra_result
+        """
+
+        url = f"{self.base_url}/salamandra/generate_salamadra_result"
+        hf_token = os.getenv("HF_TOKEN")
+        params: dict[str, Any] = {"sha1": sha1sum}
+        if hf_token:
+            params["token"] = hf_token
+
+        try:
+            r = self.session.post(url, params=params, timeout=self.timeout * 20)
+            r.raise_for_status()
+            return r.json() if r.headers.get("content-type", "").startswith("application/json") else {"status": "ok"}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+    def download_salamandra_srt(self, sha1sum: str) -> dict:
+        """Descarrega el result.srt de Salamandra.
+
+        Endpoint: GET /salamandra/download_salamadra_srt
+        """
+
+        url = f"{self.base_url}/salamandra/download_salamadra_srt"
+        hf_token = os.getenv("HF_TOKEN")
+        params: dict[str, Any] = {"sha1": sha1sum}
+        if hf_token:
+            params["token"] = hf_token
+
+        try:
+            r = self.session.get(url, params=params, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return {"text": r.text or ""}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+    def download_salamandra_free_narration(self, sha1sum: str) -> dict:
+        """Descarrega el free_narration.txt de Salamandra.
+
+        Endpoint: GET /salamandra/download_salamadra_free_narration
+        """
+
+        url = f"{self.base_url}/salamandra/download_salamadra_free_narration"
+        hf_token = os.getenv("HF_TOKEN")
+        params: dict[str, Any] = {"sha1": sha1sum}
+        if hf_token:
+            params["token"] = hf_token
+
+        try:
+            r = self.session.get(url, params=params, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return {"text": r.text or ""}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+
+    # --- MoE pipeline (result.srt + free_narration.txt) ---
+
+    def generate_moe_result(self, sha1sum: str) -> dict:
+        """Orquestra la generació dels fitxers de sortida de MoE.
+
+        Endpoint: POST /moe/generate_moe_result
+        """
+
+        url = f"{self.base_url}/moe/generate_moe_result"
+        hf_token = os.getenv("HF_TOKEN")
+        params: dict[str, Any] = {"sha1": sha1sum}
+        if hf_token:
+            params["token"] = hf_token
+
+        try:
+            r = self.session.post(url, params=params, timeout=self.timeout * 20)
+            r.raise_for_status()
+            return r.json() if r.headers.get("content-type", "").startswith("application/json") else {"status": "ok"}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+    def download_moe_srt(self, sha1sum: str) -> dict:
+        """Descarrega el result.srt de MoE.
+
+        Endpoint: GET /moe/download_moe_srt
+        """
+
+        url = f"{self.base_url}/moe/download_moe_srt"
+        hf_token = os.getenv("HF_TOKEN")
+        params: dict[str, Any] = {"sha1": sha1sum}
+        if hf_token:
+            params["token"] = hf_token
+
+        try:
+            r = self.session.get(url, params=params, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return {"text": r.text or ""}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+    def download_moe_free_narration(self, sha1sum: str) -> dict:
+        """Descarrega el free_narration.txt de MoE.
+
+        Endpoint: GET /moe/download_moe_free_narration
+        """
+
+        url = f"{self.base_url}/moe/download_moe_free_narration"
+        hf_token = os.getenv("HF_TOKEN")
+        params: dict[str, Any] = {"sha1": sha1sum}
+        if hf_token:
+            params["token"] = hf_token
+
+        try:
+            r = self.session.get(url, params=params, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return {"text": r.text or ""}
         except requests.exceptions.RequestException as e:
             return {"error": str(e)}
 
@@ -457,6 +654,51 @@ class APIClient:
             return {"error": str(e)}
 
 
+    def apply_refinement(
+        self,
+        *,
+        sha1sum: str | None = None,
+        version: str | None = None,
+        srt_content: str | None = None,
+        reflection_enabled: bool = True,
+        reflexion_enabled: bool = False,
+        introspection_enabled: bool = False,
+    ) -> dict:
+        """Aplica el pipeline de refinement multi-agent sobre un SRT.
+
+        Endpoint: POST /refinement/apply_refinement
+
+        Pot treballar de dues maneres:
+          - Passant sha1sum+version perquè el backend llegeixi l'SRT de les BDs
+          - Passant srt_content explícitament
+        """
+
+        url = f"{self.base_url}/refinement/apply_refinement"
+        hf_token = os.getenv("HF_TOKEN")
+
+        payload: dict[str, Any] = {
+            "reflection_enabled": bool(reflection_enabled),
+            "reflexion_enabled": bool(reflexion_enabled),
+            "introspection_enabled": bool(introspection_enabled),
+        }
+
+        if sha1sum is not None:
+            payload["sha1sum"] = sha1sum
+        if version is not None:
+            payload["version"] = version
+        if srt_content is not None:
+            payload["srt_content"] = srt_content
+        if hf_token:
+            payload["token"] = hf_token
+
+        try:
+            r = self.session.post(url, json=payload, timeout=self.timeout * 10)
+            r.raise_for_status()
+            return r.json() if r.headers.get("content-type", "").startswith("application/json") else {"status": "ok"}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+
     def refine_narration(self, dialogues_srt: str, frame_descriptions_json: str = "[]", config_path: str = "config.yaml") -> dict:
         """Llama al endpoint del engine /refine_narration para generar narrativa y/o SRT."""
         url = f"{self.base_url}/refine_narration"

config.yaml

@@ -1,6 +1,6 @@
 app:
   title: "Veureu AD"
-  data_origin: "internal"   # ("internal" | "external")
+  data_origin: "external"   # ("internal" | "external")
   manual_validation_enabled: false
 
 api:

databases.py

@@ -359,9 +359,17 @@ def get_audiodescription_history(sha1sum: str, version: str) -> list[sqlite3.Row
         print(
             "[DEBUG] get_audiodescription_history",
             f"DB={AUDIODESCRIPTIONS_DB_PATH}",
+            f"exists={AUDIODESCRIPTIONS_DB_PATH.exists()}",
             f"sha1sum={sha1sum}",
             f"version={version}",
         )
+        # Verificar cuántas filas totales hay en la tabla
+        try:
+            with _connect_audiodescriptions_db() as conn_check:
+                total_rows = conn_check.execute("SELECT COUNT(*) FROM audiodescriptions").fetchone()[0]
+                print(f"[DEBUG] Total rows in audiodescriptions table: {total_rows}")
+        except Exception as e:
+            print(f"[DEBUG] Error checking total rows: {e}")
         print(f"[DEBUG] get_audiodescription_history SQL: {sql}")
         print(f"[DEBUG] get_audiodescription_history params: {(sha1sum, version)}")
 

persistent_data_gate.py

@@ -79,16 +79,33 @@ def ensure_temp_databases(base_dir: Path, api_client) -> None:
 
     if data_origin == "internal":
         source_dir = base_dir / "data"
+        print(f"[ensure_temp_databases] data_origin=internal, source_dir={source_dir}")
+        print(f"[ensure_temp_databases] source_dir.exists()={source_dir.exists()}")
         if source_dir.exists():
-            for entry in source_dir.glob("*.db"):
+            db_files = list(source_dir.glob("*.db"))
+            print(f"[ensure_temp_databases] Found {len(db_files)} .db files in {source_dir}")
+            for entry in db_files:
                 dest = temp_dir / entry.name
+                print(f"[ensure_temp_databases] Copying {entry} -> {dest}")
                 shutil.copy2(entry, dest)
+        else:
+            print(f"[ensure_temp_databases] WARNING: source_dir does not exist!")
     else:
+        # Mode external: descargar BDs del engine y descomprimir en temp/
         if api_client is None:
+            print("[ensure_temp_databases] api_client is None, skipping import")
             return
         try:
-            api_client.import_databases()
-        except Exception:
+            resp = api_client.import_databases()
+            zip_bytes = resp.get("zip_bytes") if isinstance(resp, dict) else None
+            if zip_bytes:
+                _extract_zip_bytes(zip_bytes, temp_dir)
+                print(f"[ensure_temp_databases] Extracted DBs to {temp_dir}")
+            else:
+                err = resp.get("error") if isinstance(resp, dict) else "unknown"
+                print(f"[ensure_temp_databases] No zip_bytes in response: {err}")
+        except Exception as e:
+            print(f"[ensure_temp_databases] Exception: {e}")
             return
 
     # Un cop les BDs estan a temp/, crear una còpia de seguretat a temp/backup