Update modules/semantic/semantic_interface.py

modules/semantic/semantic_interface.py

@@ -25,6 +25,8 @@ 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
 
+
+###############################
 def display_semantic_interface(lang_code, nlp_models, semantic_t):
     """
     Interfaz para el análisis semántico
@@ -34,31 +36,42 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
         semantic_t: Diccionario de traducciones semánticas
     """
     try:
-        # Inicializar el estado si no existe
+        # 1. Inicializar estados de sesión
         if 'semantic_analysis_counter' not in st.session_state:
             st.session_state.semantic_analysis_counter = 0
+            
+        input_key = f"semantic_input_{lang_code}"
+        if input_key not in st.session_state:
+            st.session_state[input_key] = ""
 
-        # Opción para cargar archivo con key única
+        # 2. Configurar área de entrada (file uploader)
         uploaded_file = st.file_uploader(
-            semantic_t.get('file_uploader', 'Upload a text file for analysis'),
+            semantic_t.get('semantic_file_uploader', 'Upload a text file for semantic analysis'),
             type=['txt'],
             key=f"semantic_file_uploader_{st.session_state.semantic_analysis_counter}"
         )
 
-        # Botón de análisis con key única
+        # 3. Configurar botones de control
         col1, col2, col3 = st.columns([2,1,2])
-        with col2:
+        with col1:
             analyze_button = st.button(
-                semantic_t.get('analyze_button', 'Analyze text'),
+                semantic_t.get('semantic_analyze_button', 'Analyze Semantic'),
                 key=f"semantic_analyze_button_{st.session_state.semantic_analysis_counter}",
                 use_container_width=True
             )
 
-        if analyze_button and uploaded_file is not None:
+        # 4. Procesar análisis cuando se activa
+        if analyze_button:
+            if uploaded_file is None:
+                st.warning(semantic_t.get('warning_message', 'Please upload a file first'))
+                return
+
             try:
                 with st.spinner(semantic_t.get('processing', 'Processing...')):
+                    # 4.1 Leer contenido del archivo
                     text_content = uploaded_file.getvalue().decode('utf-8')
                     
+                    # 4.2 Realizar análisis semántico
                     analysis_result = process_semantic_input(
                         text_content, 
                         lang_code,
@@ -66,40 +79,46 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
                         semantic_t
                     )
                     
-                    if analysis_result['success']:
-                        st.session_state.semantic_result = analysis_result
-                        st.session_state.semantic_analysis_counter += 1
+                    if not analysis_result['success']:
+                        st.error(analysis_result['message'])
+                        return
+
+                    # 4.3 Guardar resultado en el estado de la sesión
+                    st.session_state.semantic_result = analysis_result
+                    
+                    # 4.4 Incrementar el contador de análisis
+                    st.session_state.semantic_analysis_counter += 1
+                    
+                    # 4.5 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'))
                         
-                        # 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'))
-                            # Mostrar resultados
-                            display_semantic_results(
-                                analysis_result,
-                                lang_code,
-                                semantic_t
-                            )
-                        else:
-                            st.error(semantic_t.get('error_message', 'Error saving analysis'))
+                        # 4.6 Mostrar resultados
+                        display_semantic_results(
+                            st.session_state.semantic_result, 
+                            analysis_result,
+                            lang_code,
+                            semantic_t
+                        )
                     else:
-                        st.error(analysis_result['message'])
+                        st.error(semantic_t.get('error_message', 'Error saving analysis'))
+                        
             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)}'))
-        elif analyze_button:
-            st.warning(semantic_t.get('warning_message', 'Please upload a file first'))
-        
-        # Mostrar resultados previos
+
+        # 5. Mostrar resultados previos si existen
         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
             )
+        # 6. Mostrar mensaje inicial
         else:
             st.info(semantic_t.get('initial_message', 'Upload a file to begin analysis'))
 
@@ -107,6 +126,7 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
         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):
     """
     Muestra los resultados del análisis semántico en tabs