Update modules/semantic/semantic_interface.py

modules/semantic/semantic_interface.py

@@ -28,137 +28,95 @@ 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
     """
-    # Mantener la página actual
-    st.session_state.page = 'semantic'
-
-    # Inicializar estados si no existen
-    if 'semantic_has_file' not in st.session_state:
-        st.session_state.semantic_has_file = False
-    if 'semantic_result' not in st.session_state:
-        st.session_state.semantic_result = None
-
-    # Estilos para los botones
-    st.markdown("""
-        <style>
-        .stButton button {
-            width: 100%;
-            height: 38px;
-        }
-        </style>
-    """, unsafe_allow_html=True)
-
-    # Contenedor principal para controles
-    with st.container():
-        col_upload, col_analyze, col_export, col_new = st.columns([4,2,2,2])
-        
-        # Columna para carga de archivo
-        with col_upload:
-            uploaded_file = st.file_uploader(
-                semantic_t.get('file_uploader', 'Upload text file'),
-                type=['txt'],
-                key="semantic_file_uploader"
-            )
-            # Actualizar estado cuando se carga un archivo
-            if uploaded_file is not None:
-                st.session_state.semantic_has_file = True
-                if 'file_content' not in st.session_state or st.session_state.file_content != uploaded_file:
-                    st.session_state.file_content = uploaded_file
-                    st.session_state.semantic_result = None  # Resetear resultado si el archivo cambia
-            else:
-                st.session_state.semantic_has_file = False
-
-        # Columna para botón de análisis
-        with col_analyze:
-            analyze_disabled = not st.session_state.semantic_has_file
-            analyze_button = st.button(
-                semantic_t.get('semantic_analyze_button', 'Analyze'),
-                disabled=analyze_disabled,
-                key="semantic_analysis_button",
-                use_container_width=True
-            )
-
-        # Columna para botón de exportación
-        with col_export:
-            export_disabled = st.session_state.semantic_result is None
-            export_button = st.button(
-                semantic_t.get('semantic_export_button', 'Export'),
-                disabled=export_disabled,
-                key="semantic_export_button",
-                use_container_width=True
-            )
-
-        # Columna para botón de nuevo análisis
-        with col_new:
-            new_disabled = not st.session_state.semantic_has_file
-            new_button = st.button(
-                semantic_t.get('semantic_new_button', 'New'),
-                disabled=new_disabled,
-                key="semantic_new_button",
-                use_container_width=True
-            )
-
-    st.markdown("---")
-
-    # Procesar análisis
-    if analyze_button and uploaded_file is not None:
-        try:
-            text_content = uploaded_file.getvalue().decode('utf-8')
+    try:
+        # Inicializar el estado de la entrada
+        input_key = f"semantic_input_{lang_code}"
+        if input_key not in st.session_state:
+            st.session_state[input_key] = ""
             
-            with st.spinner(semantic_t.get('processing', 'Processing...')):
-                analysis_result = perform_semantic_analysis(
-                    text_content,
-                    nlp_models[lang_code],
-                    lang_code
-                )
-                
-                if analysis_result['success']:
-                    st.session_state.semantic_result = analysis_result
-                    
-                    # Guardar en base de datos
-                    if store_student_semantic_result(
-                        st.session_state.username,
-                        text_content,
-                        analysis_result
-                    ):
-                        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(analysis_result['message'])
-                    
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
-
-    # Manejar exportación
-    if export_button and st.session_state.semantic_result is not None:
-        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="semantic_download_button"
+        if 'semantic_analysis_counter' not in st.session_state:
+            st.session_state.semantic_analysis_counter = 0
+
+        # Campo de entrada de texto con key única
+        text_input = st.text_area(
+            semantic_t.get('text_input_label', 'Enter text to analyze'),
+            height=150,
+            placeholder=semantic_t.get('text_input_placeholder', 'Enter your text here...'),
+            value=st.session_state[input_key],
+            key=f"semantic_text_area_{st.session_state.semantic_analysis_counter}"
+        )
+
+        # Opción para cargar archivo con key única
+        uploaded_file = st.file_uploader(
+            semantic_t.get('file_uploader', 'Or upload a text file'),
+            type=['txt'],
+            key=f"semantic_file_uploader_{st.session_state.semantic_analysis_counter}"
+        )
+
+        # Botón de análisis con key única
+        analyze_button = st.button(
+            semantic_t.get('analyze_button', 'Analyze text'),
+            key=f"semantic_analyze_button_{st.session_state.semantic_analysis_counter}"
+        )
+
+        if analyze_button:
+            if text_input or uploaded_file is not None:
+                try:
+                    with st.spinner(semantic_t.get('processing', 'Processing...')):
+                        text_content = uploaded_file.getvalue().decode('utf-8') if uploaded_file else text_input
+                        
+                        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
+                            
+                            # Guardar en la base de datos antes de mostrar resultados
+                            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'))
+                        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)}'))
+            else:
+                st.warning(semantic_t.get('warning_message', 'Please enter text or upload a file'))
+        
+        # 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
             )
-        except Exception as e:
-            st.error(f"Error exporting: {str(e)}")
-
-    # Manejar nuevo análisis
-    if new_button:
-        st.session_state.semantic_result = None
-        st.session_state.semantic_has_file = False
-        st.session_state.file_content = None
-        st.rerun()
-
-    # Mostrar resultados o mensaje inicial
-    if st.session_state.semantic_result is not None:
-        display_semantic_results(st.session_state.semantic_result, lang_code, semantic_t)
-    elif not st.session_state.semantic_has_file:
-        st.info(semantic_t.get('initial_message', 'Upload a file to begin analysis'))
+        else:
+            st.info(semantic_t.get('initial_message', 'Enter text 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.")
 
 def display_semantic_results(result, lang_code, semantic_t):
     """
@@ -170,43 +128,37 @@ def display_semantic_results(result, lang_code, semantic_t):
 
     analysis = result['analysis']
     
-    # Crear tabs para los resultados
-    tab1, tab2 = st.tabs([
-        semantic_t.get('concepts_tab', 'Key Concepts Analysis'),
-        semantic_t.get('entities_tab', 'Entities Analysis')
-    ])
-    
-    # Tab 1: Conceptos Clave
-    with tab1:
-        col1, col2 = st.columns(2)
-        
-        # Columna 1: Lista de conceptos
-        with col1:
-            st.subheader(semantic_t.get('key_concepts', 'Key Concepts'))
-            concept_text = "\n".join([
-                f"• {concept} ({frequency:.2f})" 
-                for concept, frequency in analysis['key_concepts']
-            ])
-            st.markdown(concept_text)
-        
-        # Columna 2: Gráfico de conceptos
-        with col2:
-            st.subheader(semantic_t.get('concept_graph', 'Concepts Graph'))
-            st.image(analysis['concept_graph'])
-    
-    # Tab 2: Entidades
-    with tab2:
-        col1, col2 = st.columns(2)
-        
-        # Columna 1: Lista de entidades
-        with col1:
-            st.subheader(semantic_t.get('identified_entities', 'Identified Entities'))
-            if 'entities' in analysis:
-                for entity_type, entities in analysis['entities'].items():
-                    st.markdown(f"**{entity_type}**")
-                    st.markdown("• " + "\n• ".join(entities))
-        
-        # Columna 2: Gráfico de entidades
-        with col2:
-            st.subheader(semantic_t.get('entity_graph', 'Entities Graph'))
-            st.image(analysis['entity_graph'])
+    # Mostrar conceptos clave
+    with st.expander(semantic_t.get('key_concepts', 'Key Concepts'), expanded=True):
+        concept_text = " | ".join([
+            f"{concept} ({frequency:.2f})" 
+            for concept, frequency in analysis['key_concepts']
+        ])
+        st.write(concept_text)
+
+    # Mostrar gráfico de relaciones conceptuales
+    with st.expander(semantic_t.get('conceptual_relations', 'Conceptual Relations'), expanded=True):
+        st.image(analysis['concept_graph'])
+
+    # Mostrar gráfico de entidades
+    with st.expander(semantic_t.get('entity_relations', 'Entity Relations'), expanded=True):
+        st.image(analysis['entity_graph'])
+
+    # Mostrar entidades identificadas
+    if 'entities' in analysis:
+        with st.expander(semantic_t.get('identified_entities', 'Identified Entities'), expanded=True):
+            for entity_type, entities in analysis['entities'].items():
+                st.subheader(entity_type)
+                st.write(", ".join(entities))
+
+    # Botón de exportación
+    if st.button(semantic_t.get('export_button', 'Export Analysis'), 
+                key=f"semantic_export_{st.session_state.semantic_analysis_counter}"):
+        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}"
+        )