Update modules/semantic/semantic_interface.py

modules/semantic/semantic_interface.py

@@ -17,7 +17,7 @@ from .semantic_process import (
 
 from ..utils.widget_utils import generate_unique_key
 from ..database.semantic_mongo_db import store_student_semantic_result
-from ..database.semantic_export import export_user_interactions
+from ..database.semantics_export import export_user_interactions
 
 import logging
 logger = logging.getLogger(__name__)
@@ -30,75 +30,96 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
         nlp_models: Modelos de spaCy cargados
         semantic_t: Diccionario de traducciones semánticas
     """
-    # Inicializar el estado de la entrada
-    input_key = f"semantic_input_{lang_code}"
-    if input_key not in st.session_state:
-        st.session_state[input_key] = ""
-        
-    # Inicializar contador de análisis si no existe
-    if 'semantic_analysis_counter' not in st.session_state:
-        st.session_state.semantic_analysis_counter = 0
-
-    # Campo de entrada de texto
-    text_input = st.text_area(
-        semantic_t.get('text_input_label', 'Enter text to analyze'),
-        height=150,
-        placeholder=semantic_t.get('text_input_placeholder', 'Enter your text here...'),
-        value=st.session_state[input_key],
-        key=f"text_area_{lang_code}_{st.session_state.semantic_analysis_counter}"
-    )
-
-    # Opción para cargar archivo
-    uploaded_file = st.file_uploader(
-        semantic_t.get('file_uploader', 'Or upload a text file'),
-        type=['txt'],
-        key=f"file_uploader_{lang_code}_{st.session_state.semantic_analysis_counter}"
-    )
-
-    if st.button(
-        semantic_t.get('analyze_button', 'Analyze text'),
-        key=f"analyze_button_{lang_code}_{st.session_state.semantic_analysis_counter}"
-    ):
-        if text_input or uploaded_file is not None:
-            try:
-                with st.spinner(semantic_t.get('processing', 'Processing...')):
-                    # Obtener el texto a analizar
-                    text_content = uploaded_file.getvalue().decode('utf-8') if uploaded_file else text_input
-                    
-                    # Realizar el análisis
-                    analysis_result = process_semantic_input(
-                        text_content, 
-                        lang_code,
-                        nlp_models,
-                        semantic_t
-                    )
-                    
-                    # Guardar resultado en el estado de la sesión
-                    st.session_state.semantic_result = analysis_result
-                    st.session_state.semantic_analysis_counter += 1
-                    
-                    # Mostrar resultados
-                    display_semantic_results(
-                        st.session_state.semantic_result,
-                        lang_code,
-                        semantic_t
-                    )
-
-            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)}'))
-        else:
-            st.warning(semantic_t.get('warning_message', 'Please enter text or upload a file'))
+    try:
+        # Inicializar el estado de la entrada
+        input_key = f"semantic_input_{lang_code}"
+        if input_key not in st.session_state:
+            st.session_state[input_key] = ""
             
-    # Si no se presionó el botón, verificar si hay resultados previos
-    elif 'semantic_result' in st.session_state and st.session_state.semantic_result is not None:
-        display_semantic_results(
-            st.session_state.semantic_result,
-            lang_code,
-            semantic_t
+        # Inicializar contador de análisis si no existe
+        if 'semantic_analysis_counter' not in st.session_state:
+            st.session_state.semantic_analysis_counter = 0
+
+        # Campo de entrada de texto
+        text_input = st.text_area(
+            semantic_t.get('text_input_label', 'Enter text to analyze'),
+            height=150,
+            placeholder=semantic_t.get('text_input_placeholder', 'Enter your text here...'),
+            value=st.session_state[input_key],
+            key=generate_unique_key("semantic", "text_area")
         )
-    else:
-        st.info(semantic_t.get('initial_message', 'Enter text to begin analysis'))
+
+        # Opción para cargar archivo
+        uploaded_file = st.file_uploader(
+            semantic_t.get('file_uploader', 'Or upload a text file'),
+            type=['txt'],
+            key=generate_unique_key("semantic", "file_uploader")
+        )
+
+        # Botón de análisis
+        analyze_button = st.button(
+            semantic_t.get('analyze_button', 'Analyze text'),
+            key=generate_unique_key("semantic", "analyze_button")
+        )
+
+        if analyze_button:
+            if text_input or uploaded_file is not None:
+                try:
+                    with st.spinner(semantic_t.get('processing', 'Processing...')):
+                        # Obtener el texto a analizar
+                        text_content = uploaded_file.getvalue().decode('utf-8') if uploaded_file else text_input
+                        
+                        # Realizar el análisis
+                        analysis_result = process_semantic_input(
+                            text_content, 
+                            lang_code,
+                            nlp_models,
+                            semantic_t
+                        )
+                        
+                        if analysis_result['success']:
+                            # Guardar resultado en el estado de la sesión
+                            st.session_state.semantic_result = analysis_result
+                            st.session_state.semantic_analysis_counter += 1
+                            
+                            # Mostrar resultados
+                            display_semantic_results(
+                                analysis_result,
+                                lang_code,
+                                semantic_t
+                            )
+
+                            # Guardar en la base de datos
+                            if store_student_semantic_result(
+                                st.session_state.username,
+                                text_content,
+                                analysis_result['analysis']
+                            ):
+                                st.success(semantic_t.get('success_message', 'Analysis saved successfully'))
+                            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)}'))
+            else:
+                st.warning(semantic_t.get('warning_message', 'Please enter text or upload a file'))
+                
+        # Si no se presionó el botón, verificar si hay resultados previos
+        elif 'semantic_result' in st.session_state and st.session_state.semantic_result is not None:
+            display_semantic_results(
+                st.session_state.semantic_result,
+                lang_code,
+                semantic_t
+            )
+        else:
+            st.info(semantic_t.get('initial_message', 'Enter text to begin analysis'))
+
+    except Exception as e:
+        logger.error(f"Error general en interfaz semántica: {str(e)}")
+        st.error("Se produjo un error. Por favor, intente de nuevo.")
 
 def display_semantic_results(result, lang_code, semantic_t):
     """
@@ -115,7 +136,11 @@ def display_semantic_results(result, lang_code, semantic_t):
     analysis = result['analysis']
     
     # Mostrar conceptos clave
-    with st.expander(semantic_t.get('key_concepts', 'Key Concepts'), expanded=True):
+    with st.expander(
+        semantic_t.get('key_concepts', 'Key Concepts'),
+        expanded=True,
+        key=generate_unique_key("semantic", "key_concepts_expander")
+    ):
         concept_text = " | ".join([
             f"{concept} ({frequency:.2f})" 
             for concept, frequency in analysis['key_concepts']
@@ -123,26 +148,42 @@ def display_semantic_results(result, lang_code, semantic_t):
         st.write(concept_text)
 
     # Mostrar gráfico de relaciones conceptuales
-    with st.expander(semantic_t.get('conceptual_relations', 'Conceptual Relations'), expanded=True):
+    with st.expander(
+        semantic_t.get('conceptual_relations', 'Conceptual Relations'),
+        expanded=True,
+        key=generate_unique_key("semantic", "concept_graph_expander")
+    ):
         st.image(analysis['concept_graph'])
 
     # Mostrar gráfico de entidades
-    with st.expander(semantic_t.get('entity_relations', 'Entity Relations'), expanded=True):
+    with st.expander(
+        semantic_t.get('entity_relations', 'Entity Relations'),
+        expanded=True,
+        key=generate_unique_key("semantic", "entity_graph_expander")
+    ):
         st.image(analysis['entity_graph'])
 
     # Mostrar entidades identificadas
     if 'entities' in analysis:
-        with st.expander(semantic_t.get('identified_entities', 'Identified Entities'), expanded=True):
+        with st.expander(
+            semantic_t.get('identified_entities', 'Identified Entities'),
+            expanded=True,
+            key=generate_unique_key("semantic", "entities_expander")
+        ):
             for entity_type, entities in analysis['entities'].items():
                 st.subheader(entity_type)
                 st.write(", ".join(entities))
 
     # Botón de exportación
-    if st.button(semantic_t.get('export_button', 'Export Analysis')):
+    if st.button(
+        semantic_t.get('export_button', 'Export Analysis'),
+        key=generate_unique_key("semantic", "export_button")
+    ):
         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"
+            mime="application/pdf",
+            key=generate_unique_key("semantic", "download_button")
         )