Update modules/morphosyntax/morphosyntax_interface.py

modules/morphosyntax/morphosyntax_interface.py

@@ -45,7 +45,7 @@ import re
 
 def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
     try:
-        # CSS para mejorar la estabilidad y diseño
+        # CSS mejorado para estabilidad y layout horizontal
         st.markdown("""
             <style>
             .stTextArea textarea {
@@ -55,209 +55,223 @@ def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
                 border-radius: 0.375rem;
                 border: 1px solid #e2e8f0;
                 background-color: white;
+                min-height: 100px !important;
+                height: 100px !important;
             }
-            .original-content {
-                background-color: #f8fafc;
-                padding: 1rem;
-                border-radius: 0.5rem;
-                margin-bottom: 1rem;
+            .block-container {
+                padding-top: 0.5rem !important;
+                padding-bottom: 0.5rem !important;
+                margin: 0 !important;
             }
-            .iteration-content {
-                background-color: white;
-                padding: 1rem;
-                border-radius: 0.5rem;
-                border: 1px solid #e2e8f0;
+            .main-content {
+                display: flex;
+                flex-direction: column;
+                gap: 1rem;
+                padding: 0.5rem;
             }
             .arc-diagram-container {
+                width: 100%;
+                overflow-x: auto;
+                background-color: white;
+                padding: 0.5rem;
+                border-radius: 0.375rem;
+                box-shadow: 0 1px 2px rgba(0,0,0,0.1);
+                margin-top: 0.5rem;
+            }
+            .edit-container {
+                position: sticky;
+                top: 0;
                 background-color: white;
-                padding: 1rem;
-                border-radius: 0.5rem;
-                box-shadow: 0 1px 3px rgba(0,0,0,0.1);
-                margin-top: 1rem;
+                z-index: 100;
+                padding: 0.5rem 0;
             }
             </style>
         """, unsafe_allow_html=True)
 
-        # Verificar si el estado existe y tiene todas las claves necesarias
+        # Inicialización del estado con valores por defecto
         if 'morphosyntax_state' not in st.session_state:
             st.session_state['morphosyntax_state'] = {}
         
-        # Asegurarse de que todas las claves existan con valores por defecto
         default_state = {
             'has_original': False,
             'original_text': '',
             'original_analysis': None,
             'current_text': '',
             'iterations': [],
-            'analysis_count': 0
+            'analysis_count': 0,
+            'current_tab': 0  # Para mantener el tab activo
         }
         
-        # Actualizar solo las claves faltantes
         for key, value in default_state.items():
             if key not in st.session_state.morphosyntax_state:
                 st.session_state.morphosyntax_state[key] = value
 
-        # Mostrar interfaz inicial o de iteración según el estado
-        if not st.session_state.morphosyntax_state['has_original']:
-            st.markdown("### Texto Original")
-            original_text = st.text_area(
-                "Ingrese su texto inicial",
-                key="original_text_input",
-                height=150
-            )
-            
-            col1, col2, col3 = st.columns([2,1,2])
-            with col1:
-                if st.button(
-                    "Establecer como Texto Original", 
-                    type="primary",
-                    use_container_width=True,
-                    disabled=not bool(original_text.strip())
-                ):
-                    try:
-                        # Procesar texto original
-                        doc = nlp_models[lang_code](original_text)
-                        analysis = perform_advanced_morphosyntactic_analysis(
-                            original_text,
-                            nlp_models[lang_code]
-                        )
-                        
-                        # Guardar estado original
-                        st.session_state.morphosyntax_state.update({
-                            'has_original': True,
-                            'original_text': original_text,
-                            'original_analysis': {
-                                'doc': doc,
-                                'advanced_analysis': analysis
-                            },
-                            'current_text': original_text
-                        })
-                        
-                        # Guardar en base de datos
-                        if store_student_morphosyntax_result(
-                            username=st.session_state.username,
-                            text=original_text,
-                            arc_diagrams=analysis['arc_diagrams']
-                        ):
-                            st.success("Texto original guardado exitosamente")
-                            st.rerun()
-                        else:
-                            st.error("Error al guardar el texto original")
-                    
-                    except Exception as e:
-                        logger.error(f"Error procesando texto original: {str(e)}")
-                        st.error("Error al procesar el texto original")
-
-        else:
-            # Mostrar versión original y área de iteración
-            st.markdown("### Versión Original")
-            
-            # Columnas para texto original y su análisis
-            col1, col2 = st.columns([1,1])
-            with col1:
-                st.markdown("#### Texto Original")
-                st.markdown(f"<div class='original-content'>{st.session_state.morphosyntax_state['original_text']}</div>", 
-                          unsafe_allow_html=True)
-            
-            with col2:
-                st.markdown("#### Análisis Original")
-                display_morphosyntax_results(
-                    st.session_state.morphosyntax_state['original_analysis'],
-                    lang_code,
-                    morpho_t
+        with st.container():
+            # Área de edición del texto original
+            if not st.session_state.morphosyntax_state['has_original']:
+                st.markdown("### Texto Original")
+                original_text = st.text_area(
+                    "Ingrese una oración",
+                    key="original_text_input",
+                    placeholder="Ingresar solo una oración hasta el punto y aparte. Si es punto seguido, dejar así.",
+                    height=100
                 )
+                
+                col1, col2, col3 = st.columns([2,1,2])
+                with col1:
+                    if st.button(
+                        "Analizar Texto Original", 
+                        type="primary",
+                        use_container_width=True,
+                        disabled=not bool(original_text.strip())
+                    ):
+                        try:
+                            # Procesar texto original
+                            doc = nlp_models[lang_code](original_text)
+                            analysis = perform_advanced_morphosyntactic_analysis(
+                                original_text,
+                                nlp_models[lang_code]
+                            )
+                            
+                            # Actualizar estado
+                            st.session_state.morphosyntax_state.update({
+                                'has_original': True,
+                                'original_text': original_text,
+                                'original_analysis': {
+                                    'doc': doc,
+                                    'advanced_analysis': analysis
+                                },
+                                'current_text': original_text
+                            })
+                            
+                            if store_student_morphosyntax_result(
+                                username=st.session_state.username,
+                                text=original_text,
+                                arc_diagrams=analysis['arc_diagrams']
+                            ):
+                                st.success("Texto analizado exitosamente")
+                                st.rerun()
+                            else:
+                                st.error("Error al guardar el análisis")
+                        except Exception as e:
+                            logger.error(f"Error procesando texto original: {str(e)}")
+                            st.error("Error al procesar el texto")
+            else:
+                # Layout horizontal para edición y visualización
+                st.markdown("### Versión Original")
+                
+                # Permitir editar texto original
+                edit_original = st.button("Editar texto original")
+                if edit_original:
+                    st.session_state.morphosyntax_state['has_original'] = False
+                    st.rerun()
+                
+                col1, col2 = st.columns([1, 1])
+                with col1:
+                    st.text_area(
+                        "Texto Original",
+                        value=st.session_state.morphosyntax_state['original_text'],
+                        disabled=True,
+                        height=100
+                    )
+                
+                with col2:
+                    display_morphosyntax_results(
+                        st.session_state.morphosyntax_state['original_analysis'],
+                        lang_code,
+                        morpho_t
+                    )
 
-            # Área de iteración
-            st.markdown("---")
-            st.markdown("### Iteración Actual")
-            
-            # Campo para nueva versión
-            iteration_text = st.text_area(
-                "Modifique su texto",
-                value=st.session_state.morphosyntax_state['current_text'],
-                key=f"iteration_input_{st.session_state.morphosyntax_state['analysis_count']}",
-                height=150
-            )
-
-            # Botón de análisis
-            col1, col2, col3 = st.columns([2,1,2])
-            with col1:
-                analyze_button = st.button(
-                    "Analizar Cambios",
-                    type="primary",
-                    icon="🔍",
-                    key=f"analyze_{st.session_state.morphosyntax_state['analysis_count']}",
-                    disabled=not bool(iteration_text.strip()),
-                    use_container_width=True
-                )
+                st.markdown("---")
+                st.markdown("### Iteración Actual")
+                
+                # Campo para nueva versión con layout horizontal
+                col1, col2 = st.columns([1, 1])
+                with col1:
+                    iteration_text = st.text_area(
+                        "Modifique la oración",
+                        value=st.session_state.morphosyntax_state['current_text'],
+                        key=f"iteration_input_{st.session_state.morphosyntax_state['analysis_count']}",
+                        placeholder="Ingresar solo una oración hasta el punto y aparte. Si es punto seguido, dejar así.",
+                        height=100
+                    )
 
-            # Procesar iteración
-            if analyze_button and iteration_text.strip():
-                try:
-                    with st.spinner("Procesando cambios..."):
-                        doc = nlp_models[lang_code](iteration_text)
-                        analysis = perform_advanced_morphosyntactic_analysis(
-                            iteration_text,
-                            nlp_models[lang_code]
-                        )
-                        
-                        current_analysis = {
-                            'doc': doc,
-                            'advanced_analysis': analysis
-                        }
-                        
-                        # Guardar iteración
-                        st.session_state.morphosyntax_state['iterations'].append({
-                            'text': iteration_text,
-                            'analysis': current_analysis,
-                            'timestamp': pd.Timestamp.now()
-                        })
-                        
-                        st.session_state.morphosyntax_state['current_text'] = iteration_text
-                        st.session_state.morphosyntax_state['analysis_count'] += 1
-                        
-                        # Guardar en base de datos
-                        if store_student_morphosyntax_result(
-                            username=st.session_state.username,
-                            text=iteration_text,
-                            arc_diagrams=analysis['arc_diagrams']
-                        ):
-                            st.success("Análisis guardado exitosamente")
-                            
-                            # Mostrar análisis actual
-                            st.markdown("#### Análisis Actual")
-                            display_morphosyntax_results(
-                                current_analysis,
-                                lang_code,
-                                morpho_t
-                            )
-                        else:
-                            st.error("Error al guardar el análisis")
+                    analyze_button = st.button(
+                        "Analizar Cambios",
+                        type="primary",
+                        icon="🔍",
+                        key=f"analyze_{st.session_state.morphosyntax_state['analysis_count']}",
+                        disabled=not bool(iteration_text.strip()),
+                        use_container_width=True
+                    )
                 
-                except Exception as e:
-                    logger.error(f"Error procesando iteración: {str(e)}")
-                    st.error("Error al procesar los cambios")
+                with col2:
+                    if analyze_button and iteration_text.strip():
+                        try:
+                            with st.spinner("Procesando..."):
+                                doc = nlp_models[lang_code](iteration_text)
+                                analysis = perform_advanced_morphosyntactic_analysis(
+                                    iteration_text,
+                                    nlp_models[lang_code]
+                                )
+                                
+                                current_analysis = {
+                                    'doc': doc,
+                                    'advanced_analysis': analysis
+                                }
+                                
+                                # Guardar iteración
+                                st.session_state.morphosyntax_state['iterations'].append({
+                                    'text': iteration_text,
+                                    'analysis': current_analysis,
+                                    'timestamp': pd.Timestamp.now()
+                                })
+                                
+                                st.session_state.morphosyntax_state['current_text'] = iteration_text
+                                st.session_state.morphosyntax_state['analysis_count'] += 1
+                                
+                                if store_student_morphosyntax_result(
+                                    username=st.session_state.username,
+                                    text=iteration_text,
+                                    arc_diagrams=analysis['arc_diagrams']
+                                ):
+                                    display_morphosyntax_results(
+                                        current_analysis,
+                                        lang_code,
+                                        morpho_t
+                                    )
+                                else:
+                                    st.error("Error al guardar el análisis")
+                        except Exception as e:
+                            logger.error(f"Error procesando iteración: {str(e)}")
+                            st.error("Error al procesar los cambios")
 
-            # Mostrar historial
-            if st.session_state.morphosyntax_state['iterations']:
-                with st.expander("Ver Historial de Iteraciones"):
-                    for idx, iteration in enumerate(reversed(st.session_state.morphosyntax_state['iterations']), 1):
-                        st.markdown(f"**Iteración {idx} - {iteration['timestamp'].strftime('%H:%M:%S')}**")
-                        st.markdown(f"```\n{iteration['text']}\n```")
-                        display_morphosyntax_results(
-                            iteration['analysis'],
-                            lang_code,
-                            morpho_t
-                        )
-                        st.markdown("---")
+                # Historial de iteraciones
+                if st.session_state.morphosyntax_state['iterations']:
+                    with st.expander("Historial de Iteraciones", expanded=False):
+                        for idx, iteration in enumerate(reversed(st.session_state.morphosyntax_state['iterations'])):
+                            col1, col2 = st.columns([1, 1])
+                            with col1:
+                                st.markdown(f"**Iteración {idx + 1} ({iteration['timestamp'].strftime('%H:%M:%S')})**")
+                                st.text_area(
+                                    f"Texto {idx + 1}",
+                                    value=iteration['text'],
+                                    disabled=True,
+                                    height=100,
+                                    key=f"hist_text_{idx}"
+                                )
+                            with col2:
+                                display_morphosyntax_results(
+                                    iteration['analysis'],
+                                    lang_code,
+                                    morpho_t
+                                )
+                            st.markdown("---")
 
     except Exception as e:
         logger.error(f"Error general en display_morphosyntax_interface: {str(e)}")
         st.error("Se produjo un error. Por favor, intente de nuevo.")
 
-
-
-
 #########################################################################3
 def display_morphosyntax_results(result, lang_code, morpho_t):
     """