Update modules/studentact/current_situation_analysis.py

modules/studentact/current_situation_analysis.py

@@ -14,42 +14,62 @@ logger = logging.getLogger(__name__)
 
 def analyze_text_dimensions(doc):
     """
-    Analiza las diferentes dimensiones del texto.
+    Analiza las dimensiones principales del texto.
     
     Args:
         doc: Documento procesado por spaCy
-    
+        
     Returns:
         dict: Métricas del análisis
     """
     try:
-        # Analizar claridad (basado en longitud de oraciones)
-        clarity_score = analyze_clarity(doc)
-        
-        # Analizar vocabulario (diversidad léxica)
-        vocabulary_score = analyze_vocabulary_diversity(doc)
-        
-        # Analizar cohesión (conexiones entre oraciones)
+        # Análisis de vocabulario
+        vocab_score = analyze_vocabulary_diversity(doc)
+        vocab_normalized = normalize_score(
+            value=vocab_score,
+            optimal_connections=len(doc) * 0.4  # 40% del total de palabras como conexiones óptimas
+        )
+
+        # Análisis de estructura
+        struct_score = analyze_structure(doc)
+        struct_normalized = normalize_score(
+            value=struct_score,
+            optimal_length=20  # Longitud óptima promedio de oración
+        )
+
+        # Análisis de cohesión
         cohesion_score = analyze_cohesion(doc)
-        
-        # Analizar estructura (complejidad sintáctica)
-        structure_score = analyze_structure(doc)
-        
-        # Generar gráficos
-        sentence_graphs = generate_sentence_graphs(doc)
-        word_connections = generate_word_connections(doc)
-        connection_paths = generate_connection_paths(doc)
-        
+        cohesion_normalized = normalize_score(
+            value=cohesion_score,
+            optimal_value=0.7  # 70% de cohesión como valor óptimo
+        )
+
+        # Análisis de claridad
+        clarity_score = analyze_clarity(doc)
+        clarity_normalized = normalize_score(
+            value=clarity_score,
+            optimal_value=0.8  # 80% de claridad como valor óptimo
+        )
+
         return {
-            'clarity': clarity_score,
-            'vocabulary': vocabulary_score,
-            'cohesion': cohesion_score,
-            'structure': structure_score,
-            'sentence_graphs': sentence_graphs,
-            'word_connections': word_connections,
-            'connection_paths': connection_paths
+            'vocabulary': {
+                'raw_score': vocab_score,
+                'normalized_score': vocab_normalized
+            },
+            'structure': {
+                'raw_score': struct_score,
+                'normalized_score': struct_normalized
+            },
+            'cohesion': {
+                'raw_score': cohesion_score,
+                'normalized_score': cohesion_normalized
+            },
+            'clarity': {
+                'raw_score': clarity_score,
+                'normalized_score': clarity_normalized
+            }
         }
-        
+
     except Exception as e:
         logger.error(f"Error en analyze_text_dimensions: {str(e)}")
         raise
@@ -95,31 +115,41 @@ def get_dependency_depths(token, depth=0):
         depths.extend(get_dependency_depths(child, depth + 1))
     return depths
 
-def normalize_score(value, optimal_value=1.0, range_factor=2.0, optimal_length=None):
+def normalize_score(value, optimal_value=1.0, range_factor=2.0, optimal_length=None, optimal_connections=None):
     """
     Normaliza un valor a una escala de 0-1.
+    
     Args:
         value: Valor a normalizar
-        optimal_value: Valor óptimo de referencia 
+        optimal_value: Valor óptimo de referencia
         range_factor: Factor para ajustar el rango
         optimal_length: Longitud óptima (opcional)
+        optimal_connections: Número óptimo de conexiones (opcional)
+    
+    Returns:
+        float: Valor normalizado entre 0 y 1
     """
     try:
-        if optimal_length is not None:
+        if optimal_connections is not None:
+            # Usar optimal_connections si está definido
+            diff = abs(value - optimal_connections)
+            max_diff = optimal_connections * range_factor
+            return 1.0 - min(diff / max_diff, 1.0)
+        elif optimal_length is not None:
             # Usar optimal_length si está definido
             diff = abs(value - optimal_length)
             max_diff = optimal_length * range_factor
             return 1.0 - min(diff / max_diff, 1.0)
         else:
             # Usar optimal_value por defecto
-            diff = abs(value - optimal_value) 
+            diff = abs(value - optimal_value)
             max_diff = optimal_value * range_factor
             return 1.0 - min(diff / max_diff, 1.0)
+            
     except Exception as e:
         logger.error(f"Error en normalize_score: {str(e)}")
         return 0.0
 
-
 # Funciones de generación de gráficos
 def generate_sentence_graphs(doc):
     """Genera visualizaciones de estructura de oraciones"""