Update modules/semantic/semantic_interface.py

modules/semantic/semantic_interface.py

@@ -1,9 +1,9 @@
 #modules/semantic/semantic_interface.py
-# Importaciones necesarias
 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
@@ -25,9 +25,25 @@ 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
 
-
-#modules/semantic/semantic_interface.py
-# [Mantener las importaciones igual...]
+def handle_file_upload(uploaded_file):
+    """
+    Maneja la carga de archivos y mantiene el estado
+    Args:
+        uploaded_file: Archivo subido a través del file_uploader
+    """
+    try:
+        if uploaded_file is not None:
+            content = uploaded_file.getvalue().decode('utf-8')
+            st.session_state.semantic_file_content = content
+            st.session_state.page = 'semantic'  # Mantener en la página semántica
+            logger.info(f"Archivo cargado exitosamente: {uploaded_file.name}")
+        else:
+            st.session_state.semantic_file_content = None
+            logger.info("No se ha cargado ningún archivo")
+    except Exception as e:
+        logger.error(f"Error al cargar archivo: {str(e)}")
+        st.error("Error al cargar el archivo. Asegúrese de que es un archivo de texto válido.")
+        st.session_state.semantic_file_content = None
 
 def display_semantic_interface(lang_code, nlp_models, semantic_t):
     """
@@ -90,23 +106,36 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
         if analyze_button and st.session_state.semantic_file_content:
             try:
                 with st.spinner(semantic_t.get('processing', 'Processing...')):
-                    doc = nlp_models[lang_code](st.session_state.semantic_file_content)
-                    
-                    # Usar spacy-streamlit para las visualizaciones
-                    st.markdown("### Semantic Analysis Results")
-                    
-                    # Visualizar entidades nombradas
-                    spacy_streamlit.visualize_ner(
-                        doc,
-                        labels=nlp_models[lang_code].get_pipe("ner").labels
+                    analysis_result = process_semantic_input(
+                        st.session_state.semantic_file_content,
+                        lang_code,
+                        nlp_models,
+                        semantic_t
                     )
                     
-                    # Visualizar dependencias sintácticas
-                    spacy_streamlit.visualize_parser(doc)
-                    
-                    st.session_state.semantic_analysis_done = True
-                    st.session_state.semantic_result = {'doc': doc}
-                    
+                    if analysis_result['success']:
+                        st.session_state.semantic_result = analysis_result
+                        st.session_state.semantic_analysis_done = True
+                        st.session_state.semantic_analysis_counter += 1
+                        
+                        # Guardar en la base de datos
+                        if store_student_semantic_result(
+                            st.session_state.username,
+                            st.session_state.semantic_file_content,
+                            analysis_result['analysis']
+                        ):
+                            st.success(semantic_t.get('success_message', 'Analysis saved successfully'))
+                            # Mostrar resultados
+                            display_semantic_results(
+                                analysis_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)}'))
@@ -133,20 +162,23 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
             st.session_state.semantic_analysis_counter += 1
             st.rerun()
 
-        # Mostrar mensaje inicial si no hay archivo
-        if not st.session_state.semantic_file_content and not st.session_state.semantic_analysis_done:
+        # Mostrar resultados previos o mensaje inicial
+        elif st.session_state.semantic_analysis_done and 'semantic_result' in st.session_state:
+            display_semantic_results(
+                st.session_state.semantic_result,
+                lang_code,
+                semantic_t
+            )
+        elif not st.session_state.semantic_file_content:
             st.info(semantic_t.get('initial_message', 'Upload a TXT file 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.")
 
-
-# [Resto del código igual...] ###############################################################################################################
-
 def display_semantic_results(result, lang_code, semantic_t):
     """
-    Muestra los resultados del análisis semántico en tabs
+    Muestra los resultados del análisis semántico
     """
     if result is None or not result['success']:
         st.warning(semantic_t.get('no_results', 'No results available'))
@@ -193,21 +225,4 @@ def display_semantic_results(result, lang_code, semantic_t):
         # Columna 2: Gráfico de entidades
         with col2:
             st.subheader(semantic_t.get('entity_graph', 'Entities Graph'))
-            st.image(analysis['entity_graph'])
-
-    # Botón de exportación al final
-    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}"
-            )
+            st.image(analysis['entity_graph'])