Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -86,13 +86,27 @@ def display_current_situation_activities(username: str, t: dict):
     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)
         situation_analyses = get_current_situation_analysis(username, limit=5)
         
+        # Verificar si hay datos
+        if situation_analyses:
+            logger.info(f"Recuperados {len(situation_analyses)} análisis de situación")
+            # Depurar para ver la estructura de datos
+            for i, analysis in enumerate(situation_analyses):
+                logger.info(f"Análisis #{i+1}: Claves disponibles: {list(analysis.keys())}")
+                if 'metrics' in analysis:
+                    logger.info(f"Métricas disponibles: {list(analysis['metrics'].keys())}")
+        else:
+            logger.warning("No se encontraron análisis de situación actual")
         
         logger.info(f"Recuperando recomendaciones de Claude para {username}")
         claude_recommendations = get_claude_recommendations(username)
         
+        if claude_recommendations:
+            logger.info(f"Recuperadas {len(claude_recommendations)} recomendaciones de Claude")
+        else:
+            logger.warning("No se encontraron recomendaciones de Claude")
+        
         # 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")
@@ -137,7 +151,7 @@ def display_current_situation_activities(username: str, t: dict):
         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:
+        for i, (timestamp_key, analysis_pair) in enumerate(paired_analyses):
             try:
                 # Obtener datos de situación y recomendación
                 situation_data = analysis_pair.get('situation', {})
@@ -171,16 +185,20 @@ def display_current_situation_activities(username: str, t: dict):
                     }.get(text_type, text_type)
                     title += f" - {text_type_display}"
                 
+                # Usar un ID único para cada expander
+                expander_id = f"analysis_{i}_{timestamp_key}"
+                
                 # Mostrar el análisis en un expander
                 with st.expander(title, expanded=False):
-                    # Mostrar texto analizado
+                    # Mostrar texto analizado con key único
                     st.subheader(t.get('analyzed_text', 'Texto analizado'))
                     st.text_area(
-                        "", 
+                        "Text Content", 
                         value=text_to_show, 
                         height=100,
                         disabled=True,
-                        label_visibility="collapsed"
+                        label_visibility="collapsed",
+                        key=f"text_area_{expander_id}"
                     )
                     
                     # Crear tabs para separar diagnóstico y recomendaciones
@@ -194,48 +212,62 @@ def display_current_situation_activities(username: str, t: dict):
                         if situation_data and 'metrics' in situation_data:
                             metrics = situation_data['metrics']
                             
-                            # 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'))
+                            # Verificar si metrics es un diccionario y tiene elementos
+                            if isinstance(metrics, dict) and metrics:
+                                # Dividir en dos columnas
+                                col1, col2 = st.columns(2)
                                 
-                                # 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'))
+                                # 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():
+                                        try:
+                                            # Verificar si metric_data es un diccionario y tiene normalized_score
+                                            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)
+                                        except Exception as e:
+                                            logger.error(f"Error procesando métrica {metric_name}: {str(e)}")
                                 
-                                # 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'])
+                                # Mostrar detalles adicionales si están disponibles
+                                with col2:
+                                    st.subheader(t.get('details', 'Detalles'))
+                                    
+                                    # Para cada métrica, mostrar sus detalles si existen
+                                    for metric_name, metric_data in metrics.items():
+                                        try:
+                                            if isinstance(metric_data, dict) and 'details' in metric_data and metric_data['details']:
+                                                # Usar st.json con un key único
+                                                st.write(f"**{metric_name.capitalize()}**")
+                                                st.json(metric_data['details'], expanded=False)
+                                        except Exception as e:
+                                            logger.error(f"Error mostrando detalles de {metric_name}: {str(e)}")
+                            else:
+                                st.info(t.get('no_metrics_data', 'No hay datos de métricas disponibles'))
+                                logger.warning(f"La estructura de métricas no es válida: {metrics}")
                         else:
                             st.info(t.get('no_diagnosis', 'No hay datos de diagnóstico disponibles'))
+                            if situation_data:
+                                logger.warning(f"Claves disponibles en situation_data: {list(situation_data.keys())}")
                     
                     # Tab de recomendaciones
                     with recommendations_tab: