Update modules/studentact/current_situation_analysis.py

modules/studentact/current_situation_analysis.py

@@ -12,101 +12,77 @@ import logging
 
 logger = logging.getLogger(__name__)
 
+###################################################################
 def analyze_text_dimensions(doc):
     """
     Analiza las dimensiones principales del texto.
-    
-    Args:
-        doc: Documento procesado por spaCy
-        
-    Returns:
-        dict: Métricas del análisis
     """
     try:
         # 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
-        )
-
+        vocab_score, vocab_details = analyze_vocabulary_diversity(doc)
+        
         # 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)
-        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
-        )
+        clarity_score, clarity_details = analyze_clarity(doc)
 
         return {
             'vocabulary': {
-                'raw_score': vocab_score,
-                'normalized_score': vocab_normalized
+                'normalized_score': vocab_score,
+                'details': vocab_details
             },
             'structure': {
-                'raw_score': struct_score,
-                'normalized_score': struct_normalized
+                'normalized_score': struct_score,
+                'details': None  # Por ahora no tiene detalles
             },
             'cohesion': {
-                'raw_score': cohesion_score,
-                'normalized_score': cohesion_normalized
+                'normalized_score': cohesion_score,
+                'details': None  # Por ahora no tiene detalles
             },
             'clarity': {
-                'raw_score': clarity_score,
-                'normalized_score': clarity_normalized
+                'normalized_score': clarity_score,
+                'details': clarity_details
             }
         }
 
     except Exception as e:
         logger.error(f"Error en analyze_text_dimensions: {str(e)}")
-        raise
+        return {
+            'vocabulary': {'normalized_score': 0.0, 'details': {}},
+            'structure': {'normalized_score': 0.0, 'details': {}},
+            'cohesion': {'normalized_score': 0.0, 'details': {}},
+            'clarity': {'normalized_score': 0.0, 'details': {}}
+        }
 
+####################################################################
 def analyze_clarity(doc):
     """
-    Analiza la claridad del texto considerando múltiples factores:
-    - Longitud y variación de oraciones
-    - Uso de conectores
-    - Complejidad estructural
-    - Claridad referencial
-    - Densidad léxica
+    Analiza la claridad del texto considerando múltiples factores.
     """
     try:
         # 1. Análisis de oraciones
         sentences = list(doc.sents)
         if not sentences:
-            return 0.0
+            return 0.0, {}
             
         # Longitud de oraciones
         sentence_lengths = [len(sent) for sent in sentences]
         avg_length = sum(sentence_lengths) / len(sentences)
         length_variation = np.std(sentence_lengths) if len(sentences) > 1 else 0
         
-        # Penalizar oraciones muy cortas o muy largas
-        length_score = normalize_score(
-            avg_length, 
-            optimal_length=20,  # Longitud óptima
-            range_factor=1.5    # Factor de tolerancia
-        )
+        # Normalizar longitud
+        length_score = normalize_score(avg_length, optimal_length=20)
         
         # 2. Análisis de conectores
         connector_count = 0
         connector_types = {
-            'CCONJ': 0.8,  # Coordinantes
-            'SCONJ': 1.0,  # Subordinantes
-            'ADV': 0.6     # Adverbios conectivos
+            'CCONJ': 0.8,
+            'SCONJ': 1.0,
+            'ADV': 0.6
         }
         
         for token in doc:
@@ -121,52 +97,33 @@ def analyze_clarity(doc):
             verbs = [token for token in sent if token.pos_ == 'VERB']
             clause_count += len(verbs)
             
-        complexity_score = normalize_score(
-            clause_count / len(sentences),
-            optimal_value=2.0,  # Promedio óptimo de cláusulas por oración
-            range_factor=1.5
-        )
-        
-        # 4. Claridad referencial
-        reference_score = analyze_reference_clarity(doc)
+        complexity_raw = clause_count / len(sentences) if len(sentences) > 0 else 0
+        complexity_score = normalize_score(complexity_raw, optimal_value=2.0)
         
-        # 5. Densidad léxica
+        # 4. Densidad léxica
         content_words = len([token for token in doc if token.pos_ in ['NOUN', 'VERB', 'ADJ', 'ADV']])
-        function_words = len([token for token in doc if token.pos_ not in ['NOUN', 'VERB', 'ADJ', 'ADV']])
+        total_words = len([token for token in doc])
         density_score = normalize_score(
-            content_words / (content_words + function_words) if (content_words + function_words) > 0 else 0,
-            optimal_value=0.6,  # 60% de palabras de contenido es óptimo
-            range_factor=1.5
+            content_words / total_words if total_words > 0 else 0,
+            optimal_value=0.6
         )
         
-        # Pesos para cada factor
-        weights = {
-            'length': 0.2,
-            'connectors': 0.2,
-            'complexity': 0.2,
-            'reference': 0.2,
-            'density': 0.2
-        }
-        
-        # Cálculo del score final ponderado
+        # Cálculo del score final
         clarity_score = (
-            weights['length'] * length_score +
-            weights['connectors'] * connector_score +
-            weights['complexity'] * complexity_score +
-            weights['reference'] * reference_score +
-            weights['density'] * density_score
+            0.3 * length_score +
+            0.3 * connector_score +
+            0.2 * complexity_score +
+            0.2 * density_score
         )
         
-        # Información detallada para diagnóstico
         details = {
             'length_score': length_score,
             'connector_score': connector_score,
             'complexity_score': complexity_score,
-            'reference_score': reference_score,
             'density_score': density_score,
             'avg_sentence_length': avg_length,
             'length_variation': length_variation,
-            'connectors_per_sentence': connector_count / len(sentences)
+            'connectors_per_sentence': connector_count / len(sentences) if len(sentences) > 0 else 0
         }
         
         return clarity_score, details