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

app.py

@@ -57,8 +57,9 @@ from modules.utils.widget_utils import generate_unique_key
 
 # Importaciones de interfaces
 from modules.morphosyntax.morphosyntax_interface import (
-    display_morphosyntax_interface, 
-    display_morphosyntax_results
+    display_morphosyntax_interface,
+    display_arc_diagram
+    #display_morphosyntax_results
 )
 
 from modules.semantic.semantic_interface import (

modules/__init__.py

@@ -134,10 +134,27 @@ def load_database_functions():
         get_student_situation_history,
         update_exercise_status
     )
+
+    # Importar nuevas funciones de análisis morfosintáctico iterativo
+    from .morphosyntax_iterative_mongo_db import (
+        store_student_morphosyntax_base,
+        store_student_morphosyntax_iteration,
+        get_student_morphosyntax_analysis,
+        update_student_morphosyntax_analysis, 
+        delete_student_morphosyntax_analysis,
+        get_student_morphosyntax_data
+    )
     
     from .database.chat_mongo_db import store_chat_history, get_chat_history
 
     return {
+        # Nuevas funciones morfosintácticas iterativas
+        'store_student_morphosyntax_base': store_student_morphosyntax_base,
+        'store_student_morphosyntax_iteration': store_student_morphosyntax_iteration,
+        'get_student_morphosyntax_iterative_analysis': get_student_morphosyntax_analysis,  # Renombrada para evitar conflicto
+        'update_student_morphosyntax_iterative': update_student_morphosyntax_analysis,     # Renombrada para evitar conflicto
+        'delete_student_morphosyntax_iterative': delete_student_morphosyntax_analysis,     # Renombrada para evitar conflicto
+        'get_student_morphosyntax_iterative_data': get_student_morphosyntax_data,  
         'store_current_situation_result': store_current_situation_result,
         'verify_storage': verify_storage,
         'get_recent_sessions': get_recent_sessions,
@@ -192,13 +209,9 @@ 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,
+        initialize_arc_analysis_state,
+        reset_arc_analysis_state,
+        display_arc_diagrams,
         display_morphosyntax_results
     )
     from .morphosyntax.morphosyntax_process import (
@@ -208,14 +221,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,
+        #Interface
+        'initialize_arc_analysis_state': initialize_arc_analysis_state,
+        'reset_arc_analysis_state': reset_morpho_state,
+        'display_arc_diagrams': display_arc_diagrams,
         'display_morphosyntax_interface': display_morphosyntax_interface,
-        'display_morphosyntax_results': display_morphosyntax_results,
+        #Process
         'process_morphosyntactic_input': process_morphosyntactic_input,
         'format_analysis_results': format_analysis_results,
         'perform_advanced_morphosyntactic_analysis': perform_advanced_morphosyntactic_analysis

modules/database/morphosyntax_iterative_mongo_db.py

@@ -0,0 +1,171 @@
+# modules/database/morphosyntax_iterative_mongo_db.py
+
+
+from datetime import datetime, timezone
+import logging
+from bson import ObjectId  # <--- Importar ObjectId
+from .mongo_db import get_collection, insert_document, find_documents, update_document, delete_document
+
+logger = logging.getLogger(__name__)
+
+BASE_COLLECTION = 'student_morphosyntax_analysis_base'
+ITERATION_COLLECTION = 'student_morphosyntax_iterations'
+
+def store_student_morphosyntax_base(username, text, arc_diagrams):
+    """Almacena el análisis morfosintáctico base y retorna su ObjectId."""
+    try:
+        base_document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text': text,
+            'arc_diagrams': arc_diagrams,
+            'analysis_type': 'morphosyntax_base',
+            'has_iterations': False
+        }
+        collection = get_collection(BASE_COLLECTION)
+        result = collection.insert_one(base_document)
+
+        logger.info(f"Análisis base guardado para {username}")
+        # Retornamos el ObjectId directamente (NO str)
+        return result.inserted_id
+
+    except Exception as e:
+        logger.error(f"Error almacenando análisis base: {str(e)}")
+        return None
+
+def store_student_morphosyntax_iteration(username, base_id, original_text, iteration_text, arc_diagrams):
+    """
+    Almacena una iteración de análisis morfosintáctico.
+    base_id: ObjectId de la base (o string convertible a ObjectId).
+    """
+    try:
+        # Convertir a ObjectId si viene como string
+        if isinstance(base_id, str):
+            base_id = ObjectId(base_id)
+
+        iteration_document = {
+            'username': username,
+            'base_id': base_id,  # Guardar el ObjectId en la iteración
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'original_text': original_text,
+            'iteration_text': iteration_text,
+            'arc_diagrams': arc_diagrams,
+            'analysis_type': 'morphosyntax_iteration'
+        }
+        collection = get_collection(ITERATION_COLLECTION)
+        result = collection.insert_one(iteration_document)
+
+        # Actualizar documento base (usando ObjectId)
+        base_collection = get_collection(BASE_COLLECTION)
+        base_collection.update_one(
+            {'_id': base_id, 'username': username},
+            {'$set': {'has_iterations': True}}
+        )
+
+        logger.info(f"Iteración guardada para {username}, base_id: {base_id}")
+        return result.inserted_id  # Retornar el ObjectId de la iteración
+
+    except Exception as e:
+        logger.error(f"Error almacenando iteración: {str(e)}")
+        return None
+
+def get_student_morphosyntax_analysis(username, limit=10):
+    """
+    Obtiene los análisis base y sus iteraciones.
+    Returns: Lista de análisis con sus iteraciones.
+    """
+    try:
+        base_collection = get_collection(BASE_COLLECTION)
+        base_query = {
+            "username": username,
+            "analysis_type": "morphosyntax_base"
+        }
+        base_analyses = list(
+            base_collection.find(base_query).sort("timestamp", -1).limit(limit)
+        )
+
+        # Para cada análisis base, obtener sus iteraciones
+        iteration_collection = get_collection(ITERATION_COLLECTION)
+        for analysis in base_analyses:
+            base_id = analysis['_id']
+            # Buscar iteraciones con base_id = ObjectId
+            iterations = list(
+                iteration_collection.find({"base_id": base_id}).sort("timestamp", -1)
+            )
+            analysis['iterations'] = iterations
+
+        return base_analyses
+
+    except Exception as e:
+        logger.error(f"Error obteniendo análisis: {str(e)}")
+        return []
+
+def update_student_morphosyntax_analysis(analysis_id, is_base, update_data):
+    """
+    Actualiza un análisis base o iteración.
+    analysis_id puede ser un ObjectId o string.
+    """
+    from bson import ObjectId
+
+    try:
+        collection_name = BASE_COLLECTION if is_base else ITERATION_COLLECTION
+        collection = get_collection(collection_name)
+
+        if isinstance(analysis_id, str):
+            analysis_id = ObjectId(analysis_id)
+
+        query = {"_id": analysis_id}
+        update = {"$set": update_data}
+
+        result = update_document(collection_name, query, update)
+        return result
+
+    except Exception as e:
+        logger.error(f"Error actualizando análisis: {str(e)}")
+        return False
+
+def delete_student_morphosyntax_analysis(analysis_id, is_base):
+    """
+    Elimina un análisis base o iteración.
+    Si es base, también elimina todas sus iteraciones.
+    """
+    from bson import ObjectId
+
+    try:
+        if isinstance(analysis_id, str):
+            analysis_id = ObjectId(analysis_id)
+
+        if is_base:
+            # Eliminar iteraciones vinculadas
+            iteration_collection = get_collection(ITERATION_COLLECTION)
+            iteration_collection.delete_many({"base_id": analysis_id})
+
+            # Luego eliminar el análisis base
+            collection = get_collection(BASE_COLLECTION)
+        else:
+            collection = get_collection(ITERATION_COLLECTION)
+
+        query = {"_id": analysis_id}
+        result = delete_document(collection.name, query)
+        return result
+
+    except Exception as e:
+        logger.error(f"Error eliminando análisis: {str(e)}")
+        return False
+
+def get_student_morphosyntax_data(username):
+    """
+    Obtiene todos los datos de análisis morfosintáctico de un estudiante.
+    Returns: Diccionario con todos los análisis y sus iteraciones.
+    """
+    try:
+        analyses = get_student_morphosyntax_analysis(username, limit=None)
+        return {
+            'entries': analyses,
+            'total_analyses': len(analyses),
+            'has_iterations': any(a.get('has_iterations', False) for a in analyses)
+        }
+
+    except Exception as e:
+        logger.error(f"Error obteniendo datos del estudiante: {str(e)}")
+        return {'entries': [], 'total_analyses': 0, 'has_iterations': False}

modules/morphosyntax/__init__.py

@@ -1,6 +1,7 @@
 from .morphosyntax_interface import (
-    display_morphosyntax_interface, 
-    display_morphosyntax_results
+    display_morphosyntax_interface,
+    display_arc_diagram
+    # display_morphosyntax_results
 )
 
 from .morphosyntax_process import (
@@ -15,7 +16,8 @@ from .morphosyntax_process import (
 
 __all__ = [
     'display_morphosyntax_interface',
-    'display_morphosyntax_results',
+    'display_arc_diagram',
+    #'display_morphosyntax_results',
     'process_morphosyntactic_input',
     'format_analysis_results',
     'perform_advanced_morphosyntactic_analysis',

modules/morphosyntax/morphosyntax_interface.py

@@ -1,319 +1,228 @@
-#modules/morphosyntax/morphosyntax_interface.py
+# modules/morphosyntax/morphosyntax_interface.py
 
-#Importaciones generales
 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
+import logging
+from spacy import displacy
 
-#Importaciones locales
-from .morphosyntax_process import (
-    process_morphosyntactic_input,
-    format_analysis_results,
-    perform_advanced_morphosyntactic_analysis,
-    get_repeated_words_colors,
-    highlight_repeated_words,
-    POS_COLORS,
-    POS_TRANSLATIONS
+# Funciones de análisis y DB que ya tienes en tus módulos
+from ..morphosyntax.morphosyntax_process import perform_advanced_morphosyntactic_analysis
+from ..database.morphosyntax_iterative_mongo_db import (
+    store_student_morphosyntax_base,
+    store_student_morphosyntax_iteration,
 )
 
-from ..utils.widget_utils import generate_unique_key
-from ..database.morphosintax_mongo_db import store_student_morphosyntax_result
-from ..database.chat_mongo_db import store_chat_history, get_chat_history
-
-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:
+    """Inicializa el estado de análisis de arcos (base e iteraciones) si no existe."""
+    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
+            "base_id": None,
+            "base_text": "",
+            "base_diagram": None,
+            "iteration_text": "",
+            "iteration_diagram": None,
         }
-        logger.info("Estado de análisis de arcos inicializado")
-
-    # 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")
+        logger.info("Estado de análisis de arcos inicializado.")
 
 ###########################################################################
+def reset_arc_analysis_state():
+    """Resetea completamente el estado de análisis de arcos."""
+    st.session_state.arc_analysis_state = {
+        "base_id": None,
+        "base_text": "",
+        "base_diagram": None,
+        "iteration_text": "",
+        "iteration_diagram": None,
+    }
+    logger.info("Estado de arcos reseteado.")
 
-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):
+###########################################################################
+def display_arc_diagram(doc):
+    """
+    Genera y retorna el HTML del diagrama de arco para un Doc de spaCy.
+    No imprime directamente; retorna el HTML para usar con st.write(...).
+    """
     try:
-        # CSS para layout estable
-        st.markdown("""
-            <style>
-            .stTextArea textarea {
-                font-size: 1rem;
-                line-height: 1.5;
-                min-height: 100px !important;
-                height: 100px !important;
-            }
-            .arc-diagram-container {
-                width: 100%;
-                padding: 0.5rem;
-                margin: 0.5rem 0;
-            }
-            </style>
-        """, unsafe_allow_html=True)
-
-        # 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([
-            "Análisis de Diagramas de Arco",
-            "Análisis de Categorías",
-            "Análisis Morfológico"
-        ])
-
-        # Tab de Diagramas de Arco
-        with subtabs[0]:
-            # 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()
+        diagram_html = ""
+        for sent in doc.sents:
+            svg_html = displacy.render(
+                sent,
+                style="dep",
+                options={
+                    "distance": 100,
+                    "arrow_spacing": 20,
+                    "word_spacing": 30
+                }
+            )
+            # Ajustar tamaños
+            svg_html = svg_html.replace('height="375"', 'height="200"')
+            svg_html = re.sub(
+                r'<svg[^>]*>',
+                lambda m: m.group(0).replace('height="450"', 'height="300"'),
+                svg_html
+            )
+            svg_html = re.sub(
+                r'<g [^>]*transform="translate\((\d+),(\d+)\)"',
+                lambda m: f'<g transform="translate({m.group(1)},50)"',
+                svg_html
+            )
+            # Envolver en contenedor
+            diagram_html += f'<div class="arc-diagram-container">{svg_html}</div>'
+        return diagram_html
 
-            # 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()
+    except Exception as e:
+        logger.error(f"Error en display_arc_diagram: {str(e)}")
+        return "<p style='color:red;'>Error generando diagrama</p>"
 
-            # 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(
-                    "",
-                    value=st.session_state.arc_analysis_state['original_text'],
-                    key=text_key,
-                    height=100
-                )
+###########################################################################
+def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
+    """
+    Interfaz principal para la visualización de diagramas de arco
+    (Texto Base vs Iteraciones).
+    """
+    # CSS para layout vertical y estable
+    st.markdown("""
+        <style>
+        .stTextArea textarea {
+            font-size: 1rem;
+            line-height: 1.5;
+            min-height: 100px !important;
+            height: 100px !important;
+        }
+        .arc-diagram-container {
+            width: 100%;
+            padding: 0.5rem;
+            margin: 0.5rem 0;
+        }
+        .divider {
+            height: 3px;
+            border: none;
+            background-color: #333;
+            margin: 2rem 0;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    # 1) Inicializar estados
+    initialize_arc_analysis_state()
+    arc_state = st.session_state.arc_analysis_state
+
+    # 2) Creamos pestañas: "Texto Base" y "Iteraciones"
+    tabs = st.tabs(["Texto Base", "Iteraciones"])
+
+    # =================== PESTAÑA 1: Texto Base ==========================
+    with tabs[0]:
+        st.subheader("Análisis de Texto Base")
+
+        # Botón para iniciar nuevo análisis
+        if st.button("Nuevo Análisis", key="btn_reset_base"):
+            # Si requieres recargar la app por completo, podrías descomentar:
+            # st.experimental_rerun()
+            reset_arc_analysis_state()
+
+        # Textarea de texto base
+        arc_state["base_text"] = st.text_area(
+            "Ingrese su texto inicial",
+            value=arc_state["base_text"],
+            key="base_text_input",
+            height=150
+        )
+
+        # Botón para analizar texto base
+        if st.button("Analizar Texto Base", key="btn_analyze_base"):
+            if not arc_state["base_text"].strip():
+                st.warning("Ingrese un texto para analizar.")
+            else:
+                try:
+                    # Procesar con spaCy
+                    doc = nlp_models[lang_code](arc_state["base_text"])
+                    base_arc_html = display_arc_diagram(doc)
+                    arc_state["base_diagram"] = base_arc_html
 
-                col1, col2, col3 = st.columns([2,1,2])
-                with col1:
-                    analyze_button = st.button(
-                        "Analizar Texto Original",
-                        type="primary",
-                        key=f"analyze_original_{st.session_state.arc_analysis_state['analysis_count']}",
-                        use_container_width=True
+                    # Guardar en Mongo
+                    analysis = perform_advanced_morphosyntactic_analysis(
+                        arc_state["base_text"],
+                        nlp_models[lang_code]
                     )
-
-            # Procesar texto original
-            if analyze_button and text_input.strip():
+                    base_id = store_student_morphosyntax_base(
+                        username=st.session_state.username,
+                        text=arc_state["base_text"],
+                        arc_diagrams=analysis["arc_diagrams"]
+                    )
+                    if base_id:
+                        arc_state["base_id"] = base_id
+                        st.success(f"Análisis base guardado. ID: {base_id}")
+
+                except Exception as exc:
+                    st.error("Error procesando texto base")
+                    logger.error(f"Error en análisis base: {str(exc)}")
+
+        # Mostrar diagrama base
+        if arc_state["base_diagram"]:
+            st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+            st.markdown("#### Diagrama de Arco (Texto Base)")
+            st.write(arc_state["base_diagram"], unsafe_allow_html=True)
+
+    # ================== PESTAÑA 2: Iteraciones ==========================
+    with tabs[1]:
+        st.subheader("Análisis de Cambios / Iteraciones")
+
+        # Verificar que exista un texto base
+        if not arc_state["base_id"]:
+            st.info("Primero analiza un texto base en la pestaña anterior.")
+            return
+
+        # --- 1) Mostrar SIEMPRE el diagrama base arriba ---
+        st.markdown("#### Diagrama de Arco (Texto Base)")
+        if arc_state["base_diagram"]:
+            st.write(arc_state["base_diagram"], unsafe_allow_html=True)
+        else:
+            st.info("No hay diagrama base disponible.")
+
+        # --- 2) Caja de texto para la iteración ---
+        st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+        st.subheader("Texto de Iteración")
+        arc_state["iteration_text"] = st.text_area(
+            "Ingrese su nueva versión / iteración",
+            value=arc_state["iteration_text"],
+            height=150
+        )
+
+        # Botón para analizar iteración
+        if st.button("Analizar Cambios", key="btn_analyze_iteration"):
+            if not arc_state["iteration_text"].strip():
+                st.warning("Ingrese texto de iteración.")
+            else:
                 try:
-                    doc = nlp_models[lang_code](text_input)
-                    analysis = perform_advanced_morphosyntactic_analysis(
-                        text_input,
+                    # Procesar con spaCy
+                    doc_iter = nlp_models[lang_code](arc_state["iteration_text"])
+                    arc_html_iter = display_arc_diagram(doc_iter)
+                    arc_state["iteration_diagram"] = arc_html_iter
+
+                    # Guardar en Mongo
+                    analysis_iter = perform_advanced_morphosyntactic_analysis(
+                        arc_state["iteration_text"],
                         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
-                    })
-
-                    if store_student_morphosyntax_result(
+                    iteration_id = store_student_morphosyntax_iteration(
                         username=st.session_state.username,
-                        text=text_input,
-                        arc_diagrams=analysis['arc_diagrams']
-                    ):
-                        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 al procesar texto original: {str(e)}")
-
-            # Sección de iteración
-            if st.session_state.arc_analysis_state.get('original_analysis'):
-                with iteration_input_container:
-                    st.markdown("---")
-                    
-                    # 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
-                        )
-                        
-                        # 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)
-                                    
-                                    # Mostrar ambos análisis
-                                    with col1:
-                                        display_original_analysis(
-                                            original_diagram_container,
-                                            st.session_state.arc_analysis_state['original_analysis'],
-                                            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 al procesar iteración: {str(e)}")
-
-        # Otros subtabs...
-        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 general en la interfaz: {str(e)}")
-
-############################################################################
-
-def display_morphosyntax_results(result, lang_code, morpho_t):
-    """
-    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:
-        return
-        
-    try:
-        doc = result['doc']
-        sentences = list(doc.sents)
-        for i, sent in enumerate(sentences):
-            try:
-                st.subheader(f"{morpho_t.get('sentence', '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)}")
-            
+                        base_id=arc_state["base_id"],
+                        original_text=arc_state["base_text"],
+                        iteration_text=arc_state["iteration_text"],
+                        arc_diagrams=analysis_iter["arc_diagrams"]
+                    )
+                    if iteration_id:
+                        st.success(f"Iteración guardada. ID: {iteration_id}")
+
+                except Exception as exc:
+                    st.error("Error procesando iteración")
+                    logger.error(f"Error en iteración: {str(exc)}")
+
+        # --- 3) Mostrar diagrama de iteración debajo ---
+        if arc_state["iteration_diagram"]:
+            st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+            st.markdown("#### Diagrama de Arco (Iteración)")
+            st.write(arc_state["iteration_diagram"], unsafe_allow_html=True)

modules/morphosyntax/morphosyntax_interface_vOk-30-12-24.py

@@ -0,0 +1,247 @@
+# modules/morphosyntax/morphosyntax_interface.py
+
+import streamlit as st
+import re
+import logging
+from spacy import displacy
+
+# Se asume que la función perform_advanced_morphosyntactic_analysis
+# y los métodos store_student_morphosyntax_base/iteration existen.
+from ..morphosyntax.morphosyntax_process import perform_advanced_morphosyntactic_analysis
+from ..database.morphosyntax_iterative_mongo_db import (
+    store_student_morphosyntax_base,
+    store_student_morphosyntax_iteration,
+)
+
+logger = logging.getLogger(__name__)
+
+###########################################################################
+def initialize_arc_analysis_state():
+    """
+    Inicializa el estado de análisis de arcos (base e iteraciones) si no existe.
+    """
+    if "arc_analysis_state" not in st.session_state:
+        st.session_state.arc_analysis_state = {
+            "base_id": None,
+            "base_text": "",
+            "base_diagram": None,
+            "iteration_text": "",
+            "iteration_diagram": None,
+        }
+        logger.info("Estado de análisis de arcos inicializado.")
+
+###########################################################################
+def reset_arc_analysis_state():
+    """
+    Resetea completamente el estado de análisis de arcos.
+    """
+    st.session_state.arc_analysis_state = {
+        "base_id": None,
+        "base_text": "",
+        "base_diagram": None,
+        "iteration_text": "",
+        "iteration_diagram": None,
+    }
+    logger.info("Estado de arcos reseteado.")
+
+###########################################################################
+def display_arc_diagram(doc):
+    """
+    Genera y retorna el HTML del diagrama de arco para un `Doc` de spaCy.
+    No imprime directamente en pantalla; regresa el HTML para 
+    usar con `st.write(..., unsafe_allow_html=True)`.
+    """
+    try:
+        diagram_html = ""
+        for sent in doc.sents:
+            svg_html = displacy.render(
+                sent,
+                style="dep",
+                options={
+                    "distance": 100,
+                    "arrow_spacing": 20,
+                    "word_spacing": 30
+                }
+            )
+            # Ajustar tamaños
+            svg_html = svg_html.replace('height="375"', 'height="200"')
+            svg_html = re.sub(
+                r'<svg[^>]*>',
+                lambda m: m.group(0).replace('height="450"', 'height="300"'),
+                svg_html
+            )
+            svg_html = re.sub(
+                r'<g [^>]*transform="translate\((\d+),(\d+)\)"',
+                lambda m: f'<g transform="translate({m.group(1)},50)"',
+                svg_html
+            )
+            # Envolver en contenedor
+            diagram_html += f'<div class="arc-diagram-container">{svg_html}</div>'
+        return diagram_html
+
+    except Exception as e:
+        logger.error(f"Error en display_arc_diagram: {str(e)}")
+        return "<p style='color:red;'>Error generando diagrama</p>"
+
+###########################################################################
+def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
+    """
+    Interfaz principal para la visualización de diagramas de arco
+    (Texto Base vs Iteraciones).
+    """
+    # CSS para layout vertical y estable
+    st.markdown("""
+        <style>
+        .stTextArea textarea {
+            font-size: 1rem;
+            line-height: 1.5;
+            min-height: 100px !important;
+            height: 100px !important;
+        }
+        .arc-diagram-container {
+            width: 100%;
+            padding: 0.5rem;
+            margin: 0.5rem 0;
+        }
+        .divider {
+            height: 3px;
+            border: none;
+            background-color: #333;
+            margin: 2rem 0;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    # 1) Inicializar estados
+    initialize_arc_analysis_state()
+    arc_state = st.session_state.arc_analysis_state
+
+    # 2) Creamos pestañas: "Texto Base" y "Iteraciones"
+    tabs = st.tabs(["Texto Base", "Iteraciones"])
+
+    # =================== PESTAÑA 1: Texto Base ==========================
+    with tabs[0]:
+        st.subheader("Análisis de Texto Base")
+
+        # Botón para iniciar nuevo análisis
+        if st.button("Nuevo Análisis", key="btn_reset_base"):
+            # Solo limpiamos el estado; si requieres forzar reload,
+            # descomenta la siguiente línea:
+            # st.experimental_rerun()
+            reset_arc_analysis_state()
+
+        # Textarea de texto base
+        arc_state["base_text"] = st.text_area(
+            "Ingrese su texto inicial",
+            value=arc_state["base_text"],
+            key="base_text_input",
+            height=150
+        )
+
+        # Botón para analizar texto base
+        if st.button("Analizar Texto Base", key="btn_analyze_base"):
+            if not arc_state["base_text"].strip():
+                st.warning("Ingrese un texto para analizar.")
+            else:
+                try:
+                    # Procesar con spaCy
+                    doc = nlp_models[lang_code](arc_state["base_text"])
+                    # Generar HTML del arco
+                    arc_html = display_arc_diagram(doc)
+                    arc_state["base_diagram"] = arc_html
+
+                    # Guardar en Mongo
+                    analysis = perform_advanced_morphosyntactic_analysis(
+                        arc_state["base_text"],
+                        nlp_models[lang_code]
+                    )
+                    base_id = store_student_morphosyntax_base(
+                        username=st.session_state.username,
+                        text=arc_state["base_text"],
+                        arc_diagrams=analysis["arc_diagrams"]
+                    )
+                    if base_id:
+                        arc_state["base_id"] = base_id
+                        st.success(f"Análisis base guardado. ID: {base_id}")
+
+                except Exception as exc:
+                    st.error("Error procesando texto base")
+                    logger.error(f"Error en análisis base: {str(exc)}")
+
+        # Mostrar diagrama base
+        if arc_state["base_diagram"]:
+            st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+            st.markdown("#### Diagrama de Arco (Texto Base)")
+            st.write(arc_state["base_diagram"], unsafe_allow_html=True)
+
+    # ================== PESTAÑA 2: Iteraciones ==========================
+    with tabs[1]:
+        st.subheader("Análisis de Cambios / Iteraciones")
+
+        # Verificar que exista texto base analizado
+        if not arc_state["base_id"]:
+            st.info("Primero analiza un texto base en la pestaña anterior.")
+            return
+
+        # Mostrar texto base como referencia (solo lectura)
+        st.text_area(
+            "Texto Base (solo lectura)",
+            value=arc_state["base_text"],
+            height=80,
+            disabled=True
+        )
+
+        # Caja de texto para la iteración
+        arc_state["iteration_text"] = st.text_area(
+            "Texto de Iteración",
+            value=arc_state["iteration_text"],
+            height=150
+        )
+
+        # Botón analizar iteración
+        if st.button("Analizar Cambios", key="btn_analyze_iteration"):
+            if not arc_state["iteration_text"].strip():
+                st.warning("Ingrese texto de iteración.")
+            else:
+                try:
+                    # Procesar con spaCy
+                    doc_iter = nlp_models[lang_code](arc_state["iteration_text"])
+                    arc_html_iter = display_arc_diagram(doc_iter)
+                    arc_state["iteration_diagram"] = arc_html_iter
+
+                    # Guardar en Mongo
+                    analysis_iter = perform_advanced_morphosyntactic_analysis(
+                        arc_state["iteration_text"],
+                        nlp_models[lang_code]
+                    )
+                    iteration_id = store_student_morphosyntax_iteration(
+                        username=st.session_state.username,
+                        base_id=arc_state["base_id"],
+                        original_text=arc_state["base_text"],
+                        iteration_text=arc_state["iteration_text"],
+                        arc_diagrams=analysis_iter["arc_diagrams"]
+                    )
+                    if iteration_id:
+                        st.success(f"Iteración guardada. ID: {iteration_id}")
+
+                except Exception as exc:
+                    st.error("Error procesando iteración")
+                    logger.error(f"Error en iteración: {str(exc)}")
+
+        # Mostrar diagrama de iteración
+        if arc_state["iteration_diagram"]:
+            st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+            st.markdown("#### Diagrama de Arco (Iteración)")
+            st.write(arc_state["iteration_diagram"], unsafe_allow_html=True)
+
+        # Comparación vertical (uno abajo del otro)
+        if arc_state["base_diagram"] and arc_state["iteration_diagram"]:
+            st.markdown("<hr class='divider'>", unsafe_allow_html=True)
+            st.markdown("### Comparación Vertical: Base vs. Iteración")
+            
+            st.markdown("**Diagrama Base**")
+            st.write(arc_state["base_diagram"], unsafe_allow_html=True)
+            
+            st.markdown("---")
+            st.markdown("**Diagrama Iterado**")
+            st.write(arc_state["iteration_diagram"], unsafe_allow_html=True)

modules/ui/ui.py

@@ -58,7 +58,7 @@ from ..database.chat_mongo_db import store_chat_history, get_chat_history
 ##Importaciones desde los análisis #######
 from ..morphosyntax.morphosyntax_interface import (
     display_morphosyntax_interface, 
-    display_morphosyntax_results
+    display_arc_diagram
 )
 
 from ..semantic.semantic_interface import (