#modules/semantic/semantic_interface.py
import streamlit as st
from streamlit_float import *
from streamlit_antd_components import *
from streamlit.components.v1 import html
import spacy_streamlit
import io
from io import BytesIO
import base64
import matplotlib.pyplot as plt
import pandas as pd
import re
import logging
# Configuración del logger
logger = logging.getLogger(__name__)
# Importaciones locales
from .semantic_process import (
process_semantic_input,
format_semantic_results
)
from ..utils.widget_utils import generate_unique_key
from ..database.semantic_mongo_db import store_student_semantic_result
from ..database.chat_mongo_db import store_chat_history, get_chat_history
# 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
"""
try:
# 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. Á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_state['analysis_count']}"
)
# 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'),
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
)
# 5. Procesar análisis
if analyze_button and uploaded_file is not None:
try:
with st.spinner(semantic_t.get('processing', 'Processing...')):
# Leer contenido del archivo
text_content = uploaded_file.getvalue().decode('utf-8')
# Realizar análisis
analysis_result = process_semantic_input(
text_content,
lang_code,
nlp_models,
semantic_t
)
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
# 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(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)}'))
# 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
)
else:
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(semantic_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
#######################################
def display_semantic_results(semantic_result, lang_code, semantic_t):
"""
Muestra los resultados del análisis semántico en tabs
Args:
semantic_result: Diccionario con los resultados del análisis
lang_code: Código del idioma actual
semantic_t: Diccionario de traducciones semánticas
"""
# Verificar resultado usando el nombre correcto de la variable
if semantic_result is None or not semantic_result['success']:
st.warning(semantic_t.get('no_results', 'No results available'))
return
# Usar semantic_result en lugar de result
analysis = semantic_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'))
if 'key_concepts' in analysis:
concept_text = "\n".join([
f"• {concept} ({frequency:.2f})"
for concept, frequency in analysis['key_concepts']
])
st.markdown(concept_text)
else:
st.info(semantic_t.get('no_concepts', 'No key concepts found'))
# Columna 2: Gráfico de conceptos
with col2:
st.subheader(semantic_t.get('concept_graph', 'Concepts Graph'))
if 'concept_graph' in analysis:
st.image(analysis['concept_graph'])
else:
st.info(semantic_t.get('no_graph', 'No concept graph available'))
# 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))
else:
st.info(semantic_t.get('no_entities', 'No entities found'))
# Columna 2: Gráfico de entidades
with col2:
st.subheader(semantic_t.get('entity_graph', 'Entities Graph'))
if 'entity_graph' in analysis:
st.image(analysis['entity_graph'])
else:
st.info(semantic_t.get('no_entity_graph', 'No entity graph available'))
'''
# Botón de exportación al final
if 'semantic_analysis_counter' in st.session_state:
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}"
)
'''