Merge branch #AIdeaText/test' into 'AIdeaText/test2'

app.py

@@ -115,6 +115,13 @@ def logged_in_interface():
     if 'current_lang' not in st.session_state:
         st.session_state.current_lang = 'es'  # Idioma por defecto
 
+    if 'morphosyntax_result' not in st.session_state:
+        st.session_state.morphosyntax_result = None
+    if 'semantic_result' not in st.session_state:
+        st.session_state.semantic_result = None
+    if 'discourse_result' not in st.session_state:
+        st.session_state.discourse_result = None
+
     # Crear un contenedor para la barra superior
     with st.container():
         # Usar más columnas para un mejor control del espacio

modules/database/database.py

@@ -7,13 +7,15 @@ from pymongo import MongoClient
 import certifi
 from datetime import datetime
 import io
+from io import BytesIO
 import base64
 import matplotlib.pyplot as plt
 from matplotlib.figure import Figure
 import bcrypt
 print(f"Bcrypt version: {bcrypt.__version__}")
 import uuid
-
+import plotly.graph_objects as go  # Para manejar el diagrama de Sankey
+import numpy as np  # Puede ser necesario para algunas operaciones
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
@@ -254,87 +256,93 @@ def store_morphosyntax_result(username, text, repeated_words, arc_diagrams, pos_
 ################################################################################################################
 def store_semantic_result(username, text, analysis_result):
     if analysis_collection is None:
-        logger.error("La conexión a MongoDB no está inicializada")
+        print("La conexión a MongoDB no está inicializada")
         return False
-
     try:
+        # Convertir los conceptos clave a una lista de tuplas
+        key_concepts = [(concept, float(frequency)) for concept, frequency in analysis_result['key_concepts']]
+        
         # Convertir el gráfico a imagen base64
-        buf = io.BytesIO()
+        buf = BytesIO()
         analysis_result['relations_graph'].savefig(buf, format='png')
         buf.seek(0)
         img_str = base64.b64encode(buf.getvalue()).decode('utf-8')
-
-        # Convertir los conceptos clave a una lista de tuplas
-        key_concepts = [(concept, float(frequency)) for concept, frequency in analysis_result['key_concepts']]
-
+        
         analysis_document = {
             'username': username,
             'timestamp': datetime.utcnow(),
-            'text': text,
             'key_concepts': key_concepts,
-            'network_diagram': img_str,
+            'graph': img_str,
             'analysis_type': 'semantic'
         }
-
+        
         result = analysis_collection.insert_one(analysis_document)
-        logger.info(f"Análisis semántico guardado con ID: {result.inserted_id} para el usuario: {username}")
-        logger.info(f"Longitud de la imagen guardada: {len(img_str)}")
+        print(f"Análisis semántico guardado con ID: {result.inserted_id} para el usuario: {username}")
         return True
     except Exception as e:
-        logger.error(f"Error al guardar el análisis semántico para el usuario {username}: {str(e)}")
+        print(f"Error al guardar el análisis semántico para el usuario {username}: {str(e)}")
         return False
 
 ###############################################################################################################
 
 def store_discourse_analysis_result(username, text1, text2, analysis_result):
+    if analysis_collection is None:
+        print("La conexión a MongoDB no está inicializada")
+        return False
+    
     try:
-        # Crear una nueva figura combinada
+        # Convertir los grafos individuales a imágenes base64
+        buf1 = BytesIO()
+        analysis_result['graph1'].savefig(buf1, format='png')
+        buf1.seek(0)
+        img_str1 = base64.b64encode(buf1.getvalue()).decode('utf-8')
+
+        buf2 = BytesIO()
+        analysis_result['graph2'].savefig(buf2, format='png')
+        buf2.seek(0)
+        img_str2 = base64.b64encode(buf2.getvalue()).decode('utf-8')
+
+        # Crear una imagen combinada
         fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10))
-
-        # Añadir la primera imagen
-        ax1.imshow(analysis_result['graph1'].canvas.renderer.buffer_rgba())
-        ax1.set_title("Documento 1: Relaciones Conceptuales")
+        ax1.imshow(plt.imread(BytesIO(base64.b64decode(img_str1))))
         ax1.axis('off')
-
-        # Añadir la segunda imagen
-        ax2.imshow(analysis_result['graph2'].canvas.renderer.buffer_rgba())
-        ax2.set_title("Documento 2: Relaciones Conceptuales")
+        ax1.set_title("Documento 1: Relaciones Conceptuales")
+        ax2.imshow(plt.imread(BytesIO(base64.b64decode(img_str2))))
         ax2.axis('off')
-
-        # Ajustar el diseño
-        plt.tight_layout()
-
-        # Convertir la figura combinada a una imagen base64
-        buf = io.BytesIO()
-        fig.savefig(buf, format='png')
-        buf.seek(0)
-        img_str = base64.b64encode(buf.getvalue()).decode('utf-8')
-
-        # Cerrar las figuras para liberar memoria
+        ax2.set_title("Documento 2: Relaciones Conceptuales")
+        
+        buf_combined = BytesIO()
+        fig.savefig(buf_combined, format='png')
+        buf_combined.seek(0)
+        img_str_combined = base64.b64encode(buf_combined.getvalue()).decode('utf-8')
         plt.close(fig)
-        plt.close(analysis_result['graph1'])
-        plt.close(analysis_result['graph2'])
 
         # Convertir los conceptos clave a listas de tuplas
-        key_concepts1 = [(concept, float(frequency)) for concept, frequency in analysis_result['table1'].values.tolist()]
-        key_concepts2 = [(concept, float(frequency)) for concept, frequency in analysis_result['table2'].values.tolist()]
+        key_concepts1 = [(concept, float(frequency)) for concept, frequency in analysis_result['key_concepts1']]
+        key_concepts2 = [(concept, float(frequency)) for concept, frequency in analysis_result['key_concepts2']]
 
+        # Crear el documento para guardar
         analysis_document = {
             'username': username,
             'timestamp': datetime.utcnow(),
-            'text1': text1,
-            'text2': text2,
-            'combined_graph': img_str,
+            #'text1': text1,
+            #'text2': text2,
+            'graph1': img_str1,
+            'graph2': img_str2,
+            'combined_graph': img_str_combined,
             'key_concepts1': key_concepts1,
             'key_concepts2': key_concepts2,
             'analysis_type': 'discourse'
         }
 
+        # Insertar el documento en la base de datos
         result = analysis_collection.insert_one(analysis_document)
-        logger.info(f"Análisis discursivo guardado con ID: {result.inserted_id} para el usuario: {username}")
+        print(f"Análisis discursivo guardado con ID: {result.inserted_id} para el usuario: {username}")
         return True
     except Exception as e:
-        logger.error(f"Error al guardar el análisis discursivo para el usuario {username}: {str(e)}")
+        print(f"Error al guardar el análisis discursivo para el usuario {username}: {str(e)}")
+        print(f"Tipo de excepción: {type(e).__name__}")
+        print(f"Detalles de la excepción: {e.args}")
         return False
 
 ###############################################################################################################
@@ -361,7 +369,6 @@ def get_student_data(username):
     if analysis_collection is None or chat_collection is None:
         logger.error("La conexión a MongoDB no está inicializada")
         return None
-
     formatted_data = {
         "username": username,
         "entries": [],
@@ -371,7 +378,6 @@ def get_student_data(username):
         "discourse_analyses": [],
         "chat_history": []
     }
-
     try:
         logger.info(f"Buscando datos de análisis para el usuario: {username}")
         cursor = analysis_collection.find({"username": username})
@@ -379,12 +385,12 @@ def get_student_data(username):
         for entry in cursor:
             formatted_entry = {
                 "timestamp": entry.get("timestamp", datetime.utcnow()),
-                "text": entry.get("text", ""),
                 "analysis_type": entry.get("analysis_type", "morphosyntax")
             }
             
             if formatted_entry["analysis_type"] == "morphosyntax":
                 formatted_entry.update({
+                    "text": entry.get("text", ""),
                     "word_count": entry.get("word_count", {}),
                     "arc_diagrams": entry.get("arc_diagrams", [])
                 })
@@ -392,17 +398,24 @@ def get_student_data(username):
                     formatted_data["word_count"][category] = formatted_data["word_count"].get(category, 0) + count
             
             elif formatted_entry["analysis_type"] == "semantic":
-                formatted_entry["network_diagram"] = entry.get("network_diagram", "")
+                formatted_entry.update({
+                    "key_concepts": entry.get("key_concepts", []),
+                    "graph": entry.get("graph", "")
+                })
                 formatted_data["semantic_analyses"].append(formatted_entry)
             
             elif formatted_entry["analysis_type"] == "discourse":
                 formatted_entry.update({
                     "text1": entry.get("text1", ""),
                     "text2": entry.get("text2", ""),
+                    "key_concepts1": entry.get("key_concepts1", []),
+                    "key_concepts2": entry.get("key_concepts2", []),
+                    "graph1": entry.get("graph1", ""),
+                    "graph2": entry.get("graph2", ""),
                     "combined_graph": entry.get("combined_graph", "")
                 })
                 formatted_data["discourse_analyses"].append(formatted_entry)
-            
+                        
             formatted_data["entries"].append(formatted_entry)
         
         formatted_data["entries_count"] = len(formatted_data["entries"])
@@ -428,6 +441,5 @@ def get_student_data(username):
     
     except Exception as e:
         logger.error(f"Error al obtener historial de chat del estudiante {username}: {str(e)}")
-
     logger.info(f"Datos formateados para {username}: {formatted_data}")
     return formatted_data

modules/text_analysis/discourse_analysis.py

@@ -3,6 +3,7 @@ import spacy
 import networkx as nx
 import matplotlib.pyplot as plt
 import pandas as pd
+import numpy as np
 from .semantic_analysis import (
     create_concept_graph,
     visualize_concept_graph,
@@ -49,8 +50,8 @@ def perform_discourse_analysis(text1, text2, nlp, lang):
     return {
         'graph1': graph1,
         'graph2': graph2,
-        'table1': table1,
-        'table2': table2
+        'key_concepts1': key_concepts1,
+        'key_concepts2': key_concepts2
     }
 
 def display_discourse_analysis_results(analysis_result, lang_code):

modules/text_analysis/semantic_analysis.py

@@ -63,10 +63,10 @@ ENTITY_LABELS = {
     }
 }
 
-def identify_key_concepts(doc, top_n=10):
-    # Identificar sustantivos, verbos y adjetivos más frecuentes
-    word_freq = Counter([token.lemma_.lower() for token in doc if token.pos_ in ['NOUN', 'VERB', 'ADJ'] and not token.is_stop])
-    return word_freq.most_common(top_n)
+def identify_key_concepts(doc):
+    word_freq = Counter([token.lemma_.lower() for token in doc if token.pos_ in ['NOUN', 'VERB'] and not token.is_stop])
+    key_concepts = word_freq.most_common(10)  # Top 10 conceptos clave
+    return [(concept, float(freq)) for concept, freq in key_concepts]  # Asegurarse de que las frecuencias sean float
 
 def create_concept_graph(doc, key_concepts):
     G = nx.Graph()

modules/ui/ui.py

@@ -5,12 +5,15 @@ import io
 from io import BytesIO
 import base64
 import matplotlib.pyplot as plt
+import plotly.graph_objects as go
 import pandas as pd
+import numpy as np
 import time
 from datetime import datetime
 from streamlit_player import st_player  # Necesitarás instalar esta librería: pip install streamlit-player
 from spacy import displacy
 import logging
+import random
 
 ######################################################
 # Configuración del logger
@@ -207,7 +210,7 @@ def display_videos_and_info():
     st.header("Videos: pitch, demos, entrevistas, otros")
     
     videos = {
-        "Intro AideaText": "https://www.youtube.com/watch?v=UA-md1VxaRc",
+        "Presentación en PyCon Colombia, Medellín, 2024": "https://www.youtube.com/watch?v=Jn545-IKx5Q",
         "Presentación fundación Ser Maaestro": "https://www.youtube.com/watch?v=imc4TI1q164",
         "Pitch IFE Explora": "https://www.youtube.com/watch?v=Fqi4Di_Rj_s",
         "Entrevista Dr. Guillermo Ruíz": "https://www.youtube.com/watch?v=_ch8cRja3oc",
@@ -364,59 +367,58 @@ def display_student_progress(username, lang_code='es'):
   ##########################################################  
     with st.expander("Histórico de Análisis Semánticos"):
         semantic_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
-        st.write(f"Número total de entradas semánticas: {len(semantic_entries)}")
         for entry in semantic_entries:
             st.subheader(f"Análisis del {entry['timestamp']}")
-            st.write(f"Archivo analizado: {entry.get('filename', 'Nombre no disponible')}")
-            st.write(f"Claves disponibles en esta entrada: {', '.join(entry.keys())}")
             
-            # Verificar si 'relations_graph' está en entry antes de intentar acceder
-            if 'network_diagram' in entry:
+            # Mostrar conceptos clave
+            if 'key_concepts' in entry:
+                st.write("Conceptos clave:")
+                concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts']])
+                #st.write("Conceptos clave:")
+                #st.write(concepts_str)
+                st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
+            
+            # Mostrar gráfico
+            if 'graph' in entry:
                 try:
-                    logger.info(f"Longitud de la imagen recuperada: {len(entry['network_diagram'])}")
-                    st.image(f"data:image/png;base64,{entry['network_diagram']}")
+                    img_bytes = base64.b64decode(entry['graph'])
+                    st.image(img_bytes, caption="Gráfico de relaciones conceptuales")
                 except Exception as e:
-                    st.error(f"No se pudo mostrar la imagen: {str(e)}")
-                    st.write("Datos de la imagen (para depuración):")
-                    st.write(entry['network_diagram'][:100] + "...")
-            else:
-                logger.warning(f"No se encontró 'relations_graph' en la entrada: {entry.keys()}")
-                st.write("No se encontró el gráfico para este análisis.")
+                    st.error(f"No se pudo mostrar el gráfico: {str(e)}")
                         
 ##########################################################
     with st.expander("Histórico de Análisis Discursivos"):
         discourse_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
         for entry in discourse_entries:
             st.subheader(f"Análisis del {entry['timestamp']}")
-            st.write(f"Archivo patrón: {entry.get('filename1', 'Nombre no disponible')}")
-            st.write(f"Archivo comparado: {entry.get('filename2', 'Nombre no disponible')}")
+            
+            # Mostrar conceptos clave para ambos documentos
+            if 'key_concepts1' in entry:
+                concepts_str1 = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts1']])
+                st.write("Conceptos clave del documento 1:")
+                #st.write(concepts_str1)
+                st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str1}</div>", unsafe_allow_html=True)
+            
+            if 'key_concepts2' in entry:
+                concepts_str2 = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts2']])
+                st.write("Conceptos clave del documento 2:")
+                #st.write(concepts_str2)
+                st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str2}</div>", unsafe_allow_html=True)
             
             try:
-                # Intentar obtener y combinar las dos imágenes
-                if 'graph1' in entry and 'graph2' in entry:
-                    img1 = Image.open(BytesIO(base64.b64decode(entry['graph1'])))
-                    img2 = Image.open(BytesIO(base64.b64decode(entry['graph2'])))
-                    
-                    # Crear una nueva imagen combinada
-                    total_width = img1.width + img2.width
-                    max_height = max(img1.height, img2.height)
-                    combined_img = Image.new('RGB', (total_width, max_height))
-                    
-                    # Pegar las dos imágenes lado a lado
-                    combined_img.paste(img1, (0, 0))
-                    combined_img.paste(img2, (img1.width, 0))
-                    
-                    # Convertir la imagen combinada a bytes
-                    buffered = BytesIO()
-                    combined_img.save(buffered, format="PNG")
-                    img_str = base64.b64encode(buffered.getvalue()).decode()
-                    
-                    # Mostrar la imagen combinada
-                    st.image(f"data:image/png;base64,{img_str}")
-                elif 'combined_graph' in entry:
-                    # Si ya existe una imagen combinada, mostrarla directamente
+                if 'combined_graph' in entry and entry['combined_graph']:
                     img_bytes = base64.b64decode(entry['combined_graph'])
                     st.image(img_bytes)
+                elif 'graph1' in entry and 'graph2' in entry:
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        if entry['graph1']:
+                            img_bytes1 = base64.b64decode(entry['graph1'])
+                            st.image(img_bytes1)
+                    with col2:
+                        if entry['graph2']:
+                            img_bytes2 = base64.b64decode(entry['graph2'])
+                            st.image(img_bytes2)
                 else:
                     st.write("No se encontraron gráficos para este análisis.")
             except Exception as e:
@@ -428,7 +430,6 @@ def display_student_progress(username, lang_code='es'):
                     st.write("Graph 2:", entry['graph2'][:100] + "...")
                 if 'combined_graph' in entry:
                     st.write("Combined Graph:", entry['combined_graph'][:100] + "...")
-
                     
 ##########################################################
     with st.expander("Histórico de Conversaciones con el ChatBot"):
@@ -467,6 +468,8 @@ def display_morphosyntax_analysis_interface(nlp_models, lang_code):
             'success_message': "Análisis guardado correctamente.",
             'error_message': "Hubo un problema al guardar el análisis. Por favor, inténtelo de nuevo.",
             'warning_message': "Por favor, ingrese un texto para analizar.",
+            'initial_message': "Ingrese un texto y presione 'Analizar texto' para comenzar.",
+            'no_results': "No hay resultados disponibles. Por favor, realice un análisis primero.",
             'pos_analysis': "Análisis de categorías gramaticales",
             'morphological_analysis': "Análisis morfológico",
             'sentence_structure': "Estructura de oraciones",
@@ -501,6 +504,8 @@ def display_morphosyntax_analysis_interface(nlp_models, lang_code):
             'success_message': "Analysis saved successfully.",
             'error_message': "There was a problem saving the analysis. Please try again.",
             'warning_message': "Please enter a text to analyze.",
+            'initial_message': "Enter a text and press 'Analyze text' to start.",
+            'no_results': "No results available. Please perform an analysis first.",
             'pos_analysis': "Part of Speech Analysis",
             'morphological_analysis': "Morphological Analysis",
             'sentence_structure': "Sentence Structure",
@@ -535,6 +540,8 @@ def display_morphosyntax_analysis_interface(nlp_models, lang_code):
             'success_message': "Analyse enregistrée avec succès.",
             'error_message': "Un problème est survenu lors de l'enregistrement de l'analyse. Veuillez réessayer.",
             'warning_message': "Veuillez entrer un texte à analyser.",
+            'initial_message': "Entrez un texte et appuyez sur 'Analyser le texte' pour commencer.",
+            'no_results': "Aucun résultat disponible. Veuillez d'abord effectuer une analyse.",
             'pos_analysis': "Analyse des parties du discours",
             'morphological_analysis': "Analyse morphologique",
             'sentence_structure': "Structure des phrases",
@@ -580,181 +587,202 @@ def display_morphosyntax_analysis_interface(nlp_models, lang_code):
             # Análisis morfosintáctico avanzado
             advanced_analysis = perform_advanced_morphosyntactic_analysis(current_input, nlp_models[lang_code])    
 
-            # Mostrar leyenda (código existente)
-            st.markdown(f"##### {t['legend']}")
-            legend_html = "<div style='display: flex; flex-wrap: wrap;'>"
-            for pos, color in POS_COLORS.items():
-                if pos in POS_TRANSLATIONS[lang_code]:
-                    legend_html += f"<div style='margin-right: 10px;'><span style='background-color: {color}; padding: 2px 5px;'>{POS_TRANSLATIONS[lang_code][pos]}</span></div>"
-            legend_html += "</div>"
-            st.markdown(legend_html, unsafe_allow_html=True)
-
-            # Mostrar análisis de palabras repetidas (código existente)
-            word_colors = get_repeated_words_colors(doc)
-            with st.expander(t['repeated_words'], expanded=True):
-                highlighted_text = highlight_repeated_words(doc, word_colors)
-                st.markdown(highlighted_text, unsafe_allow_html=True)
+            # Guardar el resultado en el estado de la sesión
+            st.session_state.morphosyntax_result = {
+                'doc': doc,
+                'advanced_analysis': advanced_analysis
+            }
+
+            # Mostrar resultados
+            display_morphosyntax_results(st.session_state.morphosyntax_result, lang_code, t)
+
+            # Guardar resultados
+            if store_morphosyntax_result(
+                st.session_state.username,
+                current_input,
+                get_repeated_words_colors(doc),
+                advanced_analysis['arc_diagram'],
+                advanced_analysis['pos_analysis'],
+                advanced_analysis['morphological_analysis'],
+                advanced_analysis['sentence_structure']
+            ):
+                st.success(t['success_message'])
+            else:
+                st.error(t['error_message'])
+        else:
+            st.warning(t['warning_message'])
+    elif 'morphosyntax_result' in st.session_state and st.session_state.morphosyntax_result is not None:
+        
+        # Si hay un resultado guardado, mostrarlo
+        display_morphosyntax_results(st.session_state.morphosyntax_result, lang_code, t)
+    else:
+        st.info(t['initial_message'])  # Añade esta traducción a tu diccionario            
+
+def display_morphosyntax_results(result, lang_code, t):
+    if result is None:
+        st.warning(t['no_results'])  # Añade esta traducción a tu diccionario
+        return
+
+    doc = result['doc']
+    advanced_analysis = result['advanced_analysis']
+    
+    # Mostrar leyenda (código existente)
+    st.markdown(f"##### {t['legend']}")
+    legend_html = "<div style='display: flex; flex-wrap: wrap;'>"
+    for pos, color in POS_COLORS.items():
+        if pos in POS_TRANSLATIONS[lang_code]:
+            legend_html += f"<div style='margin-right: 10px;'><span style='background-color: {color}; padding: 2px 5px;'>{POS_TRANSLATIONS[lang_code][pos]}</span></div>"
+    legend_html += "</div>"
+    st.markdown(legend_html, unsafe_allow_html=True)
+
+    # Mostrar análisis de palabras repetidas (código existente)
+    word_colors = get_repeated_words_colors(doc)
+    with st.expander(t['repeated_words'], expanded=True):
+        highlighted_text = highlight_repeated_words(doc, word_colors)
+        st.markdown(highlighted_text, unsafe_allow_html=True)
+    
+    # Mostrar estructura de oraciones
+    with st.expander(t['sentence_structure'], expanded=True):
+        for i, sent_analysis in enumerate(advanced_analysis['sentence_structure']):
+            sentence_str = (
+                f"**{t['sentence']} {i+1}** "
+                f"{t['root']}: {sent_analysis['root']} ({sent_analysis['root_pos']}) -- "
+                f"{t['subjects']}: {', '.join(sent_analysis['subjects'])} -- "
+                f"{t['objects']}: {', '.join(sent_analysis['objects'])} -- "
+                f"{t['verbs']}: {', '.join(sent_analysis['verbs'])}"
+            )
+            st.markdown(sentence_str)
+
+    # Mostrar análisis de categorías gramaticales # Mostrar análisis morfológico
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        with st.expander(t['pos_analysis'], expanded=True):
+            pos_df = pd.DataFrame(advanced_analysis['pos_analysis'])
             
-            # Mostrar estructura de oraciones
-            with st.expander(t['sentence_structure'], expanded=True):
-                for i, sent_analysis in enumerate(advanced_analysis['sentence_structure']):
-                    sentence_str = (
-                        f"**{t['sentence']} {i+1}** "
-                        f"{t['root']}: {sent_analysis['root']} ({sent_analysis['root_pos']}) -- "
-                        f"{t['subjects']}: {', '.join(sent_analysis['subjects'])} -- "
-                        f"{t['objects']}: {', '.join(sent_analysis['objects'])} -- "
-                        f"{t['verbs']}: {', '.join(sent_analysis['verbs'])}"
-                    )
-                    st.markdown(sentence_str)
-
-            # Mostrar análisis de categorías gramaticales # Mostrar análisis morfológico
-            # Mostrar análisis de categorías gramaticales # Mostrar análisis morfológico
-            col1, col2 = st.columns(2)
+            # Traducir las etiquetas POS a sus nombres en el idioma seleccionado
+            pos_df['pos'] = pos_df['pos'].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
             
-            with col1:
-                with st.expander(t['pos_analysis'], expanded=True):
-                    pos_df = pd.DataFrame(advanced_analysis['pos_analysis'])
-                    
-                    # Traducir las etiquetas POS a sus nombres en el idioma seleccionado
-                    pos_df['pos'] = pos_df['pos'].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
-                    
-                    # Renombrar las columnas para mayor claridad
-                    pos_df = pos_df.rename(columns={
-                        'pos': t['grammatical_category'],
-                        'count': t['count'],
-                        'percentage': t['percentage'],
-                        'examples': t['examples']
-                    })
-                    
-                    # Mostrar el dataframe
-                    st.dataframe(pos_df)
+            # Renombrar las columnas para mayor claridad
+            pos_df = pos_df.rename(columns={
+                'pos': t['grammatical_category'],
+                'count': t['count'],
+                'percentage': t['percentage'],
+                'examples': t['examples']
+            })
             
-            with col2:
-                with st.expander(t['morphological_analysis'], expanded=True):
-                    morph_df = pd.DataFrame(advanced_analysis['morphological_analysis'])
-                    
-                    # Definir el mapeo de columnas
-                    column_mapping = {
-                        'text': t['word'],
-                        'lemma': t['lemma'],
-                        'pos': t['grammatical_category'],
-                        'dep': t['dependency'],
-                        'morph': t['morphology']
-                    }
-                    
-                    # Renombrar las columnas existentes
-                    morph_df = morph_df.rename(columns={col: new_name for col, new_name in column_mapping.items() if col in morph_df.columns})
-                    
-                    # Traducir las categorías gramaticales
-                    morph_df[t['grammatical_category']] = morph_df[t['grammatical_category']].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
-                    
-                    # Traducir las dependencias
-                    dep_translations = {
-                        'es': {
-                            'ROOT': 'RAÍZ', 'nsubj': 'sujeto nominal', 'obj': 'objeto', 'iobj': 'objeto indirecto',
-                            'csubj': 'sujeto clausal', 'ccomp': 'complemento clausal', 'xcomp': 'complemento clausal abierto',
-                            'obl': 'oblicuo', 'vocative': 'vocativo', 'expl': 'expletivo', 'dislocated': 'dislocado',
-                            'advcl': 'cláusula adverbial', 'advmod': 'modificador adverbial', 'discourse': 'discurso',
-                            'aux': 'auxiliar', 'cop': 'cópula', 'mark': 'marcador', 'nmod': 'modificador nominal',
-                            'appos': 'aposición', 'nummod': 'modificador numeral', 'acl': 'cláusula adjetiva',
-                            'amod': 'modificador adjetival', 'det': 'determinante', 'clf': 'clasificador',
-                            'case': 'caso', 'conj': 'conjunción', 'cc': 'coordinante', 'fixed': 'fijo',
-                            'flat': 'plano', 'compound': 'compuesto', 'list': 'lista', 'parataxis': 'parataxis',
-                            'orphan': 'huérfano', 'goeswith': 'va con', 'reparandum': 'reparación', 'punct': 'puntuación'
-                        },
-                        'en': {
-                            'ROOT': 'ROOT', 'nsubj': 'nominal subject', 'obj': 'object',
-                            'iobj': 'indirect object', 'csubj': 'clausal subject', 'ccomp': 'clausal complement', 'xcomp': 'open clausal complement',
-                            'obl': 'oblique', 'vocative': 'vocative', 'expl': 'expletive', 'dislocated': 'dislocated', 'advcl': 'adverbial clause modifier',
-                            'advmod': 'adverbial modifier', 'discourse': 'discourse element', 'aux': 'auxiliary', 'cop': 'copula', 'mark': 'marker',
-                            'nmod': 'nominal modifier', 'appos': 'appositional modifier', 'nummod': 'numeric modifier', 'acl': 'clausal modifier of noun',
-                            'amod': 'adjectival modifier', 'det': 'determiner', 'clf': 'classifier', 'case': 'case marking',
-                            'conj': 'conjunct', 'cc': 'coordinating conjunction', 'fixed': 'fixed multiword expression',
-                            'flat': 'flat multiword expression', 'compound': 'compound', 'list': 'list', 'parataxis': 'parataxis', 'orphan': 'orphan',
-                            'goeswith': 'goes with', 'reparandum': 'reparandum', 'punct': 'punctuation'
-                        },
-                        'fr': {
-                            'ROOT': 'RACINE', 'nsubj': 'sujet nominal', 'obj': 'objet', 'iobj': 'objet indirect',
-                            'csubj': 'sujet phrastique', 'ccomp': 'complément phrastique', 'xcomp': 'complément phrastique ouvert', 'obl': 'oblique',
-                            'vocative': 'vocatif', 'expl': 'explétif', 'dislocated': 'disloqué', 'advcl': 'clause adverbiale', 'advmod': 'modifieur adverbial',
-                            'discourse': 'élément de discours', 'aux': 'auxiliaire', 'cop': 'copule', 'mark': 'marqueur', 'nmod': 'modifieur nominal',
-                            'appos': 'apposition', 'nummod': 'modifieur numéral', 'acl': 'clause relative', 'amod': 'modifieur adjectival', 'det': 'déterminant',
-                            'clf': 'classificateur', 'case': 'marqueur de cas', 'conj': 'conjonction', 'cc': 'coordination', 'fixed': 'expression figée',
-                            'flat': 'construction plate', 'compound': 'composé', 'list': 'liste', 'parataxis': 'parataxe', 'orphan': 'orphelin',
-                            'goeswith': 'va avec', 'reparandum': 'réparation', 'punct': 'ponctuation'
-                        }
+            # Mostrar el dataframe
+            st.dataframe(pos_df)
+    
+    with col2:
+        with st.expander(t['morphological_analysis'], expanded=True):
+            morph_df = pd.DataFrame(advanced_analysis['morphological_analysis'])
+            
+            # Definir el mapeo de columnas
+            column_mapping = {
+                'text': t['word'],
+                'lemma': t['lemma'],
+                'pos': t['grammatical_category'],
+                'dep': t['dependency'],
+                'morph': t['morphology']
+            }
+            
+            # Renombrar las columnas existentes
+            morph_df = morph_df.rename(columns={col: new_name for col, new_name in column_mapping.items() if col in morph_df.columns})
+            
+            # Traducir las categorías gramaticales
+            morph_df[t['grammatical_category']] = morph_df[t['grammatical_category']].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+            
+            # Traducir las dependencias
+            dep_translations = {
+                'es': {
+                    'ROOT': 'RAÍZ', 'nsubj': 'sujeto nominal', 'obj': 'objeto', 'iobj': 'objeto indirecto',
+                    'csubj': 'sujeto clausal', 'ccomp': 'complemento clausal', 'xcomp': 'complemento clausal abierto',
+                    'obl': 'oblicuo', 'vocative': 'vocativo', 'expl': 'expletivo', 'dislocated': 'dislocado',
+                    'advcl': 'cláusula adverbial', 'advmod': 'modificador adverbial', 'discourse': 'discurso',
+                    'aux': 'auxiliar', 'cop': 'cópula', 'mark': 'marcador', 'nmod': 'modificador nominal',
+                    'appos': 'aposición', 'nummod': 'modificador numeral', 'acl': 'cláusula adjetiva',
+                    'amod': 'modificador adjetival', 'det': 'determinante', 'clf': 'clasificador',
+                    'case': 'caso', 'conj': 'conjunción', 'cc': 'coordinante', 'fixed': 'fijo',
+                    'flat': 'plano', 'compound': 'compuesto', 'list': 'lista', 'parataxis': 'parataxis',
+                    'orphan': 'huérfano', 'goeswith': 'va con', 'reparandum': 'reparación', 'punct': 'puntuación'
+                },
+                'en': {
+                    'ROOT': 'ROOT', 'nsubj': 'nominal subject', 'obj': 'object',
+                    'iobj': 'indirect object', 'csubj': 'clausal subject', 'ccomp': 'clausal complement', 'xcomp': 'open clausal complement',
+                    'obl': 'oblique', 'vocative': 'vocative', 'expl': 'expletive', 'dislocated': 'dislocated', 'advcl': 'adverbial clause modifier',
+                    'advmod': 'adverbial modifier', 'discourse': 'discourse element', 'aux': 'auxiliary', 'cop': 'copula', 'mark': 'marker',
+                    'nmod': 'nominal modifier', 'appos': 'appositional modifier', 'nummod': 'numeric modifier', 'acl': 'clausal modifier of noun',
+                    'amod': 'adjectival modifier', 'det': 'determiner', 'clf': 'classifier', 'case': 'case marking',
+                    'conj': 'conjunct', 'cc': 'coordinating conjunction', 'fixed': 'fixed multiword expression',
+                    'flat': 'flat multiword expression', 'compound': 'compound', 'list': 'list', 'parataxis': 'parataxis', 'orphan': 'orphan',
+                    'goeswith': 'goes with', 'reparandum': 'reparandum', 'punct': 'punctuation'
+                },
+                'fr': {
+                    'ROOT': 'RACINE', 'nsubj': 'sujet nominal', 'obj': 'objet', 'iobj': 'objet indirect',
+                    'csubj': 'sujet phrastique', 'ccomp': 'complément phrastique', 'xcomp': 'complément phrastique ouvert', 'obl': 'oblique',
+                    'vocative': 'vocatif', 'expl': 'explétif', 'dislocated': 'disloqué', 'advcl': 'clause adverbiale', 'advmod': 'modifieur adverbial',
+                    'discourse': 'élément de discours', 'aux': 'auxiliaire', 'cop': 'copule', 'mark': 'marqueur', 'nmod': 'modifieur nominal',
+                    'appos': 'apposition', 'nummod': 'modifieur numéral', 'acl': 'clause relative', 'amod': 'modifieur adjectival', 'det': 'déterminant',
+                    'clf': 'classificateur', 'case': 'marqueur de cas', 'conj': 'conjonction', 'cc': 'coordination', 'fixed': 'expression figée',
+                    'flat': 'construction plate', 'compound': 'composé', 'list': 'liste', 'parataxis': 'parataxe', 'orphan': 'orphelin',
+                    'goeswith': 'va avec', 'reparandum': 'réparation', 'punct': 'ponctuation'
+                }
+            }
+            morph_df[t['dependency']] = morph_df[t['dependency']].map(lambda x: dep_translations[lang_code].get(x, x))
+            
+            # Traducir la morfología
+            def translate_morph(morph_string, lang_code):
+                morph_translations = {
+                    'es': {
+                        'Gender': 'Género', 'Number': 'Número', 'Case': 'Caso', 'Definite': 'Definido',
+                        'PronType': 'Tipo de Pronombre', 'Person': 'Persona', 'Mood': 'Modo',
+                        'Tense': 'Tiempo', 'VerbForm': 'Forma Verbal', 'Voice': 'Voz',
+                        'Fem': 'Femenino', 'Masc': 'Masculino', 'Sing': 'Singular', 'Plur': 'Plural',
+                        'Ind': 'Indicativo', 'Sub': 'Subjuntivo', 'Imp': 'Imperativo', 'Inf': 'Infinitivo',
+                        'Part': 'Participio', 'Ger': 'Gerundio', 'Pres': 'Presente', 'Past': 'Pasado',
+                        'Fut': 'Futuro', 'Perf': 'Perfecto', 'Imp': 'Imperfecto'
+                    },
+                    'en': {
+                        'Gender': 'Gender', 'Number': 'Number', 'Case': 'Case', 'Definite': 'Definite', 'PronType': 'Pronoun Type', 'Person': 'Person',
+                        'Mood': 'Mood', 'Tense': 'Tense', 'VerbForm': 'Verb Form', 'Voice': 'Voice',
+                        'Fem': 'Feminine', 'Masc': 'Masculine', 'Sing': 'Singular', 'Plur': 'Plural', 'Ind': 'Indicative',
+                        'Sub': 'Subjunctive', 'Imp': 'Imperative', 'Inf': 'Infinitive', 'Part': 'Participle',
+                        'Ger': 'Gerund', 'Pres': 'Present', 'Past': 'Past', 'Fut': 'Future', 'Perf': 'Perfect', 'Imp': 'Imperfect'
+                    },
+                    'fr': {
+                        'Gender': 'Genre', 'Number': 'Nombre', 'Case': 'Cas', 'Definite': 'Défini', 'PronType': 'Type de Pronom',
+                        'Person': 'Personne', 'Mood': 'Mode', 'Tense': 'Temps', 'VerbForm': 'Forme Verbale', 'Voice': 'Voix',
+                        'Fem': 'Féminin', 'Masc': 'Masculin', 'Sing': 'Singulier', 'Plur': 'Pluriel', 'Ind': 'Indicatif',
+                        'Sub': 'Subjonctif', 'Imp': 'Impératif', 'Inf': 'Infinitif', 'Part': 'Participe',
+                        'Ger': 'Gérondif', 'Pres': 'Présent', 'Past': 'Passé', 'Fut': 'Futur', 'Perf': 'Parfait', 'Imp': 'Imparfait'
                     }
-                    morph_df[t['dependency']] = morph_df[t['dependency']].map(lambda x: dep_translations[lang_code].get(x, x))
-                    
-                    # Traducir la morfología
-                    def translate_morph(morph_string, lang_code):
-                        morph_translations = {
-                            'es': {
-                                'Gender': 'Género', 'Number': 'Número', 'Case': 'Caso', 'Definite': 'Definido',
-                                'PronType': 'Tipo de Pronombre', 'Person': 'Persona', 'Mood': 'Modo',
-                                'Tense': 'Tiempo', 'VerbForm': 'Forma Verbal', 'Voice': 'Voz',
-                                'Fem': 'Femenino', 'Masc': 'Masculino', 'Sing': 'Singular', 'Plur': 'Plural',
-                                'Ind': 'Indicativo', 'Sub': 'Subjuntivo', 'Imp': 'Imperativo', 'Inf': 'Infinitivo',
-                                'Part': 'Participio', 'Ger': 'Gerundio', 'Pres': 'Presente', 'Past': 'Pasado',
-                                'Fut': 'Futuro', 'Perf': 'Perfecto', 'Imp': 'Imperfecto'
-                            },
-                            'en': {
-                                'Gender': 'Gender', 'Number': 'Number', 'Case': 'Case', 'Definite': 'Definite', 'PronType': 'Pronoun Type', 'Person': 'Person',
-                                'Mood': 'Mood', 'Tense': 'Tense', 'VerbForm': 'Verb Form', 'Voice': 'Voice',
-                                'Fem': 'Feminine', 'Masc': 'Masculine', 'Sing': 'Singular', 'Plur': 'Plural', 'Ind': 'Indicative',
-                                'Sub': 'Subjunctive', 'Imp': 'Imperative', 'Inf': 'Infinitive', 'Part': 'Participle',
-                                'Ger': 'Gerund', 'Pres': 'Present', 'Past': 'Past', 'Fut': 'Future', 'Perf': 'Perfect', 'Imp': 'Imperfect'
-                            },
-                            'fr': {
-                                'Gender': 'Genre', 'Number': 'Nombre', 'Case': 'Cas', 'Definite': 'Défini', 'PronType': 'Type de Pronom',
-                                'Person': 'Personne', 'Mood': 'Mode', 'Tense': 'Temps', 'VerbForm': 'Forme Verbale', 'Voice': 'Voix',
-                                'Fem': 'Féminin', 'Masc': 'Masculin', 'Sing': 'Singulier', 'Plur': 'Pluriel', 'Ind': 'Indicatif',
-                                'Sub': 'Subjonctif', 'Imp': 'Impératif', 'Inf': 'Infinitif', 'Part': 'Participe',
-                                'Ger': 'Gérondif', 'Pres': 'Présent', 'Past': 'Passé', 'Fut': 'Futur', 'Perf': 'Parfait', 'Imp': 'Imparfait'
-                            }
-                        }
-                        for key, value in morph_translations[lang_code].items():
-                            morph_string = morph_string.replace(key, value)
-                        return morph_string
-                    
-                    morph_df[t['morphology']] = morph_df[t['morphology']].apply(lambda x: translate_morph(x, lang_code))
-                    
-                    # Seleccionar y ordenar las columnas a mostrar
-                    columns_to_display = [t['word'], t['lemma'], t['grammatical_category'], t['dependency'], t['morphology']]
-                    columns_to_display = [col for col in columns_to_display if col in morph_df.columns]
-                    
-                    # Mostrar el DataFrame
-                    st.dataframe(morph_df[columns_to_display])
-                    
-        # Mostrar diagramas de arco (código existente)
-        with st.expander(t['arc_diagram'], expanded=True):
-            sentences = list(doc.sents)
-            arc_diagrams = []
-            for i, sent in enumerate(sentences):
-                st.subheader(f"{t['sentence']} {i+1}")
-                html = displacy.render(sent, style="dep", options={"distance": 100})
-                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)
-                st.write(html, unsafe_allow_html=True)
-                arc_diagrams.append(html)
+                }
+                for key, value in morph_translations[lang_code].items():
+                    morph_string = morph_string.replace(key, value)
+                return morph_string
             
-        # Guardar resultados
-        if store_morphosyntax_result(
-            st.session_state.username,
-            current_input,
-            word_colors,
-            advanced_analysis['arc_diagram'],
-            advanced_analysis['pos_analysis'],
-            advanced_analysis['morphological_analysis'],
-            advanced_analysis['sentence_structure']
-                
-        ):
-            st.success(t['success_message'])
-        else:
-            st.error(t['error_message'])
-    else:
-        st.warning(t['warning_message'])
+            morph_df[t['morphology']] = morph_df[t['morphology']].apply(lambda x: translate_morph(x, lang_code))
+            
+            # Seleccionar y ordenar las columnas a mostrar
+            columns_to_display = [t['word'], t['lemma'], t['grammatical_category'], t['dependency'], t['morphology']]
+            columns_to_display = [col for col in columns_to_display if col in morph_df.columns]
+            
+            # Mostrar el DataFrame
+            st.dataframe(morph_df[columns_to_display])
+            
+    # Mostrar diagramas de arco (código existente)
+    with st.expander(t['arc_diagram'], expanded=True):
+        sentences = list(doc.sents)
+        arc_diagrams = []
+        for i, sent in enumerate(sentences):
+            st.subheader(f"{t['sentence']} {i+1}")
+            html = displacy.render(sent, style="dep", options={"distance": 100})
+            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)
+            st.write(html, unsafe_allow_html=True)
+            arc_diagrams.append(html)
 
 ###############################################################################################################
 def display_semantic_analysis_interface(nlp_models, lang_code):
@@ -770,7 +798,9 @@ def display_semantic_analysis_interface(nlp_models, lang_code):
             'key_concepts': "Conceptos Clave",
             'success_message': "Análisis semántico guardado correctamente.",
             'error_message': "Hubo un problema al guardar el análisis semántico. Por favor, inténtelo de nuevo.",
-            'warning_message': "Por favor, ingrese un texto o cargue un archivo para analizar."
+            'warning_message': "Por favor, ingrese un texto o cargue un archivo para analizar.",
+            'initial_message': "Ingrese un texto y presione 'Analizar texto' para comenzar.",
+            'no_results': "No hay resultados disponibles. Por favor, realice un análisis primero."
         },
         'en': {
             'title': "AIdeaText - Semantic Analysis",
@@ -783,7 +813,9 @@ def display_semantic_analysis_interface(nlp_models, lang_code):
             'key_concepts': "Key Concepts",
             'success_message': "Semantic analysis saved successfully.",
             'error_message': "There was a problem saving the semantic analysis. Please try again.",
-            'warning_message': "Please enter a text or upload a file to analyze."
+            'warning_message': "Please enter a text or upload a file to analyze.",
+            'initial_message': "Enter a text and press 'Analyze text' to start.",
+            'no_results': "No results available. Please perform an analysis first."
         },
         'fr': {
             'title': "AIdeaText - Analyse sémantique",
@@ -796,7 +828,9 @@ def display_semantic_analysis_interface(nlp_models, lang_code):
             'key_concepts': "Concepts Clés",
             'success_message': "Analyse sémantique enregistrée avec succès.",
             'error_message': "Un problème est survenu lors de l'enregistrement de l'analyse sémantique. Veuillez réessayer.",
-            'warning_message': "Veuillez entrer un texte ou télécharger un fichier à analyser."
+            'warning_message': "Veuillez entrer un texte ou télécharger un fichier à analyser.",
+            'initial_message': "Entrez un texte et appuyez sur 'Analyser le texte' pour commencer.",
+            'no_results': "Aucun résultat disponible. Veuillez d'abord effectuer une analyse."
         }
     }
 
@@ -824,14 +858,11 @@ def display_semantic_analysis_interface(nlp_models, lang_code):
             # Realizar el análisis
             analysis_result = perform_semantic_analysis(text_content, nlp_models[lang_code], lang_code)
 
-            # Mostrar conceptos clave
-            with st.expander(t['key_concepts'], expanded=True):
-                concept_text = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis_result['key_concepts']])
-                st.write(concept_text)
+            # Guardar el resultado en el estado de la sesión
+            st.session_state.semantic_result = analysis_result
 
-            # Mostrar el gráfico de relaciones conceptuales
-            with st.expander(t['conceptual_relations'], expanded=True):
-                st.pyplot(analysis_result['relations_graph'])
+            # Mostrar resultados
+            display_semantic_results(st.session_state.semantic_result, lang_code, t)           
 
             # Guardar el resultado del análisis
             if store_semantic_result(st.session_state.username, text_content, analysis_result):
@@ -840,6 +871,29 @@ def display_semantic_analysis_interface(nlp_models, lang_code):
                 st.error(t['error_message'])
         else:
             st.warning(t['warning_message'])
+
+    elif 'semantic_result' in st.session_state:
+
+        # Si hay un resultado guardado, mostrarlo
+        display_semantic_results(st.session_state.semantic_result, lang_code, t)
+    
+    else:
+        st.info(t['initial_message'])  # Asegúrate de que 'initial_message' esté en tus traducciones
+            
+def display_semantic_results(result, lang_code, t):
+    if result is None:
+        st.warning(t['no_results'])  # Asegúrate de que 'no_results' esté en tus traducciones
+        return
+
+    # Mostrar conceptos clave
+    with st.expander(t['key_concepts'], expanded=True):
+        concept_text = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in result['key_concepts']])
+        st.write(concept_text)
+
+    # Mostrar el gráfico de relaciones conceptuales
+    with st.expander(t['conceptual_relations'], expanded=True):
+        st.pyplot(result['relations_graph'])
+
 ##################################################################################################
 def display_discourse_analysis_interface(nlp_models, lang_code):
     translations = {
@@ -851,7 +905,13 @@ def display_discourse_analysis_interface(nlp_models, lang_code):
             'comparison': "Comparación de Relaciones Semánticas",
             'success_message': "Análisis del discurso guardado correctamente.",
             'error_message': "Hubo un problema al guardar el análisis del discurso. Por favor, inténtelo de nuevo.",
-            'warning_message': "Por favor, cargue ambos archivos para analizar."
+            'warning_message': "Por favor, cargue ambos archivos para analizar.",
+            'initial_message': "Ingrese un texto y presione 'Analizar texto' para comenzar.",
+            'no_results': "No hay resultados disponibles. Por favor, realice un análisis primero.",
+            'key_concepts': "Conceptos Clave",
+            'graph_not_available': "El gráfico no está disponible.",
+            'concepts_not_available': "Los conceptos clave no están disponibles.",
+            'comparison_not_available': "La comparación no está disponible."
         },
         'en': {
             'title': "AIdeaText - Discourse Analysis",
@@ -861,7 +921,13 @@ def display_discourse_analysis_interface(nlp_models, lang_code):
             'comparison': "Comparison of Semantic Relations",
             'success_message': "Discourse analysis saved successfully.",
             'error_message': "There was a problem saving the discourse analysis. Please try again.",
-            'warning_message': "Please upload both files to analyze."
+            'warning_message': "Please upload both files to analyze.",
+            'initial_message': "Enter a text and press 'Analyze text' to start.",
+            'no_results': "No results available. Please perform an analysis first.",
+            'key_concepts': "Key Concepts",
+            'graph_not_available': "The graph is not available.",
+            'concepts_not_available': "Key concepts are not available.",
+            'comparison_not_available': "The comparison is not available."
         },
         'fr': {
             'title': "AIdeaText - Analyse du discours",
@@ -871,7 +937,13 @@ def display_discourse_analysis_interface(nlp_models, lang_code):
             'comparison': "Comparaison des Relations Sémantiques",
             'success_message': "Analyse du discours enregistrée avec succès.",
             'error_message': "Un problème est survenu lors de l'enregistrement de l'analyse du discours. Veuillez réessayer.",
-            'warning_message': "Veuillez télécharger les deux fichiers à analyser."
+            'warning_message': "Veuillez télécharger les deux fichiers à analyser.",
+            'initial_message': "Entrez un texte et appuyez sur 'Analyser le texte' pour commencer.",
+            'no_results': "Aucun résultat disponible. Veuillez d'abord effectuer une analyse.",
+            'key_concepts': "Concepts Clés",
+            'graph_not_available': "Le graphique n'est pas disponible.",
+            'concepts_not_available': "Les concepts clés ne sont pas disponibles.",
+            'comparison_not_available': "La comparaison n'est pas disponible."
         }
     }
 
@@ -879,10 +951,8 @@ def display_discourse_analysis_interface(nlp_models, lang_code):
     st.header(t['title'])
 
     col1, col2 = st.columns(2)
-
     with col1:
         uploaded_file1 = st.file_uploader(t['file_uploader1'], type=['txt'])
-
     with col2:
         uploaded_file2 = st.file_uploader(t['file_uploader2'], type=['txt'])
 
@@ -894,8 +964,11 @@ def display_discourse_analysis_interface(nlp_models, lang_code):
             # Realizar el análisis
             analysis_result = perform_discourse_analysis(text_content1, text_content2, nlp_models[lang_code], lang_code)
 
+            # Guardar el resultado en el estado de la sesión
+            st.session_state.discourse_result = analysis_result
+
             # Mostrar los resultados del análisis
-            display_discourse_analysis_results(analysis_result, lang_code)
+            display_discourse_results(st.session_state.discourse_result, lang_code, t)
 
             # Guardar el resultado del análisis
             if store_discourse_analysis_result(st.session_state.username, text_content1, text_content2, analysis_result):
@@ -904,6 +977,93 @@ def display_discourse_analysis_interface(nlp_models, lang_code):
                 st.error(t['error_message'])
         else:
             st.warning(t['warning_message'])
+    elif 'discourse_result' in st.session_state and st.session_state.discourse_result is not None:
+        # Si hay un resultado guardado, mostrarlo
+        display_discourse_results(st.session_state.discourse_result, lang_code, t)
+    else:
+        st.info(t['initial_message'])  # Asegúrate de que 'initial_message' esté en tus traducciones
+
+#################################################
+
+def display_discourse_results(result, lang_code, t):
+    if result is None:
+        st.warning(t.get('no_results', "No hay resultados disponibles."))
+        return
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        with st.expander(t.get('file_uploader1', "Documento 1"), expanded=True):
+            st.subheader(t.get('key_concepts', "Conceptos Clave"))
+            if 'key_concepts1' in result:
+                df1 = pd.DataFrame(result['key_concepts1'], columns=['Concepto', 'Frecuencia'])
+                df1['Frecuencia'] = df1['Frecuencia'].round(2)
+                st.table(df1)
+            else:
+                st.warning(t.get('concepts_not_available', "Los conceptos clave no están disponibles."))
+            
+            if 'graph1' in result:
+                st.pyplot(result['graph1'])
+            else:
+                st.warning(t.get('graph_not_available', "El gráfico no está disponible."))
+
+    with col2:
+        with st.expander(t.get('file_uploader2', "Documento 2"), expanded=True):
+            st.subheader(t.get('key_concepts', "Conceptos Clave"))
+            if 'key_concepts2' in result:
+                df2 = pd.DataFrame(result['key_concepts2'], columns=['Concepto', 'Frecuencia'])
+                df2['Frecuencia'] = df2['Frecuencia'].round(2)
+                st.table(df2)
+            else:
+                st.warning(t.get('concepts_not_available', "Los conceptos clave no están disponibles."))
+            
+            if 'graph2' in result:
+                st.pyplot(result['graph2'])
+            else:
+                st.warning(t.get('graph_not_available', "El gráfico no está disponible."))
+
+    # Relación de conceptos entre ambos documentos (Diagrama de Sankey)
+    st.subheader(t.get('comparison', "Relación de conceptos entre ambos documentos"))
+    if 'key_concepts1' in result and 'key_concepts2' in result:
+        df1 = pd.DataFrame(result['key_concepts1'], columns=['Concepto', 'Frecuencia'])
+        df2 = pd.DataFrame(result['key_concepts2'], columns=['Concepto', 'Frecuencia'])
+
+        # Crear una lista de todos los conceptos únicos
+        all_concepts = list(set(df1['Concepto'].tolist() + df2['Concepto'].tolist()))
+
+        # Crear un diccionario de colores para cada concepto
+        color_scale = [f'rgb({random.randint(50,255)},{random.randint(50,255)},{random.randint(50,255)})' for _ in range(len(all_concepts))]
+        color_map = dict(zip(all_concepts, color_scale))
+
+        # Crear el diagrama de Sankey
+        source = [0] * len(df1) + list(range(2, 2 + len(df1)))
+        target = list(range(2, 2 + len(df1))) + [1] * len(df2)
+        value = list(df1['Frecuencia']) + list(df2['Frecuencia'])
+        
+        node_colors = ['blue', 'red'] + [color_map[concept] for concept in df1['Concepto']] + [color_map[concept] for concept in df2['Concepto']]
+        link_colors = [color_map[concept] for concept in df1['Concepto']] + [color_map[concept] for concept in df2['Concepto']]
+
+        fig = go.Figure(data=[go.Sankey(
+            node = dict(
+              pad = 15,
+              thickness = 20,
+              line = dict(color = "black", width = 0.5),
+              label = [t.get('file_uploader1', "Documento 1"), t.get('file_uploader2', "Documento 2")] + list(df1['Concepto']) + list(df2['Concepto']),
+              color = node_colors
+            ),
+            link = dict(
+              source = source,
+              target = target,
+              value = value,
+              color = link_colors
+          ))])
+
+        fig.update_layout(title_text="Relación de conceptos entre documentos", font_size=10)
+        st.plotly_chart(fig, use_container_width=True)
+    else:
+        st.warning(t.get('comparison_not_available', "La comparación no está disponible."))
+
+    # Aquí puedes agregar el código para mostrar los gráficos si es necesario
 
 ##################################################################################################
 #def display_saved_discourse_analysis(analysis_data):

modules/ui/ui_rest1.py

@@ -0,0 +1,1145 @@
+# Importaciones generales
+import streamlit as st
+import re
+import io
+from io import BytesIO
+import base64
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+import time
+from datetime import datetime
+from streamlit_player import st_player  # Necesitarás instalar esta librería: pip install streamlit-player
+from spacy import displacy
+import logging
+
+######################################################
+# Configuración del logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+######################################################
+# Importaciones locales
+from ..email.email import send_email_notification
+
+######################################################
+# Importaciones locales de autenticación y base de datos
+from ..auth.auth import (
+    authenticate_user,
+    register_user
+)
+
+######################################################
+from ..database.database import (
+    get_student_data,
+    store_application_request,
+    store_morphosyntax_result,
+    store_semantic_result,
+    store_discourse_analysis_result,
+    store_chat_history,
+    create_admin_user,
+    create_student_user,
+    store_user_feedback
+)
+
+######################################################
+# Importaciones locales de uiadmin
+from ..admin.admin_ui import admin_page
+
+######################################################
+# Importaciones locales funciones de análisis
+from ..text_analysis.morpho_analysis import (
+    generate_arc_diagram,
+    get_repeated_words_colors,
+    highlight_repeated_words,
+    POS_COLORS,
+    POS_TRANSLATIONS, 
+    perform_advanced_morphosyntactic_analysis
+)
+
+######################################################
+from ..text_analysis.semantic_analysis import (
+    #visualize_semantic_relations,
+    perform_semantic_analysis, 
+    create_concept_graph, 
+    visualize_concept_graph
+)
+
+######################################################
+from ..text_analysis.discourse_analysis import (
+    perform_discourse_analysis, 
+    display_discourse_analysis_results
+)
+
+######################################################
+from ..chatbot.chatbot import (
+    initialize_chatbot,
+    get_chatbot_response
+)
+
+##################################################################################################
+def initialize_session_state():
+    if 'initialized' not in st.session_state:
+        st.session_state.clear()
+        st.session_state.initialized = True
+        st.session_state.logged_in = False
+        st.session_state.page = 'login'
+        st.session_state.username = None
+        st.session_state.role = None
+
+##################################################################################################
+def main():
+    initialize_session_state()
+    
+    print(f"Página actual: {st.session_state.page}")
+    print(f"Rol del usuario: {st.session_state.role}")
+    
+    if st.session_state.page == 'login':
+        login_register_page()
+    elif st.session_state.page == 'admin':
+        print("Intentando mostrar página de admin")
+        admin_page()
+    elif st.session_state.page == 'user':
+        user_page()
+    else:
+        print(f"Página no reconocida: {st.session_state.page}")
+    
+    print(f"Estado final de la sesión: {st.session_state}")
+
+##################################################################################################
+def login_register_page():
+    st.title("AIdeaText")
+
+    left_column, right_column = st.columns([1, 3])
+
+    with left_column:
+        tab1, tab2 = st.tabs(["Iniciar Sesión", "Registrarse"])
+        
+        with tab1:
+            login_form()
+        
+        with tab2:
+            register_form()
+
+    with right_column:
+        display_videos_and_info()
+
+##################################################################################################
+
+def login_form():
+    username = st.text_input("Correo electrónico", key="login_username")
+    password = st.text_input("Contraseña", type="password", key="login_password")
+    
+    if st.button("Iniciar Sesión", key="login_button"):
+        success, role = authenticate_user(username, password)
+        if success:
+            st.session_state.logged_in = True
+            st.session_state.username = username
+            st.session_state.role = role
+            st.session_state.page = 'admin' if role == 'Administrador' else 'user'
+            print(f"Inicio de sesión exitoso. Usuario: {username}, Rol: {role}")
+            print(f"Estado de sesión después de login: {st.session_state}")
+            st.rerun()
+        else:
+            st.error("Credenciales incorrectas")
+
+##################################################################################################
+def admin_page():
+    st.title("Panel de Administración")
+    st.write(f"Bienvenida, {st.session_state.username}")
+    
+    st.header("Crear Nuevo Usuario Estudiante")
+    new_username = st.text_input("Correo electrónico del nuevo usuario", key="admin_new_username")
+    new_password = st.text_input("Contraseña", type="password", key="admin_new_password")
+    if st.button("Crear Usuario", key="admin_create_user"):
+        if create_student_user(new_username, new_password):
+            st.success(f"Usuario estudiante {new_username} creado exitosamente")
+        else:
+            st.error("Error al crear el usuario estudiante")
+
+    # Aquí puedes añadir más funcionalidades para el panel de administración
+
+##################################################################################################
+def user_page():
+    # Asumimos que el idioma seleccionado está almacenado en st.session_state.lang_code
+    # Si no está definido, usamos 'es' como valor predeterminado
+    lang_code = st.session_state.get('lang_code', 'es')
+
+    translations = {
+        'es': {
+            'welcome': "Bienvenido a AIdeaText",
+            'hello': "Hola",
+            'tabs': ["Análisis Morfosintáctico", "Análisis Semántico", "Análisis del Discurso", "Chat", "Mi Progreso", "Formulario de Retroalimentación"]        
+        },
+        'en': {
+            'welcome': "Welcome to AIdeaText",
+            'hello': "Hello",
+            'tabs': ["Morphosyntactic Analysis", "Semantic Analysis", "Discourse Analysis", "Chat", "My Progress", "Feedback Form"]
+        },
+        'fr': {
+            'welcome': "Bienvenue à AIdeaText",
+            'hello': "Bonjour",
+            'tabs': ["Analyse Morphosyntaxique", "Analyse Sémantique", "Analyse du Discours", "Chat", "Mon Progrès", "Formulaire de Rétroaction"]
+        }
+    }
+
+    t = translations[lang_code]
+
+    st.title(t['welcome'])
+    st.write(f"{t['hello']}, {st.session_state.username}")
+
+    tabs = st.tabs(t['tabs'])
+
+    with tabs[0]:
+        display_morphosyntax_analysis_interface(nlp_models, lang_code)
+    with tabs[1]:
+        display_semantic_analysis_interface(nlp_models, lang_code)
+    with tabs[2]:
+        display_discourse_analysis_interface(nlp_models, lang_code)
+    with tabs[3]:
+        display_chatbot_interface(lang_code)
+    with tabs[4]:
+        display_student_progress(st.session_state.username, lang_code)
+    with tabs[5]:
+        display_feedback_form(lang_code)
+
+##################################################################################################
+def display_videos_and_info():
+    st.header("Videos: pitch, demos, entrevistas, otros")
+    
+    videos = {
+        "Intro AideaText": "https://www.youtube.com/watch?v=UA-md1VxaRc",
+        "Presentación fundación Ser Maaestro": "https://www.youtube.com/watch?v=imc4TI1q164",
+        "Pitch IFE Explora": "https://www.youtube.com/watch?v=Fqi4Di_Rj_s",
+        "Entrevista Dr. Guillermo Ruíz": "https://www.youtube.com/watch?v=_ch8cRja3oc",
+        "Demo versión desktop": "https://www.youtube.com/watch?v=nP6eXbog-ZY"
+    }
+    
+    selected_title = st.selectbox("Selecciona un video tutorial:", list(videos.keys()))
+    
+    if selected_title in videos:
+        try:
+            st_player(videos[selected_title])
+        except Exception as e:
+            st.error(f"Error al cargar el video: {str(e)}")
+    
+    st.markdown("""
+    ## Novedades de la versión actual
+    - Nueva función de análisis semántico
+    - Soporte para múltiples idiomas
+    - Interfaz mejorada para una mejor experiencia de usuario
+    """)
+
+##################################################################################################
+def register_form():
+    st.header("Solicitar prueba de la aplicación")
+    
+    name = st.text_input("Nombre completo")
+    email = st.text_input("Correo electrónico institucional")
+    institution = st.text_input("Institución")
+    role = st.selectbox("Rol", ["Estudiante", "Profesor", "Investigador", "Otro"])
+    reason = st.text_area("¿Por qué estás interesado en probar AIdeaText?")
+    
+    if st.button("Enviar solicitud"):
+        logger.info(f"Attempting to submit application for {email}")
+        logger.debug(f"Form data: name={name}, email={email}, institution={institution}, role={role}, reason={reason}")
+        
+        if not name or not email or not institution or not reason:
+            logger.warning("Incomplete form submission")
+            st.error("Por favor, completa todos los campos.")
+        elif not is_institutional_email(email):
+            logger.warning(f"Non-institutional email used: {email}")
+            st.error("Por favor, utiliza un correo electrónico institucional.")
+        else:
+            logger.info(f"Attempting to store application for {email}")
+            success = store_application_request(name, email, institution, role, reason)
+            if success:
+                st.success("Tu solicitud ha sido enviada. Te contactaremos pronto.")
+                logger.info(f"Application request stored successfully for {email}")
+            else:
+                st.error("Hubo un problema al enviar tu solicitud. Por favor, intenta de nuevo más tarde.")
+                logger.error(f"Failed to store application request for {email}")
+
+################################################################################
+def display_feedback_form(lang_code):
+    logging.info(f"display_feedback_form called with lang_code: {lang_code}")
+    translations = {
+        'es': {
+            'title': "Formulario de Retroalimentación",
+            'name': "Nombre",
+            'email': "Correo electrónico",
+            'feedback': "Tu retroalimentación",
+            'submit': "Enviar",
+            'success': "¡Gracias por tu retroalimentación!",
+            'error': "Hubo un problema al enviar el formulario. Por favor, intenta de nuevo."
+        },
+        'en': {
+            'title': "Feedback Form",
+            'name': "Name",
+            'email': "Email",
+            'feedback': "Your feedback",
+            'submit': "Submit",
+            'success': "Thank you for your feedback!",
+            'error': "There was a problem submitting the form. Please try again."
+        },
+        'fr': {
+            'title': "Formulaire de Rétroaction",
+            'name': "Nom",
+            'email': "Adresse e-mail",
+            'feedback': "Votre rétroaction",
+            'submit': "Envoyer",
+            'success': "Merci pour votre rétroaction !",
+            'error': "Un problème est survenu lors de l'envoi du formulaire. Veuillez réessayer."
+        }
+    }
+
+    t = translations[lang_code]
+
+    st.header(t['title'])
+    
+    name = st.text_input(t['name'])
+    email = st.text_input(t['email'])
+    feedback = st.text_area(t['feedback'])
+
+    if st.button(t['submit']):
+        if name and email and feedback:
+            if store_user_feedback(st.session_state.username, name, email, feedback):
+                st.success(t['success'])
+            else:
+                st.error(t['error'])
+        else:
+            st.warning("Por favor, completa todos los campos.")
+
+################################################################################
+def is_institutional_email(email):
+    forbidden_domains = ['gmail.com', 'hotmail.com', 'yahoo.com', 'outlook.com']
+    return not any(domain in email.lower() for domain in forbidden_domains)
+################################################################################
+
+def display_student_progress(username, lang_code='es'):
+    student_data = get_student_data(username)
+    
+    if student_data is None or len(student_data['entries']) == 0:
+        st.warning("No se encontraron datos para este estudiante.")
+        st.info("Intenta realizar algunos análisis de texto primero.")
+        return
+
+    st.title(f"Progreso de {username}")
+
+    with st.expander("Resumen de Actividades y Progreso", expanded=True):
+        # Resumen de actividades
+        total_entries = len(student_data['entries'])
+        st.write(f"Total de análisis realizados: {total_entries}")
+
+        # Gráfico de tipos de análisis
+        analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
+        analysis_counts = pd.Series(analysis_types).value_counts()
+        
+        fig, ax = plt.subplots()
+        analysis_counts.plot(kind='bar', ax=ax)
+        ax.set_title("Tipos de análisis realizados")
+        ax.set_xlabel("Tipo de análisis")
+        ax.set_ylabel("Cantidad")
+        st.pyplot(fig)
+
+        # Progreso a lo largo del tiempo
+        dates = [datetime.fromisoformat(entry['timestamp']) for entry in student_data['entries']]
+        analysis_counts = pd.Series(dates).value_counts().sort_index()
+        
+        fig, ax = plt.subplots()
+        analysis_counts.plot(kind='line', ax=ax)
+        ax.set_title("Análisis realizados a lo largo del tiempo")
+        ax.set_xlabel("Fecha")
+        ax.set_ylabel("Cantidad de análisis")
+        st.pyplot(fig)
+        
+##########################################################
+    with st.expander("Histórico de Análisis Morfosintácticos"):
+        morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
+        for entry in morphosyntax_entries:
+            st.subheader(f"Análisis del {entry['timestamp']}")
+            if entry['arc_diagrams']:
+                st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
+
+
+  ##########################################################  
+    with st.expander("Histórico de Análisis Semánticos"):
+        semantic_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
+        st.write(f"Número total de entradas semánticas: {len(semantic_entries)}")
+        for entry in semantic_entries:
+            st.subheader(f"Análisis del {entry['timestamp']}")
+            st.write(f"Archivo analizado: {entry.get('filename', 'Nombre no disponible')}")
+            st.write(f"Claves disponibles en esta entrada: {', '.join(entry.keys())}")
+            
+            # Verificar si 'relations_graph' está en entry antes de intentar acceder
+            if 'network_diagram' in entry:
+                try:
+                    logger.info(f"Longitud de la imagen recuperada: {len(entry['network_diagram'])}")
+                    st.image(f"data:image/png;base64,{entry['network_diagram']}")
+                except Exception as e:
+                    st.error(f"No se pudo mostrar la imagen: {str(e)}")
+                    st.write("Datos de la imagen (para depuración):")
+                    st.write(entry['network_diagram'][:100] + "...")
+            else:
+                logger.warning(f"No se encontró 'relations_graph' en la entrada: {entry.keys()}")
+                st.write("No se encontró el gráfico para este análisis.")
+                        
+##########################################################
+    with st.expander("Histórico de Análisis Discursivos"):
+        discourse_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
+        for entry in discourse_entries:
+            st.subheader(f"Análisis del {entry['timestamp']}")
+            st.write(f"Archivo patrón: {entry.get('filename1', 'Nombre no disponible')}")
+            st.write(f"Archivo comparado: {entry.get('filename2', 'Nombre no disponible')}")
+            
+            try:
+                # Intentar obtener y combinar las dos imágenes
+                if 'graph1' in entry and 'graph2' in entry:
+                    img1 = Image.open(BytesIO(base64.b64decode(entry['graph1'])))
+                    img2 = Image.open(BytesIO(base64.b64decode(entry['graph2'])))
+                    
+                    # Crear una nueva imagen combinada
+                    total_width = img1.width + img2.width
+                    max_height = max(img1.height, img2.height)
+                    combined_img = Image.new('RGB', (total_width, max_height))
+                    
+                    # Pegar las dos imágenes lado a lado
+                    combined_img.paste(img1, (0, 0))
+                    combined_img.paste(img2, (img1.width, 0))
+                    
+                    # Convertir la imagen combinada a bytes
+                    buffered = BytesIO()
+                    combined_img.save(buffered, format="PNG")
+                    img_str = base64.b64encode(buffered.getvalue()).decode()
+                    
+                    # Mostrar la imagen combinada
+                    st.image(f"data:image/png;base64,{img_str}")
+                elif 'combined_graph' in entry:
+                    # Si ya existe una imagen combinada, mostrarla directamente
+                    img_bytes = base64.b64decode(entry['combined_graph'])
+                    st.image(img_bytes)
+                else:
+                    st.write("No se encontraron gráficos para este análisis.")
+            except Exception as e:
+                st.error(f"No se pudieron mostrar los gráficos: {str(e)}")
+                st.write("Datos de los gráficos (para depuración):")
+                if 'graph1' in entry:
+                    st.write("Graph 1:", entry['graph1'][:100] + "...")
+                if 'graph2' in entry:
+                    st.write("Graph 2:", entry['graph2'][:100] + "...")
+                if 'combined_graph' in entry:
+                    st.write("Combined Graph:", entry['combined_graph'][:100] + "...")
+
+                    
+##########################################################
+    with st.expander("Histórico de Conversaciones con el ChatBot"):
+        if 'chat_history' in student_data:
+            for i, chat in enumerate(student_data['chat_history']):
+                st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
+                for message in chat['messages']:
+                    if message['role'] == 'user':
+                        st.write("Usuario: " + message['content'])
+                    else:
+                        st.write("Asistente: " + message['content'])
+                st.write("---")
+        else:
+            st.write("No se encontraron conversaciones con el ChatBot.")
+
+    # Añadir logs para depuración
+    if st.checkbox("Mostrar datos de depuración"):
+        st.write("Datos del estudiante (para depuración):")
+        st.json(student_data)
+
+##################################################################################################
+def display_morphosyntax_analysis_interface(nlp_models, lang_code):
+    translations = {
+        'es': {
+            'title': "AIdeaText - Análisis morfológico y sintáctico",
+            'input_label': "Ingrese un texto para analizar (máximo 5,000 palabras",
+            'input_placeholder': "Esta funcionalidad le ayudará con dos competencias:\n" 
+                                 "[1] \"Escribe diversos tipos de textos en su lengua materna\"\n"
+                                 "[2] \"Lee diversos tipos de textos escritos en su lengua materna\"\n\n"
+                                 "Ingrese su texto aquí para analizar...",
+            'analyze_button': "Analizar texto",
+            'repeated_words': "Palabras repetidas",
+            'legend': "Leyenda: Categorías gramaticales",
+            'arc_diagram': "An��lisis sintáctico: Diagrama de arco",
+            'sentence': "Oración",
+            'success_message': "Análisis guardado correctamente.",
+            'error_message': "Hubo un problema al guardar el análisis. Por favor, inténtelo de nuevo.",
+            'warning_message': "Por favor, ingrese un texto para analizar.",
+            'initial_message': "Ingrese un texto y presione 'Analizar texto' para comenzar.",
+            'no_results': "No hay resultados disponibles. Por favor, realice un análisis primero.",
+            'pos_analysis': "Análisis de categorías gramaticales",
+            'morphological_analysis': "Análisis morfológico",
+            'sentence_structure': "Estructura de oraciones",
+            'word': "Palabra",
+            'count': "Cantidad",
+            'percentage': "Porcentaje",
+            'examples': "Ejemplos",
+            'lemma': "Lema",
+            'tag': "Etiqueta",
+            'dep': "Dependencia",
+            'morph': "Morfología",
+            'root': "Raíz",
+            'subjects': "Sujetos",
+            'objects': "Objetos",
+            'verbs': "Verbos",
+            'grammatical_category': "Categoría gramatical",
+            'dependency': "Dependencia",
+            'morphology': "Morfología"
+        },
+        'en': {
+            'title': "AIdeaText - Morphological and Syntactic Analysis",
+            'input_label': "Enter a text to analyze (max 5,000 words):",
+            'input_placeholder': "This functionality will help you with two competencies:\n"
+                             "[1] \"Write various types of texts in your native language\"\n"
+                             "[2] \"Read various types of written texts in your native language\"\n\n"
+                             "Enter your text here to analyze...",
+            'analyze_button': "Analyze text",
+            'repeated_words': "Repeated words",
+            'legend': "Legend: Grammatical categories",
+            'arc_diagram': "Syntactic analysis: Arc diagram",
+            'sentence': "Sentence",
+            'success_message': "Analysis saved successfully.",
+            'error_message': "There was a problem saving the analysis. Please try again.",
+            'warning_message': "Please enter a text to analyze.",
+            'initial_message': "Enter a text and press 'Analyze text' to start.",
+            'no_results': "No results available. Please perform an analysis first.",
+            'pos_analysis': "Part of Speech Analysis",
+            'morphological_analysis': "Morphological Analysis",
+            'sentence_structure': "Sentence Structure",
+            'word': "Word",
+            'count': "Count",
+            'percentage': "Percentage",
+            'examples': "Examples",
+            'lemma': "Lemma",
+            'tag': "Tag",
+            'dep': "Dependency",
+            'morph': "Morphology",
+            'root': "Root",
+            'subjects': "Subjects",
+            'objects': "Objects",
+            'verbs': "Verbs", 
+            'grammatical_category': "Grammatical category",
+            'dependency': "Dependency",
+            'morphology': "Morphology"
+        },
+        'fr': {
+            'title': "AIdeaText - Analyse morphologique et syntaxique",
+            'input_label': "Entrez un texte à analyser (max 5 000 mots) :",
+            'input_placeholder': "Cette fonctionnalité vous aidera avec deux compétences :\n"
+                             "[1] \"Écrire divers types de textes dans votre langue maternelle\"\n"
+                             "[2] \"Lire divers types de textes écrits dans votre langue maternelle\"\n\n"
+                             "Entrez votre texte ici pour l'analyser...",
+            'analyze_button': "Analyser le texte",
+            'repeated_words': "Mots répétés",
+            'legend': "Légende : Catégories grammaticales",
+            'arc_diagram': "Analyse syntaxique : Diagramme en arc",
+            'sentence': "Phrase",
+            'success_message': "Analyse enregistrée avec succès.",
+            'error_message': "Un problème est survenu lors de l'enregistrement de l'analyse. Veuillez réessayer.",
+            'warning_message': "Veuillez entrer un texte à analyser.",
+            'initial_message': "Entrez un texte et appuyez sur 'Analyser le texte' pour commencer.",
+            'no_results': "Aucun résultat disponible. Veuillez d'abord effectuer une analyse.",
+            'pos_analysis': "Analyse des parties du discours",
+            'morphological_analysis': "Analyse morphologique",
+            'sentence_structure': "Structure des phrases",
+            'word': "Mot",
+            'count': "Nombre",
+            'percentage': "Pourcentage",
+            'examples': "Exemples",
+            'lemma': "Lemme",
+            'tag': "Étiquette",
+            'dep': "Dépendance",
+            'morph': "Morphologie",
+            'root': "Racine",
+            'subjects': "Sujets",
+            'objects': "Objets",
+            'verbs': "Verbes",
+            'grammatical_category': "Catégorie grammaticale",
+            'dependency': "Dépendance",
+            'morphology': "Morphologie"
+        }
+    }
+
+    t = translations[lang_code]
+
+    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(
+        t['input_label'],
+        height=150,
+        placeholder=t['input_placeholder'],
+        value=st.session_state[input_key],
+        key=f"text_area_{lang_code}",
+        on_change=lambda: setattr(st.session_state, input_key, st.session_state[f"text_area_{lang_code}"])
+    )
+
+    if st.button(t['analyze_button'], key=f"analyze_button_{lang_code}"):
+        current_input = st.session_state[input_key]
+        if current_input:
+            doc = nlp_models[lang_code](current_input)
+
+            # Análisis morfosintáctico avanzado
+            advanced_analysis = perform_advanced_morphosyntactic_analysis(current_input, nlp_models[lang_code])    
+
+            # Guardar el resultado en el estado de la sesión
+            st.session_state.morphosyntax_result = {
+                'doc': doc,
+                'advanced_analysis': advanced_analysis
+            }
+
+            # Mostrar resultados
+            display_morphosyntax_results(st.session_state.morphosyntax_result, lang_code, t)
+
+            # Guardar resultados
+            if store_morphosyntax_result(
+                st.session_state.username,
+                current_input,
+                get_repeated_words_colors(doc),
+                advanced_analysis['arc_diagram'],
+                advanced_analysis['pos_analysis'],
+                advanced_analysis['morphological_analysis'],
+                advanced_analysis['sentence_structure']
+            ):
+                st.success(t['success_message'])
+            else:
+                st.error(t['error_message'])
+        else:
+            st.warning(t['warning_message'])
+    elif 'morphosyntax_result' in st.session_state and st.session_state.morphosyntax_result is not None:
+        
+        # Si hay un resultado guardado, mostrarlo
+        display_morphosyntax_results(st.session_state.morphosyntax_result, lang_code, t)
+    else:
+        st.info(t['initial_message'])  # Añade esta traducción a tu diccionario            
+
+def display_morphosyntax_results(result, lang_code, t):
+    if result is None:
+        st.warning(t['no_results'])  # Añade esta traducción a tu diccionario
+        return
+
+    doc = result['doc']
+    advanced_analysis = result['advanced_analysis']
+    
+    # Mostrar leyenda (código existente)
+    st.markdown(f"##### {t['legend']}")
+    legend_html = "<div style='display: flex; flex-wrap: wrap;'>"
+    for pos, color in POS_COLORS.items():
+        if pos in POS_TRANSLATIONS[lang_code]:
+            legend_html += f"<div style='margin-right: 10px;'><span style='background-color: {color}; padding: 2px 5px;'>{POS_TRANSLATIONS[lang_code][pos]}</span></div>"
+    legend_html += "</div>"
+    st.markdown(legend_html, unsafe_allow_html=True)
+
+    # Mostrar análisis de palabras repetidas (código existente)
+    word_colors = get_repeated_words_colors(doc)
+    with st.expander(t['repeated_words'], expanded=True):
+        highlighted_text = highlight_repeated_words(doc, word_colors)
+        st.markdown(highlighted_text, unsafe_allow_html=True)
+    
+    # Mostrar estructura de oraciones
+    with st.expander(t['sentence_structure'], expanded=True):
+        for i, sent_analysis in enumerate(advanced_analysis['sentence_structure']):
+            sentence_str = (
+                f"**{t['sentence']} {i+1}** "
+                f"{t['root']}: {sent_analysis['root']} ({sent_analysis['root_pos']}) -- "
+                f"{t['subjects']}: {', '.join(sent_analysis['subjects'])} -- "
+                f"{t['objects']}: {', '.join(sent_analysis['objects'])} -- "
+                f"{t['verbs']}: {', '.join(sent_analysis['verbs'])}"
+            )
+            st.markdown(sentence_str)
+
+    # Mostrar análisis de categorías gramaticales # Mostrar análisis morfológico
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        with st.expander(t['pos_analysis'], expanded=True):
+            pos_df = pd.DataFrame(advanced_analysis['pos_analysis'])
+            
+            # Traducir las etiquetas POS a sus nombres en el idioma seleccionado
+            pos_df['pos'] = pos_df['pos'].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+            
+            # Renombrar las columnas para mayor claridad
+            pos_df = pos_df.rename(columns={
+                'pos': t['grammatical_category'],
+                'count': t['count'],
+                'percentage': t['percentage'],
+                'examples': t['examples']
+            })
+            
+            # Mostrar el dataframe
+            st.dataframe(pos_df)
+    
+    with col2:
+        with st.expander(t['morphological_analysis'], expanded=True):
+            morph_df = pd.DataFrame(advanced_analysis['morphological_analysis'])
+            
+            # Definir el mapeo de columnas
+            column_mapping = {
+                'text': t['word'],
+                'lemma': t['lemma'],
+                'pos': t['grammatical_category'],
+                'dep': t['dependency'],
+                'morph': t['morphology']
+            }
+            
+            # Renombrar las columnas existentes
+            morph_df = morph_df.rename(columns={col: new_name for col, new_name in column_mapping.items() if col in morph_df.columns})
+            
+            # Traducir las categorías gramaticales
+            morph_df[t['grammatical_category']] = morph_df[t['grammatical_category']].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+            
+            # Traducir las dependencias
+            dep_translations = {
+                'es': {
+                    'ROOT': 'RAÍZ', 'nsubj': 'sujeto nominal', 'obj': 'objeto', 'iobj': 'objeto indirecto',
+                    'csubj': 'sujeto clausal', 'ccomp': 'complemento clausal', 'xcomp': 'complemento clausal abierto',
+                    'obl': 'oblicuo', 'vocative': 'vocativo', 'expl': 'expletivo', 'dislocated': 'dislocado',
+                    'advcl': 'cláusula adverbial', 'advmod': 'modificador adverbial', 'discourse': 'discurso',
+                    'aux': 'auxiliar', 'cop': 'cópula', 'mark': 'marcador', 'nmod': 'modificador nominal',
+                    'appos': 'aposición', 'nummod': 'modificador numeral', 'acl': 'cláusula adjetiva',
+                    'amod': 'modificador adjetival', 'det': 'determinante', 'clf': 'clasificador',
+                    'case': 'caso', 'conj': 'conjunción', 'cc': 'coordinante', 'fixed': 'fijo',
+                    'flat': 'plano', 'compound': 'compuesto', 'list': 'lista', 'parataxis': 'parataxis',
+                    'orphan': 'huérfano', 'goeswith': 'va con', 'reparandum': 'reparación', 'punct': 'puntuación'
+                },
+                'en': {
+                    'ROOT': 'ROOT', 'nsubj': 'nominal subject', 'obj': 'object',
+                    'iobj': 'indirect object', 'csubj': 'clausal subject', 'ccomp': 'clausal complement', 'xcomp': 'open clausal complement',
+                    'obl': 'oblique', 'vocative': 'vocative', 'expl': 'expletive', 'dislocated': 'dislocated', 'advcl': 'adverbial clause modifier',
+                    'advmod': 'adverbial modifier', 'discourse': 'discourse element', 'aux': 'auxiliary', 'cop': 'copula', 'mark': 'marker',
+                    'nmod': 'nominal modifier', 'appos': 'appositional modifier', 'nummod': 'numeric modifier', 'acl': 'clausal modifier of noun',
+                    'amod': 'adjectival modifier', 'det': 'determiner', 'clf': 'classifier', 'case': 'case marking',
+                    'conj': 'conjunct', 'cc': 'coordinating conjunction', 'fixed': 'fixed multiword expression',
+                    'flat': 'flat multiword expression', 'compound': 'compound', 'list': 'list', 'parataxis': 'parataxis', 'orphan': 'orphan',
+                    'goeswith': 'goes with', 'reparandum': 'reparandum', 'punct': 'punctuation'
+                },
+                'fr': {
+                    'ROOT': 'RACINE', 'nsubj': 'sujet nominal', 'obj': 'objet', 'iobj': 'objet indirect',
+                    'csubj': 'sujet phrastique', 'ccomp': 'complément phrastique', 'xcomp': 'complément phrastique ouvert', 'obl': 'oblique',
+                    'vocative': 'vocatif', 'expl': 'explétif', 'dislocated': 'disloqué', 'advcl': 'clause adverbiale', 'advmod': 'modifieur adverbial',
+                    'discourse': 'élément de discours', 'aux': 'auxiliaire', 'cop': 'copule', 'mark': 'marqueur', 'nmod': 'modifieur nominal',
+                    'appos': 'apposition', 'nummod': 'modifieur numéral', 'acl': 'clause relative', 'amod': 'modifieur adjectival', 'det': 'déterminant',
+                    'clf': 'classificateur', 'case': 'marqueur de cas', 'conj': 'conjonction', 'cc': 'coordination', 'fixed': 'expression figée',
+                    'flat': 'construction plate', 'compound': 'composé', 'list': 'liste', 'parataxis': 'parataxe', 'orphan': 'orphelin',
+                    'goeswith': 'va avec', 'reparandum': 'réparation', 'punct': 'ponctuation'
+                }
+            }
+            morph_df[t['dependency']] = morph_df[t['dependency']].map(lambda x: dep_translations[lang_code].get(x, x))
+            
+            # Traducir la morfología
+            def translate_morph(morph_string, lang_code):
+                morph_translations = {
+                    'es': {
+                        'Gender': 'Género', 'Number': 'Número', 'Case': 'Caso', 'Definite': 'Definido',
+                        'PronType': 'Tipo de Pronombre', 'Person': 'Persona', 'Mood': 'Modo',
+                        'Tense': 'Tiempo', 'VerbForm': 'Forma Verbal', 'Voice': 'Voz',
+                        'Fem': 'Femenino', 'Masc': 'Masculino', 'Sing': 'Singular', 'Plur': 'Plural',
+                        'Ind': 'Indicativo', 'Sub': 'Subjuntivo', 'Imp': 'Imperativo', 'Inf': 'Infinitivo',
+                        'Part': 'Participio', 'Ger': 'Gerundio', 'Pres': 'Presente', 'Past': 'Pasado',
+                        'Fut': 'Futuro', 'Perf': 'Perfecto', 'Imp': 'Imperfecto'
+                    },
+                    'en': {
+                        'Gender': 'Gender', 'Number': 'Number', 'Case': 'Case', 'Definite': 'Definite', 'PronType': 'Pronoun Type', 'Person': 'Person',
+                        'Mood': 'Mood', 'Tense': 'Tense', 'VerbForm': 'Verb Form', 'Voice': 'Voice',
+                        'Fem': 'Feminine', 'Masc': 'Masculine', 'Sing': 'Singular', 'Plur': 'Plural', 'Ind': 'Indicative',
+                        'Sub': 'Subjunctive', 'Imp': 'Imperative', 'Inf': 'Infinitive', 'Part': 'Participle',
+                        'Ger': 'Gerund', 'Pres': 'Present', 'Past': 'Past', 'Fut': 'Future', 'Perf': 'Perfect', 'Imp': 'Imperfect'
+                    },
+                    'fr': {
+                        'Gender': 'Genre', 'Number': 'Nombre', 'Case': 'Cas', 'Definite': 'Défini', 'PronType': 'Type de Pronom',
+                        'Person': 'Personne', 'Mood': 'Mode', 'Tense': 'Temps', 'VerbForm': 'Forme Verbale', 'Voice': 'Voix',
+                        'Fem': 'Féminin', 'Masc': 'Masculin', 'Sing': 'Singulier', 'Plur': 'Pluriel', 'Ind': 'Indicatif',
+                        'Sub': 'Subjonctif', 'Imp': 'Impératif', 'Inf': 'Infinitif', 'Part': 'Participe',
+                        'Ger': 'Gérondif', 'Pres': 'Présent', 'Past': 'Passé', 'Fut': 'Futur', 'Perf': 'Parfait', 'Imp': 'Imparfait'
+                    }
+                }
+                for key, value in morph_translations[lang_code].items():
+                    morph_string = morph_string.replace(key, value)
+                return morph_string
+            
+            morph_df[t['morphology']] = morph_df[t['morphology']].apply(lambda x: translate_morph(x, lang_code))
+            
+            # Seleccionar y ordenar las columnas a mostrar
+            columns_to_display = [t['word'], t['lemma'], t['grammatical_category'], t['dependency'], t['morphology']]
+            columns_to_display = [col for col in columns_to_display if col in morph_df.columns]
+            
+            # Mostrar el DataFrame
+            st.dataframe(morph_df[columns_to_display])
+            
+    # Mostrar diagramas de arco (código existente)
+    with st.expander(t['arc_diagram'], expanded=True):
+        sentences = list(doc.sents)
+        arc_diagrams = []
+        for i, sent in enumerate(sentences):
+            st.subheader(f"{t['sentence']} {i+1}")
+            html = displacy.render(sent, style="dep", options={"distance": 100})
+            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)
+            st.write(html, unsafe_allow_html=True)
+            arc_diagrams.append(html)
+
+###############################################################################################################
+def display_semantic_analysis_interface(nlp_models, lang_code):
+    translations = {
+        'es': {
+            'title': "AIdeaText - Análisis semántico",
+            'text_input_label': "Ingrese un texto para analizar (máx. 5,000 palabras):",
+            'text_input_placeholder': "El objetivo de esta aplicación es que mejore sus habilidades de redacción...",
+            'file_uploader': "O cargue un archivo de texto",
+            'analyze_button': "Analizar texto",
+            'conceptual_relations': "Relaciones Conceptuales",
+            'identified_entities': "Entidades Identificadas",
+            'key_concepts': "Conceptos Clave",
+            'success_message': "Análisis semántico guardado correctamente.",
+            'error_message': "Hubo un problema al guardar el análisis semántico. Por favor, inténtelo de nuevo.",
+            'warning_message': "Por favor, ingrese un texto o cargue un archivo para analizar.",
+            'initial_message': "Ingrese un texto y presione 'Analizar texto' para comenzar.",
+            'no_results': "No hay resultados disponibles. Por favor, realice un análisis primero."
+        },
+        'en': {
+            'title': "AIdeaText - Semantic Analysis",
+            'text_input_label': "Enter a text to analyze (max. 5,000 words):",
+            'text_input_placeholder': "The goal of this application is to improve your writing skills...",
+            'file_uploader': "Or upload a text file",
+            'analyze_button': "Analyze text",
+            'conceptual_relations': "Conceptual Relations",
+            'identified_entities': "Identified Entities",
+            'key_concepts': "Key Concepts",
+            'success_message': "Semantic analysis saved successfully.",
+            'error_message': "There was a problem saving the semantic analysis. Please try again.",
+            'warning_message': "Please enter a text or upload a file to analyze.",
+            'initial_message': "Enter a text and press 'Analyze text' to start.",
+            'no_results': "No results available. Please perform an analysis first."
+        },
+        'fr': {
+            'title': "AIdeaText - Analyse sémantique",
+            'text_input_label': "Entrez un texte à analyser (max. 5 000 mots) :",
+            'text_input_placeholder': "L'objectif de cette application est d'améliorer vos compétences en rédaction...",
+            'file_uploader': "Ou téléchargez un fichier texte",
+            'analyze_button': "Analyser le texte",
+            'conceptual_relations': "Relations Conceptuelles",
+            'identified_entities': "Entités Identifiées",
+            'key_concepts': "Concepts Clés",
+            'success_message': "Analyse sémantique enregistrée avec succès.",
+            'error_message': "Un problème est survenu lors de l'enregistrement de l'analyse sémantique. Veuillez réessayer.",
+            'warning_message': "Veuillez entrer un texte ou télécharger un fichier à analyser.",
+            'initial_message': "Entrez un texte et appuyez sur 'Analyser le texte' pour commencer.",
+            'no_results': "Aucun résultat disponible. Veuillez d'abord effectuer une analyse."
+        }
+    }
+
+    t = translations[lang_code]
+
+    st.header(t['title'])
+
+    # Opción para introducir texto
+    text_input = st.text_area(
+        t['text_input_label'],
+        height=150,
+        placeholder=t['text_input_placeholder'],
+    )
+
+    # Opción para cargar archivo
+    uploaded_file = st.file_uploader(t['file_uploader'], type=['txt'])
+
+    if st.button(t['analyze_button']):
+        if text_input or uploaded_file is not None:
+            if uploaded_file:
+                text_content = uploaded_file.getvalue().decode('utf-8')
+            else:
+                text_content = text_input
+
+            # Realizar el análisis
+            analysis_result = perform_semantic_analysis(text_content, nlp_models[lang_code], lang_code)
+
+            # Guardar el resultado en el estado de la sesión
+            st.session_state.semantic_result = analysis_result
+
+            # Mostrar resultados
+            display_semantic_results(st.session_state.semantic_result, lang_code, t)           
+
+            # Guardar el resultado del análisis
+            if store_semantic_result(st.session_state.username, text_content, analysis_result):
+                st.success(t['success_message'])
+            else:
+                st.error(t['error_message'])
+        else:
+            st.warning(t['warning_message'])
+
+    elif 'semantic_result' in st.session_state:
+
+        # Si hay un resultado guardado, mostrarlo
+        display_semantic_results(st.session_state.semantic_result, lang_code, t)
+    
+    else:
+        st.info(t['initial_message'])  # Asegúrate de que 'initial_message' esté en tus traducciones
+            
+def display_semantic_results(result, lang_code, t):
+    if result is None:
+        st.warning(t['no_results'])  # Asegúrate de que 'no_results' esté en tus traducciones
+        return
+
+    # Mostrar conceptos clave
+    with st.expander(t['key_concepts'], expanded=True):
+        concept_text = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in result['key_concepts']])
+        st.write(concept_text)
+
+    # Mostrar el gráfico de relaciones conceptuales
+    with st.expander(t['conceptual_relations'], expanded=True):
+        st.pyplot(result['relations_graph'])
+
+##################################################################################################
+def display_discourse_analysis_interface(nlp_models, lang_code):
+    translations = {
+        'es': {
+            'title': "AIdeaText - Análisis del discurso",
+            'file_uploader1': "Cargar archivo de texto 1 (Patrón)",
+            'file_uploader2': "Cargar archivo de texto 2 (Comparación)",
+            'analyze_button': "Analizar textos",
+            'comparison': "Comparación de Relaciones Semánticas",
+            'success_message': "Análisis del discurso guardado correctamente.",
+            'error_message': "Hubo un problema al guardar el análisis del discurso. Por favor, inténtelo de nuevo.",
+            'warning_message': "Por favor, cargue ambos archivos para analizar.",
+            'initial_message': "Ingrese un texto y presione 'Analizar texto' para comenzar.",
+            'no_results': "No hay resultados disponibles. Por favor, realice un análisis primero.",
+            'key_concepts': "Conceptos Clave",
+            'graph_not_available': "El gráfico no está disponible.",
+            'concepts_not_available': "Los conceptos clave no están disponibles.",
+            'comparison_not_available': "La comparación no está disponible."
+        },
+        'en': {
+            'title': "AIdeaText - Discourse Analysis",
+            'file_uploader1': "Upload text file 1 (Pattern)",
+            'file_uploader2': "Upload text file 2 (Comparison)",
+            'analyze_button': "Analyze texts",
+            'comparison': "Comparison of Semantic Relations",
+            'success_message': "Discourse analysis saved successfully.",
+            'error_message': "There was a problem saving the discourse analysis. Please try again.",
+            'warning_message': "Please upload both files to analyze.",
+            'initial_message': "Enter a text and press 'Analyze text' to start.",
+            'no_results': "No results available. Please perform an analysis first.",
+            'key_concepts': "Key Concepts",
+            'graph_not_available': "The graph is not available.",
+            'concepts_not_available': "Key concepts are not available.",
+            'comparison_not_available': "The comparison is not available."
+        },
+        'fr': {
+            'title': "AIdeaText - Analyse du discours",
+            'file_uploader1': "Télécharger le fichier texte 1 (Modèle)",
+            'file_uploader2': "Télécharger le fichier texte 2 (Comparaison)",
+            'analyze_button': "Analyser les textes",
+            'comparison': "Comparaison des Relations Sémantiques",
+            'success_message': "Analyse du discours enregistrée avec succès.",
+            'error_message': "Un problème est survenu lors de l'enregistrement de l'analyse du discours. Veuillez réessayer.",
+            'warning_message': "Veuillez télécharger les deux fichiers à analyser.",
+            'initial_message': "Entrez un texte et appuyez sur 'Analyser le texte' pour commencer.",
+            'no_results': "Aucun résultat disponible. Veuillez d'abord effectuer une analyse.",
+            'key_concepts': "Concepts Clés",
+            'graph_not_available': "Le graphique n'est pas disponible.",
+            'concepts_not_available': "Les concepts clés ne sont pas disponibles.",
+            'comparison_not_available': "La comparaison n'est pas disponible."
+        }
+    }
+
+    t = translations[lang_code]
+    st.header(t['title'])
+
+    col1, col2 = st.columns(2)
+    with col1:
+        uploaded_file1 = st.file_uploader(t['file_uploader1'], type=['txt'])
+    with col2:
+        uploaded_file2 = st.file_uploader(t['file_uploader2'], type=['txt'])
+
+    if st.button(t['analyze_button']):
+        if uploaded_file1 is not None and uploaded_file2 is not None:
+            text_content1 = uploaded_file1.getvalue().decode('utf-8')
+            text_content2 = uploaded_file2.getvalue().decode('utf-8')
+
+            # Realizar el análisis
+            analysis_result = perform_discourse_analysis(text_content1, text_content2, nlp_models[lang_code], lang_code)
+
+            # Guardar el resultado en el estado de la sesión
+            st.session_state.discourse_result = analysis_result
+
+            # Mostrar los resultados del análisis
+            display_discourse_results(st.session_state.discourse_result, lang_code, t)
+
+            # Guardar el resultado del análisis
+            if store_discourse_analysis_result(st.session_state.username, text_content1, text_content2, analysis_result):
+                st.success(t['success_message'])
+            else:
+                st.error(t['error_message'])
+        else:
+            st.warning(t['warning_message'])
+    elif 'discourse_result' in st.session_state and st.session_state.discourse_result is not None:
+        # Si hay un resultado guardado, mostrarlo
+        display_discourse_results(st.session_state.discourse_result, lang_code, t)
+    else:
+        st.info(t['initial_message'])  # Asegúrate de que 'initial_message' esté en tus traducciones
+
+#################################################
+def display_discourse_results(result, lang_code, t):
+    if result is None:
+        st.warning(t.get('no_results', "No hay resultados disponibles."))
+        return
+
+    def clean_and_convert(value):
+        if isinstance(value, (int, float)):
+            return float(value)
+        elif isinstance(value, str):
+            try:
+                return float(value.replace(',', '.'))
+            except ValueError:
+                return 0.0
+        return 0.0
+
+    def process_key_concepts(key_concepts):
+        df = pd.DataFrame(key_concepts, columns=['Concepto', 'Frecuencia'])
+        df['Frecuencia'] = df['Frecuencia'].apply(clean_and_convert)
+        return df
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        with st.expander(t.get('file_uploader1', "Documento 1"), expanded=True):
+            if 'graph1' in result:
+                st.pyplot(result['graph1'])
+            else:
+                st.warning(t.get('graph_not_available', "El gráfico no está disponible."))
+            st.subheader(t.get('key_concepts', "Conceptos Clave"))
+            if 'key_concepts1' in result:
+                df1 = process_key_concepts(result['key_concepts1'])
+                st.table(df1)
+            else:
+                st.warning(t.get('concepts_not_available', "Los conceptos clave no están disponibles."))
+
+    with col2:
+        with st.expander(t.get('file_uploader2', "Documento 2"), expanded=True):
+            if 'graph2' in result:
+                st.pyplot(result['graph2'])
+            else:
+                st.warning(t.get('graph_not_available', "El gráfico no está disponible."))
+            st.subheader(t.get('key_concepts', "Conceptos Clave"))
+            if 'key_concepts2' in result:
+                df2 = process_key_concepts(result['key_concepts2'])
+                st.table(df2)
+            else:
+                st.warning(t.get('concepts_not_available', "Los conceptos clave no están disponibles."))
+
+    # Comparación de conceptos clave
+    st.subheader(t.get('comparison', "Comparación de conceptos entre ambos documentos"))
+    if 'key_concepts1' in result and 'key_concepts2' in result:
+        df1 = process_key_concepts(result['key_concepts1']).set_index('Concepto')
+        df2 = process_key_concepts(result['key_concepts2']).set_index('Concepto')
+        
+        df_comparison = pd.concat([df1, df2], axis=1, keys=[t.get('file_uploader1', "Documento 1"), t.get('file_uploader2', "Documento 2")])
+        df_comparison = df_comparison.fillna(0.0)
+        
+        # Asegurarse de que todas las columnas sean float
+        for col in df_comparison.columns:
+            df_comparison[col] = df_comparison[col].astype(float)
+        
+        # Mostrar la tabla de comparación
+        try:
+            st.dataframe(df_comparison.style.format("{:.2f}"), width=1000)
+        except Exception as e:
+            st.error(f"Error al mostrar el DataFrame: {str(e)}")
+            st.write("DataFrame sin formato:")
+            st.write(df_comparison)
+    else:
+        st.warning(t.get('comparison_not_available', "La comparación no está disponible."))
+
+    # Aquí puedes agregar el código para mostrar los gráficos si es necesario
+
+##################################################################################################
+#def display_saved_discourse_analysis(analysis_data):
+#    img_bytes = base64.b64decode(analysis_data['combined_graph'])
+#    img = plt.imread(io.BytesIO(img_bytes), format='png')
+    
+#    st.image(img, use_column_width=True)
+#    st.write("Texto del documento patrón:")
+#    st.write(analysis_data['text1'])
+#    st.write("Texto del documento comparado:")
+#    st.write(analysis_data['text2'])
+
+##################################################################################################            
+def display_chatbot_interface(lang_code):
+    translations = {
+        'es': {
+            'title': "Expertos en Vacaciones",
+            'input_placeholder': "Escribe tu mensaje aquí...",
+            'initial_message': "¡Hola! ¿Cómo podemos ayudarte?"
+        },
+        'en': {
+            'title': "Vacation Experts",
+            'input_placeholder': "Type your message here...",
+            'initial_message': "Hi! How can we help you?"
+        },
+        'fr': {
+            'title': "Experts en Vacances",
+            'input_placeholder': "Écrivez votre message ici...",
+            'initial_message': "Bonjour! Comment pouvons-nous vous aider?"
+        }
+    }
+    t = translations[lang_code]
+    st.title(t['title'])
+
+    if 'chatbot' not in st.session_state:
+        st.session_state.chatbot = initialize_chatbot()
+    if 'messages' not in st.session_state:
+        st.session_state.messages = [{"role": "assistant", "content": t['initial_message']}]
+
+    # Contenedor principal para el chat
+    chat_container = st.container()
+
+    # Mostrar mensajes existentes
+    with chat_container:
+        for message in st.session_state.messages:
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+
+    # Área de entrada del usuario
+    user_input = st.chat_input(t['input_placeholder'])
+
+    if user_input:
+        # Agregar mensaje del usuario
+        st.session_state.messages.append({"role": "user", "content": user_input})
+
+        # Mostrar mensaje del usuario
+        with chat_container:
+            with st.chat_message("user"):
+                st.markdown(user_input)
+
+        # Generar respuesta del chatbot
+        with chat_container:
+            with st.chat_message("assistant"):
+                message_placeholder = st.empty()
+                full_response = ""
+                for chunk in get_chatbot_response(st.session_state.chatbot, user_input, lang_code):
+                    full_response += chunk
+                    message_placeholder.markdown(full_response + "▌")
+                message_placeholder.markdown(full_response)
+
+        # Agregar respuesta del asistente a los mensajes
+        st.session_state.messages.append({"role": "assistant", "content": full_response})
+
+        # Guardar la conversación en la base de datos
+        try:
+            store_chat_history(st.session_state.username, st.session_state.messages)
+            st.success("Conversación guardada exitosamente")
+        except Exception as e:
+            st.error(f"Error al guardar la conversación: {str(e)}")
+            logger.error(f"Error al guardar el historial de chat para {st.session_state.username}: {str(e)}")
+
+    # Scroll al final del chat
+    st.markdown('<script>window.scrollTo(0,document.body.scrollHeight);</script>', unsafe_allow_html=True)
+
+######################################################
+if __name__ == "__main__":
+    main()    

requirements.txt

@@ -9,6 +9,7 @@ https://huggingface.co/spacy/fr_core_news_lg/resolve/main/fr_core_news_lg-any-py
 numpy
 networkx
 matplotlib
+plotly
 pydantic
 pandas
 pymssql