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

modules/database/discourse_mongo_db.py

@@ -1,7 +1,12 @@
 # modules/database/discourse_mongo_db.py
-import matplotlib.pyplot as plt  # Añadir esta importación al inicio
+# Importaciones estándar
 import io
 import base64
+from datetime import datetime, timezone
+import logging
+
+# Importaciones de terceros
+import matplotlib.pyplot as plt
 
 from .mongo_db import (
     get_collection,
@@ -11,14 +16,11 @@ from .mongo_db import (
     delete_document
 )
 
-from datetime import datetime, timezone
-
-import logging
-
+# Configuración del logger
 logger = logging.getLogger(__name__)
-
 COLLECTION_NAME = 'student_discourse_analysis'
 
+########################################################################
 def store_student_discourse_result(username, text1, text2, analysis_result):
     """
     Guarda el resultado del análisis de discurso comparativo en MongoDB.
@@ -120,10 +122,6 @@ def get_student_discourse_analysis(username, limit=10):
         logger.error(f"Error recuperando análisis del discurso: {str(e)}")
         return []
 #####################################################################################
-
-
-
-
         
 def get_student_discourse_data(username):
     """
@@ -149,6 +147,7 @@ def get_student_discourse_data(username):
         logger.error(f"Error al obtener datos del discurso: {str(e)}")
         return {'entries': []}
 
+###########################################################################
 def update_student_discourse_analysis(analysis_id, update_data):
     """
     Actualiza un análisis del discurso existente.
@@ -161,6 +160,7 @@ def update_student_discourse_analysis(analysis_id, update_data):
         logger.error(f"Error al actualizar análisis del discurso: {str(e)}")
         return False
 
+###########################################################################
 def delete_student_discourse_analysis(analysis_id):
     """
     Elimina un análisis del discurso.

modules/database/sql_db.py

@@ -1,3 +1,5 @@
+#modules/database/sql_db.py
+
 from .database_init import get_sql_containers
 from datetime import datetime, timezone
 import logging

modules/discourse/discourse_interface.py

@@ -125,6 +125,10 @@ def display_discourse_interface(lang_code, nlp_models, discourse_t):
         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
@@ -133,39 +137,144 @@ def display_discourse_results(result, lang_code, discourse_t):
         st.warning(discourse_t.get('no_results', 'No hay resultados disponibles'))
         return
 
+    # Estilo CSS
+    st.markdown("""
+        <style>
+        .concepts-container {
+            display: flex;
+            flex-wrap: nowrap;
+            gap: 8px;
+            padding: 12px;
+            background-color: #f8f9fa;
+            border-radius: 8px;
+            overflow-x: auto;
+            margin-bottom: 15px;
+            white-space: nowrap;
+        }
+        .concept-item {
+            background-color: white;
+            border-radius: 4px;
+            padding: 6px 10px;
+            display: inline-flex;
+            align-items: center;
+            gap: 4px;
+            box-shadow: 0 1px 2px rgba(0,0,0,0.1);
+            flex-shrink: 0;
+        }
+        .concept-name {
+            font-weight: 500;
+            color: #1f2937;
+            font-size: 0.85em;
+        }
+        .concept-freq {
+            color: #6b7280;
+            font-size: 0.75em;
+        }
+        .graph-container {
+            background-color: white;
+            padding: 15px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            margin-top: 10px;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
     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'))
+        st.subheader(discourse_t.get('doc1_title', 'Documento 1'))
+        st.markdown(discourse_t.get('key_concepts', 'Conceptos Clave'))
+        if 'key_concepts1' in result:
+            concepts_html = f"""
+                <div class="concepts-container">
+                    {''.join([
+                        f'<div class="concept-item"><span class="concept-name">{concept}</span>'
+                        f'<span class="concept-freq">({freq:.2f})</span></div>'
+                        for concept, freq in result['key_concepts1']
+                    ])}
+                </div>
+            """
+            st.markdown(concepts_html, unsafe_allow_html=True)
+
+            if 'graph1' in result:
+                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                st.pyplot(result['graph1'])
+                
+                # Botones y controles
+                button_col1, spacer_col1 = st.columns([1,4])
+                with button_col1:
+                    if 'graph1_bytes' in result:
+                        st.download_button(
+                            label="📥 " + discourse_t.get('download_graph', "Download"),
+                            data=result['graph1_bytes'],
+                            file_name="discourse_graph1.png",
+                            mime="image/png",
+                            use_container_width=True
+                        )
+
+                # Interpretación como texto normal sin expander
+                st.markdown("**📊 Interpretación del grafo:**")
+                st.markdown("""
+                    - 🔀 Las flechas indican la dirección de la relación entre conceptos
+                    - 🎨 Los colores más intensos indican conceptos más centrales en el texto
+                    - ⭕ El tamaño de los nodos representa la frecuencia del concepto
+                    - ↔️ El grosor de las líneas indica la fuerza de la conexión
+                """)
+                
+                st.markdown('</div>', unsafe_allow_html=True)
             else:
-                st.warning(discourse_t.get('concepts_not_available', 'Conceptos no disponibles'))
+                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'))
+        st.subheader(discourse_t.get('doc2_title', 'Documento 2'))
+        st.markdown(discourse_t.get('key_concepts', 'Conceptos Clave'))
+        if 'key_concepts2' in result:
+            concepts_html = f"""
+                <div class="concepts-container">
+                    {''.join([
+                        f'<div class="concept-item"><span class="concept-name">{concept}</span>'
+                        f'<span class="concept-freq">({freq:.2f})</span></div>'
+                        for concept, freq in result['key_concepts2']
+                    ])}
+                </div>
+            """
+            st.markdown(concepts_html, unsafe_allow_html=True)
+
+            if 'graph2' in result:
+                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                st.pyplot(result['graph2'])
+                
+                # Botones y controles
+                button_col2, spacer_col2 = st.columns([1,4])
+                with button_col2:
+                    if 'graph2_bytes' in result:
+                        st.download_button(
+                            label="📥 " + discourse_t.get('download_graph', "Download"),
+                            data=result['graph2_bytes'],
+                            file_name="discourse_graph2.png",
+                            mime="image/png",
+                            use_container_width=True
+                        )
+
+                # Interpretación como texto normal sin expander
+                st.markdown("**📊 Interpretación del grafo:**")
+                st.markdown("""
+                    - 🔀 Las flechas indican la dirección de la relación entre conceptos
+                    - 🎨 Los colores más intensos indican conceptos más centrales en el texto
+                    - ⭕ El tamaño de los nodos representa la frecuencia del concepto
+                    - ↔️ El grosor de las líneas indica la fuerza de la conexión
+                """)
+                
+                st.markdown('</div>', unsafe_allow_html=True)
             else:
-                st.warning(discourse_t.get('concepts_not_available', 'Conceptos no disponibles'))
+                st.warning(discourse_t.get('graph_not_available', 'Gráfico no disponible'))
+        else:
+            st.warning(discourse_t.get('concepts_not_available', 'Conceptos no disponibles'))
 
     # Nota informativa sobre la comparación
     st.info(discourse_t.get('comparison_note', 

modules/discourse/discourse_live_interface.py

@@ -0,0 +1,151 @@
+# modules/discourse/discourse/discourse_live_interface.py
+
+import streamlit as st
+from streamlit_float import *
+from streamlit_antd_components import *
+import pandas as pd
+import logging
+import io
+import matplotlib.pyplot as plt
+
+# Configuración del logger
+logger = logging.getLogger(__name__)
+
+# Importaciones locales
+from .discourse_process import perform_discourse_analysis
+from .discourse_interface import display_discourse_results  # Añadida esta importación
+from ..utils.widget_utils import generate_unique_key
+from ..database.discourse_mongo_db import store_student_discourse_result
+from ..database.chat_mongo_db import store_chat_history, get_chat_history
+
+
+#####################################################################################################
+def fig_to_bytes(fig):
+    """Convierte una figura de matplotlib a bytes."""
+    try:
+        buf = io.BytesIO()
+        fig.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+        buf.seek(0)
+        return buf.getvalue()
+    except Exception as e:
+        logger.error(f"Error en fig_to_bytes: {str(e)}")
+        return None
+
+#################################################################################################
+def display_discourse_live_interface(lang_code, nlp_models, discourse_t):
+    """
+    Interfaz para el análisis del discurso en vivo con layout mejorado
+    """
+    try:
+        if 'discourse_live_state' not in st.session_state:
+            st.session_state.discourse_live_state = {
+                'analysis_count': 0,
+                'current_text1': '',
+                'current_text2': '',
+                'last_result': None,
+                'text_changed': False
+            }
+
+        # Título
+        st.subheader(discourse_t.get('enter_text', 'Ingrese sus textos'))
+
+        # Área de entrada de textos en dos columnas
+        text_col1, text_col2 = st.columns(2)
+
+        # Texto 1
+        with text_col1:
+            st.markdown("**Texto 1 (Patrón)**")
+            text_input1 = st.text_area(
+                "Texto 1",
+                height=200,
+                key="discourse_live_text1",
+                value=st.session_state.discourse_live_state.get('current_text1', ''),
+                label_visibility="collapsed"
+            )
+            st.session_state.discourse_live_state['current_text1'] = text_input1
+
+        # Texto 2
+        with text_col2:
+            st.markdown("**Texto 2 (Comparación)**")
+            text_input2 = st.text_area(
+                "Texto 2",
+                height=200,
+                key="discourse_live_text2",
+                value=st.session_state.discourse_live_state.get('current_text2', ''),
+                label_visibility="collapsed"
+            )
+            st.session_state.discourse_live_state['current_text2'] = text_input2
+
+        # Botón de análisis centrado
+        col1, col2, col3 = st.columns([1,2,1])
+        with col1:
+            analyze_button = st.button(
+                discourse_t.get('analyze_button', 'Analizar'),
+                key="discourse_live_analyze",
+                type="primary",
+                icon="🔍",
+                disabled=not (text_input1 and text_input2),
+                use_container_width=True
+            )
+
+        # Proceso y visualización de resultados
+        if analyze_button and text_input1 and text_input2:
+            try:
+                with st.spinner(discourse_t.get('processing', 'Procesando...')):
+                    result = perform_discourse_analysis(
+                        text_input1,
+                        text_input2,
+                        nlp_models[lang_code],
+                        lang_code
+                    )
+
+                    if result['success']:
+                        # Procesar ambos gráficos
+                        for graph_key in ['graph1', 'graph2']:
+                            if graph_key in result and result[graph_key] is not None:
+                                bytes_key = f'{graph_key}_bytes'
+                                graph_bytes = fig_to_bytes(result[graph_key])
+                                if graph_bytes:
+                                    result[bytes_key] = graph_bytes
+                                plt.close(result[graph_key])
+
+                        st.session_state.discourse_live_state['last_result'] = result
+                        st.session_state.discourse_live_state['analysis_count'] += 1
+                        
+                        store_student_discourse_result(
+                            st.session_state.username,
+                            text_input1,
+                            text_input2,
+                            result
+                        )
+
+                        # Mostrar resultados
+                        st.markdown("---")
+                        st.subheader(discourse_t.get('results_title', 'Resultados del Análisis'))
+                        display_discourse_results(result, lang_code, discourse_t)
+
+                    else:
+                        st.error(result.get('message', 'Error en el análisis'))
+
+            except Exception as e:
+                logger.error(f"Error en análisis: {str(e)}")
+                st.error(discourse_t.get('error_processing', f'Error al procesar el texto: {str(e)}'))
+
+        # Mostrar resultados previos si existen
+        elif 'last_result' in st.session_state.discourse_live_state and \
+             st.session_state.discourse_live_state['last_result'] is not None:
+            
+            st.markdown("---")
+            st.subheader(discourse_t.get('previous_results', 'Resultados del Análisis Anterior'))
+            display_discourse_results(
+                st.session_state.discourse_live_state['last_result'],
+                lang_code,
+                discourse_t
+            )
+
+    except Exception as e:
+        logger.error(f"Error general en interfaz del discurso en vivo: {str(e)}")
+        st.error(discourse_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
+
+
+

modules/semantic/semantic_interface.py

@@ -143,62 +143,135 @@ def display_semantic_results(semantic_result, lang_code, semantic_t):
     """
     Muestra los resultados del análisis semántico de conceptos clave.
     """
-    # Verificar resultado
     if semantic_result is None or not semantic_result['success']:
         st.warning(semantic_t.get('no_results', 'No results available'))
         return
 
     analysis = semantic_result['analysis']
 
-    # Crear contenedor para los resultados con proporciones ajustadas
-    col1, col2 = st.columns([1, 2])  # Cambio de [1, 1] a [1, 2] para dar más espacio al grafo
-
-    # Columna 1: Lista de conceptos clave
-    with col1:
-        st.subheader(semantic_t.get('key_concepts', 'Key Concepts'))
-        if 'key_concepts' in analysis and analysis['key_concepts']:
-            # Crear tabla de conceptos
-            df = pd.DataFrame(
-                analysis['key_concepts'], 
-                columns=[
-                    semantic_t.get('concept', 'Concept'),
-                    semantic_t.get('frequency', 'Frequency')
-                ]
-            )
-            st.dataframe(
-                df,
-                hide_index=True,
-                column_config={
-                    semantic_t.get('frequency', 'Frequency'): st.column_config.NumberColumn(
-                        format="%.2f"
-                    )
-                },
-                height=400  # Añadido para dar más altura a la tabla
-            )
-        else:
-            st.info(semantic_t.get('no_concepts', 'No key concepts found'))
+    # Mostrar conceptos clave en formato horizontal
+    st.subheader(semantic_t.get('key_concepts', 'Key Concepts'))
+    if 'key_concepts' in analysis and analysis['key_concepts']:
+        # Crear tabla de conceptos
+        df = pd.DataFrame(
+            analysis['key_concepts'],
+            columns=[
+                semantic_t.get('concept', 'Concept'),
+                semantic_t.get('frequency', 'Frequency')
+            ]
+        )
+        
+        # Convertir DataFrame a formato horizontal
+        st.write(
+            """
+            <style>
+            .concept-table {
+                display: flex;
+                flex-wrap: wrap;
+                gap: 10px;
+                margin-bottom: 20px;
+            }
+            .concept-item {
+                background-color: #f0f2f6;
+                border-radius: 5px;
+                padding: 8px 12px;
+                display: flex;
+                align-items: center;
+                gap: 8px;
+            }
+            .concept-name {
+                font-weight: bold;
+            }
+            .concept-freq {
+                color: #666;
+                font-size: 0.9em;
+            }
+            </style>
+            <div class="concept-table">
+            """ + 
+            ''.join([
+                f'<div class="concept-item"><span class="concept-name">{concept}</span>'
+                f'<span class="concept-freq">({freq:.2f})</span></div>'
+                for concept, freq in df.values
+            ]) +
+            "</div>",
+            unsafe_allow_html=True
+        )
+    else:
+        st.info(semantic_t.get('no_concepts', 'No key concepts found'))
 
-    # Columna 2: Gráfico de conceptos
-    with col2:
-        st.subheader(semantic_t.get('concept_graph', 'Concepts Graph'))
-        if 'concept_graph' in analysis and analysis['concept_graph'] is not None:
-            # Contenedor para centrar la imagen
+    # Gráfico de conceptos
+    st.subheader(semantic_t.get('concept_graph', 'Concepts Graph'))
+    if 'concept_graph' in analysis and analysis['concept_graph'] is not None:
+        try:
+            # Container para el grafo con estilos mejorados
             st.markdown(
                 """
                 <style>
-                    .stImage > img {
-                        max-width: 100%;
-                        display: block;
-                        margin: 0 auto;
-                    }
+                .graph-container {
+                    background-color: white;
+                    border-radius: 10px;
+                    padding: 20px;
+                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                    margin: 10px 0;
+                }
+                .button-container {
+                    display: flex;
+                    gap: 10px;
+                    margin: 10px 0;
+                }
                 </style>
-                """, 
+                """,
                 unsafe_allow_html=True
             )
-            st.image(analysis['concept_graph'], use_column_width=True)
-        else:
-            st.info(semantic_t.get('no_graph', 'No concept graph available'))
 
+            with st.container():
+                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
+                
+                # Mostrar grafo
+                graph_bytes = analysis['concept_graph']
+                graph_base64 = base64.b64encode(graph_bytes).decode()
+                st.markdown(
+                    f'<img src="data:image/png;base64,{graph_base64}" alt="Concept Graph" style="width:100%;"/>',
+                    unsafe_allow_html=True
+                )
+                
+                # Leyenda del grafo
+                st.caption(semantic_t.get(
+                    'graph_description',
+                    'Visualización de relaciones entre conceptos clave identificados en el texto.'
+                ))
+                
+                st.markdown('</div>', unsafe_allow_html=True)
+
+            # Contenedor para botones
+            col1, col2 = st.columns([1,4])
+            with col1:
+                st.download_button(
+                    label="📥 " + semantic_t.get('download_graph', "Download"),
+                    data=graph_bytes,
+                    file_name="semantic_graph.png",
+                    mime="image/png",
+                    use_container_width=True
+                )
+            
+            # Expandible con la interpretación
+            with st.expander("📊 " + semantic_t.get('graph_help', "Graph Interpretation")):
+                st.markdown("""
+                    - 🔀 Las flechas indican la dirección de la relación entre conceptos
+                    - 🎨 Los colores más intensos indican conceptos más centrales en el texto
+                    - ⭕ El tamaño de los nodos representa la frecuencia del concepto
+                    - ↔️ El grosor de las líneas indica la fuerza de la conexión
+                """)
+        
+        except Exception as e:
+            logger.error(f"Error displaying graph: {str(e)}")
+            st.error(semantic_t.get('graph_error', 'Error displaying the graph'))
+    else:
+        st.info(semantic_t.get('no_graph', 'No concept graph available'))
+
+
+########################################################################################
 '''
     # Botón de exportación al final
     if 'semantic_analysis_counter' in st.session_state:

modules/semantic/semantic_live_interface.py

@@ -20,54 +20,54 @@ from ..database.chat_mongo_db import store_chat_history, get_chat_history
 
 def display_semantic_live_interface(lang_code, nlp_models, semantic_t):
     """
-    Interfaz para el análisis semántico en vivo
-    Args:
-        lang_code: Código del idioma actual
-        nlp_models: Modelos de spaCy cargados
-        semantic_t: Diccionario de traducciones semánticas
+    Interfaz para el análisis semántico en vivo con proporciones de columna ajustadas
     """
     try:
-        # 1. Inicializar el estado de la sesión para el análisis en vivo
+        # 1. Inicializar el estado de la sesión de manera más robusta
         if 'semantic_live_state' not in st.session_state:
             st.session_state.semantic_live_state = {
                 'analysis_count': 0,
-                'last_analysis': None,
-                'current_text': ''
+                'current_text': '',
+                'last_result': None,
+                'text_changed': False
             }
 
-        # 2. Crear dos columnas
-        col1, col2 = st.columns(2)
+        # 2. Función para manejar cambios en el texto
+        def on_text_change():
+            current_text = st.session_state.semantic_live_text
+            st.session_state.semantic_live_state['current_text'] = current_text
+            st.session_state.semantic_live_state['text_changed'] = True
+
+        # 3. Crear columnas con nueva proporción (1:3)
+        input_col, result_col = st.columns([1, 3])
 
         # Columna izquierda: Entrada de texto
-        with col1:
+        with input_col:
             st.subheader(semantic_t.get('enter_text', 'Ingrese su texto'))
             
-            # Área de texto para input
+            # Área de texto con manejo de eventos
             text_input = st.text_area(
                 semantic_t.get('text_input_label', 'Escriba o pegue su texto aquí'),
-                height=400,
-                key=f"semantic_live_text_{st.session_state.semantic_live_state['analysis_count']}"
+                height=500,
+                key="semantic_live_text",
+                value=st.session_state.semantic_live_state.get('current_text', ''),
+                on_change=on_text_change,
+                label_visibility="collapsed"  # Oculta el label para mayor estabilidad
             )
 
-            # Botón de análisis
+            # Botón de análisis y procesamiento
             analyze_button = st.button(
                 semantic_t.get('analyze_button', 'Analizar'),
-                key=f"semantic_live_analyze_{st.session_state.semantic_live_state['analysis_count']}",
+                key="semantic_live_analyze",
                 type="primary",
                 icon="🔍",
                 disabled=not text_input,
                 use_container_width=True
             )
 
-        # Columna derecha: Visualización de resultados
-        with col2:
-            st.subheader(semantic_t.get('live_results', 'Resultados en vivo'))
-
-            # Procesar análisis cuando se presiona el botón
             if analyze_button and text_input:
                 try:
                     with st.spinner(semantic_t.get('processing', 'Procesando...')):
-                        # Realizar análisis
                         analysis_result = process_semantic_input(
                             text_input,
                             lang_code,
@@ -76,49 +76,122 @@ def display_semantic_live_interface(lang_code, nlp_models, semantic_t):
                         )
 
                         if analysis_result['success']:
-                            # Guardar resultado
-                            st.session_state.semantic_live_result = analysis_result
+                            st.session_state.semantic_live_state['last_result'] = analysis_result
                             st.session_state.semantic_live_state['analysis_count'] += 1
+                            st.session_state.semantic_live_state['text_changed'] = False
                             
-                            # Guardar en base de datos
                             store_student_semantic_result(
                                 st.session_state.username,
                                 text_input,
                                 analysis_result['analysis']
                             )
-
-                            # Mostrar gráfico de conceptos
-                            if 'concept_graph' in analysis_result['analysis'] and analysis_result['analysis']['concept_graph'] is not None:
-                                st.image(analysis_result['analysis']['concept_graph'])
-                            else:
-                                st.info(semantic_t.get('no_graph', 'No hay gráfico disponible'))
-
-                            # Mostrar tabla de conceptos clave
-                            if 'key_concepts' in analysis_result['analysis'] and analysis_result['analysis']['key_concepts']:
-                                st.subheader(semantic_t.get('key_concepts', 'Conceptos Clave'))
-                                df = pd.DataFrame(
-                                    analysis_result['analysis']['key_concepts'],
-                                    columns=[
-                                        semantic_t.get('concept', 'Concepto'),
-                                        semantic_t.get('frequency', 'Frecuencia')
-                                    ]
-                                )
-                                st.dataframe(
-                                    df,
-                                    hide_index=True,
-                                    column_config={
-                                        semantic_t.get('frequency', 'Frecuencia'): st.column_config.NumberColumn(
-                                            format="%.2f"
-                                        )
-                                    }
-                                )
                         else:
-                            st.error(analysis_result['message'])
+                            st.error(analysis_result.get('message', 'Error en el análisis'))
 
                 except Exception as e:
-                    logger.error(f"Error en análisis semántico en vivo: {str(e)}")
-                    st.error(semantic_t.get('error_processing', f'Error al procesar el texto: {str(e)}'))
+                    logger.error(f"Error en análisis: {str(e)}")
+                    st.error(semantic_t.get('error_processing', 'Error al procesar el texto'))
+
+        # Columna derecha: Visualización de resultados
+        with result_col:
+            st.subheader(semantic_t.get('live_results', 'Resultados en vivo'))
+
+            if 'last_result' in st.session_state.semantic_live_state and \
+               st.session_state.semantic_live_state['last_result'] is not None:
+                
+                analysis = st.session_state.semantic_live_state['last_result']['analysis']
+
+                if 'key_concepts' in analysis and analysis['key_concepts'] and \
+                   'concept_graph' in analysis and analysis['concept_graph'] is not None:
+                    
+                    st.markdown("""
+                        <style>
+                        .unified-container {
+                            background-color: white;
+                            border-radius: 10px;
+                            overflow: hidden;
+                            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                            width: 100%;
+                            margin-bottom: 1rem;
+                        }
+                        .concept-table {
+                            display: flex;
+                            flex-wrap: nowrap;  /* Evita el wrap */
+                            gap: 6px;           /* Reducido el gap */
+                            padding: 10px;
+                            background-color: #f8f9fa;
+                            overflow-x: auto;    /* Permite scroll horizontal si es necesario */
+                            white-space: nowrap; /* Mantiene todo en una línea */
+                        }
+                        .concept-item {
+                            background-color: white;
+                            border-radius: 4px;
+                            padding: 4px 8px;    /* Padding reducido */
+                            display: inline-flex; /* Cambiado a inline-flex */
+                            align-items: center;
+                            gap: 4px;            /* Gap reducido */
+                            box-shadow: 0 1px 2px rgba(0,0,0,0.1);
+                            flex-shrink: 0;      /* Evita que los items se encojan */
+                        }
+                        .concept-name { 
+                            font-weight: 500; 
+                            color: #1f2937;
+                            font-size: 0.8em;    /* Tamaño de fuente reducido */
+                        }
+                        .concept-freq { 
+                            color: #6b7280; 
+                            font-size: 0.75em;   /* Tamaño de fuente reducido */
+                        }
+                        .graph-section { 
+                            padding: 20px;
+                            background-color: white;
+                        }
+                        </style>
+                    """, unsafe_allow_html=True)
+
+                    with st.container():
+                        # Conceptos en una sola línea
+                        concepts_html = """
+                        <div class="unified-container">
+                            <div class="concept-table">
+                        """
+                        concepts_html += ''.join(
+                            f'<div class="concept-item"><span class="concept-name">{concept}</span>'
+                            f'<span class="concept-freq">({freq:.2f})</span></div>'
+                            for concept, freq in analysis['key_concepts']
+                        )
+                        concepts_html += "</div></div>"
+                        st.markdown(concepts_html, unsafe_allow_html=True)
+                        
+                        # Grafo
+                        if 'concept_graph' in analysis and analysis['concept_graph'] is not None:
+                            st.image(
+                                analysis['concept_graph'],
+                                use_container_width=True
+                            )
+
+                        # Botones y controles
+                        button_col, spacer_col = st.columns([1,5])
+                        with button_col:
+                            st.download_button(
+                                label="📥 " + semantic_t.get('download_graph', "Download"),
+                                data=analysis['concept_graph'],
+                                file_name="semantic_live_graph.png",
+                                mime="image/png",
+                                use_container_width=True
+                            )
+                        
+                        with st.expander("📊 " + semantic_t.get('graph_help', "Graph Interpretation")):
+                            st.markdown("""
+                                - 🔀 Las flechas indican la dirección de la relación entre conceptos
+                                - 🎨 Los colores más intensos indican conceptos más centrales en el texto
+                                - ⭕ El tamaño de los nodos representa la frecuencia del concepto
+                                - ↔️ El grosor de las líneas indica la fuerza de la conexión
+                            """)
+                else:
+                    st.info(semantic_t.get('no_graph', 'No hay datos para mostrar'))
 
     except Exception as e:
         logger.error(f"Error general en interfaz semántica en vivo: {str(e)}")
-        st.error(semantic_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
+        st.error(semantic_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
+

modules/text_analysis/semantic_analysis.py

@@ -20,6 +20,7 @@ logger = logging.getLogger(__name__)
 # 4. Importaciones locales
 from .stopwords import (
     process_text,
+    clean_text,
     get_custom_stopwords,
     get_stopwords_for_spacy
 )
@@ -182,25 +183,48 @@ def perform_semantic_analysis(text, nlp, lang_code):
 
 def identify_key_concepts(doc, stopwords, min_freq=2, min_length=3):
     """
-    Identifica conceptos clave en el texto.
+    Identifica conceptos clave en el texto, excluyendo entidades nombradas.
+    Args:
+        doc: Documento procesado por spaCy
+        stopwords: Lista de stopwords
+        min_freq: Frecuencia mínima para considerar un concepto
+        min_length: Longitud mínima del concepto
+    Returns:
+        List[Tuple[str, int]]: Lista de tuplas (concepto, frecuencia)
     """
     try:
         word_freq = Counter()
         
+        # Crear conjunto de tokens que son parte de entidades
+        entity_tokens = set()
+        for ent in doc.ents:
+            entity_tokens.update(token.i for token in ent)
+        
+        # Procesar tokens
         for token in doc:
-            if (token.lemma_.lower() not in stopwords and
-                len(token.lemma_) >= min_length and
-                token.is_alpha and
-                not token.is_punct and
-                not token.like_num):
+            # Verificar si el token no es parte de una entidad nombrada
+            if (token.i not in entity_tokens and  # No es parte de una entidad
+                token.lemma_.lower() not in stopwords and  # No es stopword
+                len(token.lemma_) >= min_length and  # Longitud mínima
+                token.is_alpha and  # Es alfabético
+                not token.is_punct and  # No es puntuación
+                not token.like_num and  # No es número
+                not token.is_space and  # No es espacio
+                not token.is_stop and  # No es stopword de spaCy
+                not token.pos_ == 'PROPN' and  # No es nombre propio
+                not token.pos_ == 'SYM' and  # No es símbolo
+                not token.pos_ == 'NUM' and  # No es número
+                not token.pos_ == 'X'):  # No es otro
                 
+                # Convertir a minúsculas y añadir al contador
                 word_freq[token.lemma_.lower()] += 1
         
+        # Filtrar conceptos por frecuencia mínima y ordenar por frecuencia
         concepts = [(word, freq) for word, freq in word_freq.items() 
                    if freq >= min_freq]
         concepts.sort(key=lambda x: x[1], reverse=True)
         
-        logger.info(f"Identified {len(concepts)} key concepts")
+        logger.info(f"Identified {len(concepts)} key concepts after excluding entities")
         return concepts[:10]
         
     except Exception as e:
@@ -208,9 +232,10 @@ def identify_key_concepts(doc, stopwords, min_freq=2, min_length=3):
         return []
 
 ########################################################################
+
 def create_concept_graph(doc, key_concepts):
     """
-    Crea un grafo de relaciones entre conceptos.
+    Crea un grafo de relaciones entre conceptos, ignorando entidades.
     Args:
         doc: Documento procesado por spaCy
         key_concepts: Lista de tuplas (concepto, frecuencia)
@@ -223,26 +248,30 @@ def create_concept_graph(doc, key_concepts):
         # Crear un conjunto de conceptos clave para búsqueda rápida
         concept_words = {concept[0].lower() for concept in key_concepts}
         
+        # Crear conjunto de tokens que son parte de entidades
+        entity_tokens = set()
+        for ent in doc.ents:
+            entity_tokens.update(token.i for token in ent)
+        
         # Añadir nodos al grafo
         for concept, freq in key_concepts:
             G.add_node(concept.lower(), weight=freq)
         
         # Analizar cada oración
         for sent in doc.sents:
-            # Obtener conceptos en la oración actual
+            # Obtener conceptos en la oración actual, excluyendo entidades
             current_concepts = []
             for token in sent:
-                if token.lemma_.lower() in concept_words:
+                if (token.i not in entity_tokens and 
+                    token.lemma_.lower() in concept_words):
                     current_concepts.append(token.lemma_.lower())
             
             # Crear conexiones entre conceptos en la misma oración
             for i, concept1 in enumerate(current_concepts):
                 for concept2 in current_concepts[i+1:]:
                     if concept1 != concept2:
-                        # Si ya existe la arista, incrementar el peso
                         if G.has_edge(concept1, concept2):
                             G[concept1][concept2]['weight'] += 1
-                        # Si no existe, crear nueva arista con peso 1
                         else:
                             G.add_edge(concept1, concept2, weight=1)
         
@@ -250,53 +279,109 @@ def create_concept_graph(doc, key_concepts):
         
     except Exception as e:
         logger.error(f"Error en create_concept_graph: {str(e)}")
-        # Retornar un grafo vacío en caso de error
         return nx.Graph()
 
 ###############################################################################
+
 def visualize_concept_graph(G, lang_code):
     """
-    Visualiza el grafo de conceptos con nodos ajustados según la longitud del texto.
+    Visualiza el grafo de conceptos con layout consistente.
+    Args:
+        G: networkx.Graph - Grafo de conceptos
+        lang_code: str - Código del idioma
+    Returns:
+        matplotlib.figure.Figure - Figura del grafo
     """
     try:
-        # Crear nueva figura con mayor tamaño
-        fig = plt.figure(figsize=(15, 10))  # Aumentado de (12, 8) a (15, 10)
+        # Crear nueva figura con mayor tamaño y definir los ejes explícitamente
+        fig, ax = plt.subplots(figsize=(15, 10))
         
         if not G.nodes():
             logger.warning("Grafo vacío, retornando figura vacía")
             return fig
             
-        # Calcular layout con más espacio
-        pos = nx.spring_layout(G, k=2, iterations=50)  # Aumentado k de 1 a 2
+        # Convertir grafo no dirigido a dirigido para mostrar flechas
+        DG = nx.DiGraph(G)
+        
+        # Calcular centralidad de los nodos para el color
+        centrality = nx.degree_centrality(G)
+        
+        # Establecer semilla para reproducibilidad
+        seed = 42
+        
+        # Calcular layout con parámetros fijos
+        pos = nx.spring_layout(
+            DG,
+            k=2,          # Distancia ideal entre nodos
+            iterations=50, # Número de iteraciones
+            seed=seed     # Semilla fija para reproducibilidad
+        )
         
         # Calcular factor de escala basado en número de nodos
-        num_nodes = len(G.nodes())
+        num_nodes = len(DG.nodes())
         scale_factor = 1000 if num_nodes < 10 else 500 if num_nodes < 20 else 200
         
         # Obtener pesos ajustados
-        node_weights = [G.nodes[node].get('weight', 1) * scale_factor for node in G.nodes()]
-        edge_weights = [G[u][v].get('weight', 1) for u, v in G.edges()]
-        
-        # Dibujar grafo
-        nx.draw_networkx_nodes(G, pos, 
-                             node_size=node_weights,
-                             node_color='lightblue',
-                             alpha=0.6)
-        
-        nx.draw_networkx_edges(G, pos,
-                             width=edge_weights,
-                             alpha=0.5,
-                             edge_color='gray')
+        node_weights = [DG.nodes[node].get('weight', 1) * scale_factor for node in DG.nodes()]
+        edge_weights = [DG[u][v].get('weight', 1) for u, v in DG.edges()]
+        
+        # Crear mapa de colores basado en centralidad
+        node_colors = [plt.cm.viridis(centrality[node]) for node in DG.nodes()]
+        
+        # Dibujar nodos
+        nodes = nx.draw_networkx_nodes(
+            DG, 
+            pos, 
+            node_size=node_weights,
+            node_color=node_colors,
+            alpha=0.7,
+            ax=ax
+        )
+        
+        # Dibujar aristas con flechas
+        edges = nx.draw_networkx_edges(
+            DG, 
+            pos,
+            width=edge_weights,
+            alpha=0.6,
+            edge_color='gray',
+            arrows=True,
+            arrowsize=20,
+            arrowstyle='->',
+            connectionstyle='arc3,rad=0.2',
+            ax=ax
+        )
         
         # Ajustar tamaño de fuente según número de nodos
         font_size = 12 if num_nodes < 10 else 10 if num_nodes < 20 else 8
         
-        nx.draw_networkx_labels(G, pos,
-                              font_size=font_size,
-                              font_weight='bold')
-        
-        plt.title("Red de conceptos relacionados", pad=20)
-        plt.axis('off')
+        # Dibujar etiquetas con fondo blanco para mejor legibilidad
+        labels = nx.draw_networkx_labels(
+            DG, 
+            pos,
+            font_size=font_size,
+            font_weight='bold',
+            bbox=dict(
+                facecolor='white', 
+                edgecolor='none', 
+                alpha=0.7
+            ),
+            ax=ax
+        )
+        
+        # Añadir leyenda de centralidad
+        sm = plt.cm.ScalarMappable(
+            cmap=plt.cm.viridis, 
+            norm=plt.Normalize(vmin=0, vmax=1)
+        )
+        sm.set_array([])
+        plt.colorbar(sm, ax=ax, label='Centralidad del concepto')
+        
+        plt.title("Red de conceptos relacionados", pad=20, fontsize=14)
+        ax.set_axis_off()
+        
+        # Ajustar el layout para que la barra de color no se superponga
+        plt.tight_layout()
         
         return fig
         
@@ -304,7 +389,6 @@ def visualize_concept_graph(G, lang_code):
         logger.error(f"Error en visualize_concept_graph: {str(e)}")
         return plt.figure()  # Retornar figura vacía en caso de error
 
-
 ########################################################################
 def create_entity_graph(entities):
     G = nx.Graph()

modules/ui/ui.py

@@ -64,6 +64,8 @@ from ..semantic.semantic_interface import (
 
 from ..semantic.semantic_live_interface import display_semantic_live_interface
 
+from ..discourse.discourse_live_interface import display_discourse_live_interface
+
 from ..discourse.discourse_interface import (    # Agregar esta importación
     display_discourse_interface,
     display_discourse_results
@@ -328,6 +330,10 @@ def user_page(lang_code, t):
     if 'selected_tab' not in st.session_state:
         st.session_state.selected_tab = 0
 
+    # Inicializar el estado del análisis en vivo
+    if 'semantic_live_active' not in st.session_state:
+        st.session_state.semantic_live_active = False
+
     # Manejar la carga inicial de datos del usuario
     if 'user_data' not in st.session_state:
         with st.spinner(t.get('loading_data', "Cargando tus datos...")):
@@ -394,66 +400,136 @@ def user_page(lang_code, t):
     # Mostrar chatbot en sidebar
     display_sidebar_chat(lang_code, chatbot_t)
 
+    # Inicializar estados para todos los tabs
+    if 'tab_states' not in st.session_state:
+        st.session_state.tab_states = {
+            'morpho_active': False,
+            'semantic_live_active': False,
+            'semantic_active': False,
+            'discourse_live_active': False,
+            'discourse_active': False,
+            'activities_active': False,
+            'feedback_active': False
+        }
+    
     # Sistema de tabs
-    tabs = st.tabs([
+    tab_names = [
         t.get('morpho_tab', 'Análisis Morfosintáctico'),
-        t.get('semantic_live_tab', 'Análisis Semántico Vivo'),  # Nuevo tab
+        t.get('semantic_live_tab', 'Análisis Semántico Vivo'),
         t.get('semantic_tab', 'Análisis Semántico'),
-        t.get('discourse_tab', 'Análsis de discurso'),
+        t.get('discourse_live_tab', 'Análisis de Discurso Vivo'),
+        t.get('discourse_tab', 'Análsis de Discurso'),
         t.get('activities_tab', 'Mis Actividades'),
         t.get('feedback_tab', 'Formulario de Comentarios')
-    ])
+    ]
+    
+    tabs = st.tabs(tab_names)
 
     # Manejar el contenido de cada tab
     for index, tab in enumerate(tabs):
-        if tab.selected:
-            st.session_state.selected_tab = index
-    
         with tab:
             try:
-                if index == 0:
+                # Actualizar el tab seleccionado solo si no hay un análisis activo
+                if tab.selected and st.session_state.selected_tab != index:
+                    can_switch = True
+                    for state_key in st.session_state.tab_states.keys():
+                        if st.session_state.tab_states[state_key] and index != get_tab_index(state_key):
+                            can_switch = False
+                            break
+                    if can_switch:
+                        st.session_state.selected_tab = index
+
+                if index == 0:  # Morfosintáctico
+                    st.session_state.tab_states['morpho_active'] = True
                     display_morphosyntax_interface(
                         st.session_state.lang_code,
                         st.session_state.nlp_models,
                         t.get('TRANSLATIONS', {})
                     )
 
-                elif index == 1:  # Nuevo caso para el análisis semántico vivo
+                elif index == 1:  # Semántico Vivo
+                    st.session_state.tab_states['semantic_live_active'] = True
                     display_semantic_live_interface(
                         st.session_state.lang_code,
                         st.session_state.nlp_models,
                         t.get('TRANSLATIONS', {})
                     )
-                
-                
-                elif index == 2:
+
+                elif index == 2:  # Semántico
+                    st.session_state.tab_states['semantic_active'] = True
                     display_semantic_interface(
                         st.session_state.lang_code,
                         st.session_state.nlp_models,
                         t.get('TRANSLATIONS', {})
                     )
 
-                elif index == 3:
+                elif index == 3:  # Discurso Vivo
+                    st.session_state.tab_states['discourse_live_active'] = True
+                    display_discourse_live_interface(
+                        st.session_state.lang_code,
+                        st.session_state.nlp_models,
+                        t.get('TRANSLATIONS', {})
+                    )
+                
+                
+                elif index == 4:  # Discurso
+                    st.session_state.tab_states['discourse_active'] = True
                     display_discourse_interface(
                         st.session_state.lang_code,
                         st.session_state.nlp_models,
                         t.get('TRANSLATIONS', {})
                     )
-                elif index == 4:
+
+                elif index == 5:  # Actividades
+                    st.session_state.tab_states['activities_active'] = True
                     display_student_activities(
                         username=st.session_state.username,
                         lang_code=st.session_state.lang_code,
                         t=t.get('ACTIVITIES_TRANSLATIONS', {})
                     )
-                elif index == 5:
+
+                elif index == 6:  # Feedback
+                    st.session_state.tab_states['feedback_active'] = True
                     display_feedback_form(
                         st.session_state.lang_code,
                         t
                     )
+
             except Exception as e:
+                # Desactivar el estado en caso de error
+                state_key = get_state_key_for_index(index)
+                if state_key:
+                    st.session_state.tab_states[state_key] = False
                 logger.error(f"Error en tab {index}: {str(e)}")
                 st.error(t.get('tab_error', 'Error al cargar esta sección'))
 
+# Funciones auxiliares para manejar los estados de los tabs
+def get_tab_index(state_key):
+    """Obtiene el índice del tab basado en la clave de estado"""
+    index_map = {
+        'morpho_active': 0,
+        'semantic_live_active': 1,
+        'semantic_active': 2,
+        'discourse_live_active': 3,
+        'discourse_active': 4,
+        'activities_active': 5,
+        'feedback_active': 6
+    }
+    return index_map.get(state_key, -1)
+
+def get_state_key_for_index(index):
+    """Obtiene la clave de estado basada en el índice del tab"""
+    state_map = {
+        0: 'morpho_active',
+        1: 'semantic_live_active',
+        2: 'semantic_active',
+        3: 'discourse_live_active',
+        3: 'discourse_active',
+        4: 'activities_active',
+        5: 'feedback_active'
+    }
+    return state_map.get(index)
+
     # Panel de depuración (solo visible en desarrollo)
     if st.session_state.get('debug_mode', False):
         with st.expander("Debug Info"):