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

modules/__init__.py

@@ -192,6 +192,12 @@ def load_student_activities_v2_functions():
 
 def load_morphosyntax_functions():
     from .morphosyntax.morphosyntax_interface import (
+        cache_analysis_results,
+        get_cached_analysis,
+        arc_analysis_state,
+        reset_morpho_state,
+        display_original_analysis,
+        display_iteration_analysis,
         display_morphosyntax_interface,
         display_morphosyntax_results
     )
@@ -202,6 +208,12 @@ def load_morphosyntax_functions():
     )
     
     return {
+        'cache_analysis_results': cache_analysis_results,
+        'get_cached_analysis': get_cached_analysis,
+        'arc_analysis_state': arc_analysis_state,
+        'reset_morpho_state': reset_morpho_state,
+        'display_original_analysis': display_original_analysis,
+        'display_iteration_analysis': display_iteration_analysis,
         'display_morphosyntax_interface': display_morphosyntax_interface,
         'display_morphosyntax_results': display_morphosyntax_results,
         'process_morphosyntactic_input': process_morphosyntactic_input,

modules/morphosyntax/morphosyntax_interface.py

@@ -1,5 +1,6 @@
 #modules/morphosyntax/morphosyntax_interface.py
 
+#Importaciones generales
 import streamlit as st
 from streamlit_float import *
 from streamlit_antd_components import *
@@ -11,6 +12,7 @@ import pandas as pd
 import base64
 import re
 
+#Importaciones locales
 from .morphosyntax_process import (
     process_morphosyntactic_input,
     format_analysis_results,
@@ -29,20 +31,68 @@ import logging
 logger = logging.getLogger(__name__)
 
 ###########################################################################
+def initialize_arc_analysis_state():
+    """Inicializa el estado del análisis de arcos y el caché si no existen"""
+    # Inicializar estado de 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
+        }
+        logger.info("Estado de análisis de arcos inicializado")
 
-import streamlit as st
-from streamlit_float import *
-from streamlit_antd_components import *
-from streamlit.components.v1 import html
-import spacy
-from spacy import displacy
-import spacy_streamlit
-import pandas as pd
-import base64
-import re
+    # Inicializar caché de análisis
+    if 'analysis_cache' not in st.session_state:
+        st.session_state.analysis_cache = {}
+        logger.info("Caché de análisis inicializado")
+
+###########################################################################
+
+def reset_morpho_state():
+    """Resetea el estado del análisis morfosintáctico"""
+    if 'arc_analysis_state' in st.session_state:
+        st.session_state.arc_analysis_state = {
+            'original_text': '',
+            'original_analysis': None,
+            'iteration_text': '',
+            'iteration_analysis': None,
+            'analysis_count': 0
+        }
+############################################################################
+
+def display_original_analysis(container, analysis, lang_code, morpho_t):
+    """Muestra el análisis original en el contenedor especificado"""
+    with container:
+        st.subheader("Análisis Original")
+        display_morphosyntax_results(analysis, lang_code, morpho_t)
+
+def display_iteration_analysis(container, analysis, lang_code, morpho_t):
+    """Muestra el análisis de cambios en el contenedor especificado"""
+    with container:
+        st.subheader("Análisis de Cambios")
+        display_morphosyntax_results(analysis, lang_code, morpho_t)
 
 ############################################################################
 
+def cache_analysis_results(key, result):
+    """Almacena resultados de análisis en caché"""
+    if not hasattr(st.session_state, 'analysis_cache'):
+        initialize_arc_analysis_state()
+    st.session_state.analysis_cache[key] = result
+    logger.info(f"Resultado almacenado en caché con clave: {key}")
+
+def get_cached_analysis(key):
+    """Recupera resultados de análisis del caché"""
+    if not hasattr(st.session_state, 'analysis_cache'):
+        initialize_arc_analysis_state()
+        return None
+    return st.session_state.analysis_cache.get(key)
+
+
+############################################################################
 def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
     try:
         # CSS para layout estable
@@ -62,9 +112,10 @@ def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
             </style>
         """, unsafe_allow_html=True)
 
-        # Estado para subtabs
-        if 'morpho_subtab' not in st.session_state:
-            st.session_state.morpho_subtab = 0
+        # Inicializar estado y mantener tab activo
+        st.session_state.tab_states['morpho_active'] = True
+        st.session_state.selected_tab = 1
+        initialize_arc_analysis_state()
 
         # Crear subtabs
         subtabs = st.tabs([
@@ -75,19 +126,21 @@ def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
 
         # 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:
+            # Botón de reset
+            col1, col2, col3 = st.columns([2,1,2])
+            with col1:
+                if st.button("Nuevo Análisis", type="secondary", use_container_width=True):
+                    reset_morpho_state()
+                    st.rerun()
+
+            # Contenedores separados para cada tipo de análisis
+            original_input_container = st.container()
+            original_diagram_container = st.container()
+            iteration_input_container = st.container()
+            iteration_diagram_container = st.container()
+
+            # Sección de análisis original
+            with original_input_container:
                 text_key = f"original_text_{st.session_state.arc_analysis_state['analysis_count']}"
                 text_input = st.text_area(
                     "",
@@ -101,13 +154,10 @@ def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
                     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']}"
+                        key=f"analyze_original_{st.session_state.arc_analysis_state['analysis_count']}",
+                        use_container_width=True
                     )
 
-            # Contenedor para diagramas
-            diagrams_container = st.container()
-            
             # Procesar texto original
             if analyze_button and text_input.strip():
                 try:
@@ -129,82 +179,98 @@ def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
                         text=text_input,
                         arc_diagrams=analysis['arc_diagrams']
                     ):
-                        with diagrams_container:
-                            st.subheader("Análisis Original")
-                            display_morphosyntax_results(
-                                st.session_state.arc_analysis_state['original_analysis'],
-                                lang_code,
-                                morpho_t
-                            )
+                        display_original_analysis(
+                            original_diagram_container,
+                            st.session_state.arc_analysis_state['original_analysis'],
+                            lang_code,
+                            morpho_t
+                        )
+
                 except Exception as e:
                     st.error("Error al procesar texto original")
-                    logger.error(f"Error: {str(e)}")
+                    logger.error(f"Error al procesar texto original: {str(e)}")
 
-            # Contenedor para iteración
+            # Sección de iteración
             if st.session_state.arc_analysis_state.get('original_analysis'):
-                iteration_container = st.container()
-                with iteration_container:
+                with iteration_input_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(
+                    
+                    # Formulario de iteración
+                    with st.form(key="iteration_form"):
+                        iteration_text = st.text_area(
+                            "",
+                            value=st.session_state.arc_analysis_state.get('iteration_text', ''),
+                            key=f"iteration_{st.session_state.arc_analysis_state['analysis_count']}",
+                            height=100
+                        )
+                        
+                        # Botón de análisis dentro del formulario
+                        submitted = st.form_submit_button(
                             "Analizar Cambios",
-                            type="primary", 
-                            use_container_width=True,
-                            key=f"iterate_{st.session_state.arc_analysis_state['analysis_count']}"
+                            type="primary",
+                            use_container_width=True
                         )
-
-                    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
+                        
+                        # Cuando se envía el formulario
+                        if submitted and iteration_text.strip():
+                            try:
+                                # Verificar si ya existe en caché
+                                cache_key = f"iter_{iteration_text}"
+                                cached_result = get_cached_analysis(cache_key)
+                                
+                                if cached_result:
+                                    logger.info("Usando resultado cacheado")
+                                    doc_iter = cached_result['doc']
+                                    analysis_iter = cached_result['analysis']
+                                else:
+                                    logger.info("Generando nuevo análisis")
+                                    doc_iter = nlp_models[lang_code](iteration_text)
+                                    analysis_iter = perform_advanced_morphosyntactic_analysis(
+                                        iteration_text,
+                                        nlp_models[lang_code]
                                     )
+                                    # Guardar en caché
+                                    cache_analysis_results(cache_key, {
+                                        'doc': doc_iter,
+                                        'analysis': analysis_iter
+                                    })
+
+                                # Actualizar estado
+                                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']
+                                ):
+                                    # Mostrar análisis en columnas
+                                    col1, col2 = st.columns(2)
                                     
-                                    st.markdown("---")
+                                    # Mostrar ambos análisis
+                                    with col1:
+                                        display_original_analysis(
+                                            original_diagram_container,
+                                            st.session_state.arc_analysis_state['original_analysis'],
+                                            lang_code,
+                                            morpho_t
+                                        )
                                     
-                                    # Mostrar iteración
-                                    st.subheader("Análisis de Cambios")
-                                    display_morphosyntax_results(
-                                        {'doc': doc_iter, 'analysis': analysis_iter},
-                                        lang_code,
-                                        morpho_t
-                                    )
+                                    with col2:
+                                        display_iteration_analysis(
+                                            iteration_diagram_container,
+                                            {'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)}")
+                            except Exception as e:
+                                st.error("Error al procesar iteración")
+                                logger.error(f"Error al procesar iteración: {str(e)}")
 
-        # Otros subtabs aquí...
+        # Otros subtabs...
         with subtabs[1]:
             st.info("Análisis de Categorías en desarrollo...")
             
@@ -213,7 +279,7 @@ def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
 
     except Exception as e:
         st.error("Error general en la interfaz")
-        logger.error(f"Error: {str(e)}")
+        logger.error(f"Error general en la interfaz: {str(e)}")
 
 ############################################################################