Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -369,25 +369,98 @@ def display_current_situation_activities(username: str, t: dict):
 ###############################################################################################
 
 def display_morphosyntax_activities(username: str, t: dict):
-    """Muestra actividades de análisis morfosintáctico"""
+    """
+    Muestra actividades de análisis morfosintáctico, incluyendo base e iteraciones
+    desde las nuevas colecciones: student_morphosyntax_analysis_base y student_morphosyntax_iterations
+    """
     try:
-        analyses = get_student_morphosyntax_analysis(username)
-        if not analyses:
+        # Importación inline para evitar problemas de circularidad
+        # Utilizamos la función de la nueva estructura de DB iterativa
+        from ..database.morphosyntax_iterative_mongo_db import get_student_morphosyntax_analysis
+        
+        logger.info(f"Recuperando análisis morfosintáctico para {username}")
+        
+        # Esta función ahora trae tanto las bases como sus iteraciones
+        base_analyses = get_student_morphosyntax_analysis(username)
+        
+        if not base_analyses:
+            logger.info("No se encontraron análisis morfosintácticos")
             st.info(t.get('no_morpho_analyses', 'No hay análisis morfosintácticos registrados'))
             return
 
-        for analysis in analyses:
-            with st.expander(
-                f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}", 
-                expanded=False
-            ):
-                st.text(f"{t.get('analyzed_text', 'Texto analizado')}:")
-                st.write(analysis['text'])
+        logger.info(f"Procesando {len(base_analyses)} análisis morfosintácticos base")
+        
+        # Procesar cada análisis base con sus iteraciones
+        for base_analysis in base_analyses:
+            try:
+                # Formatear fecha
+                timestamp = datetime.fromisoformat(base_analysis['timestamp'].replace('Z', '+00:00'))
+                formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                
+                # Título del expander: incluir información de si tiene iteraciones
+                expander_title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
+                if base_analysis.get('has_iterations', False):
+                    expander_title += f" ({t.get('has_iterations', 'Con iteraciones')})"
+                
+                with st.expander(expander_title, expanded=False):
+                    # Mostrar texto base
+                    st.subheader(t.get('base_text', 'Texto original'))
+                    st.text_area(
+                        "Base Text Content", 
+                        value=base_analysis.get('text', ''), 
+                        height=100,
+                        disabled=True,
+                        label_visibility="collapsed",
+                        key=f"base_text_{str(base_analysis['_id'])}"
+                    )
+                    
+                    # Mostrar diagrama de arco base si existe
+                    if 'arc_diagrams' in base_analysis and base_analysis['arc_diagrams']:
+                        st.subheader(t.get('syntactic_diagrams', 'Diagrama sintáctico (original)'))
+                        # Mostrar cada diagrama (normalmente solo uno por oración)
+                        for diagram in base_analysis['arc_diagrams']:
+                            st.write(diagram, unsafe_allow_html=True)
+                    
+                    # Procesar iteraciones si existen
+                    if 'iterations' in base_analysis and base_analysis['iterations']:
+                        st.markdown("---")  # Línea divisoria
+                        st.subheader(t.get('iterations', 'Versiones mejoradas'))
+                        
+                        # Crear tabs para cada iteración
+                        iteration_tabs = st.tabs([
+                            f"{t.get('iteration', 'Versión')} {i+1}" 
+                            for i in range(len(base_analysis['iterations']))
+                        ])
+                        
+                        # Mostrar cada iteración en su propia pestaña
+                        for i, (tab, iteration) in enumerate(zip(iteration_tabs, base_analysis['iterations'])):
+                            with tab:
+                                # Timestamp de la iteración
+                                iter_timestamp = datetime.fromisoformat(
+                                    iteration['timestamp'].replace('Z', '+00:00'))
+                                iter_formatted_date = iter_timestamp.strftime("%d/%m/%Y %H:%M:%S")
+                                st.caption(f"{t.get('iteration_date', 'Fecha de versión')}: {iter_formatted_date}")
+                                
+                                # Texto de la iteración
+                                st.text_area(
+                                    f"Iteration Text {i+1}", 
+                                    value=iteration.get('iteration_text', ''), 
+                                    height=100,
+                                    disabled=True,
+                                    label_visibility="collapsed",
+                                    key=f"iter_text_{str(iteration['_id'])}"
+                                )
+                                
+                                # Diagrama de arco de la iteración
+                                if 'arc_diagrams' in iteration and iteration['arc_diagrams']:
+                                    st.subheader(t.get('iteration_diagram', 'Diagrama sintáctico (mejorado)'))
+                                    for diagram in iteration['arc_diagrams']:
+                                        st.write(diagram, unsafe_allow_html=True)
                 
-                if 'arc_diagrams' in analysis:
-                    st.subheader(t.get('syntactic_diagrams', 'Diagramas sintácticos'))
-                    for diagram in analysis['arc_diagrams']:
-                        st.write(diagram, unsafe_allow_html=True)
+            except Exception as e:
+                logger.error(f"Error procesando análisis morfosintáctico: {str(e)}")
+                st.error(t.get('error_processing_analysis', 'Error procesando este análisis'))
+                continue
 
     except Exception as e:
         logger.error(f"Error mostrando análisis morfosintáctico: {str(e)}")