modules/morphosyntax/morphosyntax_interface.py

#modules/morphosyntax/morphosyntax_interface.py
import streamlit as st
from streamlit_float import *
from streamlit_antd_components import *
from streamlit.components.v1 import html
import base64

from .morphosyntax_process import process_morphosyntactic_input, format_analysis_results

from ..utils.widget_utils import generate_unique_key
from ..database.morphosintax_mongo_db import store_student_morphosyntax_result
from ..database.chat_db import store_chat_history
from ..database.morphosintaxis_export import export_user_interactions

import logging
logger = logging.getLogger(__name__)

def display_morphosyntax_interface(lang_code, nlp_models, t):
    """
    Interfaz para el análisis morfosintáctico
    """
    morpho_t = t.get('MORPHOSYNTACTIC', {})
    st.title(morpho_t.get('title', 'AIdeaText - Morphological Analysis'))

    input_key = f"morphosyntax_input_{lang_code}"
    if input_key not in st.session_state:
        st.session_state[input_key] = ""

    sentence_input = st.text_area(
        morpho_t.get('morpho_input_label', 'Enter text to analyze:'),
        height=150,
        placeholder=morpho_t.get('morpho_input_placeholder', 'Enter your text here...'),
        value=st.session_state[input_key],
        key=f"text_area_{lang_code}"
    )

    if st.button(morpho_t.get('analyze_button', 'Analyze'), key=f"analyze_button_{lang_code}"):
        if sentence_input:
            # Usar el proceso morfosintáctico actualizado
            result = process_morphosyntactic_input(
                sentence_input,
                lang_code,
                nlp_models,
                t
            )

            if result['success']:
                # Formatear y mostrar resultados
                formatted_results = format_analysis_results(result, t)
                
                # Mostrar texto resaltado si está disponible
                if formatted_results['highlighted_text']:
                    st.markdown(formatted_results['highlighted_text'], unsafe_allow_html=True)
                
                # Mostrar el análisis formateado
                st.markdown(formatted_results['formatted_text'])
                
                # Mostrar visualizaciones
                if formatted_results['visualizations']:
                    for i, viz in enumerate(formatted_results['visualizations']):
                        st.markdown(f"**{morpho_t.get('sentence', 'Sentence')} {i+1}**")
                        st.components.v1.html(viz, height=370, scrolling=True)
                        if i < len(formatted_results['visualizations']) - 1:
                            st.markdown("---")
            else:
                st.error(result['message'])
        else:
            st.warning(morpho_t.get('warning_message', 'Please enter a text to analyze.'))

    # Botón de exportación
    if st.button(morpho_t.get('export_button', 'Export Analysis')):
        pdf_buffer = export_user_interactions(st.session_state.username, 'morphosyntax')
        st.download_button(
            label=morpho_t.get('download_pdf', 'Download PDF'),
            data=pdf_buffer,
            file_name="morphosyntax_analysis.pdf",
            mime="application/pdf"
        )

'''
    if user_input:
        # Añadir el mensaje del usuario al historial
        st.session_state.morphosyntax_chat_history.append({"role": "user", "content": user_input})

        # Procesar el input del usuario nuevo al 26-9-2024
        response, visualizations, result = process_morphosyntactic_input(user_input, lang_code, nlp_models, t)

        # Mostrar indicador de carga
        with st.spinner(t.get('processing', 'Processing...')):
            try:
                # Procesar el input del usuario
                response, visualizations, result = process_morphosyntactic_input(user_input, lang_code, nlp_models, t)

                # Añadir la respuesta al historial
                message = {
                    "role": "assistant",
                    "content": response
                }
                if visualizations:
                    message["visualizations"] = visualizations
                st.session_state.morphosyntax_chat_history.append(message)

                # Mostrar la respuesta más reciente
                with st.chat_message("assistant"):
                    st.write(response)
                    if visualizations:
                        for i, viz in enumerate(visualizations):
                            st.markdown(f"**Oración {i+1} del párrafo analizado**")
                            st.components.v1.html(
                                f"""
                                <div style="width: 100%; overflow-x: auto; white-space: nowrap;">
                                    <div style="min-width: 1200px;">
                                        {viz}
                                    </div>
                                </div>
                                """,
                                height=350,
                                scrolling=True
                            )
                            if i < len(visualizations) - 1:
                                st.markdown("---")  # Separador entre diagramas

                # Si es un análisis, guardarlo en la base de datos
                if user_input.startswith('/analisis_morfosintactico') and result:
                    store_morphosyntax_result(
                        st.session_state.username,
                        user_input.split('[', 1)[1].rsplit(']', 1)[0],  # texto analizado
                        result.get('repeated_words', {}),
                        visualizations,
                        result.get('pos_analysis', []),
                        result.get('morphological_analysis', []),
                        result.get('sentence_structure', [])
                    )


            except Exception as e:
                st.error(f"{t['error_processing']}: {str(e)}")



    # Forzar la actualización de la interfaz
        st.rerun()

    # Botón para limpiar el historial del chat
    if st.button(t['clear_chat'], key=generate_unique_key('morphosyntax', 'clear_chat')):
        st.session_state.morphosyntax_chat_history = []
        st.rerun()
'''


'''
############ MODULO PARA DEPURACIÓN Y PRUEBAS #####################################################
def display_morphosyntax_interface(lang_code, nlp_models, t):
    st.subheader(t['morpho_title'])

    text_input = st.text_area(
        t['warning_message'],
        height=150,
        key=generate_unique_key("morphosyntax", "text_area")
    )

    if st.button(
        t['results_title'],
        key=generate_unique_key("morphosyntax", "analyze_button")
    ):
        if text_input:
            # Aquí iría tu lógica de análisis morfosintáctico
            # Por ahora, solo mostraremos un mensaje de placeholder
            st.info(t['analysis_placeholder'])
        else:
            st.warning(t['no_text_warning'])
###
#################################################
'''