Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -535,7 +535,162 @@ def display_semantic_activities(username: str, t: dict):
 
 
 ###################################################################################################
-
+def display_discourse_activities(username: str, t: dict):
+    """
+    Solución simplificada para mostrar análisis de discurso con máxima tolerancia a errores
+    y corregida para evitar el error de verificación de colección MongoDB
+    """
+    try:
+        # Importar directamente la colección
+        from ..database.mongo_db import get_collection
+        
+        # Registrar información de inicio
+        logger.info(f"Intentando obtener análisis de discurso para {username}")
+        
+        # Obtener colección directamente
+        collection = get_collection('student_discourse_analysis')
+        
+        # CORRECCIÓN: Verificar si collection es None, no usar 'if not collection'
+        if collection is None:
+            st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
+            return
+        
+        # Consulta simplificada: solo por username
+        results = list(collection.find({"username": username}).sort("timestamp", -1))
+        logger.info(f"Recuperados {len(results)} documentos para {username}")
+        
+        if not results:
+            st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
+            return
+        
+        # Mostrar cada resultado
+        for doc in results:
+            try:
+                # Extraer y formatear fecha con manejo de errores
+                timestamp_str = doc.get('timestamp', 'Fecha desconocida')
+                try:
+                    if isinstance(timestamp_str, str):
+                        dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
+                        formatted_date = dt.strftime("%d/%m/%Y %H:%M:%S")
+                    else:
+                        formatted_date = str(timestamp_str)
+                except:
+                    formatted_date = str(timestamp_str)
+                
+                # Crear expander
+                expander_label = f"Análisis: {formatted_date}"
+                with st.expander(expander_label):
+                    # Mostrar texto si existe
+                    if 'text1' in doc and doc['text1']:
+                        st.text_area("Texto analizado", 
+                                    value=doc['text1'], 
+                                    height=100, 
+                                    disabled=True)
+                    
+                    # Mostrar conceptos clave si existen
+                    has_concepts = False
+                    
+                    # Intentar mostrar conceptos clave en dos columnas
+                    if 'key_concepts1' in doc or 'key_concepts2' in doc:
+                        has_concepts = True
+                        col1, col2 = st.columns(2)
+                        
+                        # Columna 1
+                        with col1:
+                            st.markdown("**Conceptos clave (Texto 1)**")
+                            if 'key_concepts1' in doc and doc['key_concepts1']:
+                                try:
+                                    # Mostrar simple como texto para evitar errores de formato
+                                    concepts = doc['key_concepts1']
+                                    if isinstance(concepts, list):
+                                        concept_text = ""
+                                        for c in concepts:
+                                            if isinstance(c, list) and len(c) >= 2:
+                                                concept_text += f"• {c[0]}: {c[1]}\n"
+                                            else:
+                                                concept_text += f"• {c}\n"
+                                        st.text(concept_text)
+                                    else:
+                                        st.text(str(concepts))
+                                except:
+                                    st.text("Error mostrando conceptos")
+                            else:
+                                st.text("Sin conceptos disponibles")
+                        
+                        # Columna 2
+                        with col2:
+                            st.markdown("**Conceptos clave (Texto 2)**")
+                            if 'key_concepts2' in doc and doc['key_concepts2']:
+                                try:
+                                    # Mostrar simple como texto para evitar errores de formato
+                                    concepts = doc['key_concepts2']
+                                    if isinstance(concepts, list):
+                                        concept_text = ""
+                                        for c in concepts:
+                                            if isinstance(c, list) and len(c) >= 2:
+                                                concept_text += f"• {c[0]}: {c[1]}\n"
+                                            else:
+                                                concept_text += f"• {c}\n"
+                                        st.text(concept_text)
+                                    else:
+                                        st.text(str(concepts))
+                                except:
+                                    st.text("Error mostrando conceptos")
+                            else:
+                                st.text("Sin conceptos disponibles")
+                    
+                    # Buscar visualizaciones
+                    st.markdown("---")
+                    st.markdown("**Visualizaciones**")
+                    
+                    # Variable para verificar si se mostró alguna visualización
+                    shown_images = 0
+                    
+                    # Mostrar todas las visualizaciones posibles
+                    for field_name in ['graph1', 'graph2', 'combined_graph']:
+                        if field_name in doc and doc[field_name]:
+                            try:
+                                data = doc[field_name]
+                                
+                                # Si es bytes, mostrar directamente
+                                if isinstance(data, bytes):
+                                    st.image(data, caption=field_name, use_column_width=True)
+                                    shown_images += 1
+                                    
+                                # Si es string, intentar como base64
+                                elif isinstance(data, str):
+                                    try:
+                                        import base64
+                                        image_bytes = base64.b64decode(data)
+                                        st.image(image_bytes, caption=field_name, use_column_width=True)
+                                        shown_images += 1
+                                    except:
+                                        # Si falla la decodificación, solo registrarlo
+                                        logger.error(f"No se pudo decodificar {field_name}")
+                            except Exception as img_err:
+                                logger.error(f"Error mostrando {field_name}: {str(img_err)}")
+                    
+                    # Mensaje si no hay visualizaciones
+                    if shown_images == 0:
+                        st.info("No hay visualizaciones disponibles para este análisis")
+                        
+                    # Mostrar los datos crudos para depuración (opcional)
+                    with st.expander("Datos completos del análisis", expanded=False):
+                        # Filtrar campos binarios y muy grandes
+                        filtered_doc = {k: v for k, v in doc.items() 
+                                      if not isinstance(v, bytes) 
+                                      and not (isinstance(v, str) and len(str(v)) > 500)}
+                        st.json(filtered_doc)
+            
+            except Exception as doc_err:
+                logger.error(f"Error procesando documento: {str(doc_err)}")
+                st.error(f"Error procesando análisis: {str(doc_err)}")
+                
+    except Exception as e:
+        logger.error(f"Error general: {str(e)}")
+        st.error(f"Error recuperando análisis: {str(e)}")
+        # Mostrar el error completo para depuración
+        st.exception(e)
 #################################################################################   
 
 def display_discourse_comparison(analysis: dict, t: dict):