Update modules/semantic/semantic_interface.py

modules/semantic/semantic_interface.py

@@ -31,119 +31,146 @@ 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
+    Interfaz para el análisis semántico con controles fijos y manejo de estado mejorado
     """
     try:
         # Inicializar estados
         if 'semantic_analysis_counter' not in st.session_state:
             st.session_state.semantic_analysis_counter = 0
-        if 'semantic_current_file' not in st.session_state:
-            st.session_state.semantic_current_file = None
-        if 'semantic_page' not in st.session_state:
-            st.session_state.semantic_page = 'semantic'
+        if 'semantic_file_content' not in st.session_state:
+            st.session_state.semantic_file_content = None
+        if 'semantic_analysis_done' not in st.session_state:
+            st.session_state.semantic_analysis_done = False
 
-        # Contenedor fijo para todos los controles
+        # Contenedor principal con bordes
         with st.container():
-            st.markdown("### Controls")
+            st.markdown("### Semantic Analysis Controls")
+            st.markdown("---")
+
+            # Sección de carga de archivo
+            col_file, _ = st.columns([6, 4])
+            with col_file:
+                uploaded_file = st.file_uploader(
+                    semantic_t.get('file_uploader', 'Upload a text file for analysis'),
+                    type=['txt'],
+                    key=f"semantic_file_uploader_{st.session_state.semantic_analysis_counter}",
+                    on_change=lambda: handle_file_upload(uploaded_file)
+                )
+
+            # Contenedor fijo para botones
+            st.markdown("---")
+            col1, col2, col3, col4 = st.columns([2, 2, 2, 6])
             
-            # File uploader
-            uploaded_file = st.file_uploader(
-                semantic_t.get('file_uploader', 'Upload a text file for analysis'),
-                type=['txt'],
-                key=f"semantic_file_uploader_{st.session_state.semantic_analysis_counter}",
-                on_change=lambda: setattr(st.session_state, 'semantic_current_file', uploaded_file)
-            )
-
-            # Contenedor para botones alineados a la izquierda
-            left_col, mid_col, right_col = st.columns([1,4,1])
-            with left_col:
-                # Botón de análisis
+            with col1:
                 analyze_button = st.button(
-                    semantic_t.get('analyze_button', 'Analyze text'),
-                    key=f"semantic_analyze_button_{st.session_state.semantic_analysis_counter}",
-                    disabled=not uploaded_file,
-                    use_container_width=True
+                    semantic_t.get('analyze_button', 'Analyze Text'),
+                    disabled=not st.session_state.semantic_file_content,
+                    use_container_width=True,
+                    key="analyze_semantic"
                 )
 
-                # Botón de exportación (si hay resultados)
-                if 'semantic_result' in st.session_state and st.session_state.semantic_result is not None:
-                    st.markdown("") # Espaciador
-                    export_button = st.button(
-                        semantic_t.get('export_button', 'Export Analysis'),
-                        key=f"semantic_export_{st.session_state.semantic_analysis_counter}",
-                        use_container_width=True
-                    )
-                    if export_button:
-                        st.download_button(
-                            label=semantic_t.get('download_pdf', 'Download PDF'),
-                            data=export_user_interactions(st.session_state.username, 'semantic'),
-                            file_name="semantic_analysis.pdf",
-                            mime="application/pdf",
-                            key=f"semantic_download_{st.session_state.semantic_analysis_counter}",
-                            use_container_width=True
-                        )
+            with col2:
+                export_button = st.button(
+                    semantic_t.get('export_button', 'Export Analysis'),
+                    disabled=not st.session_state.semantic_analysis_done,
+                    use_container_width=True,
+                    key="export_semantic"
+                )
+
+            with col3:
+                clear_button = st.button(
+                    semantic_t.get('clear_button', 'Clear Analysis'),
+                    disabled=not st.session_state.semantic_analysis_done,
+                    use_container_width=True,
+                    key="clear_semantic"
+                )
 
-        st.markdown("---")  # Separador
-
-        # Procesar el análisis cuando se presiona el botón
-        if analyze_button and uploaded_file is not None:
-            try:
-                with st.spinner(semantic_t.get('processing', 'Processing...')):
-                    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']:
-                        st.session_state.semantic_result = analysis_result
-                        st.session_state.semantic_analysis_counter += 1
+            st.markdown("---")
+
+            # Procesar análisis
+            if analyze_button and st.session_state.semantic_file_content:
+                try:
+                    with st.spinner(semantic_t.get('processing', 'Processing...')):
+                        analysis_result = process_semantic_input(
+                            st.session_state.semantic_file_content,
+                            lang_code,
+                            nlp_models,
+                            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'))
-                            # Asegurar que nos mantenemos en la página semántica
-                            st.session_state.page = 'semantic'
-                            # Mostrar resultados
-                            display_semantic_results(
-                                analysis_result,
-                                lang_code,
-                                semantic_t
-                            )
+                        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(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)}'))
-        
-        # Mostrar 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', 'Upload a file to begin analysis'))
+                            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)}'))
+
+            # Manejo de exportación
+            if export_button and st.session_state.semantic_analysis_done:
+                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}"
+                )
+
+            # Manejo de limpieza
+            if clear_button:
+                st.session_state.semantic_file_content = None
+                st.session_state.semantic_analysis_done = False
+                st.session_state.semantic_result = None
+                st.rerun()
+
+            # Mostrar resultados previos o mensaje inicial
+            if 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 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 handle_file_upload(uploaded_file):
+    """Maneja la carga de archivos y mantiene el estado"""
+    if uploaded_file is not None:
+        try:
+            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
+        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
+    else:
+        st.session_state.semantic_file_content = None
+
+# [Resto del código igual...] ###############################################################################################################
 
 def display_semantic_results(result, lang_code, semantic_t):
     """