Upload 3 files

modules/studentact/current_situation_analysis.py

@@ -1,1008 +1,1009 @@
-#v3/modules/studentact/current_situation_analysis.py
-
-import streamlit as st
-import matplotlib.pyplot as plt
-import networkx as nx
-import seaborn as sns
-from collections import Counter
-from itertools import combinations
-import numpy as np
-import matplotlib.patches as patches
-import logging
-
-from translations.recommendations import RECOMMENDATIONS
-
-# 2. Configuración básica del logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(),
-        logging.FileHandler('app.log')
-    ]
-)
-
-# 3. Obtener el logger específico para este módulo
-logger = logging.getLogger(__name__)
-
-#########################################################################
-
-def correlate_metrics(scores):
-    """
-    Ajusta los scores para mantener correlaciones lógicas entre métricas.
-    
-    Args:
-        scores: dict con scores iniciales de vocabulario, estructura, cohesión y claridad
-        
-    Returns:
-        dict con scores ajustados
-    """
-    try:
-        # 1. Correlación estructura-cohesión
-        # La cohesión no puede ser menor que estructura * 0.7
-        min_cohesion = scores['structure']['normalized_score'] * 0.7
-        if scores['cohesion']['normalized_score'] < min_cohesion:
-            scores['cohesion']['normalized_score'] = min_cohesion
-
-        # 2. Correlación vocabulario-cohesión
-        # La cohesión léxica depende del vocabulario
-        vocab_influence = scores['vocabulary']['normalized_score'] * 0.6
-        scores['cohesion']['normalized_score'] = max(
-            scores['cohesion']['normalized_score'],
-            vocab_influence
-        )
-
-        # 3. Correlación cohesión-claridad
-        # La claridad no puede superar cohesión * 1.2
-        max_clarity = scores['cohesion']['normalized_score'] * 1.2
-        if scores['clarity']['normalized_score'] > max_clarity:
-            scores['clarity']['normalized_score'] = max_clarity
-
-        # 4. Correlación estructura-claridad
-        # La claridad no puede superar estructura * 1.1
-        struct_max_clarity = scores['structure']['normalized_score'] * 1.1
-        scores['clarity']['normalized_score'] = min(
-            scores['clarity']['normalized_score'],
-            struct_max_clarity
-        )
-
-        # Normalizar todos los scores entre 0 y 1
-        for metric in scores:
-            scores[metric]['normalized_score'] = max(0.0, min(1.0, scores[metric]['normalized_score']))
-
-        return scores
-
-    except Exception as e:
-        logger.error(f"Error en correlate_metrics: {str(e)}")
-        return scores
-
-##########################################################################
-
-def analyze_text_dimensions(doc):
-    """
-    Analiza las dimensiones principales del texto manteniendo correlaciones lógicas.
-    """
-    try:
-        # Obtener scores iniciales
-        vocab_score, vocab_details = analyze_vocabulary_diversity(doc)
-        struct_score = analyze_structure(doc)
-        cohesion_score = analyze_cohesion(doc)
-        clarity_score, clarity_details = analyze_clarity(doc)
-
-        # Crear diccionario de scores inicial
-        scores = {
-            'vocabulary': {
-                'normalized_score': vocab_score,
-                'details': vocab_details
-            },
-            'structure': {
-                'normalized_score': struct_score,
-                'details': None
-            },
-            'cohesion': {
-                'normalized_score': cohesion_score,
-                'details': None
-            },
-            'clarity': {
-                'normalized_score': clarity_score,
-                'details': clarity_details
-            }
-        }
-
-        # Ajustar correlaciones entre métricas
-        adjusted_scores = correlate_metrics(scores)
-
-        # Logging para diagnóstico
-        logger.info(f"""
-            Scores originales vs ajustados:
-            Vocabulario: {vocab_score:.2f} -> {adjusted_scores['vocabulary']['normalized_score']:.2f}
-            Estructura: {struct_score:.2f} -> {adjusted_scores['structure']['normalized_score']:.2f}
-            Cohesión: {cohesion_score:.2f} -> {adjusted_scores['cohesion']['normalized_score']:.2f}
-            Claridad: {clarity_score:.2f} -> {adjusted_scores['clarity']['normalized_score']:.2f}
-        """)
-
-        return adjusted_scores
-
-    except Exception as e:
-        logger.error(f"Error en analyze_text_dimensions: {str(e)}")
-        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.
-    """
-    try:
-        sentences = list(doc.sents)
-        if not sentences:
-            return 0.0, {}
-            
-        # 1. Longitud de oraciones
-        sentence_lengths = [len(sent) for sent in sentences]
-        avg_length = sum(sentence_lengths) / len(sentences)
-        
-        # Normalizar usando los umbrales definidos para clarity
-        length_score = normalize_score(
-            value=avg_length,
-            metric_type='clarity',
-            optimal_length=20,  # Una oración ideal tiene ~20 palabras
-            min_threshold=0.60,  # Consistente con METRIC_THRESHOLDS
-            target_threshold=0.75  # Consistente con METRIC_THRESHOLDS
-        )
-        
-        # 2. Análisis de conectores
-        connector_count = 0
-        connector_weights = {
-            'CCONJ': 1.0,  # Coordinantes
-            'SCONJ': 1.2,  # Subordinantes
-            'ADV': 0.8     # Adverbios conectivos
-        }
-        
-        for token in doc:
-            if token.pos_ in connector_weights and token.dep_ in ['cc', 'mark', 'advmod']:
-                connector_count += connector_weights[token.pos_]
-                
-        # Normalizar conectores por oración
-        connectors_per_sentence = connector_count / len(sentences) if sentences else 0
-        connector_score = normalize_score(
-            value=connectors_per_sentence,
-            metric_type='clarity',
-            optimal_connections=1.5,  # ~1.5 conectores por oración es óptimo
-            min_threshold=0.60,
-            target_threshold=0.75
-        )
-        
-        # 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_raw = clause_count / len(sentences) if sentences else 0
-        complexity_score = normalize_score(
-            value=complexity_raw,
-            metric_type='clarity',
-            optimal_depth=2.0,  # ~2 cláusulas por oración es óptimo
-            min_threshold=0.60,
-            target_threshold=0.75
-        )
-        
-        # 4. Densidad léxica
-        content_words = len([token for token in doc if token.pos_ in ['NOUN', 'VERB', 'ADJ', 'ADV']])
-        total_words = len([token for token in doc if token.is_alpha])
-        density = content_words / total_words if total_words > 0 else 0
-        
-        density_score = normalize_score(
-            value=density,
-            metric_type='clarity',
-            optimal_connections=0.6,  # 60% de palabras de contenido es óptimo
-            min_threshold=0.60,
-            target_threshold=0.75
-        )
-        
-        # Score final ponderado
-        weights = {
-            'length': 0.3,
-            'connectors': 0.3,
-            'complexity': 0.2,
-            'density': 0.2
-        }
-        
-        clarity_score = (
-            weights['length'] * length_score +
-            weights['connectors'] * connector_score +
-            weights['complexity'] * complexity_score +
-            weights['density'] * density_score
-        )
-
-        details = {
-            'length_score': length_score,
-            'connector_score': connector_score,
-            'complexity_score': complexity_score,
-            'density_score': density_score,
-            'avg_sentence_length': avg_length,
-            'connectors_per_sentence': connectors_per_sentence,
-            'density': density
-        }
-        
-        # Agregar logging para diagnóstico
-        logger.info(f"""
-            Scores de Claridad:
-            - Longitud: {length_score:.2f} (avg={avg_length:.1f} palabras)
-            - Conectores: {connector_score:.2f} (avg={connectors_per_sentence:.1f} por oración)
-            - Complejidad: {complexity_score:.2f} (avg={complexity_raw:.1f} cláusulas)
-            - Densidad: {density_score:.2f} ({density*100:.1f}% palabras de contenido)
-            - Score Final: {clarity_score:.2f}
-        """)
-        
-        return clarity_score, details
-
-    except Exception as e:
-        logger.error(f"Error en analyze_clarity: {str(e)}")
-        return 0.0, {}
-
-#########################################################################
-def analyze_vocabulary_diversity(doc):
-    """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"""
-    try:
-        sentences = list(doc.sents)
-        if len(sentences) < 2:
-            logger.warning("Texto demasiado corto para análisis de cohesión")
-            return 0.0
-            
-        # 1. Análisis de conexiones léxicas
-        lexical_connections = 0
-        total_possible_connections = 0
-        
-        for i in range(len(sentences)-1):
-            # Obtener lemmas significativos (no stopwords)
-            sent1_words = {token.lemma_ for token in sentences[i] 
-                         if token.is_alpha and not token.is_stop}
-            sent2_words = {token.lemma_ for token in sentences[i+1] 
-                         if token.is_alpha and not token.is_stop}
-            
-            if sent1_words and sent2_words:  # Verificar que ambos conjuntos no estén vacíos
-                intersection = len(sent1_words.intersection(sent2_words))
-                total_possible = min(len(sent1_words), len(sent2_words))
-                
-                if total_possible > 0:
-                    lexical_score = intersection / total_possible
-                    lexical_connections += lexical_score
-                    total_possible_connections += 1
-        
-        # 2. Análisis de conectores
-        connector_count = 0
-        connector_types = {
-            'CCONJ': 1.0,  # Coordinantes
-            'SCONJ': 1.2,  # Subordinantes
-            'ADV': 0.8     # Adverbios conectivos
-        }
-        
-        for token in doc:
-            if (token.pos_ in connector_types and 
-                token.dep_ in ['cc', 'mark', 'advmod'] and 
-                not token.is_stop):
-                connector_count += connector_types[token.pos_]
-        
-        # 3. Cálculo de scores normalizados
-        if total_possible_connections > 0:
-            lexical_cohesion = lexical_connections / total_possible_connections
-        else:
-            lexical_cohesion = 0
-            
-        if len(sentences) > 1:
-            connector_cohesion = min(1.0, connector_count / (len(sentences) - 1))
-        else:
-            connector_cohesion = 0
-        
-        # 4. Score final ponderado
-        weights = {
-            'lexical': 0.7,
-            'connectors': 0.3
-        }
-        
-        cohesion_score = (
-            weights['lexical'] * lexical_cohesion + 
-            weights['connectors'] * connector_cohesion
-        )
-        
-        # 5. Logging para diagnóstico
-        logger.info(f"""
-            Análisis de Cohesión:
-            - Conexiones léxicas encontradas: {lexical_connections}
-            - Conexiones posibles: {total_possible_connections}
-            - Lexical cohesion score: {lexical_cohesion}
-            - Conectores encontrados: {connector_count}
-            - Connector cohesion score: {connector_cohesion}
-            - Score final: {cohesion_score}
-        """)
-        
-        return cohesion_score
-
-    except Exception as e:
-        logger.error(f"Error en analyze_cohesion: {str(e)}")
-        return 0.0
-
-#########################################################################
-def analyze_structure(doc):
-    try:
-        if len(doc) == 0:
-            return 0.0
-            
-        structure_scores = []
-        for token in doc:
-            if token.dep_ == 'ROOT':
-                result = get_dependency_depths(token)
-                structure_scores.append(result['final_score'])
-                
-        if not structure_scores:
-            return 0.0
-            
-        return min(1.0, sum(structure_scores) / len(structure_scores))
-        
-    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, analyzed_tokens=None):
-    """
-    Analiza la profundidad y calidad de las relaciones de dependencia.
-    
-    Args:
-        token: Token a analizar
-        depth: Profundidad actual en el árbol
-        analyzed_tokens: Set para evitar ciclos en el análisis
-    
-    Returns:
-        dict: Información detallada sobre las dependencias
-            - depths: Lista de profundidades
-            - relations: Diccionario con tipos de relaciones encontradas
-            - complexity_score: Puntuación de complejidad
-    """
-    if analyzed_tokens is None:
-        analyzed_tokens = set()
-        
-    # Evitar ciclos
-    if token.i in analyzed_tokens:
-        return {
-            'depths': [],
-            'relations': {},
-            'complexity_score': 0
-        }
-    
-    analyzed_tokens.add(token.i)
-    
-    # Pesos para diferentes tipos de dependencias
-    dependency_weights = {
-        # Dependencias principales
-        'nsubj': 1.2,    # Sujeto nominal
-        'obj': 1.1,      # Objeto directo
-        'iobj': 1.1,     # Objeto indirecto
-        'ROOT': 1.3,     # Raíz
-        
-        # Modificadores
-        'amod': 0.8,     # Modificador adjetival
-        'advmod': 0.8,   # Modificador adverbial
-        'nmod': 0.9,     # Modificador nominal
-        
-        # Estructuras complejas
-        'csubj': 1.4,    # Cláusula como sujeto
-        'ccomp': 1.3,    # Complemento clausal
-        'xcomp': 1.2,    # Complemento clausal abierto
-        'advcl': 1.2,    # Cláusula adverbial
-        
-        # Coordinación y subordinación
-        'conj': 1.1,     # Conjunción
-        'cc': 0.7,       # Coordinación
-        'mark': 0.8,     # Marcador
-        
-        # Otros
-        'det': 0.5,      # Determinante
-        'case': 0.5,     # Caso
-        'punct': 0.1     # Puntuación
-    }
-    
-    # Inicializar resultados
-    current_result = {
-        'depths': [depth],
-        'relations': {token.dep_: 1},
-        'complexity_score': dependency_weights.get(token.dep_, 0.5) * (depth + 1)
-    }
-    
-    # Analizar hijos recursivamente
-    for child in token.children:
-        child_result = get_dependency_depths(child, depth + 1, analyzed_tokens)
-        
-        # Combinar profundidades
-        current_result['depths'].extend(child_result['depths'])
-        
-        # Combinar relaciones
-        for rel, count in child_result['relations'].items():
-            current_result['relations'][rel] = current_result['relations'].get(rel, 0) + count
-            
-        # Acumular score de complejidad
-        current_result['complexity_score'] += child_result['complexity_score']
-        
-    # Calcular métricas adicionales
-    current_result['max_depth'] = max(current_result['depths'])
-    current_result['avg_depth'] = sum(current_result['depths']) / len(current_result['depths'])
-    current_result['relation_diversity'] = len(current_result['relations'])
-    
-    # Calcular score ponderado por tipo de estructura
-    structure_bonus = 0
-    
-    # Bonus por estructuras complejas
-    if 'csubj' in current_result['relations'] or 'ccomp' in current_result['relations']:
-        structure_bonus += 0.3
-    
-    # Bonus por coordinación balanceada
-    if 'conj' in current_result['relations'] and 'cc' in current_result['relations']:
-        structure_bonus += 0.2
-    
-    # Bonus por modificación rica
-    if len(set(['amod', 'advmod', 'nmod']) & set(current_result['relations'])) >= 2:
-        structure_bonus += 0.2
-        
-    current_result['final_score'] = (
-        current_result['complexity_score'] * (1 + structure_bonus)
-    )
-    
-    return current_result
-
-#########################################################################
-def normalize_score(value, metric_type, 
-                   min_threshold=0.0, target_threshold=1.0, 
-                   range_factor=2.0, optimal_length=None, 
-                   optimal_connections=None, optimal_depth=None):
-    """
-    Normaliza un valor considerando umbrales específicos por tipo de métrica.
-    
-    Args:
-        value: Valor a normalizar
-        metric_type: Tipo de métrica ('vocabulary', 'structure', 'cohesion', 'clarity')
-        min_threshold: Valor mínimo aceptable
-        target_threshold: Valor objetivo
-        range_factor: Factor para ajustar el rango
-        optimal_length: Longitud óptima (opcional)
-        optimal_connections: Número óptimo de conexiones (opcional)
-        optimal_depth: Profundidad óptima de estructura (opcional)
-    
-    Returns:
-        float: Valor normalizado entre 0 y 1
-    """
-    try:
-        # Definir umbrales por tipo de métrica
-        METRIC_THRESHOLDS = {
-            'vocabulary': {
-                'min': 0.60,
-                'target': 0.75,
-                'range_factor': 1.5
-            },
-            'structure': {
-                'min': 0.65,
-                'target': 0.80,
-                'range_factor': 1.8
-            },
-            'cohesion': {
-                'min': 0.55,
-                'target': 0.70,
-                'range_factor': 1.6
-            },
-            'clarity': {
-                'min': 0.60,
-                'target': 0.75,
-                'range_factor': 1.7
-            }
-        }
-
-        # 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
-
-        # Obtener umbrales específicos para el tipo de métrica
-        thresholds = METRIC_THRESHOLDS.get(metric_type, {
-            'min': min_threshold,
-            'target': target_threshold,
-            'range_factor': range_factor
-        })
-        
-        # Identificar el valor de referencia a usar
-        if optimal_depth is not None:
-            reference = optimal_depth
-        elif optimal_connections is not None:
-            reference = optimal_connections
-        elif optimal_length is not None:
-            reference = optimal_length
-        else:
-            reference = thresholds['target']
-
-        # Validar valor de referencia
-        if reference <= 0:
-            logger.warning(f"Valor de referencia inválido: {reference}")
-            return 0.0
-
-        # Calcular score basado en umbrales
-        if value < thresholds['min']:
-            # Valor por debajo del mínimo
-            score = (value / thresholds['min']) * 0.5  # Máximo 0.5 para valores bajo el mínimo
-        elif value < thresholds['target']:
-            # Valor entre mínimo y objetivo
-            range_size = thresholds['target'] - thresholds['min']
-            progress = (value - thresholds['min']) / range_size
-            score = 0.5 + (progress * 0.5)  # Escala entre 0.5 y 1.0
-        else:
-            # Valor alcanza o supera el objetivo
-            score = 1.0
-            
-            # Penalizar valores muy por encima del objetivo
-            if value > (thresholds['target'] * thresholds['range_factor']):
-                excess = (value - thresholds['target']) / (thresholds['target'] * thresholds['range_factor'])
-                score = max(0.7, 1.0 - excess)  # No bajar de 0.7 para valores altos
-
-        # 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
-
-#########################################################################
-#########################################################################
-def generate_recommendations(metrics, text_type, lang_code='es'):
-    """
-    Genera recomendaciones personalizadas basadas en las métricas del texto y el tipo de texto.
-    
-    Args:
-        metrics: Diccionario con las métricas analizadas
-        text_type: Tipo de texto ('academic_article', 'student_essay', 'general_communication')
-        lang_code: Código del idioma para las recomendaciones (es, en, fr, pt)
-    
-    Returns:
-        dict: Recomendaciones organizadas por categoría en el idioma correspondiente
-    """
-    try:
-        # Obtener umbrales según el tipo de texto
-        thresholds = TEXT_TYPES[text_type]['thresholds']
-        
-        # Verificar que el idioma esté soportado, usar español como respaldo
-        if lang_code not in RECOMMENDATIONS:
-            logger.warning(f"Idioma {lang_code} no soportado para recomendaciones, usando español")
-            lang_code = 'es'
-            
-        # Obtener traducciones para el idioma seleccionado
-        translations = RECOMMENDATIONS[lang_code]
-        
-        # Inicializar diccionario de recomendaciones
-        recommendations = {
-            'vocabulary': [],
-            'structure': [],
-            'cohesion': [],
-            'clarity': [],
-            'specific': [],
-            'priority': {
-                'area': 'general',
-                'tips': []
-            },
-            'text_type_name': translations['text_types'][text_type],
-            'dimension_names': translations['dimension_names'],
-            'ui_text': {
-                'priority_intro': translations['priority_intro'],
-                'detailed_recommendations': translations['detailed_recommendations'],
-                'save_button': translations['save_button'],
-                'save_success': translations['save_success'],
-                'save_error': translations['save_error'],
-                'area_priority': translations['area_priority']
-            }
-        }
-        
-        # Determinar nivel para cada dimensión y asignar recomendaciones
-        dimensions = ['vocabulary', 'structure', 'cohesion', 'clarity']
-        scores = {}
-        
-        for dim in dimensions:
-            score = metrics[dim]['normalized_score']
-            scores[dim] = score
-            
-            # Determinar nivel (bajo, medio, alto)
-            if score < thresholds[dim]['min']:
-                level = 'low'
-            elif score < thresholds[dim]['target']:
-                level = 'medium'
-            else:
-                level = 'high'
-                
-            # Asignar recomendaciones para ese nivel
-            recommendations[dim] = translations[dim][level]
-        
-        # Asignar recomendaciones específicas por tipo de texto
-        recommendations['specific'] = translations[text_type]
-        
-        # Determinar área prioritaria (la que tiene menor puntuación)
-        priority_dimension = min(scores, key=scores.get)
-        recommendations['priority']['area'] = priority_dimension
-        recommendations['priority']['tips'] = recommendations[priority_dimension]
-        
-        logger.info(f"Generadas recomendaciones en {lang_code} para texto tipo {text_type}")
-        return recommendations
-        
-    except Exception as e:
-        logger.error(f"Error en generate_recommendations: {str(e)}")
-        # Retornar mensajes genéricos en caso de error
-        if lang_code == 'en':
-            return {
-                'vocabulary': ["Try enriching your vocabulary"],
-                'structure': ["Work on the structure of your sentences"],
-                'cohesion': ["Improve the connection between your ideas"],
-                'clarity': ["Try to express your ideas more clearly"],
-                'specific': ["Adapt your text according to its purpose"],
-                'priority': {
-                    'area': 'general',
-                    'tips': ["Seek specific feedback from a tutor or teacher"]
-                },
-                'dimension_names': {
-                    'vocabulary': 'Vocabulary',
-                    'structure': 'Structure',
-                    'cohesion': 'Cohesion',
-                    'clarity': 'Clarity',
-                    'general': 'General'
-                },
-                'ui_text': {
-                    'priority_intro': "This is where you should focus your efforts.",
-                    'detailed_recommendations': "Detailed recommendations",
-                    'save_button': "Save analysis",
-                    'save_success': "Analysis saved successfully",
-                    'save_error': "Error saving analysis",
-                    'area_priority': "Priority area"
-                }
-            }
-        elif lang_code == 'fr':
-            return {
-                'vocabulary': ["Essayez d'enrichir votre vocabulaire"],
-                'structure': ["Travaillez sur la structure de vos phrases"],
-                'cohesion': ["Améliorez la connexion entre vos idées"],
-                'clarity': ["Essayez d'exprimer vos idées plus clairement"],
-                'specific': ["Adaptez votre texte en fonction de son objectif"],
-                'priority': {
-                    'area': 'general',
-                    'tips': ["Demandez des commentaires spécifiques à un tuteur ou un professeur"]
-                },
-                'dimension_names': {
-                    'vocabulary': 'Vocabulaire',
-                    'structure': 'Structure',
-                    'cohesion': 'Cohésion',
-                    'clarity': 'Clarté',
-                    'general': 'Général'
-                },
-                'ui_text': {
-                    'priority_intro': "C'est là que vous devriez concentrer vos efforts.",
-                    'detailed_recommendations': "Recommandations détaillées",
-                    'save_button': "Enregistrer l'analyse",
-                    'save_success': "Analyse enregistrée avec succès",
-                    'save_error': "Erreur lors de l'enregistrement de l'analyse",
-                    'area_priority': "Domaine prioritaire"
-                }
-            }
-        elif lang_code == 'pt':
-            return {
-                'vocabulary': ["Tente enriquecer seu vocabulário"],
-                'structure': ["Trabalhe na estrutura de suas frases"],
-                'cohesion': ["Melhore a conexão entre suas ideias"],
-                'clarity': ["Tente expressar suas ideias com mais clareza"],
-                'specific': ["Adapte seu texto de acordo com seu propósito"],
-                'priority': {
-                    'area': 'general',
-                    'tips': ["Busque feedback específico de um tutor ou professor"]
-                },
-                'dimension_names': {
-                    'vocabulary': 'Vocabulário',
-                    'structure': 'Estrutura',
-                    'cohesion': 'Coesão',
-                    'clarity': 'Clareza',
-                    'general': 'Geral'
-                },
-                'ui_text': {
-                    'priority_intro': "É aqui que você deve concentrar seus esforços.",
-                    'detailed_recommendations': "Recomendações detalhadas",
-                    'save_button': "Salvar análise",
-                    'save_success': "Análise salva com sucesso",
-                    'save_error': "Erro ao salvar análise",
-                    'area_priority': "Área prioritária"
-                }
-            }
-        else:  # Español por defecto
-            return {
-                'vocabulary': ["Intenta enriquecer tu vocabulario"],
-                'structure': ["Trabaja en la estructura de tus oraciones"],
-                'cohesion': ["Mejora la conexión entre tus ideas"],
-                'clarity': ["Busca expresar tus ideas con mayor claridad"],
-                'specific': ["Adapta tu texto según su propósito"],
-                'priority': {
-                    'area': 'general',
-                    'tips': ["Busca retroalimentación específica de un tutor o profesor"]
-                },
-                'dimension_names': {
-                    'vocabulary': 'Vocabulario',
-                    'structure': 'Estructura',
-                    'cohesion': 'Cohesión',
-                    'clarity': 'Claridad',
-                    'general': 'General'
-                },
-                'ui_text': {
-                    'priority_intro': "Esta es el área donde debes concentrar tus esfuerzos.",
-                    'detailed_recommendations': "Recomendaciones detalladas",
-                    'save_button': "Guardar análisis",
-                    'save_success': "Análisis guardado con éxito",
-                    'save_error': "Error al guardar el análisis",
-                    'area_priority': "Área prioritaria"
-                }
-            }
-
-
-#########################################################################
-#########################################################################
-# Funciones de generación de gráficos
-def generate_sentence_graphs(doc):
-    """Genera visualizaciones de estructura de oraciones"""
-    fig, ax = plt.subplots(figsize=(10, 6))
-    # Implementar visualización
-    plt.close()
-    return fig
-
-def generate_word_connections(doc):
-    """Genera red de conexiones de palabras"""
-    fig, ax = plt.subplots(figsize=(10, 6))
-    # Implementar visualización
-    plt.close()
-    return fig
-
-def generate_connection_paths(doc):
-    """Genera patrones de conexión"""
-    fig, ax = plt.subplots(figsize=(10, 6))
-    # Implementar visualización
-    plt.close()
-    return fig
-
-def create_vocabulary_network(doc):
-    """
-    Genera el grafo de red de vocabulario.
-    """
-    G = nx.Graph()
-    
-    # Crear nodos para palabras significativas
-    words = [token.text.lower() for token in doc if token.is_alpha and not token.is_stop]
-    word_freq = Counter(words)
-    
-    # Añadir nodos con tamaño basado en frecuencia
-    for word, freq in word_freq.items():
-        G.add_node(word, size=freq)
-    
-    # Crear conexiones basadas en co-ocurrencia
-    window_size = 5
-    for i in range(len(words) - window_size):
-        window = words[i:i+window_size]
-        for w1, w2 in combinations(set(window), 2):
-            if G.has_edge(w1, w2):
-                G[w1][w2]['weight'] += 1
-            else:
-                G.add_edge(w1, w2, weight=1)
-    
-    # Crear visualización
-    fig, ax = plt.subplots(figsize=(12, 8))
-    pos = nx.spring_layout(G)
-    
-    # Dibujar nodos
-    nx.draw_networkx_nodes(G, pos, 
-                          node_size=[G.nodes[node]['size']*100 for node in G.nodes],
-                          node_color='lightblue',
-                          alpha=0.7)
-    
-    # Dibujar conexiones
-    nx.draw_networkx_edges(G, pos, 
-                          width=[G[u][v]['weight']*0.5 for u,v in G.edges],
-                          alpha=0.5)
-    
-    # Añadir etiquetas
-    nx.draw_networkx_labels(G, pos)
-    
-    plt.title("Red de Vocabulario")
-    plt.axis('off')
-    return fig
-
-def create_syntax_complexity_graph(doc):
-    """
-    Genera el diagrama de arco de complejidad sintáctica.
-    Muestra la estructura de dependencias con colores basados en la complejidad.
-    """
-    try:
-        # Preparar datos para la visualización
-        sentences = list(doc.sents)
-        if not sentences:
-            return None
-            
-        # Crear figura para el gráfico
-        fig, ax = plt.subplots(figsize=(12, len(sentences) * 2))
-        
-        # Colores para diferentes niveles de profundidad
-        depth_colors = plt.cm.viridis(np.linspace(0, 1, 6))
-        
-        y_offset = 0
-        max_x = 0
-        
-        for sent in sentences:
-            words = [token.text for token in sent]
-            x_positions = range(len(words))
-            max_x = max(max_x, len(words))
-            
-            # Dibujar palabras
-            plt.plot(x_positions, [y_offset] * len(words), 'k-', alpha=0.2)
-            plt.scatter(x_positions, [y_offset] * len(words), alpha=0)
-            
-            # Añadir texto
-            for i, word in enumerate(words):
-                plt.annotate(word, (i, y_offset), xytext=(0, -10), 
-                           textcoords='offset points', ha='center')
-            
-            # Dibujar arcos de dependencia
-            for token in sent:
-                if token.dep_ != "ROOT":
-                    # Calcular profundidad de dependencia
-                    depth = 0
-                    current = token
-                    while current.head != current:
-                        depth += 1
-                        current = current.head
-                    
-                    # Determinar posiciones para el arco
-                    start = token.i - sent[0].i
-                    end = token.head.i - sent[0].i
-                    
-                    # Altura del arco basada en la distancia entre palabras
-                    height = 0.5 * abs(end - start)
-                    
-                    # Color basado en la profundidad
-                    color = depth_colors[min(depth, len(depth_colors)-1)]
-                    
-                    # Crear arco
-                    arc = patches.Arc((min(start, end) + abs(end - start)/2, y_offset),
-                                    width=abs(end - start),
-                                    height=height,
-                                    angle=0,
-                                    theta1=0,
-                                    theta2=180,
-                                    color=color,
-                                    alpha=0.6)
-                    ax.add_patch(arc)
-            
-            y_offset -= 2
-        
-        # Configurar el gráfico
-        plt.xlim(-1, max_x)
-        plt.ylim(y_offset - 1, 1)
-        plt.axis('off')
-        plt.title("Complejidad Sintáctica")
-        
-        return fig
-        
-    except Exception as e:
-        logger.error(f"Error en create_syntax_complexity_graph: {str(e)}")
-        return None
-
-
-def create_cohesion_heatmap(doc):
-    """Genera un mapa de calor que muestra la cohesión entre párrafos/oraciones."""
-    try:
-        sentences = list(doc.sents)
-        n_sentences = len(sentences)
-        
-        if n_sentences < 2:
-            return None
-            
-        similarity_matrix = np.zeros((n_sentences, n_sentences))
-        
-        for i in range(n_sentences):
-            for j in range(n_sentences):
-                sent1_lemmas = {token.lemma_ for token in sentences[i] 
-                              if token.is_alpha and not token.is_stop}
-                sent2_lemmas = {token.lemma_ for token in sentences[j] 
-                              if token.is_alpha and not token.is_stop}
-                
-                if sent1_lemmas and sent2_lemmas:
-                    intersection = len(sent1_lemmas & sent2_lemmas)  # Corregido aquí
-                    union = len(sent1_lemmas | sent2_lemmas)  # Y aquí
-                    similarity_matrix[i, j] = intersection / union if union > 0 else 0
-        
-        # Crear visualización
-        fig, ax = plt.subplots(figsize=(10, 8))
-        
-        sns.heatmap(similarity_matrix,
-                   cmap='YlOrRd',
-                   square=True,
-                   xticklabels=False,
-                   yticklabels=False,
-                   cbar_kws={'label': 'Cohesión'},
-                   ax=ax)
-        
-        plt.title("Mapa de Cohesión Textual")
-        plt.xlabel("Oraciones")
-        plt.ylabel("Oraciones")
-        
-        plt.tight_layout()
-        return fig
-        
-    except Exception as e:
-        logger.error(f"Error en create_cohesion_heatmap: {str(e)}")
-        return None
+#v3/modules/studentact/current_situation_analysis.py
+
+import streamlit as st
+import matplotlib.pyplot as plt
+import networkx as nx
+import seaborn as sns
+from collections import Counter
+from itertools import combinations
+import numpy as np
+import matplotlib.patches as patches
+import logging
+
+
+# 2. Configuración básica del logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('app.log')
+    ]
+)
+
+# 3. Obtener el logger específico para este módulo
+logger = logging.getLogger(__name__)
+
+#########################################################################
+
+def correlate_metrics(scores):
+    """
+    Ajusta los scores para mantener correlaciones lógicas entre métricas.
+    
+    Args:
+        scores: dict con scores iniciales de vocabulario, estructura, cohesión y claridad
+        
+    Returns:
+        dict con scores ajustados
+    """
+    try:
+        # 1. Correlación estructura-cohesión
+        # La cohesión no puede ser menor que estructura * 0.7
+        min_cohesion = scores['structure']['normalized_score'] * 0.7
+        if scores['cohesion']['normalized_score'] < min_cohesion:
+            scores['cohesion']['normalized_score'] = min_cohesion
+
+        # 2. Correlación vocabulario-cohesión
+        # La cohesión léxica depende del vocabulario
+        vocab_influence = scores['vocabulary']['normalized_score'] * 0.6
+        scores['cohesion']['normalized_score'] = max(
+            scores['cohesion']['normalized_score'],
+            vocab_influence
+        )
+
+        # 3. Correlación cohesión-claridad
+        # La claridad no puede superar cohesión * 1.2
+        max_clarity = scores['cohesion']['normalized_score'] * 1.2
+        if scores['clarity']['normalized_score'] > max_clarity:
+            scores['clarity']['normalized_score'] = max_clarity
+
+        # 4. Correlación estructura-claridad
+        # La claridad no puede superar estructura * 1.1
+        struct_max_clarity = scores['structure']['normalized_score'] * 1.1
+        scores['clarity']['normalized_score'] = min(
+            scores['clarity']['normalized_score'],
+            struct_max_clarity
+        )
+
+        # Normalizar todos los scores entre 0 y 1
+        for metric in scores:
+            scores[metric]['normalized_score'] = max(0.0, min(1.0, scores[metric]['normalized_score']))
+
+        return scores
+
+    except Exception as e:
+        logger.error(f"Error en correlate_metrics: {str(e)}")
+        return scores
+
+##########################################################################
+
+def analyze_text_dimensions(doc):
+    """
+    Analiza las dimensiones principales del texto manteniendo correlaciones lógicas.
+    """
+    try:
+        # Obtener scores iniciales
+        vocab_score, vocab_details = analyze_vocabulary_diversity(doc)
+        struct_score = analyze_structure(doc)
+        cohesion_score = analyze_cohesion(doc)
+        clarity_score, clarity_details = analyze_clarity(doc)
+
+        # Crear diccionario de scores inicial
+        scores = {
+            'vocabulary': {
+                'normalized_score': vocab_score,
+                'details': vocab_details
+            },
+            'structure': {
+                'normalized_score': struct_score,
+                'details': None
+            },
+            'cohesion': {
+                'normalized_score': cohesion_score,
+                'details': None
+            },
+            'clarity': {
+                'normalized_score': clarity_score,
+                'details': clarity_details
+            }
+        }
+
+        # Ajustar correlaciones entre métricas
+        adjusted_scores = correlate_metrics(scores)
+
+        # Logging para diagnóstico
+        logger.info(f"""
+            Scores originales vs ajustados:
+            Vocabulario: {vocab_score:.2f} -> {adjusted_scores['vocabulary']['normalized_score']:.2f}
+            Estructura: {struct_score:.2f} -> {adjusted_scores['structure']['normalized_score']:.2f}
+            Cohesión: {cohesion_score:.2f} -> {adjusted_scores['cohesion']['normalized_score']:.2f}
+            Claridad: {clarity_score:.2f} -> {adjusted_scores['clarity']['normalized_score']:.2f}
+        """)
+
+        return adjusted_scores
+
+    except Exception as e:
+        logger.error(f"Error en analyze_text_dimensions: {str(e)}")
+        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.
+    """
+    try:
+        sentences = list(doc.sents)
+        if not sentences:
+            return 0.0, {}
+            
+        # 1. Longitud de oraciones
+        sentence_lengths = [len(sent) for sent in sentences]
+        avg_length = sum(sentence_lengths) / len(sentences)
+        
+        # Normalizar usando los umbrales definidos para clarity
+        length_score = normalize_score(
+            value=avg_length,
+            metric_type='clarity',
+            optimal_length=20,  # Una oración ideal tiene ~20 palabras
+            min_threshold=0.60,  # Consistente con METRIC_THRESHOLDS
+            target_threshold=0.75  # Consistente con METRIC_THRESHOLDS
+        )
+        
+        # 2. Análisis de conectores
+        connector_count = 0
+        connector_weights = {
+            'CCONJ': 1.0,  # Coordinantes
+            'SCONJ': 1.2,  # Subordinantes
+            'ADV': 0.8     # Adverbios conectivos
+        }
+        
+        for token in doc:
+            if token.pos_ in connector_weights and token.dep_ in ['cc', 'mark', 'advmod']:
+                connector_count += connector_weights[token.pos_]
+                
+        # Normalizar conectores por oración
+        connectors_per_sentence = connector_count / len(sentences) if sentences else 0
+        connector_score = normalize_score(
+            value=connectors_per_sentence,
+            metric_type='clarity',
+            optimal_connections=1.5,  # ~1.5 conectores por oración es óptimo
+            min_threshold=0.60,
+            target_threshold=0.75
+        )
+        
+        # 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_raw = clause_count / len(sentences) if sentences else 0
+        complexity_score = normalize_score(
+            value=complexity_raw,
+            metric_type='clarity',
+            optimal_depth=2.0,  # ~2 cláusulas por oración es óptimo
+            min_threshold=0.60,
+            target_threshold=0.75
+        )
+        
+        # 4. Densidad léxica
+        content_words = len([token for token in doc if token.pos_ in ['NOUN', 'VERB', 'ADJ', 'ADV']])
+        total_words = len([token for token in doc if token.is_alpha])
+        density = content_words / total_words if total_words > 0 else 0
+        
+        density_score = normalize_score(
+            value=density,
+            metric_type='clarity',
+            optimal_connections=0.6,  # 60% de palabras de contenido es óptimo
+            min_threshold=0.60,
+            target_threshold=0.75
+        )
+        
+        # Score final ponderado
+        weights = {
+            'length': 0.3,
+            'connectors': 0.3,
+            'complexity': 0.2,
+            'density': 0.2
+        }
+        
+        clarity_score = (
+            weights['length'] * length_score +
+            weights['connectors'] * connector_score +
+            weights['complexity'] * complexity_score +
+            weights['density'] * density_score
+        )
+
+        details = {
+            'length_score': length_score,
+            'connector_score': connector_score,
+            'complexity_score': complexity_score,
+            'density_score': density_score,
+            'avg_sentence_length': avg_length,
+            'connectors_per_sentence': connectors_per_sentence,
+            'density': density
+        }
+        
+        # Agregar logging para diagnóstico
+        logger.info(f"""
+            Scores de Claridad:
+            - Longitud: {length_score:.2f} (avg={avg_length:.1f} palabras)
+            - Conectores: {connector_score:.2f} (avg={connectors_per_sentence:.1f} por oración)
+            - Complejidad: {complexity_score:.2f} (avg={complexity_raw:.1f} cláusulas)
+            - Densidad: {density_score:.2f} ({density*100:.1f}% palabras de contenido)
+            - Score Final: {clarity_score:.2f}
+        """)
+        
+        return clarity_score, details
+
+    except Exception as e:
+        logger.error(f"Error en analyze_clarity: {str(e)}")
+        return 0.0, {}
+
+#########################################################################
+def analyze_vocabulary_diversity(doc):
+    """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"""
+    try:
+        sentences = list(doc.sents)
+        if len(sentences) < 2:
+            logger.warning("Texto demasiado corto para análisis de cohesión")
+            return 0.0
+            
+        # 1. Análisis de conexiones léxicas
+        lexical_connections = 0
+        total_possible_connections = 0
+        
+        for i in range(len(sentences)-1):
+            # Obtener lemmas significativos (no stopwords)
+            sent1_words = {token.lemma_ for token in sentences[i] 
+                         if token.is_alpha and not token.is_stop}
+            sent2_words = {token.lemma_ for token in sentences[i+1] 
+                         if token.is_alpha and not token.is_stop}
+            
+            if sent1_words and sent2_words:  # Verificar que ambos conjuntos no estén vacíos
+                intersection = len(sent1_words.intersection(sent2_words))
+                total_possible = min(len(sent1_words), len(sent2_words))
+                
+                if total_possible > 0:
+                    lexical_score = intersection / total_possible
+                    lexical_connections += lexical_score
+                    total_possible_connections += 1
+        
+        # 2. Análisis de conectores
+        connector_count = 0
+        connector_types = {
+            'CCONJ': 1.0,  # Coordinantes
+            'SCONJ': 1.2,  # Subordinantes
+            'ADV': 0.8     # Adverbios conectivos
+        }
+        
+        for token in doc:
+            if (token.pos_ in connector_types and 
+                token.dep_ in ['cc', 'mark', 'advmod'] and 
+                not token.is_stop):
+                connector_count += connector_types[token.pos_]
+        
+        # 3. Cálculo de scores normalizados
+        if total_possible_connections > 0:
+            lexical_cohesion = lexical_connections / total_possible_connections
+        else:
+            lexical_cohesion = 0
+            
+        if len(sentences) > 1:
+            connector_cohesion = min(1.0, connector_count / (len(sentences) - 1))
+        else:
+            connector_cohesion = 0
+        
+        # 4. Score final ponderado
+        weights = {
+            'lexical': 0.7,
+            'connectors': 0.3
+        }
+        
+        cohesion_score = (
+            weights['lexical'] * lexical_cohesion + 
+            weights['connectors'] * connector_cohesion
+        )
+        
+        # 5. Logging para diagnóstico
+        logger.info(f"""
+            Análisis de Cohesión:
+            - Conexiones léxicas encontradas: {lexical_connections}
+            - Conexiones posibles: {total_possible_connections}
+            - Lexical cohesion score: {lexical_cohesion}
+            - Conectores encontrados: {connector_count}
+            - Connector cohesion score: {connector_cohesion}
+            - Score final: {cohesion_score}
+        """)
+        
+        return cohesion_score
+
+    except Exception as e:
+        logger.error(f"Error en analyze_cohesion: {str(e)}")
+        return 0.0
+
+#########################################################################
+def analyze_structure(doc):
+    try:
+        if len(doc) == 0:
+            return 0.0
+            
+        structure_scores = []
+        for token in doc:
+            if token.dep_ == 'ROOT':
+                result = get_dependency_depths(token)
+                structure_scores.append(result['final_score'])
+                
+        if not structure_scores:
+            return 0.0
+            
+        return min(1.0, sum(structure_scores) / len(structure_scores))
+        
+    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, analyzed_tokens=None):
+    """
+    Analiza la profundidad y calidad de las relaciones de dependencia.
+    
+    Args:
+        token: Token a analizar
+        depth: Profundidad actual en el árbol
+        analyzed_tokens: Set para evitar ciclos en el análisis
+    
+    Returns:
+        dict: Información detallada sobre las dependencias
+            - depths: Lista de profundidades
+            - relations: Diccionario con tipos de relaciones encontradas
+            - complexity_score: Puntuación de complejidad
+    """
+    if analyzed_tokens is None:
+        analyzed_tokens = set()
+        
+    # Evitar ciclos
+    if token.i in analyzed_tokens:
+        return {
+            'depths': [],
+            'relations': {},
+            'complexity_score': 0
+        }
+    
+    analyzed_tokens.add(token.i)
+    
+    # Pesos para diferentes tipos de dependencias
+    dependency_weights = {
+        # Dependencias principales
+        'nsubj': 1.2,    # Sujeto nominal
+        'obj': 1.1,      # Objeto directo
+        'iobj': 1.1,     # Objeto indirecto
+        'ROOT': 1.3,     # Raíz
+        
+        # Modificadores
+        'amod': 0.8,     # Modificador adjetival
+        'advmod': 0.8,   # Modificador adverbial
+        'nmod': 0.9,     # Modificador nominal
+        
+        # Estructuras complejas
+        'csubj': 1.4,    # Cláusula como sujeto
+        'ccomp': 1.3,    # Complemento clausal
+        'xcomp': 1.2,    # Complemento clausal abierto
+        'advcl': 1.2,    # Cláusula adverbial
+        
+        # Coordinación y subordinación
+        'conj': 1.1,     # Conjunción
+        'cc': 0.7,       # Coordinación
+        'mark': 0.8,     # Marcador
+        
+        # Otros
+        'det': 0.5,      # Determinante
+        'case': 0.5,     # Caso
+        'punct': 0.1     # Puntuación
+    }
+    
+    # Inicializar resultados
+    current_result = {
+        'depths': [depth],
+        'relations': {token.dep_: 1},
+        'complexity_score': dependency_weights.get(token.dep_, 0.5) * (depth + 1)
+    }
+    
+    # Analizar hijos recursivamente
+    for child in token.children:
+        child_result = get_dependency_depths(child, depth + 1, analyzed_tokens)
+        
+        # Combinar profundidades
+        current_result['depths'].extend(child_result['depths'])
+        
+        # Combinar relaciones
+        for rel, count in child_result['relations'].items():
+            current_result['relations'][rel] = current_result['relations'].get(rel, 0) + count
+            
+        # Acumular score de complejidad
+        current_result['complexity_score'] += child_result['complexity_score']
+        
+    # Calcular métricas adicionales
+    current_result['max_depth'] = max(current_result['depths'])
+    current_result['avg_depth'] = sum(current_result['depths']) / len(current_result['depths'])
+    current_result['relation_diversity'] = len(current_result['relations'])
+    
+    # Calcular score ponderado por tipo de estructura
+    structure_bonus = 0
+    
+    # Bonus por estructuras complejas
+    if 'csubj' in current_result['relations'] or 'ccomp' in current_result['relations']:
+        structure_bonus += 0.3
+    
+    # Bonus por coordinación balanceada
+    if 'conj' in current_result['relations'] and 'cc' in current_result['relations']:
+        structure_bonus += 0.2
+    
+    # Bonus por modificación rica
+    if len(set(['amod', 'advmod', 'nmod']) & set(current_result['relations'])) >= 2:
+        structure_bonus += 0.2
+        
+    current_result['final_score'] = (
+        current_result['complexity_score'] * (1 + structure_bonus)
+    )
+    
+    return current_result
+
+#########################################################################
+def normalize_score(value, metric_type, 
+                   min_threshold=0.0, target_threshold=1.0, 
+                   range_factor=2.0, optimal_length=None, 
+                   optimal_connections=None, optimal_depth=None):
+    """
+    Normaliza un valor considerando umbrales específicos por tipo de métrica.
+    
+    Args:
+        value: Valor a normalizar
+        metric_type: Tipo de métrica ('vocabulary', 'structure', 'cohesion', 'clarity')
+        min_threshold: Valor mínimo aceptable
+        target_threshold: Valor objetivo
+        range_factor: Factor para ajustar el rango
+        optimal_length: Longitud óptima (opcional)
+        optimal_connections: Número óptimo de conexiones (opcional)
+        optimal_depth: Profundidad óptima de estructura (opcional)
+    
+    Returns:
+        float: Valor normalizado entre 0 y 1
+    """
+    try:
+        # Definir umbrales por tipo de métrica
+        METRIC_THRESHOLDS = {
+            'vocabulary': {
+                'min': 0.60,
+                'target': 0.75,
+                'range_factor': 1.5
+            },
+            'structure': {
+                'min': 0.65,
+                'target': 0.80,
+                'range_factor': 1.8
+            },
+            'cohesion': {
+                'min': 0.55,
+                'target': 0.70,
+                'range_factor': 1.6
+            },
+            'clarity': {
+                'min': 0.60,
+                'target': 0.75,
+                'range_factor': 1.7
+            }
+        }
+
+        # 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
+
+        # Obtener umbrales específicos para el tipo de métrica
+        thresholds = METRIC_THRESHOLDS.get(metric_type, {
+            'min': min_threshold,
+            'target': target_threshold,
+            'range_factor': range_factor
+        })
+        
+        # Identificar el valor de referencia a usar
+        if optimal_depth is not None:
+            reference = optimal_depth
+        elif optimal_connections is not None:
+            reference = optimal_connections
+        elif optimal_length is not None:
+            reference = optimal_length
+        else:
+            reference = thresholds['target']
+
+        # Validar valor de referencia
+        if reference <= 0:
+            logger.warning(f"Valor de referencia inválido: {reference}")
+            return 0.0
+
+        # Calcular score basado en umbrales
+        if value < thresholds['min']:
+            # Valor por debajo del mínimo
+            score = (value / thresholds['min']) * 0.5  # Máximo 0.5 para valores bajo el mínimo
+        elif value < thresholds['target']:
+            # Valor entre mínimo y objetivo
+            range_size = thresholds['target'] - thresholds['min']
+            progress = (value - thresholds['min']) / range_size
+            score = 0.5 + (progress * 0.5)  # Escala entre 0.5 y 1.0
+        else:
+            # Valor alcanza o supera el objetivo
+            score = 1.0
+            
+            # Penalizar valores muy por encima del objetivo
+            if value > (thresholds['target'] * thresholds['range_factor']):
+                excess = (value - thresholds['target']) / (thresholds['target'] * thresholds['range_factor'])
+                score = max(0.7, 1.0 - excess)  # No bajar de 0.7 para valores altos
+
+        # 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
+
+#########################################################################
+#########################################################################
+
+def generate_recommendations(metrics, text_type, lang_code='es'):
+    """
+    Genera recomendaciones personalizadas basadas en las métricas del texto y el tipo de texto.
+    
+    Args:
+        metrics: Diccionario con las métricas analizadas
+        text_type: Tipo de texto ('academic_article', 'student_essay', 'general_communication')
+        lang_code: Código del idioma para las recomendaciones (es, en, uk)
+    
+    Returns:
+        dict: Recomendaciones organizadas por categoría en el idioma correspondiente
+    """
+    try:
+        # Añadir debug log para verificar el código de idioma recibido
+        logger.info(f"generate_recommendations llamado con idioma: {lang_code}")
+        
+        # Comprobar que importamos RECOMMENDATIONS correctamente
+        logger.info(f"Idiomas disponibles en RECOMMENDATIONS: {list(RECOMMENDATIONS.keys())}")
+        
+        # Obtener umbrales según el tipo de texto
+        thresholds = TEXT_TYPES[text_type]['thresholds']
+        
+        # Verificar que el idioma esté soportado, usar español como respaldo
+        if lang_code not in RECOMMENDATIONS:
+            logger.warning(f"Idioma {lang_code} no soportado para recomendaciones, usando español")
+            lang_code = 'es'
+            
+        # Obtener traducciones para el idioma seleccionado
+        translations = RECOMMENDATIONS[lang_code]
+        
+        # Inicializar diccionario de recomendaciones
+        recommendations = {
+            'vocabulary': [],
+            'structure': [],
+            'cohesion': [],
+            'clarity': [],
+            'specific': [],
+            'priority': {
+                'area': 'general',
+                'tips': []
+            },
+            'text_type_name': translations['text_types'][text_type],
+            'dimension_names': translations['dimension_names'],
+            'ui_text': {
+                'priority_intro': translations['priority_intro'],
+                'detailed_recommendations': translations['detailed_recommendations'],
+                'save_button': translations['save_button'],
+                'save_success': translations['save_success'],
+                'save_error': translations['save_error'],
+                'area_priority': translations['area_priority']
+            }
+        }
+        
+        # Determinar nivel para cada dimensión y asignar recomendaciones
+        dimensions = ['vocabulary', 'structure', 'cohesion', 'clarity']
+        scores = {}
+        
+        for dim in dimensions:
+            score = metrics[dim]['normalized_score']
+            scores[dim] = score
+            
+            # Determinar nivel (bajo, medio, alto)
+            if score < thresholds[dim]['min']:
+                level = 'low'
+            elif score < thresholds[dim]['target']:
+                level = 'medium'
+            else:
+                level = 'high'
+                
+            # Asignar recomendaciones para ese nivel
+            recommendations[dim] = translations[dim][level]
+        
+        # Asignar recomendaciones específicas por tipo de texto
+        recommendations['specific'] = translations[text_type]
+        
+        # Determinar área prioritaria (la que tiene menor puntuación)
+        priority_dimension = min(scores, key=scores.get)
+        recommendations['priority']['area'] = priority_dimension
+        recommendations['priority']['tips'] = recommendations[priority_dimension]
+        
+        logger.info(f"Generadas recomendaciones en {lang_code} para texto tipo {text_type}")
+        return recommendations
+        
+    except Exception as e:
+        logger.error(f"Error en generate_recommendations: {str(e)}")
+        
+        # Utilizar un enfoque basado en el idioma actual en lugar de casos codificados
+        # Esto permite manejar ucraniano y cualquier otro idioma futuro
+        fallback_translations = {
+            'en': {
+                'basic_recommendations': {
+                    'vocabulary': ["Try enriching your vocabulary"],
+                    'structure': ["Work on the structure of your sentences"],
+                    'cohesion': ["Improve the connection between your ideas"],
+                    'clarity': ["Try to express your ideas more clearly"],
+                    'specific': ["Adapt your text according to its purpose"],
+                },
+                'dimension_names': {
+                    'vocabulary': 'Vocabulary',
+                    'structure': 'Structure',
+                    'cohesion': 'Cohesion',
+                    'clarity': 'Clarity',
+                    'general': 'General'
+                },
+                'ui_text': {
+                    'priority_intro': "This is where you should focus your efforts.",
+                    'detailed_recommendations': "Detailed recommendations",
+                    'save_button': "Save analysis",
+                    'save_success': "Analysis saved successfully",
+                    'save_error': "Error saving analysis",
+                    'area_priority': "Priority area"
+                }
+            },
+            'uk': {
+                'basic_recommendations': {
+                    'vocabulary': ["Розширте свій словниковий запас"],
+                    'structure': ["Покращіть структуру ваших речень"],
+                    'cohesion': ["Покращіть зв'язок між вашими ідеями"],
+                    'clarity': ["Висловлюйте свої ідеї ясніше"],
+                    'specific': ["Адаптуйте свій текст відповідно до його мети"],
+                },
+                'dimension_names': {
+                    'vocabulary': 'Словниковий запас',
+                    'structure': 'Структура',
+                    'cohesion': 'Зв\'язність',
+                    'clarity': 'Ясність',
+                    'general': 'Загальне'
+                },
+                'ui_text': {
+                    'priority_intro': "Це область, де ви повинні зосередити свої зусилля.",
+                    'detailed_recommendations': "Детальні рекомендації",
+                    'save_button': "Зберегти аналіз",
+                    'save_success': "Аналіз успішно збережено",
+                    'save_error': "Помилка при збереженні аналізу",
+                    'area_priority': "Пріоритетна область"
+                }
+            },
+            'es': {
+                'basic_recommendations': {
+                    'vocabulary': ["Intenta enriquecer tu vocabulario"],
+                    'structure': ["Trabaja en la estructura de tus oraciones"],
+                    'cohesion': ["Mejora la conexión entre tus ideas"],
+                    'clarity': ["Busca expresar tus ideas con mayor claridad"],
+                    'specific': ["Adapta tu texto según su propósito"],
+                },
+                'dimension_names': {
+                    'vocabulary': 'Vocabulario',
+                    'structure': 'Estructura',
+                    'cohesion': 'Cohesión',
+                    'clarity': 'Claridad',
+                    'general': 'General'
+                },
+                'ui_text': {
+                    'priority_intro': "Esta es el área donde debes concentrar tus esfuerzos.",
+                    'detailed_recommendations': "Recomendaciones detalladas",
+                    'save_button': "Guardar análisis",
+                    'save_success': "Análisis guardado con éxito",
+                    'save_error': "Error al guardar el análisis",
+                    'area_priority': "Área prioritaria"
+                }
+            }
+        }
+        
+        # Usar el idioma actual si está disponible, o inglés, o español como última opción
+        current_lang = fallback_translations.get(lang_code, 
+                       fallback_translations.get('en', 
+                       fallback_translations['es']))
+                       
+        basic_recommendations = current_lang['basic_recommendations']
+        
+        return {
+            'vocabulary': basic_recommendations['vocabulary'],
+            'structure': basic_recommendations['structure'],
+            'cohesion': basic_recommendations['cohesion'],
+            'clarity': basic_recommendations['clarity'],
+            'specific': basic_recommendations['specific'],
+            'priority': {
+                'area': 'general',
+                'tips': ["Busca retroalimentación específica de un tutor o profesor"]
+            },
+            'dimension_names': current_lang['dimension_names'],
+            'ui_text': current_lang['ui_text']
+        }
+
+
+
+
+#########################################################################
+#########################################################################
+# Funciones de generación de gráficos
+def generate_sentence_graphs(doc):
+    """Genera visualizaciones de estructura de oraciones"""
+    fig, ax = plt.subplots(figsize=(10, 6))
+    # Implementar visualización
+    plt.close()
+    return fig
+
+############################################################################
+def generate_word_connections(doc):
+    """Genera red de conexiones de palabras"""
+    fig, ax = plt.subplots(figsize=(10, 6))
+    # Implementar visualización
+    plt.close()
+    return fig
+
+############################################################################
+def generate_connection_paths(doc):
+    """Genera patrones de conexión"""
+    fig, ax = plt.subplots(figsize=(10, 6))
+    # Implementar visualización
+    plt.close()
+    return fig
+
+############################################################################
+def create_vocabulary_network(doc):
+    """
+    Genera el grafo de red de vocabulario.
+    """
+    G = nx.Graph()
+    
+    # Crear nodos para palabras significativas
+    words = [token.text.lower() for token in doc if token.is_alpha and not token.is_stop]
+    word_freq = Counter(words)
+    
+    # Añadir nodos con tamaño basado en frecuencia
+    for word, freq in word_freq.items():
+        G.add_node(word, size=freq)
+    
+    # Crear conexiones basadas en co-ocurrencia
+    window_size = 5
+    for i in range(len(words) - window_size):
+        window = words[i:i+window_size]
+        for w1, w2 in combinations(set(window), 2):
+            if G.has_edge(w1, w2):
+                G[w1][w2]['weight'] += 1
+            else:
+                G.add_edge(w1, w2, weight=1)
+    
+    # Crear visualización
+    fig, ax = plt.subplots(figsize=(12, 8))
+    pos = nx.spring_layout(G)
+    
+    # Dibujar nodos
+    nx.draw_networkx_nodes(G, pos, 
+                          node_size=[G.nodes[node]['size']*100 for node in G.nodes],
+                          node_color='lightblue',
+                          alpha=0.7)
+    
+    # Dibujar conexiones
+    nx.draw_networkx_edges(G, pos, 
+                          width=[G[u][v]['weight']*0.5 for u,v in G.edges],
+                          alpha=0.5)
+    
+    # Añadir etiquetas
+    nx.draw_networkx_labels(G, pos)
+    
+    plt.title("Red de Vocabulario")
+    plt.axis('off')
+    return fig
+
+############################################################################
+def create_syntax_complexity_graph(doc):
+    """
+    Genera el diagrama de arco de complejidad sintáctica.
+    Muestra la estructura de dependencias con colores basados en la complejidad.
+    """
+    try:
+        # Preparar datos para la visualización
+        sentences = list(doc.sents)
+        if not sentences:
+            return None
+            
+        # Crear figura para el gráfico
+        fig, ax = plt.subplots(figsize=(12, len(sentences) * 2))
+        
+        # Colores para diferentes niveles de profundidad
+        depth_colors = plt.cm.viridis(np.linspace(0, 1, 6))
+        
+        y_offset = 0
+        max_x = 0
+        
+        for sent in sentences:
+            words = [token.text for token in sent]
+            x_positions = range(len(words))
+            max_x = max(max_x, len(words))
+            
+            # Dibujar palabras
+            plt.plot(x_positions, [y_offset] * len(words), 'k-', alpha=0.2)
+            plt.scatter(x_positions, [y_offset] * len(words), alpha=0)
+            
+            # Añadir texto
+            for i, word in enumerate(words):
+                plt.annotate(word, (i, y_offset), xytext=(0, -10), 
+                           textcoords='offset points', ha='center')
+            
+            # Dibujar arcos de dependencia
+            for token in sent:
+                if token.dep_ != "ROOT":
+                    # Calcular profundidad de dependencia
+                    depth = 0
+                    current = token
+                    while current.head != current:
+                        depth += 1
+                        current = current.head
+                    
+                    # Determinar posiciones para el arco
+                    start = token.i - sent[0].i
+                    end = token.head.i - sent[0].i
+                    
+                    # Altura del arco basada en la distancia entre palabras
+                    height = 0.5 * abs(end - start)
+                    
+                    # Color basado en la profundidad
+                    color = depth_colors[min(depth, len(depth_colors)-1)]
+                    
+                    # Crear arco
+                    arc = patches.Arc((min(start, end) + abs(end - start)/2, y_offset),
+                                    width=abs(end - start),
+                                    height=height,
+                                    angle=0,
+                                    theta1=0,
+                                    theta2=180,
+                                    color=color,
+                                    alpha=0.6)
+                    ax.add_patch(arc)
+            
+            y_offset -= 2
+        
+        # Configurar el gráfico
+        plt.xlim(-1, max_x)
+        plt.ylim(y_offset - 1, 1)
+        plt.axis('off')
+        plt.title("Complejidad Sintáctica")
+        
+        return fig
+        
+    except Exception as e:
+        logger.error(f"Error en create_syntax_complexity_graph: {str(e)}")
+        return None
+
+############################################################################
+def create_cohesion_heatmap(doc):
+    """Genera un mapa de calor que muestra la cohesión entre párrafos/oraciones."""
+    try:
+        sentences = list(doc.sents)
+        n_sentences = len(sentences)
+        
+        if n_sentences < 2:
+            return None
+            
+        similarity_matrix = np.zeros((n_sentences, n_sentences))
+        
+        for i in range(n_sentences):
+            for j in range(n_sentences):
+                sent1_lemmas = {token.lemma_ for token in sentences[i] 
+                              if token.is_alpha and not token.is_stop}
+                sent2_lemmas = {token.lemma_ for token in sentences[j] 
+                              if token.is_alpha and not token.is_stop}
+                
+                if sent1_lemmas and sent2_lemmas:
+                    intersection = len(sent1_lemmas & sent2_lemmas)  # Corregido aquí
+                    union = len(sent1_lemmas | sent2_lemmas)  # Y aquí
+                    similarity_matrix[i, j] = intersection / union if union > 0 else 0
+        
+        # Crear visualización
+        fig, ax = plt.subplots(figsize=(10, 8))
+        
+        sns.heatmap(similarity_matrix,
+                   cmap='YlOrRd',
+                   square=True,
+                   xticklabels=False,
+                   yticklabels=False,
+                   cbar_kws={'label': 'Cohesión'},
+                   ax=ax)
+        
+        plt.title("Mapa de Cohesión Textual")
+        plt.xlabel("Oraciones")
+        plt.ylabel("Oraciones")
+        
+        plt.tight_layout()
+        return fig
+        
+    except Exception as e:
+        logger.error(f"Error en create_cohesion_heatmap: {str(e)}")
+        return None

modules/studentact/current_situation_interface.py

@@ -1,321 +1,436 @@
-# modules/studentact/current_situation_interface.py
-
-import streamlit as st
-import logging
-from ..utils.widget_utils import generate_unique_key
-import matplotlib.pyplot as plt
-import numpy as np
-from ..database.current_situation_mongo_db import store_current_situation_result
-
-# Importaciones locales
-from translations import get_translations 
-
-# Importamos la función de recomendaciones personalizadas si existe
-try:
-    from .claude_recommendations import display_personalized_recommendations
-except ImportError:
-    # Si no existe el módulo, definimos una función placeholder
-    def display_personalized_recommendations(text, metrics, text_type, lang_code, t):
-        st.warning("Módulo de recomendaciones personalizadas no disponible. Por favor, contacte al administrador.")
-
-from .current_situation_analysis import (
-    analyze_text_dimensions, 
-    analyze_clarity,
-    analyze_vocabulary_diversity, 
-    analyze_cohesion,
-    analyze_structure,
-    get_dependency_depths, 
-    normalize_score, 
-    generate_sentence_graphs, 
-    generate_word_connections, 
-    generate_connection_paths,
-    create_vocabulary_network, 
-    create_syntax_complexity_graph, 
-    create_cohesion_heatmap
-)
-
-# Configuración del estilo de matplotlib para el gráfico de radar
-plt.rcParams['font.family'] = 'sans-serif'
-plt.rcParams['axes.grid'] = True
-plt.rcParams['axes.spines.top'] = False
-plt.rcParams['axes.spines.right'] = False
-
-logger = logging.getLogger(__name__)
-
-####################################
-# Definición global de los tipos de texto y sus umbrales
-TEXT_TYPES = {
-    'academic_article': {
-        'name': 'Artículo Académico',
-        'thresholds': {
-            'vocabulary': {'min': 0.70, 'target': 0.85},
-            'structure': {'min': 0.75, 'target': 0.90},
-            'cohesion': {'min': 0.65, 'target': 0.80},
-            'clarity': {'min': 0.70, 'target': 0.85}
-        }
-    },
-    'student_essay': {
-        'name': 'Trabajo Universitario',
-        'thresholds': {
-            'vocabulary': {'min': 0.60, 'target': 0.75},
-            'structure': {'min': 0.65, 'target': 0.80},
-            'cohesion': {'min': 0.55, 'target': 0.70},
-            'clarity': {'min': 0.60, 'target': 0.75}
-        }
-    },
-    'general_communication': {
-        'name': 'Comunicación General',
-        'thresholds': {
-            'vocabulary': {'min': 0.50, 'target': 0.65},
-            'structure': {'min': 0.55, 'target': 0.70},
-            'cohesion': {'min': 0.45, 'target': 0.60},
-            'clarity': {'min': 0.50, 'target': 0.65}
-        }
-    }
-}
-####################################
-
-def display_current_situation_interface(lang_code, nlp_models, t):
-    """
-    Interfaz simplificada con gráfico de radar para visualizar métricas.
-    """
-    # Inicializar estados si no existen
-    if 'text_input' not in st.session_state:
-        st.session_state.text_input = ""
-    if 'text_area' not in st.session_state:  # Añadir inicialización de text_area
-        st.session_state.text_area = ""
-    if 'show_results' not in st.session_state:
-        st.session_state.show_results = False
-    if 'current_doc' not in st.session_state:
-        st.session_state.current_doc = None
-    if 'current_metrics' not in st.session_state:
-        st.session_state.current_metrics = None
-    if 'current_recommendations' not in st.session_state:
-        st.session_state.current_recommendations = None
-        
-    try:
-        # Container principal con dos columnas
-        with st.container():
-            input_col, results_col = st.columns([1,2])
-            
-            with input_col:
-                # Text area con manejo de estado
-                text_input = st.text_area(
-                    t.get('input_prompt', "Escribe o pega tu texto aquí:"),
-                    height=400,
-                    key="text_area",
-                    value=st.session_state.text_input,
-                    help="Este texto será analizado para darte recomendaciones personalizadas"
-                )
-                
-                # Función para manejar cambios de texto
-                if text_input != st.session_state.text_input:
-                    st.session_state.text_input = text_input
-                    st.session_state.show_results = False
-                
-                if st.button(
-                    t.get('analyze_button', "Analizar mi escritura"),
-                    type="primary",
-                    disabled=not text_input.strip(),
-                    use_container_width=True,
-                ):
-                    try:
-                        with st.spinner(t.get('processing', "Analizando...")):
-                            doc = nlp_models[lang_code](text_input)
-                            metrics = analyze_text_dimensions(doc)
-                            
-                            storage_success = store_current_situation_result(
-                                username=st.session_state.username,
-                                text=text_input,
-                                metrics=metrics,
-                                feedback=None
-                            )
-                            
-                            if not storage_success:
-                                logger.warning("No se pudo guardar el análisis en la base de datos")
-                            
-                            st.session_state.current_doc = doc
-                            st.session_state.current_metrics = metrics
-                            st.session_state.show_results = True
-                            
-                    except Exception as e:
-                        logger.error(f"Error en análisis: {str(e)}")
-                        st.error(t.get('analysis_error', "Error al analizar el texto"))
-            
-            # Mostrar resultados en la columna derecha
-            with results_col:
-                if st.session_state.show_results and st.session_state.current_metrics is not None:
-                    # Primero los radio buttons para tipo de texto
-                    st.markdown("### Tipo de texto")
-                    text_type = st.radio(
-                        label="Tipo de texto",
-                        options=list(TEXT_TYPES.keys()),
-                        format_func=lambda x: TEXT_TYPES[x]['name'],
-                        horizontal=True,
-                        key="text_type_radio",
-                        label_visibility="collapsed",
-                        help="Selecciona el tipo de texto para ajustar los criterios de evaluación"
-                    )
-                    
-                    st.session_state.current_text_type = text_type
-                    
-                    # Crear subtabs
-                    subtab1, subtab2 = st.tabs(["Diagnóstico", "Recomendaciones"])
-                    
-                    # Mostrar resultados en el primer subtab
-                    with subtab1:
-                        display_diagnosis(
-                            metrics=st.session_state.current_metrics,
-                            text_type=text_type
-                        )
-                    
-                    # Mostrar recomendaciones en el segundo subtab
-                    with subtab2:
-                        # Llamar directamente a la función de recomendaciones personalizadas
-                        display_personalized_recommendations(
-                            text=text_input,
-                            metrics=st.session_state.current_metrics,
-                            text_type=text_type,
-                            lang_code=lang_code,
-                            t=t
-                        )
-
-    except Exception as e:
-        logger.error(f"Error en interfaz principal: {str(e)}")
-        st.error("Ocurrió un error al cargar la interfaz")
-
-def display_diagnosis(metrics, text_type=None):
-    """
-    Muestra los resultados del análisis: métricas verticalmente y gráfico radar.
-    """
-    try:
-        # Usar valor por defecto si no se especifica tipo
-        text_type = text_type or 'student_essay'
-        
-        # Obtener umbrales según el tipo de texto
-        thresholds = TEXT_TYPES[text_type]['thresholds']
-
-        # Crear dos columnas para las métricas y el gráfico
-        metrics_col, graph_col = st.columns([1, 1.5])
-        
-        # Columna de métricas
-        with metrics_col:
-            metrics_config = [
-                {
-                    'label': "Vocabulario",
-                    'key': 'vocabulary',
-                    'value': metrics['vocabulary']['normalized_score'],
-                    'help': "Riqueza y variedad del vocabulario",
-                    'thresholds': thresholds['vocabulary']
-                },
-                {
-                    'label': "Estructura",
-                    'key': 'structure',
-                    'value': metrics['structure']['normalized_score'],
-                    'help': "Organización y complejidad de oraciones",
-                    'thresholds': thresholds['structure']
-                },
-                {
-                    'label': "Cohesión",
-                    'key': 'cohesion',
-                    'value': metrics['cohesion']['normalized_score'],
-                    'help': "Conexión y fluidez entre ideas",
-                    'thresholds': thresholds['cohesion']
-                },
-                {
-                    'label': "Claridad",
-                    'key': 'clarity',
-                    'value': metrics['clarity']['normalized_score'],
-                    'help': "Facilidad de comprensión del texto",
-                    'thresholds': thresholds['clarity']
-                }
-            ]
-
-            # Mostrar métricas
-            for metric in metrics_config:
-                value = metric['value']
-                if value < metric['thresholds']['min']:
-                    status = "⚠️ Por mejorar"
-                    color = "inverse"
-                elif value < metric['thresholds']['target']:
-                    status = "📈 Aceptable"
-                    color = "off"
-                else:
-                    status = "✅ Óptimo"
-                    color = "normal"
-                
-                st.metric(
-                    metric['label'],
-                    f"{value:.2f}",
-                    f"{status} (Meta: {metric['thresholds']['target']:.2f})",
-                    delta_color=color,
-                    help=metric['help']
-                )
-                st.markdown("<div style='margin-bottom: 0.5rem;'></div>", unsafe_allow_html=True)
-
-        # Gráfico radar en la columna derecha
-        with graph_col:
-            display_radar_chart(metrics_config, thresholds)
-
-    except Exception as e:
-        logger.error(f"Error mostrando resultados: {str(e)}")
-        st.error("Error al mostrar los resultados")
-
-def display_radar_chart(metrics_config, thresholds):
-    """
-    Muestra el gráfico radar con los resultados.
-    """
-    try:
-        # Preparar datos para el gráfico
-        categories = [m['label'] for m in metrics_config]
-        values_user = [m['value'] for m in metrics_config]
-        min_values = [m['thresholds']['min'] for m in metrics_config]
-        target_values = [m['thresholds']['target'] for m in metrics_config]
-
-        # Crear y configurar gráfico
-        fig = plt.figure(figsize=(8, 8))
-        ax = fig.add_subplot(111, projection='polar')
-
-        # Configurar radar
-        angles = [n / float(len(categories)) * 2 * np.pi for n in range(len(categories))]
-        angles += angles[:1]
-        values_user += values_user[:1]
-        min_values += min_values[:1]
-        target_values += target_values[:1]
-
-        # Configurar ejes
-        ax.set_xticks(angles[:-1])
-        ax.set_xticklabels(categories, fontsize=10)
-        circle_ticks = np.arange(0, 1.1, 0.2)
-        ax.set_yticks(circle_ticks)
-        ax.set_yticklabels([f'{tick:.1f}' for tick in circle_ticks], fontsize=8)
-        ax.set_ylim(0, 1)
-
-        # Dibujar áreas de umbrales
-        ax.plot(angles, min_values, '#e74c3c', linestyle='--', linewidth=1, label='Mínimo', alpha=0.5)
-        ax.plot(angles, target_values, '#2ecc71', linestyle='--', linewidth=1, label='Meta', alpha=0.5)
-        ax.fill_between(angles, target_values, [1]*len(angles), color='#2ecc71', alpha=0.1)
-        ax.fill_between(angles, [0]*len(angles), min_values, color='#e74c3c', alpha=0.1)
-
-        # Dibujar valores del usuario
-        ax.plot(angles, values_user, '#3498db', linewidth=2, label='Tu escritura')
-        ax.fill(angles, values_user, '#3498db', alpha=0.2)
-
-        # Ajustar leyenda
-        ax.legend(
-            loc='upper right',
-            bbox_to_anchor=(1.3, 1.1),
-            fontsize=10,
-            frameon=True,
-            facecolor='white',
-            edgecolor='none',
-            shadow=True
-        )
-
-        plt.tight_layout()
-        st.pyplot(fig)
-        plt.close()
-
-    except Exception as e:
-        logger.error(f"Error mostrando gráfico radar: {str(e)}")
+# modules/studentact/current_situation_interface.py
+
+import streamlit as st
+import logging
+from ..utils.widget_utils import generate_unique_key
+import matplotlib.pyplot as plt
+import numpy as np
+from ..database.current_situation_mongo_db import store_current_situation_result
+
+# Importaciones locales
+from translations import get_translations 
+
+# Importamos la función de recomendaciones personalizadas si existe
+try:
+    from .claude_recommendations import display_personalized_recommendations
+except ImportError:
+    # Si no existe el módulo, definimos una función placeholder
+    def display_personalized_recommendations(text, metrics, text_type, lang_code, t):
+        # Obtener el mensaje de advertencia traducido si está disponible
+        warning = t.get('module_not_available', "Módulo de recomendaciones personalizadas no disponible. Por favor, contacte al administrador.")
+        st.warning(warning)
+
+from .current_situation_analysis import (
+    analyze_text_dimensions, 
+    analyze_clarity,
+    analyze_vocabulary_diversity, 
+    analyze_cohesion,
+    analyze_structure,
+    get_dependency_depths, 
+    normalize_score, 
+    generate_sentence_graphs, 
+    generate_word_connections, 
+    generate_connection_paths,
+    create_vocabulary_network, 
+    create_syntax_complexity_graph, 
+    create_cohesion_heatmap
+)
+
+# Configuración del estilo de matplotlib para el gráfico de radar
+plt.rcParams['font.family'] = 'sans-serif'
+plt.rcParams['axes.grid'] = True
+plt.rcParams['axes.spines.top'] = False
+plt.rcParams['axes.spines.right'] = False
+
+logger = logging.getLogger(__name__)
+
+# Definición de tipos de texto con umbrales
+TEXT_TYPES = {
+    'academic_article': {
+        # Los nombres se obtendrán de las traducciones
+        'thresholds': {
+            'vocabulary': {'min': 0.70, 'target': 0.85},
+            'structure': {'min': 0.75, 'target': 0.90},
+            'cohesion': {'min': 0.65, 'target': 0.80},
+            'clarity': {'min': 0.70, 'target': 0.85}
+        }
+    },
+    'student_essay': {
+        'thresholds': {
+            'vocabulary': {'min': 0.60, 'target': 0.75},
+            'structure': {'min': 0.65, 'target': 0.80},
+            'cohesion': {'min': 0.55, 'target': 0.70},
+            'clarity': {'min': 0.60, 'target': 0.75}
+        }
+    },
+    'general_communication': {
+        'thresholds': {
+            'vocabulary': {'min': 0.50, 'target': 0.65},
+            'structure': {'min': 0.55, 'target': 0.70},
+            'cohesion': {'min': 0.45, 'target': 0.60},
+            'clarity': {'min': 0.50, 'target': 0.65}
+        }
+    }
+}
+
+####################################################
+####################################################
+def display_current_situation_interface(lang_code, nlp_models, t):
+    """
+    Interfaz simplificada con gráfico de radar para visualizar métricas.
+    """
+    # Agregar logs para depuración
+    logger.info(f"Idioma: {lang_code}")
+    logger.info(f"Claves en t: {list(t.keys())}")
+    
+    # Inicializar estados si no existen
+    if 'text_input' not in st.session_state:
+        st.session_state.text_input = ""
+    if 'text_area' not in st.session_state:
+        st.session_state.text_area = ""
+    if 'show_results' not in st.session_state:
+        st.session_state.show_results = False
+    if 'current_doc' not in st.session_state:
+        st.session_state.current_doc = None
+    if 'current_metrics' not in st.session_state:
+        st.session_state.current_metrics = None
+    if 'current_recommendations' not in st.session_state:
+        st.session_state.current_recommendations = None
+        
+    try:
+        # Container principal con dos columnas
+        with st.container():
+            input_col, results_col = st.columns([1,2])
+
+###############################################################################################
+            # CSS personalizado para que el formulario ocupe todo el alto disponible
+            st.markdown("""
+            <style>
+                /* Hacer que la columna tenga una altura definida */
+                [data-testid="column"] {
+                    min-height: 900px;
+                    height: 100vh; /* 100% del alto visible de la ventana */
+                }
+                
+                /* Hacer que el formulario ocupe el espacio disponible en la columna */
+                .stForm {
+                    height: calc(100% - 40px); /* Ajuste por márgenes y paddings */
+                    display: flex;
+                    flex-direction: column;
+                }
+                
+                /* Hacer que el área de texto se expanda dentro del formulario */
+                .stForm .stTextArea {
+                    flex: 1;
+                    display: flex;
+                    flex-direction: column;
+                }
+                
+                /* El textarea en sí debe expandirse */
+                .stForm .stTextArea textarea {
+                    flex: 1;
+                    min-height: 750px !important;
+                }
+            </style>
+            """, unsafe_allow_html=True)
+            
+###############################################################################################
+            with input_col:
+                with st.form(key=f"text_input_form_{lang_code}"):
+                    text_input = st.text_area(
+                        t.get('input_prompt', "Escribe o pega tu texto aquí:"),
+                        height=800,
+                        key=f"text_area_{lang_code}",
+                        value=st.session_state.text_input,
+                        help=t.get('help', "Este texto será analizado para darte recomendaciones personalizadas")
+                    )
+                    
+                    submit_button = st.form_submit_button(
+                        t.get('analyze_button', "Analizar mi escritura"),
+                        type="primary",
+                        use_container_width=True
+                    )
+                    
+                    if submit_button:
+                        if text_input.strip():
+                            st.session_state.text_input = text_input
+
+#######################################################################
+                # Código para análisis...
+                    try:
+                        with st.spinner(t.get('processing', "Analizando...")):  # Usando t.get directamente
+                            doc = nlp_models[lang_code](text_input)
+                            metrics = analyze_text_dimensions(doc)
+                            
+                            storage_success = store_current_situation_result(
+                                username=st.session_state.username,
+                                text=text_input,
+                                metrics=metrics,
+                                feedback=None
+                            )
+                            
+                            if not storage_success:
+                                logger.warning("No se pudo guardar el análisis en la base de datos")
+                            
+                            st.session_state.current_doc = doc
+                            st.session_state.current_metrics = metrics
+                            st.session_state.show_results = True
+                            
+                    except Exception as e:
+                        logger.error(f"Error en análisis: {str(e)}")
+                        st.error(t.get('analysis_error', "Error al analizar el texto"))  # Usando t.get directamente
+            
+            # Mostrar resultados en la columna derecha
+            with results_col:
+                if st.session_state.show_results and st.session_state.current_metrics is not None:
+                    # Primero los radio buttons para tipo de texto - usando t.get directamente
+                    st.markdown(f"### {t.get('text_type_header', 'Tipo de texto')}")
+                    
+                    # Preparar opciones de tipos de texto con nombres traducidos
+                    text_type_options = {}
+                    for text_type_key in TEXT_TYPES.keys():
+                        # Fallback a nombres genéricos si no hay traducción
+                        default_names = {
+                            'academic_article': 'Academic Article' if lang_code == 'en' else 'Артикул академічний' if lang_code == 'uk' else 'Artículo Académico',
+                            'student_essay': 'Student Essay' if lang_code == 'en' else 'Студентське есе' if lang_code == 'uk' else 'Trabajo Universitario',
+                            'general_communication': 'General Communication' if lang_code == 'en' else 'Загальна комунікація' if lang_code == 'uk' else 'Comunicación General'
+                        }
+                        text_type_options[text_type_key] = default_names.get(text_type_key, text_type_key)
+                    
+                    text_type = st.radio(
+                        label=t.get('text_type_header', "Tipo de texto"),  # Usando t.get directamente
+                        options=list(TEXT_TYPES.keys()),
+                        format_func=lambda x: text_type_options.get(x, x),
+                        horizontal=True,
+                        key="text_type_radio",
+                        label_visibility="collapsed",
+                        help=t.get('text_type_help', "Selecciona el tipo de texto para ajustar los criterios de evaluación")  # Usando t.get directamente
+                    )
+                    
+                    st.session_state.current_text_type = text_type
+                    
+                    # Crear subtabs con nombres traducidos
+                    diagnosis_tab = "Diagnosis" if lang_code == 'en' else "Діагностика" if lang_code == 'uk' else "Diagnóstico"
+                    recommendations_tab = "Recommendations" if lang_code == 'en' else "Рекомендації" if lang_code == 'uk' else "Recomendaciones"
+                    
+                    subtab1, subtab2 = st.tabs([diagnosis_tab, recommendations_tab])
+                    
+                    # Mostrar resultados en el primer subtab
+                    with subtab1:
+                        display_diagnosis(
+                            metrics=st.session_state.current_metrics,
+                            text_type=text_type,
+                            lang_code=lang_code,
+                            t=t  # Pasar t directamente, no current_situation_t
+                        )
+                    
+                    # Mostrar recomendaciones en el segundo subtab
+                    with subtab2:
+                        # Llamar directamente a la función de recomendaciones personalizadas
+                        display_personalized_recommendations(
+                            text=text_input,
+                            metrics=st.session_state.current_metrics,
+                            text_type=text_type,
+                            lang_code=lang_code,
+                            t=t
+                        )
+
+    except Exception as e:
+        logger.error(f"Error en interfaz principal: {str(e)}")
+        st.error(t.get('error_interface', "Ocurrió un error al cargar la interfaz"))  # Usando t.get directamente
+
+#################################################################
+#################################################################
+def display_diagnosis(metrics, text_type=None, lang_code='es', t=None):
+    """
+    Muestra los resultados del análisis: métricas verticalmente y gráfico radar.
+    """
+    try:
+        # Asegurar que tenemos traducciones
+        if t is None:
+            t = {}
+
+        # Traducciones para títulos y etiquetas
+        dimension_labels = {
+            'es': {
+                'title': "Tipo de texto",
+                'vocabulary': "Vocabulario",
+                'structure': "Estructura",
+                'cohesion': "Cohesión",
+                'clarity': "Claridad",
+                'improvement': "⚠️ Por mejorar",
+                'acceptable': "📈 Aceptable",
+                'optimal': "✅ Óptimo",
+                'target': "Meta: {:.2f}"
+            },
+            'en': {
+                'title': "Text Type",
+                'vocabulary': "Vocabulary",
+                'structure': "Structure",
+                'cohesion': "Cohesion",
+                'clarity': "Clarity",
+                'improvement': "⚠️ Needs improvement",
+                'acceptable': "📈 Acceptable", 
+                'optimal': "✅ Optimal",
+                'target': "Target: {:.2f}"
+            },
+            'uk': {
+                'title': "Тип тексту",
+                'vocabulary': "Словниковий запас",
+                'structure': "Структура",
+                'cohesion': "Зв'язність",
+                'clarity': "Ясність",
+                'improvement': "⚠️ Потребує покращення",
+                'acceptable': "📈 Прийнятно",
+                'optimal': "✅ Оптимально",
+                'target': "Ціль: {:.2f}"
+            }
+        }
+        
+        # Obtener traducciones para el idioma actual, con fallback a español
+        labels = dimension_labels.get(lang_code, dimension_labels['es'])
+        
+        # Usar valor por defecto si no se especifica tipo
+        text_type = text_type or 'student_essay'
+        
+        # Obtener umbrales según el tipo de texto
+        thresholds = TEXT_TYPES[text_type]['thresholds']
+
+        # Crear dos columnas para las métricas y el gráfico
+        metrics_col, graph_col = st.columns([1, 1.5])
+        
+        # Columna de métricas
+        with metrics_col:
+            metrics_config = [
+                {
+                    'label': labels['vocabulary'],
+                    'key': 'vocabulary',
+                    'value': metrics['vocabulary']['normalized_score'],
+                    'help': t.get('vocabulary_help', "Riqueza y variedad del vocabulario"),
+                    'thresholds': thresholds['vocabulary']
+                },
+                {
+                    'label': labels['structure'],
+                    'key': 'structure',
+                    'value': metrics['structure']['normalized_score'],
+                    'help': t.get('structure_help', "Organización y complejidad de oraciones"),
+                    'thresholds': thresholds['structure']
+                },
+                {
+                    'label': labels['cohesion'],
+                    'key': 'cohesion',
+                    'value': metrics['cohesion']['normalized_score'],
+                    'help': t.get('cohesion_help', "Conexión y fluidez entre ideas"),
+                    'thresholds': thresholds['cohesion']
+                },
+                {
+                    'label': labels['clarity'],
+                    'key': 'clarity',
+                    'value': metrics['clarity']['normalized_score'],
+                    'help': t.get('clarity_help', "Facilidad de comprensión del texto"),
+                    'thresholds': thresholds['clarity']
+                }
+            ]
+
+            # Mostrar métricas con textos traducidos
+            for metric in metrics_config:
+                value = metric['value']
+                if value < metric['thresholds']['min']:
+                    status = labels['improvement']
+                    color = "inverse"
+                elif value < metric['thresholds']['target']:
+                    status = labels['acceptable']
+                    color = "off"
+                else:
+                    status = labels['optimal']
+                    color = "normal"
+                
+                target_text = labels['target'].format(metric['thresholds']['target'])
+                
+                st.metric(
+                    metric['label'],
+                    f"{value:.2f}",
+                    f"{status} ({target_text})",
+                    delta_color=color,
+                    help=metric['help']
+                )
+                st.markdown("<div style='margin-bottom: 0.5rem;'></div>", unsafe_allow_html=True)
+
+        # Gráfico radar en la columna derecha
+        with graph_col:
+            display_radar_chart(metrics_config, thresholds, lang_code)  # Pasar el parámetro lang_code
+
+    except Exception as e:
+        logger.error(f"Error mostrando resultados: {str(e)}")
+        st.error(t.get('error_results', "Error al mostrar los resultados"))
+
+##################################################################
+##################################################################
+def display_radar_chart(metrics_config, thresholds, lang_code='es'):
+    """
+    Muestra el gráfico radar con los resultados.
+    """
+    try:
+        # Traducción de las etiquetas de leyenda según el idioma
+        legend_translations = {
+            'es': {'min': 'Mínimo', 'target': 'Meta', 'user': 'Tu escritura'},
+            'en': {'min': 'Minimum', 'target': 'Target', 'user': 'Your writing'},
+            'uk': {'min': 'Мінімум', 'target': 'Ціль', 'user': 'Ваш текст'}
+        }
+        
+        # Usar español por defecto si el idioma no está soportado
+        translations = legend_translations.get(lang_code, legend_translations['es'])
+        
+        # Preparar datos para el gráfico
+        categories = [m['label'] for m in metrics_config]
+        values_user = [m['value'] for m in metrics_config]
+        min_values = [m['thresholds']['min'] for m in metrics_config]
+        target_values = [m['thresholds']['target'] for m in metrics_config]
+
+        # Crear y configurar gráfico
+        fig = plt.figure(figsize=(8, 8))
+        ax = fig.add_subplot(111, projection='polar')
+
+        # Configurar radar
+        angles = [n / float(len(categories)) * 2 * np.pi for n in range(len(categories))]
+        angles += angles[:1]
+        values_user += values_user[:1]
+        min_values += min_values[:1]
+        target_values += target_values[:1]
+
+        # Configurar ejes
+        ax.set_xticks(angles[:-1])
+        ax.set_xticklabels(categories, fontsize=10)
+        circle_ticks = np.arange(0, 1.1, 0.2)
+        ax.set_yticks(circle_ticks)
+        ax.set_yticklabels([f'{tick:.1f}' for tick in circle_ticks], fontsize=8)
+        ax.set_ylim(0, 1)
+
+        # Dibujar áreas de umbrales con etiquetas traducidas
+        ax.plot(angles, min_values, '#e74c3c', linestyle='--', linewidth=1, label=translations['min'], alpha=0.5)
+        ax.plot(angles, target_values, '#2ecc71', linestyle='--', linewidth=1, label=translations['target'], alpha=0.5)
+        ax.fill_between(angles, target_values, [1]*len(angles), color='#2ecc71', alpha=0.1)
+        ax.fill_between(angles, [0]*len(angles), min_values, color='#e74c3c', alpha=0.1)
+
+        # Dibujar valores del usuario con etiqueta traducida
+        ax.plot(angles, values_user, '#3498db', linewidth=2, label=translations['user'])
+        ax.fill(angles, values_user, '#3498db', alpha=0.2)
+
+        # Ajustar leyenda
+        ax.legend(
+            loc='upper right',
+            bbox_to_anchor=(1.3, 1.1),
+            fontsize=10,
+            frameon=True,
+            facecolor='white',
+            edgecolor='none',
+            shadow=True
+        )
+
+        plt.tight_layout()
+        st.pyplot(fig)
+        plt.close()
+
+    except Exception as e:
+        logger.error(f"Error mostrando gráfico radar: {str(e)}")
         st.error("Error al mostrar el gráfico")

modules/studentact/student_activities_v2.py

@@ -1,571 +1,576 @@
- ##############
-###modules/studentact/student_activities_v2.py
-
-import streamlit as st
-import re
-import io
-from io import BytesIO
-import pandas as pd
-import numpy as np
-import time
-import matplotlib.pyplot as plt
-from datetime import datetime, timedelta
-from spacy import displacy
-import random
-import base64
-import seaborn as sns
-import logging
-
-# Importaciones de la base de datos
-from ..database.morphosintax_mongo_db import get_student_morphosyntax_analysis
-from ..database.semantic_mongo_db import get_student_semantic_analysis
-from ..database.discourse_mongo_db import get_student_discourse_analysis
-from ..database.chat_mongo_db import get_chat_history
-from ..database.current_situation_mongo_db import get_current_situation_analysis
-from ..database.claude_recommendations_mongo_db import get_claude_recommendations
-
-# Importar la función generate_unique_key
-from ..utils.widget_utils import generate_unique_key
-
-logger = logging.getLogger(__name__)
-
-###################################################################################
-
-def display_student_activities(username: str, lang_code: str, t: dict):
-    """
-    Muestra todas las actividades del estudiante
-    Args:
-        username: Nombre del estudiante
-        lang_code: Código del idioma
-        t: Diccionario de traducciones
-    """
-    try:
-        st.header(t.get('activities_title', 'Mis Actividades'))
-
-        # Tabs para diferentes tipos de análisis
-        tabs = st.tabs([
-            t.get('current_situation_activities', 'Mi Situación Actual'),
-            t.get('morpho_activities', 'Análisis Morfosintáctico'),
-            t.get('semantic_activities', 'Análisis Semántico'),
-            t.get('discourse_activities', 'Análisis del Discurso'),
-            t.get('chat_activities', 'Conversaciones con el Asistente')
-        ])
-
-        # Tab de Situación Actual
-        with tabs[0]:
-            display_current_situation_activities(username, t)
-        
-        # Tab de Análisis Morfosintáctico
-        with tabs[1]:
-            display_morphosyntax_activities(username, t)
-
-        # Tab de Análisis Semántico
-        with tabs[2]:
-            display_semantic_activities(username, t)
-
-        # Tab de Análisis del Discurso
-        with tabs[3]:
-            display_discourse_activities(username, t)
-            
-        # Tab de Conversaciones del Chat
-        with tabs[4]:
-            display_chat_activities(username, t)
-
-    except Exception as e:
-        logger.error(f"Error mostrando actividades: {str(e)}")
-        st.error(t.get('error_loading_activities', 'Error al cargar las actividades'))
-
-
-###############################################################################################
-
-def display_current_situation_activities(username: str, t: dict):
-    """
-    Muestra análisis de situación actual junto con las recomendaciones de Claude
-    unificando la información de ambas colecciones y emparejándolas por cercanía temporal.
-    """
-    try:
-        # Recuperar datos de ambas colecciones
-        logger.info(f"Recuperando análisis de situación actual para {username}")
-        situation_analyses = get_current_situation_analysis(username, limit=10)
-        
-        # Verificar si hay datos
-        if situation_analyses:
-            logger.info(f"Recuperados {len(situation_analyses)} análisis de situación")
-            # Depurar para ver la estructura de datos
-            for i, analysis in enumerate(situation_analyses):
-                logger.info(f"Análisis #{i+1}: Claves disponibles: {list(analysis.keys())}")
-                if 'metrics' in analysis:
-                    logger.info(f"Métricas disponibles: {list(analysis['metrics'].keys())}")
-        else:
-            logger.warning("No se encontraron análisis de situación actual")
-        
-        logger.info(f"Recuperando recomendaciones de Claude para {username}")
-        claude_recommendations = get_claude_recommendations(username)
-        
-        if claude_recommendations:
-            logger.info(f"Recuperadas {len(claude_recommendations)} recomendaciones de Claude")
-        else:
-            logger.warning("No se encontraron recomendaciones de Claude")
-        
-        # Verificar si hay algún tipo de análisis disponible
-        if not situation_analyses and not claude_recommendations:
-            logger.info("No se encontraron análisis de situación actual ni recomendaciones")
-            st.info(t.get('no_current_situation', 'No hay análisis de situación actual registrados'))
-            return
-        
-        # Crear pares combinados emparejando diagnósticos y recomendaciones cercanos en tiempo
-        logger.info("Creando emparejamientos temporales de análisis")
-        
-        # Convertir timestamps a objetos datetime para comparación
-        situation_times = []
-        for analysis in situation_analyses:
-            if 'timestamp' in analysis:
-                try:
-                    timestamp_str = analysis['timestamp']
-                    dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
-                    situation_times.append((dt, analysis))
-                except Exception as e:
-                    logger.error(f"Error parseando timestamp de situación: {str(e)}")
-        
-        recommendation_times = []
-        for recommendation in claude_recommendations:
-            if 'timestamp' in recommendation:
-                try:
-                    timestamp_str = recommendation['timestamp']
-                    dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
-                    recommendation_times.append((dt, recommendation))
-                except Exception as e:
-                    logger.error(f"Error parseando timestamp de recomendación: {str(e)}")
-        
-        # Ordenar por tiempo
-        situation_times.sort(key=lambda x: x[0], reverse=True)
-        recommendation_times.sort(key=lambda x: x[0], reverse=True)
-        
-        # Crear pares combinados
-        combined_items = []
-        
-        # Primero, procesar todas las situaciones encontrando la recomendación más cercana
-        for sit_time, situation in situation_times:
-            # Buscar la recomendación más cercana en tiempo
-            best_match = None
-            min_diff = timedelta(minutes=30)  # Máxima diferencia de tiempo aceptable (30 minutos)
-            best_rec_time = None
-            
-            for rec_time, recommendation in recommendation_times:
-                time_diff = abs(sit_time - rec_time)
-                if time_diff < min_diff:
-                    min_diff = time_diff
-                    best_match = recommendation
-                    best_rec_time = rec_time
-            
-            # Crear un elemento combinado
-            if best_match:
-                timestamp_key = sit_time.isoformat()
-                combined_items.append((timestamp_key, {
-                    'situation': situation,
-                    'recommendation': best_match,
-                    'time_diff': min_diff.total_seconds()
-                }))
-                # Eliminar la recomendación usada para no reutilizarla
-                recommendation_times = [(t, r) for t, r in recommendation_times if t != best_rec_time]
-                logger.info(f"Emparejado: Diagnóstico {sit_time} con Recomendación {best_rec_time} (diferencia: {min_diff})")
-            else:
-                # Si no hay recomendación cercana, solo incluir la situación
-                timestamp_key = sit_time.isoformat()
-                combined_items.append((timestamp_key, {
-                    'situation': situation
-                }))
-                logger.info(f"Sin emparejar: Diagnóstico {sit_time} sin recomendación cercana")
-        
-        # Agregar recomendaciones restantes sin situación
-        for rec_time, recommendation in recommendation_times:
-            timestamp_key = rec_time.isoformat()
-            combined_items.append((timestamp_key, {
-                'recommendation': recommendation
-            }))
-            logger.info(f"Sin emparejar: Recomendación {rec_time} sin diagnóstico cercano")
-        
-        # Ordenar por tiempo (más reciente primero)
-        combined_items.sort(key=lambda x: x[0], reverse=True)
-        
-        logger.info(f"Procesando {len(combined_items)} elementos combinados")
-        
-        # Mostrar cada par combinado
-        for i, (timestamp_key, analysis_pair) in enumerate(combined_items):
-            try:
-                # Obtener datos de situación y recomendación
-                situation_data = analysis_pair.get('situation', {})
-                recommendation_data = analysis_pair.get('recommendation', {})
-                time_diff = analysis_pair.get('time_diff')
-                
-                # Si no hay ningún dato, continuar al siguiente
-                if not situation_data and not recommendation_data:
-                    continue
-                
-                # Determinar qué texto mostrar (priorizar el de la situación)
-                text_to_show = situation_data.get('text', recommendation_data.get('text', ''))
-                text_type = situation_data.get('text_type', recommendation_data.get('text_type', ''))
-                
-                # Formatear fecha para mostrar
-                try:
-                    # Usar timestamp del key que ya es un formato ISO
-                    dt = datetime.fromisoformat(timestamp_key)
-                    formatted_date = dt.strftime("%d/%m/%Y %H:%M:%S")
-                except Exception as date_error:
-                    logger.error(f"Error formateando fecha: {str(date_error)}")
-                    formatted_date = timestamp_key
-                
-                # Determinar el título del expander
-                title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
-                if text_type:
-                    text_type_display = {
-                        'academic_article': t.get('academic_article', 'Artículo académico'),
-                        'student_essay': t.get('student_essay', 'Trabajo universitario'),
-                        'general_communication': t.get('general_communication', 'Comunicación general')
-                    }.get(text_type, text_type)
-                    title += f" - {text_type_display}"
-                
-                # Añadir indicador de emparejamiento si existe
-                if time_diff is not None:
-                    if time_diff < 60:  # menos de un minuto
-                        title += f" 🔄 (emparejados)"
-                    else:
-                        title += f" 🔄 (emparejados, diferencia: {int(time_diff//60)} min)"
-                
-                # Usar un ID único para cada expander
-                expander_id = f"analysis_{i}_{timestamp_key.replace(':', '_')}"
-                
-                # Mostrar el análisis en un expander
-                with st.expander(title, expanded=False):
-                    # Mostrar texto analizado con key único
-                    st.subheader(t.get('analyzed_text', 'Texto analizado'))
-                    st.text_area(
-                        "Text Content", 
-                        value=text_to_show, 
-                        height=100,
-                        disabled=True,
-                        label_visibility="collapsed",
-                        key=f"text_area_{expander_id}"
-                    )
-                    
-                    # Crear tabs para separar diagnóstico y recomendaciones
-                    diagnosis_tab, recommendations_tab = st.tabs([
-                        t.get('diagnosis_tab', 'Diagnóstico'),
-                        t.get('recommendations_tab', 'Recomendaciones')
-                    ])
-                    
-                    # Tab de diagnóstico
-                    with diagnosis_tab:
-                        if situation_data and 'metrics' in situation_data:
-                            metrics = situation_data['metrics']
-                            
-                            # Dividir en dos columnas
-                            col1, col2 = st.columns(2)
-                            
-                            # Principales métricas en formato de tarjetas
-                            with col1:
-                                st.subheader(t.get('key_metrics', 'Métricas clave'))
-                                
-                                # Mostrar cada métrica principal
-                                for metric_name, metric_data in metrics.items():
-                                    try:
-                                        # Determinar la puntuación
-                                        score = None
-                                        if isinstance(metric_data, dict):
-                                            # Intentar diferentes nombres de campo
-                                            if 'normalized_score' in metric_data:
-                                                score = metric_data['normalized_score']
-                                            elif 'score' in metric_data:
-                                                score = metric_data['score']
-                                            elif 'value' in metric_data:
-                                                score = metric_data['value']
-                                        elif isinstance(metric_data, (int, float)):
-                                            score = metric_data
-                                        
-                                        if score is not None:
-                                            # Asegurarse de que score es numérico
-                                            if isinstance(score, (int, float)):
-                                                # Determinar color y emoji basado en la puntuación
-                                                if score < 0.5:
-                                                    emoji = "🔴"
-                                                    color = "#ffcccc"  # light red
-                                                elif score < 0.75:
-                                                    emoji = "🟡"
-                                                    color = "#ffffcc"  # light yellow
-                                                else:
-                                                    emoji = "🟢"
-                                                    color = "#ccffcc"  # light green
-                                                
-                                                # Mostrar la métrica con estilo
-                                                st.markdown(f"""
-                                                <div style="background-color:{color}; padding:10px; border-radius:5px; margin-bottom:10px;">
-                                                    <b>{emoji} {metric_name.capitalize()}:</b> {score:.2f}
-                                                </div>
-                                                """, unsafe_allow_html=True)
-                                            else:
-                                                # Si no es numérico, mostrar como texto
-                                                st.markdown(f"""
-                                                <div style="background-color:#f0f0f0; padding:10px; border-radius:5px; margin-bottom:10px;">
-                                                    <b>ℹ️ {metric_name.capitalize()}:</b> {str(score)}
-                                                </div>
-                                                """, unsafe_allow_html=True)
-                                    except Exception as e:
-                                        logger.error(f"Error procesando métrica {metric_name}: {str(e)}")
-                            
-                            # Mostrar detalles adicionales si están disponibles
-                            with col2:
-                                st.subheader(t.get('details', 'Detalles'))
-                                
-                                # Para cada métrica, mostrar sus detalles si existen
-                                for metric_name, metric_data in metrics.items():
-                                    try:
-                                        if isinstance(metric_data, dict):
-                                            # Mostrar detalles directamente o buscar en subcampos
-                                            details = None
-                                            if 'details' in metric_data and metric_data['details']:
-                                                details = metric_data['details']
-                                            else:
-                                                # Crear un diccionario con los detalles excluyendo 'normalized_score' y similares
-                                                details = {k: v for k, v in metric_data.items() 
-                                                          if k not in ['normalized_score', 'score', 'value']}
-                                            
-                                            if details:
-                                                st.write(f"**{metric_name.capitalize()}**")
-                                                st.json(details, expanded=False)
-                                    except Exception as e:
-                                        logger.error(f"Error mostrando detalles de {metric_name}: {str(e)}")
-                        else:
-                            st.info(t.get('no_diagnosis', 'No hay datos de diagnóstico disponibles'))
-                    
-                    # Tab de recomendaciones
-                    with recommendations_tab:
-                        if recommendation_data and 'recommendations' in recommendation_data:
-                            st.markdown(f"""
-                            <div style="padding: 20px; border-radius: 10px; 
-                                background-color: #f8f9fa; margin-bottom: 20px;">
-                                {recommendation_data['recommendations']}
-                            </div>
-                            """, unsafe_allow_html=True)
-                        elif recommendation_data and 'feedback' in recommendation_data:
-                            st.markdown(f"""
-                            <div style="padding: 20px; border-radius: 10px; 
-                                background-color: #f8f9fa; margin-bottom: 20px;">
-                                {recommendation_data['feedback']}
-                            </div>
-                            """, unsafe_allow_html=True)
-                        else:
-                            st.info(t.get('no_recommendations', 'No hay recomendaciones disponibles'))
-            
-            except Exception as e:
-                logger.error(f"Error procesando par de análisis: {str(e)}")
-                continue
-        
-    except Exception as e:
-        logger.error(f"Error mostrando actividades de situación actual: {str(e)}")
-        st.error(t.get('error_current_situation', 'Error al mostrar análisis de situación actual'))
-
-###############################################################################################
-
-def display_morphosyntax_activities(username: str, t: dict):
-    """Muestra actividades de análisis morfosintáctico"""
-    try:
-        analyses = get_student_morphosyntax_analysis(username)
-        if not analyses:
-            st.info(t.get('no_morpho_analyses', 'No hay análisis morfosintácticos registrados'))
-            return
-
-        for analysis in analyses:
-            with st.expander(
-                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
-                expanded=False
-            ):
-                st.text(f"{t.get('analyzed_text', 'Texto analizado')}:")
-                st.write(analysis['text'])
-                
-                if 'arc_diagrams' in analysis:
-                    st.subheader(t.get('syntactic_diagrams', 'Diagramas sintácticos'))
-                    for diagram in analysis['arc_diagrams']:
-                        st.write(diagram, unsafe_allow_html=True)
-
-    except Exception as e:
-        logger.error(f"Error mostrando análisis morfosintáctico: {str(e)}")
-        st.error(t.get('error_morpho', 'Error al mostrar análisis morfosintáctico'))
-
-
-###############################################################################################
-
-def display_semantic_activities(username: str, t: dict):
-    """Muestra actividades de análisis semántico"""
-    try:
-        logger.info(f"Recuperando análisis semántico para {username}")
-        analyses = get_student_semantic_analysis(username)
-        
-        if not analyses:
-            logger.info("No se encontraron análisis semánticos")
-            st.info(t.get('no_semantic_analyses', 'No hay análisis semánticos registrados'))
-            return
-
-        logger.info(f"Procesando {len(analyses)} análisis semánticos")
-        
-        for analysis in analyses:
-            try:
-                # Verificar campos necesarios
-                if not all(key in analysis for key in ['timestamp', 'concept_graph']):
-                    logger.warning(f"Análisis incompleto: {analysis.keys()}")
-                    continue
-                
-                # Formatear fecha
-                timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
-                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
-                
-                # Crear expander
-                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
-                    # Procesar y mostrar gráfico
-                    if analysis.get('concept_graph'):
-                        try:
-                            # Convertir de base64 a bytes
-                            logger.debug("Decodificando gráfico de conceptos")
-                            image_data = analysis['concept_graph']
-                            
-                            # Si el gráfico ya es bytes, usarlo directamente
-                            if isinstance(image_data, bytes):
-                                image_bytes = image_data
-                            else:
-                                # Si es string base64, decodificar
-                                image_bytes = base64.b64decode(image_data)
-                            
-                            logger.debug(f"Longitud de bytes de imagen: {len(image_bytes)}")
-                            
-                            # Mostrar imagen
-                            st.image(
-                                image_bytes,
-                                caption=t.get('concept_network', 'Red de Conceptos'),
-                                use_column_width=True
-                            )
-                            logger.debug("Gráfico mostrado exitosamente")
-                            
-                        except Exception as img_error:
-                            logger.error(f"Error procesando gráfico: {str(img_error)}")
-                            st.error(t.get('error_loading_graph', 'Error al cargar el gráfico'))
-                    else:
-                        st.info(t.get('no_graph', 'No hay visualización disponible'))
-
-            except Exception as e:
-                logger.error(f"Error procesando análisis individual: {str(e)}")
-                continue
-
-    except Exception as e:
-        logger.error(f"Error mostrando análisis semántico: {str(e)}")
-        st.error(t.get('error_semantic', 'Error al mostrar análisis semántico'))
-
-
-###################################################################################################
-def display_discourse_activities(username: str, t: dict):
-    """Muestra actividades de análisis del discurso"""
-    try:
-        logger.info(f"Recuperando análisis del discurso para {username}")
-        analyses = get_student_discourse_analysis(username)
-        
-        if not analyses:
-            logger.info("No se encontraron análisis del discurso")
-            st.info(t.get('no_discourse_analyses', 'No hay análisis del discurso registrados'))
-            return
-
-        logger.info(f"Procesando {len(analyses)} análisis del discurso")
-        for analysis in analyses:
-            try:
-                # Verificar campos mínimos necesarios
-                if not all(key in analysis for key in ['timestamp', 'combined_graph']):
-                    logger.warning(f"Análisis incompleto: {analysis.keys()}")
-                    continue
-
-                # Formatear fecha
-                timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
-                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
-                
-                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
-                    if analysis['combined_graph']:
-                        logger.debug("Decodificando gráfico combinado")
-                        try:
-                            image_bytes = base64.b64decode(analysis['combined_graph'])
-                            st.image(image_bytes, use_column_width=True)
-                            logger.debug("Gráfico mostrado exitosamente")
-                        except Exception as img_error:
-                            logger.error(f"Error decodificando imagen: {str(img_error)}")
-                            st.error(t.get('error_loading_graph', 'Error al cargar el gráfico'))
-                    else:
-                        st.info(t.get('no_visualization', 'No hay visualización comparativa disponible'))
-
-            except Exception as e:
-                logger.error(f"Error procesando análisis individual: {str(e)}")
-                continue
-
-    except Exception as e:
-        logger.error(f"Error mostrando análisis del discurso: {str(e)}")
-        st.error(t.get('error_discourse', 'Error al mostrar análisis del discurso'))
-
-#################################################################################   
-def display_chat_activities(username: str, t: dict):
-    """
-    Muestra historial de conversaciones del chat
-    """
-    try:
-        # Obtener historial del chat
-        chat_history = get_chat_history(
-            username=username,
-            analysis_type='sidebar',
-            limit=50
-        )
-        
-        if not chat_history:
-            st.info(t.get('no_chat_history', 'No hay conversaciones registradas'))
-            return
-
-        for chat in reversed(chat_history):  # Mostrar las más recientes primero
-            try:
-                # Convertir timestamp a datetime para formato
-                timestamp = datetime.fromisoformat(chat['timestamp'].replace('Z', '+00:00'))
-                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
-                
-                with st.expander(
-                    f"{t.get('chat_date', 'Fecha de conversación')}: {formatted_date}",
-                    expanded=False
-                ):
-                    if 'messages' in chat and chat['messages']:
-                        # Mostrar cada mensaje en la conversación
-                        for message in chat['messages']:
-                            role = message.get('role', 'unknown')
-                            content = message.get('content', '')
-                            
-                            # Usar el componente de chat de Streamlit
-                            with st.chat_message(role):
-                                st.markdown(content)
-                                
-                            # Agregar separador entre mensajes
-                            st.divider()
-                    else:
-                        st.warning(t.get('invalid_chat_format', 'Formato de chat no válido'))
-                        
-            except Exception as e:
-                logger.error(f"Error mostrando conversación: {str(e)}")
-                continue
-
-    except Exception as e:
-        logger.error(f"Error mostrando historial del chat: {str(e)}")
-        st.error(t.get('error_chat', 'Error al mostrar historial del chat'))
-        
-#################################################################################        
-def display_discourse_comparison(analysis: dict, t: dict):
-    """Muestra la comparación de análisis del discurso"""
-    st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
-    
-    col1, col2 = st.columns(2)
-    with col1:
-        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
-        df1 = pd.DataFrame(analysis['key_concepts1'])
-        st.dataframe(df1)
-    
-    with col2:
-        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
-        df2 = pd.DataFrame(analysis['key_concepts2'])
-        st.dataframe(df2)   
+##############
+###modules/studentact/student_activities_v2.py
+
+import streamlit as st
+import re
+import io
+from io import BytesIO
+import pandas as pd
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from datetime import datetime, timedelta
+from spacy import displacy
+import random
+import base64
+import seaborn as sns
+import logging
+
+# Importaciones de la base de datos
+from ..database.morphosintax_mongo_db import get_student_morphosyntax_analysis
+from ..database.semantic_mongo_db import get_student_semantic_analysis
+from ..database.discourse_mongo_db import get_student_discourse_analysis
+from ..database.chat_mongo_db import get_chat_history
+from ..database.current_situation_mongo_db import get_current_situation_analysis
+from ..database.claude_recommendations_mongo_db import get_claude_recommendations
+
+# Importar la función generate_unique_key
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+###################################################################################
+
+def display_student_activities(username: str, lang_code: str, t: dict):
+    """
+    Muestra todas las actividades del estudiante
+    Args:
+        username: Nombre del estudiante
+        lang_code: Código del idioma
+        t: Diccionario de traducciones
+    """
+    try:
+        # Cambiado de "Mis Actividades" a "Registro de mis actividades"
+        #st.header(t.get('activities_title', 'Registro de mis actividades'))
+
+        # Tabs para diferentes tipos de análisis
+        # Cambiado "Análisis del Discurso" a "Análisis comparado de textos"
+        tabs = st.tabs([
+            t.get('current_situation_activities', 'Registros de la función: Mi Situación Actual'),
+            t.get('morpho_activities', 'Registros de mis análisis morfosintácticos'),
+            t.get('semantic_activities', 'Registros de mis análisis semánticos'),
+            t.get('discourse_activities', 'Registros de mis análisis comparado de textos'),
+            t.get('chat_activities', 'Registros de mis conversaciones con el tutor virtual')
+        ])
+
+        # Tab de Situación Actual
+        with tabs[0]:
+            display_current_situation_activities(username, t)
+        
+        # Tab de Análisis Morfosintáctico
+        with tabs[1]:
+            display_morphosyntax_activities(username, t)
+
+        # Tab de Análisis Semántico
+        with tabs[2]:
+            display_semantic_activities(username, t)
+
+        # Tab de Análisis del Discurso (mantiene nombre interno pero UI muestra "Análisis comparado de textos")
+        with tabs[3]:
+            display_discourse_activities(username, t)
+            
+        # Tab de Conversaciones del Chat
+        with tabs[4]:
+            display_chat_activities(username, t)
+
+    except Exception as e:
+        logger.error(f"Error mostrando actividades: {str(e)}")
+        st.error(t.get('error_loading_activities', 'Error al cargar las actividades'))
+
+
+###############################################################################################
+
+def display_current_situation_activities(username: str, t: dict):
+    """
+    Muestra análisis de situación actual junto con las recomendaciones de Claude
+    unificando la información de ambas colecciones y emparejándolas por cercanía temporal.
+    """
+    try:
+        # Recuperar datos de ambas colecciones
+        logger.info(f"Recuperando análisis de situación actual para {username}")
+        situation_analyses = get_current_situation_analysis(username, limit=10)
+        
+        # Verificar si hay datos
+        if situation_analyses:
+            logger.info(f"Recuperados {len(situation_analyses)} análisis de situación")
+            # Depurar para ver la estructura de datos
+            for i, analysis in enumerate(situation_analyses):
+                logger.info(f"Análisis #{i+1}: Claves disponibles: {list(analysis.keys())}")
+                if 'metrics' in analysis:
+                    logger.info(f"Métricas disponibles: {list(analysis['metrics'].keys())}")
+        else:
+            logger.warning("No se encontraron análisis de situación actual")
+        
+        logger.info(f"Recuperando recomendaciones de Claude para {username}")
+        claude_recommendations = get_claude_recommendations(username)
+        
+        if claude_recommendations:
+            logger.info(f"Recuperadas {len(claude_recommendations)} recomendaciones de Claude")
+        else:
+            logger.warning("No se encontraron recomendaciones de Claude")
+        
+        # Verificar si hay algún tipo de análisis disponible
+        if not situation_analyses and not claude_recommendations:
+            logger.info("No se encontraron análisis de situación actual ni recomendaciones")
+            st.info(t.get('no_current_situation', 'No hay análisis de situación actual registrados'))
+            return
+        
+        # Crear pares combinados emparejando diagnósticos y recomendaciones cercanos en tiempo
+        logger.info("Creando emparejamientos temporales de análisis")
+        
+        # Convertir timestamps a objetos datetime para comparación
+        situation_times = []
+        for analysis in situation_analyses:
+            if 'timestamp' in analysis:
+                try:
+                    timestamp_str = analysis['timestamp']
+                    dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
+                    situation_times.append((dt, analysis))
+                except Exception as e:
+                    logger.error(f"Error parseando timestamp de situación: {str(e)}")
+        
+        recommendation_times = []
+        for recommendation in claude_recommendations:
+            if 'timestamp' in recommendation:
+                try:
+                    timestamp_str = recommendation['timestamp']
+                    dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
+                    recommendation_times.append((dt, recommendation))
+                except Exception as e:
+                    logger.error(f"Error parseando timestamp de recomendación: {str(e)}")
+        
+        # Ordenar por tiempo
+        situation_times.sort(key=lambda x: x[0], reverse=True)
+        recommendation_times.sort(key=lambda x: x[0], reverse=True)
+        
+        # Crear pares combinados
+        combined_items = []
+        
+        # Primero, procesar todas las situaciones encontrando la recomendación más cercana
+        for sit_time, situation in situation_times:
+            # Buscar la recomendación más cercana en tiempo
+            best_match = None
+            min_diff = timedelta(minutes=30)  # Máxima diferencia de tiempo aceptable (30 minutos)
+            best_rec_time = None
+            
+            for rec_time, recommendation in recommendation_times:
+                time_diff = abs(sit_time - rec_time)
+                if time_diff < min_diff:
+                    min_diff = time_diff
+                    best_match = recommendation
+                    best_rec_time = rec_time
+            
+            # Crear un elemento combinado
+            if best_match:
+                timestamp_key = sit_time.isoformat()
+                combined_items.append((timestamp_key, {
+                    'situation': situation,
+                    'recommendation': best_match,
+                    'time_diff': min_diff.total_seconds()
+                }))
+                # Eliminar la recomendación usada para no reutilizarla
+                recommendation_times = [(t, r) for t, r in recommendation_times if t != best_rec_time]
+                logger.info(f"Emparejado: Diagnóstico {sit_time} con Recomendación {best_rec_time} (diferencia: {min_diff})")
+            else:
+                # Si no hay recomendación cercana, solo incluir la situación
+                timestamp_key = sit_time.isoformat()
+                combined_items.append((timestamp_key, {
+                    'situation': situation
+                }))
+                logger.info(f"Sin emparejar: Diagnóstico {sit_time} sin recomendación cercana")
+        
+        # Agregar recomendaciones restantes sin situación
+        for rec_time, recommendation in recommendation_times:
+            timestamp_key = rec_time.isoformat()
+            combined_items.append((timestamp_key, {
+                'recommendation': recommendation
+            }))
+            logger.info(f"Sin emparejar: Recomendación {rec_time} sin diagnóstico cercano")
+        
+        # Ordenar por tiempo (más reciente primero)
+        combined_items.sort(key=lambda x: x[0], reverse=True)
+        
+        logger.info(f"Procesando {len(combined_items)} elementos combinados")
+        
+        # Mostrar cada par combinado
+        for i, (timestamp_key, analysis_pair) in enumerate(combined_items):
+            try:
+                # Obtener datos de situación y recomendación
+                situation_data = analysis_pair.get('situation', {})
+                recommendation_data = analysis_pair.get('recommendation', {})
+                time_diff = analysis_pair.get('time_diff')
+                
+                # Si no hay ningún dato, continuar al siguiente
+                if not situation_data and not recommendation_data:
+                    continue
+                
+                # Determinar qué texto mostrar (priorizar el de la situación)
+                text_to_show = situation_data.get('text', recommendation_data.get('text', ''))
+                text_type = situation_data.get('text_type', recommendation_data.get('text_type', ''))
+                
+                # Formatear fecha para mostrar
+                try:
+                    # Usar timestamp del key que ya es un formato ISO
+                    dt = datetime.fromisoformat(timestamp_key)
+                    formatted_date = dt.strftime("%d/%m/%Y %H:%M:%S")
+                except Exception as date_error:
+                    logger.error(f"Error formateando fecha: {str(date_error)}")
+                    formatted_date = timestamp_key
+                
+                # Determinar el título del expander
+                title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
+                if text_type:
+                    text_type_display = {
+                        'academic_article': t.get('academic_article', 'Artículo académico'),
+                        'student_essay': t.get('student_essay', 'Trabajo universitario'),
+                        'general_communication': t.get('general_communication', 'Comunicación general')
+                    }.get(text_type, text_type)
+                    title += f" - {text_type_display}"
+                
+                # Añadir indicador de emparejamiento si existe
+                if time_diff is not None:
+                    if time_diff < 60:  # menos de un minuto
+                        title += f" 🔄 (emparejados)"
+                    else:
+                        title += f" 🔄 (emparejados, diferencia: {int(time_diff//60)} min)"
+                
+                # Usar un ID único para cada expander
+                expander_id = f"analysis_{i}_{timestamp_key.replace(':', '_')}"
+                
+                # Mostrar el análisis en un expander
+                with st.expander(title, expanded=False):
+                    # Mostrar texto analizado con key único
+                    st.subheader(t.get('analyzed_text', 'Texto analizado'))
+                    st.text_area(
+                        "Text Content", 
+                        value=text_to_show, 
+                        height=100,
+                        disabled=True,
+                        label_visibility="collapsed",
+                        key=f"text_area_{expander_id}"
+                    )
+                    
+                    # Crear tabs para separar diagnóstico y recomendaciones
+                    diagnosis_tab, recommendations_tab = st.tabs([
+                        t.get('diagnosis_tab', 'Diagnóstico'),
+                        t.get('recommendations_tab', 'Recomendaciones')
+                    ])
+                    
+                    # Tab de diagnóstico
+                    with diagnosis_tab:
+                        if situation_data and 'metrics' in situation_data:
+                            metrics = situation_data['metrics']
+                            
+                            # Dividir en dos columnas
+                            col1, col2 = st.columns(2)
+                            
+                            # Principales métricas en formato de tarjetas
+                            with col1:
+                                st.subheader(t.get('key_metrics', 'Métricas clave'))
+                                
+                                # Mostrar cada métrica principal
+                                for metric_name, metric_data in metrics.items():
+                                    try:
+                                        # Determinar la puntuación
+                                        score = None
+                                        if isinstance(metric_data, dict):
+                                            # Intentar diferentes nombres de campo
+                                            if 'normalized_score' in metric_data:
+                                                score = metric_data['normalized_score']
+                                            elif 'score' in metric_data:
+                                                score = metric_data['score']
+                                            elif 'value' in metric_data:
+                                                score = metric_data['value']
+                                        elif isinstance(metric_data, (int, float)):
+                                            score = metric_data
+                                        
+                                        if score is not None:
+                                            # Asegurarse de que score es numérico
+                                            if isinstance(score, (int, float)):
+                                                # Determinar color y emoji basado en la puntuación
+                                                if score < 0.5:
+                                                    emoji = "🔴"
+                                                    color = "#ffcccc"  # light red
+                                                elif score < 0.75:
+                                                    emoji = "🟡"
+                                                    color = "#ffffcc"  # light yellow
+                                                else:
+                                                    emoji = "🟢"
+                                                    color = "#ccffcc"  # light green
+                                                
+                                                # Mostrar la métrica con estilo
+                                                st.markdown(f"""
+                                                <div style="background-color:{color}; padding:10px; border-radius:5px; margin-bottom:10px;">
+                                                    <b>{emoji} {metric_name.capitalize()}:</b> {score:.2f}
+                                                </div>
+                                                """, unsafe_allow_html=True)
+                                            else:
+                                                # Si no es numérico, mostrar como texto
+                                                st.markdown(f"""
+                                                <div style="background-color:#f0f0f0; padding:10px; border-radius:5px; margin-bottom:10px;">
+                                                    <b>ℹ️ {metric_name.capitalize()}:</b> {str(score)}
+                                                </div>
+                                                """, unsafe_allow_html=True)
+                                    except Exception as e:
+                                        logger.error(f"Error procesando métrica {metric_name}: {str(e)}")
+                            
+                            # Mostrar detalles adicionales si están disponibles
+                            with col2:
+                                st.subheader(t.get('details', 'Detalles'))
+                                
+                                # Para cada métrica, mostrar sus detalles si existen
+                                for metric_name, metric_data in metrics.items():
+                                    try:
+                                        if isinstance(metric_data, dict):
+                                            # Mostrar detalles directamente o buscar en subcampos
+                                            details = None
+                                            if 'details' in metric_data and metric_data['details']:
+                                                details = metric_data['details']
+                                            else:
+                                                # Crear un diccionario con los detalles excluyendo 'normalized_score' y similares
+                                                details = {k: v for k, v in metric_data.items() 
+                                                          if k not in ['normalized_score', 'score', 'value']}
+                                            
+                                            if details:
+                                                st.write(f"**{metric_name.capitalize()}**")
+                                                st.json(details, expanded=False)
+                                    except Exception as e:
+                                        logger.error(f"Error mostrando detalles de {metric_name}: {str(e)}")
+                        else:
+                            st.info(t.get('no_diagnosis', 'No hay datos de diagnóstico disponibles'))
+                    
+                    # Tab de recomendaciones
+                    with recommendations_tab:
+                        if recommendation_data and 'recommendations' in recommendation_data:
+                            st.markdown(f"""
+                            <div style="padding: 20px; border-radius: 10px; 
+                                background-color: #f8f9fa; margin-bottom: 20px;">
+                                {recommendation_data['recommendations']}
+                            </div>
+                            """, unsafe_allow_html=True)
+                        elif recommendation_data and 'feedback' in recommendation_data:
+                            st.markdown(f"""
+                            <div style="padding: 20px; border-radius: 10px; 
+                                background-color: #f8f9fa; margin-bottom: 20px;">
+                                {recommendation_data['feedback']}
+                            </div>
+                            """, unsafe_allow_html=True)
+                        else:
+                            st.info(t.get('no_recommendations', 'No hay recomendaciones disponibles'))
+            
+            except Exception as e:
+                logger.error(f"Error procesando par de análisis: {str(e)}")
+                continue
+        
+    except Exception as e:
+        logger.error(f"Error mostrando actividades de situación actual: {str(e)}")
+        st.error(t.get('error_current_situation', 'Error al mostrar análisis de situación actual'))
+
+###############################################################################################
+
+def display_morphosyntax_activities(username: str, t: dict):
+    """Muestra actividades de análisis morfosintáctico"""
+    try:
+        analyses = get_student_morphosyntax_analysis(username)
+        if not analyses:
+            st.info(t.get('no_morpho_analyses', 'No hay análisis morfosintácticos registrados'))
+            return
+
+        for analysis in analyses:
+            with st.expander(
+                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
+                expanded=False
+            ):
+                st.text(f"{t.get('analyzed_text', 'Texto analizado')}:")
+                st.write(analysis['text'])
+                
+                if 'arc_diagrams' in analysis:
+                    st.subheader(t.get('syntactic_diagrams', 'Diagramas sintácticos'))
+                    for diagram in analysis['arc_diagrams']:
+                        st.write(diagram, unsafe_allow_html=True)
+
+    except Exception as e:
+        logger.error(f"Error mostrando análisis morfosintáctico: {str(e)}")
+        st.error(t.get('error_morpho', 'Error al mostrar análisis morfosintáctico'))
+
+
+###############################################################################################
+
+def display_semantic_activities(username: str, t: dict):
+    """Muestra actividades de análisis semántico"""
+    try:
+        logger.info(f"Recuperando análisis semántico para {username}")
+        analyses = get_student_semantic_analysis(username)
+        
+        if not analyses:
+            logger.info("No se encontraron análisis semánticos")
+            st.info(t.get('no_semantic_analyses', 'No hay análisis semánticos registrados'))
+            return
+
+        logger.info(f"Procesando {len(analyses)} análisis semánticos")
+        
+        for analysis in analyses:
+            try:
+                # Verificar campos necesarios
+                if not all(key in analysis for key in ['timestamp', 'concept_graph']):
+                    logger.warning(f"Análisis incompleto: {analysis.keys()}")
+                    continue
+                
+                # Formatear fecha
+                timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
+                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                
+                # Crear expander
+                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
+                    # Procesar y mostrar gráfico
+                    if analysis.get('concept_graph'):
+                        try:
+                            # Convertir de base64 a bytes
+                            logger.debug("Decodificando gráfico de conceptos")
+                            image_data = analysis['concept_graph']
+                            
+                            # Si el gráfico ya es bytes, usarlo directamente
+                            if isinstance(image_data, bytes):
+                                image_bytes = image_data
+                            else:
+                                # Si es string base64, decodificar
+                                image_bytes = base64.b64decode(image_data)
+                            
+                            logger.debug(f"Longitud de bytes de imagen: {len(image_bytes)}")
+                            
+                            # Mostrar imagen
+                            st.image(
+                                image_bytes,
+                                caption=t.get('concept_network', 'Red de Conceptos'),
+                                use_column_width=True
+                            )
+                            logger.debug("Gráfico mostrado exitosamente")
+                            
+                        except Exception as img_error:
+                            logger.error(f"Error procesando gráfico: {str(img_error)}")
+                            st.error(t.get('error_loading_graph', 'Error al cargar el gráfico'))
+                    else:
+                        st.info(t.get('no_graph', 'No hay visualización disponible'))
+
+            except Exception as e:
+                logger.error(f"Error procesando análisis individual: {str(e)}")
+                continue
+
+    except Exception as e:
+        logger.error(f"Error mostrando análisis semántico: {str(e)}")
+        st.error(t.get('error_semantic', 'Error al mostrar análisis semántico'))
+
+
+###################################################################################################
+def display_discourse_activities(username: str, t: dict):
+    """Muestra actividades de análisis del discurso (mostrado como 'Análisis comparado de textos' en la UI)"""
+    try:
+        logger.info(f"Recuperando análisis del discurso para {username}")
+        analyses = get_student_discourse_analysis(username)
+        
+        if not analyses:
+            logger.info("No se encontraron análisis del discurso")
+            # Usamos el término "análisis comparado de textos" en la UI
+            st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
+            return
+
+        logger.info(f"Procesando {len(analyses)} análisis del discurso")
+        for analysis in analyses:
+            try:
+                # Verificar campos mínimos necesarios
+                if not all(key in analysis for key in ['timestamp', 'combined_graph']):
+                    logger.warning(f"Análisis incompleto: {analysis.keys()}")
+                    continue
+
+                # Formatear fecha
+                timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
+                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                
+                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
+                    if analysis['combined_graph']:
+                        logger.debug("Decodificando gráfico combinado")
+                        try:
+                            image_bytes = base64.b64decode(analysis['combined_graph'])
+                            st.image(image_bytes, use_column_width=True)
+                            logger.debug("Gráfico mostrado exitosamente")
+                        except Exception as img_error:
+                            logger.error(f"Error decodificando imagen: {str(img_error)}")
+                            st.error(t.get('error_loading_graph', 'Error al cargar el gráfico'))
+                    else:
+                        st.info(t.get('no_visualization', 'No hay visualización comparativa disponible'))
+
+            except Exception as e:
+                logger.error(f"Error procesando análisis individual: {str(e)}")
+                continue
+
+    except Exception as e:
+        logger.error(f"Error mostrando análisis del discurso: {str(e)}")
+        # Usamos el término "análisis comparado de textos" en la UI
+        st.error(t.get('error_discourse', 'Error al mostrar análisis comparado de textos'))
+
+#################################################################################   
+def display_chat_activities(username: str, t: dict):
+    """
+    Muestra historial de conversaciones del chat
+    """
+    try:
+        # Obtener historial del chat
+        chat_history = get_chat_history(
+            username=username,
+            analysis_type='sidebar',
+            limit=50
+        )
+        
+        if not chat_history:
+            st.info(t.get('no_chat_history', 'No hay conversaciones registradas'))
+            return
+
+        for chat in reversed(chat_history):  # Mostrar las más recientes primero
+            try:
+                # Convertir timestamp a datetime para formato
+                timestamp = datetime.fromisoformat(chat['timestamp'].replace('Z', '+00:00'))
+                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                
+                with st.expander(
+                    f"{t.get('chat_date', 'Fecha de conversación')}: {formatted_date}",
+                    expanded=False
+                ):
+                    if 'messages' in chat and chat['messages']:
+                        # Mostrar cada mensaje en la conversación
+                        for message in chat['messages']:
+                            role = message.get('role', 'unknown')
+                            content = message.get('content', '')
+                            
+                            # Usar el componente de chat de Streamlit
+                            with st.chat_message(role):
+                                st.markdown(content)
+                                
+                            # Agregar separador entre mensajes
+                            st.divider()
+                    else:
+                        st.warning(t.get('invalid_chat_format', 'Formato de chat no válido'))
+                        
+            except Exception as e:
+                logger.error(f"Error mostrando conversación: {str(e)}")
+                continue
+
+    except Exception as e:
+        logger.error(f"Error mostrando historial del chat: {str(e)}")
+        st.error(t.get('error_chat', 'Error al mostrar historial del chat'))
+        
+#################################################################################        
+def display_discourse_comparison(analysis: dict, t: dict):
+    """Muestra la comparación de análisis del discurso"""
+    # Cambiado para usar "textos comparados" en la UI
+    st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
+        df1 = pd.DataFrame(analysis['key_concepts1'])
+        st.dataframe(df1)
+    
+    with col2:
+        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+        df2 = pd.DataFrame(analysis['key_concepts2'])
+        st.dataframe(df2)