Merge branch #AIdeaText/v3' into 'AIdeaText/v4'

README.md

@@ -4,7 +4,7 @@ emoji: 👀
 colorFrom: blue
 colorTo: purple
 sdk: streamlit
-sdk_version: 1.40.1
+sdk_version: 1.41.1
 app_file: app.py
 pinned: true
 license: mit

app.py

@@ -109,6 +109,7 @@ from modules.database.chat_mongo_db import (
 
 # Importaciones de base de datos
 from modules.studentact.student_activities_v2 import display_student_activities
+from modules.studentact.current_situation_interface import display_current_situation_interface
 
 from modules.auth.auth import (
     authenticate_student,

modules/__init__.py

@@ -9,6 +9,69 @@ def load_auth_functions():
         'delete_student': delete_student
     }
 
+# Agregar nuevo import para current_situation
+def load_current_situation_functions():
+    """
+    Carga las funciones relacionadas con el análisis de situación actual.
+    Returns:
+        dict: Diccionario con las funciones de situación actual
+    """
+    from .studentact.current_situation_interface import (
+        display_current_situation_interface,
+        display_metrics_in_one_row,
+        display_empty_metrics_row,
+        display_metrics_analysis, 
+        display_comparison_results,
+        display_metrics_and_suggestions,
+        display_radar_chart,
+        suggest_improvement_tools,
+        prepare_metrics_config
+        )
+    
+    from .studentact.current_situation_analysis import (
+            correlate_metrics,
+            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
+        )
+    
+    return {
+        'display_current_situation_interface': display_current_situation_interface,
+        'display_metrics_in_one_row': display_metrics_in_one_line,
+        'display_empty_metrics_row': display_empty_metrics_row,
+        'display_metrics_analysis': display_metrics_analysis, 
+        'display_comparison_results': display_comparison_results,
+        'display_metrics_and_suggestions': display_metrics_and_suggestions,
+        'display_radar_chart': display_radar_chart,
+        'suggest_improvement_tools': suggest_improvement_tools,
+        'prepare_metrics_config': prepare_metrics_config,
+        'display_empty_metrics_row' : display_empty_metrics_row,
+        'correlate_metrics': correlate_metrics,
+        'analyze_text_dimensions': analyze_text_dimensions,
+        'analyze_clarity': analyze_clarity,
+        'analyze_vocabulary_diversity': analyze_vocabulary_diversity,
+        'analyze_cohesion': analyze_cohesion,
+        'analyze_structure': analyze_structure,
+        'get_dependency_depths': get_dependency_depths,
+        'normalize_score': normalize_score, 
+        'generate_sentence_graphs': generate_sentence_graphs, 
+        'generate_word_connections': generate_word_connections, 
+        'generate_connection_paths': generate_connection_paths,         
+        'create_vocabulary_network': create_vocabulary_network,
+        'create_syntax_complexity_graph': create_syntax_complexity_graph,
+        'create_cohesion_heatmap': create_cohesion_heatmap 
+    }
+
 def load_database_functions():
 
     from .database.database_init import (
@@ -63,9 +126,23 @@ def load_database_functions():
         get_student_discourse_data
     )
 
+    # Agregar nueva importación para current_situation
+    from .database.current_situation_mongo_db import (
+        store_current_situation_result,
+        verify_storage,
+        get_recent_sessions,
+        get_student_situation_history,
+        update_exercise_status
+    )
+    
     from .database.chat_mongo_db import store_chat_history, get_chat_history
 
     return {
+        'store_current_situation_result': store_current_situation_result,
+        'verify_storage': verify_storage,
+        'get_recent_sessions': get_recent_sessions,
+        'get_student_situation_history': get_student_situation_history,
+        'update_exercise_status': update_exercise_status,
         'initialize_database_connections': initialize_database_connections,
         'get_container': get_container,
         'get_mongodb': get_mongodb,
@@ -214,5 +291,6 @@ def load_all_functions():
         **load_discourse_functions(),
         **load_utils_functions(),
         **load_chatbot_functions(),
-        **load_student_activities_functions()
+        **load_student_activities_functions(),
+        **load_current_situation_functions()  # Agregar el nuevo loader
     }

modules/database/current_situation_mongo_db.py

@@ -0,0 +1,112 @@
+# modules/database/current_situation_mongo_db.py
+from datetime import datetime, timezone, timedelta
+import logging
+from .mongo_db import get_collection
+
+logger = logging.getLogger(__name__)
+COLLECTION_NAME = 'student_current_situation'
+
+# En modules/database/current_situation_mongo_db.py
+
+def store_current_situation_result(username, text, metrics, feedback):
+    """
+    Guarda los resultados del análisis de situación actual.
+    """
+    try:
+        # Verificar parámetros
+        if not all([username, text, metrics]):
+            logger.error("Faltan parámetros requeridos")
+            return False
+
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección")
+            return False
+
+        # Crear documento
+        document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text': text,
+            'metrics': metrics,
+            'feedback': feedback or {},
+            'analysis_type': 'current_situation'
+        }
+
+        # Insertar documento y verificar
+        result = collection.insert_one(document)
+        if result.inserted_id:
+            logger.info(f"""
+                Análisis de situación actual guardado:
+                - Usuario: {username}
+                - ID: {result.inserted_id}
+                - Longitud texto: {len(text)}
+            """)
+            
+            # Verificar almacenamiento
+            storage_verified = verify_storage(username)
+            if not storage_verified:
+                logger.warning("Verificación de almacenamiento falló")
+            
+            return True
+
+        logger.error("No se pudo insertar el documento")
+        return False
+
+    except Exception as e:
+        logger.error(f"Error guardando análisis de situación actual: {str(e)}")
+        return False
+
+def verify_storage(username):
+    """
+    Verifica que los datos se están guardando correctamente.
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección para verificación")
+            return False
+            
+        # Buscar documentos recientes del usuario
+        timestamp_threshold = (datetime.now(timezone.utc) - timedelta(minutes=5)).isoformat()
+        
+        recent_docs = collection.find({
+            'username': username,
+            'timestamp': {'$gte': timestamp_threshold}
+        }).sort('timestamp', -1).limit(1)
+
+        docs = list(recent_docs)
+        if docs:
+            logger.info(f"""
+                Último documento guardado:
+                - ID: {docs[0]['_id']}
+                - Timestamp: {docs[0]['timestamp']}
+                - Métricas guardadas: {bool(docs[0].get('metrics'))}
+            """)
+            return True
+        
+        logger.warning(f"No se encontraron documentos recientes para {username}")
+        return False
+
+    except Exception as e:
+        logger.error(f"Error verificando almacenamiento: {str(e)}")
+        return False
+
+def get_recent_situation_analysis(username, limit=5):
+    """
+    Obtiene los análisis más recientes de un usuario.
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            return []
+            
+        results = collection.find(
+            {'username': username}
+        ).sort('timestamp', -1).limit(limit)
+        
+        return list(results)
+        
+    except Exception as e:
+        logger.error(f"Error obteniendo análisis recientes: {str(e)}")
+        return []

modules/database/mongo_db.py

@@ -1,51 +1,62 @@
-from .database_init import get_mongodb
-import logging
-
-logger = logging.getLogger(__name__)
-
-def get_collection(collection_name):
-    db = get_mongodb()
-    return db[collection_name]
-
-def insert_document(collection_name, document):
-    collection = get_collection(collection_name)
-    try:
-        result = collection.insert_one(document)
-        logger.info(f"Documento insertado en {collection_name} con ID: {result.inserted_id}")
-        return result.inserted_id
-    except Exception as e:
-        logger.error(f"Error al insertar documento en {collection_name}: {str(e)}")
-        return None
-
-def find_documents(collection_name, query, sort=None, limit=None):
-    collection = get_collection(collection_name)
-    try:
-        cursor = collection.find(query)
-        if sort:
-            cursor = cursor.sort(sort)
-        if limit:
-            cursor = cursor.limit(limit)
-        return list(cursor)
-    except Exception as e:
-        logger.error(f"Error al buscar documentos en {collection_name}: {str(e)}")
-        return []
-
-def update_document(collection_name, query, update):
-    collection = get_collection(collection_name)
-    try:
-        result = collection.update_one(query, update)
-        logger.info(f"Documento actualizado en {collection_name}: {result.modified_count} modificado(s)")
-        return result.modified_count
-    except Exception as e:
-        logger.error(f"Error al actualizar documento en {collection_name}: {str(e)}")
-        return 0
-
-def delete_document(collection_name, query):
-    collection = get_collection(collection_name)
-    try:
-        result = collection.delete_one(query)
-        logger.info(f"Documento eliminado de {collection_name}: {result.deleted_count} eliminado(s)")
-        return result.deleted_count
-    except Exception as e:
-        logger.error(f"Error al eliminar documento de {collection_name}: {str(e)}")
+from .database_init import get_mongodb
+import logging
+
+logger = logging.getLogger(__name__)
+
+def get_collection(collection_name):
+    try:
+        db = get_mongodb()
+        if db is None:
+            logger.error(f"No se pudo obtener la base de datos para {collection_name}")
+            return None
+            
+        collection = db[collection_name]
+        logger.info(f"Colección {collection_name} obtenida exitosamente")
+        return collection
+        
+    except Exception as e:
+        logger.error(f"Error al obtener colección {collection_name}: {str(e)}")
+        return None
+
+def insert_document(collection_name, document):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.insert_one(document)
+        logger.info(f"Documento insertado en {collection_name} con ID: {result.inserted_id}")
+        return result.inserted_id
+    except Exception as e:
+        logger.error(f"Error al insertar documento en {collection_name}: {str(e)}")
+        return None
+
+def find_documents(collection_name, query, sort=None, limit=None):
+    collection = get_collection(collection_name)
+    try:
+        cursor = collection.find(query)
+        if sort:
+            cursor = cursor.sort(sort)
+        if limit:
+            cursor = cursor.limit(limit)
+        return list(cursor)
+    except Exception as e:
+        logger.error(f"Error al buscar documentos en {collection_name}: {str(e)}")
+        return []
+
+def update_document(collection_name, query, update):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.update_one(query, update)
+        logger.info(f"Documento actualizado en {collection_name}: {result.modified_count} modificado(s)")
+        return result.modified_count
+    except Exception as e:
+        logger.error(f"Error al actualizar documento en {collection_name}: {str(e)}")
+        return 0
+
+def delete_document(collection_name, query):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.delete_one(query)
+        logger.info(f"Documento eliminado de {collection_name}: {result.deleted_count} eliminado(s)")
+        return result.deleted_count
+    except Exception as e:
+        logger.error(f"Error al eliminar documento de {collection_name}: {str(e)}")
         return 0

modules/database/writing_progress_mongo_db.py

@@ -0,0 +1,141 @@
+# modules/database/writing_progress_mongo_db.py
+
+from .mongo_db import get_collection, insert_document
+from datetime import datetime, timezone
+import logging
+
+logger = logging.getLogger(__name__)
+COLLECTION_NAME = 'writing_progress'
+
+def store_writing_baseline(username, metrics, text):
+    """
+    Guarda la línea base de escritura de un usuario.
+    Args:
+        username: ID del usuario
+        metrics: Diccionario con métricas iniciales
+        text: Texto analizado
+    """
+    try:
+        document = {
+            'username': username,
+            'type': 'baseline',
+            'metrics': metrics,
+            'text': text,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'iteration': 0  # Línea base siempre es iteración 0
+        }
+        
+        # Verificar si ya existe una línea base
+        collection = get_collection(COLLECTION_NAME)
+        existing = collection.find_one({
+            'username': username,
+            'type': 'baseline'
+        })
+        
+        if existing:
+            # Actualizar línea base existente
+            result = collection.update_one(
+                {'_id': existing['_id']},
+                {'$set': document}
+            )
+            success = result.modified_count > 0
+        else:
+            # Insertar nueva línea base
+            result = collection.insert_one(document)
+            success = result.inserted_id is not None
+            
+        logger.info(f"Línea base {'actualizada' if existing else 'creada'} para usuario: {username}")
+        return success
+        
+    except Exception as e:
+        logger.error(f"Error al guardar línea base: {str(e)}")
+        return False
+
+def store_writing_progress(username, metrics, text):
+    """
+    Guarda una nueva iteración de progreso.
+    """
+    try:
+        # Obtener último número de iteración
+        collection = get_collection(COLLECTION_NAME)
+        last_progress = collection.find_one(
+            {'username': username},
+            sort=[('iteration', -1)]
+        )
+        
+        next_iteration = (last_progress['iteration'] + 1) if last_progress else 1
+        
+        document = {
+            'username': username,
+            'type': 'progress',
+            'metrics': metrics,
+            'text': text,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'iteration': next_iteration
+        }
+        
+        result = collection.insert_one(document)
+        success = result.inserted_id is not None
+        
+        if success:
+            logger.info(f"Progreso guardado para {username}, iteración {next_iteration}")
+        
+        return success
+        
+    except Exception as e:
+        logger.error(f"Error al guardar progreso: {str(e)}")
+        return False
+
+def get_writing_baseline(username):
+    """
+    Obtiene la línea base de un usuario.
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        return collection.find_one({
+            'username': username,
+            'type': 'baseline'
+        })
+    except Exception as e:
+        logger.error(f"Error al obtener línea base: {str(e)}")
+        return None
+
+def get_writing_progress(username, limit=None):
+    """
+    Obtiene el historial de progreso de un usuario.
+    Args:
+        username: ID del usuario
+        limit: Número máximo de registros a retornar
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        cursor = collection.find(
+            {
+                'username': username,
+                'type': 'progress'
+            },
+            sort=[('iteration', -1)]
+        )
+        
+        if limit:
+            cursor = cursor.limit(limit)
+            
+        return list(cursor)
+        
+    except Exception as e:
+        logger.error(f"Error al obtener progreso: {str(e)}")
+        return []
+
+def get_latest_writing_metrics(username):
+    """
+    Obtiene las métricas más recientes (línea base o progreso).
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        return collection.find_one(
+            {'username': username},
+            sort=[('timestamp', -1)]
+        )
+    except Exception as e:
+        logger.error(f"Error al obtener métricas recientes: {str(e)}")
+        return None

modules/morphosyntax/morphosyntax_interface-BackUp_Dec24_OK.py

@@ -0,0 +1,322 @@
+#modules/morphosyntax/morphosyntax_interface.py
+import streamlit as st
+from streamlit_float import *
+from streamlit_antd_components import *
+from streamlit.components.v1 import html
+import spacy
+from spacy import displacy
+import spacy_streamlit
+import pandas as pd
+import base64
+import re
+
+# Importar desde morphosyntax_process.py
+from .morphosyntax_process import (
+    process_morphosyntactic_input,
+    format_analysis_results,
+    perform_advanced_morphosyntactic_analysis,  # Añadir esta importación
+    get_repeated_words_colors,                  # Y estas también
+    highlight_repeated_words,
+    POS_COLORS,
+    POS_TRANSLATIONS
+)
+
+from ..utils.widget_utils import generate_unique_key
+
+from ..database.morphosintax_mongo_db import store_student_morphosyntax_result
+from ..database.chat_mongo_db import store_chat_history, get_chat_history
+
+# from ..database.morphosintaxis_export import export_user_interactions
+
+import logging
+logger = logging.getLogger(__name__)
+
+############################################################################################################
+def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
+    try:
+        # 1. Inicializar el estado morfosintáctico si no existe
+        if 'morphosyntax_state' not in st.session_state:
+            st.session_state.morphosyntax_state = {
+                'input_text': "",
+                'analysis_count': 0,
+                'last_analysis': None
+            }
+
+        # 2. Campo de entrada de texto con key única basada en el contador
+        input_key = f"morpho_input_{st.session_state.morphosyntax_state['analysis_count']}"
+        
+        sentence_input = st.text_area(
+            morpho_t.get('morpho_input_label', 'Enter text to analyze'),
+            height=150,
+            placeholder=morpho_t.get('morpho_input_placeholder', 'Enter your text here...'),
+            key=input_key
+        )
+
+        # 3. Actualizar el estado con el texto actual
+        st.session_state.morphosyntax_state['input_text'] = sentence_input
+
+        # 4. Crear columnas para el botón
+        col1, col2, col3 = st.columns([2,1,2])
+        
+        # 5. Botón de análisis en la columna central
+        with col1:
+            analyze_button = st.button(
+                morpho_t.get('morpho_analyze_button', 'Analyze Morphosyntax'),
+                key=f"morpho_button_{st.session_state.morphosyntax_state['analysis_count']}",
+                type="primary",  # Nuevo en Streamlit 1.39.0
+                icon="🔍",      # Nuevo en Streamlit 1.39.0
+                disabled=not bool(sentence_input.strip()),  # Se activa solo cuando hay texto
+                use_container_width=True
+            )
+
+        # 6. Lógica de análisis
+        if analyze_button and sentence_input.strip():  # Verificar que haya texto y no solo espacios
+            try:
+                with st.spinner(morpho_t.get('processing', 'Processing...')):
+                    # Obtener el modelo específico del idioma y procesar el texto
+                    doc = nlp_models[lang_code](sentence_input)
+                    
+                    # Realizar análisis morfosintáctico con el mismo modelo
+                    advanced_analysis = perform_advanced_morphosyntactic_analysis(
+                        sentence_input, 
+                        nlp_models[lang_code]
+                    )    
+    
+                    # Guardar resultado en el estado de la sesión
+                    st.session_state.morphosyntax_result = {
+                        'doc': doc,
+                        'advanced_analysis': advanced_analysis
+                    }
+    
+                    # Incrementar el contador de análisis
+                    st.session_state.morphosyntax_state['analysis_count'] += 1
+    
+                    # Guardar el análisis en la base de datos
+                    if store_student_morphosyntax_result(
+                        username=st.session_state.username,
+                        text=sentence_input,
+                        arc_diagrams=advanced_analysis['arc_diagrams']
+                    ):
+                        st.success(morpho_t.get('success_message', 'Analysis saved successfully'))
+                        
+                        # Mostrar resultados
+                        display_morphosyntax_results(
+                            st.session_state.morphosyntax_result, 
+                            lang_code, 
+                            morpho_t
+                        )
+                    else:
+                        st.error(morpho_t.get('error_message', 'Error saving analysis'))
+                    
+            except Exception as e:
+                logger.error(f"Error en análisis morfosintáctico: {str(e)}")
+                st.error(morpho_t.get('error_processing', f'Error processing text: {str(e)}'))
+                
+        # 7. Mostrar resultados previos si existen
+        elif 'morphosyntax_result' in st.session_state and st.session_state.morphosyntax_result is not None:
+            display_morphosyntax_results(
+                st.session_state.morphosyntax_result, 
+                lang_code, 
+                morpho_t
+            )
+        elif not sentence_input.strip():
+            st.info(morpho_t.get('morpho_initial_message', 'Enter text to begin analysis'))
+            
+    except Exception as e:
+        logger.error(f"Error general en display_morphosyntax_interface: {str(e)}")
+        st.error("Se produjo un error. Por favor, intente de nuevo.")
+        st.error(f"Detalles del error: {str(e)}")  # Añadido para mejor debugging
+
+############################################################################################################
+def display_morphosyntax_results(result, lang_code, morpho_t):
+    """
+    Muestra los resultados del análisis morfosintáctico.
+    Args:
+        result: Resultado del análisis
+        lang_code: Código del idioma
+        t: Diccionario de traducciones
+    """
+    # Obtener el diccionario de traducciones morfosintácticas
+    # morpho_t = t.get('MORPHOSYNTACTIC', {})
+    
+    if result is None:
+        st.warning(morpho_t.get('no_results', 'No results available'))
+        return
+
+    doc = result['doc']
+    advanced_analysis = result['advanced_analysis']
+    
+    # Mostrar leyenda
+    st.markdown(f"##### {morpho_t.get('legend', 'Legend: Grammatical categories')}")
+    legend_html = "<div style='display: flex; flex-wrap: wrap;'>"
+    for pos, color in POS_COLORS.items():
+        if pos in POS_TRANSLATIONS[lang_code]:
+            legend_html += f"<div style='margin-right: 10px;'><span style='background-color: {color}; padding: 2px 5px;'>{POS_TRANSLATIONS[lang_code][pos]}</span></div>"
+    legend_html += "</div>"
+    st.markdown(legend_html, unsafe_allow_html=True)
+
+    # Mostrar análisis de palabras repetidas
+    word_colors = get_repeated_words_colors(doc)
+    with st.expander(morpho_t.get('repeated_words', 'Repeated words'), expanded=True):
+        highlighted_text = highlight_repeated_words(doc, word_colors)
+        st.markdown(highlighted_text, unsafe_allow_html=True)
+    
+    # Mostrar estructura de oraciones
+    with st.expander(morpho_t.get('sentence_structure', 'Sentence structure'), expanded=True):
+        for i, sent_analysis in enumerate(advanced_analysis['sentence_structure']):
+            sentence_str = (
+                f"**{morpho_t.get('sentence', 'Sentence')} {i+1}** "  # Aquí está el cambio
+                f"{morpho_t.get('root', 'Root')}: {sent_analysis['root']} ({sent_analysis['root_pos']}) -- "  # Y aquí
+                f"{morpho_t.get('subjects', 'Subjects')}: {', '.join(sent_analysis['subjects'])} -- "  # Y aquí
+                f"{morpho_t.get('objects', 'Objects')}: {', '.join(sent_analysis['objects'])} -- "  # Y aquí
+                f"{morpho_t.get('verbs', 'Verbs')}: {', '.join(sent_analysis['verbs'])}"  # Y aquí
+            )
+            st.markdown(sentence_str)
+
+    # Mostrar análisis de categorías gramaticales # Mostrar análisis morfológico
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        with st.expander(morpho_t.get('pos_analysis', 'Part of speech'), expanded=True):
+            pos_df = pd.DataFrame(advanced_analysis['pos_analysis'])
+            
+            # Traducir las etiquetas POS a sus nombres en el idioma seleccionado
+            pos_df['pos'] = pos_df['pos'].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+            
+            # Renombrar las columnas para mayor claridad
+            pos_df = pos_df.rename(columns={
+                'pos': morpho_t.get('grammatical_category', 'Grammatical category'),
+                'count': morpho_t.get('count', 'Count'),
+                'percentage': morpho_t.get('percentage', 'Percentage'),
+                'examples': morpho_t.get('examples', 'Examples')
+            })
+                        
+            # Mostrar el dataframe
+            st.dataframe(pos_df)
+    
+    with col2:
+        with st.expander(morpho_t.get('morphological_analysis', 'Morphological Analysis'), expanded=True):
+            # 1. Crear el DataFrame inicial
+            morph_df = pd.DataFrame(advanced_analysis['morphological_analysis'])
+            
+            # 2. Primero renombrar las columnas usando las traducciones de la interfaz
+            column_mapping = {
+                'text': morpho_t.get('word', 'Word'),
+                'lemma': morpho_t.get('lemma', 'Lemma'),
+                'pos': morpho_t.get('grammatical_category', 'Grammatical category'),
+                'dep': morpho_t.get('dependency', 'Dependency'),
+                'morph': morpho_t.get('morphology', 'Morphology')
+            }
+            
+            # 3. Aplicar el renombrado
+            morph_df = morph_df.rename(columns=column_mapping)
+            
+            # 4. Traducir las categorías gramaticales usando POS_TRANSLATIONS global
+            grammatical_category = morpho_t.get('grammatical_category', 'Grammatical category')
+            morph_df[grammatical_category] = morph_df[grammatical_category].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+    
+            # 2.2 Traducir dependencias usando traducciones específicas
+            dep_translations = {
+                    
+                'es': {
+                    'ROOT': 'RAÍZ', 'nsubj': 'sujeto nominal', 'obj': 'objeto', 'iobj': 'objeto indirecto',
+                    'csubj': 'sujeto clausal', 'ccomp': 'complemento clausal', 'xcomp': 'complemento clausal abierto',
+                    'obl': 'oblicuo', 'vocative': 'vocativo', 'expl': 'expletivo', 'dislocated': 'dislocado',
+                    'advcl': 'cláusula adverbial', 'advmod': 'modificador adverbial', 'discourse': 'discurso',
+                    'aux': 'auxiliar', 'cop': 'cópula', 'mark': 'marcador', 'nmod': 'modificador nominal',
+                    'appos': 'aposición', 'nummod': 'modificador numeral', 'acl': 'cláusula adjetiva',
+                    'amod': 'modificador adjetival', 'det': 'determinante', 'clf': 'clasificador',
+                    'case': 'caso', 'conj': 'conjunción', 'cc': 'coordinante', 'fixed': 'fijo',
+                    'flat': 'plano', 'compound': 'compuesto', 'list': 'lista', 'parataxis': 'parataxis',
+                    'orphan': 'huérfano', 'goeswith': 'va con', 'reparandum': 'reparación', 'punct': 'puntuación'
+                },
+                    
+                'en': {
+                    'ROOT': 'ROOT', 'nsubj': 'nominal subject', 'obj': 'object',
+                    'iobj': 'indirect object', 'csubj': 'clausal subject', 'ccomp': 'clausal complement', 'xcomp': 'open clausal complement',
+                    'obl': 'oblique', 'vocative': 'vocative', 'expl': 'expletive', 'dislocated': 'dislocated', 'advcl': 'adverbial clause modifier',
+                    'advmod': 'adverbial modifier', 'discourse': 'discourse element', 'aux': 'auxiliary', 'cop': 'copula', 'mark': 'marker',
+                    'nmod': 'nominal modifier', 'appos': 'appositional modifier', 'nummod': 'numeric modifier', 'acl': 'clausal modifier of noun',
+                    'amod': 'adjectival modifier', 'det': 'determiner', 'clf': 'classifier', 'case': 'case marking',
+                    'conj': 'conjunct', 'cc': 'coordinating conjunction', 'fixed': 'fixed multiword expression',
+                    'flat': 'flat multiword expression', 'compound': 'compound', 'list': 'list', 'parataxis': 'parataxis', 'orphan': 'orphan',
+                    'goeswith': 'goes with', 'reparandum': 'reparandum', 'punct': 'punctuation'
+                },
+                    
+                'fr': {
+                    'ROOT': 'RACINE', 'nsubj': 'sujet nominal', 'obj': 'objet', 'iobj': 'objet indirect',
+                    'csubj': 'sujet phrastique', 'ccomp': 'complément phrastique', 'xcomp': 'complément phrastique ouvert', 'obl': 'oblique',
+                    'vocative': 'vocatif', 'expl': 'explétif', 'dislocated': 'disloqué', 'advcl': 'clause adverbiale', 'advmod': 'modifieur adverbial',
+                    'discourse': 'élément de discours', 'aux': 'auxiliaire', 'cop': 'copule', 'mark': 'marqueur', 'nmod': 'modifieur nominal',
+                    'appos': 'apposition', 'nummod': 'modifieur numéral', 'acl': 'clause relative', 'amod': 'modifieur adjectival', 'det': 'déterminant',
+                    'clf': 'classificateur', 'case': 'marqueur de cas', 'conj': 'conjonction', 'cc': 'coordination', 'fixed': 'expression figée',
+                    'flat': 'construction plate', 'compound': 'composé', 'list': 'liste', 'parataxis': 'parataxe', 'orphan': 'orphelin',
+                    'goeswith': 'va avec', 'reparandum': 'réparation', 'punct': 'ponctuation'
+                }
+            }
+    
+            dependency = morpho_t.get('dependency', 'Dependency')
+            morph_df[dependency] = morph_df[dependency].map(lambda x: dep_translations[lang_code].get(x, x))
+                
+            morph_translations = {
+                'es': {
+                    'Gender': 'Género', 'Number': 'Número', 'Case': 'Caso', 'Definite': 'Definido',
+                    'PronType': 'Tipo de Pronombre', 'Person': 'Persona', 'Mood': 'Modo',
+                    'Tense': 'Tiempo', 'VerbForm': 'Forma Verbal', 'Voice': 'Voz',
+                    'Fem': 'Femenino', 'Masc': 'Masculino', 'Sing': 'Singular', 'Plur': 'Plural',
+                    'Ind': 'Indicativo', 'Sub': 'Subjuntivo', 'Imp': 'Imperativo', 'Inf': 'Infinitivo',
+                    'Part': 'Participio', 'Ger': 'Gerundio', 'Pres': 'Presente', 'Past': 'Pasado',
+                    'Fut': 'Futuro', 'Perf': 'Perfecto', 'Imp': 'Imperfecto'
+                },
+                    
+                'en': {
+                    'Gender': 'Gender', 'Number': 'Number', 'Case': 'Case', 'Definite': 'Definite', 'PronType': 'Pronoun Type', 'Person': 'Person',
+                    'Mood': 'Mood', 'Tense': 'Tense', 'VerbForm': 'Verb Form', 'Voice': 'Voice',
+                    'Fem': 'Feminine', 'Masc': 'Masculine', 'Sing': 'Singular', 'Plur': 'Plural', 'Ind': 'Indicative',
+                    'Sub': 'Subjunctive', 'Imp': 'Imperative', 'Inf': 'Infinitive', 'Part': 'Participle',
+                    'Ger': 'Gerund', 'Pres': 'Present', 'Past': 'Past', 'Fut': 'Future', 'Perf': 'Perfect', 'Imp': 'Imperfect'
+                },
+                    
+                'fr': {
+                    'Gender': 'Genre', 'Number': 'Nombre', 'Case': 'Cas', 'Definite': 'Défini', 'PronType': 'Type de Pronom',
+                    'Person': 'Personne', 'Mood': 'Mode', 'Tense': 'Temps', 'VerbForm': 'Forme Verbale', 'Voice': 'Voix',
+                    'Fem': 'Féminin', 'Masc': 'Masculin', 'Sing': 'Singulier', 'Plur': 'Pluriel', 'Ind': 'Indicatif',
+                    'Sub': 'Subjonctif', 'Imp': 'Impératif', 'Inf': 'Infinitif', 'Part': 'Participe',
+                    'Ger': 'Gérondif', 'Pres': 'Présent', 'Past': 'Passé', 'Fut': 'Futur', 'Perf': 'Parfait', 'Imp': 'Imparfait'
+                }
+            }            
+    
+            def translate_morph(morph_string, lang_code):
+                for key, value in morph_translations[lang_code].items():
+                    morph_string = morph_string.replace(key, value)
+                return morph_string
+                
+            morphology = morpho_t.get('morphology', 'Morphology')
+            morph_df[morphology] = morph_df[morphology].apply(lambda x: translate_morph(x, lang_code))
+                
+            st.dataframe(morph_df)
+
+    # Mostrar diagramas de arco
+    with st.expander(morpho_t.get('arc_diagram', 'Syntactic analysis: Arc diagram'), expanded=True):
+        sentences = list(doc.sents)
+        arc_diagrams = []
+        
+        for i, sent in enumerate(sentences):
+            st.subheader(f"{morpho_t.get('sentence', 'Sentence')} {i+1}")
+            html = displacy.render(sent, style="dep", options={"distance": 100})
+            html = html.replace('height="375"', 'height="200"')
+            html = re.sub(r'<svg[^>]*>', lambda m: m.group(0).replace('height="450"', 'height="300"'), html)
+            html = re.sub(r'<g [^>]*transform="translate\((\d+),(\d+)\)"', 
+                         lambda m: f'<g transform="translate({m.group(1)},50)"', html)
+            st.write(html, unsafe_allow_html=True)
+            arc_diagrams.append(html)
+
+    # Botón de exportación
+    # if st.button(morpho_t.get('export_button', 'Export Analysis')):
+    #    pdf_buffer = export_user_interactions(st.session_state.username, 'morphosyntax')
+    #    st.download_button(
+    #        label=morpho_t.get('download_pdf', 'Download PDF'),
+    #        data=pdf_buffer,
+    #        file_name="morphosyntax_analysis.pdf",
+    #        mime="application/pdf"
+    #    )

modules/morphosyntax/morphosyntax_interface.py

@@ -1,4 +1,5 @@
 #modules/morphosyntax/morphosyntax_interface.py
+
 import streamlit as st
 from streamlit_float import *
 from streamlit_antd_components import *
@@ -10,313 +11,298 @@ import pandas as pd
 import base64
 import re
 
-# Importar desde morphosyntax_process.py
 from .morphosyntax_process import (
     process_morphosyntactic_input,
     format_analysis_results,
-    perform_advanced_morphosyntactic_analysis,  # Añadir esta importación
-    get_repeated_words_colors,                  # Y estas también
+    perform_advanced_morphosyntactic_analysis,
+    get_repeated_words_colors,
     highlight_repeated_words,
     POS_COLORS,
     POS_TRANSLATIONS
 )
 
 from ..utils.widget_utils import generate_unique_key
-
 from ..database.morphosintax_mongo_db import store_student_morphosyntax_result
 from ..database.chat_mongo_db import store_chat_history, get_chat_history
 
-# from ..database.morphosintaxis_export import export_user_interactions
-
 import logging
 logger = logging.getLogger(__name__)
 
-############################################################################################################
+###########################################################################
+
+import streamlit as st
+from streamlit_float import *
+from streamlit_antd_components import *
+from streamlit.components.v1 import html
+import spacy
+from spacy import displacy
+import spacy_streamlit
+import pandas as pd
+import base64
+import re
+
+############################################################################
+
 def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
     try:
-        # 1. Inicializar el estado morfosintáctico si no existe
+        # CSS mejorado para estabilidad y layout vertical
+        st.markdown("""
+            <style>
+            .stTextArea textarea {
+                font-size: 1rem;
+                line-height: 1.5;
+                padding: 0.5rem;
+                border-radius: 0.375rem;
+                border: 1px solid #e2e8f0;
+                background-color: white;
+                min-height: 100px !important;
+                height: 100px !important;
+            }
+            .block-container {
+                padding-top: 0.5rem !important;
+                padding-bottom: 0.5rem !important;
+                margin: 0 !important;
+            }
+            .main-content {
+                display: flex;
+                flex-direction: column;
+                gap: 1rem;
+                padding: 0.5rem;
+            }
+            .arc-diagram-container {
+                width: 100%;
+                overflow-x: auto;
+                background-color: white;
+                padding: 0.5rem;
+                border-radius: 0.375rem;
+                box-shadow: 0 1px 2px rgba(0,0,0,0.1);
+                margin-top: 0.5rem;
+            }
+            </style>
+        """, unsafe_allow_html=True)
+
+        # Inicialización más robusta del estado
         if 'morphosyntax_state' not in st.session_state:
             st.session_state.morphosyntax_state = {
-                'input_text': "",
+                'original_text': '',
+                'current_text': '',
+                'original_analysis': None,
                 'analysis_count': 0,
-                'last_analysis': None
+                'iterations': []  # Inicialización explícita de iterations como lista vacía
             }
+        else:
+            # Asegurar que todas las claves existan
+            required_keys = {
+                'original_text': '',
+                'current_text': '',
+                'original_analysis': None,
+                'analysis_count': 0,
+                'iterations': []
+            }
+            for key, default_value in required_keys.items():
+                if key not in st.session_state.morphosyntax_state:
+                    st.session_state.morphosyntax_state[key] = default_value
+
+        with st.container():
+            # Sección de texto original
+            st.markdown("### Texto Original")
+            
+            # Input para texto original
+            original_text = st.text_area(
+                "Ingrese una oración", 
+                value=st.session_state.morphosyntax_state['original_text'],
+                key="original_text_input",
+                placeholder="Ingresar solo una oración hasta el punto y aparte. Si es punto seguido, dejar así.",
+                height=100,
+                disabled=False
+            )
 
-        # 2. Campo de entrada de texto con key única basada en el contador
-        input_key = f"morpho_input_{st.session_state.morphosyntax_state['analysis_count']}"
-        
-        sentence_input = st.text_area(
-            morpho_t.get('morpho_input_label', 'Enter text to analyze'),
-            height=150,
-            placeholder=morpho_t.get('morpho_input_placeholder', 'Enter your text here...'),
-            key=input_key
-        )
+            # Botón para analizar texto original
+            col1, col2, col3 = st.columns([2,1,2])
+            with col1:
+                analyze_original = st.button(
+                    "Analizar Texto Original",
+                    type="primary",
+                    use_container_width=True,
+                    disabled=not bool(original_text.strip())
+                )
 
-        # 3. Actualizar el estado con el texto actual
-        st.session_state.morphosyntax_state['input_text'] = sentence_input
+            # Procesar texto original
+            if analyze_original and original_text.strip():
+                try:
+                    with st.spinner("Procesando texto original..."):
+                        doc = nlp_models[lang_code](original_text)
+                        analysis = perform_advanced_morphosyntactic_analysis(
+                            original_text,
+                            nlp_models[lang_code]
+                        )
+                        
+                        # Actualizar estado de forma segura
+                        st.session_state.morphosyntax_state.update({
+                            'original_text': original_text,
+                            'current_text': original_text,
+                            'original_analysis': {
+                                'doc': doc,
+                                'advanced_analysis': analysis
+                            },
+                            'iterations': []  # Reiniciar iteraciones al cambiar texto original
+                        })
+                        
+                        # Guardar en base de datos
+                        if store_student_morphosyntax_result(
+                            username=st.session_state.username,
+                            text=original_text,
+                            arc_diagrams=analysis['arc_diagrams']
+                        ):
+                            st.success("Texto original analizado exitosamente")
+                        else:
+                            st.error("Error al guardar el análisis original")
+                except Exception as e:
+                    logger.error(f"Error procesando texto original: {str(e)}")
+                    st.error("Error al procesar el texto original")
 
-        # 4. Crear columnas para el botón
-        col1, col2, col3 = st.columns([2,1,2])
-        
-        # 5. Botón de análisis en la columna central
-        with col1:
-            analyze_button = st.button(
-                morpho_t.get('morpho_analyze_button', 'Analyze Morphosyntax'),
-                key=f"morpho_button_{st.session_state.morphosyntax_state['analysis_count']}",
-                type="primary",  # Nuevo en Streamlit 1.39.0
-                icon="🔍",      # Nuevo en Streamlit 1.39.0
-                disabled=not bool(sentence_input.strip()),  # Se activa solo cuando hay texto
-                use_container_width=True
+            # Mostrar diagrama original
+            if st.session_state.morphosyntax_state['original_analysis']:
+                display_morphosyntax_results(
+                    st.session_state.morphosyntax_state['original_analysis'],
+                    lang_code,
+                    morpho_t
+                )
+
+            # Sección de iteración
+            st.markdown("---")
+            st.markdown("### Iteración Actual")
+            
+            # Campo para nueva versión
+            iteration_text = st.text_area(
+                "Modifique la oración",
+                value=st.session_state.morphosyntax_state['current_text'],
+                key=f"iteration_input_{st.session_state.morphosyntax_state['analysis_count']}",
+                placeholder="Ingresar solo una oración hasta el punto y aparte. Si es punto seguido, dejar así.",
+                height=100
             )
 
-        # 6. Lógica de análisis
-        if analyze_button and sentence_input.strip():  # Verificar que haya texto y no solo espacios
-            try:
-                with st.spinner(morpho_t.get('processing', 'Processing...')):
-                    # Obtener el modelo específico del idioma y procesar el texto
-                    doc = nlp_models[lang_code](sentence_input)
-                    
-                    # Realizar análisis morfosintáctico con el mismo modelo
-                    advanced_analysis = perform_advanced_morphosyntactic_analysis(
-                        sentence_input, 
-                        nlp_models[lang_code]
-                    )    
-    
-                    # Guardar resultado en el estado de la sesión
-                    st.session_state.morphosyntax_result = {
-                        'doc': doc,
-                        'advanced_analysis': advanced_analysis
-                    }
-    
-                    # Incrementar el contador de análisis
-                    st.session_state.morphosyntax_state['analysis_count'] += 1
-    
-                    # Guardar el análisis en la base de datos
-                    if store_student_morphosyntax_result(
-                        username=st.session_state.username,
-                        text=sentence_input,
-                        arc_diagrams=advanced_analysis['arc_diagrams']
-                    ):
-                        st.success(morpho_t.get('success_message', 'Analysis saved successfully'))
+            # Botón para analizar iteración
+            col1, col2, col3 = st.columns([2,1,2])
+            with col1:
+                analyze_iteration = st.button(
+                    "Analizar Cambios",
+                    type="primary",
+                    icon="🔍",
+                    key=f"analyze_{st.session_state.morphosyntax_state['analysis_count']}",
+                    disabled=not bool(iteration_text.strip()),
+                    use_container_width=True
+                )
+
+            # Procesar iteración
+            if analyze_iteration and iteration_text.strip():
+                try:
+                    with st.spinner("Procesando cambios..."):
+                        doc = nlp_models[lang_code](iteration_text)
+                        analysis = perform_advanced_morphosyntactic_analysis(
+                            iteration_text,
+                            nlp_models[lang_code]
+                        )
+                        
+                        current_analysis = {
+                            'doc': doc,
+                            'advanced_analysis': analysis
+                        }
                         
-                        # Mostrar resultados
+                        # Crear nueva iteración
+                        new_iteration = {
+                            'text': iteration_text,
+                            'analysis': current_analysis,
+                            'timestamp': pd.Timestamp.now()
+                        }
+                        
+                        # Actualizar estado de forma segura
+                        iterations = st.session_state.morphosyntax_state.get('iterations', [])
+                        iterations.append(new_iteration)
+                        st.session_state.morphosyntax_state.update({
+                            'current_text': iteration_text,
+                            'analysis_count': st.session_state.morphosyntax_state['analysis_count'] + 1,
+                            'iterations': iterations
+                        })
+                        
+                        if store_student_morphosyntax_result(
+                            username=st.session_state.username,
+                            text=iteration_text,
+                            arc_diagrams=analysis['arc_diagrams']
+                        ):
+                            # Mostrar resultados de la iteración
+                            display_morphosyntax_results(
+                                current_analysis,
+                                lang_code,
+                                morpho_t
+                            )
+                        else:
+                            st.error("Error al guardar la iteración")
+                except Exception as e:
+                    logger.error(f"Error procesando iteración: {str(e)}")
+                    st.error("Error al procesar los cambios")
+
+            # Mostrar historial de iteraciones
+            if st.session_state.morphosyntax_state.get('iterations', []):
+                with st.expander("Historial de Iteraciones", expanded=False):
+                    for idx, iteration in enumerate(reversed(st.session_state.morphosyntax_state['iterations'])):
+                        st.markdown(f"**Iteración {idx + 1} ({iteration['timestamp'].strftime('%H:%M:%S')})**")
+                        st.text_area(
+                            f"Texto {idx + 1}",
+                            value=iteration['text'],
+                            disabled=True,
+                            height=100,
+                            key=f"hist_text_{idx}"
+                        )
                         display_morphosyntax_results(
-                            st.session_state.morphosyntax_result, 
-                            lang_code, 
+                            iteration['analysis'],
+                            lang_code,
                             morpho_t
                         )
-                    else:
-                        st.error(morpho_t.get('error_message', 'Error saving analysis'))
-                    
-            except Exception as e:
-                logger.error(f"Error en análisis morfosintáctico: {str(e)}")
-                st.error(morpho_t.get('error_processing', f'Error processing text: {str(e)}'))
-                
-        # 7. Mostrar resultados previos si existen
-        elif 'morphosyntax_result' in st.session_state and st.session_state.morphosyntax_result is not None:
-            display_morphosyntax_results(
-                st.session_state.morphosyntax_result, 
-                lang_code, 
-                morpho_t
-            )
-        elif not sentence_input.strip():
-            st.info(morpho_t.get('morpho_initial_message', 'Enter text to begin analysis'))
-            
+                        st.markdown("---")
+
     except Exception as e:
         logger.error(f"Error general en display_morphosyntax_interface: {str(e)}")
         st.error("Se produjo un error. Por favor, intente de nuevo.")
-        st.error(f"Detalles del error: {str(e)}")  # Añadido para mejor debugging
 
-############################################################################################################
+
+
+
+
+#########################################################################3
 def display_morphosyntax_results(result, lang_code, morpho_t):
     """
-    Muestra los resultados del análisis morfosintáctico.
-    Args:
-        result: Resultado del análisis
-        lang_code: Código del idioma
-        t: Diccionario de traducciones
+    Muestra solo el análisis sintáctico con diagramas de arco.
     """
-    # Obtener el diccionario de traducciones morfosintácticas
-    # morpho_t = t.get('MORPHOSYNTACTIC', {})
-    
     if result is None:
         st.warning(morpho_t.get('no_results', 'No results available'))
         return
 
     doc = result['doc']
-    advanced_analysis = result['advanced_analysis']
-    
-    # Mostrar leyenda
-    st.markdown(f"##### {morpho_t.get('legend', 'Legend: Grammatical categories')}")
-    legend_html = "<div style='display: flex; flex-wrap: wrap;'>"
-    for pos, color in POS_COLORS.items():
-        if pos in POS_TRANSLATIONS[lang_code]:
-            legend_html += f"<div style='margin-right: 10px;'><span style='background-color: {color}; padding: 2px 5px;'>{POS_TRANSLATIONS[lang_code][pos]}</span></div>"
-    legend_html += "</div>"
-    st.markdown(legend_html, unsafe_allow_html=True)
 
-    # Mostrar análisis de palabras repetidas
-    word_colors = get_repeated_words_colors(doc)
-    with st.expander(morpho_t.get('repeated_words', 'Repeated words'), expanded=True):
-        highlighted_text = highlight_repeated_words(doc, word_colors)
-        st.markdown(highlighted_text, unsafe_allow_html=True)
+    # Análisis sintáctico (diagramas de arco)
+    st.markdown(f"### {morpho_t.get('arc_diagram', 'Syntactic analysis: Arc diagram')}")
     
-    # Mostrar estructura de oraciones
-    with st.expander(morpho_t.get('sentence_structure', 'Sentence structure'), expanded=True):
-        for i, sent_analysis in enumerate(advanced_analysis['sentence_structure']):
-            sentence_str = (
-                f"**{morpho_t.get('sentence', 'Sentence')} {i+1}** "  # Aquí está el cambio
-                f"{morpho_t.get('root', 'Root')}: {sent_analysis['root']} ({sent_analysis['root_pos']}) -- "  # Y aquí
-                f"{morpho_t.get('subjects', 'Subjects')}: {', '.join(sent_analysis['subjects'])} -- "  # Y aquí
-                f"{morpho_t.get('objects', 'Objects')}: {', '.join(sent_analysis['objects'])} -- "  # Y aquí
-                f"{morpho_t.get('verbs', 'Verbs')}: {', '.join(sent_analysis['verbs'])}"  # Y aquí
-            )
-            st.markdown(sentence_str)
-
-    # Mostrar análisis de categorías gramaticales # Mostrar análisis morfológico
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        with st.expander(morpho_t.get('pos_analysis', 'Part of speech'), expanded=True):
-            pos_df = pd.DataFrame(advanced_analysis['pos_analysis'])
-            
-            # Traducir las etiquetas POS a sus nombres en el idioma seleccionado
-            pos_df['pos'] = pos_df['pos'].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
-            
-            # Renombrar las columnas para mayor claridad
-            pos_df = pos_df.rename(columns={
-                'pos': morpho_t.get('grammatical_category', 'Grammatical category'),
-                'count': morpho_t.get('count', 'Count'),
-                'percentage': morpho_t.get('percentage', 'Percentage'),
-                'examples': morpho_t.get('examples', 'Examples')
-            })
-                        
-            # Mostrar el dataframe
-            st.dataframe(pos_df)
-    
-    with col2:
-        with st.expander(morpho_t.get('morphological_analysis', 'Morphological Analysis'), expanded=True):
-            # 1. Crear el DataFrame inicial
-            morph_df = pd.DataFrame(advanced_analysis['morphological_analysis'])
-            
-            # 2. Primero renombrar las columnas usando las traducciones de la interfaz
-            column_mapping = {
-                'text': morpho_t.get('word', 'Word'),
-                'lemma': morpho_t.get('lemma', 'Lemma'),
-                'pos': morpho_t.get('grammatical_category', 'Grammatical category'),
-                'dep': morpho_t.get('dependency', 'Dependency'),
-                'morph': morpho_t.get('morphology', 'Morphology')
-            }
-            
-            # 3. Aplicar el renombrado
-            morph_df = morph_df.rename(columns=column_mapping)
-            
-            # 4. Traducir las categorías gramaticales usando POS_TRANSLATIONS global
-            grammatical_category = morpho_t.get('grammatical_category', 'Grammatical category')
-            morph_df[grammatical_category] = morph_df[grammatical_category].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
-    
-            # 2.2 Traducir dependencias usando traducciones específicas
-            dep_translations = {
-                    
-                'es': {
-                    'ROOT': 'RAÍZ', 'nsubj': 'sujeto nominal', 'obj': 'objeto', 'iobj': 'objeto indirecto',
-                    'csubj': 'sujeto clausal', 'ccomp': 'complemento clausal', 'xcomp': 'complemento clausal abierto',
-                    'obl': 'oblicuo', 'vocative': 'vocativo', 'expl': 'expletivo', 'dislocated': 'dislocado',
-                    'advcl': 'cláusula adverbial', 'advmod': 'modificador adverbial', 'discourse': 'discurso',
-                    'aux': 'auxiliar', 'cop': 'cópula', 'mark': 'marcador', 'nmod': 'modificador nominal',
-                    'appos': 'aposición', 'nummod': 'modificador numeral', 'acl': 'cláusula adjetiva',
-                    'amod': 'modificador adjetival', 'det': 'determinante', 'clf': 'clasificador',
-                    'case': 'caso', 'conj': 'conjunción', 'cc': 'coordinante', 'fixed': 'fijo',
-                    'flat': 'plano', 'compound': 'compuesto', 'list': 'lista', 'parataxis': 'parataxis',
-                    'orphan': 'huérfano', 'goeswith': 'va con', 'reparandum': 'reparación', 'punct': 'puntuación'
-                },
-                    
-                'en': {
-                    'ROOT': 'ROOT', 'nsubj': 'nominal subject', 'obj': 'object',
-                    'iobj': 'indirect object', 'csubj': 'clausal subject', 'ccomp': 'clausal complement', 'xcomp': 'open clausal complement',
-                    'obl': 'oblique', 'vocative': 'vocative', 'expl': 'expletive', 'dislocated': 'dislocated', 'advcl': 'adverbial clause modifier',
-                    'advmod': 'adverbial modifier', 'discourse': 'discourse element', 'aux': 'auxiliary', 'cop': 'copula', 'mark': 'marker',
-                    'nmod': 'nominal modifier', 'appos': 'appositional modifier', 'nummod': 'numeric modifier', 'acl': 'clausal modifier of noun',
-                    'amod': 'adjectival modifier', 'det': 'determiner', 'clf': 'classifier', 'case': 'case marking',
-                    'conj': 'conjunct', 'cc': 'coordinating conjunction', 'fixed': 'fixed multiword expression',
-                    'flat': 'flat multiword expression', 'compound': 'compound', 'list': 'list', 'parataxis': 'parataxis', 'orphan': 'orphan',
-                    'goeswith': 'goes with', 'reparandum': 'reparandum', 'punct': 'punctuation'
-                },
-                    
-                'fr': {
-                    'ROOT': 'RACINE', 'nsubj': 'sujet nominal', 'obj': 'objet', 'iobj': 'objet indirect',
-                    'csubj': 'sujet phrastique', 'ccomp': 'complément phrastique', 'xcomp': 'complément phrastique ouvert', 'obl': 'oblique',
-                    'vocative': 'vocatif', 'expl': 'explétif', 'dislocated': 'disloqué', 'advcl': 'clause adverbiale', 'advmod': 'modifieur adverbial',
-                    'discourse': 'élément de discours', 'aux': 'auxiliaire', 'cop': 'copule', 'mark': 'marqueur', 'nmod': 'modifieur nominal',
-                    'appos': 'apposition', 'nummod': 'modifieur numéral', 'acl': 'clause relative', 'amod': 'modifieur adjectival', 'det': 'déterminant',
-                    'clf': 'classificateur', 'case': 'marqueur de cas', 'conj': 'conjonction', 'cc': 'coordination', 'fixed': 'expression figée',
-                    'flat': 'construction plate', 'compound': 'composé', 'list': 'liste', 'parataxis': 'parataxe', 'orphan': 'orphelin',
-                    'goeswith': 'va avec', 'reparandum': 'réparation', 'punct': 'ponctuation'
-                }
-            }
-    
-            dependency = morpho_t.get('dependency', 'Dependency')
-            morph_df[dependency] = morph_df[dependency].map(lambda x: dep_translations[lang_code].get(x, x))
-                
-            morph_translations = {
-                'es': {
-                    'Gender': 'Género', 'Number': 'Número', 'Case': 'Caso', 'Definite': 'Definido',
-                    'PronType': 'Tipo de Pronombre', 'Person': 'Persona', 'Mood': 'Modo',
-                    'Tense': 'Tiempo', 'VerbForm': 'Forma Verbal', 'Voice': 'Voz',
-                    'Fem': 'Femenino', 'Masc': 'Masculino', 'Sing': 'Singular', 'Plur': 'Plural',
-                    'Ind': 'Indicativo', 'Sub': 'Subjuntivo', 'Imp': 'Imperativo', 'Inf': 'Infinitivo',
-                    'Part': 'Participio', 'Ger': 'Gerundio', 'Pres': 'Presente', 'Past': 'Pasado',
-                    'Fut': 'Futuro', 'Perf': 'Perfecto', 'Imp': 'Imperfecto'
-                },
-                    
-                'en': {
-                    'Gender': 'Gender', 'Number': 'Number', 'Case': 'Case', 'Definite': 'Definite', 'PronType': 'Pronoun Type', 'Person': 'Person',
-                    'Mood': 'Mood', 'Tense': 'Tense', 'VerbForm': 'Verb Form', 'Voice': 'Voice',
-                    'Fem': 'Feminine', 'Masc': 'Masculine', 'Sing': 'Singular', 'Plur': 'Plural', 'Ind': 'Indicative',
-                    'Sub': 'Subjunctive', 'Imp': 'Imperative', 'Inf': 'Infinitive', 'Part': 'Participle',
-                    'Ger': 'Gerund', 'Pres': 'Present', 'Past': 'Past', 'Fut': 'Future', 'Perf': 'Perfect', 'Imp': 'Imperfect'
-                },
-                    
-                'fr': {
-                    'Gender': 'Genre', 'Number': 'Nombre', 'Case': 'Cas', 'Definite': 'Défini', 'PronType': 'Type de Pronom',
-                    'Person': 'Personne', 'Mood': 'Mode', 'Tense': 'Temps', 'VerbForm': 'Forme Verbale', 'Voice': 'Voix',
-                    'Fem': 'Féminin', 'Masc': 'Masculin', 'Sing': 'Singulier', 'Plur': 'Pluriel', 'Ind': 'Indicatif',
-                    'Sub': 'Subjonctif', 'Imp': 'Impératif', 'Inf': 'Infinitif', 'Part': 'Participe',
-                    'Ger': 'Gérondif', 'Pres': 'Présent', 'Past': 'Passé', 'Fut': 'Futur', 'Perf': 'Parfait', 'Imp': 'Imparfait'
-                }
-            }            
-    
-            def translate_morph(morph_string, lang_code):
-                for key, value in morph_translations[lang_code].items():
-                    morph_string = morph_string.replace(key, value)
-                return morph_string
-                
-            morphology = morpho_t.get('morphology', 'Morphology')
-            morph_df[morphology] = morph_df[morphology].apply(lambda x: translate_morph(x, lang_code))
-                
-            st.dataframe(morph_df)
-
-    # Mostrar diagramas de arco
-    with st.expander(morpho_t.get('arc_diagram', 'Syntactic analysis: Arc diagram'), expanded=True):
+    with st.container():
         sentences = list(doc.sents)
-        arc_diagrams = []
-        
         for i, sent in enumerate(sentences):
-            st.subheader(f"{morpho_t.get('sentence', 'Sentence')} {i+1}")
-            html = displacy.render(sent, style="dep", options={"distance": 100})
-            html = html.replace('height="375"', 'height="200"')
-            html = re.sub(r'<svg[^>]*>', lambda m: m.group(0).replace('height="450"', 'height="300"'), html)
-            html = re.sub(r'<g [^>]*transform="translate\((\d+),(\d+)\)"', 
-                         lambda m: f'<g transform="translate({m.group(1)},50)"', html)
-            st.write(html, unsafe_allow_html=True)
-            arc_diagrams.append(html)
-
-    # Botón de exportación
-    # if st.button(morpho_t.get('export_button', 'Export Analysis')):
-    #    pdf_buffer = export_user_interactions(st.session_state.username, 'morphosyntax')
-    #    st.download_button(
-    #        label=morpho_t.get('download_pdf', 'Download PDF'),
-    #        data=pdf_buffer,
-    #        file_name="morphosyntax_analysis.pdf",
-    #        mime="application/pdf"
-    #    )
+            with st.container():
+                st.subheader(f"{morpho_t.get('sentence', 'Sentence')} {i+1}")
+                try:
+                    html = displacy.render(sent, style="dep", options={
+                        "distance": 100,
+                        "arrow_spacing": 20,
+                        "word_spacing": 30
+                    })
+                    # Ajustar dimensiones del SVG
+                    html = html.replace('height="375"', 'height="200"')
+                    html = re.sub(r'<svg[^>]*>', lambda m: m.group(0).replace('height="450"', 'height="300"'), html)
+                    html = re.sub(r'<g [^>]*transform="translate\((\d+),(\d+)\)"', 
+                                lambda m: f'<g transform="translate({m.group(1)},50)"', html)
+                    
+                    # Envolver en un div con clase para estilos
+                    html = f'<div class="arc-diagram-container">{html}</div>'
+                    st.write(html, unsafe_allow_html=True)
+                except Exception as e:
+                    logger.error(f"Error rendering sentence {i}: {str(e)}")
+                    st.error(f"Error displaying diagram for sentence {i+1}")

modules/morphosyntax/morphosyntax_interface_BackUp_Dec-28-Ok.py

@@ -0,0 +1,164 @@
+#modules/morphosyntax/morphosyntax_interface.py
+
+import streamlit as st
+from streamlit_float import *
+from streamlit_antd_components import *
+from streamlit.components.v1 import html
+import spacy
+from spacy import displacy
+import spacy_streamlit
+import pandas as pd
+import base64
+import re
+
+from .morphosyntax_process import (
+    process_morphosyntactic_input,
+    format_analysis_results,
+    perform_advanced_morphosyntactic_analysis,
+    get_repeated_words_colors,
+    highlight_repeated_words,
+    POS_COLORS,
+    POS_TRANSLATIONS
+)
+
+from ..utils.widget_utils import generate_unique_key
+from ..database.morphosintax_mongo_db import store_student_morphosyntax_result
+from ..database.chat_mongo_db import store_chat_history, get_chat_history
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
+    try:
+        # Inicializar el estado si no existe
+        if 'morphosyntax_state' not in st.session_state:
+            st.session_state.morphosyntax_state = {
+                'analysis_count': 0,
+                'current_text': '',  # Almacenar el texto actual
+                'last_analysis': None,
+                'needs_update': False  # Flag para actualización
+            }
+
+        # Campo de entrada de texto que mantiene su valor
+        text_key = "morpho_text_input"
+        
+        # Función para manejar cambios en el texto
+        def on_text_change():
+            st.session_state.morphosyntax_state['current_text'] = st.session_state[text_key]
+            st.session_state.morphosyntax_state['needs_update'] = True
+        
+        # Recuperar el texto anterior si existe
+        default_text = st.session_state.morphosyntax_state.get('current_text', '')
+        
+        sentence_input = st.text_area(
+            morpho_t.get('morpho_input_label', 'Enter text to analyze'),
+            value=default_text,  # Usar el texto guardado
+            height=150,
+            key=text_key,
+            on_change=on_text_change,
+            placeholder=morpho_t.get('morpho_input_placeholder', 'Enter your text here...')
+        )
+
+        # Botón de análisis
+        col1, col2, col3 = st.columns([2,1,2])
+        with col1:
+            analyze_button = st.button(
+                morpho_t.get('morpho_analyze_button', 'Analyze Morphosyntax'),
+                key=f"morpho_button_{st.session_state.morphosyntax_state['analysis_count']}",
+                type="primary",
+                icon="🔍",
+                disabled=not bool(sentence_input.strip()),
+                use_container_width=True
+            )
+
+        # Procesar análisis solo cuando sea necesario
+        if (analyze_button or st.session_state.morphosyntax_state['needs_update']) and sentence_input.strip():
+            try:
+                with st.spinner(morpho_t.get('processing', 'Processing...')):
+                    doc = nlp_models[lang_code](sentence_input)
+                    advanced_analysis = perform_advanced_morphosyntactic_analysis(
+                        sentence_input,
+                        nlp_models[lang_code]
+                    )
+
+                    st.session_state.morphosyntax_result = {
+                        'doc': doc,
+                        'advanced_analysis': advanced_analysis
+                    }
+                    
+                    # Solo guardar en DB si fue un click en el botón
+                    if analyze_button:
+                        if store_student_morphosyntax_result(
+                            username=st.session_state.username,
+                            text=sentence_input,
+                            arc_diagrams=advanced_analysis['arc_diagrams']
+                        ):
+                            st.success(morpho_t.get('success_message', 'Analysis saved successfully'))
+                            st.session_state.morphosyntax_state['analysis_count'] += 1
+                    
+                    st.session_state.morphosyntax_state['needs_update'] = False
+                    
+                    # Mostrar resultados en un contenedor específico
+                    with st.container():
+                        display_morphosyntax_results(
+                            st.session_state.morphosyntax_result,
+                            lang_code,
+                            morpho_t
+                        )
+
+            except Exception as e:
+                logger.error(f"Error en análisis morfosintáctico: {str(e)}")
+                st.error(morpho_t.get('error_processing', f'Error processing text: {str(e)}'))
+        
+        # Mostrar resultados previos si existen
+        elif 'morphosyntax_result' in st.session_state and st.session_state.morphosyntax_result:
+            with st.container():
+                display_morphosyntax_results(
+                    st.session_state.morphosyntax_result,
+                    lang_code,
+                    morpho_t
+                )
+
+    except Exception as e:
+        logger.error(f"Error general en display_morphosyntax_interface: {str(e)}")
+        st.error("Se produjo un error. Por favor, intente de nuevo.")
+
+
+
+def display_morphosyntax_results(result, lang_code, morpho_t):
+    """
+    Muestra solo el análisis sintáctico con diagramas de arco.
+    """
+    if result is None:
+        st.warning(morpho_t.get('no_results', 'No results available'))
+        return
+
+    doc = result['doc']
+
+    # Análisis sintáctico (diagramas de arco)
+    st.markdown(f"### {morpho_t.get('arc_diagram', 'Syntactic analysis: Arc diagram')}")
+    
+    with st.container():
+        sentences = list(doc.sents)
+        for i, sent in enumerate(sentences):
+            with st.container():
+                st.subheader(f"{morpho_t.get('sentence', 'Sentence')} {i+1}")
+                try:
+                    html = displacy.render(sent, style="dep", options={
+                        "distance": 100,
+                        "arrow_spacing": 20,
+                        "word_spacing": 30
+                    })
+                    # Ajustar dimensiones del SVG
+                    html = html.replace('height="375"', 'height="200"')
+                    html = re.sub(r'<svg[^>]*>', lambda m: m.group(0).replace('height="450"', 'height="300"'), html)
+                    html = re.sub(r'<g [^>]*transform="translate\((\d+),(\d+)\)"', 
+                                lambda m: f'<g transform="translate({m.group(1)},50)"', html)
+                    
+                    # Envolver en un div con clase para estilos
+                    html = f'<div class="arc-diagram-container">{html}</div>'
+                    st.write(html, unsafe_allow_html=True)
+                except Exception as e:
+                    logger.error(f"Error rendering sentence {i}: {str(e)}")
+                    st.error(f"Error displaying diagram for sentence {i+1}")

modules/morphosyntax/morphosyntax_process_BackUp_Dec24_Ok.py

@@ -0,0 +1,132 @@
+#modules/morphosyntax/morphosyntax_process.py
+import streamlit as st
+
+from ..text_analysis.morpho_analysis import (
+    get_repeated_words_colors,
+    highlight_repeated_words,
+    generate_arc_diagram,
+    get_detailed_pos_analysis,
+    get_morphological_analysis,
+    get_sentence_structure_analysis,
+    perform_advanced_morphosyntactic_analysis,
+    POS_COLORS,
+    POS_TRANSLATIONS
+)
+
+from ..database.morphosintax_mongo_db import store_student_morphosyntax_result
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+def process_morphosyntactic_input(text, lang_code, nlp_models, t):
+    """
+    Procesa el texto ingresado para realizar el análisis morfosintáctico.
+    
+    Args:
+        text: Texto a analizar
+        lang_code: Código del idioma
+        nlp_models: Diccionario de modelos spaCy
+        t: Diccionario de traducciones
+    
+    Returns:
+        tuple: (análisis, visualizaciones, texto_resaltado, mensaje)
+    """
+    try:
+        # Realizar el análisis morfosintáctico
+        doc = nlp_models[lang_code](text)
+        
+        # Obtener el análisis avanzado
+        analysis = perform_advanced_morphosyntactic_analysis(text, nlp_models[lang_code])
+        
+        # Generar visualizaciones - AQUÍ ESTÁ EL CAMBIO
+        arc_diagrams = generate_arc_diagram(doc)  # Quitamos lang_code
+        
+        # Obtener palabras repetidas y texto resaltado
+        word_colors = get_repeated_words_colors(doc)
+        highlighted_text = highlight_repeated_words(doc, word_colors)
+        
+        # Guardar el análisis en la base de datos
+        store_student_morphosyntax_result(
+            st.session_state.username,
+            text,
+            {
+                'arc_diagrams': arc_diagrams,
+                'pos_analysis': analysis['pos_analysis'],
+                'morphological_analysis': analysis['morphological_analysis'],
+                'sentence_structure': analysis['sentence_structure']
+            }
+        )
+        
+        return {
+            'analysis': analysis,
+            'visualizations': arc_diagrams,
+            'highlighted_text': highlighted_text,
+            'success': True,
+            'message': t.get('MORPHOSYNTACTIC', {}).get('success_message', 'Analysis completed successfully')
+        }
+        
+    except Exception as e:
+        logger.error(f"Error en el análisis morfosintáctico: {str(e)}")
+        return {
+            'analysis': None,
+            'visualizations': None,
+            'highlighted_text': None,
+            'success': False,
+            'message': t.get('MORPHOSYNTACTIC', {}).get('error_message', f'Error in analysis: {str(e)}')
+        }
+
+
+def format_analysis_results(analysis_result, t):
+    """
+    Formatea los resultados del análisis para su visualización.
+    
+    Args:
+        analysis_result: Resultado del análisis morfosintáctico
+        t: Diccionario de traducciones
+    
+    Returns:
+        dict: Resultados formateados para visualización
+    """
+    morpho_t = t.get('MORPHOSYNTACTIC', {})
+    
+    if not analysis_result['success']:
+        return {
+            'formatted_text': analysis_result['message'],
+            'visualizations': None
+        }
+        
+    formatted_sections = []
+    
+    # Formato para análisis POS
+    if 'pos_analysis' in analysis_result['analysis']:
+        pos_section = [f"### {morpho_t.get('pos_analysis', 'Part of Speech Analysis')}"]
+        for pos_item in analysis_result['analysis']['pos_analysis']:
+            pos_section.append(
+                f"- {morpho_t.get(pos_item['pos'], pos_item['pos'])}: "
+                f"{pos_item['count']} ({pos_item['percentage']}%)\n  "
+                f"Ejemplos: {', '.join(pos_item['examples'])}"
+            )
+        formatted_sections.append('\n'.join(pos_section))
+    
+    # Agregar otras secciones de formato según sea necesario
+    
+    return {
+        'formatted_text': '\n\n'.join(formatted_sections),
+        'visualizations': analysis_result['visualizations'],
+        'highlighted_text': analysis_result['highlighted_text']
+    }
+
+# Re-exportar las funciones y constantes necesarias
+__all__ = [
+    'process_morphosyntactic_input',
+    'highlight_repeated_words',
+    'generate_arc_diagram',
+    'get_repeated_words_colors',
+    'get_detailed_pos_analysis',
+    'get_morphological_analysis',
+    'get_sentence_structure_analysis',
+    'perform_advanced_morphosyntactic_analysis',
+    'POS_COLORS',
+    'POS_TRANSLATIONS'
+]

modules/studentact/current_situation_analysis-FAIL.py

@@ -0,0 +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

modules/studentact/current_situation_analysis.py

@@ -0,0 +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

modules/studentact/current_situation_interface--FAIL.py

@@ -0,0 +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-v1.py

@@ -0,0 +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-v2.py

@@ -0,0 +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-v3.py

@@ -0,0 +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)}")
+        st.error("Error al generar la visualización")

modules/studentact/current_situation_interface.py

@@ -0,0 +1,296 @@
+# 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
+
+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")
+#######################################

modules/studentact/temp_current_situation_interface.py

@@ -0,0 +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/ui/ui.py

@@ -17,14 +17,18 @@ from session_state import initialize_session_state, logout
 
 from translations import get_translations
 
-from ..studentact.student_activities_v2 import display_student_activities
-
 from ..auth.auth import authenticate_user, authenticate_student, authenticate_admin
 
 from ..admin.admin_ui import admin_page
 
 from ..chatbot import display_sidebar_chat
 
+# Students activities
+from ..studentact.student_activities_v2 import display_student_activities
+from ..studentact.current_situation_interface import display_current_situation_interface
+from ..studentact.current_situation_analysis import analyze_text_dimensions
+
+
 ##Importaciones desde la configuración de bases datos #######
 
 from ..database.sql_db import (
@@ -403,6 +407,7 @@ def user_page(lang_code, t):
     # Inicializar estados para todos los tabs
     if 'tab_states' not in st.session_state:
         st.session_state.tab_states = {
+            'current_situation_active': False,
             'morpho_active': False,
             'semantic_live_active': False,
             'semantic_active': False,
@@ -414,6 +419,7 @@ def user_page(lang_code, t):
     
     # Sistema de tabs
     tab_names = [
+        t.get('current_situation_tab', "Mi Situación Actual"),
         t.get('morpho_tab', 'Análisis Morfosintáctico'),
         t.get('semantic_live_tab', 'Análisis Semántico Vivo'),
         t.get('semantic_tab', 'Análisis Semántico'),
@@ -439,7 +445,15 @@ def user_page(lang_code, t):
                     if can_switch:
                         st.session_state.selected_tab = index
 
-                if index == 0:  # Morfosintáctico
+                if index == 0:  # Situación actual
+                    st.session_state.tab_states['current_situation_active'] = True
+                    display_current_situation_interface(
+                        st.session_state.lang_code,
+                        st.session_state.nlp_models,
+                        t.get('TRANSLATIONS', {})
+                    )
+
+                elif index == 1:  # Morfosintáctico
                     st.session_state.tab_states['morpho_active'] = True
                     display_morphosyntax_interface(
                         st.session_state.lang_code,
@@ -447,7 +461,8 @@ def user_page(lang_code, t):
                         t.get('TRANSLATIONS', {})
                     )
 
-                elif index == 1:  # Semántico Vivo
+                
+                elif index == 2:  # Semántico Vivo
                     st.session_state.tab_states['semantic_live_active'] = True
                     display_semantic_live_interface(
                         st.session_state.lang_code,
@@ -455,7 +470,7 @@ def user_page(lang_code, t):
                         t.get('TRANSLATIONS', {})
                     )
 
-                elif index == 2:  # Semántico
+                elif index == 3:  # Semántico
                     st.session_state.tab_states['semantic_active'] = True
                     display_semantic_interface(
                         st.session_state.lang_code,
@@ -463,7 +478,7 @@ def user_page(lang_code, t):
                         t.get('TRANSLATIONS', {})
                     )
 
-                elif index == 3:  # Discurso Vivo
+                elif index == 4:  # Discurso Vivo
                     st.session_state.tab_states['discourse_live_active'] = True
                     display_discourse_live_interface(
                         st.session_state.lang_code,
@@ -472,7 +487,7 @@ def user_page(lang_code, t):
                     )
                 
                 
-                elif index == 4:  # Discurso
+                elif index == 5:  # Discurso
                     st.session_state.tab_states['discourse_active'] = True
                     display_discourse_interface(
                         st.session_state.lang_code,
@@ -480,7 +495,7 @@ def user_page(lang_code, t):
                         t.get('TRANSLATIONS', {})
                     )
 
-                elif index == 5:  # Actividades
+                elif index == 6:  # Actividades
                     st.session_state.tab_states['activities_active'] = True
                     display_student_activities(
                         username=st.session_state.username,
@@ -488,7 +503,7 @@ def user_page(lang_code, t):
                         t=t.get('ACTIVITIES_TRANSLATIONS', {})
                     )
 
-                elif index == 6:  # Feedback
+                elif index == 7:  # Feedback
                     st.session_state.tab_states['feedback_active'] = True
                     display_feedback_form(
                         st.session_state.lang_code,
@@ -507,26 +522,28 @@ def user_page(lang_code, t):
 def get_tab_index(state_key):
     """Obtiene el índice del tab basado en la clave de estado"""
     index_map = {
-        'morpho_active': 0,
-        'semantic_live_active': 1,
-        'semantic_active': 2,
-        'discourse_live_active': 3,
-        'discourse_active': 4,
-        'activities_active': 5,
-        'feedback_active': 6
+        'current_situation_active': 0,
+        'morpho_active': 1,
+        'semantic_live_active': 2,
+        'semantic_active': 3,
+        'discourse_live_active': 4,
+        'discourse_active': 5,
+        'activities_active': 6,
+        'feedback_active': 7
     }
     return index_map.get(state_key, -1)
 
 def get_state_key_for_index(index):
     """Obtiene la clave de estado basada en el índice del tab"""
     state_map = {
-        0: 'morpho_active',
-        1: 'semantic_live_active',
-        2: 'semantic_active',
-        3: 'discourse_live_active',
-        3: 'discourse_active',
-        4: 'activities_active',
-        5: 'feedback_active'
+        0: 'current_situation_active',
+        1: 'morpho_active',
+        2: 'semantic_live_active',
+        3: 'semantic_active',
+        4: 'discourse_live_active',
+        5: 'discourse_active',
+        6: 'activities_active',
+        7: 'feedback_active'
     }
     return state_map.get(index)
 

pre-requirements.txt

@@ -0,0 +1,3 @@
+#https://huggingface.co/spacy/es_core_news_lg/resolve/main/es_core_news_lg-any-py3-none-any.whl
+#https://huggingface.co/spacy/en_core_web_lg/resolve/main/en_core_web_lg-any-py3-none-any.whl
+#https://huggingface.co/spacy/fr_core_news_lg/resolve/main/fr_core_news_lg-any-py3-none-any.whl

requirements.txt

@@ -8,12 +8,17 @@ cairosvg
 python-dotenv
 drawSvg
 docx2txt
-https://huggingface.co/spacy/es_core_news_lg/resolve/main/es_core_news_lg-any-py3-none-any.whl
-https://huggingface.co/spacy/en_core_web_lg/resolve/main/en_core_web_lg-any-py3-none-any.whl
-https://huggingface.co/spacy/fr_core_news_lg/resolve/main/fr_core_news_lg-any-py3-none-any.whl
-#es-core-news-lg @ https://github.com/explosion/spacy-models/releases/download/es_core_news_lg-3.5.0/es_core_news_lg-3.5.0-py3-none-any.whl
-#en-core-web-lg @ https://github.com/explosion/spacy-models/releases/download/en_core_web_lg-3.5.0/en_core_web_lg-3.5.0-py3-none-any.whl
-#fr-core-news-lg @ https://github.com/explosion/spacy-models/releases/download/fr_core_news_lg-3.5.0/fr_core_news_lg-3.5.0-py3-none-any.whl
+
+# Modelos de spaCy desde Hugging Face
+# https://huggingface.co/spacy/es_core_news_lg/resolve/main/es_core_news_lg-any-py3-none-any.whl
+# https://huggingface.co/spacy/en_core_web_lg/resolve/main/en_core_web_lg-any-py3-none-any.whl
+# https://huggingface.co/spacy/fr_core_news_lg/resolve/main/fr_core_news_lg-any-py3-none-any.whl
+
+# Enlaces alternativos desde GitHub (comentados)
+es-core-news-lg @ https://github.com/explosion/spacy-models/releases/download/es_core_news_lg-3.7.0/es_core_news_lg-3.7.0-py3-none-any.whl
+en-core-web-lg @ https://github.com/explosion/spacy-models/releases/download/en_core_web_lg-3.7.1/en_core_web_lg-3.7.1-py3-none-any.whl
+fr-core-news-lg @ https://github.com/explosion/spacy-models/releases/download/fr_core_news_lg-3.7.0/fr_core_news_lg-3.7.0-py3-none-any.whl
+
 numpy
 networkx
 matplotlib
@@ -31,7 +36,8 @@ PyPDF2
 rlPyCairo
 requests
 reportlab
-spacy
+spacy>=3.7.0,<3.8.0
+#spacy
 spacy-streamlit
 seaborn
 squarify