|
|
|
|
|
import streamlit as st
|
|
import re
|
|
import io
|
|
from io import BytesIO
|
|
import pandas as pd
|
|
import numpy as np
|
|
import time
|
|
import matplotlib.pyplot as plt
|
|
from datetime import datetime
|
|
from spacy import displacy
|
|
import random
|
|
import base64
|
|
import seaborn as sns
|
|
import logging
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
def display_student_progress(username, lang_code, t, student_data):
|
|
if not student_data or len(student_data['entries']) == 0:
|
|
st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
|
|
st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
|
|
return
|
|
|
|
st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
|
|
|
|
with st.expander(t.get("activities_summary", "Resumen de Actividades y Progreso"), expanded=True):
|
|
total_entries = len(student_data['entries'])
|
|
st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
|
|
|
|
|
|
analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
|
|
analysis_counts = pd.Series(analysis_types).value_counts()
|
|
|
|
fig, ax = plt.subplots(figsize=(8, 4))
|
|
analysis_counts.plot(kind='bar', ax=ax)
|
|
ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
|
|
ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
|
|
ax.set_ylabel(t.get("count", "Cantidad"))
|
|
st.pyplot(fig)
|
|
|
|
|
|
with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
|
|
morphosyntax_entries = [entry for entry in username['entries'] if entry['analysis_type'] == 'morphosyntax']
|
|
if not morphosyntax_entries:
|
|
st.warning("No se encontraron análisis morfosintácticos.")
|
|
for entry in morphosyntax_entries:
|
|
st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
|
|
if 'arc_diagrams' in entry and entry['arc_diagrams']:
|
|
try:
|
|
st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
|
|
except Exception as e:
|
|
logger.error(f"Error al mostrar diagrama de arco: {str(e)}")
|
|
st.error("Error al mostrar el diagrama de arco.")
|
|
else:
|
|
st.write(t.get("no_arc_diagram", "No se encontró diagrama de arco para este análisis."))
|
|
|
|
|
|
with st.expander(t.get("semantic_history", "Histórico de Análisis Semánticos")):
|
|
semantic_entries = [entry for entry in username['entries'] if entry['analysis_type'] == 'semantic']
|
|
if not semantic_entries:
|
|
st.warning("No se encontraron análisis semánticos.")
|
|
for entry in semantic_entries:
|
|
st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
|
|
if 'key_concepts' in entry:
|
|
st.write(t.get("key_concepts", "Conceptos clave:"))
|
|
concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts']])
|
|
st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
|
|
if 'graph' in entry:
|
|
try:
|
|
img_bytes = base64.b64decode(entry['graph'])
|
|
st.image(img_bytes, caption=t.get("conceptual_relations_graph", "Gráfico de relaciones conceptuales"))
|
|
except Exception as e:
|
|
logger.error(f"Error al mostrar gráfico semántico: {str(e)}")
|
|
st.error(t.get("graph_display_error", f"No se pudo mostrar el gráfico: {str(e)}"))
|
|
|
|
|
|
with st.expander(t.get("discourse_history", "Histórico de Análisis Discursivos")):
|
|
discourse_entries = [entry for entry in username['entries'] if entry['analysis_type'] == 'discourse']
|
|
for entry in discourse_entries:
|
|
st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
|
|
for i in [1, 2]:
|
|
if f'key_concepts{i}' in entry:
|
|
st.write(f"{t.get('key_concepts', 'Conceptos clave')} {t.get('document', 'documento')} {i}:")
|
|
concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry[f'key_concepts{i}']])
|
|
st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
|
|
try:
|
|
if 'combined_graph' in entry and entry['combined_graph']:
|
|
img_bytes = base64.b64decode(entry['combined_graph'])
|
|
st.image(img_bytes, caption=t.get("combined_graph", "Gráfico combinado"))
|
|
elif 'graph1' in entry and 'graph2' in entry:
|
|
col1, col2 = st.columns(2)
|
|
with col1:
|
|
if entry['graph1']:
|
|
img_bytes1 = base64.b64decode(entry['graph1'])
|
|
st.image(img_bytes1, caption=t.get("graph_doc1", "Gráfico documento 1"))
|
|
with col2:
|
|
if entry['graph2']:
|
|
img_bytes2 = base64.b64decode(entry['graph2'])
|
|
st.image(img_bytes2, caption=t.get("graph_doc2", "Gráfico documento 2"))
|
|
except Exception as e:
|
|
st.error(t.get("graph_display_error", f"No se pudieron mostrar los gráficos: {str(e)}"))
|
|
|
|
|
|
with st.expander(t.get("chatbot_history", "Histórico de Conversaciones con el ChatBot")):
|
|
if 'chat_history' in username and username['chat_history']:
|
|
for i, chat in enumerate(username['chat_history']):
|
|
st.subheader(f"{t.get('conversation', 'Conversación')} {i+1} - {chat['timestamp']}")
|
|
for message in chat['messages']:
|
|
if message['role'] == 'user':
|
|
st.write(f"{t.get('user', 'Usuario')}: {message['content']}")
|
|
else:
|
|
st.write(f"{t.get('assistant', 'Asistente')}: {message['content']}")
|
|
st.write("---")
|
|
else:
|
|
st.write(t.get("no_chat_history", "No se encontraron conversaciones con el ChatBot."))
|
|
|
|
|
|
if st.checkbox(t.get("show_debug_data", "Mostrar datos de depuración")):
|
|
st.write(t.get("student_debug_data", "Datos del estudiante (para depuración):"))
|
|
st.json(username)
|
|
|
|
|
|
analysis_types = [entry['analysis_type'] for entry in username['entries']]
|
|
type_counts = {t: analysis_types.count(t) for t in set(analysis_types)}
|
|
st.write("Conteo de tipos de análisis:")
|
|
st.write(type_counts)
|
|
|
|
|
|
|
|
|
|
'''
|
|
##########versión 25-9-2024---02:30 ################ OK (username)####################
|
|
|
|
def display_student_progress(username, lang_code, t, student_data):
|
|
st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
|
|
|
|
if not student_data or len(student_data.get('entries', [])) == 0:
|
|
st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
|
|
st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
|
|
return
|
|
|
|
with st.expander(t.get("activities_summary", "Resumen de Actividades"), expanded=True):
|
|
total_entries = len(student_data['entries'])
|
|
st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
|
|
|
|
# Gráfico de tipos de análisis
|
|
analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
|
|
analysis_counts = pd.Series(analysis_types).value_counts()
|
|
fig, ax = plt.subplots()
|
|
analysis_counts.plot(kind='bar', ax=ax)
|
|
ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
|
|
ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
|
|
ax.set_ylabel(t.get("count", "Cantidad"))
|
|
st.pyplot(fig)
|
|
|
|
# Mostrar los últimos análisis morfosintácticos
|
|
with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
|
|
morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
|
|
for entry in morphosyntax_entries[:5]: # Mostrar los últimos 5
|
|
st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
|
|
if 'arc_diagrams' in entry and entry['arc_diagrams']:
|
|
st.components.v1.html(entry['arc_diagrams'][0], height=300, scrolling=True)
|
|
|
|
# Añadir secciones similares para análisis semánticos y discursivos si es necesario
|
|
|
|
# Mostrar el historial de chat
|
|
with st.expander(t.get("chat_history", "Historial de Chat")):
|
|
if 'chat_history' in student_data:
|
|
for chat in student_data['chat_history'][:5]: # Mostrar las últimas 5 conversaciones
|
|
st.subheader(f"{t.get('chat_from', 'Chat del')} {chat['timestamp']}")
|
|
for message in chat['messages']:
|
|
st.write(f"{message['role'].capitalize()}: {message['content']}")
|
|
st.write("---")
|
|
else:
|
|
st.write(t.get("no_chat_history", "No hay historial de chat disponible."))
|
|
|
|
|
|
##########versión 24-9-2024---17:30 ################ OK FROM--V2 de def get_student_data(username)####################
|
|
|
|
def display_student_progress(username, lang_code, t, student_data):
|
|
if not student_data or len(student_data['entries']) == 0:
|
|
st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
|
|
st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
|
|
return
|
|
|
|
st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
|
|
|
|
with st.expander(t.get("activities_summary", "Resumen de Actividades y Progreso"), expanded=True):
|
|
total_entries = len(student_data['entries'])
|
|
st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
|
|
|
|
# Gráfico de tipos de análisis
|
|
analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
|
|
analysis_counts = pd.Series(analysis_types).value_counts()
|
|
|
|
fig, ax = plt.subplots(figsize=(8, 4))
|
|
analysis_counts.plot(kind='bar', ax=ax)
|
|
ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
|
|
ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
|
|
ax.set_ylabel(t.get("count", "Cantidad"))
|
|
st.pyplot(fig)
|
|
|
|
# Histórico de Análisis Morfosintácticos
|
|
with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
|
|
morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
|
|
if not morphosyntax_entries:
|
|
st.warning("No se encontraron análisis morfosintácticos.")
|
|
for entry in morphosyntax_entries:
|
|
st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
|
|
if 'arc_diagrams' in entry and entry['arc_diagrams']:
|
|
try:
|
|
st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
|
|
except Exception as e:
|
|
logger.error(f"Error al mostrar diagrama de arco: {str(e)}")
|
|
st.error("Error al mostrar el diagrama de arco.")
|
|
else:
|
|
st.write(t.get("no_arc_diagram", "No se encontró diagrama de arco para este análisis."))
|
|
|
|
# Histórico de Análisis Semánticos
|
|
with st.expander(t.get("semantic_history", "Histórico de Análisis Semánticos")):
|
|
semantic_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
|
|
if not semantic_entries:
|
|
st.warning("No se encontraron análisis semánticos.")
|
|
for entry in semantic_entries:
|
|
st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
|
|
if 'key_concepts' in entry:
|
|
st.write(t.get("key_concepts", "Conceptos clave:"))
|
|
concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts']])
|
|
st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
|
|
if 'graph' in entry:
|
|
try:
|
|
img_bytes = base64.b64decode(entry['graph'])
|
|
st.image(img_bytes, caption=t.get("conceptual_relations_graph", "Gráfico de relaciones conceptuales"))
|
|
except Exception as e:
|
|
logger.error(f"Error al mostrar gráfico semántico: {str(e)}")
|
|
st.error(t.get("graph_display_error", f"No se pudo mostrar el gráfico: {str(e)}"))
|
|
|
|
# Histórico de Análisis Discursivos
|
|
with st.expander(t.get("discourse_history", "Histórico de Análisis Discursivos")):
|
|
discourse_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
|
|
for entry in discourse_entries:
|
|
st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
|
|
for i in [1, 2]:
|
|
if f'key_concepts{i}' in entry:
|
|
st.write(f"{t.get('key_concepts', 'Conceptos clave')} {t.get('document', 'documento')} {i}:")
|
|
concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry[f'key_concepts{i}']])
|
|
st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
|
|
try:
|
|
if 'combined_graph' in entry and entry['combined_graph']:
|
|
img_bytes = base64.b64decode(entry['combined_graph'])
|
|
st.image(img_bytes, caption=t.get("combined_graph", "Gráfico combinado"))
|
|
elif 'graph1' in entry and 'graph2' in entry:
|
|
col1, col2 = st.columns(2)
|
|
with col1:
|
|
if entry['graph1']:
|
|
img_bytes1 = base64.b64decode(entry['graph1'])
|
|
st.image(img_bytes1, caption=t.get("graph_doc1", "Gráfico documento 1"))
|
|
with col2:
|
|
if entry['graph2']:
|
|
img_bytes2 = base64.b64decode(entry['graph2'])
|
|
st.image(img_bytes2, caption=t.get("graph_doc2", "Gráfico documento 2"))
|
|
except Exception as e:
|
|
st.error(t.get("graph_display_error", f"No se pudieron mostrar los gráficos: {str(e)}"))
|
|
|
|
# Histórico de Conversaciones con el ChatBot
|
|
with st.expander(t.get("chatbot_history", "Histórico de Conversaciones con el ChatBot")):
|
|
if 'chat_history' in student_data and student_data['chat_history']:
|
|
for i, chat in enumerate(student_data['chat_history']):
|
|
st.subheader(f"{t.get('conversation', 'Conversación')} {i+1} - {chat['timestamp']}")
|
|
for message in chat['messages']:
|
|
if message['role'] == 'user':
|
|
st.write(f"{t.get('user', 'Usuario')}: {message['content']}")
|
|
else:
|
|
st.write(f"{t.get('assistant', 'Asistente')}: {message['content']}")
|
|
st.write("---")
|
|
else:
|
|
st.write(t.get("no_chat_history", "No se encontraron conversaciones con el ChatBot."))
|
|
|
|
# Añadir logs para depuración
|
|
if st.checkbox(t.get("show_debug_data", "Mostrar datos de depuración")):
|
|
st.write(t.get("student_debug_data", "Datos del estudiante (para depuración):"))
|
|
st.json(student_data)
|
|
|
|
# Mostrar conteo de tipos de análisis
|
|
analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
|
|
type_counts = {t: analysis_types.count(t) for t in set(analysis_types)}
|
|
st.write("Conteo de tipos de análisis:")
|
|
st.write(type_counts)
|
|
|
|
|
|
#############################--- Update 16:00 24-9 #########################################
|
|
def display_student_progress(username, lang_code, t, student_data):
|
|
try:
|
|
st.subheader(t.get('student_activities', 'Student Activitie'))
|
|
|
|
if not student_data or all(len(student_data.get(key, [])) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
|
|
st.warning(t.get('no_data_warning', 'No analysis data found for this student.'))
|
|
return
|
|
|
|
# Resumen de actividades
|
|
total_analyses = sum(len(student_data.get(key, [])) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
|
|
st.write(f"{t.get('total_analyses', 'Total analyses performed')}: {total_analyses}")
|
|
|
|
# Gráfico de tipos de análisis
|
|
analysis_counts = {
|
|
t.get('morpho_analyses', 'Morphosyntactic Analyses'): len(student_data.get('morphosyntax_analyses', [])),
|
|
t.get('semantic_analyses', 'Semantic Analyses'): len(student_data.get('semantic_analyses', [])),
|
|
t.get('discourse_analyses', 'Discourse Analyses'): len(student_data.get('discourse_analyses', []))
|
|
}
|
|
# Configurar el estilo de seaborn para un aspecto más atractivo
|
|
sns.set_style("whitegrid")
|
|
|
|
# Crear una figura más pequeña
|
|
fig, ax = plt.subplots(figsize=(6, 4))
|
|
|
|
# Usar colores más atractivos
|
|
colors = ['#ff9999', '#66b3ff', '#99ff99']
|
|
|
|
# Crear el gráfico de barras
|
|
bars = ax.bar(analysis_counts.keys(), analysis_counts.values(), color=colors)
|
|
|
|
# Añadir etiquetas de valor encima de cada barra
|
|
for bar in bars:
|
|
height = bar.get_height()
|
|
ax.text(bar.get_x() + bar.get_width()/2., height,
|
|
f'{height}',
|
|
ha='center', va='bottom')
|
|
|
|
# Configurar el título y las etiquetas
|
|
ax.set_title(t.get('analysis_types_chart', 'Types of analyses performed'), fontsize=12)
|
|
ax.set_ylabel(t.get('count', 'Count'), fontsize=10)
|
|
|
|
# Rotar las etiquetas del eje x para mejor legibilidad
|
|
plt.xticks(rotation=45, ha='right')
|
|
|
|
# Ajustar el diseño para que todo quepa
|
|
plt.tight_layout()
|
|
|
|
# Mostrar el gráfico en Streamlit
|
|
st.pyplot(fig)
|
|
|
|
# Mostrar los últimos análisis
|
|
for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
|
|
with st.expander(t.get(f'{analysis_type}_expander', f'{analysis_type.capitalize()} History')):
|
|
for analysis in student_data.get(analysis_type, [])[:5]: # Mostrar los últimos 5
|
|
st.subheader(f"{t.get('analysis_from', 'Analysis from')} {analysis.get('timestamp', 'N/A')}")
|
|
if analysis_type == 'morphosyntax_analyses':
|
|
if 'arc_diagrams' in analysis:
|
|
st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
|
|
elif analysis_type == 'semantic_analyses':
|
|
if 'key_concepts' in analysis:
|
|
st.write(t.get('key_concepts', 'Key concepts'))
|
|
st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
|
|
if 'graph' in analysis:
|
|
st.image(base64.b64decode(analysis['graph']))
|
|
elif analysis_type == 'discourse_analyses':
|
|
for i in [1, 2]:
|
|
if f'key_concepts{i}' in analysis:
|
|
st.write(f"{t.get('key_concepts', 'Key concepts')} {t.get('document', 'Document')} {i}")
|
|
st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
|
|
if 'combined_graph' in analysis:
|
|
st.image(base64.b64decode(analysis['combined_graph']))
|
|
|
|
# Mostrar el historial de chat
|
|
with st.expander(t.get('chat_history_expander', 'Chat History')):
|
|
for chat in student_data.get('chat_history', [])[:5]: # Mostrar las últimas 5 conversaciones
|
|
st.subheader(f"{t.get('chat_from', 'Chat from')} {chat.get('timestamp', 'N/A')}")
|
|
for message in chat.get('messages', []):
|
|
st.write(f"{message.get('role', 'Unknown').capitalize()}: {message.get('content', 'No content')}")
|
|
st.write("---")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in display_student_progress: {str(e)}", exc_info=True)
|
|
st.error(t.get('error_loading_progress', 'Error loading student progress. Please try again later.'))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#####################################################################
|
|
def display_student_progress(username, lang_code, t, student_data):
|
|
st.subheader(t['student_progress'])
|
|
|
|
if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
|
|
st.warning(t['no_data_warning'])
|
|
return
|
|
|
|
# Resumen de actividades
|
|
total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
|
|
st.write(f"{t['total_analyses']}: {total_analyses}")
|
|
|
|
# Gráfico de tipos de análisis
|
|
analysis_counts = {
|
|
t['morpho_analyses']: len(student_data['morphosyntax_analyses']),
|
|
t['semantic_analyses']: len(student_data['semantic_analyses']),
|
|
t['discourse_analyses']: len(student_data['discourse_analyses'])
|
|
}
|
|
fig, ax = plt.subplots()
|
|
ax.bar(analysis_counts.keys(), analysis_counts.values())
|
|
ax.set_title(t['analysis_types_chart'])
|
|
st.pyplot(fig)
|
|
|
|
# Mostrar los últimos análisis
|
|
for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
|
|
with st.expander(t[f'{analysis_type}_expander']):
|
|
for analysis in student_data[analysis_type][:5]: # Mostrar los últimos 5
|
|
st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
|
|
if analysis_type == 'morphosyntax_analyses':
|
|
if 'arc_diagrams' in analysis:
|
|
st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
|
|
elif analysis_type == 'semantic_analyses':
|
|
if 'key_concepts' in analysis:
|
|
st.write(t['key_concepts'])
|
|
st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
|
|
if 'graph' in analysis:
|
|
st.image(base64.b64decode(analysis['graph']))
|
|
elif analysis_type == 'discourse_analyses':
|
|
for i in [1, 2]:
|
|
if f'key_concepts{i}' in analysis:
|
|
st.write(f"{t['key_concepts']} {t['document']} {i}")
|
|
st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
|
|
if 'combined_graph' in analysis:
|
|
st.image(base64.b64decode(analysis['combined_graph']))
|
|
|
|
# Mostrar el historial de chat
|
|
with st.expander(t['chat_history_expander']):
|
|
for chat in student_data['chat_history'][:5]: # Mostrar las últimas 5 conversaciones
|
|
st.subheader(f"{t['chat_from']} {chat['timestamp']}")
|
|
for message in chat['messages']:
|
|
st.write(f"{message['role'].capitalize()}: {message['content']}")
|
|
st.write("---")
|
|
|
|
|
|
|
|
def display_student_progress(username, lang_code, t, student_data):
|
|
st.subheader(t['student_activities'])
|
|
|
|
if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
|
|
st.warning(t['no_data_warning'])
|
|
return
|
|
|
|
# Resumen de actividades
|
|
total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
|
|
st.write(f"{t['total_analyses']}: {total_analyses}")
|
|
|
|
# Gráfico de tipos de análisis
|
|
analysis_counts = {
|
|
t['morphological_analysis']: len(student_data['morphosyntax_analyses']),
|
|
t['semantic_analyses']: len(student_data['semantic_analyses']),
|
|
t['discourse_analyses']: len(student_data['discourse_analyses'])
|
|
}
|
|
fig, ax = plt.subplots()
|
|
ax.bar(analysis_counts.keys(), analysis_counts.values())
|
|
ax.set_title(t['analysis_types_chart'])
|
|
st.pyplot(fig)
|
|
|
|
# Mostrar los últimos análisis
|
|
for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
|
|
with st.expander(t[f'{analysis_type}_expander']):
|
|
for analysis in student_data[analysis_type][:5]: # Mostrar los últimos 5
|
|
st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
|
|
if analysis_type == 'morphosyntax_analyses':
|
|
if 'arc_diagrams' in analysis:
|
|
st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
|
|
elif analysis_type == 'semantic_analyses':
|
|
if 'key_concepts' in analysis:
|
|
st.write(t['key_concepts'])
|
|
st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
|
|
if 'graph' in analysis:
|
|
st.image(base64.b64decode(analysis['graph']))
|
|
elif analysis_type == 'discourse_analyses':
|
|
for i in [1, 2]:
|
|
if f'key_concepts{i}' in analysis:
|
|
st.write(f"{t['key_concepts']} {t['document']} {i}")
|
|
st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
|
|
if 'combined_graph' in analysis:
|
|
st.image(base64.b64decode(analysis['combined_graph']))
|
|
|
|
# Mostrar el historial de chat
|
|
with st.expander(t['chat_history_expander']):
|
|
for chat in student_data['chat_history'][:5]: # Mostrar las últimas 5 conversaciones
|
|
st.subheader(f"{t['chat_from']} {chat['timestamp']}")
|
|
for message in chat['messages']:
|
|
st.write(f"{message['role'].capitalize()}: {message['content']}")
|
|
st.write("---")
|
|
|
|
|
|
|
|
|
|
def display_student_progress(username, lang_code, t, student_data):
|
|
st.subheader(t['student_activities'])
|
|
|
|
if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
|
|
st.warning(t['no_data_warning'])
|
|
return
|
|
|
|
# Resumen de actividades
|
|
total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
|
|
st.write(f"{t['total_analyses']}: {total_analyses}")
|
|
|
|
# Gráfico de tipos de análisis
|
|
analysis_counts = {
|
|
t['morphological_analysis']: len(student_data['morphosyntax_analyses']),
|
|
t['semantic_analyses']: len(student_data['semantic_analyses']),
|
|
t['discourse_analyses']: len(student_data['discourse_analyses'])
|
|
}
|
|
fig, ax = plt.subplots()
|
|
ax.bar(analysis_counts.keys(), analysis_counts.values())
|
|
ax.set_title(t['analysis_types_chart'])
|
|
st.pyplot(fig)
|
|
|
|
# Mostrar los últimos análisis
|
|
for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
|
|
with st.expander(t[f'{analysis_type}_expander']):
|
|
for analysis in student_data[analysis_type][:5]: # Mostrar los últimos 5
|
|
st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
|
|
if analysis_type == 'morphosyntax_analyses':
|
|
if 'arc_diagrams' in analysis:
|
|
st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
|
|
elif analysis_type == 'semantic_analyses':
|
|
if 'key_concepts' in analysis:
|
|
st.write(t['key_concepts'])
|
|
st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
|
|
if 'graph' in analysis:
|
|
st.image(base64.b64decode(analysis['graph']))
|
|
elif analysis_type == 'discourse_analyses':
|
|
for i in [1, 2]:
|
|
if f'key_concepts{i}' in analysis:
|
|
st.write(f"{t['key_concepts']} {t['document']} {i}")
|
|
st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
|
|
if 'combined_graph' in analysis:
|
|
st.image(base64.b64decode(analysis['combined_graph']))
|
|
|
|
# Mostrar el historial de chat
|
|
with st.expander(t['chat_history_expander']):
|
|
for chat in student_data['chat_history'][:5]: # Mostrar las últimas 5 conversaciones
|
|
st.subheader(f"{t['chat_from']} {chat['timestamp']}")
|
|
for message in chat['messages']:
|
|
st.write(f"{message['role'].capitalize()}: {message['content']}")
|
|
st.write("---")
|
|
|
|
|
|
|
|
|
|
def display_student_progress(username, lang_code, t):
|
|
st.subheader(t['student_activities'])
|
|
st.write(f"{t['activities_message']} {username}")
|
|
|
|
# Aquí puedes agregar más contenido estático o placeholder
|
|
st.info(t['activities_placeholder'])
|
|
|
|
# Si necesitas mostrar algún dato, puedes usar datos de ejemplo o placeholders
|
|
col1, col2, col3 = st.columns(3)
|
|
col1.metric(t['morpho_analyses'], "5") # Ejemplo de dato
|
|
col2.metric(t['semantic_analyses'], "3") # Ejemplo de dato
|
|
col3.metric(t['discourse_analyses'], "2") # Ejemplo de dato
|
|
|
|
|
|
|
|
def display_student_progress(username, lang_code, t):
|
|
st.title(f"Actividades de {username}")
|
|
|
|
# Obtener todos los datos del estudiante
|
|
student_data = get_student_data(username)
|
|
|
|
if not student_data or len(student_data.get('entries', [])) == 0:
|
|
st.warning("No se encontraron datos de análisis para este estudiante.")
|
|
st.info("Intenta realizar algunos análisis de texto primero.")
|
|
return
|
|
|
|
# Resumen de actividades
|
|
with st.expander("Resumen de Actividades", expanded=True):
|
|
total_entries = len(student_data['entries'])
|
|
st.write(f"Total de análisis realizados: {total_entries}")
|
|
|
|
# Gráfico de tipos de análisis
|
|
analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
|
|
analysis_counts = pd.Series(analysis_types).value_counts()
|
|
fig, ax = plt.subplots()
|
|
analysis_counts.plot(kind='bar', ax=ax)
|
|
ax.set_title("Tipos de análisis realizados")
|
|
ax.set_xlabel("Tipo de análisis")
|
|
ax.set_ylabel("Cantidad")
|
|
st.pyplot(fig)
|
|
|
|
# Histórico de Análisis Morfosintácticos
|
|
with st.expander("Histórico de Análisis Morfosintácticos"):
|
|
morpho_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
|
|
for analysis in morpho_analyses[:5]: # Mostrar los últimos 5
|
|
st.subheader(f"Análisis del {analysis['timestamp']}")
|
|
if 'arc_diagrams' in analysis:
|
|
st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
|
|
|
|
# Histórico de Análisis Semánticos
|
|
with st.expander("Histórico de Análisis Semánticos"):
|
|
semantic_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
|
|
for analysis in semantic_analyses[:5]: # Mostrar los últimos 5
|
|
st.subheader(f"Análisis del {analysis['timestamp']}")
|
|
if 'key_concepts' in analysis:
|
|
concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis['key_concepts']])
|
|
st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
|
|
if 'graph' in analysis:
|
|
try:
|
|
img_bytes = base64.b64decode(analysis['graph'])
|
|
st.image(img_bytes, caption="Gráfico de relaciones conceptuales")
|
|
except Exception as e:
|
|
st.error(f"No se pudo mostrar el gráfico: {str(e)}")
|
|
|
|
# Histórico de Análisis Discursivos
|
|
with st.expander("Histórico de Análisis Discursivos"):
|
|
discourse_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
|
|
for analysis in discourse_analyses[:5]: # Mostrar los últimos 5
|
|
st.subheader(f"Análisis del {analysis['timestamp']}")
|
|
for i in [1, 2]:
|
|
if f'key_concepts{i}' in analysis:
|
|
concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis[f'key_concepts{i}']])
|
|
st.write(f"Conceptos clave del documento {i}:")
|
|
st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
|
|
if 'combined_graph' in analysis:
|
|
try:
|
|
img_bytes = base64.b64decode(analysis['combined_graph'])
|
|
st.image(img_bytes)
|
|
except Exception as e:
|
|
st.error(f"No se pudo mostrar el gráfico combinado: {str(e)}")
|
|
|
|
# Histórico de Conversaciones con el ChatBot
|
|
with st.expander("Histórico de Conversaciones con el ChatBot"):
|
|
if 'chat_history' in student_data:
|
|
for i, chat in enumerate(student_data['chat_history'][:5]): # Mostrar las últimas 5 conversaciones
|
|
st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
|
|
for message in chat['messages']:
|
|
st.write(f"{message['role'].capitalize()}: {message['content']}")
|
|
st.write("---")
|
|
else:
|
|
st.write("No se encontraron conversaciones con el ChatBot.")
|
|
|
|
# Opción para mostrar datos de depuración
|
|
if st.checkbox("Mostrar datos de depuración"):
|
|
st.write("Datos del estudiante (para depuración):")
|
|
st.json(student_data)
|
|
|
|
''' |
