Upload 4 files

api.py

@@ -13,7 +13,7 @@ from enum import Enum
 import os
 
 from video_processing import process_video_pipeline
-from audio_tools import process_audio_for_video
+from audio_tools import process_audio_for_video, extract_audio_ffmpeg, embed_voice_segments
 from casting_loader import ensure_chroma, build_faces_index, build_voices_index
 from narration_system import NarrationSystem
 from llm_router import load_yaml, LLMRouter
@@ -181,8 +181,8 @@ def process_video_job(job_id: str):
                 epsilon=epsilon,
                 min_cluster_size=min_cluster_size,
                 video_name=video_name,
-                start_offset_sec=5.0,
-                extract_every_sec=0.5
+                start_offset_sec=0.5,
+                extract_every_sec=0.25
             )
             
             print(f"[{job_id}] DEBUG - result completo: {result}")
@@ -231,11 +231,47 @@ def process_video_job(job_id: str):
             # Procesamiento de audio: diarización, ASR y embeddings de voz
             try:
                 cfg = load_yaml("config.yaml")
-                audio_segments, srt_unmod, full_txt = process_audio_for_video(video_path, base, cfg, voice_collection=None)
+                audio_segments, srt_unmod, full_txt, diar_info, connection_logs = process_audio_for_video(video_path, base, cfg, voice_collection=None)
+                # Loggear en consola del engine los eventos de conexión
+                try:
+                    for ev in (connection_logs or []):
+                        msg = ev.get("message") if isinstance(ev, dict) else None
+                        if msg:
+                            print(f"[{job_id}] {msg}")
+                except Exception:
+                    pass
             except Exception as e_audio:
                 import traceback
                 print(f"[{job_id}] WARN - Audio pipeline failed: {e_audio}\n{traceback.format_exc()}")
                 audio_segments, srt_unmod, full_txt = [], None, ""
+                diar_info = {"diarization_ok": False, "error": str(e_audio)}
+                connection_logs = []
+
+            # Fallback: si no hay segmentos de audio, crear uno mínimo del audio completo
+            if not audio_segments:
+                try:
+                    from pathlib import Path as _P
+                    from pydub import AudioSegment as _AS
+                    wav_out = extract_audio_ffmpeg(video_path, base / f"{_P(video_path).stem}.wav", sr=16000)
+                    audio = _AS.from_wav(wav_out)
+                    clips_dir = base / "clips"
+                    clips_dir.mkdir(parents=True, exist_ok=True)
+                    cp = clips_dir / "segment_000.wav"
+                    audio.export(cp, format="wav")
+                    emb_list = embed_voice_segments([str(cp)])
+                    audio_segments = [{
+                        "segment": 0,
+                        "start": 0.0,
+                        "end": float(len(audio) / 1000.0),
+                        "speaker": "SPEAKER_00",
+                        "text": "",
+                        "voice_embedding": emb_list[0] if emb_list else [],
+                        "clip_path": str(cp),
+                        "lang": "ca",
+                        "lang_prob": 1.0,
+                    }]
+                except Exception as _efb:
+                    print(f"[{job_id}] WARN - Audio minimal fallback failed: {_efb}")
 
             # Clustering de voces (DBSCAN sobre embeddings válidos)
             from sklearn.cluster import DBSCAN
@@ -266,6 +302,7 @@ def process_video_job(job_id: str):
                 "full_transcription": full_txt,
                 "voice_labels": v_labels,
                 "num_voice_embeddings": len(voice_embeddings),
+                "diarization_info": diar_info,
             }
             job["status"] = JobStatus.DONE
             

audio_tools.py

@@ -139,21 +139,36 @@ def diarize_audio(
     min_segment_duration: float = 20.0,
     max_segment_duration: float = 50.0,
     hf_token_env: str | None = None,
-) -> Tuple[List[str], List[Dict[str, Any]]]:
-    """Diarization with pyannote and clip export with pydub."""
+) -> Tuple[List[str], List[Dict[str, Any]], Dict[str, Any], List[Dict[str, Any]]]:
+    """Diarization with pyannote and clip export with pydub.
+    Returns (clip_paths, segments, info) where info includes diarization_ok and optional error.
+    """
     from pydub import AudioSegment
     audio = AudioSegment.from_wav(wav_path)
     duration = len(audio) / 1000.0
 
     diarization = None
+    connection_logs: List[Dict[str, Any]] = []
+    diar_info: Dict[str, Any] = {"diarization_ok": True, "error": "", "token_source": ""}
     try:
+        # Para pyannote usamos exclusivamente PYANNOTE_TOKEN (o un token explícito recibido)
+        _env_token = os.getenv("PYANNOTE_TOKEN")
+        _token = hf_token_env or _env_token
+        diar_info["token_source"] = "hf_token_env" if hf_token_env else ("PYANNOTE_TOKEN" if _env_token else "none")
+        import time as _t
+        t0 = _t.time()
         pipeline = Pipeline.from_pretrained(
             "pyannote/speaker-diarization-3.1",
-            use_auth_token=(hf_token_env or os.getenv("HF_TOKEN"))
+            use_auth_token=_token
         )
+        connection_logs.append({"service": "pyannote", "phase": "connect", "message": "Connecting to pyannote server..."})
         diarization = pipeline(wav_path)
+        dt = _t.time() - t0
+        connection_logs.append({"service": "pyannote", "phase": "done", "message": f"Response from pyannote received in {dt:.2f} s"})
     except Exception as e:
         log.warning(f"Diarization unavailable, using single full segment fallback: {e}")
+        diar_info.update({"diarization_ok": False, "error": str(e)})
+        connection_logs.append({"service": "pyannote", "phase": "error", "message": f"pyannote error: {str(e)}"})
 
     clips_dir = (base_dir / clips_folder)
     clips_dir.mkdir(parents=True, exist_ok=True)
@@ -203,11 +218,17 @@ def diarize_audio(
     if not segments:
         cp = clips_dir / "segment_000.wav"
         audio.export(cp, format="wav")
-        return [str(cp)], [{"start": 0.0, "end": duration, "speaker": "SPEAKER_00"}]
+        # No error here necessarily; could be due to post-filtering thresholds.
+        if diar_info.get("error"):
+            # already marked
+            pass
+        else:
+            diar_info["reason"] = "no_segments_after_filter"
+        return [str(cp)], [{"start": 0.0, "end": duration, "speaker": "SPEAKER_00"}], diar_info, connection_logs
 
     pairs = sorted(zip(clip_paths, segments), key=lambda x: x[1]["start"])
     clip_paths, segments = [p[0] for p in pairs], [p[1] for p in pairs]
-    return clip_paths, segments
+    return clip_paths, segments, diar_info, connection_logs
 
 # ------------------------------ Voice embeddings -----------------------------
 
@@ -395,7 +416,7 @@ def process_audio_for_video(
     out_dir: Path,
     cfg: Dict[str, Any],
     voice_collection=None,
-) -> Tuple[List[Dict[str, Any]], Optional[str], str]:
+) -> Tuple[List[Dict[str, Any]], Optional[str], str, Dict[str, Any], List[Dict[str, Any]]]:
     """
     Audio pipeline: FFmpeg -> diarization -> remote ASR (full + clips) -> embeddings -> speaker-ID -> SRT.
     Returns (audio_segments, srt_path or None, full_transcription_text).
@@ -409,21 +430,31 @@ def process_audio_for_video(
     diar_cfg = audio_cfg.get("diarization", {})
     min_dur = float(diar_cfg.get("min_segment_duration", 20.0))
     max_dur = float(diar_cfg.get("max_segment_duration", 50.0))
-    clip_paths, diar_segs = diarize_audio(wav_path, out_dir, "clips", min_dur, max_dur)
+    clip_paths, diar_segs, diar_info, connection_logs = diarize_audio(wav_path, out_dir, "clips", min_dur, max_dur)
     log.info("Clips de audio generados.")
 
     full_transcription = ""
     asr_section = cfg.get("asr", {})
     if asr_section.get("enable_full_transcription", True):
         log.info("Transcripción completa (remota, Space 'asr')...")
+        import time as _t
+        t0 = _t.time()
+        connection_logs.append({"service": "asr", "phase": "connect", "message": "Connecting to ASR space..."})
         full_res = transcribe_audio_remote(wav_path, cfg)
+        dt = _t.time() - t0
+        connection_logs.append({"service": "asr", "phase": "done", "message": f"Response from ASR space received in {dt:.2f} s"})
         full_transcription = full_res.get("text", "") or ""
         log.info("Transcripción completa finalizada.")
 
     log.info("Transcripción por clip (remota, Space 'asr')...")
     trans: List[str] = []
     for cp in clip_paths:
+        import time as _t
+        t0 = _t.time()
+        connection_logs.append({"service": "asr", "phase": "connect", "message": "Transcribing clip via ASR space..."})
         res = transcribe_audio_remote(cp, cfg)
+        dt = _t.time() - t0
+        connection_logs.append({"service": "asr", "phase": "done", "message": f"Clip transcribed in {dt:.2f} s"})
         trans.append(res.get("text", ""))
 
     log.info("Se han transcrito todos los clips.")
@@ -467,4 +498,4 @@ def process_audio_for_video(
         log.warning(f"SRT generation failed: {e}")
         srt_unmodified_path = None
 
-    return audio_segments, srt_unmodified_path, full_transcription
+    return audio_segments, srt_unmodified_path, full_transcription, diar_info, connection_logs

llm_router.py

@@ -6,6 +6,7 @@ import os
 import yaml
 
 from remote_clients import InstructClient, VisionClient, ToolsClient, ASRClient
+import time
 
 def load_yaml(path: str) -> Dict[str, Any]:
     p = Path(path)
@@ -36,26 +37,56 @@ class LLMRouter:
             "whisper-catalan": mk("whisper-catalan", ASRClient),
         }
 
+        self.service_names = {
+            "salamandra-instruct": "schat",
+            "salamandra-vision": "svision",
+            "salamandra-tools": "stools",
+            "whisper-catalan": "asr",
+        }
+
+    def _log_connect(self, model_key: str, phase: str, elapsed: float | None = None):
+        svc = self.service_names.get(model_key, model_key)
+        if phase == "connect":
+            print(f"[LLMRouter] Connecting to {svc} space...")
+        elif phase == "done":
+            print(f"[LLMRouter] Response from {svc} space received in {elapsed:.2f} s")
+
     # ---- INSTRUCT ----
     def instruct(self, prompt: str, system: Optional[str] = None, model: str = "salamandra-instruct", **kwargs) -> str:
         if model in self.rem:
-            return self.clients[model].generate(prompt, system=system, **kwargs)  # type: ignore
+            self._log_connect(model, "connect")
+            t0 = time.time()
+            out = self.clients[model].generate(prompt, system=system, **kwargs)  # type: ignore
+            self._log_connect(model, "done", time.time() - t0)
+            return out
         raise RuntimeError(f"Modelo local no implementado para: {model}")
 
     # ---- VISION ----
     def vision_describe(self, image_paths: List[str], context: Optional[Dict[str, Any]] = None, model: str = "salamandra-vision", **kwargs) -> List[str]:
         if model in self.rem:
-            return self.clients[model].describe(image_paths, context=context, **kwargs)  # type: ignore
+            self._log_connect(model, "connect")
+            t0 = time.time()
+            out = self.clients[model].describe(image_paths, context=context, **kwargs)  # type: ignore
+            self._log_connect(model, "done", time.time() - t0)
+            return out
         raise RuntimeError(f"Modelo local no implementado para: {model}")
 
     # ---- TOOLS ----
     def chat_with_tools(self, messages: List[Dict[str, str]], tools: Optional[List[Dict[str, Any]]] = None, model: str = "salamandra-tools", **kwargs) -> Dict[str, Any]:
         if model in self.rem:
-            return self.clients[model].chat(messages, tools=tools, **kwargs)  # type: ignore
+            self._log_connect(model, "connect")
+            t0 = time.time()
+            out = self.clients[model].chat(messages, tools=tools, **kwargs)  # type: ignore
+            self._log_connect(model, "done", time.time() - t0)
+            return out
         raise RuntimeError(f"Modelo local no implementado para: {model}")
 
     # ---- ASR ----
     def asr_transcribe(self, audio_path: str, model: str = "whisper-catalan", **kwargs) -> Dict[str, Any]:
         if model in self.rem:
-            return self.clients[model].transcribe(audio_path, **kwargs)  # type: ignore
+            self._log_connect(model, "connect")
+            t0 = time.time()
+            out = self.clients[model].transcribe(audio_path, **kwargs)  # type: ignore
+            self._log_connect(model, "done", time.time() - t0)
+            return out
         raise RuntimeError(f"Modelo local no implementado para: {model}")