Update modules/semantic/semantic_interface.py

modules/semantic/semantic_interface.py

@@ -1,89 +1,148 @@
-# Importaciones generales
+#modules/semantic/semantic_interface.py
 import streamlit as st
-import re
+from streamlit_float import *
+from streamlit_antd_components import *
+from streamlit.components.v1 import html
 import io
 from io import BytesIO
 import base64
 import matplotlib.pyplot as plt
-import plotly.graph_objects as go
 import pandas as pd
-import numpy as np
-import time
-from datetime import datetime
-from streamlit_player import st_player  # Necesitarás instalar esta librería: pip install streamlit-player
-from spacy import displacy
-import logging
-import random
+import re
 
+from .semantic_process import (
+    process_semantic_input,
+    format_semantic_results
+)
 
 from ..utils.widget_utils import generate_unique_key
-
-from ..database.morphosintax_mongo_db import store_student_morphosyntax_result
-from ..database.chat_db import store_chat_history
-from ..database.morphosintaxis_export import export_user_interactions
+from ..database.semantic_mongo_db import store_student_semantic_result
+from ..database.semantics_export import export_user_interactions
 
 import logging
 logger = logging.getLogger(__name__)
 
-
-def display_semantic_analysis_interface(nlp_models, lang_code):
-
-    t = translations[lang_code]
-
-    st.header(t['title'])
-
-    # Opción para introducir texto
+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
+    """
+    # 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 contador de análisis si no existe
+    if 'semantic_analysis_counter' not in st.session_state:
+        st.session_state.semantic_analysis_counter = 0
+
+    # Campo de entrada de texto
     text_input = st.text_area(
-        t['text_input_label'],
+        semantic_t.get('text_input_label', 'Enter text to analyze'),
         height=150,
-        placeholder=t['text_input_placeholder'],
+        placeholder=semantic_t.get('text_input_placeholder', 'Enter your text here...'),
+        value=st.session_state[input_key],
+        key=f"text_area_{lang_code}_{st.session_state.semantic_analysis_counter}"
     )
 
     # Opción para cargar archivo
-    uploaded_file = st.file_uploader(t['file_uploader'], type=['txt'])
+    uploaded_file = st.file_uploader(
+        semantic_t.get('file_uploader', 'Or upload a text file'),
+        type=['txt'],
+        key=f"file_uploader_{lang_code}_{st.session_state.semantic_analysis_counter}"
+    )
 
-    if st.button(t['analyze_button']):
+    if st.button(
+        semantic_t.get('analyze_button', 'Analyze text'),
+        key=f"analyze_button_{lang_code}_{st.session_state.semantic_analysis_counter}"
+    ):
         if text_input or uploaded_file is not None:
-            if uploaded_file:
-                text_content = uploaded_file.getvalue().decode('utf-8')
-            else:
-                text_content = text_input
-
-            # Realizar el análisis
-            analysis_result = perform_semantic_analysis(text_content, nlp_models[lang_code], lang_code)
-
-            # Guardar el resultado en el estado de la sesión
-            st.session_state.semantic_result = analysis_result
-
-            # Mostrar resultados
-            display_semantic_results(st.session_state.semantic_result, lang_code, t)           
-
-            # Guardar el resultado del análisis
-            if store_semantic_result(st.session_state.username, text_content, analysis_result):
-                st.success(t['success_message'])
-            else:
-                st.error(t['error_message'])
+            try:
+                with st.spinner(semantic_t.get('processing', 'Processing...')):
+                    # Obtener el texto a analizar
+                    text_content = uploaded_file.getvalue().decode('utf-8') if uploaded_file else text_input
+                    
+                    # Realizar el análisis
+                    analysis_result = process_semantic_input(
+                        text_content, 
+                        lang_code,
+                        nlp_models,
+                        semantic_t
+                    )
+                    
+                    # Guardar resultado en el estado de la sesión
+                    st.session_state.semantic_result = analysis_result
+                    st.session_state.semantic_analysis_counter += 1
+                    
+                    # Mostrar resultados
+                    display_semantic_results(
+                        st.session_state.semantic_result,
+                        lang_code,
+                        semantic_t
+                    )
+
+            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(t['warning_message'])
-
-    elif 'semantic_result' in st.session_state:
-
-        # Si hay un resultado guardado, mostrarlo
-        display_semantic_results(st.session_state.semantic_result, lang_code, t)
-    
-    else:
-        st.info(t['initial_message'])  # Asegúrate de que 'initial_message' esté en tus traducciones
+            st.warning(semantic_t.get('warning_message', 'Please enter text or upload a file'))
             
-def display_semantic_results(result, lang_code, t):
-    if result is None:
-        st.warning(t['no_results'])  # Asegúrate de que 'no_results' esté en tus traducciones
+    # Si no se presionó el botón, verificar si hay 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
+        )
+    else:
+        st.info(semantic_t.get('initial_message', 'Enter text to begin analysis'))
+
+def display_semantic_results(result, lang_code, semantic_t):
+    """
+    Muestra los resultados del análisis semántico
+    Args:
+        result: Resultados del análisis
+        lang_code: Código del idioma
+        semantic_t: Diccionario de traducciones
+    """
+    if result is None or not result['success']:
+        st.warning(semantic_t.get('no_results', 'No results available'))
         return
 
+    analysis = result['analysis']
+    
     # Mostrar conceptos clave
-    with st.expander(t['key_concepts'], expanded=True):
-        concept_text = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in result['key_concepts']])
+    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 el gráfico de relaciones conceptuales
-    with st.expander(t['conceptual_relations'], expanded=True):
-        st.pyplot(result['relations_graph'])
+    # 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')):
+        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"
+        )