Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -537,13 +537,14 @@ 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)"""
     try:
         logger.info(f"Recuperando análisis del discurso para {username}")
         analyses = get_student_discourse_analysis(username)
         
         if not analyses:
             logger.info("No se encontraron análisis del discurso")
+            # Usamos el término "análisis comparado de textos" en la UI
             st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
             return
 
@@ -551,8 +552,8 @@ def display_discourse_activities(username: str, t: dict):
         for analysis in analyses:
             try:
                 # Verificar campos mínimos necesarios
-                if 'timestamp' not in analysis:
-                    logger.warning(f"Análisis sin timestamp: {analysis.keys()}")
+                if not all(key in analysis for key in ['timestamp', 'graph1', 'graph2']):
+                    logger.warning(f"Análisis incompleto: {analysis.keys()}")
                     continue
 
                 # Formatear fecha
@@ -560,63 +561,91 @@ def display_discourse_activities(username: str, t: dict):
                 formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
                 
                 with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
-                    # Mostrar conceptos clave en fila
-                    if 'key_concepts1' in analysis and 'key_concepts2' in analysis:
-                        st.markdown("### Conceptos clave")
-                        
-                        # Documento 1
-                        st.markdown("**Documento 1**")
-                        if analysis['key_concepts1']:
-                            # Extraer solo los conceptos sin la frecuencia
-                            concepts1 = [concept for concept, _ in analysis['key_concepts1']]
-                            # Mostrar en formato de fila
-                            st.markdown(", ".join([f"**{concept}**" for concept in concepts1]))
-                        
-                        # Documento 2
-                        st.markdown("**Documento 2**")
-                        if analysis['key_concepts2']:
-                            # Extraer solo los conceptos sin la frecuencia
-                            concepts2 = [concept for concept, _ in analysis['key_concepts2']]
-                            # Mostrar en formato de fila
-                            st.markdown(", ".join([f"**{concept}**" for concept in concepts2]))
+                    # Mostrar textos originales si están disponibles
+                    if 'text1' in analysis and 'text2' in analysis:
+                        st.subheader(t.get('analyzed_texts', 'Textos analizados'))
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.markdown(f"**{t.get('doc1_title', 'Documento 1')}**")
+                            st.text_area(
+                                "Text Content 1", 
+                                value=analysis['text1'], 
+                                height=100,
+                                disabled=True,
+                                label_visibility="collapsed",
+                                key=f"text_area_1_{timestamp}"
+                            )
+                        with col2:
+                            st.markdown(f"**{t.get('doc2_title', 'Documento 2')}**")
+                            st.text_area(
+                                "Text Content 2", 
+                                value=analysis['text2'], 
+                                height=100,
+                                disabled=True,
+                                label_visibility="collapsed",
+                                key=f"text_area_2_{timestamp}"
+                            )
+                    
+                    # Mostrar conceptos clave
+                    st.subheader(t.get('key_concepts', 'Conceptos clave'))
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.markdown(f"**{t.get('doc1_title', 'Documento 1')}**")
+                        if 'key_concepts1' in analysis:
+                            concepts1 = ", ".join([concept for concept, _ in analysis['key_concepts1']])
+                            st.markdown(concepts1)
+                        else:
+                            st.info(t.get('no_concepts', 'No hay conceptos disponibles'))
                     
-                    # Mostrar gráficos
-                    st.markdown("### Visualización comparativa")
+                    with col2:
+                        st.markdown(f"**{t.get('doc2_title', 'Documento 2')}**")
+                        if 'key_concepts2' in analysis:
+                            concepts2 = ", ".join([concept for concept, _ in analysis['key_concepts2']])
+                            st.markdown(concepts2)
+                        else:
+                            st.info(t.get('no_concepts', 'No hay conceptos disponibles'))
                     
-                    # Verificar y mostrar gráficos si existen
-                    graph_col1, graph_col2 = st.columns(2)
-                    has_graphs = False
+                    # Mostrar visualizaciones
+                    st.subheader(t.get('comparison_visualization', 'Visualización comparativa'))
                     
-                    with graph_col1:
-                        if 'graph1' in analysis and analysis['graph1']:
+                    # Mostrar los gráficos lado a lado
+                    col1, col2 = st.columns(2)
+                    
+                    # Gráfico 1
+                    with col1:
+                        st.markdown(f"**{t.get('analysis_doc1', 'Análisis del primer texto')}**")
+                        if 'graph1' in analysis:
                             try:
-                                # Verificar que sea bytes
-                                if isinstance(analysis['graph1'], bytes):
-                                    st.image(analysis['graph1'], 
-                                            caption="Documento 1", 
-                                            use_container_width=True)  # Usar use_container_width en lugar de use_column_width
-                                    has_graphs = True
-                                else:
-                                    logger.warning(f"graph1 no es bytes: {type(analysis['graph1'])}")
+                                image_bytes1 = base64.b64decode(analysis['graph1'])
+                                st.image(image_bytes1, use_container_width=True)
                             except Exception as img_error:
-                                logger.error(f"Error mostrando graph1: {str(img_error)}")
+                                logger.error(f"Error decodificando imagen 1: {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 disponible'))
                     
-                    with graph_col2:
-                        if 'graph2' in analysis and analysis['graph2']:
+                    # Gráfico 2
+                    with col2:
+                        st.markdown(f"**{t.get('analysis_doc2', 'Análisis del segundo texto')}**")
+                        if 'graph2' in analysis:
                             try:
-                                # Verificar que sea bytes
-                                if isinstance(analysis['graph2'], bytes):
-                                    st.image(analysis['graph2'], 
-                                            caption="Documento 2", 
-                                            use_container_width=True)  # Usar use_container_width en lugar de use_column_width
-                                    has_graphs = True
-                                else:
-                                    logger.warning(f"graph2 no es bytes: {type(analysis['graph2'])}")
+                                image_bytes2 = base64.b64decode(analysis['graph2'])
+                                st.image(image_bytes2, use_container_width=True)
                             except Exception as img_error:
-                                logger.error(f"Error mostrando graph2: {str(img_error)}")
+                                logger.error(f"Error decodificando imagen 2: {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 disponible'))
+                    
+                    # Añadir leyenda de interpretación
+                    st.markdown("### 📊 " + t.get('graph_interpretation', 'Interpretación del grafo:'))
                     
-                    if not has_graphs:
-                        st.info(t.get('no_visualization', 'No hay visualización comparativa disponible'))
+                    st.markdown("""
+                    * 🔀 Las flechas indican la dirección de la relación entre conceptos
+                    * 🎨 Los colores más intensos indican conceptos más centrales en el texto
+                    * ⭕ El tamaño de los nodos representa la frecuencia del concepto
+                    * ↔️ El grosor de las líneas indica la fuerza de la conexión
+                    """)
 
             except Exception as e:
                 logger.error(f"Error procesando análisis individual: {str(e)}")
@@ -624,8 +653,12 @@ def display_discourse_activities(username: str, t: dict):
 
     except Exception as e:
         logger.error(f"Error mostrando análisis del discurso: {str(e)}")
+        # Usamos el término "análisis comparado de textos" en la UI
         st.error(t.get('error_discourse', 'Error al mostrar análisis comparado de textos'))
 
+
+
+
 #################################################################################   
 
 def display_discourse_comparison(analysis: dict, t: dict):