Update modules/semantic/semantic_interface.py

modules/semantic/semantic_interface.py

@@ -26,6 +26,9 @@ from ..database.semantic_mongo_db import store_student_semantic_result
 from ..database.semantic_export import export_user_interactions
 
 
+#modules/semantic/semantic_interface.py
+# [Mantener las importaciones igual...]
+
 def display_semantic_interface(lang_code, nlp_models, semantic_t):
     """
     Interfaz para el análisis semántico
@@ -35,75 +38,64 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
         semantic_t: Diccionario de traducciones semánticas
     """
     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] = ""
-            
+        # Inicializar el estado si no existe
         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'),
+            semantic_t.get('file_uploader', 'Upload a text file for analysis'),
             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}"
-        )
+        col1, col2, col3 = st.columns([2,1,2])
+        with col2:
+            analyze_button = st.button(
+                semantic_t.get('analyze_button', 'Analyze text'),
+                key=f"semantic_analyze_button_{st.session_state.semantic_analysis_counter}",
+                use_container_width=True
+            )
 
-        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 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
                         
-                        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'))
+                        # 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'))
+                            # Mostrar resultados
+                            display_semantic_results(
+                                analysis_result,
+                                lang_code,
+                                semantic_t
+                            )
                         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'))
+                            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)}'))
+        elif analyze_button:
+            st.warning(semantic_t.get('warning_message', 'Please upload a file first'))
         
         # Mostrar resultados previos
         elif 'semantic_result' in st.session_state and st.session_state.semantic_result is not None:
@@ -113,7 +105,7 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
                 semantic_t
             )
         else:
-            st.info(semantic_t.get('initial_message', 'Enter text to begin analysis'))
+            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)}")
@@ -121,7 +113,7 @@ def display_semantic_interface(lang_code, nlp_models, semantic_t):
 
 def display_semantic_results(result, lang_code, semantic_t):
     """
-    Muestra los resultados del análisis semántico
+    Muestra los resultados del análisis semántico en tabs
     """
     if result is None or not result['success']:
         st.warning(semantic_t.get('no_results', 'No results available'))
@@ -129,37 +121,60 @@ def display_semantic_results(result, lang_code, semantic_t):
 
     analysis = result['analysis']
     
-    # 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}"
-        )
+    # 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'])
+
+    # Botón de exportación al final
+    col1, col2, col3 = st.columns([2,1,2])
+    with col2:
+        if st.button(
+            semantic_t.get('export_button', 'Export Analysis'), 
+            key=f"semantic_export_{st.session_state.semantic_analysis_counter}",
+            use_container_width=True
+        ):
+            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}"
+            )