Upload analyze_audiodescriptions.py

page_modules/analyze_audiodescriptions.py

@@ -97,83 +97,110 @@ def _file_for_hist_choice(vid_dir: Path, version: str, filename: str, hist_choic
 
 
 def load_eval_values(vid_dir: Path, version: str, eval_content: Optional[str] = None) -> Optional[Dict[str, int]]:
-    """Carga los valores de evaluación desde eval (DB o CSV) si existe.
-    
-    Args:
-        vid_dir: Directorio del vídeo
-        version: Versión seleccionada (MoE/Salamandra)
-        
-    Returns:
-        Diccionario con los valores de evaluación o None si no existe el CSV
+    """Carga los valores de evaluación (0-7) desde eval (DB o CSV) si existe.
+
+    El formato esperado es un CSV con cabecera::
+
+        Caracteristica,Valoracio (0-7),Justificacio
+        Precisió Descriptiva,5,"..."
+        Sincronització Temporal,6,"..."
+        ...
+
+    Cada fila se mapea a una de las seis dimensiones internas:
+    transcripcio, identificacio, localitzacions, activitats, narracions, expressivitat.
     """
+
     csv_path = vid_dir / version / "eval.csv"
 
     try:
         if eval_content is not None:
-            f_obj = io.StringIO(eval_content)
+            # El contenido de la BD puede venir envuelto en ```; lo limpiamos.
+            text = eval_content.strip()
+            if text.startswith("```"):
+                text = text.lstrip("`").lstrip()
+            if text.endswith("```"):
+                text = text.rstrip("`").rstrip()
+            text = text.replace("\r\n", "\n").replace("\r", "\n")
+            f_obj = io.StringIO(text)
         elif csv_path.exists():
-            f_obj = open(csv_path, 'r', encoding='utf-8')
+            f_obj = open(csv_path, "r", encoding="utf-8")
         else:
             return None
 
         with f_obj as f:
-            reader = csv.DictReader(f)
-            row = next(reader, None)
-            
-            if not row:
+            reader = csv.reader(f)
+
+            # Saltar cabecera si la primera fila contiene "Caracteristica"
+            first = None
+            for first in reader:
+                if first and any("caracteristica" in c.lower() for c in first):
+                    # Es cabecera; pasamos a las filas de datos
+                    break
+                else:
+                    # No es cabecera; la tratamos como primera fila de datos
+                    break
+
+            # Mapeo de texto de característica -> clave interna
+            def map_feature(name: str) -> Optional[str]:
+                name_l = name.strip().lower()
+                if "precis" in name_l:  # Precisió Descriptiva
+                    return "transcripcio"
+                if "sincronitz" in name_l:  # Sincronització Temporal
+                    return "identificacio"
+                if "claredat" in name_l or "concis" in name_l:  # Claredat i Concisió
+                    return "localitzacions"
+                if "diàleg" in name_l or "diàleg/so" in name_l or "diàleg" in name_l:
+                    return "activitats"  # Inclusió de Diàleg/So
+                if "contextualitz" in name_l:
+                    return "narracions"
+                if "flux" in name_l or "ritme" in name_l:
+                    return "expressivitat"
                 return None
-            
-            # Mapeo de nombres de columnas CSV a claves internas
-            # Usamos las etiquetas actuales de config.yaml, pero
-            # mantenemos compatibilidad con nombres antiguos.
-
-            labels = _load_labels_from_config()
-            mappings = {
-                'transcripcio': [
-                    labels["score_1"],
-                    'Precisió Descriptiva',
-                ],
-                'identificacio': [
-                    labels["score_2"],
-                    'Sincronització Temporal',
-                ],
-                'localitzacions': [
-                    labels["score_3"],
-                    'Claredat i Concisió',
-                ],
-                'activitats': [
-                    labels["score_4"],
-                    'Inclusió de Diàleg/So',
-                    'Inclusió de Diàleg',
-                ],
-                'narracions': [
-                    labels["score_5"],
-                    'Contextualització',
-                ],
-                'expressivitat': [
-                    labels["score_6"],
-                    'Flux i Ritme de la Narració',
-                ],
-            }
-            
-            values = {}
-            for key, possible_names in mappings.items():
-                for name in possible_names:
-                    if name in row and row[name]:
-                        try:
-                            # Convertir a int y asegurar que está en rango 0-7
-                            val = int(float(row[name]))
-                            values[key] = max(0, min(7, val))
-                            break
-                        except (ValueError, TypeError):
-                            continue
-                
-                # Si no se encontró valor, usar 7 por defecto
+
+            values: Dict[str, int] = {}
+
+            def process_row(row):
+                if not row or all(not c.strip() for c in row):
+                    return
+                # Esperamos al menos dos columnas: Caracteristica, Valoracio (0-7)
+                if len(row) < 2:
+                    return
+                feature = row[0].strip()
+                key = map_feature(feature)
+                if not key:
+                    return
+                raw_val = row[1].strip().strip('"')
+                if not raw_val:
+                    return
+                try:
+                    v = int(float(raw_val))
+                except ValueError:
+                    return
+                values[key] = max(0, min(7, v))
+
+            # Si la primera fila ya era de datos, procesarla
+            if first:
+                # Comprobar si era cabecera
+                if not any("caracteristica" in c.lower() for c in first):
+                    process_row(first)
+
+            for row in reader:
+                process_row(row)
+
+            # Rellenar con 7 por defecto cualquier dimensión que falte
+            for key in [
+                "transcripcio",
+                "identificacio",
+                "localitzacions",
+                "activitats",
+                "narracions",
+                "expressivitat",
+            ]:
                 if key not in values:
                     values[key] = 7
-            
+
             return values
-            
+
     except Exception:
         # Si hay cualquier error, simplemente ignorar y devolver None
         return None