Update modules/semantic/semantic_interface.py

modules/semantic/semantic_interface.py

@@ -32,83 +32,87 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
     # Mantener la página en semántico
     st.session_state.page = 'semantic'
 
-    try:
-        # Inicializar estados si no existen
-        if 'semantic_analysis_counter' not in st.session_state:
-            st.session_state.semantic_analysis_counter = 0
-        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
-
-        # Estilos CSS para alinear los botones
-        st.markdown("""
-            <style>
-            .stButton > button {
-                width: 100%;
-                margin: 0;
-                height: 38px;
-                display: inline-flex;
-                align-items: center;
-                justify-content: center;
-            }
-            .upload-container {
-                margin-bottom: 0 !important;
-                padding-bottom: 0 !important;
-            }
-            </style>
-        """, unsafe_allow_html=True)
+    # Inicializar estados si no existen
+    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
+    if 'semantic_analysis_counter' not in st.session_state:
+        st.session_state.semantic_analysis_counter = 0
+
+    # Estilos CSS para alinear los botones
+    st.markdown("""
+        <style>
+        .stButton > button {
+            width: 100%;
+            height: 38px;
+        }
+        .stUploadButton > button {
+            width: 100%;
+            height: 38px;
+        }
+        div.row-widget.stButton {
+            margin-top: 1px;
+            margin-bottom: 1px;
+        }
+        </style>
+    """, unsafe_allow_html=True)
 
+    try:
         # Contenedor principal con layout fijo
         with st.container():
             # Una sola fila para todos los controles
-            cols = st.columns([4, 2, 2, 2])
+            col_file, col_analyze, col_export, col_new = st.columns([4, 2, 2, 2])
 
             # Columna 1: Carga de archivo
-            with cols[0]:
+            with col_file:
                 uploaded_file = st.file_uploader(
                     semantic_t.get('file_uploader', 'Upload TXT file'),
                     type=['txt'],
-                    key=f"semantic_file_uploader_{st.session_state.semantic_analysis_counter}"
+                    key=f"semantic_uploader_{st.session_state.semantic_analysis_counter}"
                 )
                 
-                # Actualizar el estado cuando se sube un archivo
                 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'
+                    # Actualizar el contenido del archivo
+                    file_content = uploaded_file.getvalue().decode('utf-8')
+                    if file_content != st.session_state.semantic_file_content:
+                        st.session_state.semantic_file_content = file_content
+                        st.session_state.semantic_analysis_done = False
 
             # Columna 2: Botón de análisis
-            with cols[1]:
+            with col_analyze:
+                analyze_enabled = uploaded_file is not None and not st.session_state.semantic_analysis_done
                 analyze_button = st.button(
                     semantic_t.get('analyze_button', 'Analyze Text'),
-                    disabled=(uploaded_file is None),
-                    key=f"analyze_semantic_{st.session_state.semantic_analysis_counter}"
+                    disabled=not analyze_enabled,
+                    key=f"analyze_button_{st.session_state.semantic_analysis_counter}",
+                    use_container_width=True
                 )
 
             # Columna 3: Botón de exportación
-            with cols[2]:
+            with col_export:
                 export_button = st.button(
                     semantic_t.get('export_button', 'Export'),
                     disabled=not st.session_state.semantic_analysis_done,
-                    key=f"export_semantic_{st.session_state.semantic_analysis_counter}"
+                    key=f"export_button_{st.session_state.semantic_analysis_counter}",
+                    use_container_width=True
                 )
 
             # Columna 4: Botón de nuevo análisis
-            with cols[3]:
-                new_analysis_button = st.button(
-                    semantic_t.get('new_analysis', 'New'),
+            with col_new:
+                new_button = st.button(
+                    semantic_t.get('new_analysis', 'New Analysis'),
                     disabled=not st.session_state.semantic_analysis_done,
-                    key=f"new_semantic_{st.session_state.semantic_analysis_counter}"
+                    key=f"new_button_{st.session_state.semantic_analysis_counter}",
+                    use_container_width=True
                 )
 
-        # Separador
         st.markdown("<hr style='margin: 1em 0; opacity: 0.3'>", unsafe_allow_html=True)
 
-        # Procesar análisis
-        if analyze_button and uploaded_file is not None:
-            try:
-                with st.spinner(semantic_t.get('processing', 'Processing...')):
+        # Procesar análisis cuando se presiona el botón
+        if analyze_button and st.session_state.semantic_file_content:
+            with st.spinner(semantic_t.get('processing', 'Processing...')):
+                try:
                     analysis_result = process_semantic_input(
                         st.session_state.semantic_file_content,
                         lang_code,
@@ -117,32 +121,27 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
                     )
                     
                     if analysis_result['success']:
+                        # Guardar resultados y actualizar estado
                         st.session_state.semantic_result = analysis_result
                         st.session_state.semantic_analysis_done = True
                         
-                        # Guardar en la base de datos
+                        # Guardar en 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
-                            )
+                            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: {str(e)}")
+                    st.error(semantic_t.get('error_processing', f'Error: {str(e)}'))
 
-            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
+        # Manejar exportación
         if export_button and st.session_state.semantic_analysis_done:
             try:
                 pdf_buffer = export_user_interactions(st.session_state.username, 'semantic')
@@ -151,32 +150,29 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
                     data=pdf_buffer,
                     file_name="semantic_analysis.pdf",
                     mime="application/pdf",
-                    key=f"semantic_download_{st.session_state.semantic_analysis_counter}"
+                    key=f"download_{st.session_state.semantic_analysis_counter}"
                 )
             except Exception as e:
-                st.error(f"Error exporting analysis: {str(e)}")
+                st.error(f"Error exporting: {str(e)}")
 
-        # Manejo de nuevo análisis
-        if new_analysis_button:
+        # Manejar nuevo análisis
+        if new_button:
             st.session_state.semantic_file_content = None
             st.session_state.semantic_analysis_done = False
             st.session_state.semantic_result = None
             st.session_state.semantic_analysis_counter += 1
-            st.experimental_rerun()
+            st.rerun()
 
-        # Mostrar resultados o mensaje inicial
+        # Mostrar resultados existentes 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
-            )
+            display_semantic_results(st.session_state.semantic_result, lang_code, semantic_t)
         elif not uploaded_file:
             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.")
+        logger.error(f"Error general: {str(e)}")
+        st.error("Error in semantic interface. Please try again.")
+        
 
 def display_semantic_results(result, lang_code, semantic_t):
     """