Upload 10 files

app.py

@@ -115,7 +115,7 @@ ensure_dirs(DATA_DIR)
 base_dir = Path(__file__).parent
 ensure_temp_databases(base_dir, api)
 
-DB_PATH = os.path.join(DATA_DIR, "users.db")
+DB_PATH = os.path.join(DATA_DIR, "db", "users.db")
 set_db_path(DB_PATH)
 
 # Configurar si els esdeveniments s'han de registrar a SQLite o a AWS QLDB

config.yaml

@@ -2,7 +2,7 @@
 # Title and basic app behaviour.
 app:
   title: "Veureu AD"
-  data_origin: "external"   # Where data comes from: "internal" or "external".
+  data_origin: "internal"   # Where data comes from: "internal" or "external".
   manual_validation_enabled: false  # If true, require manual validation steps in the UI.
 
 ## Engine API connection

databases.py

@@ -14,19 +14,19 @@ DEFAULT_DB_PATH = None  # set by set_db_path at runtime
 USE_BLOCKCHAIN_FOR_EVENTS = False
 
 # Ruta a la base de dades de feedback agregat (separa de users.db)
-FEEDBACK_DB_PATH = Path(__file__).resolve().parent / "temp" / "feedback.db"
+FEEDBACK_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "feedback.db"
 
 # Ruta a la base de dades de captions per als scores
-CAPTIONS_DB_PATH = Path(__file__).resolve().parent / "temp" / "captions.db"
+CAPTIONS_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "captions.db"
 
-# Ruta a la base de dades d'esdeveniments (events.db) a demo/temp
-EVENTS_DB_PATH = Path(__file__).resolve().parent / "temp" / "events.db"
+# Ruta a la base de dades d'esdeveniments (events.db) a demo/temp/db
+EVENTS_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "events.db"
 
-# Ruta a la base de dades de vídeos (videos.db) a demo/temp
-VIDEOS_DB_PATH = Path(__file__).resolve().parent / "temp" / "videos.db"
+# Ruta a la base de dades de vídeos (videos.db) a demo/temp/db
+VIDEOS_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "videos.db"
 
-# Ruta a la base de dades d'audiodescripcions (audiodescriptions.db) a demo/temp
-AUDIODESCRIPTIONS_DB_PATH = Path(__file__).resolve().parent / "temp" / "audiodescriptions.db"
+# Ruta a la base de dades d'audiodescripcions (audiodescriptions.db) a demo/temp/db
+AUDIODESCRIPTIONS_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "audiodescriptions.db"
 
 
 def set_db_path(db_path: str):

page_modules/process_video.py

@@ -24,7 +24,7 @@ from persistent_data_gate import ensure_temp_databases, _load_data_origin
 
 
 def get_all_catalan_names():
-    """Return the predefined lists of common Catalan names (male and female)."""
+    """Retorna tots els noms catalans disponibles."""
     noms_home = ["Jordi", "Marc", "Pau", "Pere", "Joan", "Josep", "David", "Àlex", "Guillem", "Albert",
                  "Arnau", "Martí", "Bernat", "Oriol", "Roger", "Pol", "Lluís", "Sergi", "Carles", "Xavier"]
     noms_dona = ["Maria", "Anna", "Laura", "Marta", "Cristina", "Núria", "Montserrat", "Júlia", "Sara", "Carla",
@@ -33,7 +33,7 @@ def get_all_catalan_names():
 
 
 def _log(msg: str) -> None:
-    """Logging helper to stderr with timestamp (kept consistent with auth.py)."""
+    """Helper de logging a stderr amb timestamp (coherent amb auth.py)."""
     ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     sys.stderr.write(f"[{ts}] {msg}\n")
     sys.stderr.flush()
@@ -97,7 +97,7 @@ def _get_video_duration(path: str) -> float:
         except FileNotFoundError:
             pass
 
-    # Last resort: try with OpenCV if it is available
+    # Últim recurs: intentar amb OpenCV si està disponible
     try:
         import cv2
 
@@ -142,7 +142,7 @@ def _transcode_video(input_path: str, output_path: str, max_duration: int | None
 def render_process_video_page(api, backend_base_url: str) -> None:
     st.header("Processar un nou clip de vídeo")
 
-    # Read config.yaml (app flags and media limits)
+    # Llegir config.yaml (flags d'app i límits de media)
     base_dir = Path(__file__).parent.parent
     config_path = base_dir / "config.yaml"
     manual_validation_enabled = True
@@ -156,13 +156,13 @@ def render_process_video_page(api, backend_base_url: str) -> None:
             manual_validation_enabled = bool(app_cfg.get("manual_validation_enabled", True))
 
             media_cfg = cfg.get("media", {}) or {}
-            # Configurable limits for file size and video duration
+            # Límits configurables de mida i durada
             max_size_mb = int(media_cfg.get("max_size_mb", max_size_mb))
             max_duration_s = int(media_cfg.get("max_duration_s", max_duration_s))
     except Exception:
         manual_validation_enabled = True
 
-    # CSS to stabilize carousels and avoid layout vibration
+    # CSS para estabilizar carruseles y evitar vibración del layout
     st.markdown("""
     <style>
     /* Contenedor de imagen con aspect ratio fijo para evitar saltos */
@@ -272,11 +272,11 @@ def render_process_video_page(api, backend_base_url: str) -> None:
     if "video_validation_approved" not in st.session_state:
         st.session_state.video_validation_approved = False
 
-    # --- 1. Video upload ---
+    # --- 1. Subida del vídeo ---
     MAX_SIZE_MB = max_size_mb
     MAX_DURATION_S = max_duration_s
 
-    # Visibility selector (private/public) shown to the right of the uploader
+    # Selector de visibilitat (privat/públic), a la dreta del uploader
     if "video_visibility" not in st.session_state:
         st.session_state.video_visibility = "Privat"
 
@@ -305,7 +305,7 @@ def render_process_video_page(api, backend_base_url: str) -> None:
         )
 
     if uploaded_file is not None:
-        # Reset session state if a new file is uploaded
+        # 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"
         ):
@@ -373,7 +373,7 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                 }
                             )
 
-                            # Register video upload event into events.db
+                            # Registre d'esdeveniment de pujada de vídeo a events.db
                             try:
                                 session_id = st.session_state.get("session_id", "")
                                 ip = st.session_state.get("client_ip", "")
@@ -403,7 +403,7 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                             except Exception as e:
                                 print(f"[events] Error registrant esdeveniment de pujada: {e}")
 
-                            # If working in "external" mode, send the video to engine pending_videos
+                            # Si treballem en mode external, enviar el vídeo a pending_videos de l'engine
                             try:
                                 base_dir = Path(__file__).parent.parent
                                 data_origin = _load_data_origin(base_dir)
@@ -411,11 +411,11 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                     pending_root = base_dir / "temp" / "pending_videos" / sha1
                                     pending_root.mkdir(parents=True, exist_ok=True)
                                     local_pending_path = pending_root / "video.mp4"
-                                    # Save local copy of the pending video
+                                    # Guardar còpia local del vídeo pendent
                                     with local_pending_path.open("wb") as f_pending:
                                         f_pending.write(video_bytes)
 
-                                    # Send the video to the backend engine so it appears in the pending list
+                                    # Enviar el vídeo al backend engine perquè aparegui a la llista de pendents
                                     try:
                                         resp_pending = api.upload_pending_video(video_bytes, uploaded_file.name)
                                         _log(f"[pending_videos] upload_pending_video resp: {resp_pending}")
@@ -424,7 +424,7 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                             except Exception as e_ext:
                                 _log(f"[pending_videos] Error bloc exterior upload_pending_video: {e_ext}")
 
-                            # Mark validation state according to security/validation configuration
+                            # Marcar estat de validació segons la configuració de seguretat
                             if manual_validation_enabled:
                                 st.session_state.video_requires_validation = True
                                 st.session_state.video_validation_approved = False
@@ -434,9 +434,9 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                         sha1sum=sha1,
                                     )
                                 except Exception as sms_exc:
-                                    print(f"[VIDEO SMS] Error sending notification to validator: {sms_exc}")
+                                    print(f"[VIDEO SMS] Error enviant notificació al validor: {sms_exc}")
                             else:
-                                # Without manual validation: consider it automatically approved
+                                # Sense validació manual: es considera validat automàticament
                                 st.session_state.video_requires_validation = False
                                 st.session_state.video_validation_approved = True
 
@@ -452,7 +452,7 @@ def render_process_video_page(api, backend_base_url: str) -> None:
         if manual_validation_enabled and st.session_state.get("video_requires_validation") and not st.session_state.get("video_validation_approved"):
             st.info("Per favor, espera a la revisió humana del vídeo.")
 
-    # Check if there is a video approval event in events.db for the current sha1sum
+    # Comprovar si hi ha aprovació de vídeo a events.db per al sha1sum actual
     current_sha1 = None
     if st.session_state.get("video_uploaded"):
         current_sha1 = st.session_state.video_uploaded.get("sha1sum")
@@ -460,8 +460,8 @@ def render_process_video_page(api, backend_base_url: str) -> None:
         if has_video_approval_event(current_sha1):
             st.session_state.video_validation_approved = True
 
-    # We can only continue with casting if the video does not require validation
-    # or if it has already been marked as approved.
+    # Només podem continuar amb el càsting si el vídeo no requereix validació
+    # o si ja ha estat marcat com a validat.
     can_proceed_casting = (
         st.session_state.get("video_uploaded") is not None
         and (
@@ -470,8 +470,8 @@ def render_process_video_page(api, backend_base_url: str) -> None:
         )
     )
 
-    # --- 2. Detection form with sliders ---
-    # Only shown once there is an uploaded video and it is validated (if validation is required).
+    # --- 2. Form de detecció amb sliders ---
+    # Només es mostra quan ja hi ha un vídeo pujat **i** està validat (si cal validació).
     if can_proceed_casting:
         st.markdown("---")
         
@@ -512,7 +512,7 @@ def render_process_video_page(api, backend_base_url: str) -> None:
             msg_ad.empty()
             try:
                 v = st.session_state.video_uploaded
-                # Reset detection-related state before starting
+                # Reset estat abans de començar
                 st.session_state.scene_clusters = None
                 st.session_state.scene_detection_done = False
                 st.session_state.detect_done = False
@@ -554,7 +554,7 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                 msg_detect.error("El processament ha fallat al servidor.")
                                 break
 
-                            # Success: collect results from engine job
+                            # Success
                             res = stt.get("results", {})
                             chars = res.get("characters", [])
                             fl = res.get("face_labels", [])
@@ -582,7 +582,7 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                             else:
                                 msg_detect.info("No s'han detectat cares en aquest vídeo.")
 
-                            # Detect scenes based on configured parameters
+                            # Detect scenes
                             try:
                                 scene_out = api.detect_scenes(
                                     video_bytes=v["bytes"],
@@ -611,8 +611,8 @@ def render_process_video_page(api, backend_base_url: str) -> None:
             except Exception as e:
                 msg_detect.error(f"Error inesperat: {e}")
 
-    # Button to manually refresh the validation status of the video
-    # Only shown while the video is waiting for human validation
+    # Botó per actualitzar manualment l'estat de validació del vídeo
+    # Només es mostra mentre el vídeo està pendent de validació humana
     if (
         st.session_state.get("video_uploaded")
         and st.session_state.get("video_requires_validation")
@@ -623,7 +623,7 @@ def render_process_video_page(api, backend_base_url: str) -> None:
             st.caption("⏳ Vídeo pendent de validació humana.")
         with col_refresh:
             if st.button("🔄 Actualitzar estat de validació", key="refresh_video_validation"):
-                # Re-synchronise temporary DBs (including events.db) from the origin
+                # Re-sincronitzar BDs temp (inclosa events.db) des de l'origen
                 try:
                     base_dir = Path(__file__).parent.parent
                     api_client = st.session_state.get("api_client")
@@ -638,7 +638,7 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                     else:
                         st.info("Encara no s'ha registrat cap aprovació per a aquest vídeo.")
 
-    # --- 3. Face carousels ---
+    # --- 3. Carruseles de cares ---
     if st.session_state.get("characters_detected") is not None:
         st.markdown("---")
         n_face_clusters = len(st.session_state.get("characters_detected") or [])
@@ -1031,202 +1031,298 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                     import traceback
                                     traceback.print_exc()
 
-    # --- 6. Combined characters (faces + voices) ---
+    # --- 6. Confirmación de casting y personajes combinados ---
     if st.session_state.get("detect_done"):
         st.markdown("---")
-        st.subheader("👥 Personatges")
-
-        def normalize_name(name: str) -> str:
-            import unicodedata
-            name_upper = name.upper()
-            name_normalized = ''.join(
-                c for c in unicodedata.normalize('NFD', name_upper)
-                if unicodedata.category(c) != 'Mn'
-            )
-            return name_normalized
-
-        characters_detected = st.session_state.get("characters_detected") or []
-
-        chars_payload: list[dict[str, Any]] = []
-        for idx, ch in enumerate(characters_detected):
-            try:
-                folder_name = Path(ch.get("folder") or "").name
-            except Exception:
-                folder_name = ""
-            char_id = ch.get("id") or folder_name or f"char{idx+1}"
-
-            def _safe_key(value: str) -> str:
-                key = re.sub(r"[^0-9a-zA-Z_]+", "_", value or "")
-                return key or f"cluster_{idx+1}"
-
-            key_prefix = _safe_key(f"char_{idx+1}_{char_id}")
-            name = st.session_state.get(f"{key_prefix}_name") or ch.get("name") or f"Cluster {idx+1}"
-            name_normalized = normalize_name(name)
-            desc = st.session_state.get(f"{key_prefix}_desc", "").strip()
-            chars_payload.append({
-                "id": char_id,
-                "name": name,
-                "name_normalized": name_normalized,
-                "face_key_prefix": key_prefix,
-                "face_files": ch.get("face_files") or [],
-                "char_data": ch,
-                "description": desc,
-                "folder": ch.get("folder"),
-            })
-
-        used_names_home = []
-        used_names_dona = []
-        noms_home_all, noms_dona_all = get_all_catalan_names()
-        for cp in chars_payload:
-            face_name = cp.get("name", "")
-            if face_name in noms_home_all:
-                used_names_home.append(face_name)
-            elif face_name in noms_dona_all:
-                used_names_dona.append(face_name)
-
-        segs = st.session_state.get("audio_segments") or []
-        vlabels = st.session_state.get("voice_labels") or []
-        vname = st.session_state.get("video_name_from_engine") or ""
-        voice_clusters_by_name: dict[str, dict[str, Any]] = {}
-
-        for i, seg in enumerate(segs):
-            lbl = vlabels[i] if i < len(vlabels) else -1
-            if not (isinstance(lbl, int) and lbl >= 0):
-                continue
-
-            vpref = f"voice_{int(lbl):02d}"
-            default_voice_name = get_catalan_name_for_speaker(int(lbl), used_names_home, used_names_dona)
-            voice_name = st.session_state.get(f"{vpref}_name") or default_voice_name
-            voice_desc = st.session_state.get(f"{vpref}_desc", "").strip()
-            voice_norm = normalize_name(voice_name)
-
-            clip_local = seg.get("clip_path")
-            fname = os.path.basename(clip_local) if clip_local else None
-            if not fname:
-                continue
-
-            voice_clusters_by_name.setdefault(voice_norm, {
-                "voice_key_prefix": vpref,
-                "clips": [],
-                "label": int(lbl),
-                "original_name": voice_name,
-                "description": voice_desc,
-            })
-            voice_clusters_by_name[voice_norm]["clips"].append(fname)
-
-        all_normalized_names = set([c["name_normalized"] for c in chars_payload] + list(voice_clusters_by_name.keys()))
-
-        for pidx, norm_name in enumerate(sorted(all_normalized_names)):
-            face_items = [c for c in chars_payload if c["name_normalized"] == norm_name]
-            voice_data = voice_clusters_by_name.get(norm_name)
-
-            display_name = face_items[0]["name"] if face_items else (voice_data["original_name"] if voice_data else norm_name)
-
-            descriptions: list[str] = []
-            for face_item in face_items:
-                if face_item["description"]:
-                    descriptions.append(face_item["description"])
-            if voice_data and voice_data.get("description"):
-                descriptions.append(voice_data["description"])
-            combined_description = "\n".join(descriptions) if descriptions else ""
-
-            st.markdown(f"**{pidx+1}. {display_name}**")
-
-            all_faces = []
-            for face_item in face_items:
-                all_faces.extend(face_item["face_files"])
-
-            face_data = face_items[0] if face_items else None
-
-            col_faces, col_voices, col_text = st.columns([1, 1, 1.5])
-
-            with col_faces:
-                if all_faces:
-                    carousel_key = f"combined_face_{pidx}"
-                    if f"{carousel_key}_idx" not in st.session_state:
-                        st.session_state[f"{carousel_key}_idx"] = 0
-                    cur = st.session_state[f"{carousel_key}_idx"]
-                    if cur >= len(all_faces):
-                        cur = 0
-                    st.session_state[f"{carousel_key}_idx"] = cur
-                    fname = all_faces[cur]
-                    ch = face_data["char_data"] if face_data else {}
-                    if fname.startswith("/files/"):
-                        img_url = f"{backend_base_url}{fname}"
-                    else:
-                        base = ch.get("image_url") or ""
-                        base_dir = "/".join((base or "/").split("/")[:-1])
-                        img_url = f"{backend_base_url}{base_dir}/{fname}" if base_dir else f"{backend_base_url}{fname}"
-                    st.image(img_url, width=150)
-                    st.caption(f"Cara {cur+1}/{len(all_faces)}")
-                    bcol1, bcol2 = st.columns(2)
-                    with bcol1:
-                        if st.button("⬅️", key=f"combined_face_prev_{pidx}"):
-                            st.session_state[f"{carousel_key}_idx"] = (cur - 1) % len(all_faces)
-                            st.rerun()
-                    with bcol2:
-                        if st.button("➡️", key=f"combined_face_next_{pidx}"):
-                            st.session_state[f"{carousel_key}_idx"] = (cur + 1) % len(all_faces)
-                            st.rerun()
+        colc1, colc2 = st.columns([1,1])
+        with colc1:
+            if st.button("Confirmar càsting definitiu", type="primary"):
+                chars_payload = []
+                for idx, ch in enumerate(st.session_state.characters_detected or []):
+                    try:
+                        folder_name = Path(ch.get("folder") or "").name
+                    except Exception:
+                        folder_name = ""
+                    char_id = ch.get("id") or folder_name or f"char{idx+1}"
+                    def _safe_key(s: str) -> str:
+                        k = re.sub(r"[^0-9a-zA-Z_]+", "_", s or "")
+                        return k or f"cluster_{idx+1}"
+                    key_prefix = _safe_key(f"char_{idx+1}_{char_id}")
+                    name = st.session_state.get(f"{key_prefix}_name") or ch.get("name") or f"Personatge {idx+1}"
+                    desc = st.session_state.get(f"{key_prefix}_desc", "")
+                    faces_all = ch.get("face_files") or []
+                    discard = st.session_state.get(f"{key_prefix}_discard", set())
+                    kept = [f for f in faces_all if f and f not in discard]
+                    chars_payload.append({
+                        "id": char_id,
+                        "name": name,
+                        "description": desc,
+                        "folder": ch.get("folder"),
+                        "kept_files": kept,
+                    })
+                
+                used_names_home_fin = []
+                used_names_dona_fin = []
+                noms_home_all, noms_dona_all = get_all_catalan_names()
+                for cp in chars_payload:
+                    face_name = cp.get("name", "")
+                    if face_name in noms_home_all:
+                        used_names_home_fin.append(face_name)
+                    elif face_name in noms_dona_all:
+                        used_names_dona_fin.append(face_name)
+                
+                segs = st.session_state.audio_segments or []
+                vlabels = st.session_state.voice_labels or []
+                vname = st.session_state.video_name_from_engine
+                voice_clusters = {}
+                for i, seg in enumerate(segs):
+                    lbl = vlabels[i] if i < len(vlabels) else -1
+                    # Només considerem clústers de veu amb etiqueta vàlida (enter >= 0)
+                    if not (isinstance(lbl, int) and lbl >= 0):
+                        continue
+                    clip_local = seg.get("clip_path")
+                    fname = os.path.basename(clip_local) if clip_local else None
+                    if fname:
+                        default_voice_name = get_catalan_name_for_speaker(int(lbl), used_names_home_fin, used_names_dona_fin)
+                        voice_clusters.setdefault(lbl, {"label": lbl, "name": default_voice_name, "description": "", "clips": []})
+                        vpref = f"voice_{int(lbl):02d}"
+                        vname_custom = st.session_state.get(f"{vpref}_name")
+                        vdesc_custom = st.session_state.get(f"{vpref}_desc")
+                        if vname_custom:
+                            voice_clusters[lbl]["name"] = vname_custom
+                        if vdesc_custom is not None:
+                            voice_clusters[lbl]["description"] = vdesc_custom
+                        voice_clusters[lbl]["clips"].append(fname)
+                
+                payload = {
+                    "video_name": vname,
+                    "base_dir": st.session_state.get("engine_base_dir"),
+                    "characters": chars_payload,
+                    "voice_clusters": list(voice_clusters.values()),
+                }
+                
+                if not payload["video_name"] or not payload["base_dir"]:
+                    st.error("Falten dades del vídeo per confirmar el càsting (video_name/base_dir). Torna a processar el vídeo.")
                 else:
-                    st.info("Sense imatges")
+                    with st.spinner("Consolidant càsting al servidor…"):
+                        res_fc = api.finalize_casting(payload)
+                    if isinstance(res_fc, dict) and res_fc.get("ok"):
+                        st.success(f"Càsting consolidat. Identities: {len(res_fc.get('face_identities', []))} cares, {len(res_fc.get('voice_identities', []))} veus.")
+                        st.session_state.casting_finalized = True
 
-            with col_voices:
-                if voice_data:
-                    clips = voice_data["clips"]
-                    if clips:
-                        carousel_key = f"combined_voice_{pidx}"
+                        # Guardar casting_json localment per a futurs processos (p.ex. audiodescripció)
+                        try:
+                            casting_json = res_fc.get("casting_json") or {}
+                            v = st.session_state.get("video_uploaded") or {}
+                            sha1 = v.get("sha1sum")
+                            if casting_json and sha1:
+                                base_dir = Path(__file__).parent.parent / "temp" / "media" / sha1
+                                base_dir.mkdir(parents=True, exist_ok=True)
+                                casting_path = base_dir / "casting.json"
+                                with casting_path.open("w", encoding="utf-8") as f:
+                                    json.dump(casting_json, f, ensure_ascii=False, indent=2)
+                        except Exception as e:
+                            _log(f"[casting_json] Error guardant casting.json: {e}")
+                        
+                        f_id = res_fc.get('face_identities', []) or []
+                        v_id = res_fc.get('voice_identities', []) or []
+                        c3, c4 = st.columns(2)
+                        with c3:
+                            st.markdown("**Identitats de cara**")
+                            for n in f_id:
+                                st.write(f"- {n}")
+                        with c4:
+                            st.markdown("**Identitats de veu**")
+                            for n in v_id:
+                                st.write(f"- {n}")
+                        
+                        faces_dir = res_fc.get('faces_dir')
+                        voices_dir = res_fc.get('voices_dir')
+                        db_dir = res_fc.get('db_dir')
+                        with st.spinner("Carregant índexs al cercador (Chroma)…"):
+                            load_res = api.load_casting(faces_dir=faces_dir, voices_dir=voices_dir, db_dir=db_dir, drop_collections=True)
+                        if isinstance(load_res, dict) and load_res.get('ok'):
+                            st.success(f"Índexs carregats: {load_res.get('faces', 0)} cares, {load_res.get('voices', 0)} veus.")
+                        else:
+                            st.error(f"Error carregant índexs: {load_res}")
+                    else:
+                        st.error(f"No s'ha pogut consolidar el càsting: {res_fc}")
+        
+        # --- Personatges combinats (cares + veus) ---
+        if st.session_state.get("casting_finalized"):
+            st.markdown("---")
+            st.subheader("👥 Personatges")
+            
+            def normalize_name(name: str) -> str:
+                import unicodedata
+                name_upper = name.upper()
+                name_normalized = ''.join(
+                    c for c in unicodedata.normalize('NFD', name_upper)
+                    if unicodedata.category(c) != 'Mn'
+                )
+                return name_normalized
+            
+            chars_payload = []
+            for idx, ch in enumerate(st.session_state.characters_detected or []):
+                try:
+                    folder_name = Path(ch.get("folder") or "").name
+                except Exception:
+                    folder_name = ""
+                char_id = ch.get("id") or folder_name or f"char{idx+1}"
+                def _safe_key(s: str) -> str:
+                    k = re.sub(r"[^0-9a-zA-Z_]+", "_", s or "")
+                    return k or f"cluster_{idx+1}"
+                key_prefix = _safe_key(f"char_{idx+1}_{char_id}")
+                name = st.session_state.get(f"{key_prefix}_name") or ch.get("name") or f"Personatge {idx+1}"
+                name_normalized = normalize_name(name)
+                desc = st.session_state.get(f"{key_prefix}_desc", "").strip()
+                chars_payload.append({
+                    "name": name,
+                    "name_normalized": name_normalized,
+                    "face_key_prefix": key_prefix,
+                    "face_files": ch.get("face_files") or [],
+                    "char_data": ch,
+                    "description": desc,
+                })
+            
+            used_names_home_pers = []
+            used_names_dona_pers = []
+            noms_home_all, noms_dona_all = get_all_catalan_names()
+            for cp in chars_payload:
+                face_name = cp.get("name", "")
+                if face_name in noms_home_all:
+                    used_names_home_pers.append(face_name)
+                elif face_name in noms_dona_all:
+                    used_names_dona_pers.append(face_name)
+            
+            segs = st.session_state.audio_segments or []
+            vlabels = st.session_state.voice_labels or []
+            vname = st.session_state.video_name_from_engine
+            voice_clusters_by_name = {}
+            for i, seg in enumerate(segs):
+                lbl = vlabels[i] if i < len(vlabels) else -1
+                if not (isinstance(lbl, int) and lbl >= 0):
+                    continue
+                vpref = f"voice_{int(lbl):02d}"
+                default_voice_name = get_catalan_name_for_speaker(int(lbl), used_names_home_pers, used_names_dona_pers) if isinstance(lbl, int) and lbl >= 0 else f"SPEAKER_{int(lbl):02d}"
+                vname_custom = st.session_state.get(f"{vpref}_name") or default_voice_name
+                vname_normalized = normalize_name(vname_custom)
+                vdesc = st.session_state.get(f"{vpref}_desc", "").strip()
+                clip_local = seg.get("clip_path")
+                fname = os.path.basename(clip_local) if clip_local else None
+                if fname:
+                    voice_clusters_by_name.setdefault(vname_normalized, {
+                        "voice_key_prefix": vpref,
+                        "clips": [],
+                        "label": lbl,
+                        "original_name": vname_custom,
+                        "description": vdesc,
+                    })
+                    voice_clusters_by_name[vname_normalized]["clips"].append(fname)
+            
+            all_normalized_names = set([c["name_normalized"] for c in chars_payload] + list(voice_clusters_by_name.keys()))
+            
+            for pidx, norm_name in enumerate(sorted(all_normalized_names)):
+                face_items = [c for c in chars_payload if c["name_normalized"] == norm_name]
+                voice_data = voice_clusters_by_name.get(norm_name)
+                
+                display_name = face_items[0]["name"] if face_items else (voice_data["original_name"] if voice_data else norm_name)
+                
+                descriptions = []
+                for face_item in face_items:
+                    if face_item["description"]:
+                        descriptions.append(face_item["description"])
+                if voice_data and voice_data.get("description"):
+                    descriptions.append(voice_data["description"])
+                
+                combined_description = "\n".join(descriptions) if descriptions else ""
+                
+                st.markdown(f"**{pidx+1}. {display_name}**")
+                
+                all_faces = []
+                for face_item in face_items:
+                    all_faces.extend(face_item["face_files"])
+                
+                face_data = face_items[0] if face_items else None
+                
+                col_faces, col_voices, col_text = st.columns([1, 1, 1.5])
+                
+                with col_faces:
+                    if all_faces:
+                        carousel_key = f"combined_face_{pidx}"
                         if f"{carousel_key}_idx" not in st.session_state:
                             st.session_state[f"{carousel_key}_idx"] = 0
                         cur = st.session_state[f"{carousel_key}_idx"]
-                        if cur >= len(clips):
+                        if cur >= len(all_faces):
                             cur = 0
                         st.session_state[f"{carousel_key}_idx"] = cur
-                        fname = clips[cur]
-                        audio_url = f"{backend_base_url}/audio/{vname}/{fname}" if (vname and fname) else None
-                        if audio_url:
-                            st.audio(audio_url, format="audio/wav")
-                        st.caption(f"Veu {cur+1}/{len(clips)}")
+                        fname = all_faces[cur]
+                        ch = face_data["char_data"] if face_data else {}
+                        if fname.startswith("/files/"):
+                            img_url = f"{backend_base_url}{fname}"
+                        else:
+                            base = ch.get("image_url") or ""
+                            base_dir = "/".join((base or "/").split("/")[:-1])
+                            img_url = f"{backend_base_url}{base_dir}/{fname}" if base_dir else f"{backend_base_url}{fname}"
+                        st.image(img_url, width=150)
+                        st.caption(f"Cara {cur+1}/{len(all_faces)}")
                         bcol1, bcol2 = st.columns(2)
                         with bcol1:
-                            if st.button("⬅️", key=f"combined_voice_prev_{pidx}"):
-                                st.session_state[f"{carousel_key}_idx"] = (cur - 1) % len(clips)
+                            if st.button("⬅️", key=f"combined_face_prev_{pidx}"):
+                                st.session_state[f"{carousel_key}_idx"] = (cur - 1) % len(all_faces)
                                 st.rerun()
                         with bcol2:
-                            if st.button("➡️", key=f"combined_voice_next_{pidx}"):
-                                st.session_state[f"{carousel_key}_idx"] = (cur + 1) % len(clips)
+                            if st.button("➡️", key=f"combined_face_next_{pidx}"):
+                                st.session_state[f"{carousel_key}_idx"] = (cur + 1) % len(all_faces)
                                 st.rerun()
                     else:
-                        st.info("Sense clips de veu")
-                else:
-                    st.info("Sense dades de veu")
-
-            with col_text:
-                combined_name_key = f"combined_char_{pidx}_name"
-                combined_desc_key = f"combined_char_{pidx}_desc"
-
-                if combined_name_key not in st.session_state:
-                    st.session_state[combined_name_key] = display_name
-                if combined_desc_key not in st.session_state:
-                    st.session_state[combined_desc_key] = combined_description
-
-                st.text_input(
-                    "Nom del personatge",
-                    key=combined_name_key,
-                    label_visibility="collapsed",
-                    placeholder="Nom del personatge",
-                )
-                st.text_area(
-                    "Descripció",
-                    key=combined_desc_key,
-                    height=120,
-                    label_visibility="collapsed",
-                    placeholder="Descripció del personatge",
-                )
-
-        # --- 7. Generar audiodescripció ---
-        st.markdown("---")
-        if st.button("🎬 Generar audiodescripció", type="primary", use_container_width=True):
+                        st.info("Sense imatges")
+                
+                with col_voices:
+                    if voice_data:
+                        clips = voice_data["clips"]
+                        if clips:
+                            carousel_key = f"combined_voice_{pidx}"
+                            if f"{carousel_key}_idx" not in st.session_state:
+                                st.session_state[f"{carousel_key}_idx"] = 0
+                            cur = st.session_state[f"{carousel_key}_idx"]
+                            if cur >= len(clips):
+                                cur = 0
+                            st.session_state[f"{carousel_key}_idx"] = cur
+                            fname = clips[cur]
+                            audio_url = f"{backend_base_url}/audio/{vname}/{fname}" if (vname and fname) else None
+                            if audio_url:
+                                st.audio(audio_url, format="audio/wav")
+                            st.caption(f"Veu {cur+1}/{len(clips)}")
+                            bcol1, bcol2 = st.columns(2)
+                            with bcol1:
+                                if st.button("⬅️", key=f"combined_voice_prev_{pidx}"):
+                                    st.session_state[f"{carousel_key}_idx"] = (cur - 1) % len(clips)
+                                    st.rerun()
+                            with bcol2:
+                                if st.button("➡️", key=f"combined_voice_next_{pidx}"):
+                                    st.session_state[f"{carousel_key}_idx"] = (cur + 1) % len(clips)
+                                    st.rerun()
+                        else:
+                            st.info("Sense clips de veu")
+                    else:
+                        st.info("Sense dades de veu")
+                
+                with col_text:
+                    combined_name_key = f"combined_char_{pidx}_name"
+                    combined_desc_key = f"combined_char_{pidx}_desc"
+                    
+                    if combined_name_key not in st.session_state:
+                        st.session_state[combined_name_key] = norm_name
+                    if combined_desc_key not in st.session_state:
+                        st.session_state[combined_desc_key] = combined_description
+                    
+                    st.text_input("Nom del personatge", key=combined_name_key, label_visibility="collapsed", placeholder="Nom del personatge")
+                    st.text_area("Descripció", key=combined_desc_key, height=120, label_visibility="collapsed", placeholder="Descripció del personatge")
+            
+            # --- 7. Generar audiodescripció ---
+            st.markdown("---")
+            if st.button("🎬 Generar audiodescripció", type="primary", use_container_width=True):
                 v = st.session_state.get("video_uploaded")
                 if not v:
                     st.error("No hi ha cap vídeo carregat.")
@@ -1246,65 +1342,6 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                             base_media_dir = Path(__file__).parent.parent / "temp" / "media" / sha1
                             base_media_dir.mkdir(parents=True, exist_ok=True)
 
-                            # 0) Finalitzar càsting automàticament abans de generar AD
-                            progress_placeholder.info("⏳ Consolidant personatges i veus...")
-                            try:
-                                video_name = v.get("original_filename", "").replace(".mp4", "") or sha1
-                                characters = st.session_state.get("characters", [])
-                                voice_labels = st.session_state.get("voice_labels", [])
-                                audio_segments = st.session_state.get("audio_segments", [])
-
-                                # Construir payload per finalize_casting
-                                char_payload = []
-                                for ch in characters:
-                                    char_id = ch.get("id", "")
-                                    name_key = f"char_name_{char_id}"
-                                    desc_key = f"char_desc_{char_id}"
-                                    kept_key = f"char_kept_{char_id}"
-                                    char_payload.append({
-                                        "id": char_id,
-                                        "name": st.session_state.get(name_key, ch.get("name", f"Cluster {char_id}")),
-                                        "description": st.session_state.get(desc_key, ch.get("description", "")),
-                                        "folder": ch.get("folder", ""),
-                                        "kept_files": st.session_state.get(kept_key, ch.get("face_files", [])),
-                                    })
-
-                                # Construir voice_clusters
-                                voice_clusters = []
-                                unique_speakers = sorted(set(voice_labels)) if voice_labels else []
-                                for spk in unique_speakers:
-                                    vname_key = f"voice_name_{spk}"
-                                    vdesc_key = f"voice_desc_{spk}"
-                                    clips = [seg for i, seg in enumerate(audio_segments) if i < len(voice_labels) and voice_labels[i] == spk]
-                                    voice_clusters.append({
-                                        "label": spk,
-                                        "name": st.session_state.get(vname_key, spk),
-                                        "description": st.session_state.get(vdesc_key, ""),
-                                        "clips": [c.get("clip_path", "") for c in clips],
-                                    })
-
-                                payload = {
-                                    "video_name": video_name,
-                                    "characters": char_payload,
-                                    "voice_clusters": voice_clusters,
-                                }
-
-                                fin_resp = api.finalize_casting(payload)
-                                _log(f"[finalize] finalize_casting resp: {fin_resp}")
-
-                                # Carregar índexs Chroma
-                                load_resp = api.load_casting(
-                                    faces_dir="identities/faces",
-                                    voices_dir="identities/voices",
-                                    db_dir="chroma_db",
-                                    drop_collections=False
-                                )
-                                _log(f"[load] load_casting resp: {load_resp}")
-
-                            except Exception as e_fin:
-                                _log(f"[finalize] Error en finalize_casting: {e_fin}")
-                                # Continuem encara que falli
-
                             # 1) Carregar i enviar el casting_json com a embeddings al engine
                             casting_json = None
                             try:

persistent_data_gate.py

@@ -65,36 +65,37 @@ def _load_compliance_flags(base_dir: Path) -> dict:
 
 
 def ensure_temp_databases(base_dir: Path, api_client) -> None:
-    """Garantiza que las BDs *.db estén presentes en demo/temp antes del login.
+    """Garantiza que las BDs *.db estén presentes en demo/temp/db antes del login.
 
-    - data_origin == "internal": copia demo/data/*.db -> demo/temp/*.db
-    - data_origin == "external": llama al endpoint remoto import_databases.
+    - data_origin == "internal": copia demo/data/db/*.db -> demo/temp/db/*.db
+    - data_origin == "external": llama al endpoint remoto import_databases (ZIP) y lo extrae en demo/temp/db.
     """
 
     data_origin = _load_data_origin(base_dir)
     compliance_flags = _load_compliance_flags(base_dir)
     public_blockchain_enabled = bool(compliance_flags.get("public_blockchain_enabled", False))
-    temp_dir = base_dir / "temp"
-    temp_dir.mkdir(parents=True, exist_ok=True)
+    temp_root = base_dir / "temp"
+    db_temp_dir = temp_root / "db"
+    db_temp_dir.mkdir(parents=True, exist_ok=True)
 
     print(f"[ensure_temp_databases] data_origin={data_origin}")
     if data_origin == "internal":
-        source_dir = base_dir / "data"
+        source_dir = base_dir / "data" / "db"
         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():
             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
+                dest = db_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: descarregar BDs del backend una sola vegada per sessió del servidor
-        marker_file = temp_dir / ".external_db_imported"
-        missing = [name for name in ("events.db", "feedback.db", "users.db", "videos.db") if not (temp_dir / name).exists()]
+        marker_file = db_temp_dir / ".external_db_imported"
+        missing = [name for name in ("events.db", "feedback.db", "users.db", "videos.db") if not (db_temp_dir / name).exists()]
         needs_import = not marker_file.exists() or missing
 
         if not needs_import:
@@ -114,8 +115,8 @@ def ensure_temp_databases(base_dir: Path, api_client) -> None:
                 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}")
+                    _extract_zip_bytes(zip_bytes, db_temp_dir)
+                    print(f"[ensure_temp_databases] Extracted DBs to {db_temp_dir}")
                     try:
                         marker_file.write_text("imported", encoding="utf-8")
                     except Exception:
@@ -127,11 +128,11 @@ def ensure_temp_databases(base_dir: Path, api_client) -> None:
                 print(f"[ensure_temp_databases] Exception: {e}")
                 return
 
-    # Un cop les BDs estan a temp/, crear una còpia de seguretat a temp/backup
-    backup_dir = temp_dir / "backup"
+    # Un cop les BDs estan a temp/db, crear una còpia de seguretat a temp/db/backup
+    backup_dir = db_temp_dir / "backup"
     backup_dir.mkdir(parents=True, exist_ok=True)
 
-    for db_path in temp_dir.glob("*.db"):
+    for db_path in db_temp_dir.glob("*.db"):
         dest_backup = backup_dir / db_path.name
         try:
             shutil.copy2(db_path, dest_backup)
@@ -139,6 +140,15 @@ def ensure_temp_databases(base_dir: Path, api_client) -> None:
             # No interrompre el flux per un error puntual de còpia
             continue
 
+    # 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()
+    except Exception as _e_ver:
+        print(f"[ensure_temp_databases] Error executant verificador de BDs: {_e_ver}")
+
 
 def _extract_zip_bytes(zip_bytes: bytes, target_dir: Path) -> None:
     target_dir.mkdir(parents=True, exist_ok=True)
@@ -223,8 +233,10 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
         return
 
     data_origin = _load_data_origin(base_dir)
-    temp_dir = base_dir / "temp"
+    temp_root = base_dir / "temp"
+    db_temp_dir = temp_root / "db"
     data_dir = base_dir / "data"
+    data_db_dir = data_dir / "db"
 
     # --- 1) Sincronitzar taules ---
     #   - internal: mantenim el comportament antic basat en el camp 'session'.
@@ -236,8 +248,8 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
     if data_origin == "internal":
         sql_statements: list[str] = []
 
-        for db_path in temp_dir.glob("*.db"):
-            target_db = data_dir / db_path.name
+        for db_path in db_temp_dir.glob("*.db"):
+            target_db = data_db_dir / db_path.name
 
             with sqlite3.connect(str(db_path)) as src_conn:
                 src_conn.row_factory = sqlite3.Row
@@ -275,10 +287,10 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
                             dst_conn.execute(insert_sql, values)
                             dst_conn.commit()
     else:
-        # Mode external: diferències entre temp/*.db i temp/backup/*.db, enviant INSERTs un a un
-        backup_dir = temp_dir / "backup"
+        # Mode external: diferències entre temp/db/*.db i temp/db/backup/*.db, enviant INSERTs un a un
+        backup_dir = db_temp_dir / "backup"
         if backup_dir.exists() and api_client is not None:
-            for db_path in temp_dir.glob("*.db"):
+            for db_path in db_temp_dir.glob("*.db"):
                 backup_db = backup_dir / db_path.name
                 if not backup_db.exists():
                     continue
@@ -354,7 +366,7 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
     # --- 2) Digest d'esdeveniments per a la sessió (public blockchain) ---
     events_digest_info = None
     if public_blockchain_enabled:
-        events_db = temp_dir / "events.db"
+        events_db = db_temp_dir / "events.db"
         try:
             import sqlite3
             import hashlib
@@ -415,7 +427,7 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
             events_digest_info = None
 
     # --- 3) Nous vídeos a videos.db associats a la sessió ---
-    videos_db = temp_dir / "videos.db"
+    videos_db = db_temp_dir / "videos.db"
     new_sha1s: set[str] = set()
 
     try:
@@ -441,7 +453,7 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
     if not new_sha1s:
         return events_digest_info
 
-    temp_media_root = temp_dir / "media"
+    temp_media_root = temp_root / "media"
 
     if data_origin == "internal":
         # Copiar carpetes de media noves a demo/data/media