Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -536,193 +536,113 @@ def display_semantic_activities(username: str, t: dict):
 
 ###################################################################################################
 
-def display_discourse_activities(username: str, t: dict):
+def display_discourse_comparison(analysis: dict, t: dict):
     """
-    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
+    Muestra la comparación de análisis del discurso de manera minimalista pero efectiva.
+    Incluye tanto las tablas de conceptos como los gráficos disponibles.
     """
-    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")
-            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 analysis in analyses:
+    st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
+    
+    # 1. Mostrar conceptos en columnas
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
+        if 'key_concepts1' in analysis and analysis['key_concepts1']:
             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")
-                
-                # 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.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.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 los gráficos - siguiendo el estilo de display_semantic_activities
-                    
-                    # 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
-                    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 - 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
-                                        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 gráficos disponibles
-                    if all(analysis.get(k) is None for k in ['graph1', 'graph2', 'combined_graph']):
-                        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.
-                                        """))
-
+                df1 = pd.DataFrame(analysis['key_concepts1'], 
+                                  columns=['Concepto', 'Relevancia'])
+                st.dataframe(df1)
             except Exception as e:
-                logger.error(f"Error procesando análisis individual: {str(e)}")
-                continue
-
-    except Exception as 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'))
-
-
-
-
-
+                # En caso de error, mostrar los datos sin procesar
+                st.write(analysis['key_concepts1'])
+        else:
+            st.info(t.get('no_concepts1', 'No hay conceptos disponibles'))
+    
+    with col2:
+        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+        if 'key_concepts2' in analysis and analysis['key_concepts2']:
+            try:
+                df2 = pd.DataFrame(analysis['key_concepts2'], 
+                                  columns=['Concepto', 'Relevancia'])
+                st.dataframe(df2)
+            except Exception as e:
+                # En caso de error, mostrar los datos sin procesar
+                st.write(analysis['key_concepts2'])
+        else:
+            st.info(t.get('no_concepts2', 'No hay conceptos disponibles'))
+    
+    # 2. Mostrar los gráficos si están disponibles
+    st.markdown("---")  # Separador
+    
+    # Verificar y mostrar gráficos
+    has_graphs = False
+    
+    # Gráfico 1
+    if 'graph1' in analysis and analysis['graph1']:
+        has_graphs = True
+        st.markdown(f"### {t.get('graph1_title', 'Gráfico Texto 1')}")
+        try:
+            # Intentar mostrar gráfico (asumiendo que es bytes o base64)
+            if isinstance(analysis['graph1'], bytes):
+                st.image(analysis['graph1'], use_column_width=True)
+            elif isinstance(analysis['graph1'], str):
+                import base64
+                try:
+                    image_bytes = base64.b64decode(analysis['graph1'])
+                    st.image(image_bytes, use_column_width=True)
+                except:
+                    st.error(t.get('error_decoding', 'Error decodificando imagen'))
+            else:
+                # Intentar como objeto matplotlib
+                st.pyplot(analysis['graph1'])
+        except Exception as e:
+            st.error(t.get('error_graph1', 'Error mostrando gráfico 1'))
+    
+    # Gráfico 2
+    if 'graph2' in analysis and analysis['graph2']:
+        has_graphs = True
+        st.markdown(f"### {t.get('graph2_title', 'Gráfico Texto 2')}")
+        try:
+            # Intentar mostrar gráfico (asumiendo que es bytes o base64)
+            if isinstance(analysis['graph2'], bytes):
+                st.image(analysis['graph2'], use_column_width=True)
+            elif isinstance(analysis['graph2'], str):
+                import base64
+                try:
+                    image_bytes = base64.b64decode(analysis['graph2'])
+                    st.image(image_bytes, use_column_width=True)
+                except:
+                    st.error(t.get('error_decoding', 'Error decodificando imagen'))
+            else:
+                # Intentar como objeto matplotlib
+                st.pyplot(analysis['graph2'])
+        except Exception as e:
+            st.error(t.get('error_graph2', 'Error mostrando gráfico 2'))
+    
+    # Gráfico combinado
+    if 'combined_graph' in analysis and analysis['combined_graph']:
+        has_graphs = True
+        st.markdown(f"### {t.get('combined_graph_title', 'Gráfico Comparativo')}")
+        try:
+            # Intentar mostrar gráfico (asumiendo que es bytes o base64)
+            if isinstance(analysis['combined_graph'], bytes):
+                st.image(analysis['combined_graph'], use_column_width=True)
+            elif isinstance(analysis['combined_graph'], str):
+                import base64
+                try:
+                    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:
+                # Intentar como objeto matplotlib
+                st.pyplot(analysis['combined_graph'])
+        except Exception as e:
+            st.error(t.get('error_combined_graph', 'Error mostrando gráfico comparativo'))
+    
+    # Mensaje si no hay gráficos
+    if not has_graphs:
+        st.info(t.get('no_graphs_available', 'No hay visualizaciones disponibles para este análisis.'))
 
 
 #################################################################################