Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -538,11 +538,8 @@ def display_semantic_activities(username: str, t: dict):
 
 def display_discourse_activities(username: str, t: dict):
     """
-    Función mejorada para mostrar análisis de discurso que:
-    1. Evita expanders anidados
-    2. Usa keys únicos para todos los elementos
-    3. Muestra los conceptos clave en formato horizontal
-    4. Maneja correctamente la verificación de colección MongoDB
+    Muestra actividades de análisis del discurso con visualizaciones gráficas
+    en el mismo formato que la interfaz principal
     """
     try:
         # Importar directamente la colección
@@ -567,6 +564,49 @@ def display_discourse_activities(username: str, t: dict):
             st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
             return
         
+        # Estilo CSS similar al de la interfaz principal
+        st.markdown("""
+            <style>
+            .concepts-container {
+                display: flex;
+                flex-wrap: nowrap;
+                gap: 8px;
+                padding: 12px;
+                background-color: #f8f9fa;
+                border-radius: 8px;
+                overflow-x: auto;
+                margin-bottom: 15px;
+                white-space: nowrap;
+            }
+            .concept-item {
+                background-color: white;
+                border-radius: 4px;
+                padding: 6px 10px;
+                display: inline-flex;
+                align-items: center;
+                gap: 4px;
+                box-shadow: 0 1px 2px rgba(0,0,0,0.1);
+                flex-shrink: 0;
+            }
+            .concept-name {
+                font-weight: 500;
+                color: #1f2937;
+                font-size: 0.85em;
+            }
+            .concept-freq {
+                color: #6b7280;
+                font-size: 0.75em;
+            }
+            .graph-container {
+                background-color: white;
+                padding: 15px;
+                border-radius: 8px;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                margin-top: 10px;
+            }
+            </style>
+        """, unsafe_allow_html=True)
+        
         # Mostrar cada resultado
         for i, doc in enumerate(results):
             try:
@@ -587,118 +627,165 @@ def display_discourse_activities(username: str, t: dict):
                 # Crear expander
                 expander_label = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
                 with st.expander(expander_label, expanded=False):
-                    # Mostrar texto si existe
-                    if 'text1' in doc and doc['text1']:
-                        st.text_area(
-                            "Texto analizado", 
-                            value=doc['text1'], 
-                            height=100, 
-                            disabled=True,
-                            key=f"text1_{doc_id}"  # Key único para este text_area
-                        )
+                    # Crear columnas como en la interfaz principal
+                    col1, col2 = st.columns(2)
                     
-                    # Mostrar conceptos clave en formato horizontal
-                    if 'key_concepts1' in doc and doc['key_concepts1']:
-                        st.subheader(t.get('key_concepts', 'Conceptos clave'))
+                    # Columna 1: Documento 1
+                    with col1:
+                        st.subheader(t.get('doc1_title', 'Documento 1'))
+                        st.markdown(t.get('key_concepts', 'Conceptos Clave'))
                         
-                        # Formatear conceptos del texto 1 - Formato horizontal
-                        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}:**")
-                        try:
-                            concepts = doc['key_concepts1']
-                            if isinstance(concepts, list):
-                                if len(concepts) > 0:
-                                    # Revisar el formato
-                                    if isinstance(concepts[0], list) and len(concepts[0]) == 2:
-                                        # Formato esperado: [["concepto", valor], ...]
-                                        # Mostrar en formato horizontal
-                                        concept_text = ", ".join([f"{c[0]} ({c[1]})" for c in concepts[:10]])
-                                        st.markdown(f"*{concept_text}*")
-                                    else:
-                                        # Otro formato de lista
-                                        st.markdown(", ".join(str(c) for c in concepts[:10]))
-                                else:
-                                    st.info("No hay conceptos disponibles")
-                            else:
-                                st.write(str(concepts))
-                        except Exception as e:
-                            logger.error(f"Error mostrando conceptos 1: {str(e)}")
-                            st.error("Error mostrando conceptos")
-                    
-                    # Conceptos del texto 2 (si existen)
-                    if 'key_concepts2' in doc and doc['key_concepts2']:
-                        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}:**")
-                        try:
-                            concepts = doc['key_concepts2']
-                            if isinstance(concepts, list):
-                                if len(concepts) > 0:
-                                    # Revisar el formato
-                                    if isinstance(concepts[0], list) and len(concepts[0]) == 2:
-                                        # Formato esperado: [["concepto", valor], ...]
-                                        # Mostrar en formato horizontal
-                                        concept_text = ", ".join([f"{c[0]} ({c[1]})" for c in concepts[:10]])
-                                        st.markdown(f"*{concept_text}*")
-                                    else:
-                                        # Otro formato de lista
-                                        st.markdown(", ".join(str(c) for c in concepts[:10]))
+                        if 'key_concepts1' in doc and doc['key_concepts1']:
+                            try:
+                                # Usar el mismo formato visual de conceptos que en la interfaz principal
+                                concepts_html = f"""
+                                    <div class="concepts-container">
+                                        {''.join([
+                                            f'<div class="concept-item"><span class="concept-name">{concept}</span>'
+                                            f'<span class="concept-freq">({freq})</span></div>'
+                                            for concept, freq in doc['key_concepts1']
+                                        ])}
+                                    </div>
+                                """
+                                st.markdown(concepts_html, unsafe_allow_html=True)
+                                
+                                # Mostrar gráfico si existe
+                                if 'graph1' in doc and doc['graph1']:
+                                    try:
+                                        st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                                        
+                                        # Manejar diferentes formatos de gráfico
+                                        if isinstance(doc['graph1'], bytes):
+                                            st.image(doc['graph1'], caption=t.get('graph1_caption', 'Grafo del Texto 1'), use_column_width=True)
+                                        elif isinstance(doc['graph1'], str):
+                                            try:
+                                                import base64
+                                                # Intentar diferentes formatos de base64
+                                                try:
+                                                    if doc['graph1'].startswith('data:image'):
+                                                        image_bytes = base64.b64decode(doc['graph1'].split(',')[1])
+                                                    else:
+                                                        image_bytes = base64.b64decode(doc['graph1'])
+                                                    st.image(image_bytes, caption=t.get('graph1_caption', 'Grafo del Texto 1'), use_column_width=True)
+                                                except:
+                                                    st.warning(t.get('graph_decode_error', 'Error al decodificar el gráfico'))
+                                            except:
+                                                st.warning(t.get('graph_format_error', 'Formato de gráfico no soportado'))
+                                        
+                                        # Interpretación como texto normal
+                                        st.markdown("**📊 Interpretación del grafo:**")
+                                        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
+                                        """)
+                                        
+                                        st.markdown('</div>', unsafe_allow_html=True)
+                                    except Exception as graph_err:
+                                        logger.error(f"Error mostrando gráfico 1: {str(graph_err)}")
+                                        st.warning(t.get('graph_not_available', 'Gráfico no disponible'))
                                 else:
-                                    st.info("No hay conceptos disponibles")
-                            else:
-                                st.write(str(concepts))
-                        except Exception as e:
-                            logger.error(f"Error mostrando conceptos 2: {str(e)}")
-                            st.error("Error mostrando conceptos")
-                    
-                    # Mostrar visualizaciones si existen
-                    st.markdown("---")
-                    st.subheader(t.get('visualizations', 'Visualizaciones'))
-                    
-                    # Variable para verificar si se mostró alguna visualización
-                    shown_images = 0
+                                    st.warning(t.get('graph_not_available', 'Gráfico no disponible'))
+                            except Exception as e:
+                                logger.error(f"Error mostrando conceptos 1: {str(e)}")
+                                st.error("Error mostrando conceptos")
+                        else:
+                            st.warning(t.get('concepts_not_available', 'Conceptos no disponibles'))
                     
-                    # Mostrar todas las visualizaciones posibles con keys únicos
-                    for field_name in ['graph1', 'graph2', 'combined_graph']:
-                        if field_name in doc and doc[field_name]:
+                    # Columna 2: Documento 2
+                    with col2:
+                        st.subheader(t.get('doc2_title', 'Documento 2'))
+                        st.markdown(t.get('key_concepts', 'Conceptos Clave'))
+                        
+                        if 'key_concepts2' in doc and doc['key_concepts2']:
                             try:
-                                data = doc[field_name]
+                                # Usar el mismo formato visual de conceptos que en la interfaz principal
+                                concepts_html = f"""
+                                    <div class="concepts-container">
+                                        {''.join([
+                                            f'<div class="concept-item"><span class="concept-name">{concept}</span>'
+                                            f'<span class="concept-freq">({freq})</span></div>'
+                                            for concept, freq in doc['key_concepts2']
+                                        ])}
+                                    </div>
+                                """
+                                st.markdown(concepts_html, unsafe_allow_html=True)
                                 
-                                # Determinar título según tipo de gráfico
-                                if field_name == 'graph1':
-                                    caption = t.get('graph1_title', 'Visualización del Texto 1')
-                                elif field_name == 'graph2':
-                                    caption = t.get('graph2_title', 'Visualización del Texto 2')
+                                # Mostrar gráfico si existe
+                                if 'graph2' in doc and doc['graph2']:
+                                    try:
+                                        st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                                        
+                                        # Manejar diferentes formatos de gráfico
+                                        if isinstance(doc['graph2'], bytes):
+                                            st.image(doc['graph2'], caption=t.get('graph2_caption', 'Grafo del Texto 2'), use_column_width=True)
+                                        elif isinstance(doc['graph2'], str):
+                                            try:
+                                                import base64
+                                                # Intentar diferentes formatos de base64
+                                                try:
+                                                    if doc['graph2'].startswith('data:image'):
+                                                        image_bytes = base64.b64decode(doc['graph2'].split(',')[1])
+                                                    else:
+                                                        image_bytes = base64.b64decode(doc['graph2'])
+                                                    st.image(image_bytes, caption=t.get('graph2_caption', 'Grafo del Texto 2'), use_column_width=True)
+                                                except:
+                                                    st.warning(t.get('graph_decode_error', 'Error al decodificar el gráfico'))
+                                            except:
+                                                st.warning(t.get('graph_format_error', 'Formato de gráfico no soportado'))
+                                        
+                                        # Interpretación como texto normal
+                                        st.markdown("**📊 Interpretación del grafo:**")
+                                        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
+                                        """)
+                                        
+                                        st.markdown('</div>', unsafe_allow_html=True)
+                                    except Exception as graph_err:
+                                        logger.error(f"Error mostrando gráfico 2: {str(graph_err)}")
+                                        st.warning(t.get('graph_not_available', 'Gráfico no disponible'))
                                 else:
-                                    caption = t.get('combined_graph_title', 'Visualización Comparativa')
-                                
-                                # Si es bytes, mostrar directamente
-                                if isinstance(data, bytes):
-                                    st.image(data, caption=caption, use_column_width=True)
-                                    shown_images += 1
-                                    
-                                # Si es string, intentar como base64
-                                elif isinstance(data, str):
+                                    st.warning(t.get('graph_not_available', 'Gráfico no disponible'))
+                            except Exception as e:
+                                logger.error(f"Error mostrando conceptos 2: {str(e)}")
+                                st.error("Error mostrando conceptos")
+                        else:
+                            st.warning(t.get('concepts_not_available', 'Conceptos no disponibles'))
+                    
+                    # Gráfico combinado (abajo de las columnas)
+                    if 'combined_graph' in doc and doc['combined_graph']:
+                        try:
+                            st.subheader(t.get('combined_graph_title', 'Análisis Comparativo'))
+                            
+                            # Manejar diferentes formatos de gráfico
+                            if isinstance(doc['combined_graph'], bytes):
+                                st.image(doc['combined_graph'], caption=t.get('combined_graph_caption', 'Visualización Comparativa'), use_column_width=True)
+                            elif isinstance(doc['combined_graph'], str):
+                                try:
+                                    import base64
+                                    # Intentar diferentes formatos de base64
                                     try:
-                                        import base64
-                                        image_bytes = base64.b64decode(data)
-                                        st.image(image_bytes, caption=caption, use_column_width=True)
-                                        shown_images += 1
+                                        if doc['combined_graph'].startswith('data:image'):
+                                            image_bytes = base64.b64decode(doc['combined_graph'].split(',')[1])
+                                        else:
+                                            image_bytes = base64.b64decode(doc['combined_graph'])
+                                        st.image(image_bytes, caption=t.get('combined_graph_caption', 'Visualización Comparativa'), use_column_width=True)
                                     except:
-                                        # Si falla la decodificación, solo registrarlo
-                                        logger.error(f"No se pudo decodificar {field_name}")
-                            except Exception as img_err:
-                                logger.error(f"Error mostrando {field_name}: {str(img_err)}")
+                                        st.warning(t.get('graph_decode_error', 'Error al decodificar el gráfico'))
+                                except:
+                                    st.warning(t.get('graph_format_error', 'Formato de gráfico no soportado'))
+                        except Exception as graph_err:
+                            logger.error(f"Error mostrando gráfico combinado: {str(graph_err)}")
+                            st.warning(t.get('combined_graph_not_available', 'Gráfico combinado no disponible'))
                     
-                    # Mensaje si no hay visualizaciones
-                    if shown_images == 0:
-                        st.info(t.get('no_visualization', 'No hay visualizaciones disponibles para este análisis'))
-                    
-                    # NO usar expander anidado - simplemente mostrar datos importantes
-                    st.markdown("---")
-                    st.markdown("**Información adicional:**")
-                    if 'analysis_type' in doc:
-                        st.markdown(f"Tipo de análisis: {doc.get('analysis_type', 'Desconocido')}")
-                    if 'timestamp' in doc:
-                        st.markdown(f"Fecha: {doc.get('timestamp', 'Desconocida')}")
-            
+                    # Nota informativa sobre la comparación
+                    st.info(t.get('comparison_note', 
+                        'La funcionalidad de comparación detallada estará disponible en una próxima actualización.'))
+                
             except Exception as doc_err:
                 logger.error(f"Error procesando documento: {str(doc_err)}")
                 st.error(f"Error procesando análisis: {str(doc_err)}")
@@ -706,6 +793,8 @@ def display_discourse_activities(username: str, t: dict):
     except Exception as e:
         logger.error(f"Error general: {str(e)}")
         st.error(f"Error recuperando análisis: {str(e)}")
+        # Mostrar el error para depuración
+        st.exception(e)