Update modules/studentact/student_activities_v2-complet.py

modules/studentact/student_activities_v2-complet.py

@@ -65,6 +65,8 @@ def display_student_activities(username: str, lang_code: str, t: dict):
         logger.error(f"Error mostrando actividades: {str(e)}")
         st.error(t.get('error_loading_activities', 'Error al cargar las actividades'))
 
+
+###############################################################################################
 def display_morphosyntax_activities(username: str, t: dict):
     """Muestra actividades de análisis morfosintáctico"""
     try:
@@ -90,110 +92,93 @@ def display_morphosyntax_activities(username: str, t: dict):
         logger.error(f"Error mostrando análisis morfosintáctico: {str(e)}")
         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:
-            with st.expander(
-                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
-                expanded=False
-            ):
-                # Mostrar texto analizado
-                st.text(f"{t.get('analyzed_file', 'Archivo analizado')}:")
-                st.write(analysis['text'])
+            try:
+                # Verificar campos mínimos 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")
                 
-                # Mostrar conceptos clave
-                if 'key_concepts' in analysis:
-                    st.subheader(t.get('key_concepts', 'Conceptos clave'))
-                    df = pd.DataFrame(
-                        analysis['key_concepts'],
-                        columns=['Concepto', 'Frecuencia']
-                    )
-                    st.dataframe(df)
-
-                # Mostrar gráfico de conceptos
-                if 'concept_graph' in analysis and analysis['concept_graph']:
-                    st.subheader(t.get('concept_graph', 'Grafo de conceptos'))
-                    image_bytes = base64.b64decode(analysis['concept_graph'])
-                    st.image(image_bytes)
+                with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
+                    if analysis['concept_graph']:
+                        logger.debug("Decodificando gráfico de conceptos")
+                        try:
+                            image_bytes = base64.b64decode(analysis['concept_graph'])
+                            st.image(image_bytes, use_column_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_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"""
     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")
             st.info(t.get('no_discourse_analyses', 'No hay análisis del discurso registrados'))
             return
 
+        logger.info(f"Procesando {len(analyses)} análisis del discurso")
         for analysis in analyses:
-            with st.expander(
-                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
-                expanded=False
-            ):
-                # Mostrar textos analizados
-                col1, col2 = st.columns(2)
-                with col1:
-                    st.text(f"{t.get('text_1', 'Texto 1')}:")
-                    st.write(analysis['text1'])
-                with col2:
-                    st.text(f"{t.get('text_2', 'Texto 2')}:")
-                    st.write(analysis['text2'])
-
-                # Mostrar conceptos clave
-                if 'key_concepts1' in analysis and 'key_concepts2' in analysis:
-                    st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
-                    
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
-                        df1 = pd.DataFrame(
-                            analysis['key_concepts1'],
-                            columns=['Concepto', 'Frecuencia']
-                        )
-                        st.dataframe(df1)
-                    
-                    with col2:
-                        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
-                        df2 = pd.DataFrame(
-                            analysis['key_concepts2'],
-                            columns=['Concepto', 'Frecuencia']
-                        )
-                        st.dataframe(df2)
-
-                # Mostrar gráficos
-                if all(key in analysis for key in ['graph1', 'graph2']):
-                    st.subheader(t.get('visualizations', 'Visualizaciones'))
-                    
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        st.markdown(f"**{t.get('graph_text_1', 'Grafo Texto 1')}**")
-                        if analysis['graph1']:
-                            image_bytes = base64.b64decode(analysis['graph1'])
-                            st.image(image_bytes)
-                    
-                    with col2:
-                        st.markdown(f"**{t.get('graph_text_2', 'Grafo Texto 2')}**")
-                        if analysis['graph2']:
-                            image_bytes = base64.b64decode(analysis['graph2'])
-                            st.image(image_bytes)
-
-                # Mostrar gráfico combinado si existe
-                if 'combined_graph' in analysis and analysis['combined_graph']:
-                    st.subheader(t.get('combined_visualization', 'Visualización Combinada'))
-                    image_bytes = base64.b64decode(analysis['combined_graph'])
-                    st.image(image_bytes)
+            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()}")
+                    continue
+
+                # Formatear fecha
+                timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
+                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                
+                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_column_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'))
+
+            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 del discurso: {str(e)}")