Upload 292 files

.gitattributes

@@ -1,37 +1,51 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-assets/img/ALPHA_Startup[[:space:]]Badges.png filter=lfs diff=lfs merge=lfs -text
-assets/img/AIdeaText_Logo_vectores.png filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/img/AIdeaText_Logo_vectores.png filter=lfs diff=lfs merge=lfs -text
+assets/img/ALPHA_Startup[[:space:]]Badges.png filter=lfs diff=lfs merge=lfs -text
+assets/img/AIdeaTextCard.jpg filter=lfs diff=lfs merge=lfs -text
+assets/img/assets_img_logo_92x92.ico filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/_MG_2535.jpg filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/_MG_2585.jpg filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/_MG_2587.jpg filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/_MG_2590.jpg filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/_MG_2678.jpg filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/_MG_2727.jpg filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/_MG_2735.jpg filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/_MG_2790.jpg filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/_MG_2845.JPG filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/AIdeaTextCard.jpg filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/Facebook_CoverPhoto_820x312.jpg filter=lfs diff=lfs merge=lfs -text
+assets/img/socialmedia/Facebook_CoverPhoto-1_820x312.jpg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,14 +1,16 @@
----
-title: V3
-emoji: 👀
-colorFrom: blue
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.44.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: AIdeaText
----
-
+---
+title: v4
+emoji: 👀
+colorFrom: blue
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.44.1
+app_file: app.py
+pinned: true
+license: mit
+short_description: AIdeaText
+thumbnail: >-
+  https://cdn-uploads.huggingface.co/production/uploads/650f8981f141bc34f92d7bea/b6wrlUCEhhlFOQ5mJ6FtA.png
+---
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

modules/__init__.py

@@ -1,319 +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/__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

@@ -1,252 +1,250 @@
-#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()
+#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/auth/auth.py

@@ -1,195 +1,195 @@
-##########modules/auth/auth.py
-
-import os
-import streamlit as st
-from azure.cosmos import CosmosClient, exceptions
-from azure.cosmos.exceptions import CosmosHttpResponseError
-import bcrypt
-import base64
-from ..database.sql_db import (
-    get_user,
-    get_student_user,
-    get_admin_user,
-    create_student_user,
-    update_student_user,
-    delete_student_user,
-    record_login,
-    record_logout
-)
-
-import logging
-
-from datetime import datetime, timezone
-
-logger = logging.getLogger(__name__)
-
-def clean_and_validate_key(key):
-    """Limpia y valida la clave de CosmosDB"""
-    key = key.strip()
-    while len(key) % 4 != 0:
-        key += '='
-    try:
-        base64.b64decode(key)
-        return key
-    except:
-        raise ValueError("La clave proporcionada no es válida")
-
-# Verificar las variables de entorno
-endpoint = os.getenv("COSMOS_ENDPOINT")
-key = os.getenv("COSMOS_KEY")
-
-if not endpoint or not key:
-    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY deben estar configuradas")
-
-key = clean_and_validate_key(key)
-
-
-def authenticate_user(username, password):
-    """Autentica un usuario y registra el inicio de sesión"""
-    try:
-        user_item = get_user(username)
-        
-        if not user_item:
-            logger.warning(f"Usuario no encontrado: {username}")
-            return False, None
-            
-        if verify_password(user_item['password'], password):
-            logger.info(f"Usuario autenticado: {username}, Rol: {user_item['role']}")
-            
-            try:
-                session_id = record_login(username)
-                if session_id:
-                    st.session_state.session_id = session_id
-                    st.session_state.username = username
-                    st.session_state.login_time = datetime.now(timezone.utc).isoformat()
-                    logger.info(f"Sesión iniciada: {session_id}")
-                else:
-                    logger.warning("No se pudo registrar la sesión")
-            except Exception as e:
-                logger.error(f"Error al registrar inicio de sesión: {str(e)}")
-            
-            return True, user_item['role']
-            
-        logger.warning(f"Contraseña incorrecta para usuario: {username}")
-        return False, None
-        
-    except Exception as e:
-        logger.error(f"Error durante la autenticación del usuario: {str(e)}")
-        return False, None
-
-def authenticate_student(username, password):
-    """Autentica un estudiante"""
-    success, role = authenticate_user(username, password)
-    if success and role == 'Estudiante':
-        return True, role
-    return False, None
-
-def authenticate_admin(username, password):
-    """Autentica un administrador"""
-    success, role = authenticate_user(username, password)
-    if success and role == 'Administrador':
-        return True, role
-    return False, None
-
-def register_student(username, password, additional_info=None):
-    """Registra un nuevo estudiante"""
-    try:
-        if get_student_user(username):
-            logger.warning(f"Estudiante ya existe: {username}")
-            return False
-
-        hashed_password = hash_password(password)
-        
-        # Asegurarse que additional_info tenga el rol correcto
-        if not additional_info:
-            additional_info = {}
-        additional_info['role'] = 'Estudiante'
-        
-        success = create_student_user(username, hashed_password, additional_info)
-        if success:
-            logger.info(f"Nuevo estudiante registrado: {username}")
-            return True
-            
-        logger.error(f"Error al crear estudiante: {username}")
-        return False
-        
-    except Exception as e:
-        logger.error(f"Error al registrar estudiante: {str(e)}")
-        return False
-
-def update_student_info(username, new_info):
-    """Actualiza la información de un estudiante"""
-    try:
-        if 'password' in new_info:
-            new_info['password'] = hash_password(new_info['password'])
-            
-        success = update_student_user(username, new_info)
-        if success:
-            logger.info(f"Información actualizada: {username}")
-            return True
-            
-        logger.error(f"Error al actualizar: {username}")
-        return False
-        
-    except Exception as e:
-        logger.error(f"Error en actualización: {str(e)}")
-        return False
-
-def delete_student(username):
-    """Elimina un estudiante"""
-    try:
-        success = delete_student_user(username)
-        if success:
-            logger.info(f"Estudiante eliminado: {username}")
-            return True
-            
-        logger.error(f"Error al eliminar: {username}")
-        return False
-        
-    except Exception as e:
-        logger.error(f"Error en eliminación: {str(e)}")
-        return False
-
-def logout():
-    """Cierra la sesión del usuario"""
-    try:
-        if 'session_id' in st.session_state and 'username' in st.session_state:
-            success = record_logout(
-                st.session_state.username, 
-                st.session_state.session_id
-            )
-            if success:
-                logger.info(f"Sesión cerrada: {st.session_state.username}")
-            else:
-                logger.warning(f"Error al registrar cierre de sesión: {st.session_state.username}")
-        
-    except Exception as e:
-        logger.error(f"Error en logout: {str(e)}")
-    finally:
-        st.session_state.clear()
-
-def hash_password(password):
-    """Hashea una contraseña"""
-    return bcrypt.hashpw(
-        password.encode('utf-8'), 
-        bcrypt.gensalt()
-    ).decode('utf-8')
-
-def verify_password(stored_password, provided_password):
-    """Verifica una contraseña"""
-    return bcrypt.checkpw(
-        provided_password.encode('utf-8'), 
-        stored_password.encode('utf-8')
-    )
-
-__all__ = [
-    'authenticate_user',
-    'authenticate_admin',
-    'authenticate_student',
-    'register_student',
-    'update_student_info',
-    'delete_student',
-    'logout',
-    'hash_password',
-    'verify_password'
+##########modules/auth/auth.py
+
+import os
+import streamlit as st
+from azure.cosmos import CosmosClient, exceptions
+from azure.cosmos.exceptions import CosmosHttpResponseError
+import bcrypt
+import base64
+from ..database.sql_db import (
+    get_user,
+    get_student_user,
+    get_admin_user,
+    create_student_user,
+    update_student_user,
+    delete_student_user,
+    record_login,
+    record_logout
+)
+
+import logging
+
+from datetime import datetime, timezone
+
+logger = logging.getLogger(__name__)
+
+def clean_and_validate_key(key):
+    """Limpia y valida la clave de CosmosDB"""
+    key = key.strip()
+    while len(key) % 4 != 0:
+        key += '='
+    try:
+        base64.b64decode(key)
+        return key
+    except:
+        raise ValueError("La clave proporcionada no es válida")
+
+# Verificar las variables de entorno
+endpoint = os.getenv("COSMOS_ENDPOINT")
+key = os.getenv("COSMOS_KEY")
+
+if not endpoint or not key:
+    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY deben estar configuradas")
+
+key = clean_and_validate_key(key)
+
+
+def authenticate_user(username, password):
+    """Autentica un usuario y registra el inicio de sesión"""
+    try:
+        user_item = get_user(username)
+        
+        if not user_item:
+            logger.warning(f"Usuario no encontrado: {username}")
+            return False, None
+            
+        if verify_password(user_item['password'], password):
+            logger.info(f"Usuario autenticado: {username}, Rol: {user_item['role']}")
+            
+            try:
+                session_id = record_login(username)
+                if session_id:
+                    st.session_state.session_id = session_id
+                    st.session_state.username = username
+                    st.session_state.login_time = datetime.now(timezone.utc).isoformat()
+                    logger.info(f"Sesión iniciada: {session_id}")
+                else:
+                    logger.warning("No se pudo registrar la sesión")
+            except Exception as e:
+                logger.error(f"Error al registrar inicio de sesión: {str(e)}")
+            
+            return True, user_item['role']
+            
+        logger.warning(f"Contraseña incorrecta para usuario: {username}")
+        return False, None
+        
+    except Exception as e:
+        logger.error(f"Error durante la autenticación del usuario: {str(e)}")
+        return False, None
+
+def authenticate_student(username, password):
+    """Autentica un estudiante"""
+    success, role = authenticate_user(username, password)
+    if success and role == 'Estudiante':
+        return True, role
+    return False, None
+
+def authenticate_admin(username, password):
+    """Autentica un administrador"""
+    success, role = authenticate_user(username, password)
+    if success and role == 'Administrador':
+        return True, role
+    return False, None
+
+def register_student(username, password, additional_info=None):
+    """Registra un nuevo estudiante"""
+    try:
+        if get_student_user(username):
+            logger.warning(f"Estudiante ya existe: {username}")
+            return False
+
+        hashed_password = hash_password(password)
+        
+        # Asegurarse que additional_info tenga el rol correcto
+        if not additional_info:
+            additional_info = {}
+        additional_info['role'] = 'Estudiante'
+        
+        success = create_student_user(username, hashed_password, additional_info)
+        if success:
+            logger.info(f"Nuevo estudiante registrado: {username}")
+            return True
+            
+        logger.error(f"Error al crear estudiante: {username}")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error al registrar estudiante: {str(e)}")
+        return False
+
+def update_student_info(username, new_info):
+    """Actualiza la información de un estudiante"""
+    try:
+        if 'password' in new_info:
+            new_info['password'] = hash_password(new_info['password'])
+            
+        success = update_student_user(username, new_info)
+        if success:
+            logger.info(f"Información actualizada: {username}")
+            return True
+            
+        logger.error(f"Error al actualizar: {username}")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error en actualización: {str(e)}")
+        return False
+
+def delete_student(username):
+    """Elimina un estudiante"""
+    try:
+        success = delete_student_user(username)
+        if success:
+            logger.info(f"Estudiante eliminado: {username}")
+            return True
+            
+        logger.error(f"Error al eliminar: {username}")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error en eliminación: {str(e)}")
+        return False
+
+def logout():
+    """Cierra la sesión del usuario"""
+    try:
+        if 'session_id' in st.session_state and 'username' in st.session_state:
+            success = record_logout(
+                st.session_state.username, 
+                st.session_state.session_id
+            )
+            if success:
+                logger.info(f"Sesión cerrada: {st.session_state.username}")
+            else:
+                logger.warning(f"Error al registrar cierre de sesión: {st.session_state.username}")
+        
+    except Exception as e:
+        logger.error(f"Error en logout: {str(e)}")
+    finally:
+        st.session_state.clear()
+
+def hash_password(password):
+    """Hashea una contraseña"""
+    return bcrypt.hashpw(
+        password.encode('utf-8'), 
+        bcrypt.gensalt()
+    ).decode('utf-8')
+
+def verify_password(stored_password, provided_password):
+    """Verifica una contraseña"""
+    return bcrypt.checkpw(
+        provided_password.encode('utf-8'), 
+        stored_password.encode('utf-8')
+    )
+
+__all__ = [
+    'authenticate_user',
+    'authenticate_admin',
+    'authenticate_student',
+    'register_student',
+    'update_student_info',
+    'delete_student',
+    'logout',
+    'hash_password',
+    'verify_password'
 ]

modules/chatbot/__init__.py

@@ -1,8 +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/__init__.py
+from .sidebar_chat import display_sidebar_chat
+from .chat_process import ChatProcessor
+
+__all__ = [
+    'display_sidebar_chat',
+    'ChatProcessor'
 ]

modules/chatbot/chabot.py

@@ -1,60 +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
-        """
+# 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

@@ -1,25 +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"):
+# 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

@@ -1,56 +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"""
+# 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/sidebar_chat.py

@@ -1,113 +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)}")
+# 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/database/chat_mongo_db.py

@@ -1,116 +1,116 @@
-# /modules/database/chat_mongo_db.py
-from .mongo_db import insert_document, find_documents, get_collection
-from datetime import datetime, timezone
-import logging
-
-logger = logging.getLogger(__name__)
-COLLECTION_NAME = 'chat_history-v3'
-
-def get_chat_history(username: str, analysis_type: str = 'sidebar', limit: int = None) -> list:
-    """
-    Recupera el historial del chat.
-    
-    Args:
-        username: Nombre del usuario
-        analysis_type: Tipo de análisis ('sidebar' por defecto)
-        limit: Límite de conversaciones a recuperar
-        
-    Returns:
-        list: Lista de conversaciones con formato
-    """
-    try:
-        query = {
-            "username": username,
-            "analysis_type": analysis_type
-        }
-        
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:
-            logger.error("No se pudo obtener la colección de chat")
-            return []
-            
-        # Obtener y formatear conversaciones
-        cursor = collection.find(query).sort("timestamp", -1)
-        if limit:
-            cursor = cursor.limit(limit)
-            
-        conversations = []
-        for chat in cursor:
-            try:
-                formatted_chat = {
-                    'timestamp': chat['timestamp'],
-                    'messages': [
-                        {
-                            'role': msg.get('role', 'unknown'),
-                            'content': msg.get('content', '')
-                        }
-                        for msg in chat.get('messages', [])
-                    ]
-                }
-                conversations.append(formatted_chat)
-            except Exception as e:
-                logger.error(f"Error formateando chat: {str(e)}")
-                continue
-                
-        return conversations
-        
-    except Exception as e:
-        logger.error(f"Error al recuperar historial de chat: {str(e)}")
-        return []
-
-def store_chat_history(username: str, messages: list, analysis_type: str = 'sidebar') -> bool:
-    """
-    Guarda el historial del chat.
-    
-    Args:
-        username: Nombre del usuario
-        messages: Lista de mensajes a guardar
-        analysis_type: Tipo de análisis
-    
-    Returns:
-        bool: True si se guardó correctamente
-    """
-    try:
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:
-            logger.error("No se pudo obtener la colección de chat")
-            return False
-            
-        # Formatear mensajes antes de guardar
-        formatted_messages = [
-            {
-                'role': msg.get('role', 'unknown'),
-                'content': msg.get('content', ''),
-                'timestamp': datetime.now(timezone.utc).isoformat()
-            }
-            for msg in messages
-        ]
-        
-        chat_document = {
-            'username': username,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'messages': formatted_messages,
-            'analysis_type': analysis_type
-        }
-        
-        result = collection.insert_one(chat_document)
-        if result.inserted_id:
-            logger.info(f"Historial de chat guardado con ID: {result.inserted_id} para el usuario: {username}")
-            return True
-            
-        logger.error("No se pudo insertar el documento")
-        return False
-        
-    except Exception as e:
-        logger.error(f"Error al guardar historial de chat: {str(e)}")
-        return False
-        
-        
-        #def get_chat_history(username, analysis_type=None, limit=10):
-#    query = {"username": username}
-#    if analysis_type:
-#        query["analysis_type"] = analysis_type
-
-#    return find_documents(COLLECTION_NAME, query, sort=[("timestamp", -1)], limit=limit)
-
+# /modules/database/chat_mongo_db.py
+from .mongo_db import insert_document, find_documents, get_collection
+from datetime import datetime, timezone
+import logging
+
+logger = logging.getLogger(__name__)
+COLLECTION_NAME = 'chat_history-v3'
+
+def get_chat_history(username: str, analysis_type: str = 'sidebar', limit: int = None) -> list:
+    """
+    Recupera el historial del chat.
+    
+    Args:
+        username: Nombre del usuario
+        analysis_type: Tipo de análisis ('sidebar' por defecto)
+        limit: Límite de conversaciones a recuperar
+        
+    Returns:
+        list: Lista de conversaciones con formato
+    """
+    try:
+        query = {
+            "username": username,
+            "analysis_type": analysis_type
+        }
+        
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección de chat")
+            return []
+            
+        # Obtener y formatear conversaciones
+        cursor = collection.find(query).sort("timestamp", -1)
+        if limit:
+            cursor = cursor.limit(limit)
+            
+        conversations = []
+        for chat in cursor:
+            try:
+                formatted_chat = {
+                    'timestamp': chat['timestamp'],
+                    'messages': [
+                        {
+                            'role': msg.get('role', 'unknown'),
+                            'content': msg.get('content', '')
+                        }
+                        for msg in chat.get('messages', [])
+                    ]
+                }
+                conversations.append(formatted_chat)
+            except Exception as e:
+                logger.error(f"Error formateando chat: {str(e)}")
+                continue
+                
+        return conversations
+        
+    except Exception as e:
+        logger.error(f"Error al recuperar historial de chat: {str(e)}")
+        return []
+
+def store_chat_history(username: str, messages: list, analysis_type: str = 'sidebar') -> bool:
+    """
+    Guarda el historial del chat.
+    
+    Args:
+        username: Nombre del usuario
+        messages: Lista de mensajes a guardar
+        analysis_type: Tipo de análisis
+    
+    Returns:
+        bool: True si se guardó correctamente
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección de chat")
+            return False
+            
+        # Formatear mensajes antes de guardar
+        formatted_messages = [
+            {
+                'role': msg.get('role', 'unknown'),
+                'content': msg.get('content', ''),
+                'timestamp': datetime.now(timezone.utc).isoformat()
+            }
+            for msg in messages
+        ]
+        
+        chat_document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'messages': formatted_messages,
+            'analysis_type': analysis_type
+        }
+        
+        result = collection.insert_one(chat_document)
+        if result.inserted_id:
+            logger.info(f"Historial de chat guardado con ID: {result.inserted_id} para el usuario: {username}")
+            return True
+            
+        logger.error("No se pudo insertar el documento")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error al guardar historial de chat: {str(e)}")
+        return False
+        
+        
+        #def get_chat_history(username, analysis_type=None, limit=10):
+#    query = {"username": username}
+#    if analysis_type:
+#        query["analysis_type"] = analysis_type
+
+#    return find_documents(COLLECTION_NAME, query, sort=[("timestamp", -1)], limit=limit)
+
 # Agregar funciones para actualizar y eliminar chat si es necesario

modules/database/claude_recommendations_mongo_db.py

@@ -1,137 +1,137 @@
-# modules/database/claude_recommendations_mongo_db.py
-from datetime import datetime, timezone, timedelta
-import logging
-from .mongo_db import get_collection
-
-logger = logging.getLogger(__name__)
-COLLECTION_NAME = 'student_claude_recommendations'
-
-def store_claude_recommendation(username, text, metrics, text_type, recommendations):
-    """
-    Guarda las recomendaciones generadas por Claude AI.
-    
-    Args:
-        username: Nombre del usuario
-        text: Texto analizado
-        metrics: Métricas del análisis
-        text_type: Tipo de texto (academic_article, university_work, general_communication)
-        recommendations: Recomendaciones generadas por Claude
-        
-    Returns:
-        bool: True si se guardó correctamente, False en caso contrario
-    """
-    try:
-        # Verificar parámetros
-        if not all([username, text, recommendations]):
-            logger.error("Faltan parámetros requeridos para guardar recomendaciones de Claude")
-            return False
-            
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:
-            logger.error("No se pudo obtener la colección de recomendaciones de Claude")
-            return False
-            
-        # Crear documento
-        document = {
-            'username': username,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'text': text,
-            'metrics': metrics or {},
-            'text_type': text_type,
-            'recommendations': recommendations,
-            'analysis_type': 'claude_recommendation'
-        }
-        
-        # Insertar documento
-        result = collection.insert_one(document)
-        if result.inserted_id:
-            logger.info(f"""
-                Recomendaciones de Claude guardadas:
-                - Usuario: {username}
-                - ID: {result.inserted_id}
-                - Tipo de texto: {text_type}
-                - Longitud del texto: {len(text)}
-            """)
-            
-            # Verificar almacenamiento
-            storage_verified = verify_recommendation_storage(username)
-            if not storage_verified:
-                logger.warning("Verificación de almacenamiento de recomendaciones falló")
-            
-            return True
-            
-        logger.error("No se pudo insertar el documento de recomendaciones")
-        return False
-        
-    except Exception as e:
-        logger.error(f"Error guardando recomendaciones de Claude: {str(e)}")
-        return False
-
-def verify_recommendation_storage(username):
-    """
-    Verifica que las recomendaciones se están guardando correctamente.
-    
-    Args:
-        username: Nombre del usuario
-        
-    Returns:
-        bool: True si la verificación es exitosa, False en caso contrario
-    """
-    try:
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:
-            logger.error("No se pudo obtener la colección para verificación de recomendaciones")
-            return False
-            
-        # Buscar documentos recientes del usuario
-        timestamp_threshold = (datetime.now(timezone.utc) - timedelta(minutes=5)).isoformat()
-        recent_docs = collection.find({
-            'username': username,
-            'timestamp': {'$gte': timestamp_threshold}
-        }).sort('timestamp', -1).limit(1)
-        
-        docs = list(recent_docs)
-        if docs:
-            logger.info(f"""
-                Último documento de recomendaciones guardado:
-                - ID: {docs[0]['_id']}
-                - Timestamp: {docs[0]['timestamp']}
-                - Tipo de texto: {docs[0].get('text_type', 'N/A')}
-            """)
-            return True
-            
-        logger.warning(f"No se encontraron documentos recientes de recomendaciones para {username}")
-        return False
-        
-    except Exception as e:
-        logger.error(f"Error verificando almacenamiento de recomendaciones: {str(e)}")
-        return False
-
-def get_claude_recommendations(username, limit=10):
-    """
-    Obtiene las recomendaciones más recientes de Claude para un usuario.
-    
-    Args:
-        username: Nombre del usuario
-        limit: Número máximo de recomendaciones a recuperar
-        
-    Returns:
-        list: Lista de recomendaciones
-    """
-    try:
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:
-            logger.error("No se pudo obtener la colección de recomendaciones")
-            return []
-            
-        results = collection.find(
-            {'username': username}
-        ).sort('timestamp', -1).limit(limit)
-        
-        recommendations = list(results)
-        logger.info(f"Recuperadas {len(recommendations)} recomendaciones de Claude para {username}")
-        return recommendations
-        
-    except Exception as e:
-        logger.error(f"Error obteniendo recomendaciones de Claude: {str(e)}")
+# modules/database/claude_recommendations_mongo_db.py
+from datetime import datetime, timezone, timedelta
+import logging
+from .mongo_db import get_collection
+
+logger = logging.getLogger(__name__)
+COLLECTION_NAME = 'student_claude_recommendations'
+
+def store_claude_recommendation(username, text, metrics, text_type, recommendations):
+    """
+    Guarda las recomendaciones generadas por Claude AI.
+    
+    Args:
+        username: Nombre del usuario
+        text: Texto analizado
+        metrics: Métricas del análisis
+        text_type: Tipo de texto (academic_article, university_work, general_communication)
+        recommendations: Recomendaciones generadas por Claude
+        
+    Returns:
+        bool: True si se guardó correctamente, False en caso contrario
+    """
+    try:
+        # Verificar parámetros
+        if not all([username, text, recommendations]):
+            logger.error("Faltan parámetros requeridos para guardar recomendaciones de Claude")
+            return False
+            
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección de recomendaciones de Claude")
+            return False
+            
+        # Crear documento
+        document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text': text,
+            'metrics': metrics or {},
+            'text_type': text_type,
+            'recommendations': recommendations,
+            'analysis_type': 'claude_recommendation'
+        }
+        
+        # Insertar documento
+        result = collection.insert_one(document)
+        if result.inserted_id:
+            logger.info(f"""
+                Recomendaciones de Claude guardadas:
+                - Usuario: {username}
+                - ID: {result.inserted_id}
+                - Tipo de texto: {text_type}
+                - Longitud del texto: {len(text)}
+            """)
+            
+            # Verificar almacenamiento
+            storage_verified = verify_recommendation_storage(username)
+            if not storage_verified:
+                logger.warning("Verificación de almacenamiento de recomendaciones falló")
+            
+            return True
+            
+        logger.error("No se pudo insertar el documento de recomendaciones")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error guardando recomendaciones de Claude: {str(e)}")
+        return False
+
+def verify_recommendation_storage(username):
+    """
+    Verifica que las recomendaciones se están guardando correctamente.
+    
+    Args:
+        username: Nombre del usuario
+        
+    Returns:
+        bool: True si la verificación es exitosa, False en caso contrario
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección para verificación de recomendaciones")
+            return False
+            
+        # Buscar documentos recientes del usuario
+        timestamp_threshold = (datetime.now(timezone.utc) - timedelta(minutes=5)).isoformat()
+        recent_docs = collection.find({
+            'username': username,
+            'timestamp': {'$gte': timestamp_threshold}
+        }).sort('timestamp', -1).limit(1)
+        
+        docs = list(recent_docs)
+        if docs:
+            logger.info(f"""
+                Último documento de recomendaciones guardado:
+                - ID: {docs[0]['_id']}
+                - Timestamp: {docs[0]['timestamp']}
+                - Tipo de texto: {docs[0].get('text_type', 'N/A')}
+            """)
+            return True
+            
+        logger.warning(f"No se encontraron documentos recientes de recomendaciones para {username}")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error verificando almacenamiento de recomendaciones: {str(e)}")
+        return False
+
+def get_claude_recommendations(username, limit=10):
+    """
+    Obtiene las recomendaciones más recientes de Claude para un usuario.
+    
+    Args:
+        username: Nombre del usuario
+        limit: Número máximo de recomendaciones a recuperar
+        
+    Returns:
+        list: Lista de recomendaciones
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección de recomendaciones")
+            return []
+            
+        results = collection.find(
+            {'username': username}
+        ).sort('timestamp', -1).limit(limit)
+        
+        recommendations = list(results)
+        logger.info(f"Recuperadas {len(recommendations)} recomendaciones de Claude para {username}")
+        return recommendations
+        
+    except Exception as e:
+        logger.error(f"Error obteniendo recomendaciones de Claude: {str(e)}")
         return []

modules/database/current_situation_mongo_db.py

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

modules/database/database_init.py

@@ -1,188 +1,188 @@
-# 1. modules/database/database_init.py
-
-import os
-import logging
-from azure.cosmos import CosmosClient
-from pymongo import MongoClient
-import certifi
-
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-# Variables globales para Cosmos DB SQL API
-cosmos_client = None
-user_database = None
-user_container = None
-application_requests_container = None
-user_feedback_container = None
-user_sessions_container = None
-
-# Variables globales para Cosmos DB MongoDB API
-mongo_client = None
-mongo_db = None
-
-###################################################################
-def verify_container_partition_key(container, expected_path):
-    """Verifica la configuración de partition key de un contenedor"""
-    try:
-        container_props = container.read()
-        partition_key_paths = container_props['partitionKey']['paths']
-        logger.info(f"Container: {container.id}, Partition Key Paths: {partition_key_paths}")
-        return expected_path in partition_key_paths
-    except Exception as e:
-        logger.error(f"Error verificando partition key en {container.id}: {str(e)}")
-        return False
-
-###################################################################
-def get_container(container_name):
-    """Obtiene un contenedor específico"""
-    logger.info(f"Solicitando contenedor: {container_name}")
-    
-    if not initialize_cosmos_sql_connection():
-        logger.error("No se pudo inicializar la conexión")
-        return None
-    
-    # Verificar estado de los contenedores
-    containers_status = {
-        "users": user_container is not None,
-        "users_sessions": user_sessions_container is not None,
-        "application_requests": application_requests_container is not None,
-        "user_feedback": user_feedback_container is not None  # Añadido
-    }
-    
-    logger.info(f"Estado actual de los contenedores: {containers_status}")
-    
-    # Mapear nombres a contenedores
-    containers = {
-        "users": user_container,
-        "users_sessions": user_sessions_container,
-        "application_requests": application_requests_container,
-        "user_feedback": user_feedback_container  # Añadido
-    }
-    
-    container = containers.get(container_name)
-    
-    if container is None:
-        logger.error(f"Contenedor '{container_name}' no encontrado o no inicializado")
-        logger.error(f"Contenedores disponibles: {[k for k, v in containers_status.items() if v]}")
-        return None
-        
-    logger.info(f"Contenedor '{container_name}' obtenido exitosamente")
-    return container
-###################################################################
-
-def initialize_cosmos_sql_connection():
-    """Inicializa la conexión a Cosmos DB SQL API"""
-    global cosmos_client, user_database, user_container, user_sessions_container, application_requests_container, user_feedback_container  # Añadida aquí user_feedback_container
-
-    try:
-        # Verificar conexión existente
-        if all([
-            cosmos_client,
-            user_database, 
-            user_container,
-            user_sessions_container,
-            application_requests_container,
-            user_feedback_container
-        ]):
-            logger.debug("Todas las conexiones ya están inicializadas")
-            return True
-
-        # Obtener credenciales
-        cosmos_endpoint = os.environ.get("COSMOS_ENDPOINT")
-        cosmos_key = os.environ.get("COSMOS_KEY")
-        
-        if not cosmos_endpoint or not cosmos_key:
-            raise ValueError("COSMOS_ENDPOINT y COSMOS_KEY deben estar configurados")
-
-        # Inicializar cliente y base de datos
-        cosmos_client = CosmosClient(cosmos_endpoint, cosmos_key)
-        user_database = cosmos_client.get_database_client("user_database")
-        
-        # Inicializar contenedores
-        try:
-            user_container = user_database.get_container_client("users")
-            logger.info("Contenedor 'users' inicializado correctamente")
-        except Exception as e:
-            logger.error(f"Error inicializando contenedor 'users': {str(e)}")
-            user_container = None
-
-        try:
-            user_sessions_container = user_database.get_container_client("users_sessions")
-            logger.info("Contenedor 'users_sessions' inicializado correctamente")
-        except Exception as e:
-            logger.error(f"Error inicializando contenedor 'users_sessions': {str(e)}")
-            user_sessions_container = None
-
-        try:
-            application_requests_container = user_database.get_container_client("application_requests")
-            logger.info("Contenedor 'application_requests' inicializado correctamente")
-        except Exception as e:
-            logger.error(f"Error inicializando contenedor 'application_requests': {str(e)}")
-            application_requests_container = None
-
-        try:
-            user_feedback_container = user_database.get_container_client("user_feedback")
-            logger.info("Contenedor 'user_feedback' inicializado correctamente")
-        except Exception as e:
-            logger.error(f"Error inicializando contenedor 'user_feedback': {str(e)}")
-            user_feedback_container = None
-
-        # Verificar el estado de los contenedores
-        containers_status = {
-            'users': user_container is not None,
-            'users_sessions': user_sessions_container is not None,
-            'application_requests': application_requests_container is not None,
-            'user_feedback': user_feedback_container is not None
-        }
-        
-        logger.info(f"Estado de los contenedores: {containers_status}")
-        
-        if all(containers_status.values()):
-            logger.info("Todos los contenedores inicializados correctamente")
-            return True
-        else:
-            logger.error("No se pudieron inicializar todos los contenedores")
-            return False
-
-    except Exception as e:
-        logger.error(f"Error al conectar con Cosmos DB SQL API: {str(e)}")
-        return False
-
-
-###################################################################
-def initialize_mongodb_connection():
-    """Inicializa la conexión a MongoDB"""
-    global mongo_client, mongo_db
-    try:
-        connection_string = os.getenv("MONGODB_CONNECTION_STRING")
-        if not connection_string:
-            raise ValueError("MONGODB_CONNECTION_STRING debe estar configurado")
-
-        mongo_client = MongoClient(
-            connection_string,
-            tls=True,
-            tlsCAFile=certifi.where(),
-            retryWrites=False,
-            serverSelectionTimeoutMS=5000,
-            connectTimeoutMS=10000,
-            socketTimeoutMS=10000
-        )
-        
-        mongo_db = mongo_client['aideatext_db']
-        return True
-    except Exception as e:
-        logger.error(f"Error conectando a MongoDB: {str(e)}")
-        return False
-
-###################################################################
-def initialize_database_connections():
-    """Inicializa todas las conexiones"""
-    return initialize_cosmos_sql_connection() and initialize_mongodb_connection()
-
-###################################################################
-def get_mongodb():
-    """Obtiene la conexión MongoDB"""
-    if mongo_db is None:
-        initialize_mongodb_connection()
+# 1. modules/database/database_init.py
+
+import os
+import logging
+from azure.cosmos import CosmosClient
+from pymongo import MongoClient
+import certifi
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Variables globales para Cosmos DB SQL API
+cosmos_client = None
+user_database = None
+user_container = None
+application_requests_container = None
+user_feedback_container = None
+user_sessions_container = None
+
+# Variables globales para Cosmos DB MongoDB API
+mongo_client = None
+mongo_db = None
+
+###################################################################
+def verify_container_partition_key(container, expected_path):
+    """Verifica la configuración de partition key de un contenedor"""
+    try:
+        container_props = container.read()
+        partition_key_paths = container_props['partitionKey']['paths']
+        logger.info(f"Container: {container.id}, Partition Key Paths: {partition_key_paths}")
+        return expected_path in partition_key_paths
+    except Exception as e:
+        logger.error(f"Error verificando partition key en {container.id}: {str(e)}")
+        return False
+
+###################################################################
+def get_container(container_name):
+    """Obtiene un contenedor específico"""
+    logger.info(f"Solicitando contenedor: {container_name}")
+    
+    if not initialize_cosmos_sql_connection():
+        logger.error("No se pudo inicializar la conexión")
+        return None
+    
+    # Verificar estado de los contenedores
+    containers_status = {
+        "users": user_container is not None,
+        "users_sessions": user_sessions_container is not None,
+        "application_requests": application_requests_container is not None,
+        "user_feedback": user_feedback_container is not None  # Añadido
+    }
+    
+    logger.info(f"Estado actual de los contenedores: {containers_status}")
+    
+    # Mapear nombres a contenedores
+    containers = {
+        "users": user_container,
+        "users_sessions": user_sessions_container,
+        "application_requests": application_requests_container,
+        "user_feedback": user_feedback_container  # Añadido
+    }
+    
+    container = containers.get(container_name)
+    
+    if container is None:
+        logger.error(f"Contenedor '{container_name}' no encontrado o no inicializado")
+        logger.error(f"Contenedores disponibles: {[k for k, v in containers_status.items() if v]}")
+        return None
+        
+    logger.info(f"Contenedor '{container_name}' obtenido exitosamente")
+    return container
+###################################################################
+
+def initialize_cosmos_sql_connection():
+    """Inicializa la conexión a Cosmos DB SQL API"""
+    global cosmos_client, user_database, user_container, user_sessions_container, application_requests_container, user_feedback_container  # Añadida aquí user_feedback_container
+
+    try:
+        # Verificar conexión existente
+        if all([
+            cosmos_client,
+            user_database, 
+            user_container,
+            user_sessions_container,
+            application_requests_container,
+            user_feedback_container
+        ]):
+            logger.debug("Todas las conexiones ya están inicializadas")
+            return True
+
+        # Obtener credenciales
+        cosmos_endpoint = os.environ.get("COSMOS_ENDPOINT")
+        cosmos_key = os.environ.get("COSMOS_KEY")
+        
+        if not cosmos_endpoint or not cosmos_key:
+            raise ValueError("COSMOS_ENDPOINT y COSMOS_KEY deben estar configurados")
+
+        # Inicializar cliente y base de datos
+        cosmos_client = CosmosClient(cosmos_endpoint, cosmos_key)
+        user_database = cosmos_client.get_database_client("user_database")
+        
+        # Inicializar contenedores
+        try:
+            user_container = user_database.get_container_client("users")
+            logger.info("Contenedor 'users' inicializado correctamente")
+        except Exception as e:
+            logger.error(f"Error inicializando contenedor 'users': {str(e)}")
+            user_container = None
+
+        try:
+            user_sessions_container = user_database.get_container_client("users_sessions")
+            logger.info("Contenedor 'users_sessions' inicializado correctamente")
+        except Exception as e:
+            logger.error(f"Error inicializando contenedor 'users_sessions': {str(e)}")
+            user_sessions_container = None
+
+        try:
+            application_requests_container = user_database.get_container_client("application_requests")
+            logger.info("Contenedor 'application_requests' inicializado correctamente")
+        except Exception as e:
+            logger.error(f"Error inicializando contenedor 'application_requests': {str(e)}")
+            application_requests_container = None
+
+        try:
+            user_feedback_container = user_database.get_container_client("user_feedback")
+            logger.info("Contenedor 'user_feedback' inicializado correctamente")
+        except Exception as e:
+            logger.error(f"Error inicializando contenedor 'user_feedback': {str(e)}")
+            user_feedback_container = None
+
+        # Verificar el estado de los contenedores
+        containers_status = {
+            'users': user_container is not None,
+            'users_sessions': user_sessions_container is not None,
+            'application_requests': application_requests_container is not None,
+            'user_feedback': user_feedback_container is not None
+        }
+        
+        logger.info(f"Estado de los contenedores: {containers_status}")
+        
+        if all(containers_status.values()):
+            logger.info("Todos los contenedores inicializados correctamente")
+            return True
+        else:
+            logger.error("No se pudieron inicializar todos los contenedores")
+            return False
+
+    except Exception as e:
+        logger.error(f"Error al conectar con Cosmos DB SQL API: {str(e)}")
+        return False
+
+
+###################################################################
+def initialize_mongodb_connection():
+    """Inicializa la conexión a MongoDB"""
+    global mongo_client, mongo_db
+    try:
+        connection_string = os.getenv("MONGODB_CONNECTION_STRING")
+        if not connection_string:
+            raise ValueError("MONGODB_CONNECTION_STRING debe estar configurado")
+
+        mongo_client = MongoClient(
+            connection_string,
+            tls=True,
+            tlsCAFile=certifi.where(),
+            retryWrites=False,
+            serverSelectionTimeoutMS=5000,
+            connectTimeoutMS=10000,
+            socketTimeoutMS=10000
+        )
+        
+        mongo_db = mongo_client['aideatext_db']
+        return True
+    except Exception as e:
+        logger.error(f"Error conectando a MongoDB: {str(e)}")
+        return False
+
+###################################################################
+def initialize_database_connections():
+    """Inicializa todas las conexiones"""
+    return initialize_cosmos_sql_connection() and initialize_mongodb_connection()
+
+###################################################################
+def get_mongodb():
+    """Obtiene la conexión MongoDB"""
+    if mongo_db is None:
+        initialize_mongodb_connection()
     return mongo_db

modules/database/discourse_mongo_db.py

@@ -1,173 +1,152 @@
-# modules/database/discourse_mongo_db.py
-# Importaciones estándar
-import io
-import base64
-from datetime import datetime, timezone
-import logging
-
-# Importaciones de terceros
-import matplotlib.pyplot as plt
-
-from .mongo_db import (
-    get_collection,
-    insert_document, 
-    find_documents, 
-    update_document, 
-    delete_document
-)
-
-# Configuración del logger
-logger = logging.getLogger(__name__)
-COLLECTION_NAME = 'student_discourse_analysis'
-
-########################################################################
-def store_student_discourse_result(username, text1, text2, analysis_result):
-    """
-    Guarda el resultado del análisis de discurso comparativo en MongoDB.
-    """
-    try:
-        # Los gráficos ya vienen en bytes, solo necesitamos codificar a base64
-        graph1_data = None
-        graph2_data = None
-        combined_graph_data = None
-
-        if 'graph1' in analysis_result and analysis_result['graph1'] is not None:
-            try:
-                graph1_data = base64.b64encode(analysis_result['graph1']).decode('utf-8')
-            except Exception as e:
-                logger.error(f"Error al codificar gráfico 1: {str(e)}")
-
-        if 'graph2' in analysis_result and analysis_result['graph2'] is not None:
-            try:
-                graph2_data = base64.b64encode(analysis_result['graph2']).decode('utf-8')
-            except Exception as e:
-                logger.error(f"Error al codificar gráfico 2: {str(e)}")
-
-        if 'combined_graph' in analysis_result and analysis_result['combined_graph'] is not None:
-            try:
-                combined_graph_data = base64.b64encode(analysis_result['combined_graph']).decode('utf-8')
-            except Exception as e:
-                logger.error(f"Error al codificar gráfico combinado: {str(e)}")
-
-        # Crear documento para MongoDB
-        analysis_document = {
-            'username': username,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'text1': text1,
-            'text2': text2,
-            'analysis_type': 'discourse',
-            'key_concepts1': analysis_result.get('key_concepts1', []),
-            'key_concepts2': analysis_result.get('key_concepts2', []),
-            'graph1': graph1_data,
-            'graph2': graph2_data,
-            'combined_graph': combined_graph_data
-        }
-
-        # Insertar en MongoDB
-        result = insert_document(COLLECTION_NAME, analysis_document)
-        if result:
-            logger.info(f"Análisis del discurso guardado con ID: {result} para el usuario: {username}")
-            return True
-
-        logger.error("No se pudo insertar el documento en MongoDB")
-        return False
-
-    except Exception as e:
-        logger.error(f"Error al guardar el análisis del discurso: {str(e)}")
-        return False
-
-
-
-#################################################################################
-def get_student_discourse_analysis(username, limit=10):
-    """
-    Recupera los análisis del discurso de un estudiante.
-    """
-    try:
-        # Obtener la colección
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:  # Cambiado de if not collection a if collection is None
-            logger.error("No se pudo obtener la colección discourse")
-            return []
-
-        # Consulta
-        query = {
-            "username": username,
-            "analysis_type": "discourse"
-        }
-        
-        # Campos a recuperar
-        projection = {
-            "timestamp": 1,
-            "combined_graph": 1,
-            "_id": 1
-        }
-        
-        # Ejecutar consulta
-        try:
-            cursor = collection.find(query, projection).sort("timestamp", -1)
-            if limit:
-                cursor = cursor.limit(limit)
-            
-            # Convertir cursor a lista
-            results = list(cursor)
-            logger.info(f"Recuperados {len(results)} análisis del discurso para {username}")
-            return results
-            
-        except Exception as db_error:
-            logger.error(f"Error en la consulta a MongoDB: {str(db_error)}")
-            return []
-        
-    except Exception as e:
-        logger.error(f"Error recuperando análisis del discurso: {str(e)}")
-        return []
-#####################################################################################
-        
-def get_student_discourse_data(username):
-    """
-    Obtiene un resumen de los análisis del discurso de un estudiante.
-    """
-    try:
-        analyses = get_student_discourse_analysis(username, limit=None)
-        formatted_analyses = []
-        
-        for analysis in analyses:
-            formatted_analysis = {
-                'timestamp': analysis['timestamp'],
-                'text1': analysis.get('text1', ''),
-                'text2': analysis.get('text2', ''),
-                'key_concepts1': analysis.get('key_concepts1', []),
-                'key_concepts2': analysis.get('key_concepts2', [])
-            }
-            formatted_analyses.append(formatted_analysis)
-            
-        return {'entries': formatted_analyses}
-        
-    except Exception as e:
-        logger.error(f"Error al obtener datos del discurso: {str(e)}")
-        return {'entries': []}
-
-###########################################################################
-def update_student_discourse_analysis(analysis_id, update_data):
-    """
-    Actualiza un análisis del discurso existente.
-    """
-    try:
-        query = {"_id": analysis_id}
-        update = {"$set": update_data}
-        return update_document(COLLECTION_NAME, query, update)
-    except Exception as e:
-        logger.error(f"Error al actualizar análisis del discurso: {str(e)}")
-        return False
-
-###########################################################################
-def delete_student_discourse_analysis(analysis_id):
-    """
-    Elimina un análisis del discurso.
-    """
-    try:
-        query = {"_id": analysis_id}
-        return delete_document(COLLECTION_NAME, query)
-    except Exception as e:
-        logger.error(f"Error al eliminar análisis del discurso: {str(e)}")
+# modules/database/discourse_mongo_db.py
+import base64
+import logging
+from datetime import datetime, timezone
+from ..database.mongo_db import get_collection, insert_document, find_documents
+
+logger = logging.getLogger(__name__)
+
+COLLECTION_NAME = 'student_discourse_analysis'
+
+########################################################################
+
+def store_student_discourse_result(username, text1, text2, analysis_result):
+    """
+    Guarda el resultado del análisis de discurso en MongoDB.
+    """
+    try:
+        # Verificar que el resultado sea válido
+        if not analysis_result.get('success', False):
+            logger.error("No se puede guardar un análisis fallido")
+            return False
+            
+        logger.info(f"Almacenando análisis de discurso para {username}")
+        
+        # Preparar el documento para MongoDB
+        document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text1': text1,
+            'text2': text2,
+            'key_concepts1': analysis_result.get('key_concepts1', []),
+            'key_concepts2': analysis_result.get('key_concepts2', [])
+        }
+        
+        # Codificar gráficos a base64 para almacenamiento
+        for graph_key in ['graph1', 'graph2', 'combined_graph']:
+            if graph_key in analysis_result and analysis_result[graph_key] is not None:
+                if isinstance(analysis_result[graph_key], bytes):
+                    logger.info(f"Codificando {graph_key} como base64")
+                    document[graph_key] = base64.b64encode(analysis_result[graph_key]).decode('utf-8')
+                    logger.info(f"{graph_key} codificado correctamente, longitud: {len(document[graph_key])}")
+                else:
+                    logger.warning(f"{graph_key} no es de tipo bytes, es: {type(analysis_result[graph_key])}")
+            else:
+                logger.info(f"{graph_key} no presente en el resultado del análisis")
+        
+        # Almacenar el documento en MongoDB
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:  # CORREGIDO: Usar 'is None' en lugar de valor booleano
+            logger.error("No se pudo obtener la colección")
+            return False
+            
+        result = collection.insert_one(document)
+        logger.info(f"Análisis de discurso guardado con ID: {result.inserted_id}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error guardando análisis de discurso: {str(e)}")
+        return False
+
+#################################################################################
+
+# Corrección 1: Actualizar get_student_discourse_analysis para recuperar todos los campos necesarios
+
+def get_student_discourse_analysis(username, limit=10):
+    """
+    Recupera los análisis del discurso de un estudiante.
+    """
+    try:
+        logger.info(f"Recuperando análisis de discurso para {username}")
+        
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección")
+            return []
+            
+        query = {"username": username}
+        documents = list(collection.find(query).sort("timestamp", -1).limit(limit))
+        logger.info(f"Recuperados {len(documents)} documentos de análisis de discurso")
+        
+        # Decodificar gráficos para uso en la aplicación
+        for doc in documents:
+            for graph_key in ['graph1', 'graph2', 'combined_graph']:
+                if graph_key in doc and doc[graph_key]:
+                    try:
+                        # Verificar si es string (base64) y decodificar
+                        if isinstance(doc[graph_key], str):
+                            logger.info(f"Decodificando {graph_key} de base64 a bytes")
+                            doc[graph_key] = base64.b64decode(doc[graph_key])
+                            logger.info(f"{graph_key} decodificado correctamente, tamaño: {len(doc[graph_key])} bytes")
+                        elif not isinstance(doc[graph_key], bytes):
+                            logger.warning(f"{graph_key} no es ni string ni bytes: {type(doc[graph_key])}")
+                    except Exception as decode_error:
+                        logger.error(f"Error decodificando {graph_key}: {str(decode_error)}")
+                        doc[graph_key] = None
+        
+        return documents
+        
+    except Exception as e:
+        logger.error(f"Error recuperando análisis de discurso: {str(e)}")
+        return []
+        
+#####################################################################################
+        
+def get_student_discourse_data(username):
+    """
+    Obtiene un resumen de los análisis del discurso de un estudiante.
+    """
+    try:
+        analyses = get_student_discourse_analysis(username, limit=None)
+        formatted_analyses = []
+        
+        for analysis in analyses:
+            formatted_analysis = {
+                'timestamp': analysis['timestamp'],
+                'text1': analysis.get('text1', ''),
+                'text2': analysis.get('text2', ''),
+                'key_concepts1': analysis.get('key_concepts1', []),
+                'key_concepts2': analysis.get('key_concepts2', [])
+            }
+            formatted_analyses.append(formatted_analysis)
+            
+        return {'entries': formatted_analyses}
+        
+    except Exception as e:
+        logger.error(f"Error al obtener datos del discurso: {str(e)}")
+        return {'entries': []}
+
+###########################################################################
+def update_student_discourse_analysis(analysis_id, update_data):
+    """
+    Actualiza un análisis del discurso existente.
+    """
+    try:
+        query = {"_id": analysis_id}
+        update = {"$set": update_data}
+        return update_document(COLLECTION_NAME, query, update)
+    except Exception as e:
+        logger.error(f"Error al actualizar análisis del discurso: {str(e)}")
+        return False
+
+###########################################################################
+def delete_student_discourse_analysis(analysis_id):
+    """
+    Elimina un análisis del discurso.
+    """
+    try:
+        query = {"_id": analysis_id}
+        return delete_document(COLLECTION_NAME, query)
+    except Exception as e:
+        logger.error(f"Error al eliminar análisis del discurso: {str(e)}")
         return False

modules/database/mongo_db.py

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

modules/database/morphosyntax_iterative_mongo_db.py

@@ -1,171 +1,171 @@
-# modules/database/morphosyntax_iterative_mongo_db.py
-
-
-from datetime import datetime, timezone
-import logging
-from bson import ObjectId  # <--- Importar ObjectId
-from .mongo_db import get_collection, insert_document, find_documents, update_document, delete_document
-
-logger = logging.getLogger(__name__)
-
-BASE_COLLECTION = 'student_morphosyntax_analysis_base'
-ITERATION_COLLECTION = 'student_morphosyntax_iterations'
-
-def store_student_morphosyntax_base(username, text, arc_diagrams):
-    """Almacena el análisis morfosintáctico base y retorna su ObjectId."""
-    try:
-        base_document = {
-            'username': username,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'text': text,
-            'arc_diagrams': arc_diagrams,
-            'analysis_type': 'morphosyntax_base',
-            'has_iterations': False
-        }
-        collection = get_collection(BASE_COLLECTION)
-        result = collection.insert_one(base_document)
-
-        logger.info(f"Análisis base guardado para {username}")
-        # Retornamos el ObjectId directamente (NO str)
-        return result.inserted_id
-
-    except Exception as e:
-        logger.error(f"Error almacenando análisis base: {str(e)}")
-        return None
-
-def store_student_morphosyntax_iteration(username, base_id, original_text, iteration_text, arc_diagrams):
-    """
-    Almacena una iteración de análisis morfosintáctico.
-    base_id: ObjectId de la base (o string convertible a ObjectId).
-    """
-    try:
-        # Convertir a ObjectId si viene como string
-        if isinstance(base_id, str):
-            base_id = ObjectId(base_id)
-
-        iteration_document = {
-            'username': username,
-            'base_id': base_id,  # Guardar el ObjectId en la iteración
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'original_text': original_text,
-            'iteration_text': iteration_text,
-            'arc_diagrams': arc_diagrams,
-            'analysis_type': 'morphosyntax_iteration'
-        }
-        collection = get_collection(ITERATION_COLLECTION)
-        result = collection.insert_one(iteration_document)
-
-        # Actualizar documento base (usando ObjectId)
-        base_collection = get_collection(BASE_COLLECTION)
-        base_collection.update_one(
-            {'_id': base_id, 'username': username},
-            {'$set': {'has_iterations': True}}
-        )
-
-        logger.info(f"Iteración guardada para {username}, base_id: {base_id}")
-        return result.inserted_id  # Retornar el ObjectId de la iteración
-
-    except Exception as e:
-        logger.error(f"Error almacenando iteración: {str(e)}")
-        return None
-
-def get_student_morphosyntax_analysis(username, limit=10):
-    """
-    Obtiene los análisis base y sus iteraciones.
-    Returns: Lista de análisis con sus iteraciones.
-    """
-    try:
-        base_collection = get_collection(BASE_COLLECTION)
-        base_query = {
-            "username": username,
-            "analysis_type": "morphosyntax_base"
-        }
-        base_analyses = list(
-            base_collection.find(base_query).sort("timestamp", -1).limit(limit)
-        )
-
-        # Para cada análisis base, obtener sus iteraciones
-        iteration_collection = get_collection(ITERATION_COLLECTION)
-        for analysis in base_analyses:
-            base_id = analysis['_id']
-            # Buscar iteraciones con base_id = ObjectId
-            iterations = list(
-                iteration_collection.find({"base_id": base_id}).sort("timestamp", -1)
-            )
-            analysis['iterations'] = iterations
-
-        return base_analyses
-
-    except Exception as e:
-        logger.error(f"Error obteniendo análisis: {str(e)}")
-        return []
-
-def update_student_morphosyntax_analysis(analysis_id, is_base, update_data):
-    """
-    Actualiza un análisis base o iteración.
-    analysis_id puede ser un ObjectId o string.
-    """
-    from bson import ObjectId
-
-    try:
-        collection_name = BASE_COLLECTION if is_base else ITERATION_COLLECTION
-        collection = get_collection(collection_name)
-
-        if isinstance(analysis_id, str):
-            analysis_id = ObjectId(analysis_id)
-
-        query = {"_id": analysis_id}
-        update = {"$set": update_data}
-
-        result = update_document(collection_name, query, update)
-        return result
-
-    except Exception as e:
-        logger.error(f"Error actualizando análisis: {str(e)}")
-        return False
-
-def delete_student_morphosyntax_analysis(analysis_id, is_base):
-    """
-    Elimina un análisis base o iteración.
-    Si es base, también elimina todas sus iteraciones.
-    """
-    from bson import ObjectId
-
-    try:
-        if isinstance(analysis_id, str):
-            analysis_id = ObjectId(analysis_id)
-
-        if is_base:
-            # Eliminar iteraciones vinculadas
-            iteration_collection = get_collection(ITERATION_COLLECTION)
-            iteration_collection.delete_many({"base_id": analysis_id})
-
-            # Luego eliminar el análisis base
-            collection = get_collection(BASE_COLLECTION)
-        else:
-            collection = get_collection(ITERATION_COLLECTION)
-
-        query = {"_id": analysis_id}
-        result = delete_document(collection.name, query)
-        return result
-
-    except Exception as e:
-        logger.error(f"Error eliminando análisis: {str(e)}")
-        return False
-
-def get_student_morphosyntax_data(username):
-    """
-    Obtiene todos los datos de análisis morfosintáctico de un estudiante.
-    Returns: Diccionario con todos los análisis y sus iteraciones.
-    """
-    try:
-        analyses = get_student_morphosyntax_analysis(username, limit=None)
-        return {
-            'entries': analyses,
-            'total_analyses': len(analyses),
-            'has_iterations': any(a.get('has_iterations', False) for a in analyses)
-        }
-
-    except Exception as e:
-        logger.error(f"Error obteniendo datos del estudiante: {str(e)}")
-        return {'entries': [], 'total_analyses': 0, 'has_iterations': False}
+# modules/database/morphosyntax_iterative_mongo_db.py
+
+
+from datetime import datetime, timezone
+import logging
+from bson import ObjectId  # <--- Importar ObjectId
+from .mongo_db import get_collection, insert_document, find_documents, update_document, delete_document
+
+logger = logging.getLogger(__name__)
+
+BASE_COLLECTION = 'student_morphosyntax_analysis_base'
+ITERATION_COLLECTION = 'student_morphosyntax_iterations'
+
+def store_student_morphosyntax_base(username, text, arc_diagrams):
+    """Almacena el análisis morfosintáctico base y retorna su ObjectId."""
+    try:
+        base_document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text': text,
+            'arc_diagrams': arc_diagrams,
+            'analysis_type': 'morphosyntax_base',
+            'has_iterations': False
+        }
+        collection = get_collection(BASE_COLLECTION)
+        result = collection.insert_one(base_document)
+
+        logger.info(f"Análisis base guardado para {username}")
+        # Retornamos el ObjectId directamente (NO str)
+        return result.inserted_id
+
+    except Exception as e:
+        logger.error(f"Error almacenando análisis base: {str(e)}")
+        return None
+
+def store_student_morphosyntax_iteration(username, base_id, original_text, iteration_text, arc_diagrams):
+    """
+    Almacena una iteración de análisis morfosintáctico.
+    base_id: ObjectId de la base (o string convertible a ObjectId).
+    """
+    try:
+        # Convertir a ObjectId si viene como string
+        if isinstance(base_id, str):
+            base_id = ObjectId(base_id)
+
+        iteration_document = {
+            'username': username,
+            'base_id': base_id,  # Guardar el ObjectId en la iteración
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'original_text': original_text,
+            'iteration_text': iteration_text,
+            'arc_diagrams': arc_diagrams,
+            'analysis_type': 'morphosyntax_iteration'
+        }
+        collection = get_collection(ITERATION_COLLECTION)
+        result = collection.insert_one(iteration_document)
+
+        # Actualizar documento base (usando ObjectId)
+        base_collection = get_collection(BASE_COLLECTION)
+        base_collection.update_one(
+            {'_id': base_id, 'username': username},
+            {'$set': {'has_iterations': True}}
+        )
+
+        logger.info(f"Iteración guardada para {username}, base_id: {base_id}")
+        return result.inserted_id  # Retornar el ObjectId de la iteración
+
+    except Exception as e:
+        logger.error(f"Error almacenando iteración: {str(e)}")
+        return None
+
+def get_student_morphosyntax_analysis(username, limit=10):
+    """
+    Obtiene los análisis base y sus iteraciones.
+    Returns: Lista de análisis con sus iteraciones.
+    """
+    try:
+        base_collection = get_collection(BASE_COLLECTION)
+        base_query = {
+            "username": username,
+            "analysis_type": "morphosyntax_base"
+        }
+        base_analyses = list(
+            base_collection.find(base_query).sort("timestamp", -1).limit(limit)
+        )
+
+        # Para cada análisis base, obtener sus iteraciones
+        iteration_collection = get_collection(ITERATION_COLLECTION)
+        for analysis in base_analyses:
+            base_id = analysis['_id']
+            # Buscar iteraciones con base_id = ObjectId
+            iterations = list(
+                iteration_collection.find({"base_id": base_id}).sort("timestamp", -1)
+            )
+            analysis['iterations'] = iterations
+
+        return base_analyses
+
+    except Exception as e:
+        logger.error(f"Error obteniendo análisis: {str(e)}")
+        return []
+
+def update_student_morphosyntax_analysis(analysis_id, is_base, update_data):
+    """
+    Actualiza un análisis base o iteración.
+    analysis_id puede ser un ObjectId o string.
+    """
+    from bson import ObjectId
+
+    try:
+        collection_name = BASE_COLLECTION if is_base else ITERATION_COLLECTION
+        collection = get_collection(collection_name)
+
+        if isinstance(analysis_id, str):
+            analysis_id = ObjectId(analysis_id)
+
+        query = {"_id": analysis_id}
+        update = {"$set": update_data}
+
+        result = update_document(collection_name, query, update)
+        return result
+
+    except Exception as e:
+        logger.error(f"Error actualizando análisis: {str(e)}")
+        return False
+
+def delete_student_morphosyntax_analysis(analysis_id, is_base):
+    """
+    Elimina un análisis base o iteración.
+    Si es base, también elimina todas sus iteraciones.
+    """
+    from bson import ObjectId
+
+    try:
+        if isinstance(analysis_id, str):
+            analysis_id = ObjectId(analysis_id)
+
+        if is_base:
+            # Eliminar iteraciones vinculadas
+            iteration_collection = get_collection(ITERATION_COLLECTION)
+            iteration_collection.delete_many({"base_id": analysis_id})
+
+            # Luego eliminar el análisis base
+            collection = get_collection(BASE_COLLECTION)
+        else:
+            collection = get_collection(ITERATION_COLLECTION)
+
+        query = {"_id": analysis_id}
+        result = delete_document(collection.name, query)
+        return result
+
+    except Exception as e:
+        logger.error(f"Error eliminando análisis: {str(e)}")
+        return False
+
+def get_student_morphosyntax_data(username):
+    """
+    Obtiene todos los datos de análisis morfosintáctico de un estudiante.
+    Returns: Diccionario con todos los análisis y sus iteraciones.
+    """
+    try:
+        analyses = get_student_morphosyntax_analysis(username, limit=None)
+        return {
+            'entries': analyses,
+            'total_analyses': len(analyses),
+            'has_iterations': any(a.get('has_iterations', False) for a in analyses)
+        }
+
+    except Exception as e:
+        logger.error(f"Error obteniendo datos del estudiante: {str(e)}")
+        return {'entries': [], 'total_analyses': 0, 'has_iterations': False}

modules/database/semantic_export.py

@@ -1,78 +1,78 @@
-from io import BytesIO
-from reportlab.lib import colors
-from reportlab.lib.pagesizes import letter
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, PageBreak
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib.units import cm
-from svglib.svglib import svg2rlg
-from reportlab.graphics import renderPM
-import base64
-import cairosvg
-from reportlab.graphics import renderPDF
-from reportlab.lib.utils import ImageReader
-
-#importaciones locales
-from .semantic_mongo_db import get_student_semantic_data
-from .chat_db import get_chat_history
-
-# Placeholder para el logo
-LOGO_PATH = "assets\img\logo_92x92.png" # Reemplaza esto con la ruta real de tu logo
-
-# Definir el tamaño de página carta manualmente (612 x 792 puntos)
-LETTER_SIZE = (612, 792)
-
-def add_logo(canvas, doc):
-    logo = Image(LOGO_PATH, width=2*cm, height=2*cm)
-    logo.drawOn(canvas, doc.leftMargin, doc.height + doc.topMargin - 0.5*cm)
-
-def export_user_interactions(username, analysis_type):
-    # Obtener historial de chat (que ahora incluye los análisis morfosintácticos)
-    chat_history = get_chat_history(username, analysis_type)
-
-    # Crear un PDF
-    buffer = BytesIO()
-    doc = SimpleDocTemplate(
-        buffer,
-        pagesize=letter,
-        rightMargin=2*cm,
-        leftMargin=2*cm,
-        topMargin=2*cm,
-        bottomMargin=2*cm
-    )
-
-    story = []
-    styles = getSampleStyleSheet()
-
-    # Título
-    story.append(Paragraph(f"Interacciones de {username} - Análisis {analysis_type}", styles['Title']))
-    story.append(Spacer(1, 0.5*cm))
-
-    # Historial del chat y análisis
-    for entry in chat_history:
-        for message in entry['messages']:
-            role = message['role']
-            content = message['content']
-            story.append(Paragraph(f"<b>{role.capitalize()}:</b> {content}", styles['BodyText']))
-            story.append(Spacer(1, 0.25*cm))
-
-            # Si hay visualizaciones (diagramas SVG), convertirlas a imagen y añadirlas
-            if 'visualizations' in message and message['visualizations']:
-                for svg in message['visualizations']:
-                    drawing = svg2rlg(BytesIO(svg.encode('utf-8')))
-                    img_data = BytesIO()
-                    renderPM.drawToFile(drawing, img_data, fmt="PNG")
-                    img_data.seek(0)
-                    img = Image(img_data, width=15*cm, height=7.5*cm)
-                    story.append(img)
-                    story.append(Spacer(1, 0.5*cm))
-
-        story.append(PageBreak())
-
-    # Construir el PDF
-    doc.build(story)
-    buffer.seek(0)
-    return buffer
-
-# Uso en Streamlit:
-# pdf_buffer = export_user_interactions(username, 'morphosyntax')
+from io import BytesIO
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, PageBreak
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import cm
+from svglib.svglib import svg2rlg
+from reportlab.graphics import renderPM
+import base64
+import cairosvg
+from reportlab.graphics import renderPDF
+from reportlab.lib.utils import ImageReader
+
+#importaciones locales
+from .semantic_mongo_db import get_student_semantic_data
+from .chat_db import get_chat_history
+
+# Placeholder para el logo
+LOGO_PATH = "assets\img\logo_92x92.png" # Reemplaza esto con la ruta real de tu logo
+
+# Definir el tamaño de página carta manualmente (612 x 792 puntos)
+LETTER_SIZE = (612, 792)
+
+def add_logo(canvas, doc):
+    logo = Image(LOGO_PATH, width=2*cm, height=2*cm)
+    logo.drawOn(canvas, doc.leftMargin, doc.height + doc.topMargin - 0.5*cm)
+
+def export_user_interactions(username, analysis_type):
+    # Obtener historial de chat (que ahora incluye los análisis morfosintácticos)
+    chat_history = get_chat_history(username, analysis_type)
+
+    # Crear un PDF
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=letter,
+        rightMargin=2*cm,
+        leftMargin=2*cm,
+        topMargin=2*cm,
+        bottomMargin=2*cm
+    )
+
+    story = []
+    styles = getSampleStyleSheet()
+
+    # Título
+    story.append(Paragraph(f"Interacciones de {username} - Análisis {analysis_type}", styles['Title']))
+    story.append(Spacer(1, 0.5*cm))
+
+    # Historial del chat y análisis
+    for entry in chat_history:
+        for message in entry['messages']:
+            role = message['role']
+            content = message['content']
+            story.append(Paragraph(f"<b>{role.capitalize()}:</b> {content}", styles['BodyText']))
+            story.append(Spacer(1, 0.25*cm))
+
+            # Si hay visualizaciones (diagramas SVG), convertirlas a imagen y añadirlas
+            if 'visualizations' in message and message['visualizations']:
+                for svg in message['visualizations']:
+                    drawing = svg2rlg(BytesIO(svg.encode('utf-8')))
+                    img_data = BytesIO()
+                    renderPM.drawToFile(drawing, img_data, fmt="PNG")
+                    img_data.seek(0)
+                    img = Image(img_data, width=15*cm, height=7.5*cm)
+                    story.append(img)
+                    story.append(Spacer(1, 0.5*cm))
+
+        story.append(PageBreak())
+
+    # Construir el PDF
+    doc.build(story)
+    buffer.seek(0)
+    return buffer
+
+# Uso en Streamlit:
+# pdf_buffer = export_user_interactions(username, 'morphosyntax')
 # st.download_button(label="Descargar PDF", data=pdf_buffer, file_name="interacciones.pdf", mime="application/pdf")

modules/database/semantic_mongo_db.py

@@ -1,160 +1,160 @@
-#/modules/database/semantic_mongo_db.py
-
-# Importaciones estándar
-import io
-import base64
-from datetime import datetime, timezone
-import logging
-
-# Importaciones de terceros
-import matplotlib.pyplot as plt
-
-# Importaciones locales
-from .mongo_db import (
-    get_collection,
-    insert_document, 
-    find_documents, 
-    update_document, 
-    delete_document
-)
-
-# Configuración del logger
-logger = logging.getLogger(__name__)  # Cambiado de name a __name__
-COLLECTION_NAME = 'student_semantic_analysis'
-
-def store_student_semantic_result(username, text, analysis_result):
-    """
-    Guarda el resultado del análisis semántico en MongoDB.
-    """
-    try:
-        # El gráfico ya viene en bytes, solo necesitamos codificarlo a base64
-        concept_graph_data = None
-        if 'concept_graph' in analysis_result and analysis_result['concept_graph'] is not None:
-            try:
-                # Ya está en bytes, solo codificar a base64
-                concept_graph_data = base64.b64encode(analysis_result['concept_graph']).decode('utf-8')
-            except Exception as e:
-                logger.error(f"Error al codificar gráfico conceptual: {str(e)}")
-
-        # Crear documento para MongoDB
-        analysis_document = {
-            'username': username,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'text': text,
-            'analysis_type': 'semantic',
-            'key_concepts': analysis_result.get('key_concepts', []),
-            'concept_graph': concept_graph_data
-        }
-
-        # Insertar en MongoDB
-        result = insert_document(COLLECTION_NAME, analysis_document)
-        if result:
-            logger.info(f"Análisis semántico guardado con ID: {result} para el usuario: {username}")
-            return True
-        
-        logger.error("No se pudo insertar el documento en MongoDB")
-        return False
-
-    except Exception as e:
-        logger.error(f"Error al guardar el análisis semántico: {str(e)}")
-        return False
-
-####################################################################################
-def get_student_semantic_analysis(username, limit=10):
-    """
-    Recupera los análisis semánticos de un estudiante.
-    """
-    try:
-        # Obtener la colección
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:  # Cambiado de if not collection a if collection is None
-            logger.error("No se pudo obtener la colección semantic")
-            return []
-
-        # Consulta
-        query = {
-            "username": username,
-            "analysis_type": "semantic"
-        }
-        
-        # Campos a recuperar
-        projection = {
-            "timestamp": 1,
-            "concept_graph": 1,
-            "_id": 1
-        }
-        
-        # Ejecutar consulta
-        try:
-            cursor = collection.find(query, projection).sort("timestamp", -1)
-            if limit:
-                cursor = cursor.limit(limit)
-            
-            # Convertir cursor a lista
-            results = list(cursor)
-            logger.info(f"Recuperados {len(results)} análisis semánticos para {username}")
-            return results
-            
-        except Exception as db_error:
-            logger.error(f"Error en la consulta a MongoDB: {str(db_error)}")
-            return []
-        
-    except Exception as e:
-        logger.error(f"Error recuperando análisis semántico: {str(e)}")
-        return []
-####################################################################################################
-
-
-def update_student_semantic_analysis(analysis_id, update_data):
-    """
-    Actualiza un análisis semántico existente.
-    Args:
-        analysis_id: ID del análisis a actualizar
-        update_data: Datos a actualizar
-    """
-    query = {"_id": analysis_id}
-    update = {"$set": update_data}
-    return update_document(COLLECTION_NAME, query, update)
-
-def delete_student_semantic_analysis(analysis_id):
-    """
-    Elimina un análisis semántico.
-    Args:
-        analysis_id: ID del análisis a eliminar
-    """
-    query = {"_id": analysis_id}
-    return delete_document(COLLECTION_NAME, query)
-
-def get_student_semantic_data(username):
-    """
-    Obtiene todos los análisis semánticos de un estudiante.
-    Args:
-        username: Nombre del usuario
-    Returns:
-        dict: Diccionario con todos los análisis del estudiante
-    """
-    analyses = get_student_semantic_analysis(username, limit=None)
-    
-    formatted_analyses = []
-    for analysis in analyses:
-        formatted_analysis = {
-            'timestamp': analysis['timestamp'],
-            'text': analysis['text'],
-            'key_concepts': analysis['key_concepts'],
-            'entities': analysis['entities']
-            # No incluimos los gráficos en el resumen general
-        }
-        formatted_analyses.append(formatted_analysis)
-    
-    return {
-        'entries': formatted_analyses
-    }
-
-# Exportar las funciones necesarias
-__all__ = [
-    'store_student_semantic_result',
-    'get_student_semantic_analysis',
-    'update_student_semantic_analysis',
-    'delete_student_semantic_analysis',
-    'get_student_semantic_data'
+#/modules/database/semantic_mongo_db.py
+
+# Importaciones estándar
+import io
+import base64
+from datetime import datetime, timezone
+import logging
+
+# Importaciones de terceros
+import matplotlib.pyplot as plt
+
+# Importaciones locales
+from .mongo_db import (
+    get_collection,
+    insert_document, 
+    find_documents, 
+    update_document, 
+    delete_document
+)
+
+# Configuración del logger
+logger = logging.getLogger(__name__)  # Cambiado de name a __name__
+COLLECTION_NAME = 'student_semantic_analysis'
+
+def store_student_semantic_result(username, text, analysis_result):
+    """
+    Guarda el resultado del análisis semántico en MongoDB.
+    """
+    try:
+        # El gráfico ya viene en bytes, solo necesitamos codificarlo a base64
+        concept_graph_data = None
+        if 'concept_graph' in analysis_result and analysis_result['concept_graph'] is not None:
+            try:
+                # Ya está en bytes, solo codificar a base64
+                concept_graph_data = base64.b64encode(analysis_result['concept_graph']).decode('utf-8')
+            except Exception as e:
+                logger.error(f"Error al codificar gráfico conceptual: {str(e)}")
+
+        # Crear documento para MongoDB
+        analysis_document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text': text,
+            'analysis_type': 'semantic',
+            'key_concepts': analysis_result.get('key_concepts', []),
+            'concept_graph': concept_graph_data
+        }
+
+        # Insertar en MongoDB
+        result = insert_document(COLLECTION_NAME, analysis_document)
+        if result:
+            logger.info(f"Análisis semántico guardado con ID: {result} para el usuario: {username}")
+            return True
+        
+        logger.error("No se pudo insertar el documento en MongoDB")
+        return False
+
+    except Exception as e:
+        logger.error(f"Error al guardar el análisis semántico: {str(e)}")
+        return False
+
+####################################################################################
+def get_student_semantic_analysis(username, limit=10):
+    """
+    Recupera los análisis semánticos de un estudiante.
+    """
+    try:
+        # Obtener la colección
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:  # Cambiado de if not collection a if collection is None
+            logger.error("No se pudo obtener la colección semantic")
+            return []
+
+        # Consulta
+        query = {
+            "username": username,
+            "analysis_type": "semantic"
+        }
+        
+        # Campos a recuperar
+        projection = {
+            "timestamp": 1,
+            "concept_graph": 1,
+            "_id": 1
+        }
+        
+        # Ejecutar consulta
+        try:
+            cursor = collection.find(query, projection).sort("timestamp", -1)
+            if limit:
+                cursor = cursor.limit(limit)
+            
+            # Convertir cursor a lista
+            results = list(cursor)
+            logger.info(f"Recuperados {len(results)} análisis semánticos para {username}")
+            return results
+            
+        except Exception as db_error:
+            logger.error(f"Error en la consulta a MongoDB: {str(db_error)}")
+            return []
+        
+    except Exception as e:
+        logger.error(f"Error recuperando análisis semántico: {str(e)}")
+        return []
+####################################################################################################
+
+
+def update_student_semantic_analysis(analysis_id, update_data):
+    """
+    Actualiza un análisis semántico existente.
+    Args:
+        analysis_id: ID del análisis a actualizar
+        update_data: Datos a actualizar
+    """
+    query = {"_id": analysis_id}
+    update = {"$set": update_data}
+    return update_document(COLLECTION_NAME, query, update)
+
+def delete_student_semantic_analysis(analysis_id):
+    """
+    Elimina un análisis semántico.
+    Args:
+        analysis_id: ID del análisis a eliminar
+    """
+    query = {"_id": analysis_id}
+    return delete_document(COLLECTION_NAME, query)
+
+def get_student_semantic_data(username):
+    """
+    Obtiene todos los análisis semánticos de un estudiante.
+    Args:
+        username: Nombre del usuario
+    Returns:
+        dict: Diccionario con todos los análisis del estudiante
+    """
+    analyses = get_student_semantic_analysis(username, limit=None)
+    
+    formatted_analyses = []
+    for analysis in analyses:
+        formatted_analysis = {
+            'timestamp': analysis['timestamp'],
+            'text': analysis['text'],
+            'key_concepts': analysis['key_concepts'],
+            'entities': analysis['entities']
+            # No incluimos los gráficos en el resumen general
+        }
+        formatted_analyses.append(formatted_analysis)
+    
+    return {
+        'entries': formatted_analyses
+    }
+
+# Exportar las funciones necesarias
+__all__ = [
+    'store_student_semantic_result',
+    'get_student_semantic_analysis',
+    'update_student_semantic_analysis',
+    'delete_student_semantic_analysis',
+    'get_student_semantic_data'
 ]

modules/database/sql_db.py

@@ -1,323 +1,323 @@
-# modules/database/sql_db.py
-
-from .database_init import get_container
-from datetime import datetime, timezone
-import logging
-import bcrypt
-import uuid
-
-logger = logging.getLogger(__name__)
-
-#########################################
-def get_user(username, role=None):
-    container = get_container("users")
-    try:
-        query = f"SELECT * FROM c WHERE c.id = '{username}'"
-        if role:
-            query += f" AND c.role = '{role}'"
-        items = list(container.query_items(query=query))
-        return items[0] if items else None
-    except Exception as e:
-        logger.error(f"Error al obtener usuario {username}: {str(e)}")
-        return None
-
-
-#########################################
-def get_admin_user(username):
-    return get_user(username, role='Administrador')
-
-
-#########################################
-def get_student_user(username):
-    return get_user(username, role='Estudiante')
-
-
-#########################################
-def get_teacher_user(username):
-    return get_user(username, role='Profesor')
-
-
-#########################################
-def create_user(username, password, role, additional_info=None):
-    """Crea un nuevo usuario"""
-    container = get_container("users")
-    if not container:
-        logger.error("No se pudo obtener el contenedor de usuarios")
-        return False
-        
-    try:
-        user_data = {
-            'id': username,
-            'password': password,
-            'role': role,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'additional_info': additional_info or {},
-            'partitionKey': username  # Agregar partition key
-        }
-        
-        # Crear item sin especificar partition_key en el método
-        container.create_item(body=user_data)
-        logger.info(f"Usuario {role} creado: {username}")
-        return True
-        
-    except Exception as e:
-        logger.error(f"Error al crear usuario {role}: {str(e)}")
-        return False
-
-#########################################
-def create_student_user(username, password, additional_info=None):
-    return create_user(username, password, 'Estudiante', additional_info)
-
-#########################################
-def create_teacher_user(username, password, additional_info=None):
-    return create_user(username, password, 'Profesor', additional_info)
-
-#########################################
-def create_admin_user(username, password, additional_info=None):
-    return create_user(username, password, 'Administrador', additional_info)
-
-#########################################
-def record_login(username):
-    """Registra el inicio de sesión de un usuario"""
-    try:
-        container = get_container("users_sessions")
-        if not container:
-            logger.error("No se pudo obtener el contenedor users_sessions")
-            return None
-
-        session_id = str(uuid.uuid4())
-        session_doc = {
-            "id": session_id,
-            "type": "session",
-            "username": username,
-            "loginTime": datetime.now(timezone.utc).isoformat(),
-            "additional_info": {},
-            "partitionKey": username
-        }
-
-        result = container.create_item(body=session_doc)
-        logger.info(f"Sesión {session_id} registrada para {username}")
-        return session_id
-    except Exception as e:
-        logger.error(f"Error registrando login: {str(e)}")
-        return None
-
-#########################################
-def record_logout(username, session_id):
-    """Registra el cierre de sesión y calcula la duración"""
-    try:
-        container = get_container("users_sessions")
-        if not container:
-            logger.error("No se pudo obtener el contenedor users_sessions")
-            return False
-
-        query = "SELECT * FROM c WHERE c.id = @id AND c.username = @username"
-        params = [
-            {"name": "@id", "value": session_id},
-            {"name": "@username", "value": username}
-        ]
-        
-        items = list(container.query_items(
-            query=query,
-            parameters=params
-        ))
-
-        if not items:
-            logger.warning(f"Sesión no encontrada: {session_id}")
-            return False
-
-        session = items[0]
-        login_time = datetime.fromisoformat(session['loginTime'].rstrip('Z'))
-        logout_time = datetime.now(timezone.utc)
-        duration = int((logout_time - login_time).total_seconds())
-
-        session.update({
-            "logoutTime": logout_time.isoformat(),
-            "sessionDuration": duration,
-            "partitionKey": username
-        })
-
-        container.upsert_item(body=session)
-        logger.info(f"Sesión {session_id} cerrada para {username}, duración: {duration}s")
-        return True
-    except Exception as e:
-        logger.error(f"Error registrando logout: {str(e)}")
-        return False
-
-#########################################
-def get_recent_sessions(limit=10):
-    """Obtiene las sesiones más recientes"""
-    try:
-        container = get_container("users_sessions")
-        if not container:
-            logger.error("No se pudo obtener el contenedor users_sessions")
-            return []
-
-        query = """
-        SELECT c.username, c.loginTime, c.logoutTime, c.sessionDuration
-        FROM c
-        WHERE c.type = 'session'
-        ORDER BY c.loginTime DESC
-        OFFSET 0 LIMIT @limit
-        """
-        
-        sessions = list(container.query_items(
-            query=query,
-            parameters=[{"name": "@limit", "value": limit}],
-            enable_cross_partition_query=True  # Agregar este parámetro
-        ))
-
-        clean_sessions = []
-        for session in sessions:
-            try:
-                clean_sessions.append({
-                    "username": session["username"],
-                    "loginTime": session["loginTime"],
-                    "logoutTime": session.get("logoutTime", "Activo"),
-                    "sessionDuration": session.get("sessionDuration", 0)
-                })
-            except KeyError as e:
-                logger.warning(f"Sesión con datos incompletos: {e}")
-                continue
-
-        return clean_sessions
-    except Exception as e:
-        logger.error(f"Error obteniendo sesiones recientes: {str(e)}")
-        return []
-
-#########################################
-def get_user_total_time(username):
-    """Obtiene el tiempo total que un usuario ha pasado en la plataforma"""
-    try:
-        container = get_container("users_sessions")
-        if not container:
-            return None
-
-        query = """
-        SELECT VALUE SUM(c.sessionDuration)
-        FROM c
-        WHERE c.type = 'session'
-        AND c.username = @username
-        AND IS_DEFINED(c.sessionDuration)
-        """
-        
-        result = list(container.query_items(
-            query=query,
-            parameters=[{"name": "@username", "value": username}]
-        ))
-
-        return result[0] if result and result[0] is not None else 0
-    except Exception as e:
-        logger.error(f"Error obteniendo tiempo total: {str(e)}")
-        return 0
-
-#########################################
-def update_student_user(username, new_info):
-    container = get_container("users") 
-    try:
-        user = get_student_user(username)
-        if user:
-            user['additional_info'].update(new_info)
-            user['partitionKey'] = username
-            container.upsert_item(body=user)
-            logger.info(f"Información del estudiante actualizada: {username}")
-            return True
-        else:
-            logger.warning(f"Intento de actualizar estudiante no existente: {username}")
-            return False
-    except Exception as e:
-        logger.error(f"Error al actualizar información del estudiante {username}: {str(e)}")
-        return False
-
-#########################################
-def delete_student_user(username):
-    container = get_container("users")
-    try:
-        user = get_student_user(username)
-        if user:
-            # El ID es suficiente para eliminación ya que partitionKey está en el documento
-            container.delete_item(item=user['id'])
-            logger.info(f"Estudiante eliminado: {username}")
-            return True
-        else:
-            logger.warning(f"Intento de eliminar estudiante no existente: {username}")
-            return False
-    except Exception as e:
-        logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
-        return False
-
-#########################################
-def store_application_request(name, lastname, email, institution, current_role, desired_role, reason):
-    """Almacena una solicitud de aplicación"""
-    try:
-        # Obtener el contenedor usando get_container() que sí funciona
-        container = get_container("application_requests")
-        if not container:
-            logger.error("No se pudo obtener el contenedor de solicitudes")
-            return False
-
-        # Crear documento con la solicitud
-        # Nótese que incluimos email como partition key en el cuerpo del documento
-        application_request = {
-            "id": str(uuid.uuid4()),
-            "name": name,
-            "lastname": lastname,
-            "email": email,
-            "institution": institution,
-            "current_role": current_role,
-            "desired_role": desired_role,
-            "reason": reason,
-            "requestDate": datetime.utcnow().isoformat(),
-            # El campo para partition key debe estar en el documento
-            "partitionKey": email
-        }
-        
-        # Crear el item en el contenedor - sin el parámetro enable_cross_partition_query
-        container.create_item(
-            body=application_request  # Solo pasamos el body
-        )
-        logger.info(f"Solicitud de aplicación almacenada para: {email}")
-        return True
-        
-    except Exception as e:
-        logger.error(f"Error al almacenar la solicitud de aplicación: {str(e)}")
-        logger.error(f"Detalles del error: {str(e)}")
-        return False
-
-
-################################################################
-def store_student_feedback(username, name, email, feedback):
-    """Almacena el feedback de un estudiante"""
-    try:
-        # Obtener el contenedor - verificar disponibilidad
-        logger.info(f"Intentando obtener contenedor user_feedback para usuario: {username}")
-        container = get_container("user_feedback")
-        if not container:
-            logger.error("No se pudo obtener el contenedor user_feedback")
-            return False
-
-        # Crear documento de feedback - asegurar que el username esté como partition key
-        feedback_item = {
-            "id": str(uuid.uuid4()),
-            "username": username,  # Campo regular
-            "name": name,
-            "email": email,
-            "feedback": feedback,
-            "role": "Estudiante",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "partitionKey": username  # Campo de partición
-        }
-
-        # Crear el item - sin el parámetro enable_cross_partition_query
-        logger.info(f"Intentando almacenar feedback para usuario: {username}")
-        result = container.create_item(
-            body=feedback_item  # Solo el body, no parámetros adicionales
-        )
-        
-        logger.info(f"Feedback almacenado exitosamente para el usuario: {username}")
-        return True
-
-    except Exception as e:
-        logger.error(f"Error al almacenar el feedback del estudiante {username}")
-        logger.error(f"Detalles del error: {str(e)}")
+# modules/database/sql_db.py
+
+from .database_init import get_container
+from datetime import datetime, timezone
+import logging
+import bcrypt
+import uuid
+
+logger = logging.getLogger(__name__)
+
+#########################################
+def get_user(username, role=None):
+    container = get_container("users")
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        if role:
+            query += f" AND c.role = '{role}'"
+        items = list(container.query_items(query=query))
+        return items[0] if items else None
+    except Exception as e:
+        logger.error(f"Error al obtener usuario {username}: {str(e)}")
+        return None
+
+
+#########################################
+def get_admin_user(username):
+    return get_user(username, role='Administrador')
+
+
+#########################################
+def get_student_user(username):
+    return get_user(username, role='Estudiante')
+
+
+#########################################
+def get_teacher_user(username):
+    return get_user(username, role='Profesor')
+
+
+#########################################
+def create_user(username, password, role, additional_info=None):
+    """Crea un nuevo usuario"""
+    container = get_container("users")
+    if not container:
+        logger.error("No se pudo obtener el contenedor de usuarios")
+        return False
+        
+    try:
+        user_data = {
+            'id': username,
+            'password': password,
+            'role': role,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'additional_info': additional_info or {},
+            'partitionKey': username  # Agregar partition key
+        }
+        
+        # Crear item sin especificar partition_key en el método
+        container.create_item(body=user_data)
+        logger.info(f"Usuario {role} creado: {username}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error al crear usuario {role}: {str(e)}")
+        return False
+
+#########################################
+def create_student_user(username, password, additional_info=None):
+    return create_user(username, password, 'Estudiante', additional_info)
+
+#########################################
+def create_teacher_user(username, password, additional_info=None):
+    return create_user(username, password, 'Profesor', additional_info)
+
+#########################################
+def create_admin_user(username, password, additional_info=None):
+    return create_user(username, password, 'Administrador', additional_info)
+
+#########################################
+def record_login(username):
+    """Registra el inicio de sesión de un usuario"""
+    try:
+        container = get_container("users_sessions")
+        if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
+            return None
+
+        session_id = str(uuid.uuid4())
+        session_doc = {
+            "id": session_id,
+            "type": "session",
+            "username": username,
+            "loginTime": datetime.now(timezone.utc).isoformat(),
+            "additional_info": {},
+            "partitionKey": username
+        }
+
+        result = container.create_item(body=session_doc)
+        logger.info(f"Sesión {session_id} registrada para {username}")
+        return session_id
+    except Exception as e:
+        logger.error(f"Error registrando login: {str(e)}")
+        return None
+
+#########################################
+def record_logout(username, session_id):
+    """Registra el cierre de sesión y calcula la duración"""
+    try:
+        container = get_container("users_sessions")
+        if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
+            return False
+
+        query = "SELECT * FROM c WHERE c.id = @id AND c.username = @username"
+        params = [
+            {"name": "@id", "value": session_id},
+            {"name": "@username", "value": username}
+        ]
+        
+        items = list(container.query_items(
+            query=query,
+            parameters=params
+        ))
+
+        if not items:
+            logger.warning(f"Sesión no encontrada: {session_id}")
+            return False
+
+        session = items[0]
+        login_time = datetime.fromisoformat(session['loginTime'].rstrip('Z'))
+        logout_time = datetime.now(timezone.utc)
+        duration = int((logout_time - login_time).total_seconds())
+
+        session.update({
+            "logoutTime": logout_time.isoformat(),
+            "sessionDuration": duration,
+            "partitionKey": username
+        })
+
+        container.upsert_item(body=session)
+        logger.info(f"Sesión {session_id} cerrada para {username}, duración: {duration}s")
+        return True
+    except Exception as e:
+        logger.error(f"Error registrando logout: {str(e)}")
+        return False
+
+#########################################
+def get_recent_sessions(limit=10):
+    """Obtiene las sesiones más recientes"""
+    try:
+        container = get_container("users_sessions")
+        if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
+            return []
+
+        query = """
+        SELECT c.username, c.loginTime, c.logoutTime, c.sessionDuration
+        FROM c
+        WHERE c.type = 'session'
+        ORDER BY c.loginTime DESC
+        OFFSET 0 LIMIT @limit
+        """
+        
+        sessions = list(container.query_items(
+            query=query,
+            parameters=[{"name": "@limit", "value": limit}],
+            enable_cross_partition_query=True  # Agregar este parámetro
+        ))
+
+        clean_sessions = []
+        for session in sessions:
+            try:
+                clean_sessions.append({
+                    "username": session["username"],
+                    "loginTime": session["loginTime"],
+                    "logoutTime": session.get("logoutTime", "Activo"),
+                    "sessionDuration": session.get("sessionDuration", 0)
+                })
+            except KeyError as e:
+                logger.warning(f"Sesión con datos incompletos: {e}")
+                continue
+
+        return clean_sessions
+    except Exception as e:
+        logger.error(f"Error obteniendo sesiones recientes: {str(e)}")
+        return []
+
+#########################################
+def get_user_total_time(username):
+    """Obtiene el tiempo total que un usuario ha pasado en la plataforma"""
+    try:
+        container = get_container("users_sessions")
+        if not container:
+            return None
+
+        query = """
+        SELECT VALUE SUM(c.sessionDuration)
+        FROM c
+        WHERE c.type = 'session'
+        AND c.username = @username
+        AND IS_DEFINED(c.sessionDuration)
+        """
+        
+        result = list(container.query_items(
+            query=query,
+            parameters=[{"name": "@username", "value": username}]
+        ))
+
+        return result[0] if result and result[0] is not None else 0
+    except Exception as e:
+        logger.error(f"Error obteniendo tiempo total: {str(e)}")
+        return 0
+
+#########################################
+def update_student_user(username, new_info):
+    container = get_container("users") 
+    try:
+        user = get_student_user(username)
+        if user:
+            user['additional_info'].update(new_info)
+            user['partitionKey'] = username
+            container.upsert_item(body=user)
+            logger.info(f"Información del estudiante actualizada: {username}")
+            return True
+        else:
+            logger.warning(f"Intento de actualizar estudiante no existente: {username}")
+            return False
+    except Exception as e:
+        logger.error(f"Error al actualizar información del estudiante {username}: {str(e)}")
+        return False
+
+#########################################
+def delete_student_user(username):
+    container = get_container("users")
+    try:
+        user = get_student_user(username)
+        if user:
+            # El ID es suficiente para eliminación ya que partitionKey está en el documento
+            container.delete_item(item=user['id'])
+            logger.info(f"Estudiante eliminado: {username}")
+            return True
+        else:
+            logger.warning(f"Intento de eliminar estudiante no existente: {username}")
+            return False
+    except Exception as e:
+        logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
+        return False
+
+#########################################
+def store_application_request(name, lastname, email, institution, current_role, desired_role, reason):
+    """Almacena una solicitud de aplicación"""
+    try:
+        # Obtener el contenedor usando get_container() que sí funciona
+        container = get_container("application_requests")
+        if not container:
+            logger.error("No se pudo obtener el contenedor de solicitudes")
+            return False
+
+        # Crear documento con la solicitud
+        # Nótese que incluimos email como partition key en el cuerpo del documento
+        application_request = {
+            "id": str(uuid.uuid4()),
+            "name": name,
+            "lastname": lastname,
+            "email": email,
+            "institution": institution,
+            "current_role": current_role,
+            "desired_role": desired_role,
+            "reason": reason,
+            "requestDate": datetime.utcnow().isoformat(),
+            # El campo para partition key debe estar en el documento
+            "partitionKey": email
+        }
+        
+        # Crear el item en el contenedor - sin el parámetro enable_cross_partition_query
+        container.create_item(
+            body=application_request  # Solo pasamos el body
+        )
+        logger.info(f"Solicitud de aplicación almacenada para: {email}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error al almacenar la solicitud de aplicación: {str(e)}")
+        logger.error(f"Detalles del error: {str(e)}")
+        return False
+
+
+################################################################
+def store_student_feedback(username, name, email, feedback):
+    """Almacena el feedback de un estudiante"""
+    try:
+        # Obtener el contenedor - verificar disponibilidad
+        logger.info(f"Intentando obtener contenedor user_feedback para usuario: {username}")
+        container = get_container("user_feedback")
+        if not container:
+            logger.error("No se pudo obtener el contenedor user_feedback")
+            return False
+
+        # Crear documento de feedback - asegurar que el username esté como partition key
+        feedback_item = {
+            "id": str(uuid.uuid4()),
+            "username": username,  # Campo regular
+            "name": name,
+            "email": email,
+            "feedback": feedback,
+            "role": "Estudiante",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "partitionKey": username  # Campo de partición
+        }
+
+        # Crear el item - sin el parámetro enable_cross_partition_query
+        logger.info(f"Intentando almacenar feedback para usuario: {username}")
+        result = container.create_item(
+            body=feedback_item  # Solo el body, no parámetros adicionales
+        )
+        
+        logger.info(f"Feedback almacenado exitosamente para el usuario: {username}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Error al almacenar el feedback del estudiante {username}")
+        logger.error(f"Detalles del error: {str(e)}")
         return False

modules/database/writing_progress_mongo_db.py

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

modules/discourse/__init__.py

@@ -1,17 +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'
+# 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

@@ -1,281 +1,318 @@
-# 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', 'Comparar textos'),
-                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/discourse_interface.py
+
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+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', 'Comparar textos'),
+                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)
+
+            # Verificar el tipo de graph1 de manera más robusta
+            if 'graph1' in result:
+                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                
+                # Más información para depuración
+                graph_type = type(result['graph1']).__name__
+                graph_size = len(result['graph1']) if isinstance(result['graph1'], bytes) else "N/A"
+                logger.info(f"Tipo de graph1: {graph_type}, Tamaño: {graph_size}")
+                
+                if isinstance(result['graph1'], bytes) and len(result['graph1']) > 0:
+                    # Es bytes válidos
+                    st.image(result['graph1'])
+                elif isinstance(result['graph1'], plt.Figure):
+                    # Es una figura de matplotlib
+                    st.pyplot(result['graph1'])
+                elif result['graph1'] is None:
+                    # Es None
+                    st.warning("Gráfico no disponible")
+                else:
+                    # Otro tipo o bytes vacíos
+                    st.warning(f"Formato de gráfico no reconocido: {graph_type}")
+                
+                # 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)
+
+            # Verificar el tipo de graph1 de manera más robusta
+            if 'graph1' in result:
+                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                
+                # Más información para depuración
+                graph_type = type(result['graph2']).__name__
+                graph_size = len(result['graph2']) if isinstance(result['graph2'], bytes) else "N/A"
+                logger.info(f"Tipo de graph2: {graph_type}, Tamaño: {graph_size}")
+                
+                if isinstance(result['graph2'], bytes) and len(result['graph2']) > 0:
+                    # Es bytes válidos
+                    st.image(result['graph2'])
+                elif isinstance(result['graph2'], plt.Figure):
+                    # Es una figura de matplotlib
+                    st.pyplot(result['graph2'])
+                elif result['graph2'] is None:
+                    # Es None
+                    st.warning("Gráfico no disponible")
+                else:
+                    # Otro tipo o bytes vacíos
+                    st.warning(f"Formato de gráfico no reconocido: {graph_type}")
+                
+                # 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

@@ -1,151 +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/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

@@ -1,68 +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)
+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/morphosyntax/__init__.py

@@ -1,29 +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'
-]
-
+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-BackUp_Dec24_OK.py

@@ -1,322 +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
+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_BackUp_Dec-28-Ok.py

@@ -1,164 +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.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

@@ -1,247 +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**")
+# 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.py

@@ -1,132 +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.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

@@ -1,132 +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.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

@@ -1,17 +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'
+# 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'
 ]

modules/semantic/semantic_interface.py

@@ -1,293 +1,296 @@
-#modules/semantic/semantic_interface.py
-import streamlit as st
-from streamlit_float import *
-from streamlit_antd_components import *
-from streamlit.components.v1 import html
-import spacy_streamlit
-import io
-from io import BytesIO
-import base64
-import matplotlib.pyplot as plt
-import pandas as pd
-import re
-import logging
-
-# Configuración del logger
-logger = logging.getLogger(__name__)
-
-# Importaciones locales
-from .semantic_process import (
-    process_semantic_input,
-    format_semantic_results
-)
-
-from ..utils.widget_utils import generate_unique_key
-from ..database.semantic_mongo_db import store_student_semantic_result
-from ..database.chat_mongo_db import store_chat_history, get_chat_history
-
-# from ..database.semantic_export import export_user_interactions
-
-
-###############################
-def display_semantic_interface(lang_code, nlp_models, semantic_t):
-    """
-    Interfaz para el análisis semántico
-    Args:
-        lang_code: Código del idioma actual
-        nlp_models: Modelos de spaCy cargados
-        semantic_t: Diccionario de traducciones semánticas
-    """
-    try:
-        # 1. Inicializar el estado de la sesión
-        if 'semantic_state' not in st.session_state:
-            st.session_state.semantic_state = {
-                'analysis_count': 0,
-                'last_analysis': None,
-                'current_file': None
-            }
-
-        # 2. Área de carga de archivo con mensaje informativo
-        st.info(semantic_t.get('initial_instruction', 
-            'Para comenzar un nuevo análisis semántico, cargue un archivo de texto (.txt)'))
-            
-        uploaded_file = st.file_uploader(
-            semantic_t.get('semantic_file_uploader', 'Upload a text file for semantic analysis'),
-            type=['txt'],
-            key=f"semantic_file_uploader_{st.session_state.semantic_state['analysis_count']}"
-        )
-
-        # 3. Columnas para los botones y mensajes
-        col1, col2 = st.columns([1,4])
-        
-        # 4. Botón de análisis
-        with col1:
-            analyze_button = st.button(
-                semantic_t.get('semantic_analyze_button', 'Analyze'),
-                key=f"semantic_analyze_button_{st.session_state.semantic_state['analysis_count']}",
-                type="primary",  # Nuevo en Streamlit 1.39.0
-                icon="🔍",      # Nuevo en Streamlit 1.39.0
-                disabled=uploaded_file is None,
-                use_container_width=True
-            )
-
-        # 5. Procesar análisis
-        if analyze_button and uploaded_file is not None:
-            try:
-                with st.spinner(semantic_t.get('processing', 'Processing...')):
-                    # Leer contenido del archivo
-                    text_content = uploaded_file.getvalue().decode('utf-8')
-                    
-                    # Realizar análisis
-                    analysis_result = process_semantic_input(
-                        text_content, 
-                        lang_code,
-                        nlp_models,
-                        semantic_t
-                    )
-                    
-                    if analysis_result['success']:
-                        # Guardar resultado
-                        st.session_state.semantic_result = analysis_result
-                        st.session_state.semantic_state['analysis_count'] += 1
-                        st.session_state.semantic_state['current_file'] = uploaded_file.name
-                        
-                        # Guardar en base de datos
-                        if store_student_semantic_result(
-                            st.session_state.username,
-                            text_content,
-                            analysis_result['analysis']
-                        ):
-                            st.success(
-                                semantic_t.get('analysis_complete', 
-                                'Análisis completado y guardado. Para realizar un nuevo análisis, cargue otro archivo.')
-                            )
-                            
-                            # Mostrar resultados
-                            display_semantic_results(
-                                st.session_state.semantic_result,
-                                lang_code,
-                                semantic_t
-                            )
-                        else:
-                            st.error(semantic_t.get('error_message', 'Error saving analysis'))
-                    else:
-                        st.error(analysis_result['message'])
-                        
-            except Exception as e:
-                logger.error(f"Error en análisis semántico: {str(e)}")
-                st.error(semantic_t.get('error_processing', f'Error processing text: {str(e)}'))
-        
-        # 6. Mostrar resultados previos o mensaje inicial
-        elif 'semantic_result' in st.session_state and st.session_state.semantic_result is not None:
-            # Mostrar mensaje sobre el análisis actual
-            st.info(
-                semantic_t.get('current_analysis_message', 
-                f'Mostrando análisis del archivo: {st.session_state.semantic_state["current_file"]}. '
-                'Para realizar un nuevo análisis, cargue otro archivo.')
-            )
-            
-            display_semantic_results(
-                st.session_state.semantic_result,
-                lang_code,
-                semantic_t
-            )
-        else:
-            st.info(semantic_t.get('upload_prompt', 'Cargue un archivo para comenzar el análisis'))
-
-    except Exception as e:
-        logger.error(f"Error general en interfaz semántica: {str(e)}")
-        st.error(semantic_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
-
-#######################################
-def display_semantic_results(semantic_result, lang_code, semantic_t):
-    """
-    Muestra los resultados del análisis semántico de conceptos clave.
-    """
-    if semantic_result is None or not semantic_result['success']:
-        st.warning(semantic_t.get('no_results', 'No results available'))
-        return
-
-    analysis = semantic_result['analysis']
-
-    # Mostrar conceptos clave en formato horizontal
-    st.subheader(semantic_t.get('key_concepts', 'Key Concepts'))
-    if 'key_concepts' in analysis and analysis['key_concepts']:
-        # Crear tabla de conceptos
-        df = pd.DataFrame(
-            analysis['key_concepts'],
-            columns=[
-                semantic_t.get('concept', 'Concept'),
-                semantic_t.get('frequency', 'Frequency')
-            ]
-        )
-        
-        # Convertir DataFrame a formato horizontal
-        st.write(
-            """
-            <style>
-            .concept-table {
-                display: flex;
-                flex-wrap: wrap;
-                gap: 10px;
-                margin-bottom: 20px;
-            }
-            .concept-item {
-                background-color: #f0f2f6;
-                border-radius: 5px;
-                padding: 8px 12px;
-                display: flex;
-                align-items: center;
-                gap: 8px;
-            }
-            .concept-name {
-                font-weight: bold;
-            }
-            .concept-freq {
-                color: #666;
-                font-size: 0.9em;
-            }
-            </style>
-            <div class="concept-table">
-            """ + 
-            ''.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 df.values
-            ]) +
-            "</div>",
-            unsafe_allow_html=True
-        )
-    else:
-        st.info(semantic_t.get('no_concepts', 'No key concepts found'))
-
-    # Gráfico de conceptos
-    st.subheader(semantic_t.get('concept_graph', 'Concepts Graph'))
-    if 'concept_graph' in analysis and analysis['concept_graph'] is not None:
-        try:
-            # Container para el grafo con estilos mejorados
-            st.markdown(
-                """
-                <style>
-                .graph-container {
-                    background-color: white;
-                    border-radius: 10px;
-                    padding: 20px;
-                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-                    margin: 10px 0;
-                }
-                .button-container {
-                    display: flex;
-                    gap: 10px;
-                    margin: 10px 0;
-                }
-                </style>
-                """,
-                unsafe_allow_html=True
-            )
-
-            with st.container():
-                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
-                
-                # Mostrar grafo
-                graph_bytes = analysis['concept_graph']
-                graph_base64 = base64.b64encode(graph_bytes).decode()
-                st.markdown(
-                    f'<img src="data:image/png;base64,{graph_base64}" alt="Concept Graph" style="width:100%;"/>',
-                    unsafe_allow_html=True
-                )
-                
-                # Leyenda del grafo
-                st.caption(semantic_t.get(
-                    'graph_description',
-                    'Visualización de relaciones entre conceptos clave identificados en el texto.'
-                ))
-                
-                st.markdown('</div>', unsafe_allow_html=True)
-
-            # Contenedor para botones
-            col1, col2 = st.columns([1,4])
-            with col1:
-                st.download_button(
-                    label="📥 " + semantic_t.get('download_graph', "Download"),
-                    data=graph_bytes,
-                    file_name="semantic_graph.png",
-                    mime="image/png",
-                    use_container_width=True
-                )
-            
-            # Expandible con la interpretación
-            with st.expander("📊 " + semantic_t.get('graph_help', "Graph Interpretation")):
-                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
-                """)
-        
-        except Exception as e:
-            logger.error(f"Error displaying graph: {str(e)}")
-            st.error(semantic_t.get('graph_error', 'Error displaying the graph'))
-    else:
-        st.info(semantic_t.get('no_graph', 'No concept graph available'))
-
-
-####################################################################################
-'''
-    # Botón de exportación al final
-    if 'semantic_analysis_counter' in st.session_state:
-        col1, col2, col3 = st.columns([2,1,2])
-        with col2:
-            if st.button(
-                semantic_t.get('export_button', 'Export Analysis'), 
-                key=f"semantic_export_{st.session_state.semantic_analysis_counter}",
-                use_container_width=True
-            ):
-                pdf_buffer = export_user_interactions(st.session_state.username, 'semantic')
-                st.download_button(
-                    label=semantic_t.get('download_pdf', 'Download PDF'),
-                    data=pdf_buffer,
-                    file_name="semantic_analysis.pdf",
-                    mime="application/pdf",
-                    key=f"semantic_download_{st.session_state.semantic_analysis_counter}"
-                )
+#modules/semantic/semantic_interface.py
+import streamlit as st
+from streamlit_float import *
+from streamlit_antd_components import *
+from streamlit.components.v1 import html
+import spacy_streamlit
+import io
+from io import BytesIO
+import base64
+import matplotlib.pyplot as plt
+import pandas as pd
+import re
+import logging
+
+# Configuración del logger
+logger = logging.getLogger(__name__)
+
+# Importaciones locales
+from .semantic_process import (
+    process_semantic_input,
+    format_semantic_results
+)
+
+from ..utils.widget_utils import generate_unique_key
+from ..database.semantic_mongo_db import store_student_semantic_result
+from ..database.chat_mongo_db import store_chat_history, get_chat_history
+
+# from ..database.semantic_export import export_user_interactions
+
+
+###############################
+
+# En semantic_interface.py
+def display_semantic_interface(lang_code, nlp_models, semantic_t):
+    try:
+        # 1. Inicializar el estado de la sesión
+        if 'semantic_state' not in st.session_state:
+            st.session_state.semantic_state = {
+                'analysis_count': 0,
+                'last_analysis': None,
+                'current_file': None,
+                'pending_analysis': False  # Nuevo flag para controlar el análisis pendiente
+            }
+
+        # 2. Área de carga de archivo con mensaje informativo
+        st.info(semantic_t.get('initial_instruction', 
+            'Para comenzar un nuevo análisis semántico, cargue un archivo de texto (.txt)'))
+            
+        uploaded_file = st.file_uploader(
+            semantic_t.get('semantic_file_uploader', 'Upload a text file for semantic analysis'),
+            type=['txt'],
+            key=f"semantic_file_uploader_{st.session_state.semantic_state['analysis_count']}"
+        )
+
+        # Verificar si hay un archivo cargado y un análisis pendiente
+        if uploaded_file is not None and st.session_state.semantic_state.get('pending_analysis', False):
+            try:
+                with st.spinner(semantic_t.get('processing', 'Processing...')):
+                    # Realizar análisis
+                    text_content = uploaded_file.getvalue().decode('utf-8')
+                    
+                    analysis_result = process_semantic_input(
+                        text_content, 
+                        lang_code,
+                        nlp_models,
+                        semantic_t
+                    )
+                    
+                    if analysis_result['success']:
+                        # Guardar resultado
+                        st.session_state.semantic_result = analysis_result
+                        st.session_state.semantic_state['analysis_count'] += 1
+                        st.session_state.semantic_state['current_file'] = uploaded_file.name
+                        
+                        # Guardar en base de datos
+                        storage_success = store_student_semantic_result(
+                            st.session_state.username,
+                            text_content,
+                            analysis_result['analysis']
+                        )
+                        
+                        if storage_success:
+                            st.success(
+                                semantic_t.get('analysis_complete', 
+                                'Análisis completado y guardado. Para realizar un nuevo análisis, cargue otro archivo.')
+                            )
+                        else:
+                            st.error(semantic_t.get('error_message', 'Error saving analysis'))
+                    else:
+                        st.error(analysis_result['message'])
+                    
+                # Restablecer el flag de análisis pendiente
+                st.session_state.semantic_state['pending_analysis'] = False
+                    
+            except Exception as e:
+                logger.error(f"Error en análisis semántico: {str(e)}")
+                st.error(semantic_t.get('error_processing', f'Error processing text: {str(e)}'))
+                # Restablecer el flag de análisis pendiente en caso de error
+                st.session_state.semantic_state['pending_analysis'] = False
+
+        # 3. Columnas para los botones y mensajes
+        col1, col2 = st.columns([1,4])
+        
+        # 4. Botón de análisis
+        with col1:
+            analyze_button = st.button(
+                semantic_t.get('semantic_analyze_button', 'Analyze'),
+                key=f"semantic_analyze_button_{st.session_state.semantic_state['analysis_count']}",
+                type="primary",
+                icon="🔍",
+                disabled=uploaded_file is None,
+                use_container_width=True
+            )
+
+        # 5. Procesar análisis
+        if analyze_button and uploaded_file is not None:
+            # En lugar de realizar el análisis inmediatamente, establecer el flag
+            st.session_state.semantic_state['pending_analysis'] = True
+            # Forzar la recarga de la aplicación
+            st.rerun()
+        
+        # 6. Mostrar resultados previos o mensaje inicial
+        elif 'semantic_result' in st.session_state and st.session_state.semantic_result is not None:
+            # Mostrar mensaje sobre el análisis actual
+            st.info(
+                semantic_t.get('current_analysis_message', 
+                f'Mostrando análisis del archivo: {st.session_state.semantic_state["current_file"]}. '
+                'Para realizar un nuevo análisis, cargue otro archivo.')
+            )
+            
+            display_semantic_results(
+                st.session_state.semantic_result,
+                lang_code,
+                semantic_t
+            )
+        else:
+            st.info(semantic_t.get('upload_prompt', 'Cargue un archivo para comenzar el análisis'))
+
+    except Exception as e:
+        logger.error(f"Error general en interfaz semántica: {str(e)}")
+        st.error(semantic_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
+
+
+#######################################
+def display_semantic_results(semantic_result, lang_code, semantic_t):
+    """
+    Muestra los resultados del análisis semántico de conceptos clave.
+    """
+    if semantic_result is None or not semantic_result['success']:
+        st.warning(semantic_t.get('no_results', 'No results available'))
+        return
+
+    analysis = semantic_result['analysis']
+
+    # Mostrar conceptos clave en formato horizontal
+    st.subheader(semantic_t.get('key_concepts', 'Key Concepts'))
+    if 'key_concepts' in analysis and analysis['key_concepts']:
+        # Crear tabla de conceptos
+        df = pd.DataFrame(
+            analysis['key_concepts'],
+            columns=[
+                semantic_t.get('concept', 'Concept'),
+                semantic_t.get('frequency', 'Frequency')
+            ]
+        )
+        
+        # Convertir DataFrame a formato horizontal
+        st.write(
+            """
+            <style>
+            .concept-table {
+                display: flex;
+                flex-wrap: wrap;
+                gap: 10px;
+                margin-bottom: 20px;
+            }
+            .concept-item {
+                background-color: #f0f2f6;
+                border-radius: 5px;
+                padding: 8px 12px;
+                display: flex;
+                align-items: center;
+                gap: 8px;
+            }
+            .concept-name {
+                font-weight: bold;
+            }
+            .concept-freq {
+                color: #666;
+                font-size: 0.9em;
+            }
+            </style>
+            <div class="concept-table">
+            """ + 
+            ''.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 df.values
+            ]) +
+            "</div>",
+            unsafe_allow_html=True
+        )
+    else:
+        st.info(semantic_t.get('no_concepts', 'No key concepts found'))
+
+    # Gráfico de conceptos
+    st.subheader(semantic_t.get('concept_graph', 'Concepts Graph'))
+    if 'concept_graph' in analysis and analysis['concept_graph'] is not None:
+        try:
+            # Container para el grafo con estilos mejorados
+            st.markdown(
+                """
+                <style>
+                .graph-container {
+                    background-color: white;
+                    border-radius: 10px;
+                    padding: 20px;
+                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                    margin: 10px 0;
+                }
+                .button-container {
+                    display: flex;
+                    gap: 10px;
+                    margin: 10px 0;
+                }
+                </style>
+                """,
+                unsafe_allow_html=True
+            )
+
+            with st.container():
+                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                
+                # Mostrar grafo
+                graph_bytes = analysis['concept_graph']
+                graph_base64 = base64.b64encode(graph_bytes).decode()
+                st.markdown(
+                    f'<img src="data:image/png;base64,{graph_base64}" alt="Concept Graph" style="width:100%;"/>',
+                    unsafe_allow_html=True
+                )
+                
+                # Leyenda del grafo
+                st.caption(semantic_t.get(
+                    'graph_description',
+                    'Visualización de relaciones entre conceptos clave identificados en el texto.'
+                ))
+                
+                st.markdown('</div>', unsafe_allow_html=True)
+
+            # Contenedor para botones
+            col1, col2 = st.columns([1,4])
+            with col1:
+                st.download_button(
+                    label="📥 " + semantic_t.get('download_graph', "Download"),
+                    data=graph_bytes,
+                    file_name="semantic_graph.png",
+                    mime="image/png",
+                    use_container_width=True
+                )
+            
+            # Expandible con la interpretación
+            with st.expander("📊 " + semantic_t.get('graph_help', "Graph Interpretation")):
+                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
+                """)
+        
+        except Exception as e:
+            logger.error(f"Error displaying graph: {str(e)}")
+            st.error(semantic_t.get('graph_error', 'Error displaying the graph'))
+    else:
+        st.info(semantic_t.get('no_graph', 'No concept graph available'))
+
+
+########################################################################################
+'''
+    # Botón de exportación al final
+    if 'semantic_analysis_counter' in st.session_state:
+        col1, col2, col3 = st.columns([2,1,2])
+        with col2:
+            if st.button(
+                semantic_t.get('export_button', 'Export Analysis'), 
+                key=f"semantic_export_{st.session_state.semantic_analysis_counter}",
+                use_container_width=True
+            ):
+                pdf_buffer = export_user_interactions(st.session_state.username, 'semantic')
+                st.download_button(
+                    label=semantic_t.get('download_pdf', 'Download PDF'),
+                    data=pdf_buffer,
+                    file_name="semantic_analysis.pdf",
+                    mime="application/pdf",
+                    key=f"semantic_download_{st.session_state.semantic_analysis_counter}"
+                )
 '''

modules/semantic/semantic_interface_1.py

@@ -1,55 +1,55 @@
-import streamlit as st
-from .semantic_process import process_semantic_analysis
-from ..chatbot.chatbot import initialize_chatbot
-from ..database.database_oldFromV2 import store_semantic_result
-from ..text_analysis.semantic_analysis import perform_semantic_analysis
-from ..utils.widget_utils import generate_unique_key
-
-def display_semantic_interface(lang_code, nlp_models, t):
-    st.subheader(t['title'])
-
-    # Inicializar el chatbot si no existe
-    if 'semantic_chatbot' not in st.session_state:
-        st.session_state.semantic_chatbot = initialize_chatbot('semantic')
-
-    # Sección para cargar archivo
-    uploaded_file = st.file_uploader(t['file_uploader'], type=['txt', 'pdf', 'docx', 'doc', 'odt'])
-    if uploaded_file:
-        file_contents = uploaded_file.getvalue().decode('utf-8')
-        st.session_state.file_contents = file_contents
-
-    # Mostrar el historial del chat
-    chat_history = st.session_state.get('semantic_chat_history', [])
-    for message in chat_history:
-        with st.chat_message(message["role"]):
-            st.write(message["content"])
-            if "visualization" in message:
-                st.pyplot(message["visualization"])
-
-    # Input del usuario
-    user_input = st.chat_input(t['semantic_initial_message'], key=generate_unique_key('semantic', st.session_state.username))
-
-    if user_input:
-        # Procesar el input del usuario
-        response, visualization = process_semantic_analysis(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents'), t)
-
-        # Actualizar el historial del chat
-        chat_history.append({"role": "user", "content": user_input})
-        chat_history.append({"role": "assistant", "content": response, "visualization": visualization})
-        st.session_state.semantic_chat_history = chat_history
-
-        # Mostrar el resultado más reciente
-        with st.chat_message("assistant"):
-            st.write(response)
-            if visualization:
-                st.pyplot(visualization)
-
-        # Guardar el resultado en la base de datos si es un análisis
-        if user_input.startswith('/analisis_semantico'):
-            result = perform_semantic_analysis(st.session_state.file_contents, nlp_models[lang_code], lang_code)
-            store_semantic_result(st.session_state.username, st.session_state.file_contents, result)
-
-    # Botón para limpiar el historial del chat
-    if st.button(t['clear_chat'], key=generate_unique_key('semantic', 'clear_chat')):
-        st.session_state.semantic_chat_history = []
+import streamlit as st
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot
+from ..database.database_oldFromV2 import store_semantic_result
+from ..text_analysis.semantic_analysis import perform_semantic_analysis
+from ..utils.widget_utils import generate_unique_key
+
+def display_semantic_interface(lang_code, nlp_models, t):
+    st.subheader(t['title'])
+
+    # Inicializar el chatbot si no existe
+    if 'semantic_chatbot' not in st.session_state:
+        st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+    # Sección para cargar archivo
+    uploaded_file = st.file_uploader(t['file_uploader'], type=['txt', 'pdf', 'docx', 'doc', 'odt'])
+    if uploaded_file:
+        file_contents = uploaded_file.getvalue().decode('utf-8')
+        st.session_state.file_contents = file_contents
+
+    # Mostrar el historial del chat
+    chat_history = st.session_state.get('semantic_chat_history', [])
+    for message in chat_history:
+        with st.chat_message(message["role"]):
+            st.write(message["content"])
+            if "visualization" in message:
+                st.pyplot(message["visualization"])
+
+    # Input del usuario
+    user_input = st.chat_input(t['semantic_initial_message'], key=generate_unique_key('semantic', st.session_state.username))
+
+    if user_input:
+        # Procesar el input del usuario
+        response, visualization = process_semantic_analysis(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents'), t)
+
+        # Actualizar el historial del chat
+        chat_history.append({"role": "user", "content": user_input})
+        chat_history.append({"role": "assistant", "content": response, "visualization": visualization})
+        st.session_state.semantic_chat_history = chat_history
+
+        # Mostrar el resultado más reciente
+        with st.chat_message("assistant"):
+            st.write(response)
+            if visualization:
+                st.pyplot(visualization)
+
+        # Guardar el resultado en la base de datos si es un análisis
+        if user_input.startswith('/analisis_semantico'):
+            result = perform_semantic_analysis(st.session_state.file_contents, nlp_models[lang_code], lang_code)
+            store_semantic_result(st.session_state.username, st.session_state.file_contents, result)
+
+    # Botón para limpiar el historial del chat
+    if st.button(t['clear_chat'], key=generate_unique_key('semantic', 'clear_chat')):
+        st.session_state.semantic_chat_history = []
         st.rerun()

modules/semantic/semantic_interface_2.py

@@ -1,167 +1,167 @@
-import streamlit as st
-from .semantic_process import process_semantic_analysis
-from ..chatbot.chatbot import initialize_chatbot
-from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
-from ..utils.widget_utils import generate_unique_key
-
-def get_translation(t, key, default):
-    return t.get(key, default)
-
-def display_semantic_interface(lang_code, nlp_models, t):
-    #st.set_page_config(layout="wide")
-
-    # Estilo CSS personalizado
-    st.markdown("""
-        <style>
-        .semantic-initial-message {
-            background-color: #f0f2f6;
-            border-left: 5px solid #4CAF50;
-            padding: 10px;
-            border-radius: 5px;
-            font-size: 16px;
-            margin-bottom: 20px;
-        }
-        .stButton > button {
-            width: 100%;
-        }
-        .chat-container {
-            height: 400px;
-            overflow-y: auto;
-            border: 1px solid #ddd;
-            padding: 10px;
-            border-radius: 5px;
-        }
-        .file-management-container {
-            border: 1px solid #ddd;
-            padding: 10px;
-            border-radius: 5px;
-            margin-bottom: 20px;
-        }
-        .horizontal-list {
-            display: flex;
-            flex-wrap: wrap;
-            gap: 10px;
-        }
-        </style>
-    """, unsafe_allow_html=True)
-
-    # Mostrar el mensaje inicial como un párrafo estilizado
-    st.markdown(f"""
-        <div class="semantic-initial-message">
-        {get_translation(t, 'semantic_initial_message', 'Welcome to the semantic analysis interface.')}
-        </div>
-    """, unsafe_allow_html=True)
-
-    # Inicializar el chatbot si no existe
-    if 'semantic_chatbot' not in st.session_state:
-        st.session_state.semantic_chatbot = initialize_chatbot('semantic')
-
-    # Contenedor para la gestión de archivos
-    with st.container():
-        st.markdown('<div class="file-management-container">', unsafe_allow_html=True)
-        col1, col2, col3, col4 = st.columns(4)
-
-        with col1:
-            if st.button(get_translation(t, 'upload_file', 'Upload File'), key=generate_unique_key('semantic', 'upload_button')):
-                uploaded_file = st.file_uploader(get_translation(t, 'file_uploader', 'Choose a file'), type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
-                if uploaded_file is not None:
-                    file_contents = uploaded_file.getvalue().decode('utf-8')
-                    if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
-                        st.success(get_translation(t, 'file_uploaded_success', 'File uploaded and saved to database successfully'))
-                        st.session_state.file_contents = file_contents
-                        st.rerun()
-                    else:
-                        st.error(get_translation(t, 'file_upload_error', 'Error uploading file'))
-
-        with col2:
-            user_files = get_user_files(st.session_state.username, 'semantic')
-            file_options = [get_translation(t, 'select_file', 'Select a file')] + [file['file_name'] for file in user_files]
-            selected_file = st.selectbox(get_translation(t, 'file_list', 'File List'), options=file_options, key=generate_unique_key('semantic', 'file_selector'))
-            if selected_file != get_translation(t, 'select_file', 'Select a file'):
-                if st.button(get_translation(t, 'load_file', 'Load File'), key=generate_unique_key('semantic', 'load_file')):
-                    file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
-                    if file_contents:
-                        st.session_state.file_contents = file_contents
-                        st.success(get_translation(t, 'file_loaded_success', 'File loaded successfully'))
-                    else:
-                        st.error(get_translation(t, 'file_load_error', 'Error loading file'))
-
-        with col3:
-            if st.button(get_translation(t, 'analyze_document', 'Analyze Document'), key=generate_unique_key('semantic', 'analyze_document')):
-                if 'file_contents' in st.session_state:
-                    with st.spinner(get_translation(t, 'analyzing', 'Analyzing...')):
-                        graph, key_concepts = process_semantic_analysis(st.session_state.file_contents, nlp_models[lang_code], lang_code)
-                    st.session_state.graph = graph
-                    st.session_state.key_concepts = key_concepts
-                    st.success(get_translation(t, 'analysis_completed', 'Analysis completed'))
-                else:
-                    st.error(get_translation(t, 'no_file_uploaded', 'No file uploaded'))
-
-        with col4:
-            if st.button(get_translation(t, 'delete_file', 'Delete File'), key=generate_unique_key('semantic', 'delete_file')):
-                if selected_file and selected_file != get_translation(t, 'select_file', 'Select a file'):
-                    if delete_file(st.session_state.username, selected_file, 'semantic'):
-                        st.success(get_translation(t, 'file_deleted_success', 'File deleted successfully'))
-                        if 'file_contents' in st.session_state:
-                            del st.session_state.file_contents
-                        st.rerun()
-                    else:
-                        st.error(get_translation(t, 'file_delete_error', 'Error deleting file'))
-                else:
-                    st.error(get_translation(t, 'no_file_selected', 'No file selected'))
-
-        st.markdown('</div>', unsafe_allow_html=True)
-
-    # Crear dos columnas: una para el chat y otra para la visualización
-    col_chat, col_graph = st.columns([1, 1])
-
-    with col_chat:
-        st.subheader(get_translation(t, 'chat_title', 'Semantic Analysis Chat'))
-        # Chat interface
-        chat_container = st.container()
-
-        with chat_container:
-            # Mostrar el historial del chat
-            chat_history = st.session_state.get('semantic_chat_history', [])
-            for message in chat_history:
-                with st.chat_message(message["role"]):
-                    st.write(message["content"])
-
-        # Input del usuario
-        user_input = st.chat_input(get_translation(t, 'semantic_chat_input', 'Type your message here...'), key=generate_unique_key('semantic', 'chat_input'))
-
-        if user_input:
-            # Añadir el mensaje del usuario al historial
-            chat_history.append({"role": "user", "content": user_input})
-
-            # Generar respuesta del chatbot
-            chatbot = st.session_state.semantic_chatbot
-            response = chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents'))
-
-            # Añadir la respuesta del chatbot al historial
-            chat_history.append({"role": "assistant", "content": response})
-
-            # Actualizar el historial en session_state
-            st.session_state.semantic_chat_history = chat_history
-
-            # Forzar la actualización de la interfaz
-            st.rerun()
-
-    with col_graph:
-        st.subheader(get_translation(t, 'graph_title', 'Semantic Graph'))
-
-        # Mostrar conceptos clave en un expander horizontal
-        with st.expander(get_translation(t, 'key_concepts_title', 'Key Concepts'), expanded=True):
-            if 'key_concepts' in st.session_state:
-                st.markdown('<div class="horizontal-list">', unsafe_allow_html=True)
-                for concept, freq in st.session_state.key_concepts:
-                    st.markdown(f'<span style="margin-right: 10px;">{concept}: {freq:.2f}</span>', unsafe_allow_html=True)
-                st.markdown('</div>', unsafe_allow_html=True)
-
-        if 'graph' in st.session_state:
-            st.pyplot(st.session_state.graph)
-
-    # Botón para limpiar el historial del chat
-    if st.button(get_translation(t, 'clear_chat', 'Clear chat'), key=generate_unique_key('semantic', 'clear_chat')):
-        st.session_state.semantic_chat_history = []
+import streamlit as st
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+def get_translation(t, key, default):
+    return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+    #st.set_page_config(layout="wide")
+
+    # Estilo CSS personalizado
+    st.markdown("""
+        <style>
+        .semantic-initial-message {
+            background-color: #f0f2f6;
+            border-left: 5px solid #4CAF50;
+            padding: 10px;
+            border-radius: 5px;
+            font-size: 16px;
+            margin-bottom: 20px;
+        }
+        .stButton > button {
+            width: 100%;
+        }
+        .chat-container {
+            height: 400px;
+            overflow-y: auto;
+            border: 1px solid #ddd;
+            padding: 10px;
+            border-radius: 5px;
+        }
+        .file-management-container {
+            border: 1px solid #ddd;
+            padding: 10px;
+            border-radius: 5px;
+            margin-bottom: 20px;
+        }
+        .horizontal-list {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    # Mostrar el mensaje inicial como un párrafo estilizado
+    st.markdown(f"""
+        <div class="semantic-initial-message">
+        {get_translation(t, 'semantic_initial_message', 'Welcome to the semantic analysis interface.')}
+        </div>
+    """, unsafe_allow_html=True)
+
+    # Inicializar el chatbot si no existe
+    if 'semantic_chatbot' not in st.session_state:
+        st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+    # Contenedor para la gestión de archivos
+    with st.container():
+        st.markdown('<div class="file-management-container">', unsafe_allow_html=True)
+        col1, col2, col3, col4 = st.columns(4)
+
+        with col1:
+            if st.button(get_translation(t, 'upload_file', 'Upload File'), key=generate_unique_key('semantic', 'upload_button')):
+                uploaded_file = st.file_uploader(get_translation(t, 'file_uploader', 'Choose a file'), type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+                if uploaded_file is not None:
+                    file_contents = uploaded_file.getvalue().decode('utf-8')
+                    if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+                        st.success(get_translation(t, 'file_uploaded_success', 'File uploaded and saved to database successfully'))
+                        st.session_state.file_contents = file_contents
+                        st.rerun()
+                    else:
+                        st.error(get_translation(t, 'file_upload_error', 'Error uploading file'))
+
+        with col2:
+            user_files = get_user_files(st.session_state.username, 'semantic')
+            file_options = [get_translation(t, 'select_file', 'Select a file')] + [file['file_name'] for file in user_files]
+            selected_file = st.selectbox(get_translation(t, 'file_list', 'File List'), options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+            if selected_file != get_translation(t, 'select_file', 'Select a file'):
+                if st.button(get_translation(t, 'load_file', 'Load File'), key=generate_unique_key('semantic', 'load_file')):
+                    file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+                    if file_contents:
+                        st.session_state.file_contents = file_contents
+                        st.success(get_translation(t, 'file_loaded_success', 'File loaded successfully'))
+                    else:
+                        st.error(get_translation(t, 'file_load_error', 'Error loading file'))
+
+        with col3:
+            if st.button(get_translation(t, 'analyze_document', 'Analyze Document'), key=generate_unique_key('semantic', 'analyze_document')):
+                if 'file_contents' in st.session_state:
+                    with st.spinner(get_translation(t, 'analyzing', 'Analyzing...')):
+                        graph, key_concepts = process_semantic_analysis(st.session_state.file_contents, nlp_models[lang_code], lang_code)
+                    st.session_state.graph = graph
+                    st.session_state.key_concepts = key_concepts
+                    st.success(get_translation(t, 'analysis_completed', 'Analysis completed'))
+                else:
+                    st.error(get_translation(t, 'no_file_uploaded', 'No file uploaded'))
+
+        with col4:
+            if st.button(get_translation(t, 'delete_file', 'Delete File'), key=generate_unique_key('semantic', 'delete_file')):
+                if selected_file and selected_file != get_translation(t, 'select_file', 'Select a file'):
+                    if delete_file(st.session_state.username, selected_file, 'semantic'):
+                        st.success(get_translation(t, 'file_deleted_success', 'File deleted successfully'))
+                        if 'file_contents' in st.session_state:
+                            del st.session_state.file_contents
+                        st.rerun()
+                    else:
+                        st.error(get_translation(t, 'file_delete_error', 'Error deleting file'))
+                else:
+                    st.error(get_translation(t, 'no_file_selected', 'No file selected'))
+
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Crear dos columnas: una para el chat y otra para la visualización
+    col_chat, col_graph = st.columns([1, 1])
+
+    with col_chat:
+        st.subheader(get_translation(t, 'chat_title', 'Semantic Analysis Chat'))
+        # Chat interface
+        chat_container = st.container()
+
+        with chat_container:
+            # Mostrar el historial del chat
+            chat_history = st.session_state.get('semantic_chat_history', [])
+            for message in chat_history:
+                with st.chat_message(message["role"]):
+                    st.write(message["content"])
+
+        # Input del usuario
+        user_input = st.chat_input(get_translation(t, 'semantic_chat_input', 'Type your message here...'), key=generate_unique_key('semantic', 'chat_input'))
+
+        if user_input:
+            # Añadir el mensaje del usuario al historial
+            chat_history.append({"role": "user", "content": user_input})
+
+            # Generar respuesta del chatbot
+            chatbot = st.session_state.semantic_chatbot
+            response = chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents'))
+
+            # Añadir la respuesta del chatbot al historial
+            chat_history.append({"role": "assistant", "content": response})
+
+            # Actualizar el historial en session_state
+            st.session_state.semantic_chat_history = chat_history
+
+            # Forzar la actualización de la interfaz
+            st.rerun()
+
+    with col_graph:
+        st.subheader(get_translation(t, 'graph_title', 'Semantic Graph'))
+
+        # Mostrar conceptos clave en un expander horizontal
+        with st.expander(get_translation(t, 'key_concepts_title', 'Key Concepts'), expanded=True):
+            if 'key_concepts' in st.session_state:
+                st.markdown('<div class="horizontal-list">', unsafe_allow_html=True)
+                for concept, freq in st.session_state.key_concepts:
+                    st.markdown(f'<span style="margin-right: 10px;">{concept}: {freq:.2f}</span>', unsafe_allow_html=True)
+                st.markdown('</div>', unsafe_allow_html=True)
+
+        if 'graph' in st.session_state:
+            st.pyplot(st.session_state.graph)
+
+    # Botón para limpiar el historial del chat
+    if st.button(get_translation(t, 'clear_chat', 'Clear chat'), key=generate_unique_key('semantic', 'clear_chat')):
+        st.session_state.semantic_chat_history = []
         st.rerun()

modules/semantic/semantic_interface_3.py

@@ -1,182 +1,182 @@
-import streamlit as st
-import logging
-from .semantic_process import process_semantic_analysis
-from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
-from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
-from ..utils.widget_utils import generate_unique_key
-
-logger = logging.getLogger(__name__)
-
-def get_translation(t, key, default):
-    return t.get(key, default)
-
-def display_semantic_interface(lang_code, nlp_models, t):
-    st.markdown("""
-        <style>
-        .semantic-initial-message {
-            background-color: #f0f2f6;
-            border-left: 5px solid #4CAF50;
-            padding: 10px;
-            border-radius: 5px;
-            font-size: 16px;
-            margin-bottom: 20px;
-        }
-        .stButton > button {
-            width: 100%;
-            height: 3em;
-        }
-        .chat-container {
-            height: 400px;
-            overflow-y: auto;
-            border: 1px solid #ddd;
-            padding: 10px;
-            border-radius: 5px;
-        }
-        .file-management-container, .analysis-container {
-            border: 1px solid #ddd;
-            padding: 10px;
-            border-radius: 5px;
-            margin-bottom: 20px;
-        }
-        .horizontal-list {
-            display: flex;
-            flex-wrap: wrap;
-            gap: 10px;
-        }
-        .graph-container {
-            height: 500px;
-            overflow-y: auto;
-        }
-        </style>
-    """, unsafe_allow_html=True)
-
-    st.markdown(f"""
-        <div class="semantic-initial-message">
-        {get_translation(t, 'semantic_initial_message', 'Welcome to the semantic analysis interface.')}
-        </div>
-    """, unsafe_allow_html=True)
-
-    if 'semantic_chatbot' not in st.session_state:
-        st.session_state.semantic_chatbot = initialize_chatbot('semantic')
-
-    # Contenedor para la gestión de archivos
-    with st.container():
-        st.markdown('<div class="file-management-container">', unsafe_allow_html=True)
-        col1, col2, col3, col4 = st.columns(4)
-
-        with col1:
-            uploaded_file = st.file_uploader(get_translation(t, 'upload_file', 'Upload File'), type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
-            if uploaded_file is not None:
-                file_contents = uploaded_file.getvalue().decode('utf-8')
-                if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
-                    st.session_state.file_contents = file_contents
-                    st.success(get_translation(t, 'file_uploaded_success', 'File uploaded and saved successfully'))
-                    st.rerun()
-                else:
-                    st.error(get_translation(t, 'file_upload_error', 'Error uploading file'))
-
-        with col2:
-            user_files = get_user_files(st.session_state.username, 'semantic')
-            file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
-            selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
-            if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
-                file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
-                if file_contents:
-                    st.session_state.file_contents = file_contents
-                    st.success(get_translation(t, 'file_loaded_success', 'File loaded successfully'))
-                else:
-                    st.error(get_translation(t, 'file_load_error', 'Error loading file'))
-
-        with col3:
-            if st.button(get_translation(t, 'analyze_document', 'Analyze Document'), key=generate_unique_key('semantic', 'analyze_document')):
-                if 'file_contents' in st.session_state:
-                    with st.spinner(get_translation(t, 'analyzing', 'Analyzing...')):
-                        try:
-                            nlp_model = nlp_models[lang_code]
-                            concept_graph, entity_graph, key_concepts = process_semantic_analysis(st.session_state.file_contents, nlp_model, lang_code)
-                            st.session_state.concept_graph = concept_graph
-                            st.session_state.entity_graph = entity_graph
-                            st.session_state.key_concepts = key_concepts
-                            st.success(get_translation(t, 'analysis_completed', 'Analysis completed'))
-                        except Exception as e:
-                            logger.error(f"Error during analysis: {str(e)}")
-                            st.error(f"Error during analysis: {str(e)}")
-                else:
-                    st.error(get_translation(t, 'no_file_uploaded', 'No file uploaded'))
-
-        with col4:
-            if st.button(get_translation(t, 'delete_file', 'Delete File'), key=generate_unique_key('semantic', 'delete_file')):
-                if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
-                    if delete_file(st.session_state.username, selected_file, 'semantic'):
-                        st.success(get_translation(t, 'file_deleted_success', 'File deleted successfully'))
-                        if 'file_contents' in st.session_state:
-                            del st.session_state.file_contents
-                        st.rerun()
-                    else:
-                        st.error(get_translation(t, 'file_delete_error', 'Error deleting file'))
-                else:
-                    st.error(get_translation(t, 'no_file_selected', 'No file selected'))
-
-        st.markdown('</div>', unsafe_allow_html=True)
-
-    # Contenedor para la sección de análisis
-    st.markdown('<div class="analysis-container">', unsafe_allow_html=True)
-    col_chat, col_graph = st.columns([1, 1])
-
-    with col_chat:
-        st.subheader(get_translation(t, 'chat_title', 'Semantic Analysis Chat'))
-        chat_container = st.container()
-
-        with chat_container:
-            chat_history = st.session_state.get('semantic_chat_history', [])
-            for message in chat_history:
-                with st.chat_message(message["role"]):
-                    st.write(message["content"])
-
-        user_input = st.chat_input(get_translation(t, 'semantic_chat_input', 'Type your message here...'), key=generate_unique_key('semantic', 'chat_input'))
-
-        if user_input:
-            chat_history.append({"role": "user", "content": user_input})
-
-            if user_input.startswith('/analyze_current'):
-                response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
-            else:
-                response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code)
-
-            chat_history.append({"role": "assistant", "content": response})
-            st.session_state.semantic_chat_history = chat_history
-
-    with col_graph:
-        st.subheader(get_translation(t, 'graph_title', 'Semantic Graphs'))
-
-        # Mostrar conceptos clave y entidades horizontalmente
-        if 'key_concepts' in st.session_state:
-            st.write(get_translation(t, 'key_concepts_title', 'Key Concepts'))
-            st.markdown('<div class="horizontal-list">', unsafe_allow_html=True)
-            for concept, freq in st.session_state.key_concepts:
-                st.markdown(f'<span style="margin-right: 10px;">{concept}: {freq:.2f}</span>', unsafe_allow_html=True)
-            st.markdown('</div>', unsafe_allow_html=True)
-
-        if 'entities' in st.session_state:
-            st.write(get_translation(t, 'entities_title', 'Entities'))
-            st.markdown('<div class="horizontal-list">', unsafe_allow_html=True)
-            for entity, type in st.session_state.entities.items():
-                st.markdown(f'<span style="margin-right: 10px;">{entity}: {type}</span>', unsafe_allow_html=True)
-            st.markdown('</div>', unsafe_allow_html=True)
-
-        # Usar pestañas para mostrar los gráficos
-        tab1, tab2 = st.tabs(["Concept Graph", "Entity Graph"])
-
-        with tab1:
-            if 'concept_graph' in st.session_state:
-                st.pyplot(st.session_state.concept_graph)
-
-        with tab2:
-            if 'entity_graph' in st.session_state:
-                st.pyplot(st.session_state.entity_graph)
-
-    st.markdown('</div>', unsafe_allow_html=True)
-
-    if st.button(get_translation(t, 'clear_chat', 'Clear chat'), key=generate_unique_key('semantic', 'clear_chat')):
-        st.session_state.semantic_chat_history = []
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+    return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+    st.markdown("""
+        <style>
+        .semantic-initial-message {
+            background-color: #f0f2f6;
+            border-left: 5px solid #4CAF50;
+            padding: 10px;
+            border-radius: 5px;
+            font-size: 16px;
+            margin-bottom: 20px;
+        }
+        .stButton > button {
+            width: 100%;
+            height: 3em;
+        }
+        .chat-container {
+            height: 400px;
+            overflow-y: auto;
+            border: 1px solid #ddd;
+            padding: 10px;
+            border-radius: 5px;
+        }
+        .file-management-container, .analysis-container {
+            border: 1px solid #ddd;
+            padding: 10px;
+            border-radius: 5px;
+            margin-bottom: 20px;
+        }
+        .horizontal-list {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+        }
+        .graph-container {
+            height: 500px;
+            overflow-y: auto;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    st.markdown(f"""
+        <div class="semantic-initial-message">
+        {get_translation(t, 'semantic_initial_message', 'Welcome to the semantic analysis interface.')}
+        </div>
+    """, unsafe_allow_html=True)
+
+    if 'semantic_chatbot' not in st.session_state:
+        st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+    # Contenedor para la gestión de archivos
+    with st.container():
+        st.markdown('<div class="file-management-container">', unsafe_allow_html=True)
+        col1, col2, col3, col4 = st.columns(4)
+
+        with col1:
+            uploaded_file = st.file_uploader(get_translation(t, 'upload_file', 'Upload File'), type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+            if uploaded_file is not None:
+                file_contents = uploaded_file.getvalue().decode('utf-8')
+                if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+                    st.session_state.file_contents = file_contents
+                    st.success(get_translation(t, 'file_uploaded_success', 'File uploaded and saved successfully'))
+                    st.rerun()
+                else:
+                    st.error(get_translation(t, 'file_upload_error', 'Error uploading file'))
+
+        with col2:
+            user_files = get_user_files(st.session_state.username, 'semantic')
+            file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+            selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+            if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+                file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+                if file_contents:
+                    st.session_state.file_contents = file_contents
+                    st.success(get_translation(t, 'file_loaded_success', 'File loaded successfully'))
+                else:
+                    st.error(get_translation(t, 'file_load_error', 'Error loading file'))
+
+        with col3:
+            if st.button(get_translation(t, 'analyze_document', 'Analyze Document'), key=generate_unique_key('semantic', 'analyze_document')):
+                if 'file_contents' in st.session_state:
+                    with st.spinner(get_translation(t, 'analyzing', 'Analyzing...')):
+                        try:
+                            nlp_model = nlp_models[lang_code]
+                            concept_graph, entity_graph, key_concepts = process_semantic_analysis(st.session_state.file_contents, nlp_model, lang_code)
+                            st.session_state.concept_graph = concept_graph
+                            st.session_state.entity_graph = entity_graph
+                            st.session_state.key_concepts = key_concepts
+                            st.success(get_translation(t, 'analysis_completed', 'Analysis completed'))
+                        except Exception as e:
+                            logger.error(f"Error during analysis: {str(e)}")
+                            st.error(f"Error during analysis: {str(e)}")
+                else:
+                    st.error(get_translation(t, 'no_file_uploaded', 'No file uploaded'))
+
+        with col4:
+            if st.button(get_translation(t, 'delete_file', 'Delete File'), key=generate_unique_key('semantic', 'delete_file')):
+                if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+                    if delete_file(st.session_state.username, selected_file, 'semantic'):
+                        st.success(get_translation(t, 'file_deleted_success', 'File deleted successfully'))
+                        if 'file_contents' in st.session_state:
+                            del st.session_state.file_contents
+                        st.rerun()
+                    else:
+                        st.error(get_translation(t, 'file_delete_error', 'Error deleting file'))
+                else:
+                    st.error(get_translation(t, 'no_file_selected', 'No file selected'))
+
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Contenedor para la sección de análisis
+    st.markdown('<div class="analysis-container">', unsafe_allow_html=True)
+    col_chat, col_graph = st.columns([1, 1])
+
+    with col_chat:
+        st.subheader(get_translation(t, 'chat_title', 'Semantic Analysis Chat'))
+        chat_container = st.container()
+
+        with chat_container:
+            chat_history = st.session_state.get('semantic_chat_history', [])
+            for message in chat_history:
+                with st.chat_message(message["role"]):
+                    st.write(message["content"])
+
+        user_input = st.chat_input(get_translation(t, 'semantic_chat_input', 'Type your message here...'), key=generate_unique_key('semantic', 'chat_input'))
+
+        if user_input:
+            chat_history.append({"role": "user", "content": user_input})
+
+            if user_input.startswith('/analyze_current'):
+                response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+            else:
+                response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code)
+
+            chat_history.append({"role": "assistant", "content": response})
+            st.session_state.semantic_chat_history = chat_history
+
+    with col_graph:
+        st.subheader(get_translation(t, 'graph_title', 'Semantic Graphs'))
+
+        # Mostrar conceptos clave y entidades horizontalmente
+        if 'key_concepts' in st.session_state:
+            st.write(get_translation(t, 'key_concepts_title', 'Key Concepts'))
+            st.markdown('<div class="horizontal-list">', unsafe_allow_html=True)
+            for concept, freq in st.session_state.key_concepts:
+                st.markdown(f'<span style="margin-right: 10px;">{concept}: {freq:.2f}</span>', unsafe_allow_html=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+
+        if 'entities' in st.session_state:
+            st.write(get_translation(t, 'entities_title', 'Entities'))
+            st.markdown('<div class="horizontal-list">', unsafe_allow_html=True)
+            for entity, type in st.session_state.entities.items():
+                st.markdown(f'<span style="margin-right: 10px;">{entity}: {type}</span>', unsafe_allow_html=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+
+        # Usar pestañas para mostrar los gráficos
+        tab1, tab2 = st.tabs(["Concept Graph", "Entity Graph"])
+
+        with tab1:
+            if 'concept_graph' in st.session_state:
+                st.pyplot(st.session_state.concept_graph)
+
+        with tab2:
+            if 'entity_graph' in st.session_state:
+                st.pyplot(st.session_state.entity_graph)
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    if st.button(get_translation(t, 'clear_chat', 'Clear chat'), key=generate_unique_key('semantic', 'clear_chat')):
+        st.session_state.semantic_chat_history = []
         st.rerun()