Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -538,7 +538,8 @@ def display_semantic_activities(username: str, t: dict):
 
 def display_discourse_activities(username: str, t: dict):
     """
-    Muestra actividades de análisis del discurso centradas en las visualizaciones comparativas
+    Muestra actividades de análisis del discurso (análisis comparado de textos)
+    con enfoque en mostrar los gráficos de manera similar al análisis semántico
     """
     try:
         logger.info(f"Recuperando análisis del discurso para {username}")
@@ -552,97 +553,163 @@ def display_discourse_activities(username: str, t: dict):
         logger.info(f"Procesando {len(analyses)} análisis del discurso")
         for analysis in analyses:
             try:
+                # Verificar campos necesarios
+                if 'timestamp' not in analysis:
+                    logger.warning(f"Análisis sin timestamp: {analysis.keys()}")
+                    continue
+
                 # Formatear fecha
                 timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
                 formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
                 
-                # Título del expander
-                expander_title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
-                
-                with st.expander(expander_title, expanded=False):
-                    # Mostrar conceptos clave en dos columnas
+                # Crear expander para cada análisis
+                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
+                    # Mostrar conceptos clave primero - esto da contexto al análisis
                     if 'key_concepts1' in analysis and 'key_concepts2' in analysis:
                         col1, col2 = st.columns(2)
                         
                         with col1:
-                            st.subheader(t.get('concepts_text_1', 'Conceptos Texto 1'))
+                            st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
                             if analysis['key_concepts1']:
                                 df1 = pd.DataFrame(analysis['key_concepts1'], columns=['Concepto', 'Relevancia'])
                                 st.dataframe(df1, use_container_width=True)
                         
                         with col2:
-                            st.subheader(t.get('concepts_text_2', 'Conceptos Texto 2'))
+                            st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
                             if analysis['key_concepts2']:
                                 df2 = pd.DataFrame(analysis['key_concepts2'], columns=['Concepto', 'Relevancia'])
                                 st.dataframe(df2, use_container_width=True)
                     
-                    # Mostrar visualizaciones semánticas
-                    st.subheader(t.get('semantic_visualization', 'Visualización Semántica'))
+                    # Mostrar los gráficos - siguiendo el estilo de display_semantic_activities
                     
-                    # Mostrar gráficos en fila
-                    graph_cols = st.columns(3)
-                    
-                    # Gráfico 1 (si existe)
-                    with graph_cols[0]:
-                        if analysis.get('graph1'):
-                            try:
-                                st.caption(t.get('graph1_caption', 'Grafo Texto 1'))
-                                if isinstance(analysis['graph1'], str) and analysis['graph1'].startswith('data:image'):
-                                    import base64
-                                    image_bytes = base64.b64decode(analysis['graph1'].split(',')[1])
-                                    st.image(image_bytes, use_column_width=True)
-                                elif isinstance(analysis['graph1'], bytes):
-                                    st.image(analysis['graph1'], use_column_width=True)
-                                elif analysis['graph1'] is not None:
-                                    st.pyplot(analysis['graph1'])
-                            except Exception as e:
-                                logger.error(f"Error mostrando gráfico 1: {str(e)}")
-                                st.error(t.get('error_graph1', 'Error mostrando gráfico 1'))
+                    # Gráfico 1
+                    if analysis.get('graph1'):
+                        st.markdown("### " + t.get('graph1_title', 'Red de Conceptos - Texto 1'))
+                        try:
+                            image_data = analysis['graph1']
+                            
+                            # Procesar la imagen según su tipo
+                            if isinstance(image_data, bytes):
+                                image_bytes = image_data
+                            elif isinstance(image_data, str):
+                                # Intentar decodificar base64
+                                try:
+                                    if image_data.startswith('data:image'):
+                                        # Formato data URI
+                                        import base64
+                                        image_bytes = base64.b64decode(image_data.split(',')[1])
+                                    else:
+                                        # Base64 directo
+                                        import base64
+                                        image_bytes = base64.b64decode(image_data)
+                                except:
+                                    logger.error("Error decodificando imagen 1")
+                                    image_bytes = None
+                            else:
+                                # Si es otro tipo (como un objeto matplotlib figure)
+                                st.pyplot(image_data)
+                                image_bytes = None
+                            
+                            # Mostrar imagen si tenemos bytes
+                            if image_bytes:
+                                st.image(
+                                    image_bytes,
+                                    caption=t.get('graph1_caption', 'Red Semántica del Texto 1'),
+                                    use_column_width=True
+                                )
+                        except Exception as e:
+                            logger.error(f"Error mostrando gráfico 1: {str(e)}")
+                            st.error(t.get('error_graph1', 'Error al cargar el gráfico del Texto 1'))
                     
-                    # Gráfico 2 (si existe)
-                    with graph_cols[1]:
-                        if analysis.get('graph2'):
-                            try:
-                                st.caption(t.get('graph2_caption', 'Grafo Texto 2'))
-                                if isinstance(analysis['graph2'], str) and analysis['graph2'].startswith('data:image'):
-                                    import base64
-                                    image_bytes = base64.b64decode(analysis['graph2'].split(',')[1])
-                                    st.image(image_bytes, use_column_width=True)
-                                elif isinstance(analysis['graph2'], bytes):
-                                    st.image(analysis['graph2'], use_column_width=True)
-                                elif analysis['graph2'] is not None:
-                                    st.pyplot(analysis['graph2'])
-                            except Exception as e:
-                                logger.error(f"Error mostrando gráfico 2: {str(e)}")
-                                st.error(t.get('error_graph2', 'Error mostrando gráfico 2'))
+                    # Gráfico 2
+                    if analysis.get('graph2'):
+                        st.markdown("### " + t.get('graph2_title', 'Red de Conceptos - Texto 2'))
+                        try:
+                            image_data = analysis['graph2']
+                            
+                            # Procesar la imagen según su tipo
+                            if isinstance(image_data, bytes):
+                                image_bytes = image_data
+                            elif isinstance(image_data, str):
+                                # Intentar decodificar base64
+                                try:
+                                    if image_data.startswith('data:image'):
+                                        # Formato data URI
+                                        import base64
+                                        image_bytes = base64.b64decode(image_data.split(',')[1])
+                                    else:
+                                        # Base64 directo
+                                        import base64
+                                        image_bytes = base64.b64decode(image_data)
+                                except:
+                                    logger.error("Error decodificando imagen 2")
+                                    image_bytes = None
+                            else:
+                                # Si es otro tipo (como un objeto matplotlib figure)
+                                st.pyplot(image_data)
+                                image_bytes = None
+                            
+                            # Mostrar imagen si tenemos bytes
+                            if image_bytes:
+                                st.image(
+                                    image_bytes,
+                                    caption=t.get('graph2_caption', 'Red Semántica del Texto 2'),
+                                    use_column_width=True
+                                )
+                        except Exception as e:
+                            logger.error(f"Error mostrando gráfico 2: {str(e)}")
+                            st.error(t.get('error_graph2', 'Error al cargar el gráfico del Texto 2'))
                     
-                    # Gráfico combinado (si existe) - en la última columna
-                    with graph_cols[2]:
-                        if analysis.get('combined_graph'):
-                            try:
-                                st.caption(t.get('combined_graph_caption', 'Grafo Comparativo'))
-                                if isinstance(analysis['combined_graph'], str):
-                                    try:
+                    # Gráfico combinado - el más importante
+                    if analysis.get('combined_graph'):
+                        st.markdown("### " + t.get('combined_graph_title', 'Análisis Comparativo de Textos'))
+                        try:
+                            image_data = analysis['combined_graph']
+                            
+                            # Procesar la imagen según su tipo
+                            if isinstance(image_data, bytes):
+                                image_bytes = image_data
+                            elif isinstance(image_data, str):
+                                # Intentar decodificar base64
+                                try:
+                                    if image_data.startswith('data:image'):
+                                        # Formato data URI
+                                        import base64
+                                        image_bytes = base64.b64decode(image_data.split(',')[1])
+                                    else:
+                                        # Base64 directo
                                         import base64
-                                        # Intentar diferentes formatos de base64
-                                        if analysis['combined_graph'].startswith('data:image'):
-                                            image_bytes = base64.b64decode(analysis['combined_graph'].split(',')[1])
-                                        else:
-                                            image_bytes = base64.b64decode(analysis['combined_graph'])
-                                        st.image(image_bytes, use_column_width=True)
-                                    except:
-                                        logger.error("Error decodificando imagen combinada")
-                                elif isinstance(analysis['combined_graph'], bytes):
-                                    st.image(analysis['combined_graph'], use_column_width=True)
-                                elif analysis['combined_graph'] is not None:
-                                    st.pyplot(analysis['combined_graph'])
-                            except Exception as e:
-                                logger.error(f"Error mostrando gráfico combinado: {str(e)}")
-                                st.error(t.get('error_combined_graph', 'Error mostrando gráfico combinado'))
+                                        image_bytes = base64.b64decode(image_data)
+                                except:
+                                    logger.error("Error decodificando imagen combinada")
+                                    image_bytes = None
+                            else:
+                                # Si es otro tipo (como un objeto matplotlib figure)
+                                st.pyplot(image_data)
+                                image_bytes = None
+                            
+                            # Mostrar imagen si tenemos bytes
+                            if image_bytes:
+                                st.image(
+                                    image_bytes,
+                                    caption=t.get('combined_graph_caption', 'Visualización Comparativa de Redes Semánticas'),
+                                    use_column_width=True
+                                )
+                        except Exception as e:
+                            logger.error(f"Error mostrando gráfico combinado: {str(e)}")
+                            st.error(t.get('error_combined_graph', 'Error al cargar el gráfico comparativo'))
                     
-                    # Si no hay ningún gráfico disponible
+                    # Si no hay gráficos disponibles
                     if all(analysis.get(k) is None for k in ['graph1', 'graph2', 'combined_graph']):
-                        st.info(t.get('no_visualizations', 'No hay visualizaciones disponibles para este análisis'))
+                        st.info(t.get('no_graphs', 'No hay visualizaciones disponibles para este análisis'))
+                        
+                        # Si tenemos al menos los conceptos clave, mostrar un mensaje más descriptivo
+                        if 'key_concepts1' in analysis and 'key_concepts2' in analysis:
+                            st.markdown(t.get('concepts_only_message', 
+                                        """
+                                        **Solo se muestran los conceptos clave extraídos de los textos.**
+                                        Las visualizaciones gráficas no están disponibles para este análisis.
+                                        """))
 
             except Exception as e:
                 logger.error(f"Error procesando análisis individual: {str(e)}")