Upload 14 files

modules/studentact/6-3-2025_current_situation_interface.py

@@ -0,0 +1,486 @@
+# modules/studentact/current_situation_interface-vOK.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 
+
+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,
+    generate_recommendations
+)
+
+# 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__)
+####################################
+
+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
+        
+    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(
+                        "",
+                        options=list(TEXT_TYPES.keys()),
+                        format_func=lambda x: TEXT_TYPES[x]['name'],
+                        horizontal=True,
+                        key="text_type_radio",
+                        help="Selecciona el tipo de texto para ajustar los criterios de evaluación"
+                    )
+                    
+                    st.session_state.current_text_type = text_type
+                    
+                    # Luego mostrar los resultados
+                    display_results(
+                        metrics=st.session_state.current_metrics,
+                        text_type=text_type
+                    )
+
+    except Exception as e:
+        logger.error(f"Error en interfaz principal: {str(e)}")
+        st.error("Ocurrió un error al cargar la interfaz")
+
+###################################3333
+
+'''
+def display_results(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_results(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)
+
+        recommendations = generate_recommendations(
+            metrics=metrics,
+            text_type=text_type,
+            lang_code=st.session_state.lang_code
+        )
+        
+        # Separador visual
+        st.markdown("---")
+        
+        # Título para la sección de recomendaciones
+        st.subheader("Recomendaciones para mejorar tu escritura")
+        
+        # Mostrar las recomendaciones
+        display_recommendations(recommendations, get_translations(st.session_state.lang_code))
+
+    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),  # Cambiado de (0.1, 0.1) a (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")
+
+#####################################################
+def display_recommendations(recommendations, t):
+    """
+    Muestra las recomendaciones con un diseño de tarjetas.
+    """
+    # Definir colores para cada categoría
+    colors = {
+        'vocabulary': '#2E86C1',  # Azul
+        'structure': '#28B463',   # Verde
+        'cohesion': '#F39C12',    # Naranja
+        'clarity': '#9B59B6',     # Púrpura
+        'priority': '#E74C3C'     # Rojo para la categoría prioritaria
+    }
+    
+    # Iconos para cada categoría
+    icons = {
+        'vocabulary': '📚',
+        'structure': '🏗️',
+        'cohesion': '🔄',
+        'clarity': '💡',
+        'priority': '⭐'
+    }
+    
+    # Obtener traducciones para cada dimensión
+    dimension_names = {
+        'vocabulary': t.get('SITUATION_ANALYSIS', {}).get('vocabulary', "Vocabulario"),
+        'structure': t.get('SITUATION_ANALYSIS', {}).get('structure', "Estructura"),
+        'cohesion': t.get('SITUATION_ANALYSIS', {}).get('cohesion', "Cohesión"),
+        'clarity': t.get('SITUATION_ANALYSIS', {}).get('clarity', "Claridad"),
+        'priority': t.get('SITUATION_ANALYSIS', {}).get('priority', "Prioridad")
+    }
+    
+    # Título de la sección prioritaria
+    priority_focus = t.get('SITUATION_ANALYSIS', {}).get('priority_focus', 'Área prioritaria para mejorar')
+    st.markdown(f"### {icons['priority']} {priority_focus}")
+    
+    # Determinar área prioritaria (la que tiene menor puntuación)
+    priority_area = recommendations.get('priority', 'vocabulary')
+    priority_title = dimension_names.get(priority_area, "Área prioritaria")
+    
+    # Determinar el contenido para mostrar
+    if isinstance(recommendations[priority_area], dict) and 'title' in recommendations[priority_area]:
+        priority_title = recommendations[priority_area]['title']
+        priority_content = recommendations[priority_area]['content']
+    else:
+        priority_content = recommendations[priority_area]
+    
+    # Mostrar la recomendación prioritaria con un estilo destacado
+    with st.container():
+        st.markdown(
+            f"""
+            <div style="border:2px solid {colors['priority']}; border-radius:5px; padding:15px; margin-bottom:20px;">
+                <h4 style="color:{colors['priority']};">{priority_title}</h4>
+                <p>{priority_content}</p>
+            </div>
+            """, 
+            unsafe_allow_html=True
+        )
+    
+    # Crear dos columnas para las tarjetas de recomendaciones restantes
+    col1, col2 = st.columns(2)
+    
+    # Distribuir las recomendaciones en las columnas
+    categories = ['vocabulary', 'structure', 'cohesion', 'clarity']
+    for i, category in enumerate(categories):
+        # Saltar si esta categoría ya es la prioritaria
+        if category == priority_area:
+            continue
+            
+        # Determinar título y contenido
+        if isinstance(recommendations[category], dict) and 'title' in recommendations[category]:
+            category_title = recommendations[category]['title']
+            category_content = recommendations[category]['content']
+        else:
+            category_title = dimension_names.get(category, category)
+            category_content = recommendations[category]
+        
+        # Alternar entre columnas
+        with col1 if i % 2 == 0 else col2:
+            # Crear tarjeta para cada recomendación
+            st.markdown(
+                f"""
+                <div style="border:1px solid {colors[category]}; border-radius:5px; padding:10px; margin-bottom:15px;">
+                    <h4 style="color:{colors[category]};">{icons[category]} {category_title}</h4>
+                    <p>{category_content}</p>
+                </div>
+                """, 
+                unsafe_allow_html=True
+            )

modules/studentact/claude_recommendations.py

@@ -0,0 +1,266 @@
+# modules/studentact/claude_recommendations.py
+import os
+import anthropic
+import streamlit as st
+import logging
+import time
+import json
+from datetime import datetime, timezone
+
+# Local imports
+from ..utils.widget_utils import generate_unique_key
+from ..database.current_situation_mongo_db import store_current_situation_result
+
+logger = logging.getLogger(__name__)
+
+# Define text types
+TEXT_TYPES = {
+    'es': {
+        'academic_article': 'artículo académico',
+        'university_work': 'trabajo universitario',
+        'general_communication': 'comunicación general'
+    },
+    'en': {
+        'academic_article': 'academic article',
+        'university_work': 'university work',
+        'general_communication': 'general communication'
+    },
+    'fr': {
+        'academic_article': 'article académique',
+        'university_work': 'travail universitaire',
+        'general_communication': 'communication générale'
+    }
+}
+
+# Cache for recommendations to avoid redundant API calls
+recommendation_cache = {}
+
+def get_recommendation_cache_key(text, metrics, text_type, lang_code):
+    """
+    Generate a cache key for recommendations.
+    """
+    # Create a simple hash based on text content and metrics
+    text_hash = hash(text[:1000])  # Only use first 1000 chars for hashing
+    metrics_hash = hash(json.dumps(metrics, sort_keys=True))
+    return f"{text_hash}_{metrics_hash}_{text_type}_{lang_code}"
+
+def format_metrics_for_claude(metrics, lang_code, text_type):
+    """
+    Format metrics in a way that's readable for Claude
+    """
+    formatted_metrics = {}
+    for key, value in metrics.items():
+        if isinstance(value, (int, float)):
+            formatted_metrics[key] = round(value, 2)
+        else:
+            formatted_metrics[key] = value
+    
+    # Add context about what type of text this is
+    text_type_label = TEXT_TYPES.get(lang_code, {}).get(text_type, text_type)
+    formatted_metrics['text_type'] = text_type_label
+    
+    return formatted_metrics
+
+def generate_claude_recommendations(text, metrics, text_type, lang_code):
+    """
+    Generate personalized recommendations using Claude API.
+    """
+    try:
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        if not api_key:
+            logger.error("Claude API key not found in environment variables")
+            return get_fallback_recommendations(lang_code)
+        
+        # Check cache first
+        cache_key = get_recommendation_cache_key(text, metrics, text_type, lang_code)
+        if cache_key in recommendation_cache:
+            logger.info("Using cached recommendations")
+            return recommendation_cache[cache_key]
+        
+        # Format metrics for Claude
+        formatted_metrics = format_metrics_for_claude(metrics, lang_code, text_type)
+        
+        # Determine language for prompt
+        if lang_code == 'es':
+            system_prompt = """Eres un asistente especializado en análisis de textos académicos y comunicación escrita. 
+            Tu tarea es analizar el texto del usuario y proporcionar recomendaciones personalizadas.
+            Usa un tono constructivo y específico. Sé claro y directo con tus sugerencias.
+            """
+            user_prompt = f"""Por favor, analiza este texto de tipo '{formatted_metrics['text_type']}' 
+            y proporciona recomendaciones personalizadas para mejorarlo.
+            
+            MÉTRICAS DE ANÁLISIS:
+            {json.dumps(formatted_metrics, indent=2, ensure_ascii=False)}
+            
+            TEXTO A ANALIZAR:
+            {text[:2000]}  # Limitamos el texto para evitar exceder tokens
+            
+            Proporciona tu análisis con el siguiente formato:
+            1. Un resumen breve (2-3 frases) del análisis general 
+            2. 3-4 recomendaciones específicas y accionables (cada una de 1-2 frases)
+            3. Un ejemplo concreto de mejora tomado del propio texto del usuario
+            4. Una sugerencia sobre qué herramienta de AIdeaText usar (Análisis Morfosintáctico, Análisis Semántico o Análisis del Discurso)
+            
+            Tu respuesta debe ser concisa y no exceder los 300 palabras."""
+        else:
+            # Default to English
+            system_prompt = """You are an assistant specialized in analyzing academic texts and written communication.
+            Your task is to analyze the user's text and provide personalized recommendations.
+            Use a constructive and specific tone. Be clear and direct with your suggestions.
+            """
+            user_prompt = f"""Please analyze this text of type '{formatted_metrics['text_type']}' 
+            and provide personalized recommendations to improve it.
+            
+            ANALYSIS METRICS:
+            {json.dumps(formatted_metrics, indent=2, ensure_ascii=False)}
+            
+            TEXT TO ANALYZE:
+            {text[:2000]}  # Limiting text to avoid exceeding tokens
+            
+            Provide your analysis with the following format:
+            1. A brief summary (2-3 sentences) of the general analysis
+            2. 3-4 specific and actionable recommendations (each 1-2 sentences)
+            3. A concrete example of improvement taken from the user's own text
+            4. A suggestion about which AIdeaText tool to use (Morphosyntactic Analysis, Semantic Analysis or Discourse Analysis)
+            
+            Your response should be concise and not exceed 300 words."""
+        
+        # Initialize Claude client
+        client = anthropic.Anthropic(api_key=api_key)
+        
+        # Call Claude API
+        start_time = time.time()
+        response = client.messages.create(
+            model="claude-3-5-sonnet-20241022",
+            max_tokens=1024,
+            temperature=0.7,
+            system=system_prompt,
+            messages=[
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+        logger.info(f"Claude API call completed in {time.time() - start_time:.2f} seconds")
+        
+        # Extract recommendations
+        recommendations = response.content[0].text
+        
+        # Cache the result
+        recommendation_cache[cache_key] = recommendations
+        
+        return recommendations
+    except Exception as e:
+        logger.error(f"Error generating recommendations with Claude: {str(e)}")
+        return get_fallback_recommendations(lang_code)
+
+def get_fallback_recommendations(lang_code):
+    """
+    Return fallback recommendations if Claude API fails
+    """
+    if lang_code == 'es':
+        return """
+        **Análisis General**
+        Tu texto presenta una estructura básica adecuada, pero hay áreas que pueden mejorarse para mayor claridad y cohesión.
+
+        **Recomendaciones**:
+        - Intenta variar tu vocabulario para evitar repeticiones innecesarias
+        - Considera revisar la longitud de tus oraciones para mantener un mejor ritmo
+        - Asegúrate de establecer conexiones claras entre las ideas principales
+        - Revisa la consistencia en el uso de tiempos verbales
+
+        **Herramienta recomendada**: 
+        Te sugerimos utilizar el Análisis Morfosintáctico para identificar patrones en tu estructura de oraciones.
+        """
+    else:
+        return """
+        **General Analysis**
+        Your text presents an adequate basic structure, but there are areas that can be improved for better clarity and cohesion.
+        
+        **Recommendations**:
+        - Try to vary your vocabulary to avoid unnecessary repetition
+        - Consider reviewing the length of your sentences to maintain a better rhythm
+        - Make sure to establish clear connections between main ideas
+        - Check consistency in the use of verb tenses
+        
+        **Recommended tool**: 
+        We suggest using Morphosyntactic Analysis to identify patterns in your sentence structure.
+        """
+
+
+#######################################
+
+def store_recommendations(username, text, metrics, text_type, recommendations):
+    """
+    Store the recommendations in the database
+    """
+    try:
+        # Importar la función de almacenamiento de recomendaciones
+        from ..database.claude_recommendations_mongo_db import store_claude_recommendation
+        
+        # Guardar usando la nueva función especializada
+        result = store_claude_recommendation(
+            username=username,
+            text=text,
+            metrics=metrics,
+            text_type=text_type,
+            recommendations=recommendations
+        )
+        
+        logger.info(f"Recommendations stored successfully: {result}")
+        return result
+    except Exception as e:
+        logger.error(f"Error storing recommendations: {str(e)}")
+        return False
+
+
+##########################################
+##########################################
+def display_personalized_recommendations(text, metrics, text_type, lang_code, t):
+    """
+    Display personalized recommendations based on text analysis
+    """
+    try:
+        # Generate recommendations
+        recommendations = generate_claude_recommendations(text, metrics, text_type, lang_code)
+        
+        # Format and display recommendations in a nice container
+        st.markdown("### 📝 " + t.get('recommendations_title', 'Personalized Recommendations'))
+        
+        with st.container():
+            st.markdown(f"""
+            <div style="padding: 20px; border-radius: 10px; 
+                background-color: #f8f9fa; margin-bottom: 20px;">
+                {recommendations}
+            </div>
+            """, unsafe_allow_html=True)
+            
+            # Add prompt to use assistant
+            st.info("💡 **" + t.get('assistant_prompt', 'For further improvement:') + "** " + 
+                   t.get('assistant_message', 'Open the virtual assistant (powered by Claude AI) in the upper left corner by clicking the arrow next to the logo.'))
+            
+            # Add save button
+            col1, col2, col3 = st.columns([1,1,1])
+            with col2:
+                if st.button(
+                    t.get('save_button', 'Save Analysis'),
+                    key=generate_unique_key("claude_recommendations", "save"),
+                    type="primary",
+                    use_container_width=True
+                ):
+                    if 'username' in st.session_state:
+                        success = store_recommendations(
+                            st.session_state.username,
+                            text,
+                            metrics,
+                            text_type,
+                            recommendations
+                        )
+                        if success:
+                            st.success(t.get('save_success', 'Analysis saved successfully'))
+                        else:
+                            st.error(t.get('save_error', 'Error saving analysis'))
+                    else:
+                        st.error(t.get('login_required', 'Please log in to save analysis'))
+    
+    except Exception as e:
+        logger.error(f"Error displaying recommendations: {str(e)}")
+        st.error(t.get('recommendations_error', 'Error generating recommendations. Please try again later.'))

modules/studentact/current_situation_analysis-FAIL.py

@@ -1,810 +1,810 @@
-#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
-
-
-# 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
+
+
+# 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_analysis.py

@@ -1,810 +1,1008 @@
-#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
-
-
-# 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
+
+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

modules/studentact/current_situation_interface--FAIL.py

@@ -1,608 +1,608 @@
-# 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
-
-from ..database.writing_progress_mongo_db import (
-    store_writing_baseline,
-    store_writing_progress,
-    get_writing_baseline,
-    get_writing_progress,
-    get_latest_writing_metrics
-)
-
-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__)
-####################################
-
-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}
-        }
-    }
-}
-####################################
-
-ANALYSIS_DIMENSION_MAPPING = {
-    'morphosyntactic': {
-        'primary': ['vocabulary', 'clarity'],
-        'secondary': ['structure'],
-        'tools': ['arc_diagrams', 'word_repetition']
-    },
-    'semantic': {
-        'primary': ['cohesion', 'structure'],
-        'secondary': ['vocabulary'],
-        'tools': ['concept_graphs', 'semantic_networks']
-    },
-    'discourse': {
-        'primary': ['cohesion', 'structure'],
-        'secondary': ['clarity'],
-        'tools': ['comparative_analysis']
-    }
-}
-
-##############################################################################
-#                           FUNCIÓN PRINCIPAL
-##############################################################################
-def display_current_situation_interface(lang_code, nlp_models, t):
-    """
-    TAB:
-      - Expander con radio para tipo de texto
-    Contenedor-1 con expanders:
-       - Expander "Métricas de la línea base"
-       - Expander "Métricas de la iteración"
-    Contenedor-2 (2 columnas):
-       - Col1: Texto base
-       - Col2: Texto iteración
-    Al final, Recomendaciones en un expander (una sola “fila”).
-    """
-
-    # --- Inicializar session_state ---
-    if 'base_text' not in st.session_state:
-        st.session_state.base_text = ""
-    if 'iter_text' not in st.session_state:
-        st.session_state.iter_text = ""
-    if 'base_metrics' not in st.session_state:
-        st.session_state.base_metrics = {}
-    if 'iter_metrics' not in st.session_state:
-        st.session_state.iter_metrics = {}
-    if 'show_base' not in st.session_state:
-        st.session_state.show_base = False
-    if 'show_iter' not in st.session_state:
-        st.session_state.show_iter = False
-
-    # Creamos un tab
-    tabs = st.tabs(["Análisis de Texto"])
-    with tabs[0]:
-        # [1] Expander con radio para seleccionar tipo de texto
-        with st.expander("Selecciona el tipo de texto", expanded=True):
-            text_type = st.radio(
-                "¿Qué tipo de texto quieres analizar?",
-                options=list(TEXT_TYPES.keys()),
-                format_func=lambda x: TEXT_TYPES[x]['name'],
-                index=0
-            )
-            st.session_state.current_text_type = text_type
-
-        st.markdown("---")
-
-        # ---------------------------------------------------------------------
-        # CONTENEDOR-1: Expanders para métricas base e iteración
-        # ---------------------------------------------------------------------
-        with st.container():
-            # --- Expander para la línea base ---
-            with st.expander("Métricas de la línea base", expanded=False):
-                if st.session_state.show_base and st.session_state.base_metrics:
-                    # Mostramos los valores reales
-                    display_metrics_in_one_row(st.session_state.base_metrics, text_type)
-                else:
-                    # Mostramos la maqueta vacía
-                    display_empty_metrics_row()
-
-            # --- Expander para la iteración ---
-            with st.expander("Métricas de la iteración", expanded=False):
-                if st.session_state.show_iter and st.session_state.iter_metrics:
-                    display_metrics_in_one_row(st.session_state.iter_metrics, text_type)
-                else:
-                    display_empty_metrics_row()
-
-        st.markdown("---")
-
-        # ---------------------------------------------------------------------
-        # CONTENEDOR-2: 2 columnas (texto base | texto iteración)
-        # ---------------------------------------------------------------------
-        with st.container():
-            col_left, col_right = st.columns(2)
-
-            # Columna izquierda: Texto base
-            with col_left:
-                st.markdown("**Texto base**")
-                text_base = st.text_area(
-                    label="",
-                    value=st.session_state.base_text,
-                    key="text_base_area",
-                    placeholder="Pega aquí tu texto base",
-                )
-                if st.button("Analizar Base"):
-                    with st.spinner("Analizando texto base..."):
-                        doc = nlp_models[lang_code](text_base)
-                        metrics = analyze_text_dimensions(doc)
-
-                        st.session_state.base_text = text_base
-                        st.session_state.base_metrics = metrics
-                        st.session_state.show_base = True
-                        # Al analizar base, reiniciamos la iteración
-                        st.session_state.show_iter = False
-
-            # Columna derecha: Texto iteración
-            with col_right:
-                st.markdown("**Texto de iteración**")
-                text_iter = st.text_area(
-                    label="",
-                    value=st.session_state.iter_text,
-                    key="text_iter_area",
-                    placeholder="Edita y mejora tu texto...",
-                    disabled=not st.session_state.show_base
-                )
-                if st.button("Analizar Iteración", disabled=not st.session_state.show_base):
-                    with st.spinner("Analizando iteración..."):
-                        doc = nlp_models[lang_code](text_iter)
-                        metrics = analyze_text_dimensions(doc)
-
-                        st.session_state.iter_text = text_iter
-                        st.session_state.iter_metrics = metrics
-                        st.session_state.show_iter = True
-
-        # ---------------------------------------------------------------------
-        # Recomendaciones al final en un expander (una sola “fila”)
-        # ---------------------------------------------------------------------
-        if st.session_state.show_iter:
-            with st.expander("Recomendaciones", expanded=False):
-                reco_list = []
-                for dimension, values in st.session_state.iter_metrics.items():
-                    score = values['normalized_score']
-                    target = TEXT_TYPES[text_type]['thresholds'][dimension]['target']
-                    if score < target:
-                        # Aquí, en lugar de get_dimension_suggestions, unificamos con:
-                        suggestions = suggest_improvement_tools_list(dimension)
-                        reco_list.extend(suggestions)
-
-                if reco_list:
-                    # Todas en una sola línea
-                    st.write(" | ".join(reco_list))
-                else:
-                    st.info("¡No hay recomendaciones! Todas las métricas superan la meta.")
-
-
-
-
-
-
-
-#Funciones de visualización ##################################
-############################################################
-# Funciones de visualización para las métricas
-############################################################
-
-def display_metrics_in_one_row(metrics, text_type):
-    """
-    Muestra las cuatro dimensiones (Vocabulario, Estructura, Cohesión, Claridad)
-    en una sola línea, usando 4 columnas con ancho uniforme.
-    """
-    thresholds = TEXT_TYPES[text_type]['thresholds']
-    dimensions = ["vocabulary", "structure", "cohesion", "clarity"]
-
-    col1, col2, col3, col4 = st.columns([1,1,1,1])
-    cols = [col1, col2, col3, col4]
-
-    for dim, col in zip(dimensions, cols):
-        score = metrics[dim]['normalized_score']
-        target = thresholds[dim]['target']
-        min_val = thresholds[dim]['min']
-
-        if score < min_val:
-            status = "⚠️ Por mejorar"
-            color = "inverse"
-        elif score < target:
-            status = "📈 Aceptable"
-            color = "off"
-        else:
-            status = "✅ Óptimo"
-            color = "normal"
-
-        with col:
-            col.metric(
-                label=dim.capitalize(),
-                value=f"{score:.2f}",
-                delta=f"{status} (Meta: {target:.2f})",
-                delta_color=color,
-                border=True
-            )
-
-
-# -------------------------------------------------------------------------
-# Función que muestra una fila de 4 columnas “vacías”
-# -------------------------------------------------------------------------
-def display_empty_metrics_row():
-    """
-    Muestra una fila de 4 columnas vacías (Vocabulario, Estructura, Cohesión, Claridad).
-    Cada columna se dibuja con st.metric en blanco (“-”).
-    """
-    empty_cols = st.columns([1,1,1,1])
-    labels = ["Vocabulario", "Estructura", "Cohesión", "Claridad"]
-
-    for col, lbl in zip(empty_cols, labels):
-        with col:
-            col.metric(
-                label=lbl,
-                value="-",
-                delta="",
-                border=True
-            )
-
-
-
-####################################################################
-
-def display_metrics_analysis(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)
-
-    except Exception as e:
-        logger.error(f"Error mostrando resultados: {str(e)}")
-        st.error("Error al mostrar los resultados")
-
-def display_comparison_results(baseline_metrics, current_metrics):
-    """Muestra comparación entre línea base y métricas actuales"""
-    
-    # Crear columnas para métricas y gráfico
-    metrics_col, graph_col = st.columns([1, 1.5])
-    
-    with metrics_col:
-        for dimension in ['vocabulary', 'structure', 'cohesion', 'clarity']:
-            baseline = baseline_metrics[dimension]['normalized_score']
-            current = current_metrics[dimension]['normalized_score']
-            delta = current - baseline
-            
-            st.metric(
-                dimension.title(),
-                f"{current:.2f}",
-                f"{delta:+.2f}",
-                delta_color="normal" if delta >= 0 else "inverse"
-            )
-            
-            # Sugerir herramientas de mejora
-            if delta < 0:
-                suggest_improvement_tools(dimension)
-                
-    with graph_col:
-        display_radar_chart_comparison(
-            baseline_metrics,
-            current_metrics
-        )
-
-def display_metrics_and_suggestions(metrics, text_type, title, show_suggestions=False):
-    """
-    Muestra métricas y opcionalmente sugerencias de mejora.
-    Args:
-        metrics: Diccionario con las métricas analizadas
-        text_type: Tipo de texto seleccionado
-        title: Título para las métricas ("Base" o "Iteración")
-        show_suggestions: Booleano para mostrar sugerencias
-    """
-    try:
-        thresholds = TEXT_TYPES[text_type]['thresholds']
-        
-        st.markdown(f"### Métricas {title}")
-        
-        for dimension, values in metrics.items():
-            score = values['normalized_score']
-            target = thresholds[dimension]['target']
-            min_val = thresholds[dimension]['min']
-            
-            # Determinar estado y color
-            if score < min_val:
-                status = "⚠️ Por mejorar"
-                color = "inverse"
-            elif score < target:
-                status = "📈 Aceptable"
-                color = "off"
-            else:
-                status = "✅ Óptimo"
-                color = "normal"
-            
-            # Mostrar métrica
-            st.metric(
-                dimension.title(),
-                f"{score:.2f}",
-                f"{status} (Meta: {target:.2f})",
-                delta_color=color,
-                help=f"Meta: {target:.2f}, Mínimo: {min_val:.2f}"
-            )
-            
-            # Mostrar sugerencias si es necesario
-            if show_suggestions and score < target:
-                suggest_improvement_tools(dimension)
-            
-            # Agregar espacio entre métricas
-            st.markdown("<div style='margin-bottom: 0.5rem;'></div>", unsafe_allow_html=True)
-            
-    except Exception as e:
-        logger.error(f"Error mostrando métricas: {str(e)}")
-        st.error("Error al mostrar métricas")
-
-def display_radar_chart(metrics_config, thresholds, baseline_metrics=None):
-    """
-    Muestra el gráfico radar con los resultados.
-    Args:
-        metrics_config: Configuración actual de métricas
-        thresholds: Umbrales para las métricas
-        baseline_metrics: Métricas de línea base (opcional)
-    """
-    try:
-        # Preparar datos para el gráfico
-        categories = [m['label'] for m in metrics_config]
-        values_current = [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_current += values_current[: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)
-
-        # Si hay línea base, dibujarla primero
-        if baseline_metrics is not None:
-            values_baseline = [baseline_metrics[m['key']]['normalized_score'] 
-                             for m in metrics_config]
-            values_baseline += values_baseline[:1]
-            ax.plot(angles, values_baseline, '#888888', linewidth=2, 
-                   label='Línea base', linestyle='--')
-            ax.fill(angles, values_baseline, '#888888', alpha=0.1)
-
-        # Dibujar valores actuales
-        label = 'Actual' if baseline_metrics else 'Tu escritura'
-        color = '#3498db' if baseline_metrics else '#3498db'
-        
-        ax.plot(angles, values_current, color, linewidth=2, label=label)
-        ax.fill(angles, values_current, color, alpha=0.2)
-
-        # Ajustar leyenda
-        legend_handles = []
-        if baseline_metrics:
-            legend_handles.extend([
-                plt.Line2D([], [], color='#888888', linestyle='--', 
-                          label='Línea base'),
-                plt.Line2D([], [], color='#3498db', label='Actual')
-            ])
-        else:
-            legend_handles.extend([
-                plt.Line2D([], [], color='#3498db', label='Tu escritura')
-            ])
-        
-        legend_handles.extend([
-            plt.Line2D([], [], color='#e74c3c', linestyle='--', label='Mínimo'),
-            plt.Line2D([], [], color='#2ecc71', linestyle='--', label='Meta')
-        ])
-
-        ax.legend(
-            handles=legend_handles,
-            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")
-
-#Funciones auxiliares ##################################
-
-
-############################################################
-# Unificamos la lógica de sugerencias en una función
-############################################################
-def suggest_improvement_tools_list(dimension):
-    """
-    Retorna en forma de lista las herramientas sugeridas 
-    basadas en 'ANALYSIS_DIMENSION_MAPPING'.
-    """
-    suggestions = []
-    for analysis, mapping in ANALYSIS_DIMENSION_MAPPING.items():
-        # Verificamos si la dimensión está en primary o secondary
-        if dimension in mapping['primary'] or dimension in mapping['secondary']:
-            suggestions.extend(mapping['tools'])
-    # Si no hay nada, al menos retornamos un placeholder
-    return suggestions if suggestions else ["Sin sugerencias específicas."]
-
-        
-def prepare_metrics_config(metrics, text_type='student_essay'):
-    """
-    Prepara la configuración de métricas en el mismo formato que display_results.
-    Args:
-        metrics: Diccionario con las métricas analizadas
-        text_type: Tipo de texto para los umbrales
-    Returns:
-        list: Lista de configuraciones de métricas
-    """
-    # Obtener umbrales según el tipo de texto
-    thresholds = TEXT_TYPES[text_type]['thresholds']
-    
-    # Usar la misma estructura que en display_results
-    return [
-        {
-            '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']
-        }
-    ]        
-
+# 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
+
+from ..database.writing_progress_mongo_db import (
+    store_writing_baseline,
+    store_writing_progress,
+    get_writing_baseline,
+    get_writing_progress,
+    get_latest_writing_metrics
+)
+
+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__)
+####################################
+
+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}
+        }
+    }
+}
+####################################
+
+ANALYSIS_DIMENSION_MAPPING = {
+    'morphosyntactic': {
+        'primary': ['vocabulary', 'clarity'],
+        'secondary': ['structure'],
+        'tools': ['arc_diagrams', 'word_repetition']
+    },
+    'semantic': {
+        'primary': ['cohesion', 'structure'],
+        'secondary': ['vocabulary'],
+        'tools': ['concept_graphs', 'semantic_networks']
+    },
+    'discourse': {
+        'primary': ['cohesion', 'structure'],
+        'secondary': ['clarity'],
+        'tools': ['comparative_analysis']
+    }
+}
+
+##############################################################################
+#                           FUNCIÓN PRINCIPAL
+##############################################################################
+def display_current_situation_interface(lang_code, nlp_models, t):
+    """
+    TAB:
+      - Expander con radio para tipo de texto
+    Contenedor-1 con expanders:
+       - Expander "Métricas de la línea base"
+       - Expander "Métricas de la iteración"
+    Contenedor-2 (2 columnas):
+       - Col1: Texto base
+       - Col2: Texto iteración
+    Al final, Recomendaciones en un expander (una sola “fila”).
+    """
+
+    # --- Inicializar session_state ---
+    if 'base_text' not in st.session_state:
+        st.session_state.base_text = ""
+    if 'iter_text' not in st.session_state:
+        st.session_state.iter_text = ""
+    if 'base_metrics' not in st.session_state:
+        st.session_state.base_metrics = {}
+    if 'iter_metrics' not in st.session_state:
+        st.session_state.iter_metrics = {}
+    if 'show_base' not in st.session_state:
+        st.session_state.show_base = False
+    if 'show_iter' not in st.session_state:
+        st.session_state.show_iter = False
+
+    # Creamos un tab
+    tabs = st.tabs(["Análisis de Texto"])
+    with tabs[0]:
+        # [1] Expander con radio para seleccionar tipo de texto
+        with st.expander("Selecciona el tipo de texto", expanded=True):
+            text_type = st.radio(
+                "¿Qué tipo de texto quieres analizar?",
+                options=list(TEXT_TYPES.keys()),
+                format_func=lambda x: TEXT_TYPES[x]['name'],
+                index=0
+            )
+            st.session_state.current_text_type = text_type
+
+        st.markdown("---")
+
+        # ---------------------------------------------------------------------
+        # CONTENEDOR-1: Expanders para métricas base e iteración
+        # ---------------------------------------------------------------------
+        with st.container():
+            # --- Expander para la línea base ---
+            with st.expander("Métricas de la línea base", expanded=False):
+                if st.session_state.show_base and st.session_state.base_metrics:
+                    # Mostramos los valores reales
+                    display_metrics_in_one_row(st.session_state.base_metrics, text_type)
+                else:
+                    # Mostramos la maqueta vacía
+                    display_empty_metrics_row()
+
+            # --- Expander para la iteración ---
+            with st.expander("Métricas de la iteración", expanded=False):
+                if st.session_state.show_iter and st.session_state.iter_metrics:
+                    display_metrics_in_one_row(st.session_state.iter_metrics, text_type)
+                else:
+                    display_empty_metrics_row()
+
+        st.markdown("---")
+
+        # ---------------------------------------------------------------------
+        # CONTENEDOR-2: 2 columnas (texto base | texto iteración)
+        # ---------------------------------------------------------------------
+        with st.container():
+            col_left, col_right = st.columns(2)
+
+            # Columna izquierda: Texto base
+            with col_left:
+                st.markdown("**Texto base**")
+                text_base = st.text_area(
+                    label="",
+                    value=st.session_state.base_text,
+                    key="text_base_area",
+                    placeholder="Pega aquí tu texto base",
+                )
+                if st.button("Analizar Base"):
+                    with st.spinner("Analizando texto base..."):
+                        doc = nlp_models[lang_code](text_base)
+                        metrics = analyze_text_dimensions(doc)
+
+                        st.session_state.base_text = text_base
+                        st.session_state.base_metrics = metrics
+                        st.session_state.show_base = True
+                        # Al analizar base, reiniciamos la iteración
+                        st.session_state.show_iter = False
+
+            # Columna derecha: Texto iteración
+            with col_right:
+                st.markdown("**Texto de iteración**")
+                text_iter = st.text_area(
+                    label="",
+                    value=st.session_state.iter_text,
+                    key="text_iter_area",
+                    placeholder="Edita y mejora tu texto...",
+                    disabled=not st.session_state.show_base
+                )
+                if st.button("Analizar Iteración", disabled=not st.session_state.show_base):
+                    with st.spinner("Analizando iteración..."):
+                        doc = nlp_models[lang_code](text_iter)
+                        metrics = analyze_text_dimensions(doc)
+
+                        st.session_state.iter_text = text_iter
+                        st.session_state.iter_metrics = metrics
+                        st.session_state.show_iter = True
+
+        # ---------------------------------------------------------------------
+        # Recomendaciones al final en un expander (una sola “fila”)
+        # ---------------------------------------------------------------------
+        if st.session_state.show_iter:
+            with st.expander("Recomendaciones", expanded=False):
+                reco_list = []
+                for dimension, values in st.session_state.iter_metrics.items():
+                    score = values['normalized_score']
+                    target = TEXT_TYPES[text_type]['thresholds'][dimension]['target']
+                    if score < target:
+                        # Aquí, en lugar de get_dimension_suggestions, unificamos con:
+                        suggestions = suggest_improvement_tools_list(dimension)
+                        reco_list.extend(suggestions)
+
+                if reco_list:
+                    # Todas en una sola línea
+                    st.write(" | ".join(reco_list))
+                else:
+                    st.info("¡No hay recomendaciones! Todas las métricas superan la meta.")
+
+
+
+
+
+
+
+#Funciones de visualización ##################################
+############################################################
+# Funciones de visualización para las métricas
+############################################################
+
+def display_metrics_in_one_row(metrics, text_type):
+    """
+    Muestra las cuatro dimensiones (Vocabulario, Estructura, Cohesión, Claridad)
+    en una sola línea, usando 4 columnas con ancho uniforme.
+    """
+    thresholds = TEXT_TYPES[text_type]['thresholds']
+    dimensions = ["vocabulary", "structure", "cohesion", "clarity"]
+
+    col1, col2, col3, col4 = st.columns([1,1,1,1])
+    cols = [col1, col2, col3, col4]
+
+    for dim, col in zip(dimensions, cols):
+        score = metrics[dim]['normalized_score']
+        target = thresholds[dim]['target']
+        min_val = thresholds[dim]['min']
+
+        if score < min_val:
+            status = "⚠️ Por mejorar"
+            color = "inverse"
+        elif score < target:
+            status = "📈 Aceptable"
+            color = "off"
+        else:
+            status = "✅ Óptimo"
+            color = "normal"
+
+        with col:
+            col.metric(
+                label=dim.capitalize(),
+                value=f"{score:.2f}",
+                delta=f"{status} (Meta: {target:.2f})",
+                delta_color=color,
+                border=True
+            )
+
+
+# -------------------------------------------------------------------------
+# Función que muestra una fila de 4 columnas “vacías”
+# -------------------------------------------------------------------------
+def display_empty_metrics_row():
+    """
+    Muestra una fila de 4 columnas vacías (Vocabulario, Estructura, Cohesión, Claridad).
+    Cada columna se dibuja con st.metric en blanco (“-”).
+    """
+    empty_cols = st.columns([1,1,1,1])
+    labels = ["Vocabulario", "Estructura", "Cohesión", "Claridad"]
+
+    for col, lbl in zip(empty_cols, labels):
+        with col:
+            col.metric(
+                label=lbl,
+                value="-",
+                delta="",
+                border=True
+            )
+
+
+
+####################################################################
+
+def display_metrics_analysis(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)
+
+    except Exception as e:
+        logger.error(f"Error mostrando resultados: {str(e)}")
+        st.error("Error al mostrar los resultados")
+
+def display_comparison_results(baseline_metrics, current_metrics):
+    """Muestra comparación entre línea base y métricas actuales"""
+    
+    # Crear columnas para métricas y gráfico
+    metrics_col, graph_col = st.columns([1, 1.5])
+    
+    with metrics_col:
+        for dimension in ['vocabulary', 'structure', 'cohesion', 'clarity']:
+            baseline = baseline_metrics[dimension]['normalized_score']
+            current = current_metrics[dimension]['normalized_score']
+            delta = current - baseline
+            
+            st.metric(
+                dimension.title(),
+                f"{current:.2f}",
+                f"{delta:+.2f}",
+                delta_color="normal" if delta >= 0 else "inverse"
+            )
+            
+            # Sugerir herramientas de mejora
+            if delta < 0:
+                suggest_improvement_tools(dimension)
+                
+    with graph_col:
+        display_radar_chart_comparison(
+            baseline_metrics,
+            current_metrics
+        )
+
+def display_metrics_and_suggestions(metrics, text_type, title, show_suggestions=False):
+    """
+    Muestra métricas y opcionalmente sugerencias de mejora.
+    Args:
+        metrics: Diccionario con las métricas analizadas
+        text_type: Tipo de texto seleccionado
+        title: Título para las métricas ("Base" o "Iteración")
+        show_suggestions: Booleano para mostrar sugerencias
+    """
+    try:
+        thresholds = TEXT_TYPES[text_type]['thresholds']
+        
+        st.markdown(f"### Métricas {title}")
+        
+        for dimension, values in metrics.items():
+            score = values['normalized_score']
+            target = thresholds[dimension]['target']
+            min_val = thresholds[dimension]['min']
+            
+            # Determinar estado y color
+            if score < min_val:
+                status = "⚠️ Por mejorar"
+                color = "inverse"
+            elif score < target:
+                status = "📈 Aceptable"
+                color = "off"
+            else:
+                status = "✅ Óptimo"
+                color = "normal"
+            
+            # Mostrar métrica
+            st.metric(
+                dimension.title(),
+                f"{score:.2f}",
+                f"{status} (Meta: {target:.2f})",
+                delta_color=color,
+                help=f"Meta: {target:.2f}, Mínimo: {min_val:.2f}"
+            )
+            
+            # Mostrar sugerencias si es necesario
+            if show_suggestions and score < target:
+                suggest_improvement_tools(dimension)
+            
+            # Agregar espacio entre métricas
+            st.markdown("<div style='margin-bottom: 0.5rem;'></div>", unsafe_allow_html=True)
+            
+    except Exception as e:
+        logger.error(f"Error mostrando métricas: {str(e)}")
+        st.error("Error al mostrar métricas")
+
+def display_radar_chart(metrics_config, thresholds, baseline_metrics=None):
+    """
+    Muestra el gráfico radar con los resultados.
+    Args:
+        metrics_config: Configuración actual de métricas
+        thresholds: Umbrales para las métricas
+        baseline_metrics: Métricas de línea base (opcional)
+    """
+    try:
+        # Preparar datos para el gráfico
+        categories = [m['label'] for m in metrics_config]
+        values_current = [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_current += values_current[: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)
+
+        # Si hay línea base, dibujarla primero
+        if baseline_metrics is not None:
+            values_baseline = [baseline_metrics[m['key']]['normalized_score'] 
+                             for m in metrics_config]
+            values_baseline += values_baseline[:1]
+            ax.plot(angles, values_baseline, '#888888', linewidth=2, 
+                   label='Línea base', linestyle='--')
+            ax.fill(angles, values_baseline, '#888888', alpha=0.1)
+
+        # Dibujar valores actuales
+        label = 'Actual' if baseline_metrics else 'Tu escritura'
+        color = '#3498db' if baseline_metrics else '#3498db'
+        
+        ax.plot(angles, values_current, color, linewidth=2, label=label)
+        ax.fill(angles, values_current, color, alpha=0.2)
+
+        # Ajustar leyenda
+        legend_handles = []
+        if baseline_metrics:
+            legend_handles.extend([
+                plt.Line2D([], [], color='#888888', linestyle='--', 
+                          label='Línea base'),
+                plt.Line2D([], [], color='#3498db', label='Actual')
+            ])
+        else:
+            legend_handles.extend([
+                plt.Line2D([], [], color='#3498db', label='Tu escritura')
+            ])
+        
+        legend_handles.extend([
+            plt.Line2D([], [], color='#e74c3c', linestyle='--', label='Mínimo'),
+            plt.Line2D([], [], color='#2ecc71', linestyle='--', label='Meta')
+        ])
+
+        ax.legend(
+            handles=legend_handles,
+            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")
+
+#Funciones auxiliares ##################################
+
+
+############################################################
+# Unificamos la lógica de sugerencias en una función
+############################################################
+def suggest_improvement_tools_list(dimension):
+    """
+    Retorna en forma de lista las herramientas sugeridas 
+    basadas en 'ANALYSIS_DIMENSION_MAPPING'.
+    """
+    suggestions = []
+    for analysis, mapping in ANALYSIS_DIMENSION_MAPPING.items():
+        # Verificamos si la dimensión está en primary o secondary
+        if dimension in mapping['primary'] or dimension in mapping['secondary']:
+            suggestions.extend(mapping['tools'])
+    # Si no hay nada, al menos retornamos un placeholder
+    return suggestions if suggestions else ["Sin sugerencias específicas."]
+
+        
+def prepare_metrics_config(metrics, text_type='student_essay'):
+    """
+    Prepara la configuración de métricas en el mismo formato que display_results.
+    Args:
+        metrics: Diccionario con las métricas analizadas
+        text_type: Tipo de texto para los umbrales
+    Returns:
+        list: Lista de configuraciones de métricas
+    """
+    # Obtener umbrales según el tipo de texto
+    thresholds = TEXT_TYPES[text_type]['thresholds']
+    
+    # Usar la misma estructura que en display_results
+    return [
+        {
+            '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']
+        }
+    ]        
+

modules/studentact/current_situation_interface-v1.py

@@ -1,272 +1,272 @@
-# modules/studentact/current_situation_interface.py
-
-import streamlit as st
-import logging
-from ..utils.widget_utils import generate_unique_key
-from .current_situation_analysis import (
-    analyze_text_dimensions, 
-    analyze_clarity,
-    analyze_reference_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,     
-)
-
-logger = logging.getLogger(__name__)
-####################################
-def display_current_situation_interface(lang_code, nlp_models, t):
-    """
-    Interfaz simplificada para el análisis inicial, enfocada en recomendaciones directas.
-    """
-    # Inicializar estados si no existen
-    if 'text_input' not in st.session_state:
-        st.session_state.text_input = ""
-    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
-
-    st.markdown("## Análisis Inicial de Escritura")
-    
-    # Container principal con dos columnas
-    with st.container():
-        input_col, results_col = st.columns([1,2])
-        
-        with input_col:
-            st.markdown("### Ingresa tu texto")
-            
-            # Función para manejar cambios en el texto
-            def on_text_change():
-                st.session_state.text_input = st.session_state.text_area
-                st.session_state.show_results = False  # Resetear resultados cuando el texto cambia
-            
-            # 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,
-                on_change=on_text_change,
-                help="Este texto será analizado para darte recomendaciones personalizadas"
-            )
-            
-            # Botón de análisis
-            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...")):
-                        # Procesar texto y obtener métricas
-                        doc = nlp_models[lang_code](text_input)
-                        metrics = analyze_text_dimensions(doc)
-                        
-                        # Actualizar estado con nuevos resultados
-                        st.session_state.current_doc = doc
-                        st.session_state.current_metrics = metrics
-                        st.session_state.show_results = True
-                        
-                        # Mantener el texto en el estado
-                        st.session_state.text_input = text_input
-                        
-                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:
-                display_recommendations(st.session_state.current_metrics, t)
-                
-                # Opción para ver detalles
-                with st.expander("🔍 Ver análisis detallado", expanded=False):
-                    display_current_situation_visual(
-                        st.session_state.current_doc,
-                        st.session_state.current_metrics
-                    )
-
-def display_current_situation_visual(doc, metrics):
-    """
-    Muestra visualizaciones detalladas del análisis.
-    """
-    try:
-        st.markdown("### 📊 Visualizaciones Detalladas")
-        
-        # 1. Visualización de vocabulario
-        with st.expander("Análisis de Vocabulario", expanded=True):
-            vocab_graph = create_vocabulary_network(doc)
-            if vocab_graph:
-                st.pyplot(vocab_graph)
-                plt.close(vocab_graph)
-        
-        # 2. Visualización de estructura
-        with st.expander("Análisis de Estructura", expanded=True):
-            syntax_graph = create_syntax_complexity_graph(doc)
-            if syntax_graph:
-                st.pyplot(syntax_graph)
-                plt.close(syntax_graph)
-        
-        # 3. Visualización de cohesión
-        with st.expander("Análisis de Cohesión", expanded=True):
-            cohesion_graph = create_cohesion_heatmap(doc)
-            if cohesion_graph:
-                st.pyplot(cohesion_graph)
-                plt.close(cohesion_graph)
-
-    except Exception as e:
-        logger.error(f"Error en visualización: {str(e)}")
-        st.error("Error al generar las visualizaciones")
-
-
-####################################
-def display_recommendations(metrics, t):
-    """
-    Muestra recomendaciones basadas en las métricas del texto.
-    """
-    # 1. Resumen Visual con Explicación
-    st.markdown("### 📊 Resumen de tu Análisis")
-    
-    # Explicación del sistema de medición
-    st.markdown("""
-        **¿Cómo interpretar los resultados?**
-        
-        Cada métrica se mide en una escala de 0.0 a 1.0, donde:
-        - 0.0 - 0.4: Necesita atención prioritaria
-        - 0.4 - 0.6: En desarrollo
-        - 0.6 - 0.8: Buen nivel
-        - 0.8 - 1.0: Nivel avanzado
-    """)
-
-    # Métricas con explicaciones detalladas
-    col1, col2, col3, col4 = st.columns(4)
-    
-    with col1:
-        st.metric(
-            "Vocabulario",
-            f"{metrics['vocabulary']['normalized_score']:.2f}",
-            help="Mide la variedad y riqueza de tu vocabulario. Un valor alto indica un uso diverso de palabras sin repeticiones excesivas."
-        )
-        with st.expander("ℹ️ Detalles"):
-            st.write("""
-                **Vocabulario**
-                - Evalúa la diversidad léxica
-                - Considera palabras únicas vs. totales
-                - Detecta repeticiones innecesarias
-                - Valor óptimo: > 0.7
-            """)
-    
-    with col2:
-        st.metric(
-            "Estructura",
-            f"{metrics['structure']['normalized_score']:.2f}",
-            help="Evalúa la complejidad y variedad de las estructuras sintácticas en tus oraciones."
-        )
-        with st.expander("ℹ️ Detalles"):
-            st.write("""
-                **Estructura**
-                - Analiza la complejidad sintáctica
-                - Mide variación en construcciones
-                - Evalúa longitud de oraciones
-                - Valor óptimo: > 0.6
-            """)
-    
-    with col3:
-        st.metric(
-            "Cohesión",
-            f"{metrics['cohesion']['normalized_score']:.2f}",
-            help="Indica qué tan bien conectadas están tus ideas y párrafos entre sí."
-        )
-        with st.expander("ℹ️ Detalles"):
-            st.write("""
-                **Cohesión**
-                - Mide conexiones entre ideas
-                - Evalúa uso de conectores
-                - Analiza progresión temática
-                - Valor óptimo: > 0.65
-            """)
-    
-    with col4:
-        st.metric(
-            "Claridad",
-            f"{metrics['clarity']['normalized_score']:.2f}",
-            help="Evalúa la facilidad de comprensión general de tu texto."
-        )
-        with st.expander("ℹ️ Detalles"):
-            st.write("""
-                **Claridad**
-                - Evalúa comprensibilidad
-                - Considera estructura lógica
-                - Mide precisión expresiva
-                - Valor óptimo: > 0.7
-            """)
-
-    st.markdown("---")
-
-    # 2. Recomendaciones basadas en puntuaciones
-    st.markdown("### 💡 Recomendaciones Personalizadas")
-    
-    # Recomendaciones morfosintácticas
-    if metrics['structure']['normalized_score'] < 0.6:
-        st.warning("""
-        #### 📝 Análisis Morfosintáctico Recomendado
-        
-        **Tu nivel actual sugiere que sería beneficioso:**
-        1. Realizar el análisis morfosintáctico de 3 párrafos diferentes
-        2. Practicar la combinación de oraciones simples en compuestas
-        3. Identificar y clasificar tipos de oraciones en textos académicos
-        4. Ejercitar la variación sintáctica
-        
-        *Hacer clic en "Comenzar ejercicios" para acceder al módulo morfosintáctico*
-        """)
-        
-    # Recomendaciones semánticas
-    if metrics['vocabulary']['normalized_score'] < 0.7:
-        st.warning("""
-        #### 📚 Análisis Semántico Recomendado
-        
-        **Para mejorar tu vocabulario y expresión:**
-        A. Realiza el análisis semántico de un texto académico
-        B. Identifica y agrupa campos semánticos relacionados
-        C. Practica la sustitución léxica en tus párrafos
-        D. Construye redes de conceptos sobre tu tema
-        E. Analiza las relaciones entre ideas principales
-        
-        *Hacer clic en "Comenzar ejercicios" para acceder al módulo semántico*
-        """)
-    
-    # Recomendaciones de cohesión
-    if metrics['cohesion']['normalized_score'] < 0.65:
-        st.warning("""
-        #### 🔄 Análisis del Discurso Recomendado
-        
-        **Para mejorar la conexión entre ideas:**
-        1. Realizar el análisis del discurso de un texto modelo
-        2. Practicar el uso de diferentes conectores textuales
-        3. Identificar cadenas de referencia en textos académicos
-        4. Ejercitar la progresión temática en tus escritos
-        
-        *Hacer clic en "Comenzar ejercicios" para acceder al módulo de análisis del discurso*
-        """)
-    
-    # Botón de acción
-    st.markdown("---")
-    col1, col2, col3 = st.columns([1,2,1])
-    with col2:
-        st.button(
-            "🎯 Comenzar ejercicios recomendados",
-            type="primary",
-            use_container_width=True,
-            key="start_exercises"
+# modules/studentact/current_situation_interface.py
+
+import streamlit as st
+import logging
+from ..utils.widget_utils import generate_unique_key
+from .current_situation_analysis import (
+    analyze_text_dimensions, 
+    analyze_clarity,
+    analyze_reference_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,     
+)
+
+logger = logging.getLogger(__name__)
+####################################
+def display_current_situation_interface(lang_code, nlp_models, t):
+    """
+    Interfaz simplificada para el análisis inicial, enfocada en recomendaciones directas.
+    """
+    # Inicializar estados si no existen
+    if 'text_input' not in st.session_state:
+        st.session_state.text_input = ""
+    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
+
+    st.markdown("## Análisis Inicial de Escritura")
+    
+    # Container principal con dos columnas
+    with st.container():
+        input_col, results_col = st.columns([1,2])
+        
+        with input_col:
+            st.markdown("### Ingresa tu texto")
+            
+            # Función para manejar cambios en el texto
+            def on_text_change():
+                st.session_state.text_input = st.session_state.text_area
+                st.session_state.show_results = False  # Resetear resultados cuando el texto cambia
+            
+            # 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,
+                on_change=on_text_change,
+                help="Este texto será analizado para darte recomendaciones personalizadas"
+            )
+            
+            # Botón de análisis
+            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...")):
+                        # Procesar texto y obtener métricas
+                        doc = nlp_models[lang_code](text_input)
+                        metrics = analyze_text_dimensions(doc)
+                        
+                        # Actualizar estado con nuevos resultados
+                        st.session_state.current_doc = doc
+                        st.session_state.current_metrics = metrics
+                        st.session_state.show_results = True
+                        
+                        # Mantener el texto en el estado
+                        st.session_state.text_input = text_input
+                        
+                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:
+                display_recommendations(st.session_state.current_metrics, t)
+                
+                # Opción para ver detalles
+                with st.expander("🔍 Ver análisis detallado", expanded=False):
+                    display_current_situation_visual(
+                        st.session_state.current_doc,
+                        st.session_state.current_metrics
+                    )
+
+def display_current_situation_visual(doc, metrics):
+    """
+    Muestra visualizaciones detalladas del análisis.
+    """
+    try:
+        st.markdown("### 📊 Visualizaciones Detalladas")
+        
+        # 1. Visualización de vocabulario
+        with st.expander("Análisis de Vocabulario", expanded=True):
+            vocab_graph = create_vocabulary_network(doc)
+            if vocab_graph:
+                st.pyplot(vocab_graph)
+                plt.close(vocab_graph)
+        
+        # 2. Visualización de estructura
+        with st.expander("Análisis de Estructura", expanded=True):
+            syntax_graph = create_syntax_complexity_graph(doc)
+            if syntax_graph:
+                st.pyplot(syntax_graph)
+                plt.close(syntax_graph)
+        
+        # 3. Visualización de cohesión
+        with st.expander("Análisis de Cohesión", expanded=True):
+            cohesion_graph = create_cohesion_heatmap(doc)
+            if cohesion_graph:
+                st.pyplot(cohesion_graph)
+                plt.close(cohesion_graph)
+
+    except Exception as e:
+        logger.error(f"Error en visualización: {str(e)}")
+        st.error("Error al generar las visualizaciones")
+
+
+####################################
+def display_recommendations(metrics, t):
+    """
+    Muestra recomendaciones basadas en las métricas del texto.
+    """
+    # 1. Resumen Visual con Explicación
+    st.markdown("### 📊 Resumen de tu Análisis")
+    
+    # Explicación del sistema de medición
+    st.markdown("""
+        **¿Cómo interpretar los resultados?**
+        
+        Cada métrica se mide en una escala de 0.0 a 1.0, donde:
+        - 0.0 - 0.4: Necesita atención prioritaria
+        - 0.4 - 0.6: En desarrollo
+        - 0.6 - 0.8: Buen nivel
+        - 0.8 - 1.0: Nivel avanzado
+    """)
+
+    # Métricas con explicaciones detalladas
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric(
+            "Vocabulario",
+            f"{metrics['vocabulary']['normalized_score']:.2f}",
+            help="Mide la variedad y riqueza de tu vocabulario. Un valor alto indica un uso diverso de palabras sin repeticiones excesivas."
+        )
+        with st.expander("ℹ️ Detalles"):
+            st.write("""
+                **Vocabulario**
+                - Evalúa la diversidad léxica
+                - Considera palabras únicas vs. totales
+                - Detecta repeticiones innecesarias
+                - Valor óptimo: > 0.7
+            """)
+    
+    with col2:
+        st.metric(
+            "Estructura",
+            f"{metrics['structure']['normalized_score']:.2f}",
+            help="Evalúa la complejidad y variedad de las estructuras sintácticas en tus oraciones."
+        )
+        with st.expander("ℹ️ Detalles"):
+            st.write("""
+                **Estructura**
+                - Analiza la complejidad sintáctica
+                - Mide variación en construcciones
+                - Evalúa longitud de oraciones
+                - Valor óptimo: > 0.6
+            """)
+    
+    with col3:
+        st.metric(
+            "Cohesión",
+            f"{metrics['cohesion']['normalized_score']:.2f}",
+            help="Indica qué tan bien conectadas están tus ideas y párrafos entre sí."
+        )
+        with st.expander("ℹ️ Detalles"):
+            st.write("""
+                **Cohesión**
+                - Mide conexiones entre ideas
+                - Evalúa uso de conectores
+                - Analiza progresión temática
+                - Valor óptimo: > 0.65
+            """)
+    
+    with col4:
+        st.metric(
+            "Claridad",
+            f"{metrics['clarity']['normalized_score']:.2f}",
+            help="Evalúa la facilidad de comprensión general de tu texto."
+        )
+        with st.expander("ℹ️ Detalles"):
+            st.write("""
+                **Claridad**
+                - Evalúa comprensibilidad
+                - Considera estructura lógica
+                - Mide precisión expresiva
+                - Valor óptimo: > 0.7
+            """)
+
+    st.markdown("---")
+
+    # 2. Recomendaciones basadas en puntuaciones
+    st.markdown("### 💡 Recomendaciones Personalizadas")
+    
+    # Recomendaciones morfosintácticas
+    if metrics['structure']['normalized_score'] < 0.6:
+        st.warning("""
+        #### 📝 Análisis Morfosintáctico Recomendado
+        
+        **Tu nivel actual sugiere que sería beneficioso:**
+        1. Realizar el análisis morfosintáctico de 3 párrafos diferentes
+        2. Practicar la combinación de oraciones simples en compuestas
+        3. Identificar y clasificar tipos de oraciones en textos académicos
+        4. Ejercitar la variación sintáctica
+        
+        *Hacer clic en "Comenzar ejercicios" para acceder al módulo morfosintáctico*
+        """)
+        
+    # Recomendaciones semánticas
+    if metrics['vocabulary']['normalized_score'] < 0.7:
+        st.warning("""
+        #### 📚 Análisis Semántico Recomendado
+        
+        **Para mejorar tu vocabulario y expresión:**
+        A. Realiza el análisis semántico de un texto académico
+        B. Identifica y agrupa campos semánticos relacionados
+        C. Practica la sustitución léxica en tus párrafos
+        D. Construye redes de conceptos sobre tu tema
+        E. Analiza las relaciones entre ideas principales
+        
+        *Hacer clic en "Comenzar ejercicios" para acceder al módulo semántico*
+        """)
+    
+    # Recomendaciones de cohesión
+    if metrics['cohesion']['normalized_score'] < 0.65:
+        st.warning("""
+        #### 🔄 Análisis del Discurso Recomendado
+        
+        **Para mejorar la conexión entre ideas:**
+        1. Realizar el análisis del discurso de un texto modelo
+        2. Practicar el uso de diferentes conectores textuales
+        3. Identificar cadenas de referencia en textos académicos
+        4. Ejercitar la progresión temática en tus escritos
+        
+        *Hacer clic en "Comenzar ejercicios" para acceder al módulo de análisis del discurso*
+        """)
+    
+    # Botón de acción
+    st.markdown("---")
+    col1, col2, col3 = st.columns([1,2,1])
+    with col2:
+        st.button(
+            "🎯 Comenzar ejercicios recomendados",
+            type="primary",
+            use_container_width=True,
+            key="start_exercises"
         )

modules/studentact/current_situation_interface-v2.py

@@ -1,291 +1,291 @@
-# modules/studentact/current_situation_interface.py
-
-import streamlit as st
-import logging
-from ..utils.widget_utils import generate_unique_key
-
-from ..database.current_situation_mongo_db import store_current_situation_result
-
-from .current_situation_analysis import (
-    analyze_text_dimensions, 
-    analyze_clarity,
-    analyze_reference_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,     
-)
-
-logger = logging.getLogger(__name__)
-####################################
-
-def display_current_situation_interface(lang_code, nlp_models, t):
-    """
-    Interfaz simplificada para el análisis inicial, enfocada en recomendaciones directas.
-    """
-    try:
-        # Inicializar estados si no existen
-        if 'text_input' not in st.session_state:
-            st.session_state.text_input = ""
-        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
-
-        st.markdown("## Análisis Inicial de Escritura")
-        
-        # Container principal con dos columnas
-        with st.container():
-            input_col, results_col = st.columns([1,2])
-            
-            with input_col:
-                st.markdown("### Ingresa tu texto")
-                
-                # Función para manejar cambios en el texto
-                def on_text_change():
-                    st.session_state.text_input = st.session_state.text_area
-                    st.session_state.show_results = False  # Resetear resultados cuando el texto cambia
-                
-                # 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,
-                    on_change=on_text_change,
-                    help="Este texto será analizado para darte recomendaciones personalizadas"
-                )
-                
-                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...")):
-                            # Procesar texto y obtener métricas
-                            doc = nlp_models[lang_code](text_input)
-                            metrics = analyze_text_dimensions(doc)
-                            
-                            # Guardar en MongoDB
-                            storage_success = store_current_situation_result(
-                                username=st.session_state.username,
-                                text=text_input,
-                                metrics=metrics,
-                                feedback=None  # Por ahora sin feedback
-                            )
-                            
-                            if not storage_success:
-                                logger.warning("No se pudo guardar el análisis en la base de datos")
-                            
-                            # Actualizar estado
-                            st.session_state.current_doc = doc
-                            st.session_state.current_metrics = metrics
-                            st.session_state.show_results = True
-                            st.session_state.text_input = text_input
-                            
-                    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:
-                    display_recommendations(st.session_state.current_metrics, t)
-                    
-                    # Opción para ver detalles
-                    with st.expander("🔍 Ver análisis detallado", expanded=False):
-                        display_current_situation_visual(
-                            st.session_state.current_doc,
-                            st.session_state.current_metrics
-                        )
-                        
-    except Exception as e:
-        logger.error(f"Error en interfaz: {str(e)}")
-        st.error("Ocurrió un error. Por favor, intente de nuevo.")
-
-
-
-def display_current_situation_visual(doc, metrics):
-    """
-    Muestra visualizaciones detalladas del análisis.
-    """
-    try:
-        st.markdown("### 📊 Visualizaciones Detalladas")
-        
-        # 1. Visualización de vocabulario
-        with st.expander("Análisis de Vocabulario", expanded=True):
-            vocab_graph = create_vocabulary_network(doc)
-            if vocab_graph:
-                st.pyplot(vocab_graph)
-                plt.close(vocab_graph)
-        
-        # 2. Visualización de estructura
-        with st.expander("Análisis de Estructura", expanded=True):
-            syntax_graph = create_syntax_complexity_graph(doc)
-            if syntax_graph:
-                st.pyplot(syntax_graph)
-                plt.close(syntax_graph)
-        
-        # 3. Visualización de cohesión
-        with st.expander("Análisis de Cohesión", expanded=True):
-            cohesion_graph = create_cohesion_heatmap(doc)
-            if cohesion_graph:
-                st.pyplot(cohesion_graph)
-                plt.close(cohesion_graph)
-
-    except Exception as e:
-        logger.error(f"Error en visualización: {str(e)}")
-        st.error("Error al generar las visualizaciones")
-
-
-####################################
-def display_recommendations(metrics, t):
-    """
-    Muestra recomendaciones basadas en las métricas del texto.
-    """
-    # 1. Resumen Visual con Explicación
-    st.markdown("### 📊 Resumen de tu Análisis")
-    
-    # Explicación del sistema de medición
-    st.markdown("""
-        **¿Cómo interpretar los resultados?**
-        
-        Cada métrica se mide en una escala de 0.0 a 1.0, donde:
-        - 0.0 - 0.4: Necesita atención prioritaria
-        - 0.4 - 0.6: En desarrollo
-        - 0.6 - 0.8: Buen nivel
-        - 0.8 - 1.0: Nivel avanzado
-    """)
-
-    # Métricas con explicaciones detalladas
-    col1, col2, col3, col4 = st.columns(4)
-    
-    with col1:
-        st.metric(
-            "Vocabulario",
-            f"{metrics['vocabulary']['normalized_score']:.2f}",
-            help="Mide la variedad y riqueza de tu vocabulario. Un valor alto indica un uso diverso de palabras sin repeticiones excesivas."
-        )
-        with st.expander("ℹ️ Detalles"):
-            st.write("""
-                **Vocabulario**
-                - Evalúa la diversidad léxica
-                - Considera palabras únicas vs. totales
-                - Detecta repeticiones innecesarias
-                - Valor óptimo: > 0.7
-            """)
-    
-    with col2:
-        st.metric(
-            "Estructura",
-            f"{metrics['structure']['normalized_score']:.2f}",
-            help="Evalúa la complejidad y variedad de las estructuras sintácticas en tus oraciones."
-        )
-        with st.expander("ℹ️ Detalles"):
-            st.write("""
-                **Estructura**
-                - Analiza la complejidad sintáctica
-                - Mide variación en construcciones
-                - Evalúa longitud de oraciones
-                - Valor óptimo: > 0.6
-            """)
-    
-    with col3:
-        st.metric(
-            "Cohesión",
-            f"{metrics['cohesion']['normalized_score']:.2f}",
-            help="Indica qué tan bien conectadas están tus ideas y párrafos entre sí."
-        )
-        with st.expander("ℹ️ Detalles"):
-            st.write("""
-                **Cohesión**
-                - Mide conexiones entre ideas
-                - Evalúa uso de conectores
-                - Analiza progresión temática
-                - Valor óptimo: > 0.65
-            """)
-    
-    with col4:
-        st.metric(
-            "Claridad",
-            f"{metrics['clarity']['normalized_score']:.2f}",
-            help="Evalúa la facilidad de comprensión general de tu texto."
-        )
-        with st.expander("ℹ️ Detalles"):
-            st.write("""
-                **Claridad**
-                - Evalúa comprensibilidad
-                - Considera estructura lógica
-                - Mide precisión expresiva
-                - Valor óptimo: > 0.7
-            """)
-
-    st.markdown("---")
-
-    # 2. Recomendaciones basadas en puntuaciones
-    st.markdown("### 💡 Recomendaciones Personalizadas")
-    
-    # Recomendaciones morfosintácticas
-    if metrics['structure']['normalized_score'] < 0.6:
-        st.warning("""
-        #### 📝 Análisis Morfosintáctico Recomendado
-        
-        **Tu nivel actual sugiere que sería beneficioso:**
-        1. Realizar el análisis morfosintáctico de 3 párrafos diferentes
-        2. Practicar la combinación de oraciones simples en compuestas
-        3. Identificar y clasificar tipos de oraciones en textos académicos
-        4. Ejercitar la variación sintáctica
-        
-        *Hacer clic en "Comenzar ejercicios" para acceder al módulo morfosintáctico*
-        """)
-        
-    # Recomendaciones semánticas
-    if metrics['vocabulary']['normalized_score'] < 0.7:
-        st.warning("""
-        #### 📚 Análisis Semántico Recomendado
-        
-        **Para mejorar tu vocabulario y expresión:**
-        A. Realiza el análisis semántico de un texto académico
-        B. Identifica y agrupa campos semánticos relacionados
-        C. Practica la sustitución léxica en tus párrafos
-        D. Construye redes de conceptos sobre tu tema
-        E. Analiza las relaciones entre ideas principales
-        
-        *Hacer clic en "Comenzar ejercicios" para acceder al módulo semántico*
-        """)
-    
-    # Recomendaciones de cohesión
-    if metrics['cohesion']['normalized_score'] < 0.65:
-        st.warning("""
-        #### 🔄 Análisis del Discurso Recomendado
-        
-        **Para mejorar la conexión entre ideas:**
-        1. Realizar el análisis del discurso de un texto modelo
-        2. Practicar el uso de diferentes conectores textuales
-        3. Identificar cadenas de referencia en textos académicos
-        4. Ejercitar la progresión temática en tus escritos
-        
-        *Hacer clic en "Comenzar ejercicios" para acceder al módulo de análisis del discurso*
-        """)
-    
-    # Botón de acción
-    st.markdown("---")
-    col1, col2, col3 = st.columns([1,2,1])
-    with col2:
-        st.button(
-            "🎯 Comenzar ejercicios recomendados",
-            type="primary",
-            use_container_width=True,
-            key="start_exercises"
-        )
+# modules/studentact/current_situation_interface.py
+
+import streamlit as st
+import logging
+from ..utils.widget_utils import generate_unique_key
+
+from ..database.current_situation_mongo_db import store_current_situation_result
+
+from .current_situation_analysis import (
+    analyze_text_dimensions, 
+    analyze_clarity,
+    analyze_reference_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,     
+)
+
+logger = logging.getLogger(__name__)
+####################################
+
+def display_current_situation_interface(lang_code, nlp_models, t):
+    """
+    Interfaz simplificada para el análisis inicial, enfocada en recomendaciones directas.
+    """
+    try:
+        # Inicializar estados si no existen
+        if 'text_input' not in st.session_state:
+            st.session_state.text_input = ""
+        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
+
+        st.markdown("## Análisis Inicial de Escritura")
+        
+        # Container principal con dos columnas
+        with st.container():
+            input_col, results_col = st.columns([1,2])
+            
+            with input_col:
+                st.markdown("### Ingresa tu texto")
+                
+                # Función para manejar cambios en el texto
+                def on_text_change():
+                    st.session_state.text_input = st.session_state.text_area
+                    st.session_state.show_results = False  # Resetear resultados cuando el texto cambia
+                
+                # 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,
+                    on_change=on_text_change,
+                    help="Este texto será analizado para darte recomendaciones personalizadas"
+                )
+                
+                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...")):
+                            # Procesar texto y obtener métricas
+                            doc = nlp_models[lang_code](text_input)
+                            metrics = analyze_text_dimensions(doc)
+                            
+                            # Guardar en MongoDB
+                            storage_success = store_current_situation_result(
+                                username=st.session_state.username,
+                                text=text_input,
+                                metrics=metrics,
+                                feedback=None  # Por ahora sin feedback
+                            )
+                            
+                            if not storage_success:
+                                logger.warning("No se pudo guardar el análisis en la base de datos")
+                            
+                            # Actualizar estado
+                            st.session_state.current_doc = doc
+                            st.session_state.current_metrics = metrics
+                            st.session_state.show_results = True
+                            st.session_state.text_input = text_input
+                            
+                    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:
+                    display_recommendations(st.session_state.current_metrics, t)
+                    
+                    # Opción para ver detalles
+                    with st.expander("🔍 Ver análisis detallado", expanded=False):
+                        display_current_situation_visual(
+                            st.session_state.current_doc,
+                            st.session_state.current_metrics
+                        )
+                        
+    except Exception as e:
+        logger.error(f"Error en interfaz: {str(e)}")
+        st.error("Ocurrió un error. Por favor, intente de nuevo.")
+
+
+
+def display_current_situation_visual(doc, metrics):
+    """
+    Muestra visualizaciones detalladas del análisis.
+    """
+    try:
+        st.markdown("### 📊 Visualizaciones Detalladas")
+        
+        # 1. Visualización de vocabulario
+        with st.expander("Análisis de Vocabulario", expanded=True):
+            vocab_graph = create_vocabulary_network(doc)
+            if vocab_graph:
+                st.pyplot(vocab_graph)
+                plt.close(vocab_graph)
+        
+        # 2. Visualización de estructura
+        with st.expander("Análisis de Estructura", expanded=True):
+            syntax_graph = create_syntax_complexity_graph(doc)
+            if syntax_graph:
+                st.pyplot(syntax_graph)
+                plt.close(syntax_graph)
+        
+        # 3. Visualización de cohesión
+        with st.expander("Análisis de Cohesión", expanded=True):
+            cohesion_graph = create_cohesion_heatmap(doc)
+            if cohesion_graph:
+                st.pyplot(cohesion_graph)
+                plt.close(cohesion_graph)
+
+    except Exception as e:
+        logger.error(f"Error en visualización: {str(e)}")
+        st.error("Error al generar las visualizaciones")
+
+
+####################################
+def display_recommendations(metrics, t):
+    """
+    Muestra recomendaciones basadas en las métricas del texto.
+    """
+    # 1. Resumen Visual con Explicación
+    st.markdown("### 📊 Resumen de tu Análisis")
+    
+    # Explicación del sistema de medición
+    st.markdown("""
+        **¿Cómo interpretar los resultados?**
+        
+        Cada métrica se mide en una escala de 0.0 a 1.0, donde:
+        - 0.0 - 0.4: Necesita atención prioritaria
+        - 0.4 - 0.6: En desarrollo
+        - 0.6 - 0.8: Buen nivel
+        - 0.8 - 1.0: Nivel avanzado
+    """)
+
+    # Métricas con explicaciones detalladas
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric(
+            "Vocabulario",
+            f"{metrics['vocabulary']['normalized_score']:.2f}",
+            help="Mide la variedad y riqueza de tu vocabulario. Un valor alto indica un uso diverso de palabras sin repeticiones excesivas."
+        )
+        with st.expander("ℹ️ Detalles"):
+            st.write("""
+                **Vocabulario**
+                - Evalúa la diversidad léxica
+                - Considera palabras únicas vs. totales
+                - Detecta repeticiones innecesarias
+                - Valor óptimo: > 0.7
+            """)
+    
+    with col2:
+        st.metric(
+            "Estructura",
+            f"{metrics['structure']['normalized_score']:.2f}",
+            help="Evalúa la complejidad y variedad de las estructuras sintácticas en tus oraciones."
+        )
+        with st.expander("ℹ️ Detalles"):
+            st.write("""
+                **Estructura**
+                - Analiza la complejidad sintáctica
+                - Mide variación en construcciones
+                - Evalúa longitud de oraciones
+                - Valor óptimo: > 0.6
+            """)
+    
+    with col3:
+        st.metric(
+            "Cohesión",
+            f"{metrics['cohesion']['normalized_score']:.2f}",
+            help="Indica qué tan bien conectadas están tus ideas y párrafos entre sí."
+        )
+        with st.expander("ℹ️ Detalles"):
+            st.write("""
+                **Cohesión**
+                - Mide conexiones entre ideas
+                - Evalúa uso de conectores
+                - Analiza progresión temática
+                - Valor óptimo: > 0.65
+            """)
+    
+    with col4:
+        st.metric(
+            "Claridad",
+            f"{metrics['clarity']['normalized_score']:.2f}",
+            help="Evalúa la facilidad de comprensión general de tu texto."
+        )
+        with st.expander("ℹ️ Detalles"):
+            st.write("""
+                **Claridad**
+                - Evalúa comprensibilidad
+                - Considera estructura lógica
+                - Mide precisión expresiva
+                - Valor óptimo: > 0.7
+            """)
+
+    st.markdown("---")
+
+    # 2. Recomendaciones basadas en puntuaciones
+    st.markdown("### 💡 Recomendaciones Personalizadas")
+    
+    # Recomendaciones morfosintácticas
+    if metrics['structure']['normalized_score'] < 0.6:
+        st.warning("""
+        #### 📝 Análisis Morfosintáctico Recomendado
+        
+        **Tu nivel actual sugiere que sería beneficioso:**
+        1. Realizar el análisis morfosintáctico de 3 párrafos diferentes
+        2. Practicar la combinación de oraciones simples en compuestas
+        3. Identificar y clasificar tipos de oraciones en textos académicos
+        4. Ejercitar la variación sintáctica
+        
+        *Hacer clic en "Comenzar ejercicios" para acceder al módulo morfosintáctico*
+        """)
+        
+    # Recomendaciones semánticas
+    if metrics['vocabulary']['normalized_score'] < 0.7:
+        st.warning("""
+        #### 📚 Análisis Semántico Recomendado
+        
+        **Para mejorar tu vocabulario y expresión:**
+        A. Realiza el análisis semántico de un texto académico
+        B. Identifica y agrupa campos semánticos relacionados
+        C. Practica la sustitución léxica en tus párrafos
+        D. Construye redes de conceptos sobre tu tema
+        E. Analiza las relaciones entre ideas principales
+        
+        *Hacer clic en "Comenzar ejercicios" para acceder al módulo semántico*
+        """)
+    
+    # Recomendaciones de cohesión
+    if metrics['cohesion']['normalized_score'] < 0.65:
+        st.warning("""
+        #### 🔄 Análisis del Discurso Recomendado
+        
+        **Para mejorar la conexión entre ideas:**
+        1. Realizar el análisis del discurso de un texto modelo
+        2. Practicar el uso de diferentes conectores textuales
+        3. Identificar cadenas de referencia en textos académicos
+        4. Ejercitar la progresión temática en tus escritos
+        
+        *Hacer clic en "Comenzar ejercicios" para acceder al módulo de análisis del discurso*
+        """)
+    
+    # Botón de acción
+    st.markdown("---")
+    col1, col2, col3 = st.columns([1,2,1])
+    with col2:
+        st.button(
+            "🎯 Comenzar ejercicios recomendados",
+            type="primary",
+            use_container_width=True,
+            key="start_exercises"
+        )

modules/studentact/current_situation_interface-v3.py

@@ -1,190 +1,190 @@
-# 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
-
-from .current_situation_analysis import (
-    analyze_text_dimensions, 
-    analyze_clarity,
-    analyze_reference_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__)
-####################################
-
-def display_current_situation_interface(lang_code, nlp_models, t):
-    """
-    Interfaz simplificada con gráfico de radar para visualizar métricas.
-    """
-    try:
-        # Inicializar estados si no existen
-        if 'text_input' not in st.session_state:
-            st.session_state.text_input = ""
-        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
-
-        st.markdown("## Análisis Inicial de Escritura")
-        
-        # Container principal con dos columnas
-        with st.container():
-            input_col, results_col = st.columns([1,2])
-            
-            with input_col:
-                #st.markdown("### Ingresa tu texto")
-                
-                # Función para manejar cambios en el texto
-                def on_text_change():
-                    st.session_state.text_input = st.session_state.text_area
-                    st.session_state.show_results = False
-                
-                # 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,
-                    on_change=on_text_change,
-                    help="Este texto será analizado para darte recomendaciones personalizadas"
-                )
-                
-                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)
-                            
-                            # Guardar en MongoDB
-                            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
-                            st.session_state.text_input = text_input
-                            
-                    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:
-                    display_radar_chart(st.session_state.current_metrics)
-
-    except Exception as e:
-        logger.error(f"Error en interfaz: {str(e)}")
-        st.error("Ocurrió un error. Por favor, intente de nuevo.")
-
-def display_radar_chart(metrics):
-    """
-    Muestra un gráfico de radar con las métricas del usuario y el patrón ideal.
-    """
-    try:
-        # Container con proporción reducida
-        with st.container():
-            # Métricas en la parte superior
-            col1, col2, col3, col4 = st.columns(4)
-            with col1:
-                st.metric("Vocabulario", f"{metrics['vocabulary']['normalized_score']:.2f}", "1.00")
-            with col2:
-                st.metric("Estructura", f"{metrics['structure']['normalized_score']:.2f}", "1.00")
-            with col3:
-                st.metric("Cohesión", f"{metrics['cohesion']['normalized_score']:.2f}", "1.00")
-            with col4:
-                st.metric("Claridad", f"{metrics['clarity']['normalized_score']:.2f}", "1.00")
-
-            # Contenedor para el gráfico con ancho controlado
-            _, graph_col, _ = st.columns([1,2,1])
-            
-            with graph_col:
-                # Preparar datos
-                categories = ['Vocabulario', 'Estructura', 'Cohesión', 'Claridad']
-                values_user = [
-                    metrics['vocabulary']['normalized_score'],
-                    metrics['structure']['normalized_score'],
-                    metrics['cohesion']['normalized_score'],
-                    metrics['clarity']['normalized_score']
-                ]
-                values_pattern = [1.0, 1.0, 1.0, 1.0]  # Patrón ideal
-
-                # Crear figura más compacta
-                fig = plt.figure(figsize=(6, 6))
-                ax = fig.add_subplot(111, projection='polar')
-
-                # Número de variables
-                num_vars = len(categories)
-
-                # Calcular ángulos
-                angles = [n / float(num_vars) * 2 * np.pi for n in range(num_vars)]
-                angles += angles[:1]
-
-                # Extender valores para cerrar polígonos
-                values_user += values_user[:1]
-                values_pattern += values_pattern[:1]
-
-                # Configurar ejes y etiquetas
-                ax.set_xticks(angles[:-1])
-                ax.set_xticklabels(categories, fontsize=8)
-
-                # Círculos concéntricos y etiquetas
-                circle_ticks = np.arange(0, 1.1, 0.2)  # Reducido a 5 niveles
-                ax.set_yticks(circle_ticks)
-                ax.set_yticklabels([f'{tick:.1f}' for tick in circle_ticks], fontsize=8)
-                ax.set_ylim(0, 1)
-
-                # Dibujar patrón ideal
-                ax.plot(angles, values_pattern, 'g--', linewidth=1, label='Patrón', alpha=0.5)
-                ax.fill(angles, values_pattern, 'g', alpha=0.1)
-
-                # Dibujar valores del usuario
-                ax.plot(angles, values_user, 'b-', linewidth=2, label='Tu escritura')
-                ax.fill(angles, values_user, 'b', alpha=0.2)
-
-                # Leyenda
-                ax.legend(loc='upper right', bbox_to_anchor=(0.1, 0.1), fontsize=8)
-
-                # Ajustes finales
-                plt.tight_layout()
-                st.pyplot(fig)
-                plt.close()
-
-    except Exception as e:
-        logger.error(f"Error generando gráfico de 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
+
+from .current_situation_analysis import (
+    analyze_text_dimensions, 
+    analyze_clarity,
+    analyze_reference_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__)
+####################################
+
+def display_current_situation_interface(lang_code, nlp_models, t):
+    """
+    Interfaz simplificada con gráfico de radar para visualizar métricas.
+    """
+    try:
+        # Inicializar estados si no existen
+        if 'text_input' not in st.session_state:
+            st.session_state.text_input = ""
+        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
+
+        st.markdown("## Análisis Inicial de Escritura")
+        
+        # Container principal con dos columnas
+        with st.container():
+            input_col, results_col = st.columns([1,2])
+            
+            with input_col:
+                #st.markdown("### Ingresa tu texto")
+                
+                # Función para manejar cambios en el texto
+                def on_text_change():
+                    st.session_state.text_input = st.session_state.text_area
+                    st.session_state.show_results = False
+                
+                # 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,
+                    on_change=on_text_change,
+                    help="Este texto será analizado para darte recomendaciones personalizadas"
+                )
+                
+                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)
+                            
+                            # Guardar en MongoDB
+                            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
+                            st.session_state.text_input = text_input
+                            
+                    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:
+                    display_radar_chart(st.session_state.current_metrics)
+
+    except Exception as e:
+        logger.error(f"Error en interfaz: {str(e)}")
+        st.error("Ocurrió un error. Por favor, intente de nuevo.")
+
+def display_radar_chart(metrics):
+    """
+    Muestra un gráfico de radar con las métricas del usuario y el patrón ideal.
+    """
+    try:
+        # Container con proporción reducida
+        with st.container():
+            # Métricas en la parte superior
+            col1, col2, col3, col4 = st.columns(4)
+            with col1:
+                st.metric("Vocabulario", f"{metrics['vocabulary']['normalized_score']:.2f}", "1.00")
+            with col2:
+                st.metric("Estructura", f"{metrics['structure']['normalized_score']:.2f}", "1.00")
+            with col3:
+                st.metric("Cohesión", f"{metrics['cohesion']['normalized_score']:.2f}", "1.00")
+            with col4:
+                st.metric("Claridad", f"{metrics['clarity']['normalized_score']:.2f}", "1.00")
+
+            # Contenedor para el gráfico con ancho controlado
+            _, graph_col, _ = st.columns([1,2,1])
+            
+            with graph_col:
+                # Preparar datos
+                categories = ['Vocabulario', 'Estructura', 'Cohesión', 'Claridad']
+                values_user = [
+                    metrics['vocabulary']['normalized_score'],
+                    metrics['structure']['normalized_score'],
+                    metrics['cohesion']['normalized_score'],
+                    metrics['clarity']['normalized_score']
+                ]
+                values_pattern = [1.0, 1.0, 1.0, 1.0]  # Patrón ideal
+
+                # Crear figura más compacta
+                fig = plt.figure(figsize=(6, 6))
+                ax = fig.add_subplot(111, projection='polar')
+
+                # Número de variables
+                num_vars = len(categories)
+
+                # Calcular ángulos
+                angles = [n / float(num_vars) * 2 * np.pi for n in range(num_vars)]
+                angles += angles[:1]
+
+                # Extender valores para cerrar polígonos
+                values_user += values_user[:1]
+                values_pattern += values_pattern[:1]
+
+                # Configurar ejes y etiquetas
+                ax.set_xticks(angles[:-1])
+                ax.set_xticklabels(categories, fontsize=8)
+
+                # Círculos concéntricos y etiquetas
+                circle_ticks = np.arange(0, 1.1, 0.2)  # Reducido a 5 niveles
+                ax.set_yticks(circle_ticks)
+                ax.set_yticklabels([f'{tick:.1f}' for tick in circle_ticks], fontsize=8)
+                ax.set_ylim(0, 1)
+
+                # Dibujar patrón ideal
+                ax.plot(angles, values_pattern, 'g--', linewidth=1, label='Patrón', alpha=0.5)
+                ax.fill(angles, values_pattern, 'g', alpha=0.1)
+
+                # Dibujar valores del usuario
+                ax.plot(angles, values_user, 'b-', linewidth=2, label='Tu escritura')
+                ax.fill(angles, values_user, 'b', alpha=0.2)
+
+                # Leyenda
+                ax.legend(loc='upper right', bbox_to_anchor=(0.1, 0.1), fontsize=8)
+
+                # Ajustes finales
+                plt.tight_layout()
+                st.pyplot(fig)
+                plt.close()
+
+    except Exception as e:
+        logger.error(f"Error generando gráfico de radar: {str(e)}")
         st.error("Error al generar la visualización")

modules/studentact/current_situation_interface.py

@@ -1,397 +1,321 @@
-# 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__)
-
-####################################
-
-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
-        
-    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(
-                        "",
-                        options=list(TEXT_TYPES.keys()),
-                        format_func=lambda x: TEXT_TYPES[x]['name'],
-                        horizontal=True,
-                        key="text_type_radio",
-                        help="Selecciona el tipo de texto para ajustar los criterios de evaluación"
-                    )
-                    
-                    st.session_state.current_text_type = text_type
-                    
-                    # Luego mostrar los resultados
-                    display_results(
-                        metrics=st.session_state.current_metrics,
-                        text_type=text_type
-                    )
-
-    except Exception as e:
-        logger.error(f"Error en interfaz principal: {str(e)}")
-        st.error("Ocurrió un error al cargar la interfaz")
-
-###################################3333
-
-def display_results(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),  # Cambiado de (0.1, 0.1) a (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")
-#######################################
-
-def display_recommendations(recommendations, t):
-    """
-    Muestra las recomendaciones con un diseño de tarjetas.
-    """
-    # Definir colores para cada categoría
-    colors = {
-        'vocabulary': '#2E86C1',  # Azul
-        'structure': '#28B463',   # Verde
-        'cohesion': '#F39C12',    # Naranja
-        'clarity': '#9B59B6',     # Púrpura
-        'priority': '#E74C3C'     # Rojo para la categoría prioritaria
-    }
-    
-    # Iconos para cada categoría
-    icons = {
-        'vocabulary': '📚',
-        'structure': '🏗️',
-        'cohesion': '🔄',
-        'clarity': '💡',
-        'priority': '⭐'
-    }
-    
-    # Obtener traducciones para cada dimensión
-    dimension_names = {
-        'vocabulary': t.get('SITUATION_ANALYSIS', {}).get('vocabulary', "Vocabulario"),
-        'structure': t.get('SITUATION_ANALYSIS', {}).get('structure', "Estructura"),
-        'cohesion': t.get('SITUATION_ANALYSIS', {}).get('cohesion', "Cohesión"),
-        'clarity': t.get('SITUATION_ANALYSIS', {}).get('clarity', "Claridad"),
-        'priority': t.get('SITUATION_ANALYSIS', {}).get('priority', "Prioridad")
-    }
-    
-    # Título de la sección prioritaria
-    priority_focus = t.get('SITUATION_ANALYSIS', {}).get('priority_focus', 'Área prioritaria para mejorar')
-    st.markdown(f"### {icons['priority']} {priority_focus}")
-    
-    # Determinar área prioritaria (la que tiene menor puntuación)
-    priority_area = recommendations.get('priority', 'vocabulary')
-    priority_title = dimension_names.get(priority_area, "Área prioritaria")
-    
-    # Determinar el contenido para mostrar
-    if isinstance(recommendations[priority_area], dict) and 'title' in recommendations[priority_area]:
-        priority_title = recommendations[priority_area]['title']
-        priority_content = recommendations[priority_area]['content']
-    else:
-        priority_content = recommendations[priority_area]
-    
-    # Mostrar la recomendación prioritaria con un estilo destacado
-    with st.container():
-        st.markdown(
-            f"""
-            <div style="border:2px solid {colors['priority']}; border-radius:5px; padding:15px; margin-bottom:20px;">
-                <h4 style="color:{colors['priority']};">{priority_title}</h4>
-                <p>{priority_content}</p>
-            </div>
-            """, 
-            unsafe_allow_html=True
-        )
-    
-    # Crear dos columnas para las tarjetas de recomendaciones restantes
-    col1, col2 = st.columns(2)
-    
-    # Distribuir las recomendaciones en las columnas
-    categories = ['vocabulary', 'structure', 'cohesion', 'clarity']
-    for i, category in enumerate(categories):
-        # Saltar si esta categoría ya es la prioritaria
-        if category == priority_area:
-            continue
-            
-        # Determinar título y contenido
-        if isinstance(recommendations[category], dict) and 'title' in recommendations[category]:
-            category_title = recommendations[category]['title']
-            category_content = recommendations[category]['content']
-        else:
-            category_title = dimension_names.get(category, category)
-            category_content = recommendations[category]
-        
-        # Alternar entre columnas
-        with col1 if i % 2 == 0 else col2:
-            # Crear tarjeta para cada recomendación
-            st.markdown(
-                f"""
-                <div style="border:1px solid {colors[category]}; border-radius:5px; padding:10px; margin-bottom:15px;">
-                    <h4 style="color:{colors[category]};">{icons[category]} {category_title}</h4>
-                    <p>{category_content}</p>
-                </div>
-                """, 
-                unsafe_allow_html=True
-            )
+# 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)}")
+        st.error("Error al mostrar el gráfico")

modules/studentact/student_activities.py

@@ -1,111 +1,111 @@
-#modules/studentact/student_activities.py
-
-import streamlit as st
-import pandas as pd
-import matplotlib.pyplot as plt
-import seaborn as sns
-import base64
-from io import BytesIO
-from reportlab.pdfgen import canvas
-from reportlab.lib.pagesizes import letter
-from docx import Document
-from odf.opendocument import OpenDocumentText
-from odf.text import P
-from datetime import datetime, timedelta
-import pytz
-import logging
-
-# Configuración de logging
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-# Importaciones locales
-try:
-    from ..database.morphosintax_mongo_db import get_student_morphosyntax_data
-    from ..database.semantic_mongo_db import get_student_semantic_data
-    from ..database.discourse_mongo_db import get_student_discourse_data
-    
-    from ..database.chat_mongo_db import get_chat_history
-    
-    logger.info("Importaciones locales exitosas")
-except ImportError as e:
-    logger.error(f"Error en las importaciones locales: {e}")
-
-def display_student_progress(username, lang_code, t):
-    logger.debug(f"Iniciando display_student_progress para {username}")
-
-    st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
-
-    # Obtener los datos del estudiante
-    student_data = get_student_morphosyntax_data(username)
-
-    if not student_data or len(student_data.get('entries', [])) == 0:
-        logger.warning(f"No se encontraron datos para el estudiante {username}")
-        st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
-        st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
-        return
-
-    logger.debug(f"Datos del estudiante obtenidos: {len(student_data['entries'])} entradas")
-
-    # Resumen de actividades
-    with st.expander(t.get("activities_summary", "Resumen de Actividades"), expanded=True):
-        total_entries = len(student_data['entries'])
-        st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
-
-        # Gráfico de tipos de análisis
-        try:
-            analysis_types = [entry.get('analysis_type', 'unknown') for entry in student_data['entries']]
-            analysis_counts = pd.Series(analysis_types).value_counts()
-            fig, ax = plt.subplots()
-            sns.barplot(x=analysis_counts.index, y=analysis_counts.values, ax=ax)
-            ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
-            ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
-            ax.set_ylabel(t.get("count", "Cantidad"))
-            st.pyplot(fig)
-        except Exception as e:
-            logger.error(f"Error al crear el gráfico: {e}")
-            st.error("No se pudo crear el gráfico de tipos de análisis.")
-
-    # Función para generar el contenido del archivo de actividades de las últimas 48 horas
-    def generate_activity_content_48h():
-        content = f"Actividades de {username} en las últimas 48 horas\n\n"
-
-        two_days_ago = datetime.now(pytz.utc) - timedelta(days=2)
-
-        try:
-            morphosyntax_analyses = get_student_morphosyntax_data(username)
-            recent_morphosyntax = [a for a in morphosyntax_analyses if datetime.fromisoformat(a['timestamp']) > two_days_ago]
-
-            content += f"Análisis morfosintácticos: {len(recent_morphosyntax)}\n"
-            for analysis in recent_morphosyntax:
-                content += f"- Análisis del {analysis['timestamp']}: {analysis['text'][:50]}...\n"
-
-            chat_history = get_chat_history(username, None)
-            recent_chats = [c for c in chat_history if datetime.fromisoformat(c['timestamp']) > two_days_ago]
-
-            content += f"\nConversaciones de chat: {len(recent_chats)}\n"
-            for chat in recent_chats:
-                content += f"- Chat del {chat['timestamp']}: {len(chat['messages'])} mensajes\n"
-        except Exception as e:
-            logger.error(f"Error al generar el contenido de actividades: {e}")
-            content += "Error al recuperar los datos de actividades.\n"
-
-        return content
-
-    # Botones para descargar el histórico de actividades de las últimas 48 horas
-    st.subheader(t.get("download_history_48h", "Descargar Histórico de Actividades (Últimas 48 horas)"))
-    if st.button("Generar reporte de 48 horas"):
-        try:
-            report_content = generate_activity_content_48h()
-            st.text_area("Reporte de 48 horas", report_content, height=300)
-            st.download_button(
-                label="Descargar TXT (48h)",
-                data=report_content,
-                file_name="actividades_48h.txt",
-                mime="text/plain"
-            )
-        except Exception as e:
-            logger.error(f"Error al generar el reporte: {e}")
-            st.error("No se pudo generar el reporte. Por favor, verifica los logs para más detalles.")
-
+#modules/studentact/student_activities.py
+
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import base64
+from io import BytesIO
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter
+from docx import Document
+from odf.opendocument import OpenDocumentText
+from odf.text import P
+from datetime import datetime, timedelta
+import pytz
+import logging
+
+# Configuración de logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Importaciones locales
+try:
+    from ..database.morphosintax_mongo_db import get_student_morphosyntax_data
+    from ..database.semantic_mongo_db import get_student_semantic_data
+    from ..database.discourse_mongo_db import get_student_discourse_data
+    
+    from ..database.chat_mongo_db import get_chat_history
+    
+    logger.info("Importaciones locales exitosas")
+except ImportError as e:
+    logger.error(f"Error en las importaciones locales: {e}")
+
+def display_student_progress(username, lang_code, t):
+    logger.debug(f"Iniciando display_student_progress para {username}")
+
+    st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
+
+    # Obtener los datos del estudiante
+    student_data = get_student_morphosyntax_data(username)
+
+    if not student_data or len(student_data.get('entries', [])) == 0:
+        logger.warning(f"No se encontraron datos para el estudiante {username}")
+        st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
+        st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
+        return
+
+    logger.debug(f"Datos del estudiante obtenidos: {len(student_data['entries'])} entradas")
+
+    # Resumen de actividades
+    with st.expander(t.get("activities_summary", "Resumen de Actividades"), expanded=True):
+        total_entries = len(student_data['entries'])
+        st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
+
+        # Gráfico de tipos de análisis
+        try:
+            analysis_types = [entry.get('analysis_type', 'unknown') for entry in student_data['entries']]
+            analysis_counts = pd.Series(analysis_types).value_counts()
+            fig, ax = plt.subplots()
+            sns.barplot(x=analysis_counts.index, y=analysis_counts.values, ax=ax)
+            ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
+            ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
+            ax.set_ylabel(t.get("count", "Cantidad"))
+            st.pyplot(fig)
+        except Exception as e:
+            logger.error(f"Error al crear el gráfico: {e}")
+            st.error("No se pudo crear el gráfico de tipos de análisis.")
+
+    # Función para generar el contenido del archivo de actividades de las últimas 48 horas
+    def generate_activity_content_48h():
+        content = f"Actividades de {username} en las últimas 48 horas\n\n"
+
+        two_days_ago = datetime.now(pytz.utc) - timedelta(days=2)
+
+        try:
+            morphosyntax_analyses = get_student_morphosyntax_data(username)
+            recent_morphosyntax = [a for a in morphosyntax_analyses if datetime.fromisoformat(a['timestamp']) > two_days_ago]
+
+            content += f"Análisis morfosintácticos: {len(recent_morphosyntax)}\n"
+            for analysis in recent_morphosyntax:
+                content += f"- Análisis del {analysis['timestamp']}: {analysis['text'][:50]}...\n"
+
+            chat_history = get_chat_history(username, None)
+            recent_chats = [c for c in chat_history if datetime.fromisoformat(c['timestamp']) > two_days_ago]
+
+            content += f"\nConversaciones de chat: {len(recent_chats)}\n"
+            for chat in recent_chats:
+                content += f"- Chat del {chat['timestamp']}: {len(chat['messages'])} mensajes\n"
+        except Exception as e:
+            logger.error(f"Error al generar el contenido de actividades: {e}")
+            content += "Error al recuperar los datos de actividades.\n"
+
+        return content
+
+    # Botones para descargar el histórico de actividades de las últimas 48 horas
+    st.subheader(t.get("download_history_48h", "Descargar Histórico de Actividades (Últimas 48 horas)"))
+    if st.button("Generar reporte de 48 horas"):
+        try:
+            report_content = generate_activity_content_48h()
+            st.text_area("Reporte de 48 horas", report_content, height=300)
+            st.download_button(
+                label="Descargar TXT (48h)",
+                data=report_content,
+                file_name="actividades_48h.txt",
+                mime="text/plain"
+            )
+        except Exception as e:
+            logger.error(f"Error al generar el reporte: {e}")
+            st.error("No se pudo generar el reporte. Por favor, verifica los logs para más detalles.")
+
     logger.debug("Finalizando display_student_progress")

modules/studentact/student_activities_v2-complet.py

@@ -1,794 +1,794 @@
-##############
-###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
-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
-
-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('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 Análisis Morfosintáctico
-        with tabs[0]:
-            display_morphosyntax_activities(username, t)
-
-        # Tab de Análisis Semántico
-        with tabs[1]:
-            display_semantic_activities(username, t)
-
-        # Tab de Análisis del Discurso
-        with tabs[2]:
-            display_discourse_activities(username, t)
-
-        # Tab de Conversaciones del Chat
-        with tabs[3]:
-            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_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 mínimos 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")
-                
-                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
-                    if analysis['concept_graph']:
-                        logger.debug("Decodificando gráfico de conceptos")
-                        try:
-                            image_bytes = base64.b64decode(analysis['concept_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_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_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)
-
-#################################################################################   
-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'))
-
-
-
-
-
-
-
-
-
-'''
-##########versión 25-9-2024---02:30 ################ OK (username)####################
-
-def display_student_progress(username, lang_code, t, student_data):
-    st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
-
-    if not student_data or len(student_data.get('entries', [])) == 0:
-        st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
-        st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
-        return
-
-    with st.expander(t.get("activities_summary", "Resumen de Actividades"), expanded=True):
-        total_entries = len(student_data['entries'])
-        st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
-
-        # Gráfico de tipos de análisis
-        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
-        analysis_counts = pd.Series(analysis_types).value_counts()
-        fig, ax = plt.subplots()
-        analysis_counts.plot(kind='bar', ax=ax)
-        ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
-        ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
-        ax.set_ylabel(t.get("count", "Cantidad"))
-        st.pyplot(fig)
-
-    # Mostrar los últimos análisis morfosintácticos
-    with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
-        morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
-        for entry in morphosyntax_entries[:5]:  # Mostrar los últimos 5
-            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
-            if 'arc_diagrams' in entry and entry['arc_diagrams']:
-                st.components.v1.html(entry['arc_diagrams'][0], height=300, scrolling=True)
-
-    # Añadir secciones similares para análisis semánticos y discursivos si es necesario
-
-    # Mostrar el historial de chat
-    with st.expander(t.get("chat_history", "Historial de Chat")):
-        if 'chat_history' in student_data:
-            for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
-                st.subheader(f"{t.get('chat_from', 'Chat del')} {chat['timestamp']}")
-                for message in chat['messages']:
-                    st.write(f"{message['role'].capitalize()}: {message['content']}")
-                st.write("---")
-        else:
-            st.write(t.get("no_chat_history", "No hay historial de chat disponible."))
-
-
-##########versión 24-9-2024---17:30 ################ OK FROM--V2 de def get_student_data(username)####################
-
-def display_student_progress(username, lang_code, t, student_data):
-    if not student_data or len(student_data['entries']) == 0:
-        st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
-        st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
-        return
-
-    st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
-
-    with st.expander(t.get("activities_summary", "Resumen de Actividades y Progreso"), expanded=True):
-        total_entries = len(student_data['entries'])
-        st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
-
-        # Gráfico de tipos de análisis
-        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
-        analysis_counts = pd.Series(analysis_types).value_counts()
-
-        fig, ax = plt.subplots(figsize=(8, 4))
-        analysis_counts.plot(kind='bar', ax=ax)
-        ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
-        ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
-        ax.set_ylabel(t.get("count", "Cantidad"))
-        st.pyplot(fig)
-
-    # Histórico de Análisis Morfosintácticos
-    with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
-        morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
-        if not morphosyntax_entries:
-            st.warning("No se encontraron análisis morfosintácticos.")
-        for entry in morphosyntax_entries:
-            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
-            if 'arc_diagrams' in entry and entry['arc_diagrams']:
-                try:
-                    st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
-                except Exception as e:
-                    logger.error(f"Error al mostrar diagrama de arco: {str(e)}")
-                    st.error("Error al mostrar el diagrama de arco.")
-            else:
-                st.write(t.get("no_arc_diagram", "No se encontró diagrama de arco para este análisis."))
-
-    # Histórico de Análisis Semánticos
-    with st.expander(t.get("semantic_history", "Histórico de Análisis Semánticos")):
-        semantic_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
-        if not semantic_entries:
-            st.warning("No se encontraron análisis semánticos.")
-        for entry in semantic_entries:
-            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
-            if 'key_concepts' in entry:
-                st.write(t.get("key_concepts", "Conceptos clave:"))
-                concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts']])
-                st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
-            if 'graph' in entry:
-                try:
-                    img_bytes = base64.b64decode(entry['graph'])
-                    st.image(img_bytes, caption=t.get("conceptual_relations_graph", "Gráfico de relaciones conceptuales"))
-                except Exception as e:
-                    logger.error(f"Error al mostrar gráfico semántico: {str(e)}")
-                    st.error(t.get("graph_display_error", f"No se pudo mostrar el gráfico: {str(e)}"))
-
-    # Histórico de Análisis Discursivos
-    with st.expander(t.get("discourse_history", "Histórico de Análisis Discursivos")):
-        discourse_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
-        for entry in discourse_entries:
-            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
-            for i in [1, 2]:
-                if f'key_concepts{i}' in entry:
-                    st.write(f"{t.get('key_concepts', 'Conceptos clave')} {t.get('document', 'documento')} {i}:")
-                    concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry[f'key_concepts{i}']])
-                    st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
-            try:
-                if 'combined_graph' in entry and entry['combined_graph']:
-                    img_bytes = base64.b64decode(entry['combined_graph'])
-                    st.image(img_bytes, caption=t.get("combined_graph", "Gráfico combinado"))
-                elif 'graph1' in entry and 'graph2' in entry:
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        if entry['graph1']:
-                            img_bytes1 = base64.b64decode(entry['graph1'])
-                            st.image(img_bytes1, caption=t.get("graph_doc1", "Gráfico documento 1"))
-                    with col2:
-                        if entry['graph2']:
-                            img_bytes2 = base64.b64decode(entry['graph2'])
-                            st.image(img_bytes2, caption=t.get("graph_doc2", "Gráfico documento 2"))
-            except Exception as e:
-                st.error(t.get("graph_display_error", f"No se pudieron mostrar los gráficos: {str(e)}"))
-
-    # Histórico de Conversaciones con el ChatBot
-    with st.expander(t.get("chatbot_history", "Histórico de Conversaciones con el ChatBot")):
-        if 'chat_history' in student_data and student_data['chat_history']:
-            for i, chat in enumerate(student_data['chat_history']):
-                st.subheader(f"{t.get('conversation', 'Conversación')} {i+1} - {chat['timestamp']}")
-                for message in chat['messages']:
-                    if message['role'] == 'user':
-                        st.write(f"{t.get('user', 'Usuario')}: {message['content']}")
-                    else:
-                        st.write(f"{t.get('assistant', 'Asistente')}: {message['content']}")
-                st.write("---")
-        else:
-            st.write(t.get("no_chat_history", "No se encontraron conversaciones con el ChatBot."))
-
-    # Añadir logs para depuración
-    if st.checkbox(t.get("show_debug_data", "Mostrar datos de depuración")):
-        st.write(t.get("student_debug_data", "Datos del estudiante (para depuración):"))
-        st.json(student_data)
-
-        # Mostrar conteo de tipos de análisis
-        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
-        type_counts = {t: analysis_types.count(t) for t in set(analysis_types)}
-        st.write("Conteo de tipos de análisis:")
-        st.write(type_counts)
-
-
-#############################--- Update 16:00 24-9 #########################################
-def display_student_progress(username, lang_code, t, student_data):
-    try:
-        st.subheader(t.get('student_activities', 'Student Activitie'))
-
-        if not student_data or all(len(student_data.get(key, [])) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
-            st.warning(t.get('no_data_warning', 'No analysis data found for this student.'))
-            return
-
-        # Resumen de actividades
-        total_analyses = sum(len(student_data.get(key, [])) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
-        st.write(f"{t.get('total_analyses', 'Total analyses performed')}: {total_analyses}")
-
-        # Gráfico de tipos de análisis
-        analysis_counts = {
-            t.get('morpho_analyses', 'Morphosyntactic Analyses'): len(student_data.get('morphosyntax_analyses', [])),
-            t.get('semantic_analyses', 'Semantic Analyses'): len(student_data.get('semantic_analyses', [])),
-            t.get('discourse_analyses', 'Discourse Analyses'): len(student_data.get('discourse_analyses', []))
-        }
-        # Configurar el estilo de seaborn para un aspecto más atractivo
-        sns.set_style("whitegrid")
-
-        # Crear una figura más pequeña
-        fig, ax = plt.subplots(figsize=(6, 4))
-
-        # Usar colores más atractivos
-        colors = ['#ff9999', '#66b3ff', '#99ff99']
-
-        # Crear el gráfico de barras
-        bars = ax.bar(analysis_counts.keys(), analysis_counts.values(), color=colors)
-
-        # Añadir etiquetas de valor encima de cada barra
-        for bar in bars:
-            height = bar.get_height()
-            ax.text(bar.get_x() + bar.get_width()/2., height,
-                    f'{height}',
-                    ha='center', va='bottom')
-
-        # Configurar el título y las etiquetas
-        ax.set_title(t.get('analysis_types_chart', 'Types of analyses performed'), fontsize=12)
-        ax.set_ylabel(t.get('count', 'Count'), fontsize=10)
-
-        # Rotar las etiquetas del eje x para mejor legibilidad
-        plt.xticks(rotation=45, ha='right')
-
-        # Ajustar el diseño para que todo quepa
-        plt.tight_layout()
-
-        # Mostrar el gráfico en Streamlit
-        st.pyplot(fig)
-
-        # Mostrar los últimos análisis
-        for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
-            with st.expander(t.get(f'{analysis_type}_expander', f'{analysis_type.capitalize()} History')):
-                for analysis in student_data.get(analysis_type, [])[:5]:  # Mostrar los últimos 5
-                    st.subheader(f"{t.get('analysis_from', 'Analysis from')} {analysis.get('timestamp', 'N/A')}")
-                    if analysis_type == 'morphosyntax_analyses':
-                        if 'arc_diagrams' in analysis:
-                            st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
-                    elif analysis_type == 'semantic_analyses':
-                        if 'key_concepts' in analysis:
-                            st.write(t.get('key_concepts', 'Key concepts'))
-                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
-                        if 'graph' in analysis:
-                            st.image(base64.b64decode(analysis['graph']))
-                    elif analysis_type == 'discourse_analyses':
-                        for i in [1, 2]:
-                            if f'key_concepts{i}' in analysis:
-                                st.write(f"{t.get('key_concepts', 'Key concepts')} {t.get('document', 'Document')} {i}")
-                                st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
-                        if 'combined_graph' in analysis:
-                            st.image(base64.b64decode(analysis['combined_graph']))
-
-        # Mostrar el historial de chat
-        with st.expander(t.get('chat_history_expander', 'Chat History')):
-            for chat in student_data.get('chat_history', [])[:5]:  # Mostrar las últimas 5 conversaciones
-                st.subheader(f"{t.get('chat_from', 'Chat from')} {chat.get('timestamp', 'N/A')}")
-                for message in chat.get('messages', []):
-                    st.write(f"{message.get('role', 'Unknown').capitalize()}: {message.get('content', 'No content')}")
-                st.write("---")
-
-    except Exception as e:
-        logger.error(f"Error in display_student_progress: {str(e)}", exc_info=True)
-        st.error(t.get('error_loading_progress', 'Error loading student progress. Please try again later.'))
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#####################################################################
-def display_student_progress(username, lang_code, t, student_data):
-    st.subheader(t['student_progress'])
-
-    if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
-        st.warning(t['no_data_warning'])
-        return
-
-    # Resumen de actividades
-    total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
-    st.write(f"{t['total_analyses']}: {total_analyses}")
-
-    # Gráfico de tipos de análisis
-    analysis_counts = {
-        t['morpho_analyses']: len(student_data['morphosyntax_analyses']),
-        t['semantic_analyses']: len(student_data['semantic_analyses']),
-        t['discourse_analyses']: len(student_data['discourse_analyses'])
-    }
-    fig, ax = plt.subplots()
-    ax.bar(analysis_counts.keys(), analysis_counts.values())
-    ax.set_title(t['analysis_types_chart'])
-    st.pyplot(fig)
-
-    # Mostrar los últimos análisis
-    for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
-        with st.expander(t[f'{analysis_type}_expander']):
-            for analysis in student_data[analysis_type][:5]:  # Mostrar los últimos 5
-                st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
-                if analysis_type == 'morphosyntax_analyses':
-                    if 'arc_diagrams' in analysis:
-                        st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
-                elif analysis_type == 'semantic_analyses':
-                    if 'key_concepts' in analysis:
-                        st.write(t['key_concepts'])
-                        st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
-                    if 'graph' in analysis:
-                        st.image(base64.b64decode(analysis['graph']))
-                elif analysis_type == 'discourse_analyses':
-                    for i in [1, 2]:
-                        if f'key_concepts{i}' in analysis:
-                            st.write(f"{t['key_concepts']} {t['document']} {i}")
-                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
-                    if 'combined_graph' in analysis:
-                        st.image(base64.b64decode(analysis['combined_graph']))
-
-    # Mostrar el historial de chat
-    with st.expander(t['chat_history_expander']):
-        for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
-            st.subheader(f"{t['chat_from']} {chat['timestamp']}")
-            for message in chat['messages']:
-                st.write(f"{message['role'].capitalize()}: {message['content']}")
-            st.write("---")
-
-
-
-def display_student_progress(username, lang_code, t, student_data):
-    st.subheader(t['student_activities'])
-
-    if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
-        st.warning(t['no_data_warning'])
-        return
-
-    # Resumen de actividades
-    total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
-    st.write(f"{t['total_analyses']}: {total_analyses}")
-
-    # Gráfico de tipos de análisis
-    analysis_counts = {
-        t['morphological_analysis']: len(student_data['morphosyntax_analyses']),
-        t['semantic_analyses']: len(student_data['semantic_analyses']),
-        t['discourse_analyses']: len(student_data['discourse_analyses'])
-    }
-    fig, ax = plt.subplots()
-    ax.bar(analysis_counts.keys(), analysis_counts.values())
-    ax.set_title(t['analysis_types_chart'])
-    st.pyplot(fig)
-
-    # Mostrar los últimos análisis
-    for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
-        with st.expander(t[f'{analysis_type}_expander']):
-            for analysis in student_data[analysis_type][:5]:  # Mostrar los últimos 5
-                st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
-                if analysis_type == 'morphosyntax_analyses':
-                    if 'arc_diagrams' in analysis:
-                        st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
-                elif analysis_type == 'semantic_analyses':
-                    if 'key_concepts' in analysis:
-                        st.write(t['key_concepts'])
-                        st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
-                    if 'graph' in analysis:
-                        st.image(base64.b64decode(analysis['graph']))
-                elif analysis_type == 'discourse_analyses':
-                    for i in [1, 2]:
-                        if f'key_concepts{i}' in analysis:
-                            st.write(f"{t['key_concepts']} {t['document']} {i}")
-                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
-                    if 'combined_graph' in analysis:
-                        st.image(base64.b64decode(analysis['combined_graph']))
-
-    # Mostrar el historial de chat
-    with st.expander(t['chat_history_expander']):
-        for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
-            st.subheader(f"{t['chat_from']} {chat['timestamp']}")
-            for message in chat['messages']:
-                st.write(f"{message['role'].capitalize()}: {message['content']}")
-            st.write("---")
-
-
-
-
-def display_student_progress(username, lang_code, t, student_data):
-    st.subheader(t['student_activities'])
-
-    if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
-        st.warning(t['no_data_warning'])
-        return
-
-    # Resumen de actividades
-    total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
-    st.write(f"{t['total_analyses']}: {total_analyses}")
-
-    # Gráfico de tipos de análisis
-    analysis_counts = {
-        t['morphological_analysis']: len(student_data['morphosyntax_analyses']),
-        t['semantic_analyses']: len(student_data['semantic_analyses']),
-        t['discourse_analyses']: len(student_data['discourse_analyses'])
-    }
-    fig, ax = plt.subplots()
-    ax.bar(analysis_counts.keys(), analysis_counts.values())
-    ax.set_title(t['analysis_types_chart'])
-    st.pyplot(fig)
-
-    # Mostrar los últimos análisis
-    for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
-        with st.expander(t[f'{analysis_type}_expander']):
-            for analysis in student_data[analysis_type][:5]:  # Mostrar los últimos 5
-                st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
-                if analysis_type == 'morphosyntax_analyses':
-                    if 'arc_diagrams' in analysis:
-                        st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
-                elif analysis_type == 'semantic_analyses':
-                    if 'key_concepts' in analysis:
-                        st.write(t['key_concepts'])
-                        st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
-                    if 'graph' in analysis:
-                        st.image(base64.b64decode(analysis['graph']))
-                elif analysis_type == 'discourse_analyses':
-                    for i in [1, 2]:
-                        if f'key_concepts{i}' in analysis:
-                            st.write(f"{t['key_concepts']} {t['document']} {i}")
-                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
-                    if 'combined_graph' in analysis:
-                        st.image(base64.b64decode(analysis['combined_graph']))
-
-    # Mostrar el historial de chat
-    with st.expander(t['chat_history_expander']):
-        for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
-            st.subheader(f"{t['chat_from']} {chat['timestamp']}")
-            for message in chat['messages']:
-                st.write(f"{message['role'].capitalize()}: {message['content']}")
-            st.write("---")
-
-
-
-
-def display_student_progress(username, lang_code, t):
-    st.subheader(t['student_activities'])
-    st.write(f"{t['activities_message']} {username}")
-
-    # Aquí puedes agregar más contenido estático o placeholder
-    st.info(t['activities_placeholder'])
-
-    # Si necesitas mostrar algún dato, puedes usar datos de ejemplo o placeholders
-    col1, col2, col3 = st.columns(3)
-    col1.metric(t['morpho_analyses'], "5")  # Ejemplo de dato
-    col2.metric(t['semantic_analyses'], "3")  # Ejemplo de dato
-    col3.metric(t['discourse_analyses'], "2")  # Ejemplo de dato
-
-
-
-def display_student_progress(username, lang_code, t):
-    st.title(f"Actividades de {username}")
-
-    # Obtener todos los datos del estudiante
-    student_data = get_student_data(username)
-
-    if not student_data or len(student_data.get('entries', [])) == 0:
-        st.warning("No se encontraron datos de análisis para este estudiante.")
-        st.info("Intenta realizar algunos análisis de texto primero.")
-        return
-
-    # Resumen de actividades
-    with st.expander("Resumen de Actividades", expanded=True):
-        total_entries = len(student_data['entries'])
-        st.write(f"Total de análisis realizados: {total_entries}")
-
-        # Gráfico de tipos de análisis
-        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
-        analysis_counts = pd.Series(analysis_types).value_counts()
-        fig, ax = plt.subplots()
-        analysis_counts.plot(kind='bar', ax=ax)
-        ax.set_title("Tipos de análisis realizados")
-        ax.set_xlabel("Tipo de análisis")
-        ax.set_ylabel("Cantidad")
-        st.pyplot(fig)
-
-    # Histórico de Análisis Morfosintácticos
-    with st.expander("Histórico de Análisis Morfosintácticos"):
-        morpho_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
-        for analysis in morpho_analyses[:5]:  # Mostrar los últimos 5
-            st.subheader(f"Análisis del {analysis['timestamp']}")
-            if 'arc_diagrams' in analysis:
-                st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
-
-    # Histórico de Análisis Semánticos
-    with st.expander("Histórico de Análisis Semánticos"):
-        semantic_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
-        for analysis in semantic_analyses[:5]:  # Mostrar los últimos 5
-            st.subheader(f"Análisis del {analysis['timestamp']}")
-            if 'key_concepts' in analysis:
-                concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis['key_concepts']])
-                st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
-            if 'graph' in analysis:
-                try:
-                    img_bytes = base64.b64decode(analysis['graph'])
-                    st.image(img_bytes, caption="Gráfico de relaciones conceptuales")
-                except Exception as e:
-                    st.error(f"No se pudo mostrar el gráfico: {str(e)}")
-
-    # Histórico de Análisis Discursivos
-    with st.expander("Histórico de Análisis Discursivos"):
-        discourse_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
-        for analysis in discourse_analyses[:5]:  # Mostrar los últimos 5
-            st.subheader(f"Análisis del {analysis['timestamp']}")
-            for i in [1, 2]:
-                if f'key_concepts{i}' in analysis:
-                    concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis[f'key_concepts{i}']])
-                    st.write(f"Conceptos clave del documento {i}:")
-                    st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
-            if 'combined_graph' in analysis:
-                try:
-                    img_bytes = base64.b64decode(analysis['combined_graph'])
-                    st.image(img_bytes)
-                except Exception as e:
-                    st.error(f"No se pudo mostrar el gráfico combinado: {str(e)}")
-
-    # Histórico de Conversaciones con el ChatBot
-    with st.expander("Histórico de Conversaciones con el ChatBot"):
-        if 'chat_history' in student_data:
-            for i, chat in enumerate(student_data['chat_history'][:5]):  # Mostrar las últimas 5 conversaciones
-                st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
-                for message in chat['messages']:
-                    st.write(f"{message['role'].capitalize()}: {message['content']}")
-                st.write("---")
-        else:
-            st.write("No se encontraron conversaciones con el ChatBot.")
-
-    # Opción para mostrar datos de depuración
-    if st.checkbox("Mostrar datos de depuración"):
-        st.write("Datos del estudiante (para depuración):")
-        st.json(student_data)
-
+##############
+###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
+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
+
+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('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 Análisis Morfosintáctico
+        with tabs[0]:
+            display_morphosyntax_activities(username, t)
+
+        # Tab de Análisis Semántico
+        with tabs[1]:
+            display_semantic_activities(username, t)
+
+        # Tab de Análisis del Discurso
+        with tabs[2]:
+            display_discourse_activities(username, t)
+
+        # Tab de Conversaciones del Chat
+        with tabs[3]:
+            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_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 mínimos 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")
+                
+                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
+                    if analysis['concept_graph']:
+                        logger.debug("Decodificando gráfico de conceptos")
+                        try:
+                            image_bytes = base64.b64decode(analysis['concept_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_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_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)
+
+#################################################################################   
+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'))
+
+
+
+
+
+
+
+
+
+'''
+##########versión 25-9-2024---02:30 ################ OK (username)####################
+
+def display_student_progress(username, lang_code, t, student_data):
+    st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
+
+    if not student_data or len(student_data.get('entries', [])) == 0:
+        st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
+        st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
+        return
+
+    with st.expander(t.get("activities_summary", "Resumen de Actividades"), expanded=True):
+        total_entries = len(student_data['entries'])
+        st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
+
+        # Gráfico de tipos de análisis
+        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
+        analysis_counts = pd.Series(analysis_types).value_counts()
+        fig, ax = plt.subplots()
+        analysis_counts.plot(kind='bar', ax=ax)
+        ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
+        ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
+        ax.set_ylabel(t.get("count", "Cantidad"))
+        st.pyplot(fig)
+
+    # Mostrar los últimos análisis morfosintácticos
+    with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
+        morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
+        for entry in morphosyntax_entries[:5]:  # Mostrar los últimos 5
+            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
+            if 'arc_diagrams' in entry and entry['arc_diagrams']:
+                st.components.v1.html(entry['arc_diagrams'][0], height=300, scrolling=True)
+
+    # Añadir secciones similares para análisis semánticos y discursivos si es necesario
+
+    # Mostrar el historial de chat
+    with st.expander(t.get("chat_history", "Historial de Chat")):
+        if 'chat_history' in student_data:
+            for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
+                st.subheader(f"{t.get('chat_from', 'Chat del')} {chat['timestamp']}")
+                for message in chat['messages']:
+                    st.write(f"{message['role'].capitalize()}: {message['content']}")
+                st.write("---")
+        else:
+            st.write(t.get("no_chat_history", "No hay historial de chat disponible."))
+
+
+##########versión 24-9-2024---17:30 ################ OK FROM--V2 de def get_student_data(username)####################
+
+def display_student_progress(username, lang_code, t, student_data):
+    if not student_data or len(student_data['entries']) == 0:
+        st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
+        st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
+        return
+
+    st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
+
+    with st.expander(t.get("activities_summary", "Resumen de Actividades y Progreso"), expanded=True):
+        total_entries = len(student_data['entries'])
+        st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
+
+        # Gráfico de tipos de análisis
+        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
+        analysis_counts = pd.Series(analysis_types).value_counts()
+
+        fig, ax = plt.subplots(figsize=(8, 4))
+        analysis_counts.plot(kind='bar', ax=ax)
+        ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
+        ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
+        ax.set_ylabel(t.get("count", "Cantidad"))
+        st.pyplot(fig)
+
+    # Histórico de Análisis Morfosintácticos
+    with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
+        morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
+        if not morphosyntax_entries:
+            st.warning("No se encontraron análisis morfosintácticos.")
+        for entry in morphosyntax_entries:
+            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
+            if 'arc_diagrams' in entry and entry['arc_diagrams']:
+                try:
+                    st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
+                except Exception as e:
+                    logger.error(f"Error al mostrar diagrama de arco: {str(e)}")
+                    st.error("Error al mostrar el diagrama de arco.")
+            else:
+                st.write(t.get("no_arc_diagram", "No se encontró diagrama de arco para este análisis."))
+
+    # Histórico de Análisis Semánticos
+    with st.expander(t.get("semantic_history", "Histórico de Análisis Semánticos")):
+        semantic_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
+        if not semantic_entries:
+            st.warning("No se encontraron análisis semánticos.")
+        for entry in semantic_entries:
+            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
+            if 'key_concepts' in entry:
+                st.write(t.get("key_concepts", "Conceptos clave:"))
+                concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts']])
+                st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
+            if 'graph' in entry:
+                try:
+                    img_bytes = base64.b64decode(entry['graph'])
+                    st.image(img_bytes, caption=t.get("conceptual_relations_graph", "Gráfico de relaciones conceptuales"))
+                except Exception as e:
+                    logger.error(f"Error al mostrar gráfico semántico: {str(e)}")
+                    st.error(t.get("graph_display_error", f"No se pudo mostrar el gráfico: {str(e)}"))
+
+    # Histórico de Análisis Discursivos
+    with st.expander(t.get("discourse_history", "Histórico de Análisis Discursivos")):
+        discourse_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
+        for entry in discourse_entries:
+            st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
+            for i in [1, 2]:
+                if f'key_concepts{i}' in entry:
+                    st.write(f"{t.get('key_concepts', 'Conceptos clave')} {t.get('document', 'documento')} {i}:")
+                    concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry[f'key_concepts{i}']])
+                    st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
+            try:
+                if 'combined_graph' in entry and entry['combined_graph']:
+                    img_bytes = base64.b64decode(entry['combined_graph'])
+                    st.image(img_bytes, caption=t.get("combined_graph", "Gráfico combinado"))
+                elif 'graph1' in entry and 'graph2' in entry:
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        if entry['graph1']:
+                            img_bytes1 = base64.b64decode(entry['graph1'])
+                            st.image(img_bytes1, caption=t.get("graph_doc1", "Gráfico documento 1"))
+                    with col2:
+                        if entry['graph2']:
+                            img_bytes2 = base64.b64decode(entry['graph2'])
+                            st.image(img_bytes2, caption=t.get("graph_doc2", "Gráfico documento 2"))
+            except Exception as e:
+                st.error(t.get("graph_display_error", f"No se pudieron mostrar los gráficos: {str(e)}"))
+
+    # Histórico de Conversaciones con el ChatBot
+    with st.expander(t.get("chatbot_history", "Histórico de Conversaciones con el ChatBot")):
+        if 'chat_history' in student_data and student_data['chat_history']:
+            for i, chat in enumerate(student_data['chat_history']):
+                st.subheader(f"{t.get('conversation', 'Conversación')} {i+1} - {chat['timestamp']}")
+                for message in chat['messages']:
+                    if message['role'] == 'user':
+                        st.write(f"{t.get('user', 'Usuario')}: {message['content']}")
+                    else:
+                        st.write(f"{t.get('assistant', 'Asistente')}: {message['content']}")
+                st.write("---")
+        else:
+            st.write(t.get("no_chat_history", "No se encontraron conversaciones con el ChatBot."))
+
+    # Añadir logs para depuración
+    if st.checkbox(t.get("show_debug_data", "Mostrar datos de depuración")):
+        st.write(t.get("student_debug_data", "Datos del estudiante (para depuración):"))
+        st.json(student_data)
+
+        # Mostrar conteo de tipos de análisis
+        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
+        type_counts = {t: analysis_types.count(t) for t in set(analysis_types)}
+        st.write("Conteo de tipos de análisis:")
+        st.write(type_counts)
+
+
+#############################--- Update 16:00 24-9 #########################################
+def display_student_progress(username, lang_code, t, student_data):
+    try:
+        st.subheader(t.get('student_activities', 'Student Activitie'))
+
+        if not student_data or all(len(student_data.get(key, [])) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
+            st.warning(t.get('no_data_warning', 'No analysis data found for this student.'))
+            return
+
+        # Resumen de actividades
+        total_analyses = sum(len(student_data.get(key, [])) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
+        st.write(f"{t.get('total_analyses', 'Total analyses performed')}: {total_analyses}")
+
+        # Gráfico de tipos de análisis
+        analysis_counts = {
+            t.get('morpho_analyses', 'Morphosyntactic Analyses'): len(student_data.get('morphosyntax_analyses', [])),
+            t.get('semantic_analyses', 'Semantic Analyses'): len(student_data.get('semantic_analyses', [])),
+            t.get('discourse_analyses', 'Discourse Analyses'): len(student_data.get('discourse_analyses', []))
+        }
+        # Configurar el estilo de seaborn para un aspecto más atractivo
+        sns.set_style("whitegrid")
+
+        # Crear una figura más pequeña
+        fig, ax = plt.subplots(figsize=(6, 4))
+
+        # Usar colores más atractivos
+        colors = ['#ff9999', '#66b3ff', '#99ff99']
+
+        # Crear el gráfico de barras
+        bars = ax.bar(analysis_counts.keys(), analysis_counts.values(), color=colors)
+
+        # Añadir etiquetas de valor encima de cada barra
+        for bar in bars:
+            height = bar.get_height()
+            ax.text(bar.get_x() + bar.get_width()/2., height,
+                    f'{height}',
+                    ha='center', va='bottom')
+
+        # Configurar el título y las etiquetas
+        ax.set_title(t.get('analysis_types_chart', 'Types of analyses performed'), fontsize=12)
+        ax.set_ylabel(t.get('count', 'Count'), fontsize=10)
+
+        # Rotar las etiquetas del eje x para mejor legibilidad
+        plt.xticks(rotation=45, ha='right')
+
+        # Ajustar el diseño para que todo quepa
+        plt.tight_layout()
+
+        # Mostrar el gráfico en Streamlit
+        st.pyplot(fig)
+
+        # Mostrar los últimos análisis
+        for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
+            with st.expander(t.get(f'{analysis_type}_expander', f'{analysis_type.capitalize()} History')):
+                for analysis in student_data.get(analysis_type, [])[:5]:  # Mostrar los últimos 5
+                    st.subheader(f"{t.get('analysis_from', 'Analysis from')} {analysis.get('timestamp', 'N/A')}")
+                    if analysis_type == 'morphosyntax_analyses':
+                        if 'arc_diagrams' in analysis:
+                            st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
+                    elif analysis_type == 'semantic_analyses':
+                        if 'key_concepts' in analysis:
+                            st.write(t.get('key_concepts', 'Key concepts'))
+                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
+                        if 'graph' in analysis:
+                            st.image(base64.b64decode(analysis['graph']))
+                    elif analysis_type == 'discourse_analyses':
+                        for i in [1, 2]:
+                            if f'key_concepts{i}' in analysis:
+                                st.write(f"{t.get('key_concepts', 'Key concepts')} {t.get('document', 'Document')} {i}")
+                                st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
+                        if 'combined_graph' in analysis:
+                            st.image(base64.b64decode(analysis['combined_graph']))
+
+        # Mostrar el historial de chat
+        with st.expander(t.get('chat_history_expander', 'Chat History')):
+            for chat in student_data.get('chat_history', [])[:5]:  # Mostrar las últimas 5 conversaciones
+                st.subheader(f"{t.get('chat_from', 'Chat from')} {chat.get('timestamp', 'N/A')}")
+                for message in chat.get('messages', []):
+                    st.write(f"{message.get('role', 'Unknown').capitalize()}: {message.get('content', 'No content')}")
+                st.write("---")
+
+    except Exception as e:
+        logger.error(f"Error in display_student_progress: {str(e)}", exc_info=True)
+        st.error(t.get('error_loading_progress', 'Error loading student progress. Please try again later.'))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#####################################################################
+def display_student_progress(username, lang_code, t, student_data):
+    st.subheader(t['student_progress'])
+
+    if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
+        st.warning(t['no_data_warning'])
+        return
+
+    # Resumen de actividades
+    total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
+    st.write(f"{t['total_analyses']}: {total_analyses}")
+
+    # Gráfico de tipos de análisis
+    analysis_counts = {
+        t['morpho_analyses']: len(student_data['morphosyntax_analyses']),
+        t['semantic_analyses']: len(student_data['semantic_analyses']),
+        t['discourse_analyses']: len(student_data['discourse_analyses'])
+    }
+    fig, ax = plt.subplots()
+    ax.bar(analysis_counts.keys(), analysis_counts.values())
+    ax.set_title(t['analysis_types_chart'])
+    st.pyplot(fig)
+
+    # Mostrar los últimos análisis
+    for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
+        with st.expander(t[f'{analysis_type}_expander']):
+            for analysis in student_data[analysis_type][:5]:  # Mostrar los últimos 5
+                st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
+                if analysis_type == 'morphosyntax_analyses':
+                    if 'arc_diagrams' in analysis:
+                        st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
+                elif analysis_type == 'semantic_analyses':
+                    if 'key_concepts' in analysis:
+                        st.write(t['key_concepts'])
+                        st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
+                    if 'graph' in analysis:
+                        st.image(base64.b64decode(analysis['graph']))
+                elif analysis_type == 'discourse_analyses':
+                    for i in [1, 2]:
+                        if f'key_concepts{i}' in analysis:
+                            st.write(f"{t['key_concepts']} {t['document']} {i}")
+                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
+                    if 'combined_graph' in analysis:
+                        st.image(base64.b64decode(analysis['combined_graph']))
+
+    # Mostrar el historial de chat
+    with st.expander(t['chat_history_expander']):
+        for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
+            st.subheader(f"{t['chat_from']} {chat['timestamp']}")
+            for message in chat['messages']:
+                st.write(f"{message['role'].capitalize()}: {message['content']}")
+            st.write("---")
+
+
+
+def display_student_progress(username, lang_code, t, student_data):
+    st.subheader(t['student_activities'])
+
+    if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
+        st.warning(t['no_data_warning'])
+        return
+
+    # Resumen de actividades
+    total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
+    st.write(f"{t['total_analyses']}: {total_analyses}")
+
+    # Gráfico de tipos de análisis
+    analysis_counts = {
+        t['morphological_analysis']: len(student_data['morphosyntax_analyses']),
+        t['semantic_analyses']: len(student_data['semantic_analyses']),
+        t['discourse_analyses']: len(student_data['discourse_analyses'])
+    }
+    fig, ax = plt.subplots()
+    ax.bar(analysis_counts.keys(), analysis_counts.values())
+    ax.set_title(t['analysis_types_chart'])
+    st.pyplot(fig)
+
+    # Mostrar los últimos análisis
+    for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
+        with st.expander(t[f'{analysis_type}_expander']):
+            for analysis in student_data[analysis_type][:5]:  # Mostrar los últimos 5
+                st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
+                if analysis_type == 'morphosyntax_analyses':
+                    if 'arc_diagrams' in analysis:
+                        st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
+                elif analysis_type == 'semantic_analyses':
+                    if 'key_concepts' in analysis:
+                        st.write(t['key_concepts'])
+                        st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
+                    if 'graph' in analysis:
+                        st.image(base64.b64decode(analysis['graph']))
+                elif analysis_type == 'discourse_analyses':
+                    for i in [1, 2]:
+                        if f'key_concepts{i}' in analysis:
+                            st.write(f"{t['key_concepts']} {t['document']} {i}")
+                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
+                    if 'combined_graph' in analysis:
+                        st.image(base64.b64decode(analysis['combined_graph']))
+
+    # Mostrar el historial de chat
+    with st.expander(t['chat_history_expander']):
+        for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
+            st.subheader(f"{t['chat_from']} {chat['timestamp']}")
+            for message in chat['messages']:
+                st.write(f"{message['role'].capitalize()}: {message['content']}")
+            st.write("---")
+
+
+
+
+def display_student_progress(username, lang_code, t, student_data):
+    st.subheader(t['student_activities'])
+
+    if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
+        st.warning(t['no_data_warning'])
+        return
+
+    # Resumen de actividades
+    total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
+    st.write(f"{t['total_analyses']}: {total_analyses}")
+
+    # Gráfico de tipos de análisis
+    analysis_counts = {
+        t['morphological_analysis']: len(student_data['morphosyntax_analyses']),
+        t['semantic_analyses']: len(student_data['semantic_analyses']),
+        t['discourse_analyses']: len(student_data['discourse_analyses'])
+    }
+    fig, ax = plt.subplots()
+    ax.bar(analysis_counts.keys(), analysis_counts.values())
+    ax.set_title(t['analysis_types_chart'])
+    st.pyplot(fig)
+
+    # Mostrar los últimos análisis
+    for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
+        with st.expander(t[f'{analysis_type}_expander']):
+            for analysis in student_data[analysis_type][:5]:  # Mostrar los últimos 5
+                st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
+                if analysis_type == 'morphosyntax_analyses':
+                    if 'arc_diagrams' in analysis:
+                        st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
+                elif analysis_type == 'semantic_analyses':
+                    if 'key_concepts' in analysis:
+                        st.write(t['key_concepts'])
+                        st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
+                    if 'graph' in analysis:
+                        st.image(base64.b64decode(analysis['graph']))
+                elif analysis_type == 'discourse_analyses':
+                    for i in [1, 2]:
+                        if f'key_concepts{i}' in analysis:
+                            st.write(f"{t['key_concepts']} {t['document']} {i}")
+                            st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
+                    if 'combined_graph' in analysis:
+                        st.image(base64.b64decode(analysis['combined_graph']))
+
+    # Mostrar el historial de chat
+    with st.expander(t['chat_history_expander']):
+        for chat in student_data['chat_history'][:5]:  # Mostrar las últimas 5 conversaciones
+            st.subheader(f"{t['chat_from']} {chat['timestamp']}")
+            for message in chat['messages']:
+                st.write(f"{message['role'].capitalize()}: {message['content']}")
+            st.write("---")
+
+
+
+
+def display_student_progress(username, lang_code, t):
+    st.subheader(t['student_activities'])
+    st.write(f"{t['activities_message']} {username}")
+
+    # Aquí puedes agregar más contenido estático o placeholder
+    st.info(t['activities_placeholder'])
+
+    # Si necesitas mostrar algún dato, puedes usar datos de ejemplo o placeholders
+    col1, col2, col3 = st.columns(3)
+    col1.metric(t['morpho_analyses'], "5")  # Ejemplo de dato
+    col2.metric(t['semantic_analyses'], "3")  # Ejemplo de dato
+    col3.metric(t['discourse_analyses'], "2")  # Ejemplo de dato
+
+
+
+def display_student_progress(username, lang_code, t):
+    st.title(f"Actividades de {username}")
+
+    # Obtener todos los datos del estudiante
+    student_data = get_student_data(username)
+
+    if not student_data or len(student_data.get('entries', [])) == 0:
+        st.warning("No se encontraron datos de análisis para este estudiante.")
+        st.info("Intenta realizar algunos análisis de texto primero.")
+        return
+
+    # Resumen de actividades
+    with st.expander("Resumen de Actividades", expanded=True):
+        total_entries = len(student_data['entries'])
+        st.write(f"Total de análisis realizados: {total_entries}")
+
+        # Gráfico de tipos de análisis
+        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
+        analysis_counts = pd.Series(analysis_types).value_counts()
+        fig, ax = plt.subplots()
+        analysis_counts.plot(kind='bar', ax=ax)
+        ax.set_title("Tipos de análisis realizados")
+        ax.set_xlabel("Tipo de análisis")
+        ax.set_ylabel("Cantidad")
+        st.pyplot(fig)
+
+    # Histórico de Análisis Morfosintácticos
+    with st.expander("Histórico de Análisis Morfosintácticos"):
+        morpho_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
+        for analysis in morpho_analyses[:5]:  # Mostrar los últimos 5
+            st.subheader(f"Análisis del {analysis['timestamp']}")
+            if 'arc_diagrams' in analysis:
+                st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
+
+    # Histórico de Análisis Semánticos
+    with st.expander("Histórico de Análisis Semánticos"):
+        semantic_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
+        for analysis in semantic_analyses[:5]:  # Mostrar los últimos 5
+            st.subheader(f"Análisis del {analysis['timestamp']}")
+            if 'key_concepts' in analysis:
+                concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis['key_concepts']])
+                st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
+            if 'graph' in analysis:
+                try:
+                    img_bytes = base64.b64decode(analysis['graph'])
+                    st.image(img_bytes, caption="Gráfico de relaciones conceptuales")
+                except Exception as e:
+                    st.error(f"No se pudo mostrar el gráfico: {str(e)}")
+
+    # Histórico de Análisis Discursivos
+    with st.expander("Histórico de Análisis Discursivos"):
+        discourse_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
+        for analysis in discourse_analyses[:5]:  # Mostrar los últimos 5
+            st.subheader(f"Análisis del {analysis['timestamp']}")
+            for i in [1, 2]:
+                if f'key_concepts{i}' in analysis:
+                    concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis[f'key_concepts{i}']])
+                    st.write(f"Conceptos clave del documento {i}:")
+                    st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
+            if 'combined_graph' in analysis:
+                try:
+                    img_bytes = base64.b64decode(analysis['combined_graph'])
+                    st.image(img_bytes)
+                except Exception as e:
+                    st.error(f"No se pudo mostrar el gráfico combinado: {str(e)}")
+
+    # Histórico de Conversaciones con el ChatBot
+    with st.expander("Histórico de Conversaciones con el ChatBot"):
+        if 'chat_history' in student_data:
+            for i, chat in enumerate(student_data['chat_history'][:5]):  # Mostrar las últimas 5 conversaciones
+                st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
+                for message in chat['messages']:
+                    st.write(f"{message['role'].capitalize()}: {message['content']}")
+                st.write("---")
+        else:
+            st.write("No se encontraron conversaciones con el ChatBot.")
+
+    # Opción para mostrar datos de depuración
+    if st.checkbox("Mostrar datos de depuración"):
+        st.write("Datos del estudiante (para depuración):")
+        st.json(student_data)
+
 '''

modules/studentact/student_activities_v2-error.py

@@ -1,251 +1,251 @@
-##############
-###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
-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
-
-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('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 Análisis Morfosintáctico
-        with tabs[0]:
-            display_morphosyntax_activities(username, t)
-
-        # Tab de Análisis Semántico
-        with tabs[1]:
-            display_semantic_activities(username, t)
-
-        # Tab de Análisis del Discurso
-        with tabs[2]:
-            display_discourse_activities(username, t)
-
-        # Tab de Conversaciones del Chat
-        with tabs[3]:
-            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_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:
-        analyses = get_student_semantic_analysis(username)
-        if not analyses:
-            st.info(t.get('no_semantic_analyses', 'No hay análisis semánticos registrados'))
-            return
-
-        for analysis in analyses:
-            with st.expander(
-                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
-                expanded=False
-            ):
-                
-                # Mostrar conceptos clave
-                if 'key_concepts' in analysis:
-                    st.subheader(t.get('key_concepts', 'Conceptos clave'))
-                    df = pd.DataFrame(
-                        analysis['key_concepts'],
-                        columns=['Concepto', 'Frecuencia']
-                    )
-                    st.dataframe(df)
-
-                # Mostrar gráfico de conceptos
-                if 'concept_graph' in analysis and analysis['concept_graph']:
-                    st.subheader(t.get('concept_graph', 'Grafo de conceptos'))
-                    image_bytes = base64.b64decode(analysis['concept_graph'])
-                    st.image(image_bytes)
-
-    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:
-        analyses = get_student_discourse_analysis(username)
-        if not analyses:
-            st.info(t.get('no_discourse_analyses', 'No hay análisis del discurso registrados'))
-            return
-
-        for analysis in analyses:
-            with st.expander(
-                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
-                expanded=False
-            ):
-
-                # Mostrar conceptos clave
-                if 'key_concepts1' in analysis and 'key_concepts2' in analysis:
-                    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'],
-                            columns=['Concepto', 'Frecuencia']
-                        )
-                        st.dataframe(df1)
-                    
-                    with col2:
-                        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
-                        df2 = pd.DataFrame(
-                            analysis['key_concepts2'],
-                            columns=['Concepto', 'Frecuencia']
-                        )
-                        st.dataframe(df2)
-
-                # Mostrar gráficos
-                if all(key in analysis for key in ['graph1', 'graph2']):
-                    st.subheader(t.get('visualizations', 'Visualizaciones'))
-                    
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        st.markdown(f"**{t.get('graph_text_1', 'Grafo Texto 1')}**")
-                        if analysis['graph1']:
-                            image_bytes = base64.b64decode(analysis['graph1'])
-                            st.image(image_bytes)
-                    
-                    with col2:
-                        st.markdown(f"**{t.get('graph_text_2', 'Grafo Texto 2')}**")
-                        if analysis['graph2']:
-                            image_bytes = base64.b64decode(analysis['graph2'])
-                            st.image(image_bytes)
-
-    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_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)
-
-#################################################################################   
-
-        
-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)}")
+##############
+###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
+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
+
+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('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 Análisis Morfosintáctico
+        with tabs[0]:
+            display_morphosyntax_activities(username, t)
+
+        # Tab de Análisis Semántico
+        with tabs[1]:
+            display_semantic_activities(username, t)
+
+        # Tab de Análisis del Discurso
+        with tabs[2]:
+            display_discourse_activities(username, t)
+
+        # Tab de Conversaciones del Chat
+        with tabs[3]:
+            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_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:
+        analyses = get_student_semantic_analysis(username)
+        if not analyses:
+            st.info(t.get('no_semantic_analyses', 'No hay análisis semánticos registrados'))
+            return
+
+        for analysis in analyses:
+            with st.expander(
+                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
+                expanded=False
+            ):
+                
+                # Mostrar conceptos clave
+                if 'key_concepts' in analysis:
+                    st.subheader(t.get('key_concepts', 'Conceptos clave'))
+                    df = pd.DataFrame(
+                        analysis['key_concepts'],
+                        columns=['Concepto', 'Frecuencia']
+                    )
+                    st.dataframe(df)
+
+                # Mostrar gráfico de conceptos
+                if 'concept_graph' in analysis and analysis['concept_graph']:
+                    st.subheader(t.get('concept_graph', 'Grafo de conceptos'))
+                    image_bytes = base64.b64decode(analysis['concept_graph'])
+                    st.image(image_bytes)
+
+    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:
+        analyses = get_student_discourse_analysis(username)
+        if not analyses:
+            st.info(t.get('no_discourse_analyses', 'No hay análisis del discurso registrados'))
+            return
+
+        for analysis in analyses:
+            with st.expander(
+                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
+                expanded=False
+            ):
+
+                # Mostrar conceptos clave
+                if 'key_concepts1' in analysis and 'key_concepts2' in analysis:
+                    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'],
+                            columns=['Concepto', 'Frecuencia']
+                        )
+                        st.dataframe(df1)
+                    
+                    with col2:
+                        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+                        df2 = pd.DataFrame(
+                            analysis['key_concepts2'],
+                            columns=['Concepto', 'Frecuencia']
+                        )
+                        st.dataframe(df2)
+
+                # Mostrar gráficos
+                if all(key in analysis for key in ['graph1', 'graph2']):
+                    st.subheader(t.get('visualizations', 'Visualizaciones'))
+                    
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.markdown(f"**{t.get('graph_text_1', 'Grafo Texto 1')}**")
+                        if analysis['graph1']:
+                            image_bytes = base64.b64decode(analysis['graph1'])
+                            st.image(image_bytes)
+                    
+                    with col2:
+                        st.markdown(f"**{t.get('graph_text_2', 'Grafo Texto 2')}**")
+                        if analysis['graph2']:
+                            image_bytes = base64.b64decode(analysis['graph2'])
+                            st.image(image_bytes)
+
+    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_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)
+
+#################################################################################   
+
+        
+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'))

modules/studentact/student_activities_v2.py

@@ -1,282 +1,571 @@
-##############
-###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
-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
-
-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('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 Análisis Morfosintáctico
-        with tabs[0]:
-            display_morphosyntax_activities(username, t)
-
-        # Tab de Análisis Semántico
-        with tabs[1]:
-            display_semantic_activities(username, t)
-
-        # Tab de Análisis del Discurso
-        with tabs[2]:
-            display_discourse_activities(username, t)
-
-        # Tab de Conversaciones del Chat
-        with tabs[3]:
-            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_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_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)
-
-#################################################################################   
-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'))
+ ##############
+###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/temp_current_situation_interface.py

@@ -1,311 +1,311 @@
-# modules/studentact/current_situation_interface.py
-
-import streamlit as st
-import logging
-from ..utils.widget_utils import generate_unique_key
-from .current_situation_analysis import (
-    analyze_text_dimensions,
-    create_vocabulary_network,
-    create_syntax_complexity_graph, 
-    create_cohesion_heatmap
-)
-
-logger = logging.getLogger(__name__)
-
-def display_current_situation_interface(lang_code, nlp_models, t):
-    """
-    Interfaz modular para el análisis de la situación actual del estudiante.
-    Esta función maneja la presentación y la interacción con el usuario.
-    
-    Args:
-        lang_code: Código del idioma actual
-        nlp_models: Diccionario de modelos de spaCy cargados
-        t: Diccionario de traducciones
-    """
-    st.markdown("## Mi Situación Actual de Escritura")
-    
-    # Container principal para mejor organización visual
-    with st.container():
-        # Columnas para entrada y visualización
-        text_col, visual_col = st.columns([1,2])
-        
-        with text_col:
-            # Área de entrada de texto
-            text_input = st.text_area(
-                t.get('current_situation_input', "Ingresa tu texto para analizar:"),
-                height=400,
-                key=generate_unique_key("current_situation", "input")
-            )
-            
-            # Botón de análisis
-            if st.button(
-                t.get('analyze_button', "Explorar mi escritura"),
-                type="primary",
-                disabled=not text_input,
-                key=generate_unique_key("current_situation", "analyze")
-            ):
-                try:
-                    with st.spinner(t.get('processing', "Analizando texto...")):
-                        # 1. Procesar el texto
-                        doc = nlp_models[lang_code](text_input)
-                        metrics = analyze_text_dimensions(doc)
-                        
-                        # 2. Mostrar visualizaciones en la columna derecha
-                        with visual_col:
-                            display_current_situation_visual(doc, metrics)
-                        
-                        # 3. Obtener retroalimentación de Claude
-                        feedback = get_claude_feedback(metrics, text_input)
-                        
-                        # 4. Guardar los resultados
-                        from ..database.current_situation_mongo_db import store_current_situation_result
-                        
-                    if st.button(t.get('analyze_button', "Explorar mi escritura")):
-                        with st.spinner(t.get('processing', "Analizando texto...")):
-                            # Procesar y analizar
-                            doc = nlp_models[lang_code](text_input)
-                            
-                            # Obtener métricas con manejo de errores
-                            try:
-                                metrics = analyze_text_dimensions(doc)
-                            except Exception as e:
-                                logger.error(f"Error en análisis: {str(e)}")
-                                st.error("Error en el análisis de dimensiones")
-                                return
-                            
-                            # Obtener feedback
-                            try:
-                                feedback = get_claude_feedback(metrics, text_input)
-                            except Exception as e:
-                                logger.error(f"Error obteniendo feedback: {str(e)}")
-                                st.error("Error obteniendo retroalimentación")
-                                return
-                            
-                            # Guardar resultados con verificación
-                            if store_current_situation_result(
-                                st.session_state.username,
-                                text_input,
-                                metrics,
-                                feedback
-                            ):
-                                st.success(t.get('save_success', "Análisis guardado"))
-                                
-                                # Mostrar visualizaciones y recomendaciones
-                                display_current_situation_visual(doc, metrics)
-                                show_recommendations(feedback, t)
-                            else:
-                                st.error("Error al guardar el análisis")
-                                
-                except Exception as e:
-                    logger.error(f"Error en interfaz: {str(e)}")
-                    st.error("Error general en la interfaz")
-
-################################################################
-def display_current_situation_visual(doc, metrics):
-    """Visualización mejorada de resultados con interpretaciones"""
-    try:
-        with st.container():
-            # Estilos CSS mejorados para los contenedores
-            st.markdown("""
-                <style>
-                .graph-container {
-                    background-color: white;
-                    border-radius: 10px;
-                    padding: 20px;
-                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-                    margin: 15px 0;
-                }
-                .interpretation-box {
-                    background-color: #f8f9fa;
-                    border-left: 4px solid #0d6efd;
-                    padding: 15px;
-                    margin: 10px 0;
-                }
-                .metric-indicator {
-                    font-size: 1.2em;
-                    font-weight: 500;
-                    color: #1f2937;
-                }
-                </style>
-            """, unsafe_allow_html=True)
-
-            # 1. Riqueza de Vocabulario
-            with st.expander("📚 Riqueza de Vocabulario", expanded=True):
-                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
-                vocabulary_graph = create_vocabulary_network(doc)
-                if vocabulary_graph:
-                    # Mostrar gráfico
-                    st.pyplot(vocabulary_graph)
-                    plt.close(vocabulary_graph)
-                    
-                    # Interpretación
-                    st.markdown('<div class="interpretation-box">', unsafe_allow_html=True)
-                    st.markdown("**¿Qué significa este gráfico?**")
-                    st.markdown("""
-                        - 🔵 Los nodos azules representan palabras clave en tu texto
-                        - 📏 El tamaño de cada nodo indica su frecuencia de uso
-                        - 🔗 Las líneas conectan palabras que aparecen juntas frecuentemente
-                        - 🎨 Los colores más intensos indican palabras más centrales
-                    """)
-                    st.markdown("</div>", unsafe_allow_html=True)
-                st.markdown("</div>", unsafe_allow_html=True)
-
-            # 2. Estructura de Oraciones
-            with st.expander("🏗️ Complejidad Estructural", expanded=True):
-                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
-                syntax_graph = create_syntax_complexity_graph(doc)
-                if syntax_graph:
-                    st.pyplot(syntax_graph)
-                    plt.close(syntax_graph)
-                    
-                    st.markdown('<div class="interpretation-box">', unsafe_allow_html=True)
-                    st.markdown("**Análisis de la estructura:**")
-                    st.markdown("""
-                        - 📊 Las barras muestran la complejidad de cada oración
-                        - 📈 Mayor altura indica estructuras más elaboradas
-                        - 🎯 La línea punteada indica el nivel óptimo de complejidad
-                        - 🔄 Variación en las alturas sugiere dinamismo en la escritura
-                    """)
-                    st.markdown("</div>", unsafe_allow_html=True)
-                st.markdown("</div>", unsafe_allow_html=True)
-
-            # 3. Cohesión Textual
-            with st.expander("🔄 Cohesión del Texto", expanded=True):
-                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
-                cohesion_map = create_cohesion_heatmap(doc)
-                if cohesion_map:
-                    st.pyplot(cohesion_map)
-                    plt.close(cohesion_map)
-                    
-                    st.markdown('<div class="interpretation-box">', unsafe_allow_html=True)
-                    st.markdown("**¿Cómo leer el mapa de calor?**")
-                    st.markdown("""
-                        - 🌈 Colores más intensos indican mayor conexión entre oraciones
-                        - 📝 La diagonal muestra la coherencia interna de cada oración
-                        - 🔗 Las zonas claras sugieren oportunidades de mejorar conexiones
-                        - 🎯 Un buen texto muestra patrones de color consistentes
-                    """)
-                    st.markdown("</div>", unsafe_allow_html=True)
-                st.markdown("</div>", unsafe_allow_html=True)
-
-            # 4. Métricas Generales
-            with st.expander("📊 Resumen de Métricas", expanded=True):
-                col1, col2, col3 = st.columns(3)
-                
-                with col1:
-                    st.metric(
-                        "Diversidad Léxica",
-                        f"{metrics['vocabulary_richness']:.2f}/1.0",
-                        help="Mide la variedad de palabras diferentes utilizadas"
-                    )
-                
-                with col2:
-                    st.metric(
-                        "Complejidad Estructural",
-                        f"{metrics['structural_complexity']:.2f}/1.0",
-                        help="Indica qué tan elaboradas son las estructuras de las oraciones"
-                    )
-                
-                with col3:
-                    st.metric(
-                        "Cohesión Textual",
-                        f"{metrics['cohesion_score']:.2f}/1.0",
-                        help="Evalúa qué tan bien conectadas están las ideas entre sí"
-                    )
-
-    except Exception as e:
-        logger.error(f"Error en visualización: {str(e)}")
-        st.error("Error al generar las visualizaciones")
-
-################################################################
-def show_recommendations(feedback, t):
-    """
-    Muestra las recomendaciones y ejercicios personalizados para el estudiante,
-    permitiendo el seguimiento de su progreso.
-    
-    Args:
-        feedback: Diccionario con retroalimentación y ejercicios recomendados
-        t: Diccionario de traducciones
-    """
-    st.markdown("### " + t.get('recommendations_title', "Recomendaciones para mejorar"))
-    
-    for area, exercises in feedback['recommendations'].items():
-        with st.expander(f"💡 {area}"):
-            try:
-                # Descripción del área de mejora
-                st.markdown(exercises['description'])
-                
-                # Obtener el historial de ejercicios del estudiante
-                from ..database.current_situation_mongo_db import get_student_exercises_history
-                exercises_history = get_student_exercises_history(st.session_state.username)
-                
-                # Separar ejercicios en completados y pendientes
-                completed = exercises_history.get(area, [])
-                
-                # Mostrar estado actual
-                progress_col1, progress_col2 = st.columns([3,1])
-                with progress_col1:
-                    st.markdown("**Ejercicio sugerido:**")
-                    st.markdown(exercises['activity'])
-                
-                with progress_col2:
-                    # Verificar si el ejercicio ya está completado
-                    exercise_key = f"{area}_{exercises['activity']}"
-                    is_completed = exercise_key in completed
-                    
-                    if is_completed:
-                        st.success("✅ Completado")
-                    else:
-                        # Botón para marcar ejercicio como completado
-                        if st.button(
-                            t.get('mark_complete', "Marcar como completado"),
-                            key=generate_unique_key("exercise", area),
-                            type="primary"
-                        ):
-                            try:
-                                from ..database.current_situation_mongo_db import update_exercise_status
-                                
-                                # Actualizar estado del ejercicio
-                                success = update_exercise_status(
-                                    username=st.session_state.username,
-                                    area=area,
-                                    exercise=exercises['activity'],
-                                    completed=True
-                                )
-                                
-                                if success:
-                                    st.success(t.get(
-                                        'exercise_completed', 
-                                        "¡Ejercicio marcado como completado!"
-                                    ))
-                                    st.rerun()
-                                else:
-                                    st.error(t.get(
-                                        'exercise_error',
-                                        "Error al actualizar el estado del ejercicio"
-                                    ))
-                            except Exception as e:
-                                logger.error(f"Error actualizando estado del ejercicio: {str(e)}")
-                                st.error(t.get('update_error', "Error al actualizar el ejercicio"))
-                
-                # Mostrar recursos adicionales si existen
-                if 'resources' in exercises:
-                    st.markdown("**Recursos adicionales:**")
-                    for resource in exercises['resources']:
-                        st.markdown(f"- {resource}")
-                
-                # Mostrar fecha de finalización si está completado
-                if is_completed:
-                    completion_date = exercises_history[exercise_key].get('completion_date')
-                    if completion_date:
-                        st.caption(
-                            t.get('completed_on', "Completado el") + 
-                            f": {completion_date.strftime('%d/%m/%Y %H:%M')}"
-                        )
-                        
-            except Exception as e:
-                logger.error(f"Error mostrando recomendaciones para {area}: {str(e)}")
-                st.error(t.get(
-                    'recommendations_error',
-                    f"Error al mostrar las recomendaciones para {area}"
+# modules/studentact/current_situation_interface.py
+
+import streamlit as st
+import logging
+from ..utils.widget_utils import generate_unique_key
+from .current_situation_analysis import (
+    analyze_text_dimensions,
+    create_vocabulary_network,
+    create_syntax_complexity_graph, 
+    create_cohesion_heatmap
+)
+
+logger = logging.getLogger(__name__)
+
+def display_current_situation_interface(lang_code, nlp_models, t):
+    """
+    Interfaz modular para el análisis de la situación actual del estudiante.
+    Esta función maneja la presentación y la interacción con el usuario.
+    
+    Args:
+        lang_code: Código del idioma actual
+        nlp_models: Diccionario de modelos de spaCy cargados
+        t: Diccionario de traducciones
+    """
+    st.markdown("## Mi Situación Actual de Escritura")
+    
+    # Container principal para mejor organización visual
+    with st.container():
+        # Columnas para entrada y visualización
+        text_col, visual_col = st.columns([1,2])
+        
+        with text_col:
+            # Área de entrada de texto
+            text_input = st.text_area(
+                t.get('current_situation_input', "Ingresa tu texto para analizar:"),
+                height=400,
+                key=generate_unique_key("current_situation", "input")
+            )
+            
+            # Botón de análisis
+            if st.button(
+                t.get('analyze_button', "Explorar mi escritura"),
+                type="primary",
+                disabled=not text_input,
+                key=generate_unique_key("current_situation", "analyze")
+            ):
+                try:
+                    with st.spinner(t.get('processing', "Analizando texto...")):
+                        # 1. Procesar el texto
+                        doc = nlp_models[lang_code](text_input)
+                        metrics = analyze_text_dimensions(doc)
+                        
+                        # 2. Mostrar visualizaciones en la columna derecha
+                        with visual_col:
+                            display_current_situation_visual(doc, metrics)
+                        
+                        # 3. Obtener retroalimentación de Claude
+                        feedback = get_claude_feedback(metrics, text_input)
+                        
+                        # 4. Guardar los resultados
+                        from ..database.current_situation_mongo_db import store_current_situation_result
+                        
+                    if st.button(t.get('analyze_button', "Explorar mi escritura")):
+                        with st.spinner(t.get('processing', "Analizando texto...")):
+                            # Procesar y analizar
+                            doc = nlp_models[lang_code](text_input)
+                            
+                            # Obtener métricas con manejo de errores
+                            try:
+                                metrics = analyze_text_dimensions(doc)
+                            except Exception as e:
+                                logger.error(f"Error en análisis: {str(e)}")
+                                st.error("Error en el análisis de dimensiones")
+                                return
+                            
+                            # Obtener feedback
+                            try:
+                                feedback = get_claude_feedback(metrics, text_input)
+                            except Exception as e:
+                                logger.error(f"Error obteniendo feedback: {str(e)}")
+                                st.error("Error obteniendo retroalimentación")
+                                return
+                            
+                            # Guardar resultados con verificación
+                            if store_current_situation_result(
+                                st.session_state.username,
+                                text_input,
+                                metrics,
+                                feedback
+                            ):
+                                st.success(t.get('save_success', "Análisis guardado"))
+                                
+                                # Mostrar visualizaciones y recomendaciones
+                                display_current_situation_visual(doc, metrics)
+                                show_recommendations(feedback, t)
+                            else:
+                                st.error("Error al guardar el análisis")
+                                
+                except Exception as e:
+                    logger.error(f"Error en interfaz: {str(e)}")
+                    st.error("Error general en la interfaz")
+
+################################################################
+def display_current_situation_visual(doc, metrics):
+    """Visualización mejorada de resultados con interpretaciones"""
+    try:
+        with st.container():
+            # Estilos CSS mejorados para los contenedores
+            st.markdown("""
+                <style>
+                .graph-container {
+                    background-color: white;
+                    border-radius: 10px;
+                    padding: 20px;
+                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                    margin: 15px 0;
+                }
+                .interpretation-box {
+                    background-color: #f8f9fa;
+                    border-left: 4px solid #0d6efd;
+                    padding: 15px;
+                    margin: 10px 0;
+                }
+                .metric-indicator {
+                    font-size: 1.2em;
+                    font-weight: 500;
+                    color: #1f2937;
+                }
+                </style>
+            """, unsafe_allow_html=True)
+
+            # 1. Riqueza de Vocabulario
+            with st.expander("📚 Riqueza de Vocabulario", expanded=True):
+                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                vocabulary_graph = create_vocabulary_network(doc)
+                if vocabulary_graph:
+                    # Mostrar gráfico
+                    st.pyplot(vocabulary_graph)
+                    plt.close(vocabulary_graph)
+                    
+                    # Interpretación
+                    st.markdown('<div class="interpretation-box">', unsafe_allow_html=True)
+                    st.markdown("**¿Qué significa este gráfico?**")
+                    st.markdown("""
+                        - 🔵 Los nodos azules representan palabras clave en tu texto
+                        - 📏 El tamaño de cada nodo indica su frecuencia de uso
+                        - 🔗 Las líneas conectan palabras que aparecen juntas frecuentemente
+                        - 🎨 Los colores más intensos indican palabras más centrales
+                    """)
+                    st.markdown("</div>", unsafe_allow_html=True)
+                st.markdown("</div>", unsafe_allow_html=True)
+
+            # 2. Estructura de Oraciones
+            with st.expander("🏗️ Complejidad Estructural", expanded=True):
+                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                syntax_graph = create_syntax_complexity_graph(doc)
+                if syntax_graph:
+                    st.pyplot(syntax_graph)
+                    plt.close(syntax_graph)
+                    
+                    st.markdown('<div class="interpretation-box">', unsafe_allow_html=True)
+                    st.markdown("**Análisis de la estructura:**")
+                    st.markdown("""
+                        - 📊 Las barras muestran la complejidad de cada oración
+                        - 📈 Mayor altura indica estructuras más elaboradas
+                        - 🎯 La línea punteada indica el nivel óptimo de complejidad
+                        - 🔄 Variación en las alturas sugiere dinamismo en la escritura
+                    """)
+                    st.markdown("</div>", unsafe_allow_html=True)
+                st.markdown("</div>", unsafe_allow_html=True)
+
+            # 3. Cohesión Textual
+            with st.expander("🔄 Cohesión del Texto", expanded=True):
+                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                cohesion_map = create_cohesion_heatmap(doc)
+                if cohesion_map:
+                    st.pyplot(cohesion_map)
+                    plt.close(cohesion_map)
+                    
+                    st.markdown('<div class="interpretation-box">', unsafe_allow_html=True)
+                    st.markdown("**¿Cómo leer el mapa de calor?**")
+                    st.markdown("""
+                        - 🌈 Colores más intensos indican mayor conexión entre oraciones
+                        - 📝 La diagonal muestra la coherencia interna de cada oración
+                        - 🔗 Las zonas claras sugieren oportunidades de mejorar conexiones
+                        - 🎯 Un buen texto muestra patrones de color consistentes
+                    """)
+                    st.markdown("</div>", unsafe_allow_html=True)
+                st.markdown("</div>", unsafe_allow_html=True)
+
+            # 4. Métricas Generales
+            with st.expander("📊 Resumen de Métricas", expanded=True):
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    st.metric(
+                        "Diversidad Léxica",
+                        f"{metrics['vocabulary_richness']:.2f}/1.0",
+                        help="Mide la variedad de palabras diferentes utilizadas"
+                    )
+                
+                with col2:
+                    st.metric(
+                        "Complejidad Estructural",
+                        f"{metrics['structural_complexity']:.2f}/1.0",
+                        help="Indica qué tan elaboradas son las estructuras de las oraciones"
+                    )
+                
+                with col3:
+                    st.metric(
+                        "Cohesión Textual",
+                        f"{metrics['cohesion_score']:.2f}/1.0",
+                        help="Evalúa qué tan bien conectadas están las ideas entre sí"
+                    )
+
+    except Exception as e:
+        logger.error(f"Error en visualización: {str(e)}")
+        st.error("Error al generar las visualizaciones")
+
+################################################################
+def show_recommendations(feedback, t):
+    """
+    Muestra las recomendaciones y ejercicios personalizados para el estudiante,
+    permitiendo el seguimiento de su progreso.
+    
+    Args:
+        feedback: Diccionario con retroalimentación y ejercicios recomendados
+        t: Diccionario de traducciones
+    """
+    st.markdown("### " + t.get('recommendations_title', "Recomendaciones para mejorar"))
+    
+    for area, exercises in feedback['recommendations'].items():
+        with st.expander(f"💡 {area}"):
+            try:
+                # Descripción del área de mejora
+                st.markdown(exercises['description'])
+                
+                # Obtener el historial de ejercicios del estudiante
+                from ..database.current_situation_mongo_db import get_student_exercises_history
+                exercises_history = get_student_exercises_history(st.session_state.username)
+                
+                # Separar ejercicios en completados y pendientes
+                completed = exercises_history.get(area, [])
+                
+                # Mostrar estado actual
+                progress_col1, progress_col2 = st.columns([3,1])
+                with progress_col1:
+                    st.markdown("**Ejercicio sugerido:**")
+                    st.markdown(exercises['activity'])
+                
+                with progress_col2:
+                    # Verificar si el ejercicio ya está completado
+                    exercise_key = f"{area}_{exercises['activity']}"
+                    is_completed = exercise_key in completed
+                    
+                    if is_completed:
+                        st.success("✅ Completado")
+                    else:
+                        # Botón para marcar ejercicio como completado
+                        if st.button(
+                            t.get('mark_complete', "Marcar como completado"),
+                            key=generate_unique_key("exercise", area),
+                            type="primary"
+                        ):
+                            try:
+                                from ..database.current_situation_mongo_db import update_exercise_status
+                                
+                                # Actualizar estado del ejercicio
+                                success = update_exercise_status(
+                                    username=st.session_state.username,
+                                    area=area,
+                                    exercise=exercises['activity'],
+                                    completed=True
+                                )
+                                
+                                if success:
+                                    st.success(t.get(
+                                        'exercise_completed', 
+                                        "¡Ejercicio marcado como completado!"
+                                    ))
+                                    st.rerun()
+                                else:
+                                    st.error(t.get(
+                                        'exercise_error',
+                                        "Error al actualizar el estado del ejercicio"
+                                    ))
+                            except Exception as e:
+                                logger.error(f"Error actualizando estado del ejercicio: {str(e)}")
+                                st.error(t.get('update_error', "Error al actualizar el ejercicio"))
+                
+                # Mostrar recursos adicionales si existen
+                if 'resources' in exercises:
+                    st.markdown("**Recursos adicionales:**")
+                    for resource in exercises['resources']:
+                        st.markdown(f"- {resource}")
+                
+                # Mostrar fecha de finalización si está completado
+                if is_completed:
+                    completion_date = exercises_history[exercise_key].get('completion_date')
+                    if completion_date:
+                        st.caption(
+                            t.get('completed_on', "Completado el") + 
+                            f": {completion_date.strftime('%d/%m/%Y %H:%M')}"
+                        )
+                        
+            except Exception as e:
+                logger.error(f"Error mostrando recomendaciones para {area}: {str(e)}")
+                st.error(t.get(
+                    'recommendations_error',
+                    f"Error al mostrar las recomendaciones para {area}"
                 ))