Update modules/semantic/semantic_interface.py

modules/semantic/semantic_interface.py

@@ -29,150 +29,95 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
     """
     Interfaz para el análisis semántico con controles alineados horizontalmente
     """
-    # Mantener la página en semántico
+    # Forzar la página a semántico
     st.session_state.page = 'semantic'
-
-    # 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
-            col_file, col_analyze, col_export, col_new = st.columns([4, 2, 2, 2])
-
-            # Columna 1: Carga de archivo
-            with col_file:
-                uploaded_file = st.file_uploader(
-                    semantic_t.get('file_uploader', 'Upload TXT file'),
-                    type=['txt'],
-                    key=f"semantic_uploader_{st.session_state.semantic_analysis_counter}"
-                )
-                
-                if uploaded_file is not None:
-                    # 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 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=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 col_export:
-                export_button = st.button(
-                    semantic_t.get('export_button', 'Export'),
-                    disabled=not st.session_state.semantic_analysis_done,
-                    key=f"export_button_{st.session_state.semantic_analysis_counter}",
-                    use_container_width=True
-                )
-
-            # Columna 4: Botón de nuevo análisis
-            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_button_{st.session_state.semantic_analysis_counter}",
-                    use_container_width=True
-                )
-
-        st.markdown("<hr style='margin: 1em 0; opacity: 0.3'>", unsafe_allow_html=True)
-
-        # 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,
-                        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 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'))
-                            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)}'))
-
-        # Manejar exportación
-        if export_button and st.session_state.semantic_analysis_done:
-            try:
-                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"download_{st.session_state.semantic_analysis_counter}"
-                )
-            except Exception as e:
-                st.error(f"Error exporting: {str(e)}")
-
-        # 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.rerun()
-
-        # 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)
-        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: {str(e)}")
-        st.error("Error in semantic interface. Please try again.")
+    
+    # Inicializar estados básicos
+    if 'semantic_content' not in st.session_state:
+        st.session_state.semantic_content = None
+    if 'semantic_analyzed' not in st.session_state:
+        st.session_state.semantic_analyzed = False
+
+    # Contenedor principal
+    with st.container():
+        # Una sola fila para todos los controles
+        cols = st.columns([4, 2, 2, 2])
         
+        # Columna 1: Carga de archivo
+        with cols[0]:
+            uploaded_file = st.file_uploader(
+                "Upload text file",  # Simplificamos el mensaje
+                type=['txt'],
+                key="semantic_file_upload"
+            )
+
+        # Columna 2: Botón de análisis
+        with cols[1]:
+            can_analyze = uploaded_file is not None and not st.session_state.semantic_analyzed
+            if st.button('Analyze', 
+                        disabled=not can_analyze,
+                        key="semantic_analyze"):
+                if uploaded_file:
+                    text_content = uploaded_file.getvalue().decode('utf-8')
+                    # Realizar el análisis
+                    with st.spinner("Analyzing..."):
+                        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_analyzed = True
+                            st.success("Analysis completed!")
+                            
+                            # Mostrar resultados
+                            display_semantic_results(
+                                analysis_result,
+                                lang_code,
+                                semantic_t
+                            )
+
+        # Columna 3: Botón de exportación
+        with cols[2]:
+            if st.button('Export', 
+                        disabled=not st.session_state.semantic_analyzed,
+                        key="semantic_export"):
+                if st.session_state.semantic_analyzed:
+                    try:
+                        pdf_buffer = export_user_interactions(
+                            st.session_state.username, 
+                            'semantic'
+                        )
+                        st.download_button(
+                            "Download PDF",
+                            data=pdf_buffer,
+                            file_name="semantic_analysis.pdf",
+                            mime="application/pdf"
+                        )
+                    except Exception as e:
+                        st.error(f"Error exporting: {str(e)}")
+
+        # Columna 4: Botón de nuevo análisis
+        with cols[3]:
+            if st.button('New Analysis', 
+                        disabled=not st.session_state.semantic_analyzed,
+                        key="semantic_new"):
+                st.session_state.semantic_content = None
+                st.session_state.semantic_analyzed = False
+                st.session_state.semantic_result = None
+                st.rerun()
+
+    # Mostrar resultados si existen
+    if st.session_state.semantic_analyzed and 'semantic_result' in st.session_state:
+        display_semantic_results(
+            st.session_state.semantic_result,
+            lang_code,
+            semantic_t
+        )
+    elif not uploaded_file:
+        st.info("Please upload a text file to begin analysis")
 
 def display_semantic_results(result, lang_code, semantic_t):
     """