modules/studentact/student_activities_v2.py

##############
#########student_activities.py
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}")

        # 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 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."))

    # 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 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)}"))

    # 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 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)}"))

    # 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 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."))

    # 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(username)

        # Mostrar conteo de tipos de análisis
        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)



'''