Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -515,7 +515,7 @@ def display_semantic_activities(username: str, t: dict):
                             st.image(
                                 image_bytes,
                                 caption=t.get('concept_network', 'Red de Conceptos'),
-                                use_container_width=True 
+                                use_column_width=True
                             )
                             logger.debug("Gráfico mostrado exitosamente")
                             
@@ -537,9 +537,7 @@ 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"""
     try:
         logger.info(f"Recuperando análisis del discurso para {username}")
         analyses = get_student_discourse_analysis(username)
@@ -552,97 +550,73 @@ 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 mínimos 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
+                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:
-                        col1, col2 = st.columns(2)
+                        st.markdown("### Conceptos clave")
                         
-                        with col1:
-                            st.subheader(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)
+                        # 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]))
                         
-                        with col2:
-                            st.subheader(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)
+                        # 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 visualizaciones semánticas
-                    st.subheader(t.get('semantic_visualization', 'Visualización Semántica'))
+                    # Mostrar gráficos
+                    st.markdown("### Visualización comparativa")
                     
-                    # Mostrar gráficos en fila
-                    graph_cols = st.columns(3)
+                    # Verificar y mostrar gráficos si existen
+                    graph_col1, graph_col2 = st.columns(2)
+                    has_graphs = False
                     
-                    # Gráfico 1 (si existe)
-                    with graph_cols[0]:
-                        if analysis.get('graph1'):
+                    with graph_col1:
+                        if 'graph1' in analysis and analysis['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'))
+                                # 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'])}")
+                            except Exception as img_error:
+                                logger.error(f"Error mostrando graph1: {str(img_error)}")
                     
-                    # Gráfico 2 (si existe)
-                    with graph_cols[1]:
-                        if analysis.get('graph2'):
+                    with graph_col2:
+                        if 'graph2' in analysis and analysis['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'))
+                                # 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'])}")
+                            except Exception as img_error:
+                                logger.error(f"Error mostrando graph2: {str(img_error)}")
                     
-                    # 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:
-                                        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'))
-                    
-                    # Si no hay ningún gráfico disponible
-                    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'))
+                    if not has_graphs:
+                        st.info(t.get('no_visualization', 'No hay visualización comparativa disponible'))
 
             except Exception as e:
                 logger.error(f"Error procesando análisis individual: {str(e)}")
@@ -652,6 +626,59 @@ def display_discourse_activities(username: str, t: dict):
         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.
+    Formato horizontal simplificado.
+    """
+    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
+    
+    # Conceptos del Texto 1 - Formato horizontal
+    st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}:**")
+    try:
+        # Comprobar formato y mostrar horizontalmente
+        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:
+                # Formatear como "concepto (valor), concepto2 (valor2), ..."
+                concepts_text = ", ".join([f"{c[0]} ({c[1]})" for c in analysis['key_concepts1'][:10]])
+                st.markdown(f"*{concepts_text}*")
+            else:
+                # Si no tiene el formato esperado, mostrar como lista simple
+                st.markdown(", ".join(str(c) for c in analysis['key_concepts1'][:10]))
+        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'))
+    
+    # Conceptos del Texto 2 - Formato horizontal
+    st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}:**")
+    if 'key_concepts2' in analysis and analysis['key_concepts2']:
+        try:
+            # Comprobar formato y mostrar horizontalmente
+            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:
+                    # Formatear como "concepto (valor), concepto2 (valor2), ..."
+                    concepts_text = ", ".join([f"{c[0]} ({c[1]})" for c in analysis['key_concepts2'][:10]])
+                    st.markdown(f"*{concepts_text}*")
+                else:
+                    # Si no tiene el formato esperado, mostrar como lista simple
+                    st.markdown(", ".join(str(c) for c in analysis['key_concepts2'][:10]))
+            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'))
+
 
 #################################################################################   
 def display_chat_activities(username: str, t: dict):
@@ -704,18 +731,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"""
-    # Cambiado para usar "textos comparados" en la UI
-    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)