Upload 9 files

api_client.py

@@ -171,6 +171,61 @@ class APIClient:
             # Devolvemos un diccionario con error para que la UI lo muestre
             return {"error": str(e)}
 
+
+    def import_databases(self) -> dict:
+        url = f"{self.base_url}/import_databases"
+        try:
+            r = self.session.post(url, timeout=self.timeout * 2)
+            r.raise_for_status()
+            return r.json()
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+
+    def import_media(self, sha1sum: str) -> dict:
+        url = f"{self.base_url}/import_media/{sha1sum}"
+        try:
+            r = self.session.get(url, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return {"zip_bytes": r.content}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+
+    def import_media_version(self, sha1sum: str, version: str) -> dict:
+        url = f"{self.base_url}/import_media_version/{sha1sum}/{version}"
+        try:
+            r = self.session.get(url, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return {"zip_bytes": r.content}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+
+    def update_databases(self, payload: dict) -> dict:
+        """Envia les sentències SQL generades a l'endpoint /update_databases."""
+
+        url = f"{self.base_url}/update_databases"
+        try:
+            r = self.session.post(url, json=payload, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return r.json()
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+
+    def export_media(self, zip_bytes: bytes) -> dict:
+        """Envia un ZIP amb els nous vídeos a l'endpoint /export_media."""
+
+        url = f"{self.base_url}/export_media"
+        files = {"media_zip": ("media_export.zip", zip_bytes, "application/zip")}
+        try:
+            r = self.session.post(url, files=files, timeout=self.timeout * 10)
+            r.raise_for_status()
+            return r.json()
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
     def generate_audiodescription(self, video_bytes: bytes, video_name: str) -> dict:
         """Llama al endpoint del engine /generate_audiodescription con un MP4 en memoria."""
         url = f"{self.base_url}/generate_audiodescription"

app.py

@@ -13,6 +13,7 @@ from databases import set_db_path, init_schema, set_blockchain_enabled
 from api_client import APIClient
 from utils import ensure_dirs
 from auth import initialize_auth_system, render_login_form, render_sidebar, require_login
+from persistent_data_gate import ensure_temp_databases
 from mobile_verification import render_mobile_verification_screen, get_user_permissions
 from compliance_client import compliance_client
 from page_modules.process_video import render_process_video_page
@@ -84,8 +85,15 @@ USE_MOCK = bool(CFG.get("app", {}).get("use_mock", False))  # si no la tienes en
 BLOCKCHAIN_ENABLED = bool(CFG.get("blockchain", {}).get("enabled", False))
 API_TOKEN = CFG.get("api", {}).get("token") or os.getenv("API_SHARED_TOKEN")
 
+# Cliente del backend (engine)
+api = APIClient(BACKEND_BASE_URL, use_mock=USE_MOCK, data_dir=DATA_DIR, token=API_TOKEN, tts_url=TTS_URL)
+
 os.makedirs(DATA_DIR, exist_ok=True)
 ensure_dirs(DATA_DIR)
+
+base_dir = Path(__file__).parent
+ensure_temp_databases(base_dir, api)
+
 DB_PATH = os.path.join(DATA_DIR, "users.db")
 set_db_path(DB_PATH)
 
@@ -97,14 +105,33 @@ init_schema()
 # Initialize authentication system and sync default users
 initialize_auth_system(DB_PATH)
 
-api = APIClient(BACKEND_BASE_URL, use_mock=USE_MOCK, data_dir=DATA_DIR, token=API_TOKEN, tts_url=TTS_URL)
-
 # Identificador de sessió per a traça d'esdeveniments
 if "session_id" not in st.session_state:
     st.session_state.session_id = str(uuid.uuid4())
 
+# Exposar client d'API al session_state per a altres mòduls (p.ex. auth/persistent_data_gate)
+st.session_state.api_client = api
+
 st.set_page_config(page_title="Veureu — Audiodescripció", page_icon="🎬", layout="wide")
 
+# Estil global: botons primaris en taronja (en lloc de blau per defecte)
+st.markdown(
+    """
+    <style>
+    .stButton > button[kind="primary"] {
+        background-color: #f97316;
+        border-color: #ea580c;
+        color: white;
+    }
+    .stButton > button[kind="primary"]:hover {
+        background-color: #ea580c;
+        border-color: #c2410c;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
 # Initialize session state for user
 if "user" not in st.session_state:
     st.session_state.user = None

auth.py

@@ -15,6 +15,7 @@ from mobile_verification import (
     get_user_permissions,
     show_verification_status_in_sidebar
 )
+from persistent_data_gate import confirm_changes_and_logout
 
 
 def log(msg: str):
@@ -165,11 +166,6 @@ def render_sidebar():
             
             # Mostrar estado de verificación SMS
             show_verification_status_in_sidebar()
-            
-            if st.button("Tancar sessió"):
-                st.session_state.user = None
-                st.session_state.sms_verified = None
-                st.rerun()
         
         if st.session_state.user:
             # Obtener permisos del usuario
@@ -202,6 +198,22 @@ def render_sidebar():
                 page_options,
                 index=0
             )
+            st.markdown("---")
+            st.button("Confirmar canvis", key="confirmar_canvis", use_container_width=True)
+
+            if st.button("Confirmar canvis i tancar sessió"):
+                # Persistir canvis de la sessió actual abans de tancar
+                try:
+                    base_dir = Path(__file__).parent
+                    session_id = st.session_state.get("session_id", "")
+                    api_client = st.session_state.get("api_client")
+                    confirm_changes_and_logout(base_dir, api_client, session_id)
+                except Exception:
+                    pass
+
+                st.session_state.user = None
+                st.session_state.sms_verified = None
+                st.rerun()
         else:
             page = None
     

page_modules/analyze_audiodescriptions.py

@@ -11,6 +11,7 @@ import streamlit as st
 import yaml
 
 from utils import save_bytes
+from persistent_data_gate import ensure_media_for_video
 from databases import (
     get_accessible_videos_with_sha1,
     insert_demo_feedback_row,
@@ -145,7 +146,8 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
         st.stop()
 
     # Base de media: demo/temp/media/<sha1sum>
-    base_media_dir = Path(__file__).resolve().parent.parent / "temp" / "media"
+    base_dir = Path(__file__).resolve().parent.parent
+    base_media_dir = base_dir / "temp" / "media"
 
     # DEBUG: llistar subcarpetes actuals sota demo/temp/media
     try:
@@ -181,6 +183,8 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
             del st.session_state["eval_values"]
         st.rerun()
 
+    ensure_media_for_video(base_dir, api, selected_sha1)
+
     vid_dir = base_media_dir / selected_sha1
     mp4s = sorted(vid_dir.glob("*.mp4"))
 
@@ -199,6 +203,8 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
         
         # Cargar valores de evaluación cuando cambia la versión
         if subcarpeta_seleccio:
+            ensure_media_for_video(base_dir, api, selected_sha1, subcarpeta_seleccio)
+
             # Clau única per vídeo (sha1) + versió seleccionada
             current_version_key = f"{selected_sha1}_{subcarpeta_seleccio}"
             if "last_version_key" not in st.session_state or st.session_state.last_version_key != current_version_key:

persistent_data_gate.py

@@ -0,0 +1,263 @@
+import os
+import shutil
+import zipfile
+import io
+from pathlib import Path
+from typing import Optional
+
+
+def _load_data_origin(base_dir: Path) -> str:
+    """Lee demo/config.yaml y devuelve data_origin (internal|external)."""
+
+    cfg_path = base_dir / "config.yaml"
+    origin = "internal"
+    try:
+        import yaml
+
+        with cfg_path.open("r", encoding="utf-8") as f:
+            cfg = yaml.safe_load(f) or {}
+        origin = str(cfg.get("data_origin", "internal")).lower()
+    except Exception:
+        origin = "internal"
+    return origin
+
+
+def ensure_temp_databases(base_dir: Path, api_client) -> None:
+    """Garantiza que las BDs *.db estén presentes en demo/temp antes del login.
+
+    - data_origin == "internal": copia demo/data/*.db -> demo/temp/*.db
+    - data_origin == "external": llama al endpoint remoto import_databases.
+    """
+
+    data_origin = _load_data_origin(base_dir)
+    temp_dir = base_dir / "temp"
+    temp_dir.mkdir(parents=True, exist_ok=True)
+
+    if data_origin == "internal":
+        source_dir = base_dir / "data"
+        if source_dir.exists():
+            for entry in source_dir.glob("*.db"):
+                dest = temp_dir / entry.name
+                shutil.copy2(entry, dest)
+    else:
+        if api_client is None:
+            return
+        try:
+            api_client.import_databases()
+        except Exception:
+            return
+
+
+def _extract_zip_bytes(zip_bytes: bytes, target_dir: Path) -> None:
+    target_dir.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
+        zf.extractall(target_dir)
+
+def ensure_media_for_video(
+    base_dir: Path,
+    api_client,
+    sha1sum: str,
+    version: Optional[str] = None,
+) -> None:
+    """Garantiza que exista demo/temp/media/<sha1sum>[/<version>].
+
+    - data_origin == "internal":
+      * copia video.mp4 desde demo/data/media/<sha1sum>/ a demo/temp/media/<sha1sum>/
+      * si version, copia carpeta demo/data/media/<sha1sum>/<version> -> demo/temp/media/<sha1sum>/<version>
+    - data_origin == "external":
+      * usa endpoints del engine para obtener zips de media y descomprimirlos en demo/temp/media.
+    """
+
+    data_origin = _load_data_origin(base_dir)
+    temp_media_root = base_dir / "temp" / "media"
+    data_media_root = base_dir / "data" / "media"
+
+    video_dir_temp = temp_media_root / sha1sum
+    if not video_dir_temp.exists():
+        video_dir_temp.mkdir(parents=True, exist_ok=True)
+        if data_origin == "internal":
+            src_video = data_media_root / sha1sum / "video.mp4"
+            if src_video.exists():
+                shutil.copy2(src_video, video_dir_temp / "video.mp4")
+        else:
+            if api_client is not None:
+                try:
+                    resp = api_client.import_media(sha1sum)
+                    zip_bytes = resp.get("zip_bytes") if isinstance(resp, dict) else None
+                    if zip_bytes:
+                        _extract_zip_bytes(zip_bytes, video_dir_temp)
+                except Exception:
+                    pass
+
+    if not version:
+        return
+
+    version_dir_temp = video_dir_temp / version
+    if version_dir_temp.exists():
+        return
+
+    if data_origin == "internal":
+        src_version_dir = data_media_root / sha1sum / version
+        if src_version_dir.exists():
+            shutil.copytree(src_version_dir, version_dir_temp, dirs_exist_ok=True)
+    else:
+        if api_client is None:
+            return
+        try:
+            resp = api_client.import_media_version(sha1sum, version)
+            zip_bytes = resp.get("zip_bytes") if isinstance(resp, dict) else None
+            if zip_bytes:
+                _extract_zip_bytes(zip_bytes, version_dir_temp)
+        except Exception:
+            return
+
+
+def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> None:
+    """Confirma canvis de la sessió actual i els persisteix.
+
+    1) Per a totes les taules de demo/temp/*.db que tinguin camp 'session' amb
+       valor igual a session_id, es generen INSERTs per aplicar els canvis a
+       demo/data/*.db (mode internal) o s'envien a l'endpoint update_databases
+       (mode external).
+
+    2) Per als nous vídeos registrats a demo/temp/videos.db amb session=session_id,
+       es miren les carpetes demo/temp/media/<sha1sum> corresponents.
+       - internal: es copien a demo/data/media/<sha1sum>.
+       - external: es crea un ZIP amb totes aquestes carpetes i s'envia a
+         l'endpoint export_media del backend.
+    """
+
+    if not session_id:
+        return
+
+    data_origin = _load_data_origin(base_dir)
+    temp_dir = base_dir / "temp"
+    data_dir = base_dir / "data"
+
+    # --- 1) Sincronitzar taules amb camp 'session' ---
+    sql_statements: list[str] = []
+
+    for db_path in temp_dir.glob("*.db"):
+        target_db = data_dir / db_path.name
+        import sqlite3
+
+        with sqlite3.connect(str(db_path)) as src_conn:
+            src_conn.row_factory = sqlite3.Row
+            cur = src_conn.cursor()
+
+            # Llistar taules usuari
+            cur.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+            )
+            tables = [r[0] for r in cur.fetchall()]
+
+            for table in tables:
+                # Mirar si la taula té columna 'session'
+                cur.execute(f"PRAGMA table_info({table})")
+                cols = cur.fetchall()
+                col_names = [c[1] for c in cols]
+                if "session" not in col_names:
+                    continue
+
+                # Files per a la sessió actual
+                cur.execute(f"SELECT * FROM {table} WHERE session = ?", (session_id,))
+                rows = cur.fetchall()
+                if not rows:
+                    continue
+
+                columns_sql = ", ".join(col_names)
+                placeholders = ", ".join(["?"] * len(col_names))
+                insert_sql = f"INSERT OR REPLACE INTO {table} ({columns_sql}) VALUES ({placeholders})"
+
+                for row in rows:
+                    values = [row[name] for name in col_names]
+                    if data_origin == "internal":
+                        # Aplicar directament a demo/data/*.db
+                        target_db.parent.mkdir(parents=True, exist_ok=True)
+                        with sqlite3.connect(str(target_db)) as dst_conn:
+                            dst_conn.execute(insert_sql, values)
+                            dst_conn.commit()
+                    else:
+                        # Guardar la sentència + valors com a SQL literal simple
+                        # (assumim que el backend farà el parse o executarà directament).
+                        # Per simplicitat, fem una interpolació segura bàsica.
+                        def _sql_literal(v):
+                            if v is None:
+                                return "NULL"
+                            if isinstance(v, (int, float)):
+                                return str(v)
+                            return "'" + str(v).replace("'", "''") + "'"
+
+                        values_sql = ", ".join(_sql_literal(v) for v in values)
+                        full_sql = f"INSERT OR REPLACE INTO {table} ({columns_sql}) VALUES ({values_sql});"
+                        sql_statements.append(full_sql)
+
+    if data_origin != "internal" and sql_statements and api_client is not None:
+        try:
+            api_client.update_databases({"statements": sql_statements})
+        except Exception:
+            pass
+
+    # --- 2) Nous vídeos a videos.db associats a la sessió ---
+    videos_db = temp_dir / "videos.db"
+    new_sha1s: set[str] = set()
+
+    try:
+        import sqlite3
+
+        with sqlite3.connect(str(videos_db)) as vconn:
+            vconn.row_factory = sqlite3.Row
+            cur = vconn.cursor()
+            # Només si existeix columna 'session' i 'sha1sum'
+            cur.execute("PRAGMA table_info(videos)")
+            cols = cur.fetchall()
+            col_names = [c[1] for c in cols]
+            if "session" in col_names and "sha1sum" in col_names:
+                cur.execute(
+                    "SELECT DISTINCT sha1sum FROM videos WHERE session = ?", (session_id,)
+                )
+                for r in cur.fetchall():
+                    if r["sha1sum"]:
+                        new_sha1s.add(str(r["sha1sum"]))
+    except Exception:
+        new_sha1s = set()
+
+    if not new_sha1s:
+        return
+
+    temp_media_root = temp_dir / "media"
+
+    if data_origin == "internal":
+        # Copiar carpetes de media noves a demo/data/media
+        data_media_root = data_dir / "media"
+        for sha1 in new_sha1s:
+            src_dir = temp_media_root / sha1
+            dst_dir = data_media_root / sha1
+            if src_dir.exists():
+                shutil.copytree(src_dir, dst_dir, dirs_exist_ok=True)
+    else:
+        # Crear un ZIP amb totes les carpetes de sha1sum i enviar-lo a export_media
+        if api_client is None:
+            return
+
+        import tempfile
+
+        try:
+            with tempfile.TemporaryDirectory() as tmpdir:
+                zip_path = Path(tmpdir) / "media_export.zip"
+                with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+                    for sha1 in new_sha1s:
+                        src_dir = temp_media_root / sha1
+                        if not src_dir.exists():
+                            continue
+                        for root, _, files in os.walk(src_dir):
+                            root_path = Path(root)
+                            for fname in files:
+                                fpath = root_path / fname
+                                rel_path = fpath.relative_to(temp_media_root)
+                                zf.write(fpath, arcname=str(rel_path))
+
+                zip_bytes = zip_path.read_bytes()
+                api_client.export_media(zip_bytes)
+        except Exception:
+            return