Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -538,109 +538,157 @@ def display_semantic_activities(username: str, t: dict):
 
 def display_discourse_activities(username: str, t: dict):
     """
-    Muestra actividades de análisis del discurso en la sección de historial
-    Ahora muestra los dos gráficos principales uno al lado del otro
+    Solución simplificada para mostrar análisis de discurso con máxima tolerancia a errores
     """
     try:
-        logger.info(f"Recuperando análisis del discurso para {username}")
+        # Importar directamente la colección
+        from ..database.mongo_db import get_collection
         
-        # Obtener análisis - usando la función existente
-        analyses = get_student_discourse_analysis(username)
+        # Registrar información de inicio
+        logger.info(f"Intentando obtener análisis de discurso para {username}")
         
-        if not analyses:
-            logger.info("No se encontraron análisis del discurso")
+        # Obtener colección directamente
+        collection = get_collection('student_discourse_analysis')
+        if not collection:
             st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
             return
-            
-        logger.info(f"Procesando {len(analyses)} análisis del discurso")
         
-        for analysis in analyses:
+        # 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:
-                # Formatear fecha - con manejo de errores mejorado
+                # Extraer y formatear fecha con manejo de errores
+                timestamp_str = doc.get('timestamp', 'Fecha desconocida')
                 try:
-                    timestamp = datetime.fromisoformat(analysis.get('timestamp', '').replace('Z', '+00:00'))
-                    formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                    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(analysis.get('timestamp', 'Fecha desconocida'))
+                    formatted_date = str(timestamp_str)
                 
                 # Crear expander
-                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
-                    # Mostrar conceptos si están disponibles
-                    if 'key_concepts1' in analysis and analysis['key_concepts1']:
-                        # Usar la función de comparación existente para mostrar conceptos
-                        display_discourse_comparison(analysis, t)
+                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 gráficos - ahora en dos columnas
-                    has_graphs = False
+                    # Mostrar conceptos clave si existen
+                    has_concepts = False
                     
-                    # Crear columnas para los gráficos principales
-                    if ('graph1' in analysis and analysis['graph1']) or ('graph2' in analysis and analysis['graph2']):
-                        has_graphs = True
+                    # 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)
                         
-                        # Gráfico 1 en la primera columna
+                        # Columna 1
                         with col1:
-                            if 'graph1' in analysis and analysis['graph1']:
-                                st.markdown(f"**{t.get('graph1_title', 'Visualización Texto 1')}**")
+                            st.markdown("**Conceptos clave (Texto 1)**")
+                            if 'key_concepts1' in doc and doc['key_concepts1']:
                                 try:
-                                    # Si es bytes directamente
-                                    if isinstance(analysis['graph1'], bytes):
-                                        st.image(analysis['graph1'], use_column_width=True)
-                                    # Si es string base64
-                                    elif isinstance(analysis['graph1'], str):
-                                        image_bytes = base64.b64decode(analysis['graph1'])
-                                        st.image(image_bytes, use_column_width=True)
-                                except Exception as e:
-                                    logger.error(f"Error mostrando graph1: {str(e)}")
-                                    st.error(t.get('error_graph', 'Error mostrando visualización del Texto 1'))
+                                    # 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.info(t.get('no_graph1', 'No hay visualización para el Texto 1'))
+                                st.text("Sin conceptos disponibles")
                         
-                        # Gráfico 2 en la segunda columna
+                        # Columna 2
                         with col2:
-                            if 'graph2' in analysis and analysis['graph2']:
-                                st.markdown(f"**{t.get('graph2_title', 'Visualización Texto 2')}**")
+                            st.markdown("**Conceptos clave (Texto 2)**")
+                            if 'key_concepts2' in doc and doc['key_concepts2']:
                                 try:
-                                    # Si es bytes directamente
-                                    if isinstance(analysis['graph2'], bytes):
-                                        st.image(analysis['graph2'], use_column_width=True)
-                                    # Si es string base64
-                                    elif isinstance(analysis['graph2'], str):
-                                        image_bytes = base64.b64decode(analysis['graph2'])
-                                        st.image(image_bytes, use_column_width=True)
-                                except Exception as e:
-                                    logger.error(f"Error mostrando graph2: {str(e)}")
-                                    st.error(t.get('error_graph', 'Error mostrando visualización del Texto 2'))
+                                    # 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.info(t.get('no_graph2', 'No hay visualización para el Texto 2'))
+                                st.text("Sin conceptos disponibles")
                     
-                    # Mostrar gráfico combinado si existe (debajo de los dos gráficos)
-                    if 'combined_graph' in analysis and analysis['combined_graph']:
-                        has_graphs = True
-                        st.markdown(f"### {t.get('combined_graph_title', 'Visualización Comparativa')}")
-                        try:
-                            # Si es bytes directamente
-                            if isinstance(analysis['combined_graph'], bytes):
-                                st.image(analysis['combined_graph'], use_column_width=True)
-                            # Si es string base64
-                            elif isinstance(analysis['combined_graph'], str):
-                                image_bytes = base64.b64decode(analysis['combined_graph'])
-                                st.image(image_bytes, use_column_width=True)
-                        except Exception as e:
-                            logger.error(f"Error mostrando combined_graph: {str(e)}")
-                            st.error(t.get('error_graph', 'Error mostrando visualización comparativa'))
+                    # Buscar visualizaciones
+                    st.markdown("---")
+                    st.markdown("**Visualizaciones**")
                     
-                    # Mensaje si no hay gráficos
-                    if not has_graphs:
-                        st.info(t.get('no_visualization', 'No hay visualizaciones disponibles'))
-
-            except Exception as e:
-                logger.error(f"Error procesando análisis individual: {str(e)}")
-                continue
+                    # 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 mostrando análisis del discurso: {str(e)}")
-        st.error(t.get('error_discourse', 'Error al mostrar análisis comparado de textos'))
+        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)
 
 #################################################################################