Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -287,23 +287,20 @@ def display_current_situation_activities(username: str, t: dict):
             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 = {}
         
         # 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
+                timestamp_key = analysis['timestamp'].split('.')[0]
                 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
+                timestamp_key = recommendation['timestamp'].split('.')[0]
                 if timestamp_key in analyses_by_timestamp:
                     analyses_by_timestamp[timestamp_key]['recommendation'] = recommendation
                 else:
@@ -334,13 +331,12 @@ def display_current_situation_activities(username: str, t: dict):
                 if not situation_data and not recommendation_data:
                     continue
                 
-                # Determinar qué texto mostrar (priorizar el de la situación)
+                # Determinar qué texto mostrar
                 text_to_show = situation_data.get('text', recommendation_data.get('text', ''))
                 text_type = situation_data.get('text_type', recommendation_data.get('text_type', ''))
                 
                 # 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")
@@ -358,30 +354,24 @@ def display_current_situation_activities(username: str, t: dict):
                     }.get(text_type, text_type)
                     title += f" - {text_type_display}"
                 
-                # Generar clave única para este expander
-                expander_key = generate_unique_key("situation", f"expander_{i}", username)
-                
                 # Mostrar el análisis en un expander
-                with st.expander(title, expanded=False, key=expander_key):
+                with st.expander(title, expanded=False, key=f"situation_expander_{i}"):
                     # Mostrar texto analizado
                     st.subheader(t.get('analyzed_text', 'Texto analizado'))
-                    # Usar clave única para el text_area
-                    text_area_key = generate_unique_key("situation", f"text_area_{i}", username)
                     st.text_area(
                         label="Texto analizado", 
                         value=text_to_show, 
                         height=100,
                         disabled=True,
-                        key=text_area_key,
+                        key=f"situation_text_{i}",
                         label_visibility="hidden"
                     )
                     
                     # Crear tabs para separar diagnóstico y recomendaciones
-                    tab_key = generate_unique_key("situation", f"tabs_{i}", username)
                     diagnosis_tab, recommendations_tab = st.tabs([
                         t.get('diagnosis_tab', 'Diagnóstico'),
                         t.get('recommendations_tab', 'Recomendaciones')
-                    ], key=tab_key)
+                    ])
                     
                     # Tab de diagnóstico
                     with diagnosis_tab:
@@ -396,7 +386,7 @@ def display_current_situation_activities(username: str, t: dict):
                                 st.subheader(t.get('key_metrics', 'Métricas clave'))
                                 
                                 # Mostrar cada métrica principal
-                                for metric_name, metric_data in metrics.items():
+                                for j, (metric_name, metric_data) in enumerate(metrics.items()):
                                     if isinstance(metric_data, dict) and 'normalized_score' in metric_data:
                                         score = metric_data['normalized_score']
                                         
@@ -412,45 +402,40 @@ def display_current_situation_activities(username: str, t: dict):
                                             color = "#ccffcc"  # light green
                                         
                                         # Mostrar la métrica con estilo
-                                        metric_key = generate_unique_key("situation", f"metric_{i}_{metric_name}", username)
                                         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, key=metric_key)
+                                        """, 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 como JSON o texto plano
-                                for metric_name, metric_data in metrics.items():
+                                # Mostrar detalles como texto simple
+                                for j, (metric_name, metric_data) in enumerate(metrics.items()):
                                     if isinstance(metric_data, dict) and 'details' in metric_data and metric_data['details']:
-                                        detail_key = generate_unique_key("situation", f"detail_{i}_{metric_name}", username)
-                                        with st.container():
-                                            st.markdown(f"**{metric_name.capitalize()}**")
-                                            st.json(metric_data['details'], key=detail_key)
+                                        st.markdown(f"**{metric_name.capitalize()}**")
+                                        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:
-                            recom_key = generate_unique_key("situation", f"recom_{i}", username)
                             st.markdown(f"""
                             <div style="padding: 20px; border-radius: 10px; 
                                 background-color: #f8f9fa; margin-bottom: 20px;">
                                 {recommendation_data['recommendations']}
                             </div>
-                            """, unsafe_allow_html=True, key=recom_key)
+                            """, unsafe_allow_html=True)
                         elif recommendation_data and 'feedback' in recommendation_data:
-                            feedback_key = generate_unique_key("situation", f"feedback_{i}", username)
                             st.markdown(f"""
                             <div style="padding: 20px; border-radius: 10px; 
                                 background-color: #f8f9fa; margin-bottom: 20px;">
                                 {recommendation_data['feedback']}
                             </div>
-                            """, unsafe_allow_html=True, key=feedback_key)
+                            """, unsafe_allow_html=True)
                         else:
                             st.info(t.get('no_recommendations', 'No hay recomendaciones disponibles'))
             
@@ -462,6 +447,7 @@ def display_current_situation_activities(username: str, t: dict):
         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"""