Update modules/database.py

modules/database.py

@@ -8,6 +8,8 @@ import certifi
 from datetime import datetime
 import io
 import base64
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
 import bcrypt
 print(f"Bcrypt version: {bcrypt.__version__}")
 
@@ -127,71 +129,93 @@ def get_user(username):
 
 ################################################################################
 # Funciones para Cosmos DB MongoDB API (análisis de texto)
+def display_student_progress(username, lang_code='es'):
+    student_data = get_student_data(username)
+    
+    if student_data is None:
+        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}")
+
+    if student_data['entries_count'] > 0:
+        # 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)
+                
+                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')
+                
+                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)
+
+        # 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)
+
+        # 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)
+
+        # 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']))
+
+        # 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.")
+
+    # Añadir logs para depuración
+    st.write("Datos del estudiante (para depuración):")
+    st.json(student_data)
 
-def get_student_data(username):
-    if analysis_collection is None:
-        logger.error("La conexión a MongoDB no está inicializada")
-        return None
-
-    try:
-        logger.info(f"Buscando datos para el usuario: {username}")
-        cursor = analysis_collection.find({"username": username})
-        
-        formatted_data = {
-            "username": username,
-            "entries": [],
-            "entries_count": 0,
-            "word_count": {},
-            "semantic_analyses": [],
-            "discourse_analyses": [],
-            "chat_history": []
-        }
-        
-        for entry in cursor:
-            formatted_entry = {
-                "timestamp": entry["timestamp"],
-                "text": entry["text"],
-                "analysis_type": entry.get("analysis_type", "morphosyntax")
-            }
-            
-            if formatted_entry["analysis_type"] == "morphosyntax":
-                formatted_entry.update({
-                    "word_count": entry.get("word_count", {}),
-                    "arc_diagrams": entry.get("arc_diagrams", [])
-                })
-                for category, count in formatted_entry["word_count"].items():
-                    formatted_data["word_count"][category] = formatted_data["word_count"].get(category, 0) + count
-            
-            elif formatted_entry["analysis_type"] == "semantic":
-                formatted_entry["network_diagram"] = entry.get("network_diagram", "")
-                formatted_data["semantic_analyses"].append(formatted_entry)
-            
-            elif formatted_entry["analysis_type"] == "discourse":
-                formatted_entry.update({
-                    "graph1": entry.get("graph1", ""),
-                    "graph2": entry.get("graph2", "")
-                })
-                formatted_data["discourse_analyses"].append(formatted_entry)
-            
-            formatted_data["entries"].append(formatted_entry)
-        
-        formatted_data["entries_count"] = len(formatted_data["entries"])
-        formatted_data["entries"].sort(key=lambda x: x["timestamp"], reverse=True)
-        
-        for entry in formatted_data["entries"]:
-            entry["timestamp"] = entry["timestamp"].isoformat()
-        
-        # Obtener el historial del chat
-        chat_cursor = chat_collection.find({"username": username})
-        formatted_data["chat_history"] = list(chat_cursor)
-        
-        logger.info(f"Datos formateados para {username}: {formatted_data}")
-        return formatted_data
-
-    except Exception as e:
-        logger.error(f"Error al obtener datos del estudiante {username}: {str(e)}")
-        return None
-        
 #######################################################################################################
 
 def store_morphosyntax_result(username, text, repeated_words, arc_diagrams):
@@ -247,10 +271,6 @@ def store_semantic_result(username, text, network_diagram):
         return False
 
 ###############################################################################################################
-import io
-import base64
-import matplotlib.pyplot as plt
-from matplotlib.figure import Figure
 
 def store_discourse_analysis_result(username, text1, text2, graph1, graph2):
     try: