Update modules/morphosyntax/morphosyntax_interface.py

modules/morphosyntax/morphosyntax_interface.py

@@ -42,216 +42,184 @@ import base64
 import re
 
 ############################################################################
+
 def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
     try:
-        # CSS mejorado para estabilidad, layout y prevención de saltos
+        # CSS para layout estable
         st.markdown("""
             <style>
             .stTextArea textarea {
                 font-size: 1rem;
                 line-height: 1.5;
-                padding: 0.5rem;
-                border-radius: 0.375rem;
-                border: 1px solid #e2e8f0;
-                background-color: white;
                 min-height: 100px !important;
                 height: 100px !important;
             }
             .arc-diagram-container {
                 width: 100%;
-                overflow-x: auto;
-                background-color: white;
                 padding: 0.5rem;
-                border-radius: 0.375rem;
-                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
                 margin: 0.5rem 0;
             }
-            .stTab {
-                position: sticky;
-                top: 0;
-                z-index: 999;
-            }
-            [data-testid="stVerticalBlock"] {
-                gap: 0 !important;
-            }
             </style>
         """, unsafe_allow_html=True)
 
-        # Inicialización del estado
-        if 'current_tab' not in st.session_state:
-            st.session_state.current_tab = "morphosyntax"
-
-        if 'morphosyntax_state' not in st.session_state:
-            st.session_state.morphosyntax_state = {}
-        
-        default_state = {
-            'original_text': '',
-            'original_analysis': None,
-            'current_text': '',
-            'current_analysis': None,
-            'analysis_count': 0,
-            'show_original': False,
-            'show_iteration': False
-        }
-        
-        for key, default_value in default_state.items():
-            if key not in st.session_state.morphosyntax_state:
-                st.session_state.morphosyntax_state[key] = default_value
-
-        def update_analysis():
-            st.session_state.current_tab = "morphosyntax"  # Mantener tab activo
+        # Estado consistente con keys únicas
+        if 'morpho_state' not in st.session_state:
+            st.session_state.morpho_state = {
+                'original_text': '',
+                'original_analysis': None,
+                'iteration_text': '',
+                'iteration_analysis': None,
+                'analysis_count': 0
+            }
 
-        # Sección del texto original - Layout simplificado
-        st.text_area(
-            "",  # Label vacío
-            value=st.session_state.morphosyntax_state['original_text'],
-            key="original_text_input",
-            placeholder="Ingresar solo una oración hasta el punto y aparte.",
-            height=100,
-            on_change=update_analysis
+        # Texto original - Key única basada en timestamp
+        text_key = f"original_text_{st.session_state.morpho_state['analysis_count']}"
+        text_input = st.text_area(
+            "",
+            value=st.session_state.morpho_state['original_text'],
+            key=text_key,
+            height=100
         )
 
+        # Botón analizar original
         col1, col2, col3 = st.columns([2,1,2])
         with col1:
-            analyze_original = st.button(
+            analyze_button = st.button(
                 "Analizar Texto Original",
                 type="primary",
-                use_container_width=True,
-                disabled=not bool(st.session_state.get("original_text_input", "").strip())
+                use_container_width=True
             )
 
-        # Procesar y mostrar texto original
-        if analyze_original and st.session_state.get("original_text_input", "").strip():
+        # Procesar texto original
+        if analyze_button and text_input.strip():
             try:
-                with st.spinner(""):  # Spinner sin texto
-                    doc = nlp_models[lang_code](st.session_state.original_text_input)
-                    analysis = perform_advanced_morphosyntactic_analysis(
-                        st.session_state.original_text_input,
-                        nlp_models[lang_code]
+                doc = nlp_models[lang_code](text_input)
+                analysis = perform_advanced_morphosyntactic_analysis(
+                    text_input,
+                    nlp_models[lang_code]
+                )
+                
+                # Actualizar estado
+                st.session_state.morpho_state.update({
+                    'original_text': text_input,
+                    'original_analysis': {'doc': doc, 'analysis': analysis},
+                    'iteration_text': text_input,
+                    'analysis_count': st.session_state.morpho_state['analysis_count'] + 1
+                })
+
+                # Guardar en base de datos
+                if store_student_morphosyntax_result(
+                    username=st.session_state.username,
+                    text=text_input,
+                    arc_diagrams=analysis['arc_diagrams']
+                ):
+                    # Mostrar diagrama original
+                    display_arc_diagram(doc, morpho_t)
+
+                    st.markdown("---")
+
+                    # Campo para iteración
+                    iteration_key = f"iteration_{st.session_state.morpho_state['analysis_count']}"
+                    iteration_text = st.text_area(
+                        "",
+                        value=st.session_state.morpho_state['iteration_text'],
+                        key=iteration_key,
+                        height=100
                     )
-                    
-                    st.session_state.morphosyntax_state.update({
-                        'original_text': st.session_state.original_text_input,
-                        'original_analysis': {'doc': doc, 'analysis': analysis},
-                        'current_text': st.session_state.original_text_input,
-                        'show_original': True,
-                        'analysis_count': st.session_state.morphosyntax_state['analysis_count'] + 1
-                    })
 
-                    if store_student_morphosyntax_result(
-                        username=st.session_state.username,
-                        text=st.session_state.original_text_input,
-                        arc_diagrams=analysis['arc_diagrams']
-                    ):
-                        st.session_state.current_tab = "morphosyntax"
+                    # Botón analizar iteración  
+                    col1, col2, col3 = st.columns([2,1,2])
+                    with col1:
+                        iterate_button = st.button(
+                            "Analizar Cambios",
+                            type="primary", 
+                            use_container_width=True
+                        )
 
-            except Exception as e:
-                logger.error(f"Error en análisis original: {str(e)}")
-                st.error("Error al procesar el texto")
+                    # Procesar iteración
+                    if iterate_button and iteration_text.strip():
+                        try:
+                            doc = nlp_models[lang_code](iteration_text)
+                            analysis = perform_advanced_morphosyntactic_analysis(
+                                iteration_text,
+                                nlp_models[lang_code]
+                            )
 
-        # Mostrar diagrama original si existe
-        if st.session_state.morphosyntax_state.get('show_original'):
-            display_morphosyntax_results(
-                st.session_state.morphosyntax_state['original_analysis'],
-                lang_code,
-                morpho_t
-            )
+                            # Actualizar estado
+                            st.session_state.morpho_state.update({
+                                'iteration_text': iteration_text,
+                                'iteration_analysis': {'doc': doc, 'analysis': analysis}
+                            })
 
-            st.markdown("---")
-            
-            # Sección de iteración - Layout simplificado
-            iteration_text = st.text_area(
-                "",  # Label vacío
-                value=st.session_state.morphosyntax_state['current_text'],
-                key=f"iteration_input_{st.session_state.morphosyntax_state['analysis_count']}",
-                placeholder="Modifique el texto para mejorar la estructura",
-                height=100,
-                on_change=update_analysis
-            )
+                            # Guardar y mostrar
+                            if store_student_morphosyntax_result(
+                                username=st.session_state.username,
+                                text=iteration_text,
+                                arc_diagrams=analysis['arc_diagrams']
+                            ):
+                                display_arc_diagram(doc, morpho_t)
 
-            col1, col2, col3 = st.columns([2,1,2])
-            with col1:
-                analyze_iteration = st.button(
-                    "Analizar Cambios",
-                    type="primary",
-                    use_container_width=True,
-                    disabled=not bool(iteration_text.strip())
-                )
+                        except Exception as e:
+                            st.error("Error al procesar iteración")
+                            logger.error(f"Error: {str(e)}")
 
-            # Procesar y mostrar iteración
-            if analyze_iteration and iteration_text.strip():
-                try:
-                    with st.spinner(""):  # Spinner sin texto
-                        doc = nlp_models[lang_code](iteration_text)
-                        analysis = perform_advanced_morphosyntactic_analysis(
-                            iteration_text,
-                            nlp_models[lang_code]
-                        )
-                        
-                        st.session_state.morphosyntax_state.update({
-                            'current_text': iteration_text,
-                            'current_analysis': {'doc': doc, 'analysis': analysis},
-                            'show_iteration': True,
-                            'analysis_count': 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']
-                        ):
-                            # Actualizar solo el diagrama de iteración
-                            display_morphosyntax_results(
-                                st.session_state.morphosyntax_state['current_analysis'],
-                                lang_code,
-                                morpho_t
-                            )
-
-                except Exception as e:
-                    logger.error(f"Error en iteración: {str(e)}")
-                    st.error("Error al procesar los cambios")
+            except Exception as e:
+                st.error("Error al procesar texto original")
+                logger.error(f"Error: {str(e)}")
 
     except Exception as e:
-        logger.error(f"Error general: {str(e)}")
-        st.error("Se produjo un error. Por favor, intente de nuevo.")
-   
-
-
+        st.error("Error general en la interfaz")
+        logger.error(f"Error: {str(e)}")
 
 #########################################################################3
+
 def display_morphosyntax_results(result, lang_code, morpho_t):
     """
     Muestra solo el análisis sintáctico con diagramas de arco.
+    Args:
+        result: Resultado del análisis que contiene el documento procesado
+        lang_code: Código del idioma actual
+        morpho_t: Diccionario de traducciones
     """
     if result is None:
-        st.warning(morpho_t.get('no_results', 'No results available'))
+        logger.warning("No hay resultados para mostrar")
         return
 
-    doc = result['doc']
-
-    # Análisis sintáctico (diagramas de arco)
-    # st.markdown(f"### {morpho_t.get('arc_diagram', 'Syntactic analysis: Arc diagram')}")
-    
-    with st.container():
-        sentences = list(doc.sents)
-        for i, sent in enumerate(sentences):
-            with st.container():
-                st.subheader(f"{morpho_t.get('sentence', 'Sentence')} {i+1}")
+    try:
+        doc = result['doc']
+        
+        with st.container():
+            sentences = list(doc.sents)
+            for i, sent in enumerate(sentences):
                 try:
+                    st.subheader(f"{morpho_t.get('sentence', 'Sentence')} {i+1}")
+                    
+                    # Renderizar con opciones optimizadas
                     html = displacy.render(sent, style="dep", options={
                         "distance": 100,
                         "arrow_spacing": 20,
                         "word_spacing": 30
                     })
+                    
                     # Ajustar dimensiones del SVG
                     html = html.replace('height="375"', 'height="200"')
-                    html = re.sub(r'<svg[^>]*>', lambda m: m.group(0).replace('height="450"', 'height="300"'), html)
+                    html = re.sub(r'<svg[^>]*>', 
+                                lambda m: m.group(0).replace('height="450"', 'height="300"'), 
+                                html)
                     html = re.sub(r'<g [^>]*transform="translate\((\d+),(\d+)\)"', 
-                                lambda m: f'<g transform="translate({m.group(1)},50)"', html)
+                                lambda m: f'<g transform="translate({m.group(1)},50)"', 
+                                html)
                     
-                    # Envolver en un div con clase para estilos
+                    # Envolver en contenedor con clase CSS
                     html = f'<div class="arc-diagram-container">{html}</div>'
+                    
+                    # Mostrar diagrama
                     st.write(html, unsafe_allow_html=True)
+                    
                 except Exception as e:
-                    logger.error(f"Error rendering sentence {i}: {str(e)}")
-                    st.error(f"Error displaying diagram for sentence {i+1}")
+                    logger.error(f"Error al renderizar oración {i}: {str(e)}")
+                    continue  # Continuar con la siguiente oración si hay error
+                    
+    except Exception as e:
+        logger.error(f"Error general en display_morphosyntax_results: {str(e)}")
+