Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -1,4 +1,4 @@
-##############
+ ##############
 ###modules/studentact/student_activities_v2.py
 
 import streamlit as st
@@ -21,8 +21,8 @@ from ..database.morphosintax_mongo_db import get_student_morphosyntax_analysis
 from ..database.semantic_mongo_db import get_student_semantic_analysis
 from ..database.discourse_mongo_db import get_student_discourse_analysis
 from ..database.chat_mongo_db import get_chat_history
-from ..database.current_situation_mongo_db import get_current_situation_analysis  # Nueva importación
-from ..database.claude_recommendations_mongo_db import get_claude_recommendations  # Actualizada
+from ..database.current_situation_mongo_db import get_current_situation_analysis
+from ..database.claude_recommendations_mongo_db import get_claude_recommendations
 
 logger = logging.getLogger(__name__)
 
@@ -39,16 +39,16 @@ def display_student_activities(username: str, lang_code: str, t: dict):
     try:
         st.header(t.get('activities_title', 'Mis Actividades'))
 
-        # Tabs para diferentes tipos de análisis (añadimos la nueva tab)
+        # Tabs para diferentes tipos de análisis
         tabs = st.tabs([
-            t.get('current_situation_activities', 'Mi Situación Actual'),  # Nueva pestaña
+            t.get('current_situation_activities', 'Mi Situación Actual'),
             t.get('morpho_activities', 'Análisis Morfosintáctico'),
             t.get('semantic_activities', 'Análisis Semántico'),
             t.get('discourse_activities', 'Análisis del Discurso'),
             t.get('chat_activities', 'Conversaciones con el Asistente')
         ])
 
-        # Tab de Situación Actual (nueva)
+        # Tab de Situación Actual
         with tabs[0]:
             display_current_situation_activities(username, t)
         
@@ -212,101 +212,6 @@ def display_discourse_activities(username: str, t: dict):
         logger.error(f"Error mostrando análisis del discurso: {str(e)}")
         st.error(t.get('error_discourse', 'Error al mostrar análisis del discurso'))
 
-
-###################################################################################
-# Nueva función para mostrar las actividades de Situación Actual
-def display_current_situation_activities(username: str, t: dict):
-    """Muestra actividades de análisis de situación actual con recomendaciones de Claude"""
-    try:
-        logger.info(f"Recuperando análisis de situación actual para {username}")
-        analyses = get_current_situation_analysis(username)
-        
-        if not analyses:
-            logger.info("No se encontraron análisis de situación actual")
-            st.info(t.get('no_current_situation', 'No hay análisis de situación actual registrados'))
-            return
-
-        logger.info(f"Procesando {len(analyses)} análisis de situación actual")
-        
-        for analysis in analyses:
-            try:
-                # Verificar campos necesarios
-                if not all(key in analysis for key in ['timestamp', 'feedback']):
-                    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 con título que incluye información del tipo de texto si está disponible
-                title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
-                if 'text_type' in analysis:
-                    text_type_display = {
-                        'academic_article': t.get('academic_article', 'Artículo académico'),
-                        'university_work': t.get('university_work', 'Trabajo universitario'),
-                        'general_communication': t.get('general_communication', 'Comunicación general')
-                    }.get(analysis['text_type'], analysis['text_type'])
-                    title += f" - {text_type_display}"
-                
-                with st.expander(title, expanded=False):
-                    # Mostrar el texto original analizado
-                    st.subheader(t.get('analyzed_text', 'Texto analizado'))
-                    st.text_area(
-                        "",
-                        value=analysis.get('text', ''),
-                        height=100,
-                        disabled=True,
-                        label_visibility="collapsed"
-                    )
-                    
-                    # Mostrar las recomendaciones generadas por Claude
-                    st.subheader(t.get('recommendations', 'Recomendaciones'))
-                    
-                    # Dar formato a las recomendaciones en un contenedor estilizado
-                    st.markdown(f"""
-                    <div style="padding: 20px; border-radius: 10px; 
-                        background-color: #f8f9fa; margin-bottom: 20px;">
-                        {analysis['feedback']}
-                    </div>
-                    """, unsafe_allow_html=True)
-                    
-                    # Mostrar métricas adicionales si están disponibles
-                    if 'metrics' in analysis and analysis['metrics']:
-                        with st.expander(t.get('metrics_details', 'Detalles de métricas')):
-                            # Convertir métricas a dataframe para mejor visualización
-                            metrics_df = pd.DataFrame([
-                                {"Métrica": k, "Valor": v}
-                                for k, v in analysis['metrics'].items()
-                                if k not in ['test_type', 'timestamp'] and not isinstance(v, dict)
-                            ])
-                            st.dataframe(metrics_df, use_container_width=True)
-
-            except Exception as e:
-                logger.error(f"Error procesando análisis individual de situación actual: {str(e)}")
-                continue
-
-    except Exception as e:
-        logger.error(f"Error mostrando análisis de situación actual: {str(e)}")
-        st.error(t.get('error_current_situation', 'Error al mostrar análisis de situación actual'))
-        
-        
-#################################################################################        
-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'))
-    
-    col1, col2 = st.columns(2)
-    with col1:
-        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
-        df1 = pd.DataFrame(analysis['key_concepts1'])
-        st.dataframe(df1)
-    
-    with col2:
-        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
-        df2 = pd.DataFrame(analysis['key_concepts2'])
-        st.dataframe(df2)
-
 #################################################################################   
 def display_chat_activities(username: str, t: dict):
     """
@@ -357,83 +262,203 @@ def display_chat_activities(username: str, t: dict):
         logger.error(f"Error mostrando historial del chat: {str(e)}")
         st.error(t.get('error_chat', 'Error al mostrar historial del chat'))
 
-##############################################################################################
-# Nueva función para mostrar las actividades de Situación Actual
+#################################################################################
 def display_current_situation_activities(username: str, t: dict):
-    """Muestra actividades de análisis de situación actual con recomendaciones de Claude"""
+    """
+    Muestra análisis de situación actual junto con las recomendaciones de Claude
+    unificando la información de ambas colecciones.
+    """
     try:
+        # Recuperar datos de ambas colecciones
+        logger.info(f"Recuperando análisis de situación actual para {username}")
+        situation_analyses = get_current_situation_analysis(username)
+        
         logger.info(f"Recuperando recomendaciones de Claude para {username}")
-        recommendations = get_claude_recommendations(username)
+        claude_recommendations = get_claude_recommendations(username)
         
-        if not recommendations:
-            logger.info("No se encontraron recomendaciones de Claude")
-            st.info(t.get('no_recommendations', 'No hay recomendaciones de Claude registradas'))
+        # Verificar si hay algún tipo de análisis disponible
+        if not situation_analyses and not claude_recommendations:
+            logger.info("No se encontraron análisis de situación actual ni recomendaciones")
+            st.info(t.get('no_current_situation', 'No hay análisis de situación actual registrados'))
             return
-
-        logger.info(f"Procesando {len(recommendations)} recomendaciones de Claude")
         
-        for recommendation in recommendations:
+        # Crear un diccionario para indexar análisis por timestamp
+        # Esto permite emparejar diagnósticos y recomendaciones del mismo momento
+        logger.info("Creando índice temporal de análisis")
+        analyses_by_timestamp = {}
+        
+        # Indexar análisis de situación actual
+        for analysis in situation_analyses:
+            if 'timestamp' in analysis:
+                # Normalizar el formato de timestamp para comparación
+                timestamp_key = analysis['timestamp'].split('.')[0]  # Remover milisegundos
+                if timestamp_key not in analyses_by_timestamp:
+                    analyses_by_timestamp[timestamp_key] = {'situation': analysis}
+        
+        # Indexar recomendaciones de Claude 
+        for recommendation in claude_recommendations:
+            if 'timestamp' in recommendation:
+                # Normalizar el formato de timestamp para comparación
+                timestamp_key = recommendation['timestamp'].split('.')[0]  # Remover milisegundos
+                if timestamp_key in analyses_by_timestamp:
+                    analyses_by_timestamp[timestamp_key]['recommendation'] = recommendation
+                else:
+                    analyses_by_timestamp[timestamp_key] = {'recommendation': recommendation}
+        
+        # Si no hay análisis después de la indexación
+        if not analyses_by_timestamp:
+            st.info(t.get('no_paired_analyses', 'No hay análisis disponibles'))
+            return
+            
+        # Convertir a lista ordenada por timestamp (más reciente primero)
+        paired_analyses = sorted(
+            analyses_by_timestamp.items(), 
+            key=lambda x: x[0], 
+            reverse=True
+        )
+        
+        logger.info(f"Procesando {len(paired_analyses)} pares de análisis")
+        
+        # Mostrar cada par de análisis
+        for timestamp_key, analysis_pair in paired_analyses:
             try:
-                # Verificar campos necesarios
-                if not all(key in recommendation for key in ['timestamp', 'feedback']):
-                    logger.warning(f"Recomendación incompleta: {recommendation.keys()}")
+                # Obtener datos de situación y recomendación
+                situation_data = analysis_pair.get('situation', {})
+                recommendation_data = analysis_pair.get('recommendation', {})
+                
+                # Si no hay ningún dato, continuar al siguiente
+                if not situation_data and not recommendation_data:
                     continue
                 
-                # Formatear fecha
-                timestamp = datetime.fromisoformat(recommendation['timestamp'].replace('Z', '+00:00'))
-                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                # Determinar qué texto mostrar (priorizar el de la situación)
+                text_to_show = situation_data.get('text', recommendation_data.get('text', ''))
+                text_type = situation_data.get('text_type', recommendation_data.get('text_type', ''))
                 
-                # Crear expander con título que incluye información del tipo de texto si está disponible
-                title = f"{t.get('recommendation_date', 'Fecha')}: {formatted_date}"
-                if 'text_type' in recommendation:
+                # Formatear fecha para mostrar
+                try:
+                    # Usar timestamp de situation_data si está disponible, sino usar el de recommendation_data
+                    timestamp_str = situation_data.get('timestamp', recommendation_data.get('timestamp', timestamp_key))
+                    timestamp = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
+                    formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                except Exception as date_error:
+                    logger.error(f"Error formateando fecha: {str(date_error)}")
+                    formatted_date = timestamp_key
+                
+                # Determinar el título del expander
+                title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
+                if text_type:
                     text_type_display = {
                         'academic_article': t.get('academic_article', 'Artículo académico'),
-                        'university_work': t.get('university_work', 'Trabajo universitario'),
+                        'student_essay': t.get('student_essay', 'Trabajo universitario'),
                         'general_communication': t.get('general_communication', 'Comunicación general')
-                    }.get(recommendation['text_type'], recommendation['text_type'])
+                    }.get(text_type, text_type)
                     title += f" - {text_type_display}"
                 
+                # Mostrar el análisis en un expander
                 with st.expander(title, expanded=False):
-                    # Mostrar el texto original analizado
+                    # Mostrar texto analizado
                     st.subheader(t.get('analyzed_text', 'Texto analizado'))
                     st.text_area(
-                        "",
-                        value=recommendation.get('text', ''),
+                        "", 
+                        value=text_to_show, 
                         height=100,
                         disabled=True,
                         label_visibility="collapsed"
                     )
                     
-                    # Mostrar las recomendaciones generadas por Claude
-                    st.subheader(t.get('recommendations', 'Recomendaciones de Claude'))
-                    
-                    # Dar formato a las recomendaciones en un contenedor estilizado
-                    st.markdown(f"""
-                    <div style="padding: 20px; border-radius: 10px; 
-                        background-color: #f8f9fa; margin-bottom: 20px;">
-                        {recommendation.get('feedback', 'No hay recomendaciones disponibles')}
-                    </div>
-                    """, unsafe_allow_html=True)
+                    # Crear tabs para separar diagnóstico y recomendaciones
+                    diagnosis_tab, recommendations_tab = st.tabs([
+                        t.get('diagnosis_tab', 'Diagnóstico'),
+                        t.get('recommendations_tab', 'Recomendaciones')
+                    ])
                     
-                    # Mostrar métricas adicionales si están disponibles
-                    if 'metrics' in recommendation and recommendation['metrics']:
-                        with st.expander(t.get('metrics_details', 'Detalles de métricas')):
-                            # Crear un DataFrame para mejor visualización
-                            metrics_data = []
-                            for key, value in recommendation['metrics'].items():
-                                if not isinstance(value, dict) and key not in ['test_type', 'timestamp']:
-                                    metrics_data.append({"Métrica": key, "Valor": value})
+                    # Tab de diagnóstico
+                    with diagnosis_tab:
+                        if situation_data and 'metrics' in situation_data:
+                            metrics = situation_data['metrics']
                             
-                            if metrics_data:
-                                metrics_df = pd.DataFrame(metrics_data)
-                                st.dataframe(metrics_df, use_container_width=True)
-                            else:
-                                st.info(t.get('no_metrics', 'No hay métricas disponibles'))
-
+                            # Dividir en dos columnas
+                            col1, col2 = st.columns(2)
+                            
+                            # Principales métricas en formato de tarjetas
+                            with col1:
+                                st.subheader(t.get('key_metrics', 'Métricas clave'))
+                                
+                                # Mostrar cada métrica principal
+                                for metric_name, metric_data in metrics.items():
+                                    if isinstance(metric_data, dict) and 'normalized_score' in metric_data:
+                                        score = metric_data['normalized_score']
+                                        
+                                        # Determinar color y emoji basado en la puntuación
+                                        if score < 0.5:
+                                            emoji = "🔴"
+                                            color = "#ffcccc"  # light red
+                                        elif score < 0.75:
+                                            emoji = "🟡"
+                                            color = "#ffffcc"  # light yellow
+                                        else:
+                                            emoji = "🟢"
+                                            color = "#ccffcc"  # light green
+                                        
+                                        # Mostrar la métrica con estilo
+                                        st.markdown(f"""
+                                        <div style="background-color:{color}; padding:10px; border-radius:5px; margin-bottom:10px;">
+                                            <b>{emoji} {metric_name.capitalize()}:</b> {score:.2f}
+                                        </div>
+                                        """, unsafe_allow_html=True)
+                            
+                            # Mostrar detalles adicionales si están disponibles
+                            with col2:
+                                st.subheader(t.get('details', 'Detalles'))
+                                
+                                # Recursivamente mostrar detalles de las métricas
+                                for metric_name, metric_data in metrics.items():
+                                    if isinstance(metric_data, dict) and 'details' in metric_data and metric_data['details']:
+                                        with st.expander(f"{metric_name.capitalize()} - {t.get('details', 'Detalles')}"):
+                                            # Mostrar detalles como JSON
+                                            st.json(metric_data['details'])
+                        else:
+                            st.info(t.get('no_diagnosis', 'No hay datos de diagnóstico disponibles'))
+                    
+                    # Tab de recomendaciones
+                    with recommendations_tab:
+                        if recommendation_data and 'recommendations' in recommendation_data:
+                            st.markdown(f"""
+                            <div style="padding: 20px; border-radius: 10px; 
+                                background-color: #f8f9fa; margin-bottom: 20px;">
+                                {recommendation_data['recommendations']}
+                            </div>
+                            """, unsafe_allow_html=True)
+                        elif recommendation_data and 'feedback' in recommendation_data:
+                            st.markdown(f"""
+                            <div style="padding: 20px; border-radius: 10px; 
+                                background-color: #f8f9fa; margin-bottom: 20px;">
+                                {recommendation_data['feedback']}
+                            </div>
+                            """, unsafe_allow_html=True)
+                        else:
+                            st.info(t.get('no_recommendations', 'No hay recomendaciones disponibles'))
+            
             except Exception as e:
-                logger.error(f"Error procesando recomendación individual: {str(e)}")
+                logger.error(f"Error procesando par de análisis: {str(e)}")
                 continue
-
+        
     except Exception as e:
-        logger.error(f"Error mostrando recomendaciones de Claude: {str(e)}")
-        st.error(t.get('error_recommendations', 'Error al mostrar recomendaciones de Claude'))
+        logger.error(f"Error mostrando actividades de situación actual: {str(e)}")
+        st.error(t.get('error_current_situation', 'Error al mostrar análisis de situación actual'))
+
+#################################################################################        
+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'))
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
+        df1 = pd.DataFrame(analysis['key_concepts1'])
+        st.dataframe(df1)
+    
+    with col2:
+        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+        df2 = pd.DataFrame(analysis['key_concepts2'])
+        st.dataframe(df2)