Update modules/ui.py

modules/ui.py

@@ -194,101 +194,160 @@ def display_chat_interface():
 
 ################################################################################
 # Funciones para Cosmos DB MongoDB API (análisis de texto)
-def display_student_progress(username, lang_code='es'):
-    logger.info(f"Intentando mostrar progreso para el usuario: {username}")
-    student_data = get_student_data(username)
+#def display_student_progress(username, lang_code='es'):
+    #logger.info(f"Intentando mostrar progreso para el usuario: {username}")
+    #student_data = get_student_data(username)
     
-    if student_data is None:
-        logger.warning(f"No se pudieron recuperar datos para el usuario: {username}")
-        st.warning("No se encontraron datos para este estudiante.")
-        st.info("Intenta realizar algunos análisis de texto primero.")
-        return
+    #if student_data is None:
+    #    logger.warning(f"No se pudieron recuperar datos para el usuario: {username}")
+    #    st.warning("No se encontraron datos para este estudiante.")
+    #    st.info("Intenta realizar algunos análisis de texto primero.")
+    #    return
 
-    logger.info(f"Datos recuperados para {username}: {student_data}")
+    #logger.info(f"Datos recuperados para {username}: {student_data}")
     
-    st.title(f"Progreso de {username}")
+    #st.title(f"Progreso de {username}")
 
-    if student_data['entries_count'] == 0:
-        st.warning("No se encontraron entradas para este estudiante.")
-        st.info("Intenta realizar algunos análisis de texto primero.")
-        return
+    #if student_data['entries_count'] == 0:
+    #    st.warning("No se encontraron entradas para este estudiante.")
+    #    st.info("Intenta realizar algunos análisis de texto primero.")
+    #    return
         
         # Mostrar el conteo de palabras
-        if student_data['word_count']:
-            with st.expander("Total de palabras por categoría gramatical", expanded=False):
-                df = pd.DataFrame(list(student_data['word_count'].items()), columns=['category', 'count'])
-                df['label'] = df.apply(lambda x: f"{POS_TRANSLATIONS[lang_code].get(x['category'], x['category'])}", axis=1)
-                df = df.sort_values('count', ascending=False)
+        #if student_data['word_count']:
+        #    with st.expander("Total de palabras por categoría gramatical", expanded=False):
+        #        df = pd.DataFrame(list(student_data['word_count'].items()), columns=['category', 'count'])
+        #        df['label'] = df.apply(lambda x: f"{POS_TRANSLATIONS[lang_code].get(x['category'], x['category'])}", axis=1)
+        #        df = df.sort_values('count', ascending=False)
                 
-                fig, ax = plt.subplots(figsize=(12, 6))
-                bars = ax.bar(df['label'], df['count'], color=df['category'])
+        #        fig, ax = plt.subplots(figsize=(12, 6))
+        #        bars = ax.bar(df['label'], df['count'], color=df['category'])
                 
-                ax.set_xlabel('Categoría Gramatical')
-                ax.set_ylabel('Cantidad de Palabras')
-                ax.set_title('Total de palabras por categoría gramatical')
-                plt.xticks(rotation=45, ha='right')
+        #        ax.set_xlabel('Categoría Gramatical')
+        #        ax.set_ylabel('Cantidad de Palabras')
+        #        ax.set_title('Total de palabras por categoría gramatical')
+        #        plt.xticks(rotation=45, ha='right')
                 
-                for bar in bars:
-                    height = bar.get_height()
-                    ax.text(bar.get_x() + bar.get_width()/2., height, f'{height}', ha='center', va='bottom')
+        #        for bar in bars:
+        #            height = bar.get_height()
+        #            ax.text(bar.get_x() + bar.get_width()/2., height, f'{height}', ha='center', va='bottom')
                 
-                plt.tight_layout()
-                st.pyplot(fig)
+        #        plt.tight_layout()
+        #        st.pyplot(fig)
 
         # Mostrar análisis morfosintáctico
-        morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
-        if morphosyntax_entries:
-            with st.expander("Análisis Morfosintáctico - Diagramas de Arco", expanded=False):
-                for i, entry in enumerate(morphosyntax_entries):
-                    st.subheader(f"Análisis {i+1} - {entry['timestamp']}")
-                    st.write(entry['text'])
-                    for j, diagram in enumerate(entry.get('arc_diagrams', [])):
-                        st.subheader(f"Diagrama de Arco {j+1}")
-                        st.write(diagram, unsafe_allow_html=True)
+        #morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
+        #if morphosyntax_entries:
+        #    with st.expander("Análisis Morfosintáctico - Diagramas de Arco", expanded=False):
+        #        for i, entry in enumerate(morphosyntax_entries):
+        #            st.subheader(f"Análisis {i+1} - {entry['timestamp']}")
+        #            st.write(entry['text'])
+        #            for j, diagram in enumerate(entry.get('arc_diagrams', [])):
+        #                st.subheader(f"Diagrama de Arco {j+1}")
+        #                st.write(diagram, unsafe_allow_html=True)
 
         # Mostrar análisis semántico
-        if student_data['semantic_analyses']:
-            with st.expander("Análisis Semántico - Diagramas de Red", expanded=False):
-                for i, entry in enumerate(student_data['semantic_analyses']):
-                    st.subheader(f"Análisis Semántico {i+1} - {entry['timestamp']}")
-                    st.write(entry['text'])
-                    if 'network_diagram' in entry:
-                        image_bytes = base64.b64decode(entry['network_diagram'])
-                        st.image(image_bytes)
+        #if student_data['semantic_analyses']:
+        #    with st.expander("Análisis Semántico - Diagramas de Red", expanded=False):
+        #        for i, entry in enumerate(student_data['semantic_analyses']):
+        #            st.subheader(f"Análisis Semántico {i+1} - {entry['timestamp']}")
+        #            st.write(entry['text'])
+        #            if 'network_diagram' in entry:
+        #                image_bytes = base64.b64decode(entry['network_diagram'])
+        #                st.image(image_bytes)
 
         # Mostrar análisis del discurso
-        if student_data['discourse_analyses']:
-            with st.expander("Análisis del Discurso - Comparación de Grafos", expanded=False):
-                for i, entry in enumerate(student_data['discourse_analyses']):
-                    st.subheader(f"Análisis del Discurso {i+1} - {entry['timestamp']}")
-                    st.write("Texto del documento patrón:")
-                    st.write(entry.get('text1', 'No disponible'))
-                    st.write("Texto del documento comparado:")
-                    st.write(entry.get('text2', 'No disponible'))
-                    if 'graph1' in entry:
-                        st.image(base64.b64decode(entry['graph1']))
-                    if 'graph2' in entry:
-                        st.image(base64.b64decode(entry['graph2']))
+        #if student_data['discourse_analyses']:
+        #    with st.expander("Análisis del Discurso - Comparación de Grafos", expanded=False):
+        #        for i, entry in enumerate(student_data['discourse_analyses']):
+        #            st.subheader(f"Análisis del Discurso {i+1} - {entry['timestamp']}")
+        #            st.write("Texto del documento patrón:")
+        #            st.write(entry.get('text1', 'No disponible'))
+        #            st.write("Texto del documento comparado:")
+        #            st.write(entry.get('text2', 'No disponible'))
+        #            if 'graph1' in entry:
+        #                st.image(base64.b64decode(entry['graph1']))
+        #            if 'graph2' in entry:
+        #                st.image(base64.b64decode(entry['graph2']))
 
         # Mostrar conversaciones del chat
-        if student_data['chat_history']:
-            with st.expander("Historial de Conversaciones del Chat", expanded=False):
-                for i, chat in enumerate(student_data['chat_history']):
-                    st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
-                    for message in chat['messages']:
-                        if message['role'] == 'user':
-                            st.write("Usuario: " + message['content'])
-                        else:
-                            st.write("Asistente: " + message['content'])
-                    st.write("---")
-    else:
-        st.warning("No se encontraron entradas para este estudiante.")
-        st.info("Intenta realizar algunos análisis de texto primero.")
+        #if student_data['chat_history']:
+        #    with st.expander("Historial de Conversaciones del Chat", expanded=False):
+        #        for i, chat in enumerate(student_data['chat_history']):
+        #            st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
+        #            for message in chat['messages']:
+        #                if message['role'] == 'user':
+        #                    st.write("Usuario: " + message['content'])
+        #               else:
+        #                    st.write("Asistente: " + message['content'])
+        #            st.write("---")
+    #else:
+    #    st.warning("No se encontraron entradas para este estudiante.")
+    #    st.info("Intenta realizar algunos análisis de texto primero.")
 
     # Añadir logs para depuración
-    st.write("Datos del estudiante (para depuración):")
-    st.json(student_data)
+    #st.write("Datos del estudiante (para depuración):")
+    #st.json(student_data)
+
+def display_student_progress(username, lang_code='es'):
+    student_data = get_student_data(username)
+    
+    if student_data is None or len(student_data['entries']) == 0:
+        st.warning("No se encontraron datos para este estudiante.")
+        st.info("Intenta realizar algunos análisis de texto primero.")
+        return
+
+    st.title(f"Progreso de {username}")
+
+    # Mostrar resumen de actividades
+    st.header("Resumen de actividades")
+    total_entries = len(student_data['entries'])
+    st.write(f"Total de análisis realizados: {total_entries}")
 
+    # Mostrar 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)
+
+    # Mostrar últimos análisis
+    st.header("Últimos análisis realizados")
+    for i, entry in enumerate(student_data['entries'][:5]):  # Mostrar los últimos 5 análisis
+        with st.expander(f"Análisis {i+1} - {entry['timestamp']}"):
+            st.write(f"Tipo: {entry['analysis_type']}")
+            st.write(f"Texto: {entry['text']}")
+            
+            if entry['analysis_type'] == 'morphosyntax':
+                if entry['word_count']:
+                    st.subheader("Conteo de palabras por categoría")
+                    word_count_df = pd.DataFrame.from_dict(entry['word_count'], orient='index', columns=['Cantidad'])
+                    st.dataframe(word_count_df)
+                
+                if entry['arc_diagrams']:
+                    st.subheader("Diagrama de arco")
+                    st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
+
+    # Mostrar progreso a lo largo del tiempo
+    st.header("Progreso a lo largo del tiempo")
+    dates = [datetime.fromisoformat(entry['timestamp']) for entry in student_data['entries']]
+    analysis_counts = pd.Series(dates).value_counts().sort_index()
+    
+    fig, ax = plt.subplots()
+    analysis_counts.plot(kind='line', ax=ax)
+    ax.set_title("Análisis realizados a lo largo del tiempo")
+    ax.set_xlabel("Fecha")
+    ax.set_ylabel("Cantidad de análisis")
+    st.pyplot(fig)
+
+    # Añadir logs para depuración
+    if st.checkbox("Mostrar datos de depuración"):
+        st.write("Datos del estudiante (para depuración):")
+        st.json(student_data)
 
 ##################################################################################################
 def display_morphosyntax_analysis_interface(nlp_models, lang_code):