Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -77,6 +77,188 @@ 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.
+    """
+    try:
+        # Recuperar datos de ambas colecciones
+        logger.info(f"Recuperando análisis de situación actual para {username}")
+        situation_analyses = get_student_current_situation(username)
+        
+        logger.info(f"Recuperando recomendaciones de Claude para {username}")
+        claude_recommendations = get_claude_recommendations(username)
+        
+        # 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
+        
+        # Crear un diccionario para indexar análisis por timestamp
+        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:
+                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:
+                timestamp_key = recommendation['timestamp'].split('.')[0]
+                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 i, (timestamp_key, analysis_pair) in enumerate(paired_analyses):
+            try:
+                # 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
+                
+                # 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:
+                    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'),
+                        'student_essay': t.get('student_essay', 'Trabajo universitario'),
+                        'general_communication': t.get('general_communication', 'Comunicación general')
+                    }.get(text_type, text_type)
+                    title += f" - {text_type_display}"
+                
+                # Mostrar el análisis en un expander
+                with st.expander(title, expanded=False, key=f"situation_expander_{i}"):
+                    # Mostrar texto analizado
+                    st.subheader(t.get('analyzed_text', 'Texto analizado'))
+                    st.text_area(
+                        label="Texto analizado", 
+                        value=text_to_show, 
+                        height=100,
+                        disabled=True,
+                        key=f"situation_text_{i}",
+                        label_visibility="hidden"
+                    )
+                    
+                    # 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')
+                    ])
+                    
+                    # Tab de diagnóstico
+                    with diagnosis_tab:
+                        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'))
+                                
+                                # Mostrar cada métrica principal
+                                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']
+                                        
+                                        # 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'))
+                                
+                                # 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']:
+                                        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:
+                            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 par de análisis: {str(e)}")
+                continue
+        
+    except Exception as e:
+        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_morphosyntax_activities(username: str, t: dict):
     """Muestra actividades de análisis morfosintáctico"""
     try:
@@ -264,189 +446,6 @@ def display_chat_activities(username: str, t: dict):
     except Exception as e:
         logger.error(f"Error mostrando historial del chat: {str(e)}")
         st.error(t.get('error_chat', 'Error al mostrar historial del chat'))
-
-#################################################################################
-
-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.
-    """
-    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}")
-        claude_recommendations = get_claude_recommendations(username)
-        
-        # 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
-        
-        # Crear un diccionario para indexar análisis por timestamp
-        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:
-                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:
-                timestamp_key = recommendation['timestamp'].split('.')[0]
-                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 i, (timestamp_key, analysis_pair) in enumerate(paired_analyses):
-            try:
-                # 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
-                
-                # 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:
-                    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'),
-                        'student_essay': t.get('student_essay', 'Trabajo universitario'),
-                        'general_communication': t.get('general_communication', 'Comunicación general')
-                    }.get(text_type, text_type)
-                    title += f" - {text_type_display}"
-                
-                # Mostrar el análisis en un expander
-                with st.expander(title, expanded=False, key=f"situation_expander_{i}"):
-                    # Mostrar texto analizado
-                    st.subheader(t.get('analyzed_text', 'Texto analizado'))
-                    st.text_area(
-                        label="Texto analizado", 
-                        value=text_to_show, 
-                        height=100,
-                        disabled=True,
-                        key=f"situation_text_{i}",
-                        label_visibility="hidden"
-                    )
-                    
-                    # 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')
-                    ])
-                    
-                    # Tab de diagnóstico
-                    with diagnosis_tab:
-                        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'))
-                                
-                                # Mostrar cada métrica principal
-                                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']
-                                        
-                                        # 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'))
-                                
-                                # 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']:
-                                        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:
-                            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 par de análisis: {str(e)}")
-                continue
-        
-    except Exception as e:
-        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):