Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -467,16 +467,81 @@ def display_morphosyntax_activities(username: str, t: dict):
         st.error(t.get('error_morpho', 'Error al mostrar análisis morfosintáctico'))
 
 
-###############################################################################################
+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"""
+    """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}")
         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
 
@@ -484,8 +549,8 @@ def display_discourse_activities(username: str, t: dict):
         for analysis in analyses:
             try:
                 # Verificar campos mínimos necesarios
-                if 'timestamp' not in analysis:
-                    logger.warning(f"Análisis sin timestamp: {analysis.keys()}")
+                if not all(key in analysis for key in ['timestamp']):
+                    logger.warning(f"Análisis incompleto: {analysis.keys()}")
                     continue
 
                 # Formatear fecha
@@ -516,40 +581,48 @@ def display_discourse_activities(username: str, t: dict):
                     # Mostrar gráficos
                     st.markdown("### Visualización comparativa")
                     
-                    # Verificar y mostrar gráficos si existen
-                    graph_col1, graph_col2 = st.columns(2)
                     has_graphs = False
                     
-                    with graph_col1:
-                        if 'graph1' in analysis and analysis['graph1']:
-                            try:
-                                # 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 mostrando graph1: {str(img_error)}")
+                    # Mostrar graph1 (Documento 1)
+                    if 'graph1' in analysis:
+                        try:
+                            # 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 e:
+                            logger.error(f"Error mostrando graph1: {str(e)}")
                     
-                    with graph_col2:
-                        if 'graph2' in analysis and analysis['graph2']:
-                            try:
-                                # 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 mostrando graph2: {str(img_error)}")
+                    # Mostrar graph2 (Documento 2)
+                    if 'graph2' in analysis:
+                        try:
+                            # 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 e:
+                            logger.error(f"Error mostrando graph2: {str(e)}")
                     
                     if not has_graphs:
-                        st.info(t.get('no_visualization', 'No hay visualización comparativa disponible'))
+                        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:'))
+                    
+                    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
+                    """)
 
             except Exception as e:
                 logger.error(f"Error procesando análisis individual: {str(e)}")
@@ -557,11 +630,9 @@ 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):