Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -535,49 +535,189 @@ def display_semantic_activities(username: str, t: dict):
 
 
 ###################################################################################################
+
 def display_discourse_activities(username: str, t: dict):
-    """Muestra actividades de análisis del discurso"""
+    """
+    Muestra actividades de análisis del discurso (mostrado como 'Análisis comparado de textos' en la UI)
+    Versión simplificada que muestra cualquier dato disponible
+    """
     try:
         logger.info(f"Recuperando análisis del discurso para {username}")
-        analyses = get_student_discourse_analysis(username)
+        
+        # Importación inline para evitar circularidad
+        from ..database.mongo_db import get_collection
+        
+        # Obtener la colección directamente para evitar cualquier filtrado
+        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
+            
+        # Consulta básica - solo por username para capturar todos los registros posibles
+        query = {"username": username}
+        
+        # Ejecutar consulta
+        try:
+            analyses = list(collection.find(query).sort("timestamp", -1))
+            logger.info(f"Recuperados {len(analyses)} análisis para {username}")
+        except Exception as e:
+            logger.error(f"Error recuperando análisis: {str(e)}")
+            analyses = []
         
         if not analyses:
-            logger.info("No se encontraron análisis del discurso")
-            st.info(t.get('no_discourse_analyses', 'No hay análisis del discurso registrados'))
+            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")
+        # Procesar cada análisis
         for analysis in analyses:
             try:
-                # Verificar campos mínimos necesarios
-                if not all(key in analysis for key in ['timestamp', 'combined_graph']):
-                    logger.warning(f"Análisis incompleto: {analysis.keys()}")
-                    continue
-
                 # Formatear fecha
-                timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
-                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                try:
+                    timestamp = datetime.fromisoformat(analysis.get('timestamp', '').replace('Z', '+00:00'))
+                    formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                except:
+                    formatted_date = str(analysis.get('timestamp', 'Fecha desconocida'))
                 
-                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
-                    if analysis['combined_graph']:
-                        logger.debug("Decodificando gráfico combinado")
-                        try:
-                            image_bytes = base64.b64decode(analysis['combined_graph'])
-                            st.image(image_bytes, use_column_width=True)
-                            logger.debug("Gráfico mostrado exitosamente")
-                        except Exception as img_error:
-                            logger.error(f"Error decodificando imagen: {str(img_error)}")
-                            st.error(t.get('error_loading_graph', 'Error al cargar el gráfico'))
-                    else:
-                        st.info(t.get('no_visualization', 'No hay visualización comparativa disponible'))
+                # Crear título del expander
+                expander_title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
+                
+                # Mostrar expander
+                with st.expander(expander_title, expanded=False):
+                    # 1. Mostrar texto analizado si existe
+                    if 'text1' in analysis and analysis['text1']:
+                        st.subheader(t.get('analyzed_text', 'Texto analizado'))
+                        st.text_area(
+                            "Texto", 
+                            value=analysis['text1'], 
+                            height=100,
+                            disabled=True,
+                            key=f"text_{str(analysis.get('_id', 'unknown'))}"
+                        )
+                    
+                    # 2. Mostrar conceptos clave si existen
+                    if 'key_concepts1' in analysis and analysis['key_concepts1']:
+                        st.subheader(t.get('key_concepts', 'Conceptos clave'))
+                        
+                        col1, col2 = st.columns(2)
+                        
+                        with col1:
+                            st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
+                            try:
+                                # Mostrar como dataframe o texto según formato
+                                if isinstance(analysis['key_concepts1'], list):
+                                    if len(analysis['key_concepts1']) > 0:
+                                        if isinstance(analysis['key_concepts1'][0], list):
+                                            df = pd.DataFrame(analysis['key_concepts1'], columns=['Concepto', 'Relevancia'])
+                                            st.dataframe(df)
+                                        else:
+                                            st.write(", ".join(str(c) for c in analysis['key_concepts1']))
+                                else:
+                                    st.write(str(analysis['key_concepts1']))
+                            except:
+                                st.write(str(analysis['key_concepts1']))
+                        
+                        with col2:
+                            if 'key_concepts2' in analysis and analysis['key_concepts2']:
+                                st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+                                try:
+                                    # Mostrar como dataframe o texto según formato
+                                    if isinstance(analysis['key_concepts2'], list):
+                                        if len(analysis['key_concepts2']) > 0:
+                                            if isinstance(analysis['key_concepts2'][0], list):
+                                                df = pd.DataFrame(analysis['key_concepts2'], columns=['Concepto', 'Relevancia'])
+                                                st.dataframe(df)
+                                            else:
+                                                st.write(", ".join(str(c) for c in analysis['key_concepts2']))
+                                    else:
+                                        st.write(str(analysis['key_concepts2']))
+                                except:
+                                    st.write(str(analysis['key_concepts2']))
+                    
+                    # 3. Mostrar cualquier gráfico disponible
+                    st.subheader(t.get('visualizations', 'Visualizaciones'))
+                    
+                    # Revisar todos los campos que podrían contener gráficos
+                    graph_fields = ['graph1', 'graph2', 'combined_graph']
+                    found_graphs = False
+                    
+                    for field in graph_fields:
+                        if field in analysis and analysis[field]:
+                            found_graphs = True
+                            
+                            # Título según el tipo de gráfico
+                            if field == 'graph1':
+                                title = t.get('graph1_title', 'Gráfico Texto 1')
+                            elif field == 'graph2':
+                                title = t.get('graph2_title', 'Gráfico Texto 2')
+                            else:
+                                title = t.get('combined_graph_title', 'Gráfico Combinado')
+                            
+                            st.markdown(f"**{title}**")
+                            
+                            # Mostrar el gráfico según su tipo
+                            graph_data = analysis[field]
+                            
+                            try:
+                                # Si es bytes, mostrar directamente
+                                if isinstance(graph_data, bytes):
+                                    st.image(graph_data, use_column_width=True)
+                                
+                                # Si es string, intentar decodificar como base64
+                                elif isinstance(graph_data, str):
+                                    try:
+                                        import base64
+                                        # Intentar diferentes formatos de base64
+                                        if graph_data.startswith('data:image'):
+                                            image_bytes = base64.b64decode(graph_data.split(',')[1])
+                                        else:
+                                            image_bytes = base64.b64decode(graph_data)
+                                        
+                                        st.image(image_bytes, use_column_width=True)
+                                    except:
+                                        # Si falla la decodificación, mostrar como texto si no es muy largo
+                                        if len(graph_data) < 100:
+                                            st.text(f"Datos no decodificables: {graph_data}")
+                                        else:
+                                            st.text(f"Datos no decodificables (muy largos)")
+                                
+                                # Otros tipos (matplotlib, etc.)
+                                else:
+                                    st.write(f"Gráfico presente pero en formato no mostrable")
+                            except Exception as e:
+                                st.error(f"Error mostrando gráfico: {str(e)}")
+                    
+                    # Si no hay gráficos, mostrar mensaje
+                    if not found_graphs:
+                        st.info(t.get('no_graphs', 'No hay gráficos disponibles para este análisis'))
+                    
+                    # Mostrar botón para generar nuevos gráficos (para futura implementación)
+                    # st.button("Regenerar gráficos", key=f"btn_regenerate_{str(analysis.get('_id', 'unknown'))}")
+                    
+                    # 4. Mostrar campos adicionales que puedan ser útiles
+                    with st.expander("Ver datos adicionales", expanded=False):
+                        # Filtrar campos para mostrar solo los relevantes
+                        filtered_data = {k: v for k, v in analysis.items() 
+                                       if k not in ['_id', 'username', 'timestamp', 'text1', 'text2', 
+                                                  'graph1', 'graph2', 'combined_graph', 
+                                                  'key_concepts1', 'key_concepts2']
+                                       and not isinstance(v, bytes)
+                                       and not (isinstance(v, str) and len(v) > 200)}
+                        
+                        if filtered_data:
+                            st.json(filtered_data)
+                        else:
+                            st.text("No hay datos adicionales disponibles")
 
             except Exception as e:
                 logger.error(f"Error procesando análisis individual: {str(e)}")
+                st.error(f"Error procesando análisis: {str(e)}")
                 continue
 
     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'))
+        logger.error(f"Error general en display_discourse_activities: {str(e)}")
+        st.error(t.get('error_discourse', 'Error al mostrar análisis comparado de textos'))
+
+
 
 
 #################################################################################