Update modules/discourse/discourse_interface.py

modules/discourse/discourse_interface.py

@@ -1,125 +1,176 @@
-import streamlit as st
-import pandas as pd
-from streamlit_float import *
-from .discourse_process import process_discourse_input
-from ..chatbot.chatbot import initialize_chatbot
-from ..database.database_oldFromV2 import store_discourse_analysis_result
-from ..text_analysis.discourse_analysis import perform_discourse_analysis
-from ..utils.widget_utils import generate_unique_key
-
-def display_discourse_interface(lang_code, nlp_models, t):
-    st.subheader(t['discourse_title'])
-
-    text_input = st.text_area(
-        t['warning_message'],
-        height=150,
-        key=generate_unique_key("discourse", "text_area")
-    )
-
-    if st.button(
-        t['results_title'],
-        key=generate_unique_key("discourse", "analyze_button")
-    ):
-        if text_input:
-            # Aquí iría tu lógica de análisis morfosintáctico
-            # Por ahora, solo mostraremos un mensaje de placeholder
-            st.info(t['analysis_placeholder'])
-        else:
-            st.warning(t['no_text_warning'])
-
-'''
-def display_discourse_interface(lang_code, nlp_models, t):
-    st.subheader(t['title'])
-
-    # Inicializar el chatbot si no existe
-    if 'discourse_chatbot' not in st.session_state:
-        st.session_state.discourse_chatbot = initialize_chatbot('discourse')
-
-    # Mostrar el historial del chat
-    chat_history = st.session_state.get('discourse_chat_history', [])
-    for message in chat_history:
-        with st.chat_message(message["role"]):
-            st.write(message["content"])
-            if "visualization" in message:
-                st.pyplot(message["visualization"])
-
-    # Input del usuario
-    user_input = st.chat_input(t['discourse_initial_message'], key=generate_unique_key('discourse', st.session_state.username))
-
-    if user_input:
-        # Procesar el input del usuario
-        response, visualization = process_discourse_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents'), t)
-
-        # Actualizar el historial del chat
-        chat_history.append({"role": "user", "content": user_input})
-        chat_history.append({"role": "assistant", "content": response, "visualization": visualization})
-        st.session_state.discourse_chat_history = chat_history
-
-        # Mostrar el resultado más reciente
-        with st.chat_message("assistant"):
-            st.write(response)
-            if visualization:
-                st.pyplot(visualization)
-
-    # Botón para limpiar el historial del chat
-    if st.button(t['clear_chat'], key=generate_unique_key('discourse', 'clear_chat')):
-        st.session_state.discourse_chat_history = []
-        st.rerun()
-
-    # Sección para cargar archivos
-    col1, col2 = st.columns(2)
-    with col1:
-        uploaded_file1 = st.file_uploader(t['file_uploader1'], type=['txt', 'pdf', 'docx', 'doc', 'odt'])
-    with col2:
-        uploaded_file2 = st.file_uploader(t['file_uploader2'], type=['txt', 'pdf', 'docx', 'doc', 'odt'])
-
-    if uploaded_file1 and uploaded_file2:
-        file_contents1 = uploaded_file1.getvalue().decode('utf-8')
-        file_contents2 = uploaded_file2.getvalue().decode('utf-8')
-        st.session_state.file_contents = (file_contents1, file_contents2)
-
-        if st.button(t['analyze_button']):
-            result = perform_discourse_analysis(file_contents1, file_contents2, nlp_models[lang_code], lang_code)
-            st.session_state.discourse_result = result
-            display_discourse_results(result, lang_code, t)
-            store_discourse_analysis_result(st.session_state.username, file_contents1, file_contents2, result)
-
-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)
-
-            if 'graph1' in result:
-                st.pyplot(result['graph1'])
-
-    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)
-
-            if 'graph2' in result:
-                st.pyplot(result['graph2'])
-
-    # 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:
-        # Código para generar el diagrama de Sankey (como en la función original)
-        pass
-    else:
-        st.warning(t.get('comparison_not_available', "La comparación no está disponible."))
-
-
-        '''
+# modules/discourse/discourse/discourse_interface.py
+
+import streamlit as st
+import pandas as pd
+import plotly.graph_objects as go
+import logging
+from ..utils.widget_utils import generate_unique_key
+from .discourse_process import perform_discourse_analysis
+from ..database.discourse_mongo_db import store_discourse_analysis_result
+
+logger = logging.getLogger(__name__)
+
+def display_discourse_interface(lang_code, nlp_models, discourse_t):
+    """
+    Interfaz para el análisis del discurso
+    Args:
+        lang_code: Código del idioma actual
+        nlp_models: Modelos de spaCy cargados
+        discourse_t: Diccionario de traducciones
+    """
+    try:
+        # 1. Inicializar estado si no existe
+        if 'discourse_state' not in st.session_state:
+            st.session_state.discourse_state = {
+                'analysis_count': 0,
+                'last_analysis': None,
+                'current_files': None
+            }
+
+        # 2. Título y descripción
+        st.subheader(discourse_t.get('discourse_title', 'Análisis del Discurso'))
+        st.info(discourse_t.get('initial_instruction', 
+            'Cargue dos archivos de texto para realizar un análisis comparativo del discurso.'))
+
+        # 3. Área de carga de archivos
+        col1, col2 = st.columns(2)
+        with col1:
+            st.markdown(discourse_t.get('file1_label', "**Documento 1 (Patrón)**"))
+            uploaded_file1 = st.file_uploader(
+                discourse_t.get('file_uploader1', "Cargar archivo 1"),
+                type=['txt'],
+                key=f"discourse_file1_{st.session_state.discourse_state['analysis_count']}"
+            )
+
+        with col2:
+            st.markdown(discourse_t.get('file2_label', "**Documento 2 (Comparación)**"))
+            uploaded_file2 = st.file_uploader(
+                discourse_t.get('file_uploader2', "Cargar archivo 2"),
+                type=['txt'],
+                key=f"discourse_file2_{st.session_state.discourse_state['analysis_count']}"
+            )
+
+        # 4. Botón de análisis
+        col1, col2, col3 = st.columns([1,2,1])
+        with col2:
+            analyze_button = st.button(
+                discourse_t.get('analyze_button', 'Analizar Discurso'),
+                key=generate_unique_key("discourse", "analyze_button"),
+                type="primary",
+                icon="🔍",
+                disabled=not (uploaded_file1 and uploaded_file2),
+                use_container_width=True
+            )
+
+        # 5. Proceso de análisis
+        if analyze_button and uploaded_file1 and uploaded_file2:
+            try:
+                with st.spinner(discourse_t.get('processing', 'Procesando análisis...')):
+                    # Leer contenido de archivos
+                    text1 = uploaded_file1.getvalue().decode('utf-8')
+                    text2 = uploaded_file2.getvalue().decode('utf-8')
+
+                    # Realizar análisis
+                    result = perform_discourse_analysis(
+                        text1, 
+                        text2, 
+                        nlp_models[lang_code],
+                        lang_code
+                    )
+
+                    if result['success']:
+                        # Guardar estado
+                        st.session_state.discourse_result = result
+                        st.session_state.discourse_state['analysis_count'] += 1
+                        st.session_state.discourse_state['current_files'] = (
+                            uploaded_file1.name,
+                            uploaded_file2.name
+                        )
+
+                        # Guardar en base de datos
+                        if store_discourse_analysis_result(
+                            st.session_state.username,
+                            text1,
+                            text2,
+                            result
+                        ):
+                            st.success(discourse_t.get('success_message', 'Análisis guardado correctamente'))
+                            
+                            # Mostrar resultados
+                            display_discourse_results(result, lang_code, discourse_t)
+                        else:
+                            st.error(discourse_t.get('error_message', 'Error al guardar el análisis'))
+                    else:
+                        st.error(discourse_t.get('analysis_error', 'Error en el análisis'))
+
+            except Exception as e:
+                logger.error(f"Error en análisis del discurso: {str(e)}")
+                st.error(discourse_t.get('error_processing', f'Error procesando archivos: {str(e)}'))
+
+        # 6. Mostrar resultados previos
+        elif 'discourse_result' in st.session_state and st.session_state.discourse_result is not None:
+            if st.session_state.discourse_state.get('current_files'):
+                st.info(
+                    discourse_t.get('current_analysis_message', 'Mostrando análisis de los archivos: {} y {}')
+                    .format(*st.session_state.discourse_state['current_files'])
+                )
+            display_discourse_results(
+                st.session_state.discourse_result,
+                lang_code,
+                discourse_t
+            )
+
+    except Exception as e:
+        logger.error(f"Error general en interfaz del discurso: {str(e)}")
+        st.error(discourse_t.get('general_error', 'Se produjo un error. Por favor, intente de nuevo.'))
+
+def display_discourse_results(result, lang_code, discourse_t):
+    """
+    Muestra los resultados del análisis del discurso
+    """
+    if not result.get('success'):
+        st.warning(discourse_t.get('no_results', 'No hay resultados disponibles'))
+        return
+
+    col1, col2 = st.columns(2)
+
+    # Documento 1
+    with col1:
+        with st.expander(discourse_t.get('doc1_title', 'Documento 1'), expanded=True):
+            st.subheader(discourse_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)
+
+                if 'graph1' in result:
+                    st.pyplot(result['graph1'])
+                else:
+                    st.warning(discourse_t.get('graph_not_available', 'Gráfico no disponible'))
+            else:
+                st.warning(discourse_t.get('concepts_not_available', 'Conceptos no disponibles'))
+
+    # Documento 2
+    with col2:
+        with st.expander(discourse_t.get('doc2_title', 'Documento 2'), expanded=True):
+            st.subheader(discourse_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)
+
+                if 'graph2' in result:
+                    st.pyplot(result['graph2'])
+                else:
+                    st.warning(discourse_t.get('graph_not_available', 'Gráfico no disponible'))
+            else:
+                st.warning(discourse_t.get('concepts_not_available', 'Conceptos no disponibles'))
+
+    # Comparación de conceptos
+    if 'key_concepts1' in result and 'key_concepts2' in result:
+        st.subheader(discourse_t.get('comparison_title', 'Comparación de Conceptos'))
+        try:
+            plot_concept_comparison(result, discourse_t)
+        except Exception as e:
+            logger.error(f"Error en visualización de comparación: {str(e)}")
+            st.warning(discourse_t.get('comparison_error', 'Error al generar la comparación'))