Upload 182 files

modules/__init__.py

@@ -0,0 +1,319 @@
+# modules/__init__.py
+
+def load_auth_functions():
+    from .auth.auth import authenticate_student, register_student, update_student_info, delete_student
+    return {
+        'authenticate_student': authenticate_student,
+        'register_student': register_student,
+        'update_student_info': update_student_info,
+        '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 (
+    initialize_database_connections, 
+    get_container, 
+    get_mongodb
+    )
+
+    # Importar funciones SQL
+    from .database.sql_db import (
+        create_student_user,
+        get_student_user,
+        update_student_user,
+        delete_student_user,
+        store_application_request,
+        store_student_feedback,
+        record_login,
+        record_logout,
+        get_recent_sessions,
+        get_user_total_time
+    )
+    
+    from .database.mongo_db import (
+        get_collection,
+        insert_document,
+        find_documents,
+        update_document,
+        delete_document,
+    )
+    
+    from .database.morphosintax_mongo_db import (
+        store_student_morphosyntax_result,
+        get_student_morphosyntax_analysis,
+        update_student_morphosyntax_analysis,
+        delete_student_morphosyntax_analysis,
+        get_student_morphosyntax_data
+    )
+
+    from .database.semantic_mongo_db import (
+        store_student_semantic_result,
+        get_student_semantic_analysis,
+        update_student_semantic_analysis,
+        delete_student_semantic_analysis,
+        get_student_semantic_data
+    )
+
+    from .database.discourse_mongo_db import (
+        store_student_discourse_result,
+        get_student_discourse_analysis,
+        update_student_discourse_analysis,
+        delete_student_discourse_analysis,
+        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
+    )
+
+    # Importar nuevas funciones de análisis morfosintáctico iterativo
+    from .morphosyntax_iterative_mongo_db import (
+        store_student_morphosyntax_base,
+        store_student_morphosyntax_iteration,
+        get_student_morphosyntax_analysis,
+        update_student_morphosyntax_analysis, 
+        delete_student_morphosyntax_analysis,
+        get_student_morphosyntax_data
+    )
+    
+    from .database.chat_mongo_db import store_chat_history, get_chat_history
+
+    return {
+        # Nuevas funciones morfosintácticas iterativas
+        'store_student_morphosyntax_base': store_student_morphosyntax_base,
+        'store_student_morphosyntax_iteration': store_student_morphosyntax_iteration,
+        'get_student_morphosyntax_iterative_analysis': get_student_morphosyntax_analysis,  # Renombrada para evitar conflicto
+        'update_student_morphosyntax_iterative': update_student_morphosyntax_analysis,     # Renombrada para evitar conflicto
+        'delete_student_morphosyntax_iterative': delete_student_morphosyntax_analysis,     # Renombrada para evitar conflicto
+        'get_student_morphosyntax_iterative_data': get_student_morphosyntax_data,  
+        '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,
+        'create_student_user': create_student_user,
+        'get_student_user': get_student_user,
+        'update_student_user': update_student_user,
+        'delete_student_user': delete_student_user,
+        'store_application_request': store_application_request,
+        'store_student_feedback': store_student_feedback,
+        'get_collection': get_collection,
+        'insert_document': insert_document,
+        'find_documents': find_documents,
+        'update_document': update_document,
+        'delete_document': delete_document,
+        'store_student_morphosyntax_result': store_student_morphosyntax_result,
+        'get_student_morphosyntax_analysis': get_student_morphosyntax_analysis,
+        'update_student_morphosyntax_analysis': update_student_morphosyntax_analysis,
+        'delete_student_morphosyntax_analysis': delete_student_morphosyntax_analysis,
+        'get_student_morphosyntax_data': get_student_morphosyntax_data,
+        'store_student_semantic_result': store_student_semantic_result,
+        'get_student_semantic_analysis': get_student_semantic_analysis,
+        'update_student_semantic_analysis': update_student_semantic_analysis,
+        'delete_student_semantic_analysis': delete_student_semantic_analysis,
+        'get_student_semantic_data': get_student_semantic_data,
+        'store_chat_history': store_chat_history,
+        'get_chat_history': get_chat_history, 
+        'store_student_discourse_result': store_student_discourse_result,
+        'get_student_discourse_analysis': get_student_discourse_analysis,
+        'update_student_discourse_analysis': update_student_discourse_analysis,
+        'delete_student_discourse_analysis': delete_student_discourse_analysis,
+        'get_student_discourse_data': get_student_discourse_data, 
+        'record_login': record_login,
+        'record_logout': record_logout,
+        'get_recent_sessions': get_recent_sessions,
+        'get_user_total_time': get_user_total_time
+    }
+
+def load_ui_functions():
+    # No importamos nada de ui.py aquí
+    return {}  # Retornamos un diccionario vacío
+
+def load_student_activities_v2_functions():
+    from .studentact.student_activities_v2 import display_student_activities
+    return {
+        'display_student_progress': display_student_activities
+    }
+
+def load_morphosyntax_functions():
+    from .morphosyntax.morphosyntax_interface import (
+        initialize_arc_analysis_state,
+        reset_arc_analysis_state,
+        display_arc_diagrams,
+        display_morphosyntax_results
+    )
+    from .morphosyntax.morphosyntax_process import (
+        process_morphosyntactic_input,
+        format_analysis_results,
+        perform_advanced_morphosyntactic_analysis  # Añadir esta función
+    )
+    
+    return {
+        #Interface
+        'initialize_arc_analysis_state': initialize_arc_analysis_state,
+        'reset_arc_analysis_state': reset_morpho_state,
+        'display_arc_diagrams': display_arc_diagrams,
+        'display_morphosyntax_interface': display_morphosyntax_interface,
+        #Process
+        'process_morphosyntactic_input': process_morphosyntactic_input,
+        'format_analysis_results': format_analysis_results,
+        'perform_advanced_morphosyntactic_analysis': perform_advanced_morphosyntactic_analysis
+    }
+
+def load_semantic_functions():
+    from .semantic.semantic_interface import (
+        display_semantic_interface, 
+        display_semantic_results
+    )
+    from modules.semantic.semantic_process import (
+        process_semantic_input, 
+        format_semantic_results
+    )
+
+    return {
+        'display_semantic_interface': display_semantic_interface,
+        'display_semantic_results': display_semantic_results,
+        'process_semantic_input': process_semantic_input,
+        'format_semantic_results': format_analysis_results,
+    }
+
+
+def load_discourse_functions():
+    from .discourse.discourse_interface import (
+        display_discourse_interface, 
+        display_discourse_results
+    )
+    from modules.discourse.discourse_process import (
+        perform_discourse_analysis,      # Este es el nombre correcto de la función
+        extract_key_concepts,            # Función adicional que necesitamos
+        generate_concept_graph,          # Función adicional que necesitamos
+        calculate_similarity_matrix      # Función adicional que necesitamos
+    )
+    
+    return {
+        'display_discourse_interface': display_discourse_interface,
+        'display_discourse_results': display_discourse_results,
+        'perform_discourse_analysis': perform_discourse_analysis,
+        'extract_key_concepts': extract_key_concepts,
+        'generate_concept_graph': generate_concept_graph,
+        'calculate_similarity_matrix': calculate_similarity_matrix
+    }
+
+def load_admin_functions():
+    from .admin.admin_ui import admin_page
+    return {
+        'admin_page': admin_page
+    }
+
+def load_utils_functions():
+    from .utils.spacy_utils import load_spacy_models
+    return {
+        'load_spacy_models': load_spacy_models
+    }
+
+def load_chatbot_functions():
+    """
+    Carga las funciones del módulo de chatbot
+    Returns:
+        dict: Diccionario con las funciones del chatbot
+    """
+    from modules.chatbot.sidebar_chat import (
+        display_sidebar_chat
+    )
+    
+    from modules.chatbot.chat_process import (
+        ChatProcessor
+    )
+    
+    return {
+        'display_sidebar_chat': display_sidebar_chat,
+        'ChatProcessor': ChatProcessor
+    }
+
+# Función para cargar todas las funciones
+def load_all_functions():
+    return {
+        **load_auth_functions(),
+        **load_database_functions(),
+        # **load_ui_functions(),
+        **load_admin_functions(),
+        **load_morphosyntax_functions(),
+        **load_semantic_functions(),
+        **load_discourse_functions(),
+        **load_utils_functions(),
+        **load_chatbot_functions(),
+        **load_student_activities_functions(),
+        **load_current_situation_functions()  # Agregar el nuevo loader
+    }

modules/admin/admin_ui.py

@@ -0,0 +1,252 @@
+#modules/admin/admin_ui.py
+
+import streamlit as st
+
+from datetime import datetime
+
+from ..database.sql_db import (
+    get_user,
+    get_student_user,
+    get_admin_user,
+    get_teacher_user,
+    create_student_user,
+    update_student_user,
+    delete_student_user,
+    record_login, 
+    record_logout, 
+    get_recent_sessions,
+    get_user_total_time
+)
+
+from ..database.morphosintax_mongo_db import get_student_morphosyntax_analysis
+
+from ..auth.auth import hash_password  # Agregar esta importación al inicio
+
+########################################################
+def format_duration(seconds):
+    """Convierte segundos a formato legible"""
+    if not seconds:
+        return "0h 0m"
+    hours = seconds // 3600
+    minutes = (seconds % 3600) // 60
+    return f"{hours}h {minutes}m"
+
+
+
+########################################################
+def admin_page():
+    st.title("Panel de Administración")
+    st.write(f"Bienvenido, {st.session_state.username}")
+
+    # Crear tres tabs para las diferentes secciones
+    tab1, tab2, tab3 = st.tabs([
+        "Gestión de Usuarios",
+        "Búsqueda de Usuarios",
+        "Actividad de la Plataforma"
+    ])
+
+    
+########################################################
+    # Tab 1: Gestión de Usuarios
+    with tab1:
+        st.header("Crear Nuevo Usuario Estudiante")
+        
+        # Crear dos columnas para el formulario
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            new_username = st.text_input(
+                "Correo electrónico del nuevo usuario", 
+                key="admin_new_username"
+            )
+        
+        with col2:
+            new_password = st.text_input(
+                "Contraseña", 
+                type="password", 
+                key="admin_new_password"
+            )
+        
+        if st.button("Crear Usuario", key="admin_create_user", type="primary"):
+            if new_username and new_password:  # Verificamos que ambos campos tengan valor
+                try:
+                    # Hashear la contraseña antes de crear el usuario
+                    hashed_password = hash_password(new_password)
+                    if create_student_user(new_username, hashed_password, {'partitionKey': new_username}):
+                        st.success(f"Usuario estudiante {new_username} creado exitosamente")
+                    else:
+                        st.error("Error al crear el usuario estudiante")
+                except Exception as e:
+                    st.error(f"Error al crear usuario: {str(e)}")
+            else:
+                st.warning("Por favor complete todos los campos")
+
+#######################################################################                
+    # Tab 2: Búsqueda de Usuarios
+    with tab2:
+        st.header("Búsqueda de Usuarios")
+        
+        search_col1, search_col2 = st.columns([2,1])
+        
+        with search_col1:
+            student_username = st.text_input(
+                "Nombre de usuario del estudiante", 
+                key="admin_view_student"
+            )
+        
+        with search_col2:
+            search_button = st.button(
+                "Buscar", 
+                key="admin_view_student_data",
+                type="primary"
+            )
+
+        if search_button:
+            student = get_student_user(student_username)
+            if student:
+                # Crear tabs para diferentes tipos de información
+                info_tab1, info_tab2, info_tab3 = st.tabs([
+                    "Información Básica",
+                    "Análisis Realizados",
+                    "Tiempo en Plataforma"
+                ])
+                
+                with info_tab1:
+                    st.subheader("Información del Usuario")
+                    st.json(student)
+
+                with info_tab2:
+                    st.subheader("Análisis Realizados")
+                    student_data = get_student_morphosyntax_analysis(student_username)
+                    if student_data:
+                        st.json(student_data)
+                    else:
+                        st.info("No hay datos de análisis para este estudiante.")
+
+                with info_tab3:
+                    st.subheader("Tiempo en Plataforma")
+                    total_time = get_user_total_time(student_username)
+                    if total_time:
+                        st.metric(
+                            "Tiempo Total", 
+                            format_duration(total_time)
+                        )
+                    else:
+                        st.info("No hay registros de tiempo para este usuario")
+            else:
+                st.error("Estudiante no encontrado")
+
+#######################################################################      
+# Tab 3: Actividad de la Plataforma
+    with tab3:
+        st.header("Actividad Reciente")
+        
+        # Agregar botón de actualización
+        if st.button("Actualizar datos", key="refresh_sessions", type="primary"):
+            st.rerun()
+        
+        # Mostrar spinner mientras carga
+        with st.spinner("Cargando datos de sesiones..."):
+            # Obtener sesiones recientes
+            recent_sessions = get_recent_sessions(20)  # Aumentado a 20 para más datos
+        
+        if recent_sessions:
+            # Crear dataframe para mostrar los datos
+            sessions_data = []
+            for session in recent_sessions:
+                try:
+                    # Manejar el formato de fecha con manejo de excepciones
+                    try:
+                        login_time = datetime.fromisoformat(
+                            session['loginTime'].replace('Z', '+00:00')
+                        ).strftime("%Y-%m-%d %H:%M:%S")
+                    except Exception as e:
+                        login_time = session['loginTime']
+                    
+                    # Manejar el caso de logout_time cuando la sesión está activa
+                    if session.get('logoutTime') and session['logoutTime'] != "Activo":
+                        try:
+                            logout_time = datetime.fromisoformat(
+                                session['logoutTime'].replace('Z', '+00:00')
+                            ).strftime("%Y-%m-%d %H:%M:%S")
+                        except Exception as e:
+                            logout_time = session['logoutTime']
+                    else:
+                        logout_time = "Activo"
+                    
+                    # Agregar datos a la lista
+                    sessions_data.append({
+                        "Usuario": session.get('username', 'Desconocido'),
+                        "Inicio de Sesión": login_time,
+                        "Fin de Sesión": logout_time,
+                        "Duración": format_duration(session.get('sessionDuration', 0))
+                    })
+                except Exception as e:
+                    st.error(f"Error procesando sesión: {str(e)}")
+                    continue
+            
+            # Mostrar información de depuración si hay problemas
+            with st.expander("Información de depuración", expanded=False):
+                st.write("Datos crudos recuperados:")
+                st.json(recent_sessions)
+                
+                st.write("Datos procesados para mostrar:")
+                st.json(sessions_data)
+            
+            # Mostrar tabla con estilos
+            st.dataframe(
+                sessions_data,
+                hide_index=True,
+                column_config={
+                    "Usuario": st.column_config.TextColumn(
+                        "Usuario",
+                        width="medium"
+                    ),
+                    "Inicio de Sesión": st.column_config.TextColumn(
+                        "Inicio de Sesión",
+                        width="medium"
+                    ),
+                    "Fin de Sesión": st.column_config.TextColumn(
+                        "Fin de Sesión",
+                        width="medium"
+                    ),
+                    "Duración": st.column_config.TextColumn(
+                        "Duración",
+                        width="small"
+                    )
+                }
+            )
+            
+            # Añadir métricas resumen
+            total_sessions = len(sessions_data)
+            total_users = len(set(session['Usuario'] for session in sessions_data))
+            
+            metric_col1, metric_col2 = st.columns(2)
+            with metric_col1:
+                st.metric("Total de Sesiones", total_sessions)
+            with metric_col2:
+                st.metric("Usuarios Únicos", total_users)
+        else:
+            st.info("No hay registros de sesiones recientes o hubo un problema al recuperarlos.")
+            
+            # Ayuda de depuración
+            if st.button("Mostrar diagnóstico"):
+                st.write("Verificando la función get_recent_sessions:")
+                container = get_container("users_sessions")
+                if container:
+                    st.success("✅ Conectado al contenedor users_sessions")
+                else:
+                    st.error("❌ No se pudo conectar al contenedor users_sessions")
+
+##################################################################
+    # Agregar una línea divisoria antes del botón
+    st.markdown("---")
+
+##################################################################    
+    # Centrar el botón de cierre de sesión
+    col1, col2, col3 = st.columns([2,1,2])
+    with col2:
+        if st.button("Cerrar Sesión", key="admin_logout", type="primary", use_container_width=True):
+            from ..auth.auth import logout
+            logout()
+            st.rerun()

modules/chatbot/__init__.py

@@ -0,0 +1,8 @@
+# modules/chatbot/__init__.py
+from .sidebar_chat import display_sidebar_chat
+from .chat_process import ChatProcessor
+
+__all__ = [
+    'display_sidebar_chat',
+    'ChatProcessor'
+]

modules/chatbot/chabot.py

@@ -0,0 +1,60 @@
+# chatbot/chatbot.py
+import streamlit as st
+from typing import Dict, List, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+class AIdeaTextChatbot:
+    def __init__(self, lang_code: str):
+        self.lang_code = lang_code
+        self.conversation_history = []
+        self.context = {
+            'current_analysis': None,
+            'last_question': None,
+            'user_profile': None
+        }
+
+    def process_message(self, message: str, context: Dict = None) -> str:
+        """
+        Procesa el mensaje del usuario y genera una respuesta
+        """
+        try:
+            # Actualizar contexto
+            if context:
+                self.context.update(context)
+
+            # Analizar intención del mensaje
+            intent = self._analyze_intent(message)
+
+            # Generar respuesta basada en la intención
+            response = self._generate_response(intent, message)
+
+            # Actualizar historial
+            self._update_history(message, response)
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error procesando mensaje: {str(e)}")
+            return self._get_fallback_response()
+
+    def _analyze_intent(self, message: str) -> str:
+        """
+        Analiza la intención del mensaje del usuario
+        """
+        # Implementar análisis de intención
+        pass
+
+    def _generate_response(self, intent: str, message: str) -> str:
+        """
+        Genera una respuesta basada en la intención
+        """
+        # Implementar generación de respuesta
+        pass
+
+    def get_conversation_history(self) -> List[Tuple[str, str]]:
+        """
+        Retorna el historial de conversación
+        """
+        return self.conversation_history

modules/chatbot/chat_interface.py

@@ -0,0 +1,25 @@
+# chatbot/chat_interface.py
+import streamlit as st
+from .chatbot import AIdeaTextChatbot
+
+def display_chat_interface(lang_code: str, chat_translations: Dict):
+    """
+    Muestra la interfaz del chat
+    """
+    # Inicializar chatbot si no existe
+    if 'chatbot' not in st.session_state:
+        st.session_state.chatbot = AIdeaTextChatbot(lang_code)
+
+    # Mostrar historial
+    for msg in st.session_state.chatbot.get_conversation_history():
+        with st.chat_message(msg[0]):
+            st.write(msg[1])
+
+    # Input del usuario
+    if prompt := st.chat_input(chat_translations.get('chat_placeholder', 'Escribe tu mensaje...')):
+        # Procesar mensaje
+        response = st.session_state.chatbot.process_message(prompt)
+        
+        # Mostrar respuesta
+        with st.chat_message("assistant"):
+            st.write(response)

modules/chatbot/chat_process.py

@@ -0,0 +1,56 @@
+# modules/chatbot/chat_process.py
+import os
+import anthropic
+import logging
+from typing import Dict, Generator
+
+logger = logging.getLogger(__name__)
+
+####################################################
+class ChatProcessor:
+    def __init__(self):
+        """Inicializa el procesador de chat con la API de Claude"""
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        if not api_key:
+            raise ValueError("No se encontró la clave API de Anthropic. Asegúrate de configurarla en las variables de entorno.")
+        self.client = anthropic.Anthropic(api_key=api_key)
+        self.conversation_history = []
+
+    def process_chat_input(self, message: str, lang_code: str) -> Generator[str, None, None]:
+        """Procesa el mensaje y genera una respuesta"""
+        try:
+            # Agregar mensaje a la historia
+            self.conversation_history.append({"role": "user", "content": message})
+            
+            # Generar respuesta usando la API de Claude
+            response = self.client.messages.create(
+                model="claude-3-5-sonnet-20241022",
+                messages=self.conversation_history,
+                max_tokens=8000,  # Añadimos este parámetro requerido
+                temperature=0.7,
+            )
+            
+            # Procesar la respuesta
+            claude_response = response.content[0].text
+            self.conversation_history.append({"role": "assistant", "content": claude_response})
+            
+            # Mantener un historial limitado
+            if len(self.conversation_history) > 10:
+                self.conversation_history = self.conversation_history[-10:]
+                
+            # Dividir la respuesta en palabras para streaming
+            words = claude_response.split()
+            for word in words:
+                yield word + " "
+                
+        except Exception as e:
+            logger.error(f"Error en process_chat_input: {str(e)}")
+            yield f"Error: {str(e)}"
+
+    def get_conversation_history(self) -> list:
+        """Retorna el historial de la conversación"""
+        return self.conversation_history
+
+    def clear_history(self):
+        """Limpia el historial de la conversación"""
+        self.conversation_history = []

modules/chatbot/chatbot-Old.py

@@ -0,0 +1,46 @@
+import streamlit as st
+from ..text_analysis.morpho_analysis import perform_advanced_morphosyntactic_analysis
+from ..text_analysis.semantic_analysis import perform_semantic_analysis
+from ..text_analysis.discourse_analysis import perform_discourse_analysis
+
+class AIdeaTextChatbot:
+    def __init__(self):
+        self.conversation_history = []
+
+    def handle_morphosyntactic_input(self, user_input, lang_code, nlp_models, t):
+        if user_input.startswith('/analisis_morfosintactico'):
+            text_to_analyze = user_input.split('[', 1)[1].rsplit(']', 1)[0]
+            result = perform_advanced_morphosyntactic_analysis(text_to_analyze, nlp_models[lang_code])
+            if result is None or 'arc_diagrams' not in result:
+                return t.get('morphosyntactic_analysis_error', 'Error en el análisis morfosintáctico'), None, None
+            return t.get('morphosyntactic_analysis_completed', 'Análisis morfosintáctico completado'), result['arc_diagrams'], result
+        else:
+            # Aquí puedes manejar otras interacciones relacionadas con el análisis morfosintáctico
+            return self.generate_response(user_input, lang_code), None, None
+
+
+    def handle_semantic_input(self, user_input, lang_code, nlp_models, t):
+        # Implementar lógica para análisis semántico
+        pass
+
+    def handle_discourse_input(self, user_input, lang_code, nlp_models, t):
+        # Implementar lógica para análisis de discurso
+        pass
+
+    def handle_generate_response(self, prompt, lang_code):
+        # Aquí iría la lógica para generar respuestas generales del chatbot
+        # Puedes usar la API de Claude aquí si lo deseas
+        pass
+
+def initialize_chatbot():
+    return AIdeaTextChatbot()
+
+def process_chat_input(user_input, lang_code, nlp_models, analysis_type, t, file_contents=None):
+    chatbot = st.session_state.get('aideatext_chatbot')
+    if not chatbot:
+        chatbot = initialize_chatbot()
+        st.session_state.aideatext_chatbot = chatbot
+
+    if analysis_type == 'morphosyntactic':
+        return chatbot.handle_morphosyntactic_input(user_input, lang_code, nlp_models, t)
+    # ... manejar otros tipos de análisis ...

modules/chatbot/chatbot_open_Source_Model-test.py

@@ -0,0 +1,124 @@
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
+import torch
+from torch.optim import Adam
+from torch.utils.data import DataLoader, Dataset
+import json
+import tqdm
+
+tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2")
+model = GPT2LMHeadModel.from_pretrained("openai-community/gpt2")
+
+class MultilingualChatData(Dataset):
+    def __init__(self, file_path, tokenizer, max_length=512):
+        with open(file_path, 'r', encoding='utf-8') as f:
+            self.data = json.load(f)
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        item = self.data[idx]
+        input_text = f"<startofstring> {item['input']} <bot>: {item['output']} <endofstring>"
+        encoding = self.tokenizer(input_text, truncation=True, padding='max_length', max_length=self.max_length, return_tensors="pt")
+        return encoding['input_ids'].squeeze(), encoding['attention_mask'].squeeze()
+
+class MultilingualChatbot:
+    def __init__(self):
+        self.models = {
+            'en': GPT2LMHeadModel.from_pretrained("microsoft/DialoGPT-medium"),
+            'es': GPT2LMHeadModel.from_pretrained("DeepESP/gpt2-spanish"),
+            'fr': GPT2LMHeadModel.from_pretrained("asi/gpt-fr-cased-small")
+        }
+        self.tokenizers = {
+            'en': GPT2Tokenizer.from_pretrained("microsoft/DialoGPT-medium"),
+            'es': GPT2Tokenizer.from_pretrained("DeepESP/gpt2-spanish"),
+            'fr': GPT2Tokenizer.from_pretrained("asi/gpt-fr-cased-small")
+        }
+        for tokenizer in self.tokenizers.values():
+            tokenizer.pad_token = tokenizer.eos_token
+            tokenizer.add_special_tokens({
+                "bos_token": "<startofstring>",
+                "eos_token": "<endofstring>"
+            })
+            tokenizer.add_tokens(["<bot>:"])
+        
+        for model in self.models.values():
+            model.resize_token_embeddings(len(self.tokenizers['en']))  # Assuming all tokenizers have the same vocabulary size
+        
+        self.device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+        for model in self.models.values():
+            model.to(self.device)
+
+    def train(self, lang, data_file, epochs=5, batch_size=32, learning_rate=1e-4):
+        model = self.models[lang]
+        tokenizer = self.tokenizers[lang]
+        
+        chat_data = MultilingualChatData(data_file, tokenizer)
+        data_loader = DataLoader(chat_data, batch_size=batch_size, shuffle=True)
+        
+        optimizer = Adam(model.parameters(), lr=learning_rate)
+        
+        model.train()
+        for epoch in range(epochs):
+            total_loss = 0
+            for batch in tqdm.tqdm(data_loader, desc=f"Epoch {epoch+1}/{epochs}"):
+                input_ids, attention_mask = [b.to(self.device) for b in batch]
+                
+                optimizer.zero_grad()
+                outputs = model(input_ids, attention_mask=attention_mask, labels=input_ids)
+                loss = outputs.loss
+                loss.backward()
+                optimizer.step()
+                
+                total_loss += loss.item()
+            
+            print(f"Epoch {epoch+1}/{epochs}, Loss: {total_loss/len(data_loader):.4f}")
+        
+        torch.save(model.state_dict(), f"model_state_{lang}.pt")
+
+    def generate_response(self, prompt, src_lang):
+        model = self.models.get(src_lang, self.models['en'])
+        tokenizer = self.tokenizers.get(src_lang, self.tokenizers['en'])
+        
+        input_text = f"<startofstring> {prompt} <bot>: "
+        input_ids = tokenizer.encode(input_text, return_tensors='pt').to(self.device)
+        
+        attention_mask = torch.ones(input_ids.shape, dtype=torch.long, device=self.device)
+        
+        output = model.generate(
+            input_ids,
+            attention_mask=attention_mask,
+            max_length=1000,
+            pad_token_id=tokenizer.eos_token_id,
+            no_repeat_ngram_size=3,
+            do_sample=True,
+            top_k=50,
+            top_p=0.95,
+            temperature=0.7,
+            num_return_sequences=1,
+            length_penalty=1.0,
+            repetition_penalty=1.2
+        )
+        
+        decoded_output = tokenizer.decode(output[0], skip_special_tokens=True)
+        return decoded_output.split("<bot>:")[-1].strip()
+
+def initialize_chatbot():
+    return MultilingualChatbot()
+
+def get_chatbot_response(chatbot, prompt, src_lang):
+    return chatbot.generate_response(prompt, src_lang)
+
+# Ejemplo de uso
+if __name__ == "__main__":
+    chatbot = initialize_chatbot()
+    
+    # Entrenar el modelo en español (asumiendo que tienes un archivo de datos en español)
+    chatbot.train('es', './spanish_chat_data.json', epochs=3)
+    
+    # Generar respuestas
+    print(get_chatbot_response(chatbot, "Hola, ¿cómo estás?", 'es'))
+    print(get_chatbot_response(chatbot, "Hello, how are you?", 'en'))
+    print(get_chatbot_response(chatbot, "Bonjour, comment allez-vous?", 'fr'))

modules/chatbot/sidebar_chat.py

@@ -0,0 +1,113 @@
+# modules/chatbot/sidebar_chat.py
+import streamlit as st
+from .chat_process import ChatProcessor
+from ..database.chat_mongo_db import store_chat_history, get_chat_history
+import logging
+
+logger = logging.getLogger(__name__)
+
+def display_sidebar_chat(lang_code: str, chatbot_t: dict):
+    """
+    Muestra el chatbot en el sidebar
+    Args:
+        lang_code: Código del idioma
+        chatbot_t: Diccionario de traducciones del chatbot
+    """
+    # Asegurar que tenemos las traducciones necesarias
+    default_translations = {
+        'error_message': 'An error occurred',
+        'expand_chat': 'Open Assistant',
+        'initial_message': 'Hi! How can I help?',
+        'input_placeholder': 'Type your message...',
+        'clear_chat': 'Clear chat'
+    }
+    
+    # Combinar traducciones por defecto con las proporcionadas
+    translations = {**default_translations, **chatbot_t}
+
+    with st.sidebar:
+        # Chatbot expandible
+        with st.expander(translations['expand_chat'], expanded=False):
+            try:
+                # Inicializar procesador si no existe
+                if 'chat_processor' not in st.session_state:
+                    try:
+                        st.session_state.chat_processor = ChatProcessor()
+                    except Exception as e:
+                        logger.error(f"Error inicializando ChatProcessor: {str(e)}")
+                        st.error("Error: No se pudo inicializar el chat. Verifica la configuración.")
+                        return
+                
+                # Inicializar mensajes si no existen
+                if 'sidebar_messages' not in st.session_state:
+                    # Intentar recuperar historial previo
+                    try:
+                        history = get_chat_history(st.session_state.username, 'sidebar', 10)
+                        if history:
+                            st.session_state.sidebar_messages = history[0]['messages']
+                        else:
+                            st.session_state.sidebar_messages = [
+                                {"role": "assistant", "content": translations['initial_message']}
+                            ]
+                    except Exception as e:
+                        logger.error(f"Error recuperando historial: {str(e)}")
+                        st.session_state.sidebar_messages = [
+                            {"role": "assistant", "content": translations['initial_message']}
+                        ]
+
+                # Contenedor del chat
+                chat_container = st.container()
+
+                # Mostrar mensajes existentes
+                with chat_container:
+                    for message in st.session_state.sidebar_messages:
+                        with st.chat_message(message["role"]):
+                            st.markdown(message["content"])
+
+                # Input del usuario
+                user_input = st.text_input(
+                    translations['input_placeholder'],
+                    key='sidebar_chat_input'
+                )
+
+                if user_input:
+                    # Agregar mensaje del usuario
+                    st.session_state.sidebar_messages.append(
+                        {"role": "user", "content": user_input}
+                    )
+                
+                    # Generar y mostrar respuesta
+                    with chat_container:
+                        with st.chat_message("assistant"):
+                            message_placeholder = st.empty()
+                            full_response = ""
+                            
+                            for chunk in st.session_state.chat_processor.process_chat_input(
+                                user_input,
+                                lang_code
+                            ):
+                                full_response += chunk
+                                message_placeholder.markdown(full_response)
+                            
+                            # Guardar respuesta
+                            st.session_state.sidebar_messages.append(
+                                {"role": "assistant", "content": full_response.strip()}
+                            )
+                                    
+                    # En la función donde guardamos el chat
+                    store_chat_history(
+                        username=st.session_state.username,
+                        messages=st.session_state.sidebar_messages,
+                        analysis_type='sidebar'  # Especificar el tipo
+                    )
+
+                # Botón para limpiar chat
+                if st.button(translations['clear_chat']):
+                    st.session_state.sidebar_messages = [
+                        {"role": "assistant", "content": translations['initial_message']}
+                    ]
+                    st.rerun()
+
+            except Exception as e:
+                logger.error(f"Error en sidebar chat: {str(e)}")
+                st.error(translations['error_message'])

modules/discourse/__init__.py

@@ -0,0 +1,17 @@
+# En /modules/discourse/__init__.py
+
+from ..database.discourse_mongo_db import (
+    store_student_discourse_result,
+    get_student_discourse_analysis,
+    update_student_discourse_analysis,
+    delete_student_discourse_analysis,
+    get_student_discourse_data
+)
+
+__all__ = [
+    'store_student_discourse_result',
+    'get_student_discourse_analysis',
+    'update_student_discourse_analysis',
+    'delete_student_discourse_analysis',
+    'get_student_discourse_data'
+]

modules/discourse/discourse_interface.py

@@ -0,0 +1,281 @@
+# modules/discourse/discourse/discourse_interface.py
+
+import streamlit as st
+import pandas as pd
+import plotly.graph_objects as go
+import logging
+from ..utils.widget_utils import generate_unique_key
+from .discourse_process import perform_discourse_analysis
+from ..database.chat_mongo_db import store_chat_history
+from ..database.discourse_mongo_db import store_student_discourse_result
+
+logger = logging.getLogger(__name__)
+
+def display_discourse_interface(lang_code, nlp_models, discourse_t):
+    """
+    Interfaz para el análisis del discurso
+    Args:
+        lang_code: Código del idioma actual
+        nlp_models: Modelos de spaCy cargados
+        discourse_t: Diccionario de traducciones
+    """
+    try:
+        # 1. Inicializar estado si no existe
+        if 'discourse_state' not in st.session_state:
+            st.session_state.discourse_state = {
+                'analysis_count': 0,
+                'last_analysis': None,
+                'current_files': None
+            }
+
+        # 2. Título y descripción
+        st.subheader(discourse_t.get('discourse_title', 'Análisis del Discurso'))
+        st.info(discourse_t.get('initial_instruction', 
+            'Cargue dos archivos de texto para realizar un análisis comparativo del discurso.'))
+
+        # 3. Área de carga de archivos
+        col1, col2 = st.columns(2)
+        with col1:
+            st.markdown(discourse_t.get('file1_label', "**Documento 1 (Patrón)**"))
+            uploaded_file1 = st.file_uploader(
+                discourse_t.get('file_uploader1', "Cargar archivo 1"),
+                type=['txt'],
+                key=f"discourse_file1_{st.session_state.discourse_state['analysis_count']}"
+            )
+
+        with col2:
+            st.markdown(discourse_t.get('file2_label', "**Documento 2 (Comparación)**"))
+            uploaded_file2 = st.file_uploader(
+                discourse_t.get('file_uploader2', "Cargar archivo 2"),
+                type=['txt'],
+                key=f"discourse_file2_{st.session_state.discourse_state['analysis_count']}"
+            )
+
+        # 4. Botón de análisis
+        col1, col2, col3 = st.columns([1,2,1])
+        with col1:
+            analyze_button = st.button(
+                discourse_t.get('discourse_analyze_button', 'Analizar Discurso'),
+                key=generate_unique_key("discourse", "analyze_button"),
+                type="primary",
+                icon="🔍",
+                disabled=not (uploaded_file1 and uploaded_file2),
+                use_container_width=True
+            )
+
+        # 5. Proceso de análisis
+        if analyze_button and uploaded_file1 and uploaded_file2:
+            try:
+                with st.spinner(discourse_t.get('processing', 'Procesando análisis...')):
+                    # Leer contenido de archivos
+                    text1 = uploaded_file1.getvalue().decode('utf-8')
+                    text2 = uploaded_file2.getvalue().decode('utf-8')
+
+                    # Realizar análisis
+                    result = perform_discourse_analysis(
+                        text1, 
+                        text2, 
+                        nlp_models[lang_code],
+                        lang_code
+                    )
+
+                    if result['success']:
+                        # Guardar estado
+                        st.session_state.discourse_result = result
+                        st.session_state.discourse_state['analysis_count'] += 1
+                        st.session_state.discourse_state['current_files'] = (
+                            uploaded_file1.name,
+                            uploaded_file2.name
+                        )
+
+                        # Guardar en base de datos
+                        if store_student_discourse_result(
+                            st.session_state.username,
+                            text1,
+                            text2,
+                            result
+                        ):
+                            st.success(discourse_t.get('success_message', 'Análisis guardado correctamente'))
+                            
+                            # Mostrar resultados
+                            display_discourse_results(result, lang_code, discourse_t)
+                        else:
+                            st.error(discourse_t.get('error_message', 'Error al guardar el análisis'))
+                    else:
+                        st.error(discourse_t.get('analysis_error', 'Error en el análisis'))
+
+            except Exception as e:
+                logger.error(f"Error en análisis del discurso: {str(e)}")
+                st.error(discourse_t.get('error_processing', f'Error procesando archivos: {str(e)}'))
+
+        # 6. Mostrar resultados previos
+        elif 'discourse_result' in st.session_state and st.session_state.discourse_result is not None:
+            if st.session_state.discourse_state.get('current_files'):
+                st.info(
+                    discourse_t.get('current_analysis_message', 'Mostrando análisis de los archivos: {} y {}')
+                    .format(*st.session_state.discourse_state['current_files'])
+                )
+            display_discourse_results(
+                st.session_state.discourse_result,
+                lang_code,
+                discourse_t
+            )
+
+    except Exception as e:
+        logger.error(f"Error general en interfaz del discurso: {str(e)}")
+        st.error(discourse_t.get('general_error', 'Se produjo un error. Por favor, intente de nuevo.'))
+
+
+
+#####################################################################################################################
+
+def display_discourse_results(result, lang_code, discourse_t):
+    """
+    Muestra los resultados del análisis del discurso
+    """
+    if not result.get('success'):
+        st.warning(discourse_t.get('no_results', 'No hay resultados disponibles'))
+        return
+
+    # Estilo CSS
+    st.markdown("""
+        <style>
+        .concepts-container {
+            display: flex;
+            flex-wrap: nowrap;
+            gap: 8px;
+            padding: 12px;
+            background-color: #f8f9fa;
+            border-radius: 8px;
+            overflow-x: auto;
+            margin-bottom: 15px;
+            white-space: nowrap;
+        }
+        .concept-item {
+            background-color: white;
+            border-radius: 4px;
+            padding: 6px 10px;
+            display: inline-flex;
+            align-items: center;
+            gap: 4px;
+            box-shadow: 0 1px 2px rgba(0,0,0,0.1);
+            flex-shrink: 0;
+        }
+        .concept-name {
+            font-weight: 500;
+            color: #1f2937;
+            font-size: 0.85em;
+        }
+        .concept-freq {
+            color: #6b7280;
+            font-size: 0.75em;
+        }
+        .graph-container {
+            background-color: white;
+            padding: 15px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            margin-top: 10px;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    col1, col2 = st.columns(2)
+
+    # Documento 1
+    with col1:
+        st.subheader(discourse_t.get('doc1_title', 'Documento 1'))
+        st.markdown(discourse_t.get('key_concepts', 'Conceptos Clave'))
+        if 'key_concepts1' in result:
+            concepts_html = f"""
+                <div class="concepts-container">
+                    {''.join([
+                        f'<div class="concept-item"><span class="concept-name">{concept}</span>'
+                        f'<span class="concept-freq">({freq:.2f})</span></div>'
+                        for concept, freq in result['key_concepts1']
+                    ])}
+                </div>
+            """
+            st.markdown(concepts_html, unsafe_allow_html=True)
+
+            if 'graph1' in result:
+                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                st.pyplot(result['graph1'])
+                
+                # Botones y controles
+                button_col1, spacer_col1 = st.columns([1,4])
+                with button_col1:
+                    if 'graph1_bytes' in result:
+                        st.download_button(
+                            label="📥 " + discourse_t.get('download_graph', "Download"),
+                            data=result['graph1_bytes'],
+                            file_name="discourse_graph1.png",
+                            mime="image/png",
+                            use_container_width=True
+                        )
+
+                # Interpretación como texto normal sin expander
+                st.markdown("**📊 Interpretación del grafo:**")
+                st.markdown("""
+                    - 🔀 Las flechas indican la dirección de la relación entre conceptos
+                    - 🎨 Los colores más intensos indican conceptos más centrales en el texto
+                    - ⭕ El tamaño de los nodos representa la frecuencia del concepto
+                    - ↔️ El grosor de las líneas indica la fuerza de la conexión
+                """)
+                
+                st.markdown('</div>', unsafe_allow_html=True)
+            else:
+                st.warning(discourse_t.get('graph_not_available', 'Gráfico no disponible'))
+        else:
+            st.warning(discourse_t.get('concepts_not_available', 'Conceptos no disponibles'))
+
+    # Documento 2
+    with col2:
+        st.subheader(discourse_t.get('doc2_title', 'Documento 2'))
+        st.markdown(discourse_t.get('key_concepts', 'Conceptos Clave'))
+        if 'key_concepts2' in result:
+            concepts_html = f"""
+                <div class="concepts-container">
+                    {''.join([
+                        f'<div class="concept-item"><span class="concept-name">{concept}</span>'
+                        f'<span class="concept-freq">({freq:.2f})</span></div>'
+                        for concept, freq in result['key_concepts2']
+                    ])}
+                </div>
+            """
+            st.markdown(concepts_html, unsafe_allow_html=True)
+
+            if 'graph2' in result:
+                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                st.pyplot(result['graph2'])
+                
+                # Botones y controles
+                button_col2, spacer_col2 = st.columns([1,4])
+                with button_col2:
+                    if 'graph2_bytes' in result:
+                        st.download_button(
+                            label="📥 " + discourse_t.get('download_graph', "Download"),
+                            data=result['graph2_bytes'],
+                            file_name="discourse_graph2.png",
+                            mime="image/png",
+                            use_container_width=True
+                        )
+
+                # Interpretación como texto normal sin expander
+                st.markdown("**📊 Interpretación del grafo:**")
+                st.markdown("""
+                    - 🔀 Las flechas indican la dirección de la relación entre conceptos
+                    - 🎨 Los colores más intensos indican conceptos más centrales en el texto
+                    - ⭕ El tamaño de los nodos representa la frecuencia del concepto
+                    - ↔️ El grosor de las líneas indica la fuerza de la conexión
+                """)
+                
+                st.markdown('</div>', unsafe_allow_html=True)
+            else:
+                st.warning(discourse_t.get('graph_not_available', 'Gráfico no disponible'))
+        else:
+            st.warning(discourse_t.get('concepts_not_available', 'Conceptos no disponibles'))
+
+    # Nota informativa sobre la comparación
+    st.info(discourse_t.get('comparison_note', 
+        'La funcionalidad de comparación detallada estará disponible en una próxima actualización.'))

modules/discourse/discourse_live_interface.py

@@ -0,0 +1,151 @@
+# modules/discourse/discourse/discourse_live_interface.py
+
+import streamlit as st
+from streamlit_float import *
+from streamlit_antd_components import *
+import pandas as pd
+import logging
+import io
+import matplotlib.pyplot as plt
+
+# Configuración del logger
+logger = logging.getLogger(__name__)
+
+# Importaciones locales
+from .discourse_process import perform_discourse_analysis
+from .discourse_interface import display_discourse_results  # Añadida esta importación
+from ..utils.widget_utils import generate_unique_key
+from ..database.discourse_mongo_db import store_student_discourse_result
+from ..database.chat_mongo_db import store_chat_history, get_chat_history
+
+
+#####################################################################################################
+def fig_to_bytes(fig):
+    """Convierte una figura de matplotlib a bytes."""
+    try:
+        buf = io.BytesIO()
+        fig.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+        buf.seek(0)
+        return buf.getvalue()
+    except Exception as e:
+        logger.error(f"Error en fig_to_bytes: {str(e)}")
+        return None
+
+#################################################################################################
+def display_discourse_live_interface(lang_code, nlp_models, discourse_t):
+    """
+    Interfaz para el análisis del discurso en vivo con layout mejorado
+    """
+    try:
+        if 'discourse_live_state' not in st.session_state:
+            st.session_state.discourse_live_state = {
+                'analysis_count': 0,
+                'current_text1': '',
+                'current_text2': '',
+                'last_result': None,
+                'text_changed': False
+            }
+
+        # Título
+        st.subheader(discourse_t.get('enter_text', 'Ingrese sus textos'))
+
+        # Área de entrada de textos en dos columnas
+        text_col1, text_col2 = st.columns(2)
+
+        # Texto 1
+        with text_col1:
+            st.markdown("**Texto 1 (Patrón)**")
+            text_input1 = st.text_area(
+                "Texto 1",
+                height=200,
+                key="discourse_live_text1",
+                value=st.session_state.discourse_live_state.get('current_text1', ''),
+                label_visibility="collapsed"
+            )
+            st.session_state.discourse_live_state['current_text1'] = text_input1
+
+        # Texto 2
+        with text_col2:
+            st.markdown("**Texto 2 (Comparación)**")
+            text_input2 = st.text_area(
+                "Texto 2",
+                height=200,
+                key="discourse_live_text2",
+                value=st.session_state.discourse_live_state.get('current_text2', ''),
+                label_visibility="collapsed"
+            )
+            st.session_state.discourse_live_state['current_text2'] = text_input2
+
+        # Botón de análisis centrado
+        col1, col2, col3 = st.columns([1,2,1])
+        with col1:
+            analyze_button = st.button(
+                discourse_t.get('analyze_button', 'Analizar'),
+                key="discourse_live_analyze",
+                type="primary",
+                icon="🔍",
+                disabled=not (text_input1 and text_input2),
+                use_container_width=True
+            )
+
+        # Proceso y visualización de resultados
+        if analyze_button and text_input1 and text_input2:
+            try:
+                with st.spinner(discourse_t.get('processing', 'Procesando...')):
+                    result = perform_discourse_analysis(
+                        text_input1,
+                        text_input2,
+                        nlp_models[lang_code],
+                        lang_code
+                    )
+
+                    if result['success']:
+                        # Procesar ambos gráficos
+                        for graph_key in ['graph1', 'graph2']:
+                            if graph_key in result and result[graph_key] is not None:
+                                bytes_key = f'{graph_key}_bytes'
+                                graph_bytes = fig_to_bytes(result[graph_key])
+                                if graph_bytes:
+                                    result[bytes_key] = graph_bytes
+                                plt.close(result[graph_key])
+
+                        st.session_state.discourse_live_state['last_result'] = result
+                        st.session_state.discourse_live_state['analysis_count'] += 1
+                        
+                        store_student_discourse_result(
+                            st.session_state.username,
+                            text_input1,
+                            text_input2,
+                            result
+                        )
+
+                        # Mostrar resultados
+                        st.markdown("---")
+                        st.subheader(discourse_t.get('results_title', 'Resultados del Análisis'))
+                        display_discourse_results(result, lang_code, discourse_t)
+
+                    else:
+                        st.error(result.get('message', 'Error en el análisis'))
+
+            except Exception as e:
+                logger.error(f"Error en análisis: {str(e)}")
+                st.error(discourse_t.get('error_processing', f'Error al procesar el texto: {str(e)}'))
+
+        # Mostrar resultados previos si existen
+        elif 'last_result' in st.session_state.discourse_live_state and \
+             st.session_state.discourse_live_state['last_result'] is not None:
+            
+            st.markdown("---")
+            st.subheader(discourse_t.get('previous_results', 'Resultados del Análisis Anterior'))
+            display_discourse_results(
+                st.session_state.discourse_live_state['last_result'],
+                lang_code,
+                discourse_t
+            )
+
+    except Exception as e:
+        logger.error(f"Error general en interfaz del discurso en vivo: {str(e)}")
+        st.error(discourse_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
+
+
+

modules/discourse/discourse_process.py

@@ -0,0 +1,68 @@
+from ..text_analysis.discourse_analysis import perform_discourse_analysis, compare_semantic_analysis
+import streamlit as st
+
+def process_discourse_input(text1, text2, nlp_models, lang_code):
+    """
+    Procesa la entrada para el análisis del discurso
+    Args:
+        text1: Texto del primer documento
+        text2: Texto del segundo documento
+        nlp_models: Diccionario de modelos de spaCy
+        lang_code: Código del idioma actual
+    Returns:
+        dict: Resultados del análisis
+    """
+    try:
+        # Obtener el modelo específico del idioma
+        nlp = nlp_models[lang_code]
+        
+        # Realizar el análisis
+        analysis_result = perform_discourse_analysis(text1, text2, nlp, lang_code)
+        
+        if analysis_result['success']:
+            return {
+                'success': True,
+                'analysis': analysis_result
+            }
+        else:
+            return {
+                'success': False,
+                'error': 'Error en el análisis del discurso'
+            }
+            
+    except Exception as e:
+        logger.error(f"Error en process_discourse_input: {str(e)}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+def format_discourse_results(result):
+    """
+    Formatea los resultados del análisis para su visualización
+    Args:
+        result: Resultado del análisis
+    Returns:
+        dict: Resultados formateados
+    """
+    try:
+        if not result['success']:
+            return result
+
+        analysis = result['analysis']
+        return {
+            'success': True,
+            'graph1': analysis['graph1'],
+            'graph2': analysis['graph2'],
+            'key_concepts1': analysis['key_concepts1'],
+            'key_concepts2': analysis['key_concepts2'],
+            'table1': analysis['table1'],
+            'table2': analysis['table2']
+        }
+        
+    except Exception as e:
+        logger.error(f"Error en format_discourse_results: {str(e)}")
+        return {
+            'success': False,
+            'error': str(e)
+        }

modules/email/email.py

@@ -0,0 +1,92 @@
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+import os
+
+def send_email_notification(name, email, institution, role, reason):
+    sender_email = "[email protected]"  # Configura esto con tu dirección de correo
+    receiver_email = "[email protected]"
+    password = os.environ.get("NOREPLY_EMAIL_PASSWORD")  # Configura esto en tus variables de entorno
+
+    message = MIMEMultipart("alternative")
+    message["Subject"] = "Nueva solicitud de prueba de AIdeaText"
+    message["From"] = sender_email
+    message["To"] = receiver_email
+
+    text = f"""\
+    Nueva solicitud de prueba de AIdeaText:
+    Nombre: {name}
+    Email: {email}
+    Institución: {institution}
+    Rol: {role}
+    Razón: {reason}
+    """
+
+    html = f"""\
+    <html>
+      <body>
+        <h2>Nueva solicitud de prueba de AIdeaText</h2>
+        <p><strong>Nombre:</strong> {name}</p>
+        <p><strong>Email:</strong> {email}</p>
+        <p><strong>Institución:</strong> {institution}</p>
+        <p><strong>Rol:</strong> {role}</p>
+        <p><strong>Razón:</strong> {reason}</p>
+      </body>
+    </html>
+    """
+
+    part1 = MIMEText(text, "plain")
+    part2 = MIMEText(html, "html")
+
+    message.attach(part1)
+    message.attach(part2)
+
+    try:
+        with smtplib.SMTP_SSL("smtp.titan.email", 465) as server:
+            logger.info("Conectado al servidor SMTP")
+            server.login(sender_email, password)
+            logger.info("Inicio de sesión exitoso")
+            server.sendmail(sender_email, receiver_email, message.as_string())
+            logger.info(f"Correo enviado de {sender_email} a {receiver_email}")
+        logger.info(f"Email notification sent for application request: {email}")
+        return True
+    except Exception as e:
+        logger.error(f"Error sending email notification: {str(e)}")
+        return False
+
+def send_user_feedback_notification(name, email, feedback):
+    sender_email = "[email protected]"
+    receiver_email = "[email protected]"  # Cambia esto a la dirección que desees
+    password = os.environ.get("NOREPLY_EMAIL_PASSWORD")
+
+    message = MIMEMultipart("alternative")
+    message["Subject"] = "Nuevo comentario de usuario en AIdeaText"
+    message["From"] = sender_email
+    message["To"] = receiver_email
+
+    html = f"""\
+    <html>
+      <body>
+        <h2>Nuevo comentario de usuario en AIdeaText</h2>
+        <p><strong>Nombre:</strong> {name}</p>
+        <p><strong>Email:</strong> {email}</p>
+        <p><strong>Comentario:</strong> {feedback}</p>
+      </body>
+    </html>
+    """
+
+    part = MIMEText(html, "html")
+    message.attach(part)
+
+    try:
+        with smtplib.SMTP_SSL("smtp.titan.email", 465) as server:
+            logger.info("Conectado al servidor SMTP")
+            server.login(sender_email, password)
+            logger.info("Inicio de sesión exitoso")
+            server.sendmail(sender_email, receiver_email, message.as_string())
+            logger.info(f"Correo enviado de {sender_email} a {receiver_email}")
+        logger.info(f"Email notification sent for user feedback from: {email}")
+        return True
+    except Exception as e:
+        logger.error(f"Error sending user feedback email notification: {str(e)}")
+        return False

modules/morphosyntax/__init__.py

@@ -0,0 +1,29 @@
+from .morphosyntax_interface import (
+    display_morphosyntax_interface,
+    display_arc_diagram
+    # display_morphosyntax_results
+)
+
+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
+)
+
+__all__ = [
+    'display_morphosyntax_interface',
+    'display_arc_diagram',
+    #'display_morphosyntax_results',
+    'process_morphosyntactic_input',
+    'format_analysis_results',
+    'perform_advanced_morphosyntactic_analysis',
+    'get_repeated_words_colors',
+    'highlight_repeated_words',
+    'POS_COLORS',
+    'POS_TRANSLATIONS'
+]
+

modules/morphosyntax/morphosyntax_interface-Back1910-25-9-24.py

@@ -0,0 +1,171 @@
+#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 base64
+from .morphosyntax_process import process_morphosyntactic_input
+from ..chatbot.chatbot import initialize_chatbot
+from ..utils.widget_utils import generate_unique_key
+from ..database.database_oldFromV2 import store_morphosyntax_result
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+####################### VERSION ANTERIOR A LAS 20:00 24-9-24
+
+def display_morphosyntax_interface(lang_code, nlp_models, t):
+    # Estilo CSS personalizado
+    st.markdown("""
+        <style>
+        .morpho-initial-message {
+            background-color: #f0f2f6;
+            border-left: 5px solid #4CAF50;
+            padding: 10px;
+            border-radius: 5px;
+            font-size: 16px;
+            margin-bottom: 20px;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    # Mostrar el mensaje inicial como un párrafo estilizado
+    st.markdown(f"""
+        <div class="morpho-initial-message">
+        {t['morpho_initial_message']}
+        </div>
+    """, unsafe_allow_html=True)
+
+    # Inicializar el chatbot si no existe
+    if 'morphosyntax_chatbot' not in st.session_state:
+        st.session_state.morphosyntax_chatbot = initialize_chatbot('morphosyntactic')
+
+    # Crear un contenedor para el chat
+    chat_container = st.container()
+
+    # Mostrar el historial del chat
+    with chat_container:
+        if 'morphosyntax_chat_history' not in st.session_state:
+            st.session_state.morphosyntax_chat_history = []
+        for i, message in enumerate(st.session_state.morphosyntax_chat_history):
+            with st.chat_message(message["role"]):
+                st.write(message["content"])
+                if "visualizations" in message:
+                    for viz in message["visualizations"]:
+                        st.components.v1.html(
+                            f"""
+                            <div style="width: 100%; overflow-x: auto; white-space: nowrap;">
+                                <div style="min-width: 1200px;">
+                                    {viz}
+                                </div>
+                            </div>
+                            """,
+                            height=370,
+                            scrolling=True
+                        )
+
+
+    # Input del usuario
+    user_input = st.chat_input(
+        t['morpho_input_label'],
+        key=generate_unique_key('morphosyntax', "chat_input")
+    )
+
+    if user_input:
+        # Añadir el mensaje del usuario al historial
+        st.session_state.morphosyntax_chat_history.append({"role": "user", "content": user_input})
+
+        # Mostrar indicador de carga
+        with st.spinner(t.get('processing', 'Processing...')):
+            try:
+                # Procesar el input del usuario
+                response, visualizations, result = process_morphosyntactic_input(user_input, lang_code, nlp_models, t)
+
+                # Añadir la respuesta al historial
+                message = {
+                    "role": "assistant",
+                    "content": response
+                }
+                if visualizations:
+                    message["visualizations"] = visualizations
+                st.session_state.morphosyntax_chat_history.append(message)
+
+                # Mostrar la respuesta más reciente
+                with st.chat_message("assistant"):
+                    st.write(response)
+                    if visualizations:
+                        for i, viz in enumerate(visualizations):
+                            st.components.v1.html(
+                                f"""
+                                <div style="width: 100%; overflow-x: auto; white-space: nowrap;">
+                                    <div style="min-width: 1200px;">
+                                        {viz}
+                                    </div>
+                                </div>
+                                """,
+                                height=350,
+                                scrolling=True
+                            )
+
+                # Si es un análisis, guardarlo en la base de datos
+                if user_input.startswith('/analisis_morfosintactico') and result:
+                    store_morphosyntax_result(
+                        st.session_state.username,
+                        user_input.split('[', 1)[1].rsplit(']', 1)[0],  # texto analizado
+                        result.get('repeated_words', {}),
+                        visualizations,
+                        result.get('pos_analysis', []),
+                        result.get('morphological_analysis', []),
+                        result.get('sentence_structure', [])
+                    )
+
+            except Exception as e:
+                st.error(f"{t['error_processing']}: {str(e)}")
+
+        # Si es un análisis, guardarlo en la base de datos
+        if user_input.startswith('/analisis_morfosintactico') and result:
+            store_morphosyntax_result(
+                st.session_state.username,
+                user_input.split('[', 1)[1].rsplit(']', 1)[0],  # texto analizado
+                result['repeated_words'],
+                visualizations,  # Ahora pasamos todas las visualizaciones
+                result['pos_analysis'],
+                result['morphological_analysis'],
+                result['sentence_structure']
+            )
+
+    # Forzar la actualización de la interfaz
+        st.rerun()
+
+    # Botón para limpiar el historial del chat
+    if st.button(t['clear_chat'], key=generate_unique_key('morphosyntax', 'clear_chat')):
+        st.session_state.morphosyntax_chat_history = []
+        st.rerun()
+
+
+
+'''
+############ MODULO PARA DEPURACIÓN Y PRUEBAS #####################################################
+def display_morphosyntax_interface(lang_code, nlp_models, t):
+    st.subheader(t['morpho_title'])
+
+    text_input = st.text_area(
+        t['warning_message'],
+        height=150,
+        key=generate_unique_key("morphosyntax", "text_area")
+    )
+
+    if st.button(
+        t['results_title'],
+        key=generate_unique_key("morphosyntax", "analyze_button")
+    ):
+        if text_input:
+            # Aquí iría tu lógica de análisis morfosintáctico
+            # Por ahora, solo mostraremos un mensaje de placeholder
+            st.info(t['analysis_placeholder'])
+        else:
+            st.warning(t['no_text_warning'])
+###
+#################################################
+'''

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

@@ -0,0 +1,228 @@
+# modules/morphosyntax/morphosyntax_interface.py
+
+import streamlit as st
+import re
+import logging
+from spacy import displacy
+
+# Funciones de análisis y DB que ya tienes en tus módulos
+from ..morphosyntax.morphosyntax_process import perform_advanced_morphosyntactic_analysis
+from ..database.morphosyntax_iterative_mongo_db import (
+    store_student_morphosyntax_base,
+    store_student_morphosyntax_iteration,
+)
+
+logger = logging.getLogger(__name__)
+
+###########################################################################
+def initialize_arc_analysis_state():
+    """Inicializa el estado de análisis de arcos (base e iteraciones) si no existe."""
+    if "arc_analysis_state" not in st.session_state:
+        st.session_state.arc_analysis_state = {
+            "base_id": None,
+            "base_text": "",
+            "base_diagram": None,
+            "iteration_text": "",
+            "iteration_diagram": None,
+        }
+        logger.info("Estado de análisis de arcos inicializado.")
+
+###########################################################################
+def reset_arc_analysis_state():
+    """Resetea completamente el estado de análisis de arcos."""
+    st.session_state.arc_analysis_state = {
+        "base_id": None,
+        "base_text": "",
+        "base_diagram": None,
+        "iteration_text": "",
+        "iteration_diagram": None,
+    }
+    logger.info("Estado de arcos reseteado.")
+
+###########################################################################
+def display_arc_diagram(doc):
+    """
+    Genera y retorna el HTML del diagrama de arco para un Doc de spaCy.
+    No imprime directamente; retorna el HTML para usar con st.write(...).
+    """
+    try:
+        diagram_html = ""
+        for sent in doc.sents:
+            svg_html = displacy.render(
+                sent,
+                style="dep",
+                options={
+                    "distance": 100,
+                    "arrow_spacing": 20,
+                    "word_spacing": 30
+                }
+            )
+            # Ajustar tamaños
+            svg_html = svg_html.replace('height="375"', 'height="200"')
+            svg_html = re.sub(
+                r'<svg[^>]*>',
+                lambda m: m.group(0).replace('height="450"', 'height="300"'),
+                svg_html
+            )
+            svg_html = re.sub(
+                r'<g [^>]*transform="translate\((\d+),(\d+)\)"',
+                lambda m: f'<g transform="translate({m.group(1)},50)"',
+                svg_html
+            )
+            # Envolver en contenedor
+            diagram_html += f'<div class="arc-diagram-container">{svg_html}</div>'
+        return diagram_html
+
+    except Exception as e:
+        logger.error(f"Error en display_arc_diagram: {str(e)}")
+        return "<p style='color:red;'>Error generando diagrama</p>"
+
+###########################################################################
+def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
+    """
+    Interfaz principal para la visualización de diagramas de arco
+    (Texto Base vs Iteraciones).
+    """
+    # CSS para layout vertical y estable
+    st.markdown("""
+        <style>
+        .stTextArea textarea {
+            font-size: 1rem;
+            line-height: 1.5;
+            min-height: 100px !important;
+            height: 100px !important;
+        }
+        .arc-diagram-container {
+            width: 100%;
+            padding: 0.5rem;
+            margin: 0.5rem 0;
+        }
+        .divider {
+            height: 3px;
+            border: none;
+            background-color: #333;
+            margin: 2rem 0;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    # 1) Inicializar estados
+    initialize_arc_analysis_state()
+    arc_state = st.session_state.arc_analysis_state
+
+    # 2) Creamos pestañas: "Texto Base" y "Iteraciones"
+    tabs = st.tabs(["Texto Base", "Iteraciones"])
+
+    # =================== PESTAÑA 1: Texto Base ==========================
+    with tabs[0]:
+        st.subheader("Análisis de Texto Base")
+
+        # Botón para iniciar nuevo análisis
+        if st.button("Nuevo Análisis", key="btn_reset_base"):
+            # Si requieres recargar la app por completo, podrías descomentar:
+            # st.experimental_rerun()
+            reset_arc_analysis_state()
+
+        # Textarea de texto base
+        arc_state["base_text"] = st.text_area(
+            "Ingrese su texto inicial",
+            value=arc_state["base_text"],
+            key="base_text_input",
+            height=150
+        )
+
+        # Botón para analizar texto base
+        if st.button("Analizar Texto Base", key="btn_analyze_base"):
+            if not arc_state["base_text"].strip():
+                st.warning("Ingrese un texto para analizar.")
+            else:
+                try:
+                    # Procesar con spaCy
+                    doc = nlp_models[lang_code](arc_state["base_text"])
+                    base_arc_html = display_arc_diagram(doc)
+                    arc_state["base_diagram"] = base_arc_html
+
+                    # Guardar en Mongo
+                    analysis = perform_advanced_morphosyntactic_analysis(
+                        arc_state["base_text"],
+                        nlp_models[lang_code]
+                    )
+                    base_id = store_student_morphosyntax_base(
+                        username=st.session_state.username,
+                        text=arc_state["base_text"],
+                        arc_diagrams=analysis["arc_diagrams"]
+                    )
+                    if base_id:
+                        arc_state["base_id"] = base_id
+                        st.success(f"Análisis base guardado. ID: {base_id}")
+
+                except Exception as exc:
+                    st.error("Error procesando texto base")
+                    logger.error(f"Error en análisis base: {str(exc)}")
+
+        # Mostrar diagrama base
+        if arc_state["base_diagram"]:
+            st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+            st.markdown("#### Diagrama de Arco (Texto Base)")
+            st.write(arc_state["base_diagram"], unsafe_allow_html=True)
+
+    # ================== PESTAÑA 2: Iteraciones ==========================
+    with tabs[1]:
+        st.subheader("Análisis de Cambios / Iteraciones")
+
+        # Verificar que exista un texto base
+        if not arc_state["base_id"]:
+            st.info("Primero analiza un texto base en la pestaña anterior.")
+            return
+
+        # --- 1) Mostrar SIEMPRE el diagrama base arriba ---
+        st.markdown("#### Diagrama de Arco (Texto Base)")
+        if arc_state["base_diagram"]:
+            st.write(arc_state["base_diagram"], unsafe_allow_html=True)
+        else:
+            st.info("No hay diagrama base disponible.")
+
+        # --- 2) Caja de texto para la iteración ---
+        st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+        st.subheader("Texto de Iteración")
+        arc_state["iteration_text"] = st.text_area(
+            "Ingrese su nueva versión / iteración",
+            value=arc_state["iteration_text"],
+            height=150
+        )
+
+        # Botón para analizar iteración
+        if st.button("Analizar Cambios", key="btn_analyze_iteration"):
+            if not arc_state["iteration_text"].strip():
+                st.warning("Ingrese texto de iteración.")
+            else:
+                try:
+                    # Procesar con spaCy
+                    doc_iter = nlp_models[lang_code](arc_state["iteration_text"])
+                    arc_html_iter = display_arc_diagram(doc_iter)
+                    arc_state["iteration_diagram"] = arc_html_iter
+
+                    # Guardar en Mongo
+                    analysis_iter = perform_advanced_morphosyntactic_analysis(
+                        arc_state["iteration_text"],
+                        nlp_models[lang_code]
+                    )
+                    iteration_id = store_student_morphosyntax_iteration(
+                        username=st.session_state.username,
+                        base_id=arc_state["base_id"],
+                        original_text=arc_state["base_text"],
+                        iteration_text=arc_state["iteration_text"],
+                        arc_diagrams=analysis_iter["arc_diagrams"]
+                    )
+                    if iteration_id:
+                        st.success(f"Iteración guardada. ID: {iteration_id}")
+
+                except Exception as exc:
+                    st.error("Error procesando iteración")
+                    logger.error(f"Error en iteración: {str(exc)}")
+
+        # --- 3) Mostrar diagrama de iteración debajo ---
+        if arc_state["iteration_diagram"]:
+            st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+            st.markdown("#### Diagrama de Arco (Iteración)")
+            st.write(arc_state["iteration_diagram"], unsafe_allow_html=True)

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_interface_vOk-30-12-24.py

@@ -0,0 +1,247 @@
+# modules/morphosyntax/morphosyntax_interface.py
+
+import streamlit as st
+import re
+import logging
+from spacy import displacy
+
+# Se asume que la función perform_advanced_morphosyntactic_analysis
+# y los métodos store_student_morphosyntax_base/iteration existen.
+from ..morphosyntax.morphosyntax_process import perform_advanced_morphosyntactic_analysis
+from ..database.morphosyntax_iterative_mongo_db import (
+    store_student_morphosyntax_base,
+    store_student_morphosyntax_iteration,
+)
+
+logger = logging.getLogger(__name__)
+
+###########################################################################
+def initialize_arc_analysis_state():
+    """
+    Inicializa el estado de análisis de arcos (base e iteraciones) si no existe.
+    """
+    if "arc_analysis_state" not in st.session_state:
+        st.session_state.arc_analysis_state = {
+            "base_id": None,
+            "base_text": "",
+            "base_diagram": None,
+            "iteration_text": "",
+            "iteration_diagram": None,
+        }
+        logger.info("Estado de análisis de arcos inicializado.")
+
+###########################################################################
+def reset_arc_analysis_state():
+    """
+    Resetea completamente el estado de análisis de arcos.
+    """
+    st.session_state.arc_analysis_state = {
+        "base_id": None,
+        "base_text": "",
+        "base_diagram": None,
+        "iteration_text": "",
+        "iteration_diagram": None,
+    }
+    logger.info("Estado de arcos reseteado.")
+
+###########################################################################
+def display_arc_diagram(doc):
+    """
+    Genera y retorna el HTML del diagrama de arco para un `Doc` de spaCy.
+    No imprime directamente en pantalla; regresa el HTML para 
+    usar con `st.write(..., unsafe_allow_html=True)`.
+    """
+    try:
+        diagram_html = ""
+        for sent in doc.sents:
+            svg_html = displacy.render(
+                sent,
+                style="dep",
+                options={
+                    "distance": 100,
+                    "arrow_spacing": 20,
+                    "word_spacing": 30
+                }
+            )
+            # Ajustar tamaños
+            svg_html = svg_html.replace('height="375"', 'height="200"')
+            svg_html = re.sub(
+                r'<svg[^>]*>',
+                lambda m: m.group(0).replace('height="450"', 'height="300"'),
+                svg_html
+            )
+            svg_html = re.sub(
+                r'<g [^>]*transform="translate\((\d+),(\d+)\)"',
+                lambda m: f'<g transform="translate({m.group(1)},50)"',
+                svg_html
+            )
+            # Envolver en contenedor
+            diagram_html += f'<div class="arc-diagram-container">{svg_html}</div>'
+        return diagram_html
+
+    except Exception as e:
+        logger.error(f"Error en display_arc_diagram: {str(e)}")
+        return "<p style='color:red;'>Error generando diagrama</p>"
+
+###########################################################################
+def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
+    """
+    Interfaz principal para la visualización de diagramas de arco
+    (Texto Base vs Iteraciones).
+    """
+    # CSS para layout vertical y estable
+    st.markdown("""
+        <style>
+        .stTextArea textarea {
+            font-size: 1rem;
+            line-height: 1.5;
+            min-height: 100px !important;
+            height: 100px !important;
+        }
+        .arc-diagram-container {
+            width: 100%;
+            padding: 0.5rem;
+            margin: 0.5rem 0;
+        }
+        .divider {
+            height: 3px;
+            border: none;
+            background-color: #333;
+            margin: 2rem 0;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    # 1) Inicializar estados
+    initialize_arc_analysis_state()
+    arc_state = st.session_state.arc_analysis_state
+
+    # 2) Creamos pestañas: "Texto Base" y "Iteraciones"
+    tabs = st.tabs(["Texto Base", "Iteraciones"])
+
+    # =================== PESTAÑA 1: Texto Base ==========================
+    with tabs[0]:
+        st.subheader("Análisis de Texto Base")
+
+        # Botón para iniciar nuevo análisis
+        if st.button("Nuevo Análisis", key="btn_reset_base"):
+            # Solo limpiamos el estado; si requieres forzar reload,
+            # descomenta la siguiente línea:
+            # st.experimental_rerun()
+            reset_arc_analysis_state()
+
+        # Textarea de texto base
+        arc_state["base_text"] = st.text_area(
+            "Ingrese su texto inicial",
+            value=arc_state["base_text"],
+            key="base_text_input",
+            height=150
+        )
+
+        # Botón para analizar texto base
+        if st.button("Analizar Texto Base", key="btn_analyze_base"):
+            if not arc_state["base_text"].strip():
+                st.warning("Ingrese un texto para analizar.")
+            else:
+                try:
+                    # Procesar con spaCy
+                    doc = nlp_models[lang_code](arc_state["base_text"])
+                    # Generar HTML del arco
+                    arc_html = display_arc_diagram(doc)
+                    arc_state["base_diagram"] = arc_html
+
+                    # Guardar en Mongo
+                    analysis = perform_advanced_morphosyntactic_analysis(
+                        arc_state["base_text"],
+                        nlp_models[lang_code]
+                    )
+                    base_id = store_student_morphosyntax_base(
+                        username=st.session_state.username,
+                        text=arc_state["base_text"],
+                        arc_diagrams=analysis["arc_diagrams"]
+                    )
+                    if base_id:
+                        arc_state["base_id"] = base_id
+                        st.success(f"Análisis base guardado. ID: {base_id}")
+
+                except Exception as exc:
+                    st.error("Error procesando texto base")
+                    logger.error(f"Error en análisis base: {str(exc)}")
+
+        # Mostrar diagrama base
+        if arc_state["base_diagram"]:
+            st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+            st.markdown("#### Diagrama de Arco (Texto Base)")
+            st.write(arc_state["base_diagram"], unsafe_allow_html=True)
+
+    # ================== PESTAÑA 2: Iteraciones ==========================
+    with tabs[1]:
+        st.subheader("Análisis de Cambios / Iteraciones")
+
+        # Verificar que exista texto base analizado
+        if not arc_state["base_id"]:
+            st.info("Primero analiza un texto base en la pestaña anterior.")
+            return
+
+        # Mostrar texto base como referencia (solo lectura)
+        st.text_area(
+            "Texto Base (solo lectura)",
+            value=arc_state["base_text"],
+            height=80,
+            disabled=True
+        )
+
+        # Caja de texto para la iteración
+        arc_state["iteration_text"] = st.text_area(
+            "Texto de Iteración",
+            value=arc_state["iteration_text"],
+            height=150
+        )
+
+        # Botón analizar iteración
+        if st.button("Analizar Cambios", key="btn_analyze_iteration"):
+            if not arc_state["iteration_text"].strip():
+                st.warning("Ingrese texto de iteración.")
+            else:
+                try:
+                    # Procesar con spaCy
+                    doc_iter = nlp_models[lang_code](arc_state["iteration_text"])
+                    arc_html_iter = display_arc_diagram(doc_iter)
+                    arc_state["iteration_diagram"] = arc_html_iter
+
+                    # Guardar en Mongo
+                    analysis_iter = perform_advanced_morphosyntactic_analysis(
+                        arc_state["iteration_text"],
+                        nlp_models[lang_code]
+                    )
+                    iteration_id = store_student_morphosyntax_iteration(
+                        username=st.session_state.username,
+                        base_id=arc_state["base_id"],
+                        original_text=arc_state["base_text"],
+                        iteration_text=arc_state["iteration_text"],
+                        arc_diagrams=analysis_iter["arc_diagrams"]
+                    )
+                    if iteration_id:
+                        st.success(f"Iteración guardada. ID: {iteration_id}")
+
+                except Exception as exc:
+                    st.error("Error procesando iteración")
+                    logger.error(f"Error en iteración: {str(exc)}")
+
+        # Mostrar diagrama de iteración
+        if arc_state["iteration_diagram"]:
+            st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+            st.markdown("#### Diagrama de Arco (Iteración)")
+            st.write(arc_state["iteration_diagram"], unsafe_allow_html=True)
+
+        # Comparación vertical (uno abajo del otro)
+        if arc_state["base_diagram"] and arc_state["iteration_diagram"]:
+            st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+            st.markdown("### Comparación Vertical: Base vs. Iteración")
+            
+            st.markdown("**Diagrama Base**")
+            st.write(arc_state["base_diagram"], unsafe_allow_html=True)
+            
+            st.markdown("---")
+            st.markdown("**Diagrama Iterado**")
+            st.write(arc_state["iteration_diagram"], unsafe_allow_html=True)

modules/morphosyntax/morphosyntax_process-Back1910-25-9-24.py

@@ -0,0 +1,29 @@
+#modules/morphosyntax/morphosyntax_process.py
+from ..text_analysis.morpho_analysis import perform_advanced_morphosyntactic_analysis
+from ..database.database_oldFromV2 import store_morphosyntax_result
+import streamlit as st
+
+def process_morphosyntactic_input(user_input, lang_code, nlp_models, t):
+    if user_input.startswith('/analisis_morfosintactico'):
+        # Extraer el texto entre corchetes
+        text_to_analyze = user_input.split('[', 1)[1].rsplit(']', 1)[0]
+
+        # Realizar el análisis morfosintáctico
+        result = perform_advanced_morphosyntactic_analysis(text_to_analyze, nlp_models[lang_code])
+
+        if result is None:
+            response = t.get('morphosyntactic_analysis_error', 'Error in morphosyntactic analysis')
+            return response, None, None
+
+        # Preparar la respuesta
+        response = t.get('morphosyntactic_analysis_completed', 'Morphosyntactic analysis completed')
+
+        # Obtener todos los diagramas de arco
+        visualizations = result['arc_diagram']
+
+        return response, visualizations, result
+    else:
+        # Para otros tipos de input, simplemente devolver la respuesta del chatbot
+        chatbot = st.session_state.morphosyntax_chatbot
+        response = chatbot.generate_response(user_input, lang_code)
+        return response, None, None

modules/morphosyntax/morphosyntax_process.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/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/semantic/__init_.py

@@ -0,0 +1,17 @@
+# modules/semantic/__init_.py
+
+from .semantic_interface import (
+    display_semantic_interface,
+    display_semantic_results
+)
+from .semantic_process import (
+    process_semantic_input,
+    format_semantic_results
+)
+
+__all__ = [
+    'display_semantic_interface',
+    'display_semantic_results',
+    'process_semantic_input',
+    'format_semantic_results'
+]