Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -536,185 +536,49 @@ def display_semantic_activities(username: str, t: dict):
 
 ###################################################################################################
 def display_discourse_activities(username: str, t: dict):
-    """
-    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
-    """
+    """Muestra actividades de análisis del discurso"""
     try:
         logger.info(f"Recuperando análisis del discurso para {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 = []
+        analyses = get_student_discourse_analysis(username)
         
         if not analyses:
-            st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
+            logger.info("No se encontraron análisis del discurso")
+            st.info(t.get('no_discourse_analyses', 'No hay análisis del discurso registrados'))
             return
 
-        # Procesar cada análisis
+        logger.info(f"Procesando {len(analyses)} análisis del discurso")
         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
-                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'))
-                
-                # Crear título del expander
-                expander_title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
+                timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
+                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
                 
-                # 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")
+                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'))
 
             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 general en display_discourse_activities: {str(e)}")
-        st.error(t.get('error_discourse', 'Error al mostrar análisis comparado de textos'))
+        logger.error(f"Error mostrando análisis del discurso: {str(e)}")
+        st.error(t.get('error_discourse', 'Error al mostrar análisis del discurso'))
+
 
 #################################################################################   
 def display_chat_activities(username: str, t: dict):
@@ -767,3 +631,18 @@ def display_chat_activities(username: str, t: dict):
         st.error(t.get('error_chat', 'Error al mostrar historial del chat'))
         
 #################################################################################        
+
+def display_discourse_comparison(analysis: dict, t: dict):
+    """Muestra la comparación de análisis del discurso"""
+    st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
+        df1 = pd.DataFrame(analysis['key_concepts1'])
+        st.dataframe(df1)
+    
+    with col2:
+        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+        df2 = pd.DataFrame(analysis['key_concepts2'])
+        st.dataframe(df2)