Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -535,241 +535,114 @@ 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 centradas en las visualizaciones comparativas
     """
     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:
             logger.info("No se encontraron análisis del discurso")
-            # Usamos el término "análisis comparado de textos" en la UI
             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:
             try:
-                # Verificar campos mínimos necesarios
-                if 'timestamp' not in analysis:
-                    logger.warning(f"Análisis sin timestamp: {analysis.keys()}")
-                    continue
-
                 # Formatear fecha
-                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'))
+                timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
+                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
                 
-                # Crear el título del expander
+                # 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')
-                    ])
+                    # Mostrar conceptos clave en dos columnas
+                    if 'key_concepts1' in analysis and 'key_concepts2' in analysis:
+                        col1, col2 = st.columns(2)
+                        
+                        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)
+                        
+                        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)
                     
-                    # 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'))
+                    # Mostrar visualizaciones semánticas
+                    st.subheader(t.get('semantic_visualization', 'Visualización Semántica'))
                     
-                    # 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'))
+                    # Mostrar gráficos en fila
+                    graph_cols = st.columns(3)
+                    
+                    # Gráfico 1 (si existe)
+                    with graph_cols[0]:
+                        if analysis.get('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'))
+                    
+                    # Gráfico 2 (si existe)
+                    with graph_cols[1]:
+                        if analysis.get('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'))
                     
-                    # 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'))
+                    # 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):
-                                    # Si es string base64
-                                    if analysis['combined_graph'].startswith('data:image'):
+                                    try:
                                         import base64
-                                        image_bytes = base64.b64decode(analysis['combined_graph'].split(',')[1])
-                                    else:
-                                        # Podría ser base64 sin prefijo
-                                        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'])
-                                        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)
+                                        st.image(image_bytes, use_column_width=True)
+                                    except:
+                                        logger.error("Error decodificando imagen combinada")
                                 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
+                                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 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.'))
+                                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'))
 
             except Exception as e:
                 logger.error(f"Error procesando análisis individual: {str(e)}")
@@ -777,9 +650,20 @@ def display_discourse_activities(username: str, t: dict):
 
     except Exception as e:
         logger.error(f"Error mostrando análisis del discurso: {str(e)}")
-        # Usamos el término "análisis comparado de textos" en la UI
         st.error(t.get('error_discourse', 'Error al mostrar análisis comparado de textos'))
 
+
+
+
+
+
+
+
+
+
+
+
+
 #################################################################################   
 def display_chat_activities(username: str, t: dict):
     """