Update modules/semantic/semantic_interface.py

modules/semantic/semantic_interface.py

@@ -37,42 +37,46 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
         semantic_t: Diccionario de traducciones semánticas
     """
     try:
-        # 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] = ""
+        # 1. Inicializar el estado de la sesión
+        if 'semantic_state' not in st.session_state:
+            st.session_state.semantic_state = {
+                'analysis_count': 0,
+                'last_analysis': None,
+                'current_file': None
+            }
 
-        # 2. Configurar área de entrada (file uploader)
+        # 2. Área de carga de archivo con mensaje informativo
+        st.info(semantic_t.get('initial_instruction', 
+            'Para comenzar un nuevo análisis semántico, cargue un archivo de texto (.txt)'))
+            
         uploaded_file = st.file_uploader(
             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}"
+            key=f"semantic_file_uploader_{st.session_state.semantic_state['analysis_count']}"
         )
 
-        # 3. Configurar botones de control
-        col1, col2, col3 = st.columns([2,1,2])
+        # 3. Columnas para los botones y mensajes
+        col1, col2 = st.columns([1,4])
+        
+        # 4. Botón de análisis
         with col1:
             analyze_button = st.button(
-                semantic_t.get('semantic_analyze_button', 'Analyze Semantic'),
-                key=f"semantic_analyze_button_{st.session_state.semantic_analysis_counter}",
+                semantic_t.get('semantic_analyze_button', 'Analyze'),
+                key=f"semantic_analyze_button_{st.session_state.semantic_state['analysis_count']}",
+                type="primary",  # Nuevo en Streamlit 1.39.0
+                icon="🔍",      # Nuevo en Streamlit 1.39.0
+                disabled=uploaded_file is None,
                 use_container_width=True
             )
 
-        # 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
-
+        # 5. Procesar análisis
+        if analyze_button and uploaded_file is not None:
             try:
                 with st.spinner(semantic_t.get('processing', 'Processing...')):
-                    # 4.1 Leer contenido del archivo
+                    # Leer contenido del archivo
                     text_content = uploaded_file.getvalue().decode('utf-8')
                     
-                    # 4.2 Realizar análisis semántico
+                    # Realizar análisis
                     analysis_result = process_semantic_input(
                         text_content, 
                         lang_code,
@@ -80,51 +84,58 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
                         semantic_t
                     )
                     
-                    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'))
+                    if analysis_result['success']:
+                        # Guardar resultado
+                        st.session_state.semantic_result = analysis_result
+                        st.session_state.semantic_state['analysis_count'] += 1
+                        st.session_state.semantic_state['current_file'] = uploaded_file.name
                         
-                        # 4.6 Mostrar resultados - CORREGIDO: removido analysis_result redundante
-                        display_semantic_results(
-                            st.session_state.semantic_result,
-                            lang_code,
-                            semantic_t
-                        )
+                        # Guardar en base de datos
+                        if store_student_semantic_result(
+                            st.session_state.username,
+                            text_content,
+                            analysis_result['analysis']
+                        ):
+                            st.success(
+                                semantic_t.get('analysis_complete', 
+                                'Análisis completado y guardado. Para realizar un nuevo análisis, cargue otro archivo.')
+                            )
+                            
+                            # Mostrar resultados
+                            display_semantic_results(
+                                st.session_state.semantic_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'))
+                        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)}'))
-
-        # 5. Mostrar resultados previos si existen
+        
+        # 6. Mostrar resultados previos o mensaje inicial
         elif 'semantic_result' in st.session_state and st.session_state.semantic_result is not None:
+            # Mostrar mensaje sobre el análisis actual
+            st.info(
+                semantic_t.get('current_analysis_message', 
+                f'Mostrando análisis del archivo: {st.session_state.semantic_state["current_file"]}. '
+                'Para realizar un nuevo análisis, cargue otro archivo.')
+            )
+            
             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'))
+            st.info(semantic_t.get('upload_prompt', 'Cargue un archivo para comenzar el análisis'))
 
     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.")
+        st.error(semantic_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
 
 #######################################
 def display_semantic_results(semantic_result, lang_code, semantic_t):