Update modules/studentact/current_situation_analysis.py

modules/studentact/current_situation_analysis.py

@@ -75,16 +75,197 @@ def analyze_text_dimensions(doc):
         raise
 
 def analyze_clarity(doc):
-    """Analiza la claridad basada en longitud de oraciones"""
-    sentences = list(doc.sents)
-    avg_length = sum(len(sent) for sent in sentences) / len(sentences)
-    return normalize_score(avg_length, optimal_length=20)
+    """
+    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
+    """
+    try:
+        # 1. Análisis de oraciones
+        sentences = list(doc.sents)
+        if not sentences:
+            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
+        )
+        
+        # 2. Análisis de conectores
+        connector_count = 0
+        connector_types = {
+            'CCONJ': 0.8,  # Coordinantes
+            'SCONJ': 1.0,  # Subordinantes
+            'ADV': 0.6     # Adverbios conectivos
+        }
+        
+        for token in doc:
+            if token.pos_ in connector_types and token.dep_ in ['cc', 'mark', 'advmod']:
+                connector_count += connector_types[token.pos_]
+                
+        connector_score = min(1.0, connector_count / (len(sentences) * 0.8))
+        
+        # 3. Complejidad estructural
+        clause_count = 0
+        for sent in sentences:
+            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)
+        
+        # 5. 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']])
+        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
+        )
+        
+        # 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
+        clarity_score = (
+            weights['length'] * length_score +
+            weights['connectors'] * connector_score +
+            weights['complexity'] * complexity_score +
+            weights['reference'] * reference_score +
+            weights['density'] * 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)
+        }
+        
+        return clarity_score, details
+        
+    except Exception as e:
+        logger.error(f"Error en analyze_clarity: {str(e)}")
+        return 0.0, {}
+
+def analyze_reference_clarity(doc):
+    """
+    Analiza la claridad de las referencias en el texto
+    """
+    try:
+        # Contar referencias anafóricas
+        reference_count = 0
+        unclear_references = 0
+        
+        for token in doc:
+            # Detectar pronombres y determinantes
+            if token.pos_ in ['PRON', 'DET']:
+                reference_count += 1
+                
+                # Verificar si tiene antecedente claro
+                has_antecedent = False
+                for ancestor in token.ancestors:
+                    if ancestor.pos_ == 'NOUN':
+                        has_antecedent = True
+                        break
+                        
+                if not has_antecedent:
+                    unclear_references += 1
+        
+        # Calcular score
+        if reference_count == 0:
+            return 1.0  # No hay referencias = claridad máxima
+            
+        clarity = 1.0 - (unclear_references / reference_count)
+        return max(0.0, min(1.0, clarity))
+        
+    except Exception as e:
+        logger.error(f"Error en analyze_reference_clarity: {str(e)}")
+        return 0.0
 
 def analyze_vocabulary_diversity(doc):
-    """Analiza la diversidad del vocabulario"""
-    unique_lemmas = {token.lemma_ for token in doc if token.is_alpha}
-    total_words = len([token for token in doc if token.is_alpha])
-    return len(unique_lemmas) / total_words if total_words > 0 else 0
+    """Análisis mejorado de la diversidad y calidad del vocabulario"""
+    try:
+        # 1. Análisis básico de diversidad
+        unique_lemmas = {token.lemma_ for token in doc if token.is_alpha}
+        total_words = len([token for token in doc if token.is_alpha])
+        basic_diversity = len(unique_lemmas) / total_words if total_words > 0 else 0
+        
+        # 2. Análisis de registro
+        academic_words = 0
+        narrative_words = 0
+        technical_terms = 0
+        
+        # Clasificar palabras por registro
+        for token in doc:
+            if token.is_alpha:
+                # Detectar términos académicos/técnicos
+                if token.pos_ in ['NOUN', 'VERB', 'ADJ']:
+                    if any(parent.pos_ == 'NOUN' for parent in token.ancestors):
+                        technical_terms += 1
+                # Detectar palabras narrativas
+                if token.pos_ in ['VERB', 'ADV'] and token.dep_ in ['ROOT', 'advcl']:
+                    narrative_words += 1
+                    
+        # 3. Análisis de complejidad sintáctica
+        avg_sentence_length = sum(len(sent) for sent in doc.sents) / len(list(doc.sents))
+        
+        # 4. Calcular score ponderado
+        weights = {
+            'diversity': 0.3,
+            'technical': 0.3,
+            'narrative': 0.2,
+            'complexity': 0.2
+        }
+        
+        scores = {
+            'diversity': basic_diversity,
+            'technical': technical_terms / total_words if total_words > 0 else 0,
+            'narrative': narrative_words / total_words if total_words > 0 else 0,
+            'complexity': min(1.0, avg_sentence_length / 20)  # Normalizado a 20 palabras
+        }
+        
+        # Score final ponderado
+        final_score = sum(weights[key] * scores[key] for key in weights)
+        
+        # Información adicional para diagnóstico
+        details = {
+            'text_type': 'narrative' if scores['narrative'] > scores['technical'] else 'academic',
+            'scores': scores
+        }
+        
+        return final_score, details
+        
+    except Exception as e:
+        logger.error(f"Error en analyze_vocabulary_diversity: {str(e)}")
+        return 0.0, {}
 
 def analyze_cohesion(doc):
     """Analiza la cohesión textual"""