Upload 2 files

api_client.py

@@ -4,7 +4,8 @@ import requests
 import base64
 import zipfile
 import io
-from typing import Iterable, Dict, Any
+from typing import Iterable, Dict, Any, Tuple
+from PIL import Image
 
 class APIClient:
     """
@@ -413,3 +414,100 @@ class APIClient:
             return {"error": str(e)}
 
 
+# ===========================
+# Cliente para SVision Space
+# ===========================
+
+def describe_image_with_svision(image_path: str, is_face: bool = True) -> Tuple[str, str]:
+    """
+    Llama al space svision para describir una imagen (cara o escena).
+    
+    Args:
+        image_path: Ruta absoluta a la imagen
+        is_face: True si es una cara, False si es una escena
+    
+    Returns:
+        tuple (descripción_completa, nombre_abreviado)
+    """
+    try:
+        from gradio_client import Client
+        
+        # Conectar al space svision con timeout generoso para cold start de ZeroGPU
+        svision_url = os.getenv("SVISION_URL", "https://veureu-svision.hf.space")
+        print(f"[svision] Connectant a {svision_url}...")
+        client = Client(svision_url)
+        
+        # Cargar imagen
+        img = Image.open(image_path)
+        
+        # Preparar prompt según el tipo
+        if is_face:
+            prompt = "Descriu aquesta persona. Inclou: edat aproximada (jove/adult), gènere, característiques físiques notables (ulleres, barba, bigoti, etc.), expressió i vestimenta."
+        else:
+            prompt = "Descriu aquesta escena. Inclou: tipus de localització (interior/exterior), elements principals, ambient, il·luminació."
+        
+        print(f"[svision] Enviant petició (pot trigar si ZeroGPU està en cold start)...")
+        
+        # Llamar al endpoint /describe con timeout aumentado para ZeroGPU cold start
+        # El primer request puede tardar 30-60 segundos en ZeroGPU
+        import time
+        start_time = time.time()
+        
+        result = client.predict(
+            img,  # imagen PIL
+            prompt,  # texto
+            256,  # max_new_tokens
+            0.7,  # temperature
+            api_name="/describe"
+        )
+        
+        elapsed = time.time() - start_time
+        print(f"[svision] Resposta rebuda en {elapsed:.1f}s")
+        
+        full_description = result.strip() if result else ""
+        
+        if not full_description:
+            return ("", "")
+        
+        # Generar nombre abreviado para caras
+        if is_face:
+            # Extraer características clave para el nombre
+            desc_lower = full_description.lower()
+            
+            # Determinar edad y género
+            is_young = any(word in desc_lower for word in ["jove", "nen", "nena", "adolescent", "noi", "noia"])
+            is_female = any(word in desc_lower for word in ["dona", "noia", "nena", "femení"])
+            
+            if is_young:
+                base_name = "Noia" if is_female else "Noi"
+            else:
+                base_name = "Dona" if is_female else "Home"
+            
+            # Añadir características distintivas
+            features = []
+            if "ullere" in desc_lower or "gafa" in desc_lower:
+                features.append("ulleres")
+            if "barba" in desc_lower:
+                features.append("barba")
+            if "bigoti" in desc_lower:
+                features.append("bigoti")
+            
+            if features:
+                short_name = f"{base_name} amb {', '.join(features)}"
+            else:
+                short_name = base_name
+        else:
+            # Para escenas, extraer primeras palabras clave
+            words = full_description.split()[:4]
+            short_name = " ".join(words).capitalize()
+        
+        print(f"[svision] Descripció generada: {full_description[:100]}...")
+        print(f"[svision] Nom: {short_name}")
+        
+        return (full_description, short_name)
+        
+    except Exception as e:
+        print(f"[svision] Error al descriure imatge: {e}")
+        import traceback
+        traceback.print_exc()
+        return ("", "")

app.py

@@ -454,6 +454,61 @@ if page == "Processar vídeo nou":
                             st.session_state.video_name_from_engine = vname
                             st.session_state.engine_base_dir = base_dir
                             st.session_state.diarization_info = diar_info or {}
+                            
+                            # Llamar a svision para generar descripciones de caras
+                            if chars:
+                                from api_client import describe_image_with_svision
+                                import os as _os2
+                                import tempfile
+                                import requests as _req
+                                
+                                # Mostrar progreso para el usuario
+                                total_chars = len(chars)
+                                progress_text = st.empty()
+                                progress_bar = st.progress(0.0)
+                                progress_text.info("🎨 Generant descripcions amb Salamandra Vision (pot trigar uns segons en la primera càrrega)...")
+                                
+                                for idx, ch in enumerate(chars):
+                                    # Actualizar progreso
+                                    progress_bar.progress((idx + 1) / total_chars)
+                                    progress_text.info(f"🎨 Descrivint cara {idx + 1}/{total_chars} amb Salamandra Vision...")
+                                    
+                                    # Obtener URL de imagen representativa
+                                    img_url = ch.get("image_url")
+                                    if img_url:
+                                        # Construir URL completa
+                                        if not img_url.startswith("http"):
+                                            img_url = f"{BACKEND_BASE_URL}{img_url}"
+                                        
+                                        try:
+                                            # Descargar imagen temporalmente
+                                            resp = _req.get(img_url, timeout=10)
+                                            if resp.status_code == 200:
+                                                # Guardar en archivo temporal
+                                                with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
+                                                    tmp.write(resp.content)
+                                                    tmp_path = tmp.name
+                                                
+                                                # Llamar a svision (con timeout generoso para cold start)
+                                                desc, name = describe_image_with_svision(tmp_path, is_face=True)
+                                                if desc:
+                                                    ch["description"] = desc
+                                                if name:
+                                                    ch["name"] = name
+                                                log(f"Descripció svision per {ch.get('id', 'unknown')}: {name}")
+                                                
+                                                # Limpiar archivo temporal
+                                                _os2.unlink(tmp_path)
+                                        except Exception as e:
+                                            log(f"Error cridant svision per {ch.get('id', 'unknown')}: {e}")
+                                            # Continuar con valores por defecto si falla
+                                            if "name" not in ch or not ch["name"]:
+                                                ch["name"] = f"Personatge {idx + 1}"
+                                
+                                # Limpiar indicadores de progreso
+                                progress_bar.empty()
+                                progress_text.success(f"✅ {total_chars} cares descrites amb Salamandra Vision")
+                            
                             # Escenes (opcional, quan l'engine ho proporcioni)
                             try:
                                 st.session_state.scene_clusters = res.get("scene_clusters", []) or []
@@ -471,6 +526,60 @@ if page == "Processar vídeo nou":
                                 scs = scene_out.get("scene_clusters") if isinstance(scene_out, dict) else None
                                 if isinstance(scs, list):
                                     st.session_state.scene_clusters = scs
+                                    
+                                    # Llamar a svision para generar descripciones de escenas
+                                    if scs:
+                                        from api_client import describe_image_with_svision
+                                        import os as _os3
+                                        import tempfile
+                                        import requests as _req2
+                                        
+                                        # Mostrar progreso para el usuario
+                                        total_scenes = len(scs)
+                                        scene_progress_text = st.empty()
+                                        scene_progress_bar = st.progress(0.0)
+                                        scene_progress_text.info("🎬 Generant descripcions d'escenes amb Salamandra Vision...")
+                                        
+                                        for sidx, sc in enumerate(scs):
+                                            # Actualizar progreso
+                                            scene_progress_bar.progress((sidx + 1) / total_scenes)
+                                            scene_progress_text.info(f"🎬 Descrivint escena {sidx + 1}/{total_scenes} amb Salamandra Vision...")
+                                            
+                                            # Obtener URL de imagen representativa
+                                            img_url = sc.get("image_url")
+                                            if img_url:
+                                                # Construir URL completa
+                                                if not img_url.startswith("http"):
+                                                    img_url = f"{BACKEND_BASE_URL}{img_url}"
+                                                
+                                                try:
+                                                    # Descargar imagen temporalmente
+                                                    resp = _req2.get(img_url, timeout=10)
+                                                    if resp.status_code == 200:
+                                                        # Guardar en archivo temporal
+                                                        with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
+                                                            tmp.write(resp.content)
+                                                            tmp_path = tmp.name
+                                                        
+                                                        # Llamar a svision
+                                                        desc, name = describe_image_with_svision(tmp_path, is_face=False)
+                                                        if desc:
+                                                            sc["description"] = desc
+                                                        if name:
+                                                            sc["name"] = name
+                                                        log(f"Descripció svision per escena {sc.get('id', 'unknown')}: {name}")
+                                                        
+                                                        # Limpiar archivo temporal
+                                                        _os3.unlink(tmp_path)
+                                                except Exception as e:
+                                                    log(f"Error cridant svision per escena {sc.get('id', 'unknown')}: {e}")
+                                                    # Continuar con valores por defecto si falla
+                                                    if "name" not in sc or not sc["name"]:
+                                                        sc["name"] = f"Escena {sidx + 1}"
+                                        
+                                        # Limpiar indicadores de progreso
+                                        scene_progress_bar.empty()
+                                        scene_progress_text.success(f"✅ {total_scenes} escenes descrites amb Salamandra Vision")
                                 else:
                                     st.session_state.scene_clusters = []
                             except Exception as _esc: