Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -81,12 +81,12 @@ def display_student_activities(username: str, lang_code: str, t: dict):
 def display_current_situation_activities(username: str, t: dict):
     """
     Muestra análisis de situación actual junto con las recomendaciones de Claude
-    unificando la información de ambas colecciones.
+    unificando la información de ambas colecciones y emparejándolas por cercanía temporal.
     """
     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, limit=5)
+        situation_analyses = get_current_situation_analysis(username, limit=10)
         
         # Verificar si hay datos
         if situation_analyses:
@@ -113,49 +113,90 @@ def display_current_situation_activities(username: str, t: dict):
             st.info(t.get('no_current_situation', 'No hay análisis de situación actual registrados'))
             return
         
-        # 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 = {}
+        # Crear pares combinados emparejando diagnósticos y recomendaciones cercanos en tiempo
+        logger.info("Creando emparejamientos temporales de análisis")
         
-        # Indexar análisis de situación actual
+        # Convertir timestamps a objetos datetime para comparación
+        situation_times = []
         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}
+                try:
+                    timestamp_str = analysis['timestamp']
+                    dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
+                    situation_times.append((dt, analysis))
+                except Exception as e:
+                    logger.error(f"Error parseando timestamp de situación: {str(e)}")
         
-        # Indexar recomendaciones de Claude 
+        recommendation_times = []
         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}
+                try:
+                    timestamp_str = recommendation['timestamp']
+                    dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
+                    recommendation_times.append((dt, recommendation))
+                except Exception as e:
+                    logger.error(f"Error parseando timestamp de recomendación: {str(e)}")
         
-        # 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
+        # Ordenar por tiempo
+        situation_times.sort(key=lambda x: x[0], reverse=True)
+        recommendation_times.sort(key=lambda x: x[0], reverse=True)
+        
+        # Crear pares combinados
+        combined_items = []
+        
+        # Primero, procesar todas las situaciones encontrando la recomendación más cercana
+        for sit_time, situation in situation_times:
+            # Buscar la recomendación más cercana en tiempo
+            best_match = None
+            min_diff = timedelta(minutes=30)  # Máxima diferencia de tiempo aceptable (30 minutos)
+            best_rec_time = None
             
-        # Convertir a lista ordenada por timestamp (más reciente primero)
-        paired_analyses = sorted(
-            analyses_by_timestamp.items(), 
-            key=lambda x: x[0], 
-            reverse=True
-        )
+            for rec_time, recommendation in recommendation_times:
+                time_diff = abs(sit_time - rec_time)
+                if time_diff < min_diff:
+                    min_diff = time_diff
+                    best_match = recommendation
+                    best_rec_time = rec_time
+            
+            # Crear un elemento combinado
+            if best_match:
+                timestamp_key = sit_time.isoformat()
+                combined_items.append((timestamp_key, {
+                    'situation': situation,
+                    'recommendation': best_match,
+                    'time_diff': min_diff.total_seconds()
+                }))
+                # Eliminar la recomendación usada para no reutilizarla
+                recommendation_times = [(t, r) for t, r in recommendation_times if t != best_rec_time]
+                logger.info(f"Emparejado: Diagnóstico {sit_time} con Recomendación {best_rec_time} (diferencia: {min_diff})")
+            else:
+                # Si no hay recomendación cercana, solo incluir la situación
+                timestamp_key = sit_time.isoformat()
+                combined_items.append((timestamp_key, {
+                    'situation': situation
+                }))
+                logger.info(f"Sin emparejar: Diagnóstico {sit_time} sin recomendación cercana")
+        
+        # Agregar recomendaciones restantes sin situación
+        for rec_time, recommendation in recommendation_times:
+            timestamp_key = rec_time.isoformat()
+            combined_items.append((timestamp_key, {
+                'recommendation': recommendation
+            }))
+            logger.info(f"Sin emparejar: Recomendación {rec_time} sin diagnóstico cercano")
+        
+        # Ordenar por tiempo (más reciente primero)
+        combined_items.sort(key=lambda x: x[0], reverse=True)
         
-        logger.info(f"Procesando {len(paired_analyses)} pares de análisis")
+        logger.info(f"Procesando {len(combined_items)} elementos combinados")
         
-        # Mostrar cada par de análisis
-        for i, (timestamp_key, analysis_pair) in enumerate(paired_analyses):
+        # Mostrar cada par combinado
+        for i, (timestamp_key, analysis_pair) in enumerate(combined_items):
             try:
                 # Obtener datos de situación y recomendación
                 situation_data = analysis_pair.get('situation', {})
                 recommendation_data = analysis_pair.get('recommendation', {})
+                time_diff = analysis_pair.get('time_diff')
                 
                 # Si no hay ningún dato, continuar al siguiente
                 if not situation_data and not recommendation_data:
@@ -167,10 +208,9 @@ def display_current_situation_activities(username: str, t: dict):
                 
                 # 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")
+                    # Usar timestamp del key que ya es un formato ISO
+                    dt = datetime.fromisoformat(timestamp_key)
+                    formatted_date = dt.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
@@ -185,8 +225,15 @@ def display_current_situation_activities(username: str, t: dict):
                     }.get(text_type, text_type)
                     title += f" - {text_type_display}"
                 
+                # Añadir indicador de emparejamiento si existe
+                if time_diff is not None:
+                    if time_diff < 60:  # menos de un minuto
+                        title += f" 🔄 (emparejados)"
+                    else:
+                        title += f" 🔄 (emparejados, diferencia: {int(time_diff//60)} min)"
+                
                 # Usar un ID único para cada expander
-                expander_id = f"analysis_{i}_{timestamp_key}"
+                expander_id = f"analysis_{i}_{timestamp_key.replace(':', '_')}"
                 
                 # Mostrar el análisis en un expander
                 with st.expander(title, expanded=False):
@@ -212,9 +259,6 @@ def display_current_situation_activities(username: str, t: dict):
                         if situation_data and 'metrics' in situation_data:
                             metrics = situation_data['metrics']
                             
-                            # Imprimir estructura real para depuración
-                            st.write("Estructura de métricas:", metrics)
-                            
                             # Dividir en dos columnas
                             col1, col2 = st.columns(2)
                             
@@ -235,9 +279,8 @@ def display_current_situation_activities(username: str, t: dict):
                                                 score = metric_data['score']
                                             elif 'value' in metric_data:
                                                 score = metric_data['value']
-                                            # Agregar fallback para valores numéricos directos
-                                            elif isinstance(metric_data, (int, float)):
-                                                score = metric_data
+                                        elif isinstance(metric_data, (int, float)):
+                                            score = metric_data
                                         
                                         if score is not None:
                                             # Asegurarse de que score es numérico
@@ -263,11 +306,10 @@ def display_current_situation_activities(username: str, t: dict):
                                                 # Si no es numérico, mostrar como texto
                                                 st.markdown(f"""
                                                 <div style="background-color:#f0f0f0; padding:10px; border-radius:5px; margin-bottom:10px;">
-                                                    <b>ℹ️ {metric_name.capitalize()}:</b> {score}
+                                                    <b>ℹ️ {metric_name.capitalize()}:</b> {str(score)}
                                                 </div>
                                                 """, unsafe_allow_html=True)
                                     except Exception as e:
-                                        st.error(f"Error procesando métrica {metric_name}: {str(e)}")
                                         logger.error(f"Error procesando métrica {metric_name}: {str(e)}")
                             
                             # Mostrar detalles adicionales si están disponibles
@@ -288,16 +330,12 @@ def display_current_situation_activities(username: str, t: dict):
                                                           if k not in ['normalized_score', 'score', 'value']}
                                             
                                             if details:
-                                                detail_key = f"details_{metric_name}_{timestamp_key}_{i}"
                                                 st.write(f"**{metric_name.capitalize()}**")
                                                 st.json(details, expanded=False)
                                     except Exception as e:
-                                        st.error(f"Error mostrando detalles de {metric_name}: {str(e)}")
                                         logger.error(f"Error mostrando detalles de {metric_name}: {str(e)}")
                         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: