Update modules/ui/ui.py

modules/ui/ui.py

@@ -580,181 +580,182 @@ 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)
+
+    elif 'morphosyntax_result' in st.session_state:
+        # Si hay un resultado guardado, mostrarlo
+        display_morphosyntax_results(st.session_state.morphosyntax_result, lang_code, t)
+    else:
+        st.warning(t['warning_message'])
+
+def display_morphosyntax_results(result, lang_code, t):
+    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):
@@ -824,14 +825,15 @@ 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)
+def display_semantic_results(result, lang_code, t):            
+    # 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)
 
-            # Mostrar el gráfico de relaciones conceptuales
-            with st.expander(t['conceptual_relations'], expanded=True):
-                st.pyplot(analysis_result['relations_graph'])
+    # Mostrar el gráfico de relaciones conceptuales
+    with st.expander(t['conceptual_relations'], expanded=True):
+        st.pyplot(analysis_result['relations_graph'])
 
             # Guardar el resultado del análisis
             if store_semantic_result(st.session_state.username, text_content, analysis_result):
@@ -879,10 +881,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,16 +894,49 @@ 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):
                 st.success(t['success_message'])
             else:
                 st.error(t['error_message'])
-        else:
-            st.warning(t['warning_message'])
+    
+    elif 'discourse_result' in st.session_state:
+        # Si hay un resultado guardado, mostrarlo
+        display_discourse_results(st.session_state.discourse_result, lang_code, t)
+    else:
+        st.warning(t['warning_message'])
+
+def display_discourse_results(result, lang_code, t):
+    col1, col2 = st.columns(2)
+
+    with col1:
+        with st.expander(t['file_uploader1'], expanded=True):
+            st.pyplot(result['graph1'])
+            st.subheader(t['comparison'])
+            concept_text1 = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in result['key_concepts1']])
+            st.write(concept_text1)
+
+    with col2:
+        with st.expander(t['file_uploader2'], expanded=True):
+            st.pyplot(result['graph2'])
+            st.subheader(t['comparison'])
+            concept_text2 = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in result['key_concepts2']])
+            st.write(concept_text2)
+
+    # Aquí puedes añadir más visualizaciones o comparaciones entre los dos documentos
+    # Por ejemplo, podrías mostrar una tabla comparativa de los conceptos clave
+    st.subheader(t['comparison'])
+    df = pd.DataFrame({
+        t['file_uploader1']: dict(result['key_concepts1']),
+        t['file_uploader2']: dict(result['key_concepts2'])
+    }).fillna(0)
+    st.dataframe(df)
 
 ##################################################################################################
 #def display_saved_discourse_analysis(analysis_data):