Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -538,186 +538,155 @@ 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 en la sección de historial
     """
     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 análisis - usando la función existente
+        analyses = get_student_discourse_analysis(username)
         
-        # Obtener la colección directamente para evitar cualquier filtrado
-        collection = get_collection('student_discourse_analysis')
-        if not collection:
+        if not analyses:
+            logger.info("No se encontraron análisis del discurso")
             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}
+        logger.info(f"Procesando {len(analyses)} análisis del discurso")
         
-        # 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:
-            st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
-            return
-
-        # Procesar cada análisis
         for analysis in analyses:
             try:
-                # Formatear fecha
+                # Formatear fecha - con manejo de errores mejorado
                 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}"
-                
-                # 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
+                # 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']:
-                        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']))
+                        # Usar la función de comparación existente para mostrar conceptos
+                        display_discourse_comparison(analysis, t)
                     
-                    # 3. Mostrar cualquier gráfico disponible
-                    st.subheader(t.get('visualizations', 'Visualizaciones'))
+                    # Mostrar gráficos - intentando diferentes campos y formatos
+                    has_graphs = False
                     
-                    # 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')
+                    # Primero intentar el gráfico combinado
+                    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):
+                                try:
+                                    import base64
+                                    image_bytes = base64.b64decode(analysis['combined_graph'])
+                                    st.image(image_bytes, use_column_width=True)
+                                except:
+                                    st.error(t.get('error_decoding', 'Error decodificando imagen'))
                             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]
-                            
+                                st.error(t.get('unknown_format', 'Formato de imagen desconocido'))
+                        except Exception as e:
+                            logger.error(f"Error mostrando combined_graph: {str(e)}")
+                            st.error(t.get('error_graph', 'Error mostrando visualización'))
+                    
+                    # Luego intentar gráficos individuales
+                    for graph_key, title in [
+                        ('graph1', t.get('graph1_title', 'Visualización Texto 1')),
+                        ('graph2', t.get('graph2_title', 'Visualización Texto 2'))
+                    ]:
+                        if graph_key in analysis and analysis[graph_key]:
+                            has_graphs = True
+                            st.markdown(f"### {title}")
                             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):
+                                # Si es bytes directamente
+                                if isinstance(analysis[graph_key], bytes):
+                                    st.image(analysis[graph_key], use_column_width=True)
+                                # Si es string base64
+                                elif isinstance(analysis[graph_key], 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)
-                                        
+                                        image_bytes = base64.b64decode(analysis[graph_key])
                                         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.)
+                                        st.error(t.get('error_decoding', 'Error decodificando imagen'))
                                 else:
-                                    st.write(f"Gráfico presente pero en formato no mostrable")
+                                    st.error(t.get('unknown_format', 'Formato de imagen desconocido'))
                             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'))
+                                logger.error(f"Error mostrando {graph_key}: {str(e)}")
+                                st.error(t.get('error_graph', f'Error mostrando {title}'))
                     
-                    # 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")
+                    # 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)}")
-                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)}")
+        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'))
 
+#################################################################################   
 
+def display_discourse_comparison(analysis: dict, t: dict):
+    """
+    Muestra la comparación de conceptos clave en análisis del discurso.
+    Mejorada para manejar diferentes formatos y errores.
+    """
+    st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
+    
+    # Verificar si tenemos los conceptos necesarios
+    if not ('key_concepts1' in analysis and analysis['key_concepts1']):
+        st.info(t.get('no_concepts', 'No hay conceptos disponibles para comparar'))
+        return
+    
+    # Mostrar en dos columnas
+    col1, col2 = st.columns(2)
+    
+    # Columna 1: Conceptos del texto 1
+    with col1:
+        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
+        try:
+            # Comprobar formato y crear DataFrame
+            if isinstance(analysis['key_concepts1'], list) and len(analysis['key_concepts1']) > 0:
+                if isinstance(analysis['key_concepts1'][0], list) and len(analysis['key_concepts1'][0]) == 2:
+                    df1 = pd.DataFrame(analysis['key_concepts1'], columns=['Concepto', 'Relevancia'])
+                    st.dataframe(df1)
+                else:
+                    # Si no tiene el formato esperado, mostrar como lista
+                    st.write(", ".join(str(c) for c in analysis['key_concepts1']))
+            else:
+                st.write(str(analysis['key_concepts1']))
+        except Exception as e:
+            logger.error(f"Error mostrando key_concepts1: {str(e)}")
+            st.error(t.get('error_concepts1', 'Error mostrando conceptos del Texto 1'))
+    
+    # Columna 2: Conceptos del texto 2
+    with col2:
+        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+        if 'key_concepts2' in analysis and analysis['key_concepts2']:
+            try:
+                # Comprobar formato y crear DataFrame
+                if isinstance(analysis['key_concepts2'], list) and len(analysis['key_concepts2']) > 0:
+                    if isinstance(analysis['key_concepts2'][0], list) and len(analysis['key_concepts2'][0]) == 2:
+                        df2 = pd.DataFrame(analysis['key_concepts2'], columns=['Concepto', 'Relevancia'])
+                        st.dataframe(df2)
+                    else:
+                        # Si no tiene el formato esperado, mostrar como lista
+                        st.write(", ".join(str(c) for c in analysis['key_concepts2']))
+                else:
+                    st.write(str(analysis['key_concepts2']))
+            except Exception as e:
+                logger.error(f"Error mostrando key_concepts2: {str(e)}")
+                st.error(t.get('error_concepts2', 'Error mostrando conceptos del Texto 2'))
+        else:
+            st.info(t.get('no_concepts2', 'No hay conceptos disponibles para el Texto 2'))
 
 
 #################################################################################   
@@ -771,18 +740,3 @@ 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)