Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -25,7 +25,6 @@ from ..database.chat_mongo_db import get_chat_history
 logger = logging.getLogger(__name__)
 
 ###################################################################################
-
 def display_student_activities(username: str, lang_code: str, t: dict):
     """
     Muestra todas las actividades del estudiante
@@ -65,52 +64,61 @@ 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:
+        analyses = get_student_morphosyntax_analysis(username)
+        if not analyses:
+            st.info(t.get('no_morpho_analyses', 'No hay análisis morfosintácticos registrados'))
+            return
+
+        for analysis in analyses:
+            with st.expander(
+                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
+                expanded=False
+            ):
+                st.text(f"{t.get('analyzed_text', 'Texto analizado')}:")
+                st.write(analysis['text'])
+                
+                if 'arc_diagrams' in analysis:
+                    st.subheader(t.get('syntactic_diagrams', 'Diagramas sintácticos'))
+                    for diagram in analysis['arc_diagrams']:
+                        st.write(diagram, unsafe_allow_html=True)
+
+    except Exception as e:
+        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:
-            try:
-                logger.debug(f"Datos del análisis: {analysis.keys()}")
+            with st.expander(
+                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
+                expanded=False
+            ):
                 
-                # Verificar timestamp
-                if 'timestamp' not in analysis:
-                    logger.warning("Análisis sin timestamp")
-                    continue
-                    
-                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):
-                    # Verificar gráfico
-                    if 'concept_graph' not in analysis:
-                        logger.warning("Análisis sin gráfico de conceptos")
-                        st.info(t.get('no_graph', 'No hay visualización disponible'))
-                        continue
-                        
-                    if not analysis['concept_graph']:
-                        logger.warning("Gráfico de conceptos vacío")
-                        st.info(t.get('no_graph', 'No hay visualización disponible'))
-                        continue
-                        
-                    logger.debug("Decodificando gráfico de conceptos")
+                # 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)
-                    logger.debug("Gráfico mostrado exitosamente")
-
-            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)}")
@@ -121,54 +129,60 @@ def display_semantic_activities(username: str, t: dict):
 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:
-            try:
-                logger.debug(f"Datos del análisis: {analysis.keys()}")
-                
-                # Verificar timestamp
-                if 'timestamp' not in analysis:
-                    logger.warning("Análisis sin timestamp")
-                    continue
+            with st.expander(
+                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
+                expanded=False
+            ):
+
+                # Mostrar conceptos clave
+                if 'key_concepts1' in analysis and 'key_concepts2' in analysis:
+                    st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
                     
-                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):
-                    # Verificar gráfico
-                    if 'combined_graph' not in analysis:
-                        logger.warning("Análisis sin gráfico combinado")
-                        st.info(t.get('no_visualization', 'No hay visualización comparativa disponible'))
-                        continue
-                        
-                    if not analysis['combined_graph']:
-                        logger.warning("Gráfico combinado vacío")
-                        st.info(t.get('no_visualization', 'No hay visualización comparativa disponible'))
-                        continue
-                        
-                    logger.debug("Decodificando gráfico combinado")
-                    image_bytes = base64.b64decode(analysis['combined_graph'])
-                    st.image(image_bytes)
-                    logger.debug("Gráfico mostrado exitosamente")
-
-            except Exception as e:
-                logger.error(f"Error procesando análisis individual: {str(e)}")
-                continue
+                    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)
 
     except Exception as e:
         logger.error(f"Error mostrando análisis del discurso: {str(e)}")
         st.error(t.get('error_discourse', 'Error al mostrar análisis del discurso'))
 #################################################################################        
 
-
 def display_discourse_comparison(analysis: dict, t: dict):
     """Muestra la comparación de análisis del discurso"""
     st.subheader(t.get('comparison_results', 'Resultados de la comparación'))