Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -536,9 +536,14 @@ def display_semantic_activities(username: str, t: dict):
 
 ###################################################################################################
 def display_discourse_activities(username: str, t: dict):
-    """Muestra actividades de análisis del discurso (mostrado como 'Análisis comparado de textos' en la UI)"""
+    """
+    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}")
+        
+        # Obtener análisis del discurso con el tipo correcto
+        from ..database.discourse_mongo_db import get_student_discourse_analysis
         analyses = get_student_discourse_analysis(username)
         
         if not analyses:
@@ -551,26 +556,220 @@ def display_discourse_activities(username: str, t: dict):
         for analysis in analyses:
             try:
                 # Verificar campos mínimos necesarios
-                if not all(key in analysis for key in ['timestamp', 'combined_graph']):
-                    logger.warning(f"Análisis incompleto: {analysis.keys()}")
+                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")
+                try:
+                    timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
+                    formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                except Exception as e:
+                    logger.error(f"Error al formatear timestamp: {str(e)}")
+                    formatted_date = str(analysis.get('timestamp', 'Fecha desconocida'))
                 
-                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
-                    if analysis['combined_graph']:
-                        logger.debug("Decodificando gráfico combinado")
-                        try:
-                            image_bytes = base64.b64decode(analysis['combined_graph'])
-                            st.image(image_bytes, use_container_width=True)
-                            logger.debug("Gráfico mostrado exitosamente")
-                        except Exception as img_error:
-                            logger.error(f"Error decodificando imagen: {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 comparativa disponible'))
+                # Crear el título del expander
+                expander_title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
+                
+                with st.expander(expander_title, expanded=False):
+                    # Crear pestañas para los textos y la comparación
+                    tabs = st.tabs([
+                        t.get('text1_tab', 'Texto 1 (Patrón)'),
+                        t.get('text2_tab', 'Texto 2 (Comparación)'),
+                        t.get('comparison_tab', 'Análisis Comparativo')
+                    ])
+                    
+                    # Tab para Texto 1
+                    with tabs[0]:
+                        if 'text1' in analysis and analysis['text1']:
+                            st.text_area(
+                                "Texto 1", 
+                                value=analysis['text1'], 
+                                height=150,
+                                disabled=True,
+                                label_visibility="collapsed",
+                                key=f"text1_{str(analysis['_id'])}"
+                            )
+                            
+                            # Mostrar conceptos clave del texto 1
+                            if 'key_concepts1' in analysis and analysis['key_concepts1']:
+                                st.subheader(t.get('key_concepts1', 'Conceptos clave (Texto 1)'))
+                                
+                                # Crear una tabla/dataframe de conceptos
+                                concept_data = analysis['key_concepts1']
+                                if concept_data and len(concept_data) > 0:
+                                    # Verificar formato de los datos
+                                    if isinstance(concept_data[0], list) and len(concept_data[0]) == 2:
+                                        # Formato esperado: [["concepto", valor], ...]
+                                        df = pd.DataFrame(concept_data, columns=['Concepto', 'Relevancia'])
+                                        st.dataframe(df, use_container_width=True)
+                                    else:
+                                        st.write(concept_data)  # Mostrar como está si no tiene el formato esperado
+                                else:
+                                    st.info(t.get('no_concepts1', 'No hay conceptos clave disponibles para el Texto 1'))
+                            
+                            # Mostrar gráfico si existe
+                            if 'graph1' in analysis and analysis['graph1']:
+                                st.subheader(t.get('graph1', 'Visualización del Texto 1'))
+                                try:
+                                    if isinstance(analysis['graph1'], str) and analysis['graph1'].startswith('data:image'):
+                                        # Manejo para string base64
+                                        import base64
+                                        image_bytes = base64.b64decode(analysis['graph1'].split(',')[1])
+                                        st.image(image_bytes, use_column_width=True)
+                                    elif isinstance(analysis['graph1'], bytes):
+                                        # Manejo para bytes directos
+                                        st.image(analysis['graph1'], use_column_width=True)
+                                    else:
+                                        # Otro tipo de gráfico (matplotlib, etc.)
+                                        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 al mostrar el gráfico del Texto 1'))
+                        else:
+                            st.info(t.get('no_text1', 'Texto 1 no disponible'))
+                    
+                    # Tab para Texto 2
+                    with tabs[1]:
+                        if 'text2' in analysis and analysis['text2']:
+                            st.text_area(
+                                "Texto 2", 
+                                value=analysis['text2'], 
+                                height=150,
+                                disabled=True,
+                                label_visibility="collapsed",
+                                key=f"text2_{str(analysis['_id'])}"
+                            )
+                            
+                            # Mostrar conceptos clave del texto 2
+                            if 'key_concepts2' in analysis and analysis['key_concepts2']:
+                                st.subheader(t.get('key_concepts2', 'Conceptos clave (Texto 2)'))
+                                
+                                # Crear una tabla/dataframe de conceptos
+                                concept_data = analysis['key_concepts2']
+                                if concept_data and len(concept_data) > 0:
+                                    # Verificar formato de los datos
+                                    if isinstance(concept_data[0], list) and len(concept_data[0]) == 2:
+                                        # Formato esperado: [["concepto", valor], ...]
+                                        df = pd.DataFrame(concept_data, columns=['Concepto', 'Relevancia'])
+                                        st.dataframe(df, use_container_width=True)
+                                    else:
+                                        st.write(concept_data)  # Mostrar como está si no tiene el formato esperado
+                                else:
+                                    st.info(t.get('no_concepts2', 'No hay conceptos clave disponibles para el Texto 2'))
+                            
+                            # Mostrar gráfico si existe
+                            if 'graph2' in analysis and analysis['graph2']:
+                                st.subheader(t.get('graph2', 'Visualización del Texto 2'))
+                                try:
+                                    if isinstance(analysis['graph2'], str) and analysis['graph2'].startswith('data:image'):
+                                        # Manejo para string base64
+                                        import base64
+                                        image_bytes = base64.b64decode(analysis['graph2'].split(',')[1])
+                                        st.image(image_bytes, use_column_width=True)
+                                    elif isinstance(analysis['graph2'], bytes):
+                                        # Manejo para bytes directos
+                                        st.image(analysis['graph2'], use_column_width=True)
+                                    else:
+                                        # Otro tipo de gráfico (matplotlib, etc.)
+                                        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 al mostrar el gráfico del Texto 2'))
+                        else:
+                            # Caso especial: si text2 está ausente pero text1 está presente
+                            # mostrar text1 aquí también (para documentos de un solo texto)
+                            if 'text1' in analysis and analysis['text1']:
+                                st.info(t.get('using_text1', 'Usando el mismo texto como referencia.'))
+                                st.text_area(
+                                    "Texto 1 como referencia", 
+                                    value=analysis['text1'], 
+                                    height=150,
+                                    disabled=True,
+                                    label_visibility="collapsed",
+                                    key=f"text1_ref_{str(analysis['_id'])}"
+                                )
+                            else:
+                                st.info(t.get('no_text2', 'Texto 2 no disponible'))
+                    
+                    # Tab para Comparación
+                    with tabs[2]:
+                        # Mostrar gráfico combinado si existe
+                        if 'combined_graph' in analysis and analysis['combined_graph']:
+                            st.subheader(t.get('combined_visualization', 'Visualización comparativa'))
+                            try:
+                                if isinstance(analysis['combined_graph'], str):
+                                    # Si es string base64
+                                    if analysis['combined_graph'].startswith('data:image'):
+                                        import base64
+                                        image_bytes = base64.b64decode(analysis['combined_graph'].split(',')[1])
+                                    else:
+                                        # Podría ser base64 sin prefijo
+                                        try:
+                                            import base64
+                                            image_bytes = base64.b64decode(analysis['combined_graph'])
+                                        except:
+                                            st.text(analysis['combined_graph'][:100] + "...")  # Mostrar parte como texto
+                                            raise ValueError("Formato de gráfico combinado no reconocido")
+                                    
+                                    st.image(image_bytes, use_column_width=True)
+                                elif isinstance(analysis['combined_graph'], bytes):
+                                    # Si son bytes directos
+                                    st.image(analysis['combined_graph'], use_column_width=True)
+                                else:
+                                    # Otro tipo de gráfico
+                                    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 al mostrar la visualización comparativa'))
+                        else:
+                            # Mostrar comparación de conceptos lado a lado
+                            if ('key_concepts1' in analysis and analysis['key_concepts1'] and
+                                'key_concepts2' in analysis and analysis['key_concepts2']):
+                                
+                                st.subheader(t.get('concept_comparison', 'Comparación de conceptos clave'))
+                                col1, col2 = st.columns(2)
+                                
+                                with col1:
+                                    st.markdown(f"**{t.get('text1_concepts', 'Conceptos del Texto 1')}**")
+                                    concept_data1 = analysis['key_concepts1']
+                                    if concept_data1 and len(concept_data1) > 0:
+                                        if isinstance(concept_data1[0], list) and len(concept_data1[0]) == 2:
+                                            df1 = pd.DataFrame(concept_data1, columns=['Concepto', 'Relevancia'])
+                                            st.dataframe(df1, use_container_width=True)
+                                        else:
+                                            st.write(concept_data1)
+                                
+                                with col2:
+                                    st.markdown(f"**{t.get('text2_concepts', 'Conceptos del Texto 2')}**")
+                                    concept_data2 = analysis['key_concepts2']
+                                    if concept_data2 and len(concept_data2) > 0:
+                                        if isinstance(concept_data2[0], list) and len(concept_data2[0]) == 2:
+                                            df2 = pd.DataFrame(concept_data2, columns=['Concepto', 'Relevancia'])
+                                            st.dataframe(df2, use_container_width=True)
+                                        else:
+                                            st.write(concept_data2)
+                                
+                                # Mostrar conceptos en común (intersección)
+                                if (isinstance(analysis['key_concepts1'], list) and 
+                                    isinstance(analysis['key_concepts2'], list)):
+                                    
+                                    concepts1 = [item[0] for item in analysis['key_concepts1'] if isinstance(item, list) and len(item) == 2]
+                                    concepts2 = [item[0] for item in analysis['key_concepts2'] if isinstance(item, list) and len(item) == 2]
+                                    
+                                    common_concepts = set(concepts1).intersection(set(concepts2))
+                                    
+                                    if common_concepts:
+                                        st.subheader(t.get('common_concepts', 'Conceptos en común'))
+                                        st.write(", ".join(common_concepts))
+                                    else:
+                                        st.info(t.get('no_common_concepts', 'No se encontraron conceptos en común entre los textos'))
+                            else:
+                                st.info(t.get('no_comparison_data', 'No hay datos suficientes para la comparación'))
+                                
+                            # Nota sobre la comparación
+                            st.info(t.get('comparison_note', 
+                                'La funcionalidad de comparación avanzada estará disponible en una próxima actualización.'))
 
             except Exception as e:
                 logger.error(f"Error procesando análisis individual: {str(e)}")