Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -535,10 +535,14 @@ def display_semantic_activities(username: str, t: dict):
 
 
 ###################################################################################################
+
 def display_discourse_activities(username: str, t: dict):
     """
-    Solución simplificada para mostrar análisis de discurso con máxima tolerancia a errores
-    y corregida para evitar el error de verificación de colección MongoDB
+    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
     """
     try:
         # Importar directamente la colección
@@ -550,7 +554,7 @@ def display_discourse_activities(username: str, t: dict):
         # Obtener colección directamente
         collection = get_collection('student_discourse_analysis')
         
-        # CORRECCIÓN: Verificar si collection es None, no usar 'if not collection'
+        # Verificar correctamente si collection es None
         if collection is None:
             st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
             return
@@ -564,8 +568,11 @@ def display_discourse_activities(username: str, t: dict):
             return
         
         # Mostrar cada resultado
-        for doc in results:
+        for i, doc in enumerate(results):
             try:
+                # Crear ID único para este análisis
+                doc_id = str(doc.get('_id', f"doc_{i}"))
+                
                 # Extraer y formatear fecha con manejo de errores
                 timestamp_str = doc.get('timestamp', 'Fecha desconocida')
                 try:
@@ -578,83 +585,93 @@ def display_discourse_activities(username: str, t: dict):
                     formatted_date = str(timestamp_str)
                 
                 # Crear expander
-                expander_label = f"Análisis: {formatted_date}"
-                with st.expander(expander_label):
+                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)
+                        st.text_area(
+                            "Texto analizado", 
+                            value=doc['text1'], 
+                            height=100, 
+                            disabled=True,
+                            key=f"text1_{doc_id}"  # Key único para este text_area
+                        )
                     
-                    # Mostrar conceptos clave si existen
-                    has_concepts = False
-                    
-                    # Intentar mostrar conceptos clave en dos columnas
-                    if 'key_concepts1' in doc or 'key_concepts2' in doc:
-                        has_concepts = True
-                        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
-                        with col1:
-                            st.markdown("**Conceptos clave (Texto 1)**")
-                            if 'key_concepts1' in doc and doc['key_concepts1']:
-                                try:
-                                    # Mostrar simple como texto para evitar errores de formato
-                                    concepts = doc['key_concepts1']
-                                    if isinstance(concepts, list):
-                                        concept_text = ""
-                                        for c in concepts:
-                                            if isinstance(c, list) and len(c) >= 2:
-                                                concept_text += f"• {c[0]}: {c[1]}\n"
-                                            else:
-                                                concept_text += f"• {c}\n"
-                                        st.text(concept_text)
+                        # 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:
-                                        st.text(str(concepts))
-                                except:
-                                    st.text("Error mostrando conceptos")
+                                        # Otro formato de lista
+                                        st.markdown(", ".join(str(c) for c in concepts[:10]))
+                                else:
+                                    st.info("No hay conceptos disponibles")
                             else:
-                                st.text("Sin conceptos disponibles")
-                        
-                        # Columna 2
-                        with col2:
-                            st.markdown("**Conceptos clave (Texto 2)**")
-                            if 'key_concepts2' in doc and doc['key_concepts2']:
-                                try:
-                                    # Mostrar simple como texto para evitar errores de formato
-                                    concepts = doc['key_concepts2']
-                                    if isinstance(concepts, list):
-                                        concept_text = ""
-                                        for c in concepts:
-                                            if isinstance(c, list) and len(c) >= 2:
-                                                concept_text += f"• {c[0]}: {c[1]}\n"
-                                            else:
-                                                concept_text += f"• {c}\n"
-                                        st.text(concept_text)
+                                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:
-                                        st.text(str(concepts))
-                                except:
-                                    st.text("Error mostrando conceptos")
+                                        # Otro formato de lista
+                                        st.markdown(", ".join(str(c) for c in concepts[:10]))
+                                else:
+                                    st.info("No hay conceptos disponibles")
                             else:
-                                st.text("Sin conceptos disponibles")
+                                st.write(str(concepts))
+                        except Exception as e:
+                            logger.error(f"Error mostrando conceptos 2: {str(e)}")
+                            st.error("Error mostrando conceptos")
                     
-                    # Buscar visualizaciones
+                    # Mostrar visualizaciones si existen
                     st.markdown("---")
-                    st.markdown("**Visualizaciones**")
+                    st.subheader(t.get('visualizations', 'Visualizaciones'))
                     
                     # Variable para verificar si se mostró alguna visualización
                     shown_images = 0
                     
-                    # Mostrar todas las visualizaciones posibles
+                    # 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]:
                             try:
                                 data = doc[field_name]
                                 
+                                # 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')
+                                else:
+                                    caption = t.get('combined_graph_title', 'Visualización Comparativa')
+                                
                                 # Si es bytes, mostrar directamente
                                 if isinstance(data, bytes):
-                                    st.image(data, caption=field_name, use_column_width=True)
+                                    st.image(data, caption=caption, use_column_width=True)
                                     shown_images += 1
                                     
                                 # Si es string, intentar como base64
@@ -662,7 +679,7 @@ def display_discourse_activities(username: str, t: dict):
                                     try:
                                         import base64
                                         image_bytes = base64.b64decode(data)
-                                        st.image(image_bytes, caption=field_name, use_column_width=True)
+                                        st.image(image_bytes, caption=caption, use_column_width=True)
                                         shown_images += 1
                                     except:
                                         # Si falla la decodificación, solo registrarlo
@@ -672,15 +689,15 @@ def display_discourse_activities(username: str, t: dict):
                     
                     # Mensaje si no hay visualizaciones
                     if shown_images == 0:
-                        st.info("No hay visualizaciones disponibles para este análisis")
-                        
-                    # Mostrar los datos crudos para depuración (opcional)
-                    with st.expander("Datos completos del análisis", expanded=False):
-                        # Filtrar campos binarios y muy grandes
-                        filtered_doc = {k: v for k, v in doc.items() 
-                                      if not isinstance(v, bytes) 
-                                      and not (isinstance(v, str) and len(str(v)) > 500)}
-                        st.json(filtered_doc)
+                        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')}")
             
             except Exception as doc_err:
                 logger.error(f"Error procesando documento: {str(doc_err)}")
@@ -689,14 +706,15 @@ 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 completo para depuración
-        st.exception(e)
+
+
+
 #################################################################################   
 
 def display_discourse_comparison(analysis: dict, t: dict):
     """
     Muestra la comparación de conceptos clave en análisis del discurso.
-    Mejorada para manejar diferentes formatos y errores.
+    Formato horizontal simplificado.
     """
     st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
     
@@ -705,47 +723,44 @@ def display_discourse_comparison(analysis: dict, t: dict):
         st.info(t.get('no_concepts', 'No hay conceptos disponibles para comparar'))
         return
     
-    # Mostrar en dos columnas
-    col1, col2 = st.columns(2)
+    # 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'))
     
-    # Columna 1: Conceptos del texto 1
-    with col1:
-        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos 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 crear DataFrame
-            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:
-                    df1 = pd.DataFrame(analysis['key_concepts1'], columns=['Concepto', 'Relevancia'])
-                    st.dataframe(df1)
+            # 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
-                    st.write(", ".join(str(c) for c in analysis['key_concepts1']))
+                    # 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_concepts1']))
+                st.write(str(analysis['key_concepts2']))
         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'))
-    
-    # Columna 2: Conceptos del texto 2
-    with col2:
-        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
-        if 'key_concepts2' in analysis and analysis['key_concepts2']:
-            try:
-                # Comprobar formato y crear DataFrame
-                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:
-                        df2 = pd.DataFrame(analysis['key_concepts2'], columns=['Concepto', 'Relevancia'])
-                        st.dataframe(df2)
-                    else:
-                        # Si no tiene el formato esperado, mostrar como lista
-                        st.write(", ".join(str(c) for c in analysis['key_concepts2']))
-                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'))
+            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'))
 
 
 #################################################################################