Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -16,119 +16,169 @@ import base64
 import seaborn as sns
 import logging
 
+# Importaciones de la base de datos
+from ..database.morphosintax_mongo_db import get_student_morphosyntax_analysis
+from ..database.semantic_mongo_db import get_student_semantic_analysis
+from ..database.discourse_mongo_db import get_student_discourse_analysis
+from ..database.chat_mongo_db import get_chat_history
+
 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
+def display_student_activities(username: str, lang_code: str, t: dict):
+    """
+    Muestra todas las actividades del estudiante
+    Args:
+        username: Nombre del estudiante
+        lang_code: Código del idioma
+        t: Diccionario de traducciones
+    """
+    try:
+        st.header(t.get('activities_title', 'Mis Actividades'))
 
-    st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
+        # Tabs para diferentes tipos de análisis
+        tabs = st.tabs([
+            t.get('morpho_activities', 'Análisis Morfosintáctico'),
+            t.get('semantic_activities', 'Análisis Semántico'),
+            t.get('discourse_activities', 'Análisis del Discurso'),
+            t.get('chat_activities', 'Conversaciones con el Asistente')
+        ])
 
-    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}")
+        # Tab de Análisis Morfosintáctico
+        with tabs[0]:
+            display_morphosyntax_activities(username, t)
 
-        # 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()
+        # Tab de Análisis Semántico
+        with tabs[1]:
+            display_semantic_activities(username, t)
 
-        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)
+        # Tab de Análisis del Discurso
+        with tabs[2]:
+            display_discourse_activities(username, t)
 
-    # 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."))
+        # Tab de Conversaciones del Chat
+        with tabs[3]:
+            display_chat_activities(username, t)
 
-    # 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)}"))
+    except Exception as e:
+        logger.error(f"Error mostrando actividades: {str(e)}")
+        st.error(t.get('error_loading_activities', 'Error al cargar las actividades'))
 
-    # 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)}"))
+def display_morphosyntax_activities(username: str, t: dict):
+    """Muestra actividades de análisis morfosintáctico"""
+    try:
+        analyses = get_student_morphosyntax_analysis(username)
+        if not analyses:
+            st.info(t.get('no_morpho_analyses', 'No hay análisis morfosintácticos registrados'))
+            return
 
-    # 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 analysis in analyses:
+            with st.expander(
+                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
+                expanded=False
+            ):
+                st.text(f"{t.get('analyzed_text', 'Texto analizado')}:")
+                st.write(analysis['text'])
+                
+                if 'arc_diagrams' in analysis:
+                    st.subheader(t.get('syntactic_diagrams', 'Diagramas sintácticos'))
+                    for diagram in analysis['arc_diagrams']:
+                        st.write(diagram, unsafe_allow_html=True)
+
+    except Exception as e:
+        logger.error(f"Error mostrando análisis morfosintáctico: {str(e)}")
+        st.error(t.get('error_morpho', 'Error al mostrar análisis morfosintáctico'))
+
+def display_semantic_activities(username: str, t: dict):
+    """Muestra actividades de análisis semántico"""
+    try:
+        analyses = get_student_semantic_analysis(username)
+        if not analyses:
+            st.info(t.get('no_semantic_analyses', 'No hay análisis semánticos registrados'))
+            return
+
+        for analysis in analyses:
+            with st.expander(
+                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
+                expanded=False
+            ):
+                st.text(f"{t.get('analyzed_file', 'Archivo analizado')}:")
+                st.write(analysis['text'])
+                
+                if 'key_concepts' in analysis:
+                    st.subheader(t.get('key_concepts', 'Conceptos clave'))
+                    df = pd.DataFrame(analysis['key_concepts'])
+                    st.dataframe(df)
+
+    except Exception as e:
+        logger.error(f"Error mostrando análisis semántico: {str(e)}")
+        st.error(t.get('error_semantic', 'Error al mostrar análisis semántico'))
+
+def display_discourse_activities(username: str, t: dict):
+    """Muestra actividades de análisis del discurso"""
+    try:
+        analyses = get_student_discourse_analysis(username)
+        if not analyses:
+            st.info(t.get('no_discourse_analyses', 'No hay análisis del discurso registrados'))
+            return
+
+        for analysis in analyses:
+            with st.expander(
+                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
+                expanded=False
+            ):
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.text(f"{t.get('text_1', 'Texto 1')}:")
+                    st.write(analysis['text1'])
+                with col2:
+                    st.text(f"{t.get('text_2', 'Texto 2')}:")
+                    st.write(analysis['text2'])
+
+                if 'key_concepts1' in analysis and 'key_concepts2' in analysis:
+                    display_discourse_comparison(analysis, t)
+
+    except Exception as e:
+        logger.error(f"Error mostrando análisis del discurso: {str(e)}")
+        st.error(t.get('error_discourse', 'Error al mostrar análisis del discurso'))
+
+def display_chat_activities(username: str, t: dict):
+    """Muestra historial de conversaciones del chat"""
+    try:
+        chat_history = get_chat_history(username, limit=50)
+        if not chat_history:
+            st.info(t.get('no_chat_history', 'No hay conversaciones registradas'))
+            return
+
+        for chat in chat_history:
+            with st.expander(
+                f"{t.get('chat_date', 'Fecha de conversación')}: {chat['timestamp']}", 
+                expanded=False
+            ):
                 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."))
+                    with st.chat_message(message["role"]):
+                        st.markdown(message["content"])
 
-    # 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)
+    except Exception as e:
+        logger.error(f"Error mostrando historial del chat: {str(e)}")
+        st.error(t.get('error_chat', 'Error al mostrar historial del chat'))
+
+def display_discourse_comparison(analysis: dict, t: dict):
+    """Muestra la comparación de análisis del discurso"""
+    st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
+        df1 = pd.DataFrame(analysis['key_concepts1'])
+        st.dataframe(df1)
+    
+    with col2:
+        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+        df2 = pd.DataFrame(analysis['key_concepts2'])
+        st.dataframe(df2)
 
-        # 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)