Update modules/studentact/current_situation_analysis.py

modules/studentact/current_situation_analysis.py

@@ -88,29 +88,51 @@ def analyze_vocabulary_diversity(doc):
 
 def analyze_cohesion(doc):
     """Analiza la cohesión textual"""
-    sentences = list(doc.sents)
-    connections = 0
-    for i in range(len(sentences)-1):
-        sent1_words = {token.lemma_ for token in sentences[i]}
-        sent2_words = {token.lemma_ for token in sentences[i+1]}
-        connections += len(sent1_words.intersection(sent2_words))
-    return normalize_score(connections, optimal_connections=5)
+    try:
+        sentences = list(doc.sents)
+        if len(sentences) < 2:
+            logger.warning("Texto demasiado corto para análisis de cohesión")
+            return 0.0
+            
+        connections = 0
+        for i in range(len(sentences)-1):
+            sent1_words = {token.lemma_ for token in sentences[i]}
+            sent2_words = {token.lemma_ for token in sentences[i+1]}
+            connections += len(sent1_words.intersection(sent2_words))
+            
+        # Validar que haya conexiones antes de normalizar
+        if connections == 0:
+            logger.warning("No se encontraron conexiones entre oraciones")
+            return 0.0
+            
+        return normalize_score(connections, optimal_connections=max(5, len(sentences) * 0.2))
+    except Exception as e:
+        logger.error(f"Error en analyze_cohesion: {str(e)}")
+        return 0.0
 
 def analyze_structure(doc):
     """Analiza la complejidad estructural"""
     try:
+        if len(doc) == 0:
+            logger.warning("Documento vacío")
+            return 0.0
+            
         root_distances = []
         for token in doc:
             if token.dep_ == 'ROOT':
                 depths = get_dependency_depths(token)
                 root_distances.extend(depths)
-        avg_depth = sum(root_distances) / len(root_distances) if root_distances else 0
-        return normalize_score(avg_depth, optimal_depth=3)  # Usando optimal_depth en lugar de optimal_value
+                
+        if not root_distances:
+            logger.warning("No se encontraron estructuras de dependencia")
+            return 0.0
+            
+        avg_depth = sum(root_distances) / len(root_distances)
+        return normalize_score(avg_depth, optimal_depth=max(3, len(doc) * 0.1))
     except Exception as e:
         logger.error(f"Error en analyze_structure: {str(e)}")
         return 0.0
 
-
 # Funciones auxiliares de análisis
 def get_dependency_depths(token, depth=0):
     """Obtiene las profundidades de dependencia"""
@@ -122,7 +144,7 @@ def get_dependency_depths(token, depth=0):
 def normalize_score(value, optimal_value=1.0, range_factor=2.0, optimal_length=None, 
                    optimal_connections=None, optimal_depth=None):
     """
-    Normaliza un valor a una escala de 0-1.
+    Normaliza un valor a una escala de 0-1 con manejo de casos extremos.
     
     Args:
         value: Valor a normalizar
@@ -136,23 +158,46 @@ def normalize_score(value, optimal_value=1.0, range_factor=2.0, optimal_length=N
         float: Valor normalizado entre 0 y 1
     """
     try:
+        # Validar valores negativos o cero
+        if value < 0:
+            logger.warning(f"Valor negativo recibido: {value}")
+            return 0.0
+            
+        # Manejar caso donde el valor es cero
+        if value == 0:
+            logger.warning("Valor cero recibido")
+            return 0.0
+
+        # Identificar el valor de referencia a usar
         if optimal_depth is not None:
-            diff = abs(value - optimal_depth)
-            max_diff = optimal_depth * range_factor
-            return 1.0 - min(diff / max_diff, 1.0)
+            reference = optimal_depth
         elif optimal_connections is not None:
-            diff = abs(value - optimal_connections)
-            max_diff = optimal_connections * range_factor
-            return 1.0 - min(diff / max_diff, 1.0)
+            reference = optimal_connections
         elif optimal_length is not None:
-            diff = abs(value - optimal_length)
-            max_diff = optimal_length * range_factor
-            return 1.0 - min(diff / max_diff, 1.0)
+            reference = optimal_length
         else:
-            diff = abs(value - optimal_value)
-            max_diff = optimal_value * range_factor
-            return 1.0 - min(diff / max_diff, 1.0)
-            
+            reference = optimal_value
+
+        # Validar valor de referencia
+        if reference <= 0:
+            logger.warning(f"Valor de referencia inválido: {reference}")
+            return 0.0
+
+        # Calcular diferencia y máxima diferencia permitida
+        diff = abs(value - reference)
+        max_diff = reference * range_factor
+
+        # Validar max_diff
+        if max_diff <= 0:
+            logger.warning(f"Máxima diferencia inválida: {max_diff}")
+            return 0.0
+
+        # Calcular score normalizado
+        score = 1.0 - min(diff / max_diff, 1.0)
+        
+        # Asegurar que el resultado esté entre 0 y 1
+        return max(0.0, min(1.0, score))
+
     except Exception as e:
         logger.error(f"Error en normalize_score: {str(e)}")
         return 0.0