Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -537,173 +537,184 @@ def display_semantic_activities(username: str, t: dict):
 ###################################################################################################
 def display_discourse_activities(username: str, t: dict):
     """
-    Versión mejorada de display_discourse_activities que maneja mejor 
-    los datos faltantes y la depuración.
+    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}")
         
-        # Usar la función mejorada de recuperación
-        analyses = get_student_discourse_analysis(username)
+        # Importación inline para evitar circularidad
+        from ..database.mongo_db import get_collection
         
-        # Información de depuración
-        logger.info(f"Recuperados {len(analyses)} análisis de discurso")
-        for i, analysis in enumerate(analyses):
-            keys = list(analysis.keys())
-            logger.info(f"Análisis {i+1}: claves disponibles = {keys}")
+        # 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 comparados de textos registrados'))
             return
 
-        logger.info(f"Procesando {len(analyses)} análisis del discurso")
-        
-        for i, analysis in enumerate(analyses):
+        # Procesar cada análisis
+        for analysis in analyses:
             try:
-                # Formatear fecha con manejo de errores
+                # Formatear fecha
                 try:
                     timestamp = datetime.fromisoformat(analysis.get('timestamp', '').replace('Z', '+00:00'))
                     formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
-                except (KeyError, ValueError, TypeError) as e:
-                    logger.warning(f"Error formateando fecha: {str(e)}")
+                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 más información en el título para facilitar identificación
-                if 'text1' in analysis and analysis['text1']:
-                    text_preview = analysis['text1'][:50] + "..." if len(analysis['text1']) > 50 else analysis['text1']
-                    expander_title += f" | {text_preview}"
-                
-                # Crear expander
+                # Mostrar expander
                 with st.expander(expander_title, expanded=False):
-                    # Mostrar los datos brutos para depuración (solo durante desarrollo)
-                    st.markdown("**Datos del análisis:**")
-                    # Filtrar keys innecesarias o con datos muy grandes
-                    filtered_data = {k: v for k, v in analysis.items() 
-                                    if k not in ['_id', 'timestamp', 'text1', 'text2'] 
-                                    and not isinstance(v, bytes) 
-                                    and not (isinstance(v, str) and len(v) > 500)}
-                    st.json(filtered_data)
-                    
-                    # Mostrar textos analizados (si están disponibles)
+                    # 1. Mostrar texto analizado si existe
                     if 'text1' in analysis and analysis['text1']:
-                        with st.expander("Ver texto analizado", expanded=False):
-                            st.markdown("**Texto analizado:**")
-                            st.text_area("Texto", value=analysis['text1'], height=150, disabled=True)
+                        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'))}"
+                        )
                     
-                    # Mostrar conceptos clave (si están disponibles)
-                    has_concepts = False
-                    
-                    # Verificar si hay conceptos y son del formato correcto
-                    if ('key_concepts1' in analysis and analysis['key_concepts1'] and 
-                        isinstance(analysis['key_concepts1'], list)):
-                        has_concepts = True
+                    # 2. Mostrar conceptos clave si existen
+                    if 'key_concepts1' in analysis and analysis['key_concepts1']:
+                        st.subheader(t.get('key_concepts', 'Conceptos clave'))
                         
-                        # Crear dos columnas para los conceptos
                         col1, col2 = st.columns(2)
                         
-                        # Primera columna: conceptos del texto 1
                         with col1:
                             st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
                             try:
-                                # Intentar crear DataFrame
-                                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, use_container_width=True)
+                                # 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:
-                                    # Mostrar como lista simple
-                                    st.write(", ".join([str(item) for item in analysis['key_concepts1']]))
-                            except Exception as e:
-                                logger.error(f"Error mostrando conceptos 1: {str(e)}")
-                                st.error("Error al mostrar conceptos del Texto 1")
+                                    st.write(str(analysis['key_concepts1']))
+                            except:
+                                st.write(str(analysis['key_concepts1']))
                         
-                        # Segunda columna: conceptos del texto 2 (si existen)
                         with col2:
-                            st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
-                            if ('key_concepts2' in analysis and analysis['key_concepts2'] and 
-                                isinstance(analysis['key_concepts2'], list)):
+                            if 'key_concepts2' in analysis and analysis['key_concepts2']:
+                                st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
                                 try:
-                                    # Intentar crear DataFrame
-                                    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, use_container_width=True)
+                                    # 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:
-                                        # Mostrar como lista simple
-                                        st.write(", ".join([str(item) for item in analysis['key_concepts2']]))
-                                except Exception as e:
-                                    logger.error(f"Error mostrando conceptos 2: {str(e)}")
-                                    st.error("Error al mostrar conceptos del Texto 2")
-                            else:
-                                st.info("No hay conceptos disponibles para el Texto 2")
+                                        st.write(str(analysis['key_concepts2']))
+                                except:
+                                    st.write(str(analysis['key_concepts2']))
                     
-                    # Mostrar gráficos (si existen)
-                    has_graphs = False
-                    for graph_key, graph_title in [
-                        ('graph1', t.get('graph1_title', 'Visualización del Texto 1')),
-                        ('graph2', t.get('graph2_title', 'Visualización del Texto 2')),
-                        ('combined_graph', t.get('combined_graph_title', 'Visualización Comparativa'))
-                    ]:
-                        if graph_key in analysis and analysis[graph_key]:
-                            has_graphs = True
-                            st.markdown(f"### {graph_title}")
+                    # 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:
-                                image_data = analysis[graph_key]
+                                # Si es bytes, mostrar directamente
+                                if isinstance(graph_data, bytes):
+                                    st.image(graph_data, use_column_width=True)
                                 
-                                # Mostrar según el tipo de dato
-                                if isinstance(image_data, bytes):
-                                    st.image(image_data, use_column_width=True)
-                                elif isinstance(image_data, str):
-                                    # Intentar decodificar si es base64
+                                # Si es string, intentar decodificar como base64
+                                elif isinstance(graph_data, str):
                                     try:
                                         import base64
-                                        if image_data.startswith('data:image'):
-                                            image_bytes = base64.b64decode(image_data.split(',')[1])
+                                        # Intentar diferentes formatos de base64
+                                        if graph_data.startswith('data:image'):
+                                            image_bytes = base64.b64decode(graph_data.split(',')[1])
                                         else:
-                                            image_bytes = base64.b64decode(image_data)
+                                            image_bytes = base64.b64decode(graph_data)
+                                        
                                         st.image(image_bytes, use_column_width=True)
-                                    except Exception as decode_err:
-                                        logger.error(f"Error decodificando imagen: {str(decode_err)}")
-                                        st.error("Error decodificando imagen")
-                                elif hasattr(image_data, 'figure'):
-                                    # Si es un objeto matplotlib
-                                    st.pyplot(image_data)
+                                    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.error(f"Formato de gráfico no reconocido")
+                                    st.write(f"Gráfico presente pero en formato no mostrable")
                             except Exception as e:
-                                logger.error(f"Error mostrando gráfico {graph_key}: {str(e)}")
-                                st.error(f"Error mostrando {graph_title}")
+                                st.error(f"Error mostrando gráfico: {str(e)}")
                     
-                    # Mensaje si no hay gráficos ni conceptos
-                    if not has_graphs and not has_concepts:
-                        st.warning("No se encontraron visualizaciones ni conceptos para este análisis")
-                        
-                        # Sugerir regenerar el análisis
-                        st.markdown("""
-                        Este análisis parece estar incompleto. Posibles razones:
-                        1. El proceso de análisis no terminó correctamente
-                        2. El texto era demasiado corto o no contenía suficiente información
-                        3. Hubo un error durante la generación de visualizaciones
+                    # 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)}
                         
-                        Considera realizar un nuevo análisis con más contenido textual.
-                        """)
+                        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 en análisis #{i+1}: {str(e)}")
+                st.error(f"Error procesando análisis: {str(e)}")
                 continue
 
     except Exception as e:
-        logger.error(f"Error general mostrando análisis del discurso: {str(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'))
-        st.markdown("**Detalles del error:**")
-        st.exception(e)
 
 #################################################################################   
 def display_chat_activities(username: str, t: dict):