Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -469,82 +469,14 @@ def display_morphosyntax_activities(username: str, t: dict):
 
 ###############################################################################################
 
-def display_semantic_activities(username: str, t: dict):
-    """Muestra actividades de análisis semántico"""
-    try:
-        logger.info(f"Recuperando análisis semántico para {username}")
-        analyses = get_student_semantic_analysis(username)
-        
-        if not analyses:
-            logger.info("No se encontraron análisis semánticos")
-            st.info(t.get('no_semantic_analyses', 'No hay análisis semánticos registrados'))
-            return
-
-        logger.info(f"Procesando {len(analyses)} análisis semánticos")
-        
-        for analysis in analyses:
-            try:
-                # Verificar campos necesarios
-                if not all(key in analysis for key in ['timestamp', 'concept_graph']):
-                    logger.warning(f"Análisis incompleto: {analysis.keys()}")
-                    continue
-                
-                # Formatear fecha
-                timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
-                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
-                
-                # Crear expander
-                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
-                    # Procesar y mostrar gráfico
-                    if analysis.get('concept_graph'):
-                        try:
-                            # Convertir de base64 a bytes
-                            logger.debug("Decodificando gráfico de conceptos")
-                            image_data = analysis['concept_graph']
-                            
-                            # Si el gráfico ya es bytes, usarlo directamente
-                            if isinstance(image_data, bytes):
-                                image_bytes = image_data
-                            else:
-                                # Si es string base64, decodificar
-                                image_bytes = base64.b64decode(image_data)
-                            
-                            logger.debug(f"Longitud de bytes de imagen: {len(image_bytes)}")
-                            
-                            # Mostrar imagen
-                            st.image(
-                                image_bytes,
-                                caption=t.get('concept_network', 'Red de Conceptos'),
-                                use_container_width=True
-                            )
-                            logger.debug("Gráfico mostrado exitosamente")
-                            
-                        except Exception as img_error:
-                            logger.error(f"Error procesando gráfico: {str(img_error)}")
-                            st.error(t.get('error_loading_graph', 'Error al cargar el gráfico'))
-                    else:
-                        st.info(t.get('no_graph', 'No hay visualización disponible'))
-
-            except Exception as e:
-                logger.error(f"Error procesando análisis individual: {str(e)}")
-                continue
-
-    except Exception as e:
-        logger.error(f"Error mostrando análisis semántico: {str(e)}")
-        st.error(t.get('error_semantic', 'Error al mostrar análisis semántico'))
-
-
-###################################################################################################
-
 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"""
     try:
         logger.info(f"Recuperando análisis del discurso para {username}")
         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
 
@@ -552,8 +484,8 @@ 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', 'graph1', 'graph2']):
-                    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
@@ -561,91 +493,63 @@ def display_discourse_activities(username: str, t: dict):
                 formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
                 
                 with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
-                    # Mostrar textos originales si están disponibles
-                    if 'text1' in analysis and 'text2' in analysis:
-                        st.subheader(t.get('analyzed_texts', 'Textos analizados'))
-                        col1, col2 = st.columns(2)
-                        with col1:
-                            st.markdown(f"**{t.get('doc1_title', 'Documento 1')}**")
-                            st.text_area(
-                                "Text Content 1", 
-                                value=analysis['text1'], 
-                                height=100,
-                                disabled=True,
-                                label_visibility="collapsed",
-                                key=f"text_area_1_{timestamp}"
-                            )
-                        with col2:
-                            st.markdown(f"**{t.get('doc2_title', 'Documento 2')}**")
-                            st.text_area(
-                                "Text Content 2", 
-                                value=analysis['text2'], 
-                                height=100,
-                                disabled=True,
-                                label_visibility="collapsed",
-                                key=f"text_area_2_{timestamp}"
-                            )
-                    
-                    # Mostrar conceptos clave
-                    st.subheader(t.get('key_concepts', 'Conceptos clave'))
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        st.markdown(f"**{t.get('doc1_title', 'Documento 1')}**")
-                        if 'key_concepts1' in analysis:
-                            concepts1 = ", ".join([concept for concept, _ in analysis['key_concepts1']])
-                            st.markdown(concepts1)
-                        else:
-                            st.info(t.get('no_concepts', 'No hay conceptos disponibles'))
-                    
-                    with col2:
-                        st.markdown(f"**{t.get('doc2_title', 'Documento 2')}**")
-                        if 'key_concepts2' in analysis:
-                            concepts2 = ", ".join([concept for concept, _ in analysis['key_concepts2']])
-                            st.markdown(concepts2)
-                        else:
-                            st.info(t.get('no_concepts', 'No hay conceptos disponibles'))
+                    # Mostrar conceptos clave en fila
+                    if 'key_concepts1' in analysis and 'key_concepts2' in analysis:
+                        st.markdown("### Conceptos clave")
+                        
+                        # 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]))
+                        
+                        # 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
-                    st.subheader(t.get('comparison_visualization', 'Visualización comparativa'))
+                    # Mostrar gráficos
+                    st.markdown("### Visualización comparativa")
                     
-                    # Mostrar los gráficos lado a lado
-                    col1, col2 = st.columns(2)
+                    # Verificar y mostrar gráficos si existen
+                    graph_col1, graph_col2 = st.columns(2)
+                    has_graphs = False
                     
-                    # Gráfico 1
-                    with col1:
-                        st.markdown(f"**{t.get('analysis_doc1', 'Análisis del primer texto')}**")
-                        if 'graph1' in analysis:
+                    with graph_col1:
+                        if 'graph1' in analysis and analysis['graph1']:
                             try:
-                                image_bytes1 = base64.b64decode(analysis['graph1'])
-                                st.image(image_bytes1, use_container_width=True)
+                                # 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 decodificando imagen 1: {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 disponible'))
+                                logger.error(f"Error mostrando graph1: {str(img_error)}")
                     
-                    # Gráfico 2
-                    with col2:
-                        st.markdown(f"**{t.get('analysis_doc2', 'Análisis del segundo texto')}**")
-                        if 'graph2' in analysis:
+                    with graph_col2:
+                        if 'graph2' in analysis and analysis['graph2']:
                             try:
-                                image_bytes2 = base64.b64decode(analysis['graph2'])
-                                st.image(image_bytes2, use_container_width=True)
+                                # 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 decodificando imagen 2: {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 disponible'))
-                    
-                    # Añadir leyenda de interpretación
-                    st.markdown("### 📊 " + t.get('graph_interpretation', 'Interpretación del grafo:'))
+                                logger.error(f"Error mostrando graph2: {str(img_error)}")
                     
-                    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
-                    """)
+                    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)}")
@@ -653,9 +557,11 @@ 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_discourse_comparison(analysis: dict, t: dict):