# modules/studentact/current_situation_interface.py
import streamlit as st
import logging
from ..utils.widget_utils import generate_unique_key
from .current_situation_analysis import (
analyze_text_dimensions,
create_vocabulary_network,
create_syntax_complexity_graph,
create_cohesion_heatmap
)
logger = logging.getLogger(__name__)
def display_current_situation_interface(lang_code, nlp_models, t):
"""
Interfaz modular para el análisis de la situación actual del estudiante.
Esta función maneja la presentación y la interacción con el usuario.
Args:
lang_code: Código del idioma actual
nlp_models: Diccionario de modelos de spaCy cargados
t: Diccionario de traducciones
"""
st.markdown("## Mi Situación Actual de Escritura")
# Container principal para mejor organización visual
with st.container():
# Columnas para entrada y visualización
text_col, visual_col = st.columns([1,2])
with text_col:
# Área de entrada de texto
text_input = st.text_area(
t.get('current_situation_input', "Ingresa tu texto para analizar:"),
height=400,
key=generate_unique_key("current_situation", "input")
)
# Botón de análisis
if st.button(
t.get('analyze_button', "Explorar mi escritura"),
type="primary",
disabled=not text_input,
key=generate_unique_key("current_situation", "analyze")
):
try:
with st.spinner(t.get('processing', "Analizando texto...")):
# 1. Procesar el texto
doc = nlp_models[lang_code](text_input)
metrics = analyze_text_dimensions(doc)
# 2. Mostrar visualizaciones en la columna derecha
with visual_col:
display_current_situation_visual(doc, metrics)
# 3. Obtener retroalimentación de Claude
feedback = get_claude_feedback(metrics, text_input)
# 4. Guardar los resultados
from ..database.current_situation_mongo_db import store_current_situation_result
if st.button(t.get('analyze_button', "Explorar mi escritura")):
with st.spinner(t.get('processing', "Analizando texto...")):
# Procesar y analizar
doc = nlp_models[lang_code](text_input)
# Obtener métricas con manejo de errores
try:
metrics = analyze_text_dimensions(doc)
except Exception as e:
logger.error(f"Error en análisis: {str(e)}")
st.error("Error en el análisis de dimensiones")
return
# Obtener feedback
try:
feedback = get_claude_feedback(metrics, text_input)
except Exception as e:
logger.error(f"Error obteniendo feedback: {str(e)}")
st.error("Error obteniendo retroalimentación")
return
# Guardar resultados con verificación
if store_current_situation_result(
st.session_state.username,
text_input,
metrics,
feedback
):
st.success(t.get('save_success', "Análisis guardado"))
# Mostrar visualizaciones y recomendaciones
display_current_situation_visual(doc, metrics)
show_recommendations(feedback, t)
else:
st.error("Error al guardar el análisis")
except Exception as e:
logger.error(f"Error en interfaz: {str(e)}")
st.error("Error general en la interfaz")
################################################################
def display_current_situation_visual(doc, metrics):
"""Visualización mejorada de resultados con interpretaciones"""
try:
with st.container():
# Estilos CSS mejorados para los contenedores
st.markdown("""
<style>
.graph-container {
background-color: white;
border-radius: 10px;
padding: 20px;
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
margin: 15px 0;
}
.interpretation-box {
background-color: #f8f9fa;
border-left: 4px solid #0d6efd;
padding: 15px;
margin: 10px 0;
}
.metric-indicator {
font-size: 1.2em;
font-weight: 500;
color: #1f2937;
}
</style>
""", unsafe_allow_html=True)
# 1. Riqueza de Vocabulario
with st.expander("📚 Riqueza de Vocabulario", expanded=True):
st.markdown('<div class="graph-container">', unsafe_allow_html=True)
vocabulary_graph = create_vocabulary_network(doc)
if vocabulary_graph:
# Mostrar gráfico
st.pyplot(vocabulary_graph)
plt.close(vocabulary_graph)
# Interpretación
st.markdown('<div class="interpretation-box">', unsafe_allow_html=True)
st.markdown("**¿Qué significa este gráfico?**")
st.markdown("""
- 🔵 Los nodos azules representan palabras clave en tu texto
- 📏 El tamaño de cada nodo indica su frecuencia de uso
- 🔗 Las líneas conectan palabras que aparecen juntas frecuentemente
- 🎨 Los colores más intensos indican palabras más centrales
""")
st.markdown("</div>", unsafe_allow_html=True)
st.markdown("</div>", unsafe_allow_html=True)
# 2. Estructura de Oraciones
with st.expander("🏗️ Complejidad Estructural", expanded=True):
st.markdown('<div class="graph-container">', unsafe_allow_html=True)
syntax_graph = create_syntax_complexity_graph(doc)
if syntax_graph:
st.pyplot(syntax_graph)
plt.close(syntax_graph)
st.markdown('<div class="interpretation-box">', unsafe_allow_html=True)
st.markdown("**Análisis de la estructura:**")
st.markdown("""
- 📊 Las barras muestran la complejidad de cada oración
- 📈 Mayor altura indica estructuras más elaboradas
- 🎯 La línea punteada indica el nivel óptimo de complejidad
- 🔄 Variación en las alturas sugiere dinamismo en la escritura
""")
st.markdown("</div>", unsafe_allow_html=True)
st.markdown("</div>", unsafe_allow_html=True)
# 3. Cohesión Textual
with st.expander("🔄 Cohesión del Texto", expanded=True):
st.markdown('<div class="graph-container">', unsafe_allow_html=True)
cohesion_map = create_cohesion_heatmap(doc)
if cohesion_map:
st.pyplot(cohesion_map)
plt.close(cohesion_map)
st.markdown('<div class="interpretation-box">', unsafe_allow_html=True)
st.markdown("**¿Cómo leer el mapa de calor?**")
st.markdown("""
- 🌈 Colores más intensos indican mayor conexión entre oraciones
- 📝 La diagonal muestra la coherencia interna de cada oración
- 🔗 Las zonas claras sugieren oportunidades de mejorar conexiones
- 🎯 Un buen texto muestra patrones de color consistentes
""")
st.markdown("</div>", unsafe_allow_html=True)
st.markdown("</div>", unsafe_allow_html=True)
# 4. Métricas Generales
with st.expander("📊 Resumen de Métricas", expanded=True):
col1, col2, col3 = st.columns(3)
with col1:
st.metric(
"Diversidad Léxica",
f"{metrics['vocabulary_richness']:.2f}/1.0",
help="Mide la variedad de palabras diferentes utilizadas"
)
with col2:
st.metric(
"Complejidad Estructural",
f"{metrics['structural_complexity']:.2f}/1.0",
help="Indica qué tan elaboradas son las estructuras de las oraciones"
)
with col3:
st.metric(
"Cohesión Textual",
f"{metrics['cohesion_score']:.2f}/1.0",
help="Evalúa qué tan bien conectadas están las ideas entre sí"
)
except Exception as e:
logger.error(f"Error en visualización: {str(e)}")
st.error("Error al generar las visualizaciones")
################################################################
def show_recommendations(feedback, t):
"""
Muestra las recomendaciones y ejercicios personalizados para el estudiante,
permitiendo el seguimiento de su progreso.
Args:
feedback: Diccionario con retroalimentación y ejercicios recomendados
t: Diccionario de traducciones
"""
st.markdown("### " + t.get('recommendations_title', "Recomendaciones para mejorar"))
for area, exercises in feedback['recommendations'].items():
with st.expander(f"💡 {area}"):
try:
# Descripción del área de mejora
st.markdown(exercises['description'])
# Obtener el historial de ejercicios del estudiante
from ..database.current_situation_mongo_db import get_student_exercises_history
exercises_history = get_student_exercises_history(st.session_state.username)
# Separar ejercicios en completados y pendientes
completed = exercises_history.get(area, [])
# Mostrar estado actual
progress_col1, progress_col2 = st.columns([3,1])
with progress_col1:
st.markdown("**Ejercicio sugerido:**")
st.markdown(exercises['activity'])
with progress_col2:
# Verificar si el ejercicio ya está completado
exercise_key = f"{area}_{exercises['activity']}"
is_completed = exercise_key in completed
if is_completed:
st.success("✅ Completado")
else:
# Botón para marcar ejercicio como completado
if st.button(
t.get('mark_complete', "Marcar como completado"),
key=generate_unique_key("exercise", area),
type="primary"
):
try:
from ..database.current_situation_mongo_db import update_exercise_status
# Actualizar estado del ejercicio
success = update_exercise_status(
username=st.session_state.username,
area=area,
exercise=exercises['activity'],
completed=True
)
if success:
st.success(t.get(
'exercise_completed',
"¡Ejercicio marcado como completado!"
))
st.rerun()
else:
st.error(t.get(
'exercise_error',
"Error al actualizar el estado del ejercicio"
))
except Exception as e:
logger.error(f"Error actualizando estado del ejercicio: {str(e)}")
st.error(t.get('update_error', "Error al actualizar el ejercicio"))
# Mostrar recursos adicionales si existen
if 'resources' in exercises:
st.markdown("**Recursos adicionales:**")
for resource in exercises['resources']:
st.markdown(f"- {resource}")
# Mostrar fecha de finalización si está completado
if is_completed:
completion_date = exercises_history[exercise_key].get('completion_date')
if completion_date:
st.caption(
t.get('completed_on', "Completado el") +
f": {completion_date.strftime('%d/%m/%Y %H:%M')}"
)
except Exception as e:
logger.error(f"Error mostrando recomendaciones para {area}: {str(e)}")
st.error(t.get(
'recommendations_error',
f"Error al mostrar las recomendaciones para {area}"
))