Merge branch #AIdeaText/v3' into 'AIdeaText/v4'

modules/morphosyntax/morphosyntax_interface.py

@@ -45,264 +45,209 @@ import re
 
 def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
     try:
-        # CSS mejorado para estabilidad y layout vertical
+        # 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;
             }
-            .block-container {
-                padding-top: 0.5rem !important;
-                padding-bottom: 0.5rem !important;
-                margin: 0 !important;
-            }
-            .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;
+                margin: 0.5rem 0;
             }
             </style>
         """, unsafe_allow_html=True)
 
-        # Inicialización más robusta del estado
-        if 'morphosyntax_state' not in st.session_state:
-            st.session_state.morphosyntax_state = {
-                'original_text': '',
-                'current_text': '',
-                'original_analysis': None,
-                'analysis_count': 0,
-                'iterations': []  # Inicialización explícita de iterations como lista vacía
-            }
-        else:
-            # Asegurar que todas las claves existan
-            required_keys = {
-                'original_text': '',
-                'current_text': '',
-                'original_analysis': None,
-                'analysis_count': 0,
-                'iterations': []
-            }
-            for key, default_value in required_keys.items():
-                if key not in st.session_state.morphosyntax_state:
-                    st.session_state.morphosyntax_state[key] = default_value
-
-        with st.container():
-            # Sección de texto original
-            st.markdown("### Texto Original")
-            
-            # Input para texto original
-            original_text = st.text_area(
-                "Ingrese una oración", 
-                value=st.session_state.morphosyntax_state['original_text'],
-                key="original_text_input",
-                placeholder="Ingresar solo una oración hasta el punto y aparte. Si es punto seguido, dejar así.",
-                height=100,
-                disabled=False
-            )
-
-            # Botón para analizar texto original
-            col1, col2, col3 = st.columns([2,1,2])
-            with col1:
-                analyze_original = st.button(
-                    "Analizar Texto Original",
-                    type="primary",
-                    use_container_width=True,
-                    disabled=not bool(original_text.strip())
+        # Estado para subtabs
+        if 'morpho_subtab' not in st.session_state:
+            st.session_state.morpho_subtab = 0
+
+        # Crear subtabs
+        subtabs = st.tabs([
+            "Análisis de Diagramas de Arco",
+            "Análisis de Categorías",
+            "Análisis Morfológico"
+        ])
+
+        # Tab de Diagramas de Arco
+        with subtabs[0]:
+            # Estado para análisis
+            if 'arc_analysis_state' not in st.session_state:
+                st.session_state.arc_analysis_state = {
+                    'original_text': '',
+                    'original_analysis': None,
+                    'iteration_text': '',
+                    'iteration_analysis': None,
+                    'analysis_count': 0
+                }
+
+            # Contenedor para texto original
+            original_container = st.container()
+            with original_container:
+                text_key = f"original_text_{st.session_state.arc_analysis_state['analysis_count']}"
+                text_input = st.text_area(
+                    "",
+                    value=st.session_state.arc_analysis_state['original_text'],
+                    key=text_key,
+                    height=100
                 )
 
+                col1, col2, col3 = st.columns([2,1,2])
+                with col1:
+                    analyze_button = st.button(
+                        "Analizar Texto Original",
+                        type="primary",
+                        use_container_width=True,
+                        key=f"analyze_original_{st.session_state.arc_analysis_state['analysis_count']}"
+                    )
+
+            # Contenedor para diagramas
+            diagrams_container = st.container()
+            
             # Procesar texto original
-            if analyze_original and original_text.strip():
+            if analyze_button and text_input.strip():
                 try:
-                    with st.spinner("Procesando texto original..."):
-                        doc = nlp_models[lang_code](original_text)
-                        analysis = perform_advanced_morphosyntactic_analysis(
-                            original_text,
-                            nlp_models[lang_code]
-                        )
-                        
-                        # Actualizar estado de forma segura
-                        st.session_state.morphosyntax_state.update({
-                            'original_text': original_text,
-                            'current_text': original_text,
-                            'original_analysis': {
-                                'doc': doc,
-                                'advanced_analysis': analysis
-                            },
-                            'iterations': []  # Reiniciar iteraciones al cambiar texto original
-                        })
-                        
-                        # 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 analizado exitosamente")
-                        else:
-                            st.error("Error al guardar el análisis original")
-                except Exception as e:
-                    logger.error(f"Error procesando texto original: {str(e)}")
-                    st.error("Error al procesar el texto original")
-
-            # Mostrar diagrama original
-            if st.session_state.morphosyntax_state['original_analysis']:
-                display_morphosyntax_results(
-                    st.session_state.morphosyntax_state['original_analysis'],
-                    lang_code,
-                    morpho_t
-                )
-
-            # Sección de iteración
-            st.markdown("---")
-            st.markdown("### Iteración Actual")
-            
-            # Campo para nueva versión
-            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
-            )
-
-            # Botón para analizar iteración
-            col1, col2, col3 = st.columns([2,1,2])
-            with col1:
-                analyze_iteration = 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
-                )
+                    doc = nlp_models[lang_code](text_input)
+                    analysis = perform_advanced_morphosyntactic_analysis(
+                        text_input,
+                        nlp_models[lang_code]
+                    )
+                    
+                    st.session_state.arc_analysis_state.update({
+                        'original_text': text_input,
+                        'original_analysis': {'doc': doc, 'analysis': analysis},
+                        'iteration_text': text_input,
+                        'analysis_count': st.session_state.arc_analysis_state['analysis_count'] + 1
+                    })
 
-            # Procesar iteración
-            if analyze_iteration 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
-                        }
-                        
-                        # Crear nueva iteración
-                        new_iteration = {
-                            'text': iteration_text,
-                            'analysis': current_analysis,
-                            'timestamp': pd.Timestamp.now()
-                        }
-                        
-                        # Actualizar estado de forma segura
-                        iterations = st.session_state.morphosyntax_state.get('iterations', [])
-                        iterations.append(new_iteration)
-                        st.session_state.morphosyntax_state.update({
-                            'current_text': iteration_text,
-                            'analysis_count': st.session_state.morphosyntax_state['analysis_count'] + 1,
-                            'iterations': iterations
-                        })
-                        
-                        if store_student_morphosyntax_result(
-                            username=st.session_state.username,
-                            text=iteration_text,
-                            arc_diagrams=analysis['arc_diagrams']
-                        ):
-                            # Mostrar resultados de la iteración
+                    if store_student_morphosyntax_result(
+                        username=st.session_state.username,
+                        text=text_input,
+                        arc_diagrams=analysis['arc_diagrams']
+                    ):
+                        with diagrams_container:
+                            st.subheader("Análisis Original")
                             display_morphosyntax_results(
-                                current_analysis,
+                                st.session_state.arc_analysis_state['original_analysis'],
                                 lang_code,
                                 morpho_t
                             )
-                        else:
-                            st.error("Error al guardar la iteración")
                 except Exception as e:
-                    logger.error(f"Error procesando iteración: {str(e)}")
-                    st.error("Error al procesar los cambios")
-
-            # Mostrar historial de iteraciones
-            if st.session_state.morphosyntax_state.get('iterations', []):
-                with st.expander("Historial de Iteraciones", expanded=False):
-                    for idx, iteration in enumerate(reversed(st.session_state.morphosyntax_state['iterations'])):
-                        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}"
-                        )
-                        display_morphosyntax_results(
-                            iteration['analysis'],
-                            lang_code,
-                            morpho_t
+                    st.error("Error al procesar texto original")
+                    logger.error(f"Error: {str(e)}")
+
+            # Contenedor para iteración
+            if st.session_state.arc_analysis_state.get('original_analysis'):
+                iteration_container = st.container()
+                with iteration_container:
+                    st.markdown("---")
+                    iteration_key = f"iteration_{st.session_state.arc_analysis_state['analysis_count']}"
+                    iteration_text = st.text_area(
+                        "",
+                        value=st.session_state.arc_analysis_state['iteration_text'],
+                        key=iteration_key,
+                        height=100,
+                        on_change=lambda: None  # Prevenir recarga en cambio de foco
+                    )
+
+                    col1, col2, col3 = st.columns([2,1,2])
+                    with col1:
+                        iterate_button = st.button(
+                            "Analizar Cambios",
+                            type="primary", 
+                            use_container_width=True,
+                            key=f"iterate_{st.session_state.arc_analysis_state['analysis_count']}"
                         )
-                        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.")
 
+                    if iterate_button and iteration_text.strip():
+                        try:
+                            doc_iter = nlp_models[lang_code](iteration_text)
+                            analysis_iter = perform_advanced_morphosyntactic_analysis(
+                                iteration_text,
+                                nlp_models[lang_code]
+                            )
 
+                            st.session_state.arc_analysis_state.update({
+                                'iteration_text': iteration_text,
+                                'iteration_analysis': {'doc': doc_iter, 'analysis': analysis_iter}
+                            })
+
+                            if store_student_morphosyntax_result(
+                                username=st.session_state.username,
+                                text=iteration_text,
+                                arc_diagrams=analysis_iter['arc_diagrams']
+                            ):
+                                with diagrams_container:
+                                    # Mostrar original
+                                    st.subheader("Análisis Original")
+                                    display_morphosyntax_results(
+                                        st.session_state.arc_analysis_state['original_analysis'],
+                                        lang_code,
+                                        morpho_t
+                                    )
+                                    
+                                    st.markdown("---")
+                                    
+                                    # Mostrar iteración
+                                    st.subheader("Análisis de Cambios")
+                                    display_morphosyntax_results(
+                                        {'doc': doc_iter, 'analysis': analysis_iter},
+                                        lang_code,
+                                        morpho_t
+                                    )
+
+                        except Exception as e:
+                            st.error("Error al procesar iteración")
+                            logger.error(f"Error: {str(e)}")
+
+        # Otros subtabs aquí...
+        with subtabs[1]:
+            st.info("Análisis de Categorías en desarrollo...")
+            
+        with subtabs[2]:
+            st.info("Análisis Morfológico en desarrollo...")
 
+    except Exception as e:
+        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.
+    Muestra solo el diagrama de arco.
+    Args:
+        result: Diccionario con el documento procesado y su análisis
+        lang_code: Código del idioma
+        morpho_t: Diccionario de traducciones
     """
     if result is None:
-        st.warning(morpho_t.get('no_results', 'No results available'))
         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():
+        
+    try:
+        doc = result['doc']
         sentences = list(doc.sents)
         for i, sent in enumerate(sentences):
-            with st.container():
+            try:
                 st.subheader(f"{morpho_t.get('sentence', 'Sentence')} {i+1}")
-                try:
-                    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'<g [^>]*transform="translate\((\d+),(\d+)\)"', 
-                                lambda m: f'<g transform="translate({m.group(1)},50)"', html)
-                    
-                    # Envolver en un div con clase para estilos
-                    html = f'<div class="arc-diagram-container">{html}</div>'
-                    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}")
+                html = displacy.render(sent, style="dep", options={
+                    "distance": 100,
+                    "arrow_spacing": 20,
+                    "word_spacing": 30
+                })
+                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'<g [^>]*transform="translate\((\d+),(\d+)\)"', 
+                            lambda m: f'<g transform="translate({m.group(1)},50)"', html)
+                html = f'<div class="arc-diagram-container">{html}</div>'
+                st.write(html, unsafe_allow_html=True)
+            except Exception as e:
+                logger.error(f"Error en diagrama {i}: {str(e)}")
+                continue
+    except Exception as e:
+        logger.error(f"Error en display_morphosyntax_results: {str(e)}")
+