' +
+ ''.join([
+ f'
",
+ unsafe_allow_html=True
+ )
+
+ if 'graph1' in result and result['graph1']:
+ st.image(result['graph1'], use_container_width=True)
+
+ # Documento 2
+ with col2:
+ st.subheader(discourse_t.get('compare_doc2_title', 'Documento 2'))
+ if 'key_concepts2' in result:
+ df2 = pd.DataFrame(
+ result['key_concepts2'],
+ columns=[discourse_t.get('concept', 'Concepto'), discourse_t.get('frequency', 'Frecuencia')]
+ )
+ st.write(
+ '{concept}'
+ f'({freq:.2f})
'
+ for concept, freq in df1.values
+ ]) + "' +
+ ''.join([
+ f'
",
+ unsafe_allow_html=True
+ )
+
+ if 'graph2' in result and result['graph2']:
+ st.image(result['graph2'], use_container_width=True)
+
+ # Sección unificada de interpretación (como semantic_interface)
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ with st.expander("📊 " + discourse_t.get('semantic_graph_interpretation', "Interpretación de los gráficos")):
+ st.markdown(f"""
+ - 🔀 {discourse_t.get('compare_arrow_meaning', 'Las flechas indican la dirección de la relación entre conceptos')}
+ - 🎨 {discourse_t.get('compare_color_meaning', 'Los colores más intensos indican conceptos más centrales en el texto')}
+ - ⭕ {discourse_t.get('compare_size_meaning', 'El tamaño de los nodos representa la frecuencia del concepto')}
+ - ↔️ {discourse_t.get('compare_thickness_meaning', 'El grosor de las líneas indica la fuerza de la conexión')}
+ """)
+
+ # Botón de descarga combinado (para ambas imágenes)
+ if 'graph1' in result and 'graph2' in result and result['graph1'] and result['graph2']:
+ # Crear figura combinada
+ fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 10))
+
+ # Mostrar primer gráfico
+ if isinstance(result['graph1'], bytes):
+ img1 = plt.imread(io.BytesIO(result['graph1']))
+ ax1.imshow(img1)
+ ax1.axis('off')
+ ax1.set_title(discourse_t.get('compare_doc1_title', 'Documento 1'))
+
+ # Mostrar segundo gráfico
+ if isinstance(result['graph2'], bytes):
+ img2 = plt.imread(io.BytesIO(result['graph2']))
+ ax2.imshow(img2)
+ ax2.axis('off')
+ ax2.set_title(discourse_t.get('compare_doc2_title', 'Documento 2'))
+
+ plt.tight_layout()
+
+ # Convertir a bytes
+ buf = io.BytesIO()
+ plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
+ buf.seek(0)
+
+ # Botón de descarga
+ st.markdown('{concept}'
+ f'({freq:.2f})
'
+ for concept, freq in df2.values
+ ]) + "', unsafe_allow_html=True)
+ st.download_button(
+ label="📥 " + discourse_t.get('download_both_graphs', "Descargar ambos gráficos"),
+ data=buf,
+ file_name="comparison_graphs.png",
+ mime="image/png",
+ use_container_width=True
+ )
+ st.markdown('
', unsafe_allow_html=True)
+
+ plt.close()
\ No newline at end of file
diff --git a/src/modules/discourse/discourse_live_interface.py b/src/modules/discourse/discourse_live_interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..564c0dd216a73e3c924bd3a10264459fbb84c507
--- /dev/null
+++ b/src/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."))
+
+
+
diff --git a/src/modules/discourse/discourse_process.py b/src/modules/discourse/discourse_process.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9379e77331b3d300ad21e53cac26098a039a754
--- /dev/null
+++ b/src/modules/discourse/discourse_process.py
@@ -0,0 +1,68 @@
+from ..text_analysis.discourse_analysis import perform_discourse_analysis, compare_semantic_analysis
+import streamlit as st
+
+def process_discourse_input(text1, text2, nlp_models, lang_code):
+ """
+ Procesa la entrada para el análisis del discurso
+ Args:
+ text1: Texto del primer documento
+ text2: Texto del segundo documento
+ nlp_models: Diccionario de modelos de spaCy
+ lang_code: Código del idioma actual
+ Returns:
+ dict: Resultados del análisis
+ """
+ try:
+ # Obtener el modelo específico del idioma
+ nlp = nlp_models[lang_code]
+
+ # Realizar el análisis
+ analysis_result = perform_discourse_analysis(text1, text2, nlp, lang_code)
+
+ if analysis_result['success']:
+ return {
+ 'success': True,
+ 'analysis': analysis_result
+ }
+ else:
+ return {
+ 'success': False,
+ 'error': 'Error en el análisis del discurso'
+ }
+
+ except Exception as e:
+ logger.error(f"Error en process_discourse_input: {str(e)}")
+ return {
+ 'success': False,
+ 'error': str(e)
+ }
+
+def format_discourse_results(result):
+ """
+ Formatea los resultados del análisis para su visualización
+ Args:
+ result: Resultado del análisis
+ Returns:
+ dict: Resultados formateados
+ """
+ try:
+ if not result['success']:
+ return result
+
+ analysis = result['analysis']
+ return {
+ 'success': True,
+ 'graph1': analysis['graph1'],
+ 'graph2': analysis['graph2'],
+ 'key_concepts1': analysis['key_concepts1'],
+ 'key_concepts2': analysis['key_concepts2'],
+ 'table1': analysis['table1'],
+ 'table2': analysis['table2']
+ }
+
+ except Exception as e:
+ logger.error(f"Error en format_discourse_results: {str(e)}")
+ return {
+ 'success': False,
+ 'error': str(e)
+ }
\ No newline at end of file
diff --git a/src/modules/email/__init__.py b/src/modules/email/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/email/__pycache__/__init__.cpython-311.pyc b/src/modules/email/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..decd2af6d410fe2fb58d2694805363eb73aacd9d
Binary files /dev/null and b/src/modules/email/__pycache__/__init__.cpython-311.pyc differ
diff --git a/src/modules/email/__pycache__/email.cpython-311.pyc b/src/modules/email/__pycache__/email.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..766c7c57fb026d6b10afe9262588d1facb6b17e4
Binary files /dev/null and b/src/modules/email/__pycache__/email.cpython-311.pyc differ
diff --git a/src/modules/email/email.py b/src/modules/email/email.py
new file mode 100644
index 0000000000000000000000000000000000000000..878d5c53b1c1c31a51c2d7ec3bb7710784855861
--- /dev/null
+++ b/src/modules/email/email.py
@@ -0,0 +1,92 @@
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+import os
+
+def send_email_notification(name, email, institution, role, reason):
+ sender_email = "noreply@aideatext.ai" # Configura esto con tu dirección de correo
+ receiver_email = "hello@aideatext.ai"
+ password = os.environ.get("NOREPLY_EMAIL_PASSWORD") # Configura esto en tus variables de entorno
+
+ message = MIMEMultipart("alternative")
+ message["Subject"] = "Nueva solicitud de prueba de AIdeaText"
+ message["From"] = sender_email
+ message["To"] = receiver_email
+
+ text = f"""\
+ Nueva solicitud de prueba de AIdeaText:
+ Nombre: {name}
+ Email: {email}
+ Institución: {institution}
+ Rol: {role}
+ Razón: {reason}
+ """
+
+ html = f"""\
+
+
+ Nueva solicitud de prueba de AIdeaText
+Nombre: {name}
+Email: {email}
+Institución: {institution}
+Rol: {role}
+Razón: {reason}
+ + + """ + + part1 = MIMEText(text, "plain") + part2 = MIMEText(html, "html") + + message.attach(part1) + message.attach(part2) + + try: + with smtplib.SMTP_SSL("smtp.titan.email", 465) as server: + logger.info("Conectado al servidor SMTP") + server.login(sender_email, password) + logger.info("Inicio de sesión exitoso") + server.sendmail(sender_email, receiver_email, message.as_string()) + logger.info(f"Correo enviado de {sender_email} a {receiver_email}") + logger.info(f"Email notification sent for application request: {email}") + return True + except Exception as e: + logger.error(f"Error sending email notification: {str(e)}") + return False + +def send_user_feedback_notification(name, email, feedback): + sender_email = "noreply@aideatext.ai" + receiver_email = "feedback@aideatext.ai" # Cambia esto a la dirección que desees + password = os.environ.get("NOREPLY_EMAIL_PASSWORD") + + message = MIMEMultipart("alternative") + message["Subject"] = "Nuevo comentario de usuario en AIdeaText" + message["From"] = sender_email + message["To"] = receiver_email + + html = f"""\ + + +Nuevo comentario de usuario en AIdeaText
+Nombre: {name}
+Email: {email}
+Comentario: {feedback}
+ + + """ + + part = MIMEText(html, "html") + message.attach(part) + + try: + with smtplib.SMTP_SSL("smtp.titan.email", 465) as server: + logger.info("Conectado al servidor SMTP") + server.login(sender_email, password) + logger.info("Inicio de sesión exitoso") + server.sendmail(sender_email, receiver_email, message.as_string()) + logger.info(f"Correo enviado de {sender_email} a {receiver_email}") + logger.info(f"Email notification sent for user feedback from: {email}") + return True + except Exception as e: + logger.error(f"Error sending user feedback email notification: {str(e)}") + return False \ No newline at end of file diff --git a/src/modules/email/txt.txt b/src/modules/email/txt.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/modules/lost.py b/src/modules/lost.py new file mode 100644 index 0000000000000000000000000000000000000000..9a5a4fee0812e6dae79d898d23afedd8355961bd --- /dev/null +++ b/src/modules/lost.py @@ -0,0 +1,104 @@ +import streamlit as st +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns +from datetime import datetime, timedelta +import pytz +import logging +from io import BytesIO +from reportlab.pdfgen import canvas +from reportlab.lib.pagesizes import letter +from docx import Document +from odf.opendocument import OpenDocumentText +from odf.text import P + +# Configuración de logging +logging.basicConfig(level=logging.DEBUG) +logger = logging.getLogger(__name__) + +# Asumimos que estas funciones están disponibles a través de las importaciones en load_database_functions +from .database.morphosintax_mongo_db import get_student_morphosyntax_analysis, get_student_morphosyntax_data +from .database.chat_db import get_chat_history + +def display_student_progress(username, lang_code, t): + logger.debug(f"Iniciando display_student_progress para {username}") + + st.title(f"{t.get('progress_of', 'Progreso de')} {username}") + + # Obtener datos de análisis morfosintáctico + morphosyntax_data = get_student_morphosyntax_data(username) + # Obtener historial de chat + chat_history = get_chat_history(username, None) + + if not morphosyntax_data and not chat_history: + logger.warning(f"No se encontraron datos para el estudiante {username}") + st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante.")) + st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero.")) + return + + # Resumen de actividades + with st.expander(t.get("activities_summary", "Resumen de Actividades"), expanded=True): + total_morphosyntax = len(morphosyntax_data) + total_chats = len(chat_history) + st.write(f"{t.get('total_morphosyntax_analyses', 'Total de análisis morfosintácticos')}: {total_morphosyntax}") + st.write(f"{t.get('total_chats', 'Total de conversaciones de chat')}: {total_chats}") + + # Gráfico de tipos de actividades + try: + activity_counts = pd.Series({ + 'Análisis Morfosintáctico': total_morphosyntax, + 'Conversaciones de Chat': total_chats + }) + fig, ax = plt.subplots() + sns.barplot(x=activity_counts.index, y=activity_counts.values, ax=ax) + ax.set_title(t.get("activity_types_chart", "Tipos de actividades realizadas")) + ax.set_ylabel(t.get("count", "Cantidad")) + st.pyplot(fig) + except Exception as e: + logger.error(f"Error al crear el gráfico: {e}") + st.error("No se pudo crear el gráfico de tipos de actividades.") + + # Función para generar el contenido del archivo de actividades de las últimas 48 horas + def generate_activity_content_48h(): + content = f"Actividades de {username} en las últimas 48 horas\n\n" + + two_days_ago = datetime.now(pytz.utc) - timedelta(days=2) + + try: + recent_morphosyntax = [a for a in morphosyntax_data if datetime.fromisoformat(a['timestamp']) > two_days_ago] + + content += f"Análisis morfosintácticos: {len(recent_morphosyntax)}\n" + for analysis in recent_morphosyntax: + content += f"- Análisis del {analysis['timestamp']}: {analysis['text'][:50]}...\n" + + recent_chats = [c for c in chat_history if datetime.fromisoformat(c['timestamp']) > two_days_ago] + + content += f"\nConversaciones de chat: {len(recent_chats)}\n" + for chat in recent_chats: + content += f"- Chat del {chat['timestamp']}: {len(chat['messages'])} mensajes\n" + except Exception as e: + logger.error(f"Error al generar el contenido de actividades: {e}") + content += "Error al recuperar los datos de actividades.\n" + + return content + + # Botones para descargar el histórico de actividades de las últimas 48 horas + st.subheader(t.get("download_history_48h", "Descargar Histórico de Actividades (Últimas 48 horas)")) + if st.button("Generar reporte de 48 horas"): + try: + report_content = generate_activity_content_48h() + st.text_area("Reporte de 48 horas", report_content, height=300) + st.download_button( + label="Descargar TXT (48h)", + data=report_content, + file_name="actividades_48h.txt", + mime="text/plain" + ) + except Exception as e: + logger.error(f"Error al generar el reporte: {e}") + st.error("No se pudo generar el reporte. Por favor, verifica los logs para más detalles.") + + logger.debug("Finalizando display_student_progress") + +# Funciones auxiliares para generar diferentes formatos de archivo (PDF, DOCX, ODT) se mantienen igual +# ... \ No newline at end of file diff --git a/src/modules/morphosyntax/__init__.py b/src/modules/morphosyntax/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b1da8c211b7315325f058baa1f599e8ccb01f15f --- /dev/null +++ b/src/modules/morphosyntax/__init__.py @@ -0,0 +1,29 @@ +from .morphosyntax_interface import ( + display_morphosyntax_interface, + display_arc_diagram + # display_morphosyntax_results +) + +from .morphosyntax_process import ( + process_morphosyntactic_input, + format_analysis_results, + perform_advanced_morphosyntactic_analysis, + get_repeated_words_colors, + highlight_repeated_words, + POS_COLORS, + POS_TRANSLATIONS +) + +__all__ = [ + 'display_morphosyntax_interface', + 'display_arc_diagram', + #'display_morphosyntax_results', + 'process_morphosyntactic_input', + 'format_analysis_results', + 'perform_advanced_morphosyntactic_analysis', + 'get_repeated_words_colors', + 'highlight_repeated_words', + 'POS_COLORS', + 'POS_TRANSLATIONS' +] + diff --git a/src/modules/morphosyntax/__pycache__/__init__.cpython-311.pyc b/src/modules/morphosyntax/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d1de440bb8567809c523502b8eb53e8cbc879140 Binary files /dev/null and b/src/modules/morphosyntax/__pycache__/__init__.cpython-311.pyc differ diff --git a/src/modules/morphosyntax/__pycache__/morphosyntax_interface.cpython-311.pyc b/src/modules/morphosyntax/__pycache__/morphosyntax_interface.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..31626a87d30b5ef698ab28d4e18280c2ab3b2878 Binary files /dev/null and b/src/modules/morphosyntax/__pycache__/morphosyntax_interface.cpython-311.pyc differ diff --git a/src/modules/morphosyntax/__pycache__/morphosyntax_process.cpython-311.pyc b/src/modules/morphosyntax/__pycache__/morphosyntax_process.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46b24c65f61758eaa702d506363ec7f9d05ceeaa Binary files /dev/null and b/src/modules/morphosyntax/__pycache__/morphosyntax_process.cpython-311.pyc differ diff --git a/src/modules/morphosyntax/morphosyntax_interface-Back1910-25-9-24.py b/src/modules/morphosyntax/morphosyntax_interface-Back1910-25-9-24.py new file mode 100644 index 0000000000000000000000000000000000000000..e8bb9d5dda50e6e595246de2a292bf0e3fa4536d --- /dev/null +++ b/src/modules/morphosyntax/morphosyntax_interface-Back1910-25-9-24.py @@ -0,0 +1,171 @@ +#modules/morphosyntax/morphosyntax_interface.py +import streamlit as st +from streamlit_float import * +from streamlit_antd_components import * +from streamlit.components.v1 import html +import base64 +from .morphosyntax_process import process_morphosyntactic_input +from ..chatbot.chatbot import initialize_chatbot +from ..utils.widget_utils import generate_unique_key +from ..database.database_oldFromV2 import store_morphosyntax_result + +import logging +logger = logging.getLogger(__name__) + + +####################### VERSION ANTERIOR A LAS 20:00 24-9-24 + +def display_morphosyntax_interface(lang_code, nlp_models, t): + # Estilo CSS personalizado + st.markdown(""" + + """, unsafe_allow_html=True) + + # Mostrar el mensaje inicial como un párrafo estilizado + st.markdown(f""" + + """, unsafe_allow_html=True) + + # Inicializar el chatbot si no existe + if 'morphosyntax_chatbot' not in st.session_state: + st.session_state.morphosyntax_chatbot = initialize_chatbot('morphosyntactic') + + # Crear un contenedor para el chat + chat_container = st.container() + + # Mostrar el historial del chat + with chat_container: + if 'morphosyntax_chat_history' not in st.session_state: + st.session_state.morphosyntax_chat_history = [] + for i, message in enumerate(st.session_state.morphosyntax_chat_history): + with st.chat_message(message["role"]): + st.write(message["content"]) + if "visualizations" in message: + for viz in message["visualizations"]: + st.components.v1.html( + f""" +
+
+ """,
+ height=370,
+ scrolling=True
+ )
+
+
+ # Input del usuario
+ user_input = st.chat_input(
+ t['morpho_input_label'],
+ key=generate_unique_key('morphosyntax', "chat_input")
+ )
+
+ if user_input:
+ # Añadir el mensaje del usuario al historial
+ st.session_state.morphosyntax_chat_history.append({"role": "user", "content": user_input})
+
+ # Mostrar indicador de carga
+ with st.spinner(t.get('processing', 'Processing...')):
+ try:
+ # Procesar el input del usuario
+ response, visualizations, result = process_morphosyntactic_input(user_input, lang_code, nlp_models, t)
+
+ # Añadir la respuesta al historial
+ message = {
+ "role": "assistant",
+ "content": response
+ }
+ if visualizations:
+ message["visualizations"] = visualizations
+ st.session_state.morphosyntax_chat_history.append(message)
+
+ # Mostrar la respuesta más reciente
+ with st.chat_message("assistant"):
+ st.write(response)
+ if visualizations:
+ for i, viz in enumerate(visualizations):
+ st.components.v1.html(
+ f"""
+
+ {viz}
+
+
+
+ """,
+ height=350,
+ scrolling=True
+ )
+
+ # Si es un análisis, guardarlo en la base de datos
+ if user_input.startswith('/analisis_morfosintactico') and result:
+ store_morphosyntax_result(
+ st.session_state.username,
+ user_input.split('[', 1)[1].rsplit(']', 1)[0], # texto analizado
+ result.get('repeated_words', {}),
+ visualizations,
+ result.get('pos_analysis', []),
+ result.get('morphological_analysis', []),
+ result.get('sentence_structure', [])
+ )
+
+ except Exception as e:
+ st.error(f"{t['error_processing']}: {str(e)}")
+
+ # Si es un análisis, guardarlo en la base de datos
+ if user_input.startswith('/analisis_morfosintactico') and result:
+ store_morphosyntax_result(
+ st.session_state.username,
+ user_input.split('[', 1)[1].rsplit(']', 1)[0], # texto analizado
+ result['repeated_words'],
+ visualizations, # Ahora pasamos todas las visualizaciones
+ result['pos_analysis'],
+ result['morphological_analysis'],
+ result['sentence_structure']
+ )
+
+ # Forzar la actualización de la interfaz
+ st.rerun()
+
+ # Botón para limpiar el historial del chat
+ if st.button(t['clear_chat'], key=generate_unique_key('morphosyntax', 'clear_chat')):
+ st.session_state.morphosyntax_chat_history = []
+ st.rerun()
+
+
+
+'''
+############ MODULO PARA DEPURACIÓN Y PRUEBAS #####################################################
+def display_morphosyntax_interface(lang_code, nlp_models, t):
+ st.subheader(t['morpho_title'])
+
+ text_input = st.text_area(
+ t['warning_message'],
+ height=150,
+ key=generate_unique_key("morphosyntax", "text_area")
+ )
+
+ if st.button(
+ t['results_title'],
+ key=generate_unique_key("morphosyntax", "analyze_button")
+ ):
+ if text_input:
+ # Aquí iría tu lógica de análisis morfosintáctico
+ # Por ahora, solo mostraremos un mensaje de placeholder
+ st.info(t['analysis_placeholder'])
+ else:
+ st.warning(t['no_text_warning'])
+###
+#################################################
+'''
diff --git a/src/modules/morphosyntax/morphosyntax_interface-BackUp_Dec24_OK.py b/src/modules/morphosyntax/morphosyntax_interface-BackUp_Dec24_OK.py
new file mode 100644
index 0000000000000000000000000000000000000000..490e5ed0e2ad0652d432e79d31e4a05236b4f2f1
--- /dev/null
+++ b/src/modules/morphosyntax/morphosyntax_interface-BackUp_Dec24_OK.py
@@ -0,0 +1,322 @@
+#modules/morphosyntax/morphosyntax_interface.py
+import streamlit as st
+from streamlit_float import *
+from streamlit_antd_components import *
+from streamlit.components.v1 import html
+import spacy
+from spacy import displacy
+import spacy_streamlit
+import pandas as pd
+import base64
+import re
+
+# Importar desde morphosyntax_process.py
+from .morphosyntax_process import (
+ process_morphosyntactic_input,
+ format_analysis_results,
+ perform_advanced_morphosyntactic_analysis, # Añadir esta importación
+ get_repeated_words_colors, # Y estas también
+ highlight_repeated_words,
+ POS_COLORS,
+ POS_TRANSLATIONS
+)
+
+from ..utils.widget_utils import generate_unique_key
+
+from ..database.morphosintax_mongo_db import store_student_morphosyntax_result
+from ..database.chat_mongo_db import store_chat_history, get_chat_history
+
+# from ..database.morphosintaxis_export import export_user_interactions
+
+import logging
+logger = logging.getLogger(__name__)
+
+############################################################################################################
+def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
+ try:
+ # 1. Inicializar el estado morfosintáctico si no existe
+ if 'morphosyntax_state' not in st.session_state:
+ st.session_state.morphosyntax_state = {
+ 'input_text': "",
+ 'analysis_count': 0,
+ 'last_analysis': None
+ }
+
+ # 2. Campo de entrada de texto con key única basada en el contador
+ input_key = f"morpho_input_{st.session_state.morphosyntax_state['analysis_count']}"
+
+ sentence_input = st.text_area(
+ morpho_t.get('morpho_input_label', 'Enter text to analyze'),
+ height=150,
+ placeholder=morpho_t.get('morpho_input_placeholder', 'Enter your text here...'),
+ key=input_key
+ )
+
+ # 3. Actualizar el estado con el texto actual
+ st.session_state.morphosyntax_state['input_text'] = sentence_input
+
+ # 4. Crear columnas para el botón
+ col1, col2, col3 = st.columns([2,1,2])
+
+ # 5. Botón de análisis en la columna central
+ with col1:
+ analyze_button = st.button(
+ morpho_t.get('morpho_analyze_button', 'Analyze Morphosyntax'),
+ key=f"morpho_button_{st.session_state.morphosyntax_state['analysis_count']}",
+ type="primary", # Nuevo en Streamlit 1.39.0
+ icon="🔍", # Nuevo en Streamlit 1.39.0
+ disabled=not bool(sentence_input.strip()), # Se activa solo cuando hay texto
+ use_container_width=True
+ )
+
+ # 6. Lógica de análisis
+ if analyze_button and sentence_input.strip(): # Verificar que haya texto y no solo espacios
+ try:
+ with st.spinner(morpho_t.get('processing', 'Processing...')):
+ # Obtener el modelo específico del idioma y procesar el texto
+ doc = nlp_models[lang_code](sentence_input)
+
+ # Realizar análisis morfosintáctico con el mismo modelo
+ advanced_analysis = perform_advanced_morphosyntactic_analysis(
+ sentence_input,
+ nlp_models[lang_code]
+ )
+
+ # Guardar resultado en el estado de la sesión
+ st.session_state.morphosyntax_result = {
+ 'doc': doc,
+ 'advanced_analysis': advanced_analysis
+ }
+
+ # Incrementar el contador de análisis
+ st.session_state.morphosyntax_state['analysis_count'] += 1
+
+ # Guardar el análisis en la base de datos
+ if store_student_morphosyntax_result(
+ username=st.session_state.username,
+ text=sentence_input,
+ arc_diagrams=advanced_analysis['arc_diagrams']
+ ):
+ st.success(morpho_t.get('success_message', 'Analysis saved successfully'))
+
+ # Mostrar resultados
+ display_morphosyntax_results(
+ st.session_state.morphosyntax_result,
+ lang_code,
+ morpho_t
+ )
+ else:
+ st.error(morpho_t.get('error_message', 'Error saving analysis'))
+
+ except Exception as e:
+ logger.error(f"Error en análisis morfosintáctico: {str(e)}")
+ st.error(morpho_t.get('error_processing', f'Error processing text: {str(e)}'))
+
+ # 7. Mostrar resultados previos si existen
+ elif 'morphosyntax_result' in st.session_state and st.session_state.morphosyntax_result is not None:
+ display_morphosyntax_results(
+ st.session_state.morphosyntax_result,
+ lang_code,
+ morpho_t
+ )
+ elif not sentence_input.strip():
+ st.info(morpho_t.get('morpho_initial_message', 'Enter text to begin analysis'))
+
+ except Exception as e:
+ logger.error(f"Error general en display_morphosyntax_interface: {str(e)}")
+ st.error("Se produjo un error. Por favor, intente de nuevo.")
+ st.error(f"Detalles del error: {str(e)}") # Añadido para mejor debugging
+
+############################################################################################################
+def display_morphosyntax_results(result, lang_code, morpho_t):
+ """
+ Muestra los resultados del análisis morfosintáctico.
+ Args:
+ result: Resultado del análisis
+ lang_code: Código del idioma
+ t: Diccionario de traducciones
+ """
+ # Obtener el diccionario de traducciones morfosintácticas
+ # morpho_t = t.get('MORPHOSYNTACTIC', {})
+
+ if result is None:
+ st.warning(morpho_t.get('no_results', 'No results available'))
+ return
+
+ doc = result['doc']
+ advanced_analysis = result['advanced_analysis']
+
+ # Mostrar leyenda
+ st.markdown(f"##### {morpho_t.get('legend', 'Legend: Grammatical categories')}")
+ legend_html = "
+ {viz}
+
+ "
+ for pos, color in POS_COLORS.items():
+ if pos in POS_TRANSLATIONS[lang_code]:
+ legend_html += f"
"
+ st.markdown(legend_html, unsafe_allow_html=True)
+
+ # Mostrar análisis de palabras repetidas
+ word_colors = get_repeated_words_colors(doc)
+ with st.expander(morpho_t.get('repeated_words', '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(morpho_t.get('sentence_structure', 'Sentence structure'), expanded=True):
+ for i, sent_analysis in enumerate(advanced_analysis['sentence_structure']):
+ sentence_str = (
+ f"**{morpho_t.get('sentence', 'Sentence')} {i+1}** " # Aquí está el cambio
+ f"{morpho_t.get('root', 'Root')}: {sent_analysis['root']} ({sent_analysis['root_pos']}) -- " # Y aquí
+ f"{morpho_t.get('subjects', 'Subjects')}: {', '.join(sent_analysis['subjects'])} -- " # Y aquí
+ f"{morpho_t.get('objects', 'Objects')}: {', '.join(sent_analysis['objects'])} -- " # Y aquí
+ f"{morpho_t.get('verbs', 'Verbs')}: {', '.join(sent_analysis['verbs'])}" # Y aquí
+ )
+ 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(morpho_t.get('pos_analysis', 'Part of speech'), 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': morpho_t.get('grammatical_category', 'Grammatical category'),
+ 'count': morpho_t.get('count', 'Count'),
+ 'percentage': morpho_t.get('percentage', 'Percentage'),
+ 'examples': morpho_t.get('examples', 'Examples')
+ })
+
+ # Mostrar el dataframe
+ st.dataframe(pos_df)
+
+ with col2:
+ with st.expander(morpho_t.get('morphological_analysis', 'Morphological Analysis'), expanded=True):
+ # 1. Crear el DataFrame inicial
+ morph_df = pd.DataFrame(advanced_analysis['morphological_analysis'])
+
+ # 2. Primero renombrar las columnas usando las traducciones de la interfaz
+ column_mapping = {
+ 'text': morpho_t.get('word', 'Word'),
+ 'lemma': morpho_t.get('lemma', 'Lemma'),
+ 'pos': morpho_t.get('grammatical_category', 'Grammatical category'),
+ 'dep': morpho_t.get('dependency', 'Dependency'),
+ 'morph': morpho_t.get('morphology', 'Morphology')
+ }
+
+ # 3. Aplicar el renombrado
+ morph_df = morph_df.rename(columns=column_mapping)
+
+ # 4. Traducir las categorías gramaticales usando POS_TRANSLATIONS global
+ grammatical_category = morpho_t.get('grammatical_category', 'Grammatical category')
+ morph_df[grammatical_category] = morph_df[grammatical_category].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+
+ # 2.2 Traducir dependencias usando traducciones específicas
+ 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'
+ }
+ }
+
+ dependency = morpho_t.get('dependency', 'Dependency')
+ morph_df[dependency] = morph_df[dependency].map(lambda x: dep_translations[lang_code].get(x, x))
+
+ 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'
+ }
+ }
+
+ def translate_morph(morph_string, lang_code):
+ for key, value in morph_translations[lang_code].items():
+ morph_string = morph_string.replace(key, value)
+ return morph_string
+
+ morphology = morpho_t.get('morphology', 'Morphology')
+ morph_df[morphology] = morph_df[morphology].apply(lambda x: translate_morph(x, lang_code))
+
+ st.dataframe(morph_df)
+
+ # Mostrar diagramas de arco
+ with st.expander(morpho_t.get('arc_diagram', 'Syntactic analysis: Arc diagram'), expanded=True):
+ sentences = list(doc.sents)
+ arc_diagrams = []
+
+ for i, sent in enumerate(sentences):
+ st.subheader(f"{morpho_t.get('sentence', 'Sentence')} {i+1}")
+ html = displacy.render(sent, style="dep", options={"distance": 100})
+ html = html.replace('height="375"', 'height="200"')
+ html = re.sub(r'{POS_TRANSLATIONS[lang_code][pos]}
"
+ legend_html += "Error generando diagrama
" + +########################################################################### +def display_morphosyntax_interface(lang_code, nlp_models, morpho_t): + """ + Interfaz principal para la visualización de diagramas de arco + (Texto Base vs Iteraciones), usando traducciones con morpho_t. + """ + # CSS para layout y estilo + st.markdown(""" + + """, unsafe_allow_html=True) + + # 1) Inicializar estados + initialize_arc_analysis_state() + arc_state = st.session_state.arc_analysis_state + + # 2) Crear pestañas con etiquetas traducidas + tab_text_base = morpho_t.get('tab_text_baseline', 'Ingresa la primera versión de tu texto') + tab_iterations = morpho_t.get('tab_iterations', 'Produce nuevas versiones de tu primer texto') + tabs = st.tabs([tab_text_base, tab_iterations]) + + # =================== PESTAÑA 1: Texto Base ========================== + with tabs[0]: + # st.subheader(morpho_t.get('analysis_base_subheader', "Análisis de Texto Base")) + + # Textarea de texto base + arc_state["base_text"] = st.text_area( + morpho_t.get('input_baseline_text', "Ingresa el primer texto para analizarlo"), + value=arc_state["base_text"], + key="base_text_input", + height=150 + ) + + # Botón para analizar texto base + if st.button(morpho_t.get('btn_analyze_baseline', "Analizar la primera versión de tu texto"), key="btn_analyze_base"): + if not arc_state["base_text"].strip(): + st.warning(morpho_t.get('warn_enter_text', "Ingrese un texto nuevo para analizarlo.")) + else: + try: + # Procesar con spaCy + doc = nlp_models[lang_code](arc_state["base_text"]) + base_arc_html = display_arc_diagram(doc) + arc_state["base_diagram"] = base_arc_html + + # Guardar en Mongo + analysis = perform_advanced_morphosyntactic_analysis( + arc_state["base_text"], + nlp_models[lang_code] + ) + base_id = store_student_morphosyntax_base( + username=st.session_state.username, + text=arc_state["base_text"], + arc_diagrams=analysis["arc_diagrams"] + ) + if base_id: + arc_state["base_id"] = base_id + saved_msg = morpho_t.get('analysis_base_saved', "Análisis base guardado. ID: {base_id}") + st.success(saved_msg.format(base_id=base_id)) + + except Exception as exc: + st.error(morpho_t.get('error_processing_baseline', "Error al procesar el texto inicial")) + logger.error(f"Error en análisis base: {str(exc)}") + + # Botón para iniciar nuevo análisis + if st.button(morpho_t.get('btn_new_morpho_analysis', "Nuevo análisis morfosintático"), key="btn_reset_base"): + # Si fuera necesario recargar la app por completo: + # st.experimental_rerun() + reset_arc_analysis_state() + + # Mostrar diagrama base + if arc_state["base_diagram"]: + st.markdown("", unsafe_allow_html=True) + st.markdown(f"#### {morpho_t.get('arc_diagram_baseline_label', 'Diagrama de arco del texto inicial')}") + st.write(arc_state["base_diagram"], unsafe_allow_html=True) + else: + if arc_state["base_text"].strip(): + # Solo mostrar si ya hay texto base pero no se ha procesado + st.info(morpho_t.get('baseline_diagram_not_available', "Diagrama de arco del texto inicial no disponible.")) + + # ================== PESTAÑA 2: Iteraciones ========================== + with tabs[1]: + #st.subheader(morpho_t.get('iteration_text_subheader', "Nueva versión del texto inicial")) + + # Verificar que exista un texto base + if not arc_state["base_id"]: + st.info(morpho_t.get('info_first_analyze_base', + "Verifica la existencia de un texto anterior.")) + return + + # --- 1) Mostrar SIEMPRE el diagrama base arriba --- + st.markdown(f"#### {morpho_t.get('arc_diagram_base_label', 'Diagrama de arco del texto inicial')}") + if arc_state["base_diagram"]: + st.write(arc_state["base_diagram"], unsafe_allow_html=True) + else: + st.info(morpho_t.get('baseline_diagram_not_available', "Diagrama de arco del texto inicial no disponible.")) + + # --- 2) Caja de texto para la iteración --- + st.markdown("
", unsafe_allow_html=True) + #st.subheader(morpho_t.get('iteration_text_subheader', "Ingresa una nueva versión del texto inicial y compara los arcos de ambos textos")) + + arc_state["iteration_text"] = st.text_area( + morpho_t.get('input_iteration_text', "Ingresa una nueva versión del texto inicial y compara los arcos de ambos textos"), + value=arc_state["iteration_text"], + height=150 + ) + + # Botón para analizar iteración + if st.button(morpho_t.get('btn_analyze_iteration', "Analizar Cambios"), key="btn_analyze_iteration"): + if not arc_state["iteration_text"].strip(): + st.warning(morpho_t.get('warn_enter_iteration_text', "Ingresa una nueva versión del texto inicial y compara los arcos de ambos textos.")) + else: + try: + # Procesar con spaCy + doc_iter = nlp_models[lang_code](arc_state["iteration_text"]) + arc_html_iter = display_arc_diagram(doc_iter) + arc_state["iteration_diagram"] = arc_html_iter + + # Guardar en Mongo + analysis_iter = perform_advanced_morphosyntactic_analysis( + arc_state["iteration_text"], + nlp_models[lang_code] + ) + iteration_id = store_student_morphosyntax_iteration( + username=st.session_state.username, + base_id=arc_state["base_id"], + original_text=arc_state["base_text"], + iteration_text=arc_state["iteration_text"], + arc_diagrams=analysis_iter["arc_diagrams"] + ) + if iteration_id: + saved_iter_msg = morpho_t.get('iteration_saved', "Cambios guardados correctamente. ID: {iteration_id}") + st.success(saved_iter_msg.format(iteration_id=iteration_id)) + + except Exception as exc: + st.error(morpho_t.get('error_iteration', "Error procesando los nuevos cambios")) + logger.error(f"Error en iteración: {str(exc)}") + + + # --- 3) Mostrar diagrama de iteración debajo --- + if arc_state["iteration_diagram"]: + st.markdown("
", unsafe_allow_html=True) + st.markdown(f"#### {morpho_t.get('arc_diagram_iteration_label', 'Diagrama de Arco (Iteración)')}") + st.write(arc_state["iteration_diagram"], unsafe_allow_html=True) diff --git a/src/modules/morphosyntax/morphosyntax_interface_BackUp_Dec-28-Ok.py b/src/modules/morphosyntax/morphosyntax_interface_BackUp_Dec-28-Ok.py new file mode 100644 index 0000000000000000000000000000000000000000..38ab7f95c54e79429398ecc4539fb3340ff52520 --- /dev/null +++ b/src/modules/morphosyntax/morphosyntax_interface_BackUp_Dec-28-Ok.py @@ -0,0 +1,164 @@ +#modules/morphosyntax/morphosyntax_interface.py + +import streamlit as st +from streamlit_float import * +from streamlit_antd_components import * +from streamlit.components.v1 import html +import spacy +from spacy import displacy +import spacy_streamlit +import pandas as pd +import base64 +import re + +from .morphosyntax_process import ( + process_morphosyntactic_input, + format_analysis_results, + perform_advanced_morphosyntactic_analysis, + get_repeated_words_colors, + highlight_repeated_words, + POS_COLORS, + POS_TRANSLATIONS +) + +from ..utils.widget_utils import generate_unique_key +from ..database.morphosintax_mongo_db import store_student_morphosyntax_result +from ..database.chat_mongo_db import store_chat_history, get_chat_history + +import logging +logger = logging.getLogger(__name__) + + +def display_morphosyntax_interface(lang_code, nlp_models, morpho_t): + try: + # Inicializar el estado si no existe + if 'morphosyntax_state' not in st.session_state: + st.session_state.morphosyntax_state = { + 'analysis_count': 0, + 'current_text': '', # Almacenar el texto actual + 'last_analysis': None, + 'needs_update': False # Flag para actualización + } + + # Campo de entrada de texto que mantiene su valor + text_key = "morpho_text_input" + + # Función para manejar cambios en el texto + def on_text_change(): + st.session_state.morphosyntax_state['current_text'] = st.session_state[text_key] + st.session_state.morphosyntax_state['needs_update'] = True + + # Recuperar el texto anterior si existe + default_text = st.session_state.morphosyntax_state.get('current_text', '') + + sentence_input = st.text_area( + morpho_t.get('morpho_input_label', 'Enter text to analyze'), + value=default_text, # Usar el texto guardado + height=150, + key=text_key, + on_change=on_text_change, + placeholder=morpho_t.get('morpho_input_placeholder', 'Enter your text here...') + ) + + # Botón de análisis + col1, col2, col3 = st.columns([2,1,2]) + with col1: + analyze_button = st.button( + morpho_t.get('morpho_analyze_button', 'Analyze Morphosyntax'), + key=f"morpho_button_{st.session_state.morphosyntax_state['analysis_count']}", + type="primary", + icon="🔍", + disabled=not bool(sentence_input.strip()), + use_container_width=True + ) + + # Procesar análisis solo cuando sea necesario + if (analyze_button or st.session_state.morphosyntax_state['needs_update']) and sentence_input.strip(): + try: + with st.spinner(morpho_t.get('processing', 'Processing...')): + doc = nlp_models[lang_code](sentence_input) + advanced_analysis = perform_advanced_morphosyntactic_analysis( + sentence_input, + nlp_models[lang_code] + ) + + st.session_state.morphosyntax_result = { + 'doc': doc, + 'advanced_analysis': advanced_analysis + } + + # Solo guardar en DB si fue un click en el botón + if analyze_button: + if store_student_morphosyntax_result( + username=st.session_state.username, + text=sentence_input, + arc_diagrams=advanced_analysis['arc_diagrams'] + ): + st.success(morpho_t.get('success_message', 'Analysis saved successfully')) + st.session_state.morphosyntax_state['analysis_count'] += 1 + + st.session_state.morphosyntax_state['needs_update'] = False + + # Mostrar resultados en un contenedor específico + with st.container(): + display_morphosyntax_results( + st.session_state.morphosyntax_result, + lang_code, + morpho_t + ) + + except Exception as e: + logger.error(f"Error en análisis morfosintáctico: {str(e)}") + st.error(morpho_t.get('error_processing', f'Error processing text: {str(e)}')) + + # Mostrar resultados previos si existen + elif 'morphosyntax_result' in st.session_state and st.session_state.morphosyntax_result: + with st.container(): + display_morphosyntax_results( + st.session_state.morphosyntax_result, + lang_code, + morpho_t + ) + + except Exception as e: + logger.error(f"Error general en display_morphosyntax_interface: {str(e)}") + st.error("Se produjo un error. Por favor, intente de nuevo.") + + + +def display_morphosyntax_results(result, lang_code, morpho_t): + """ + Muestra solo el análisis sintáctico con diagramas de arco. + """ + if result is None: + st.warning(morpho_t.get('no_results', 'No results available')) + return + + doc = result['doc'] + + # Análisis sintáctico (diagramas de arco) + st.markdown(f"### {morpho_t.get('arc_diagram', 'Syntactic analysis: Arc diagram')}") + + with st.container(): + sentences = list(doc.sents) + for i, sent in enumerate(sentences): + with st.container(): + st.subheader(f"{morpho_t.get('sentence', 'Sentence')} {i+1}") + try: + html = displacy.render(sent, style="dep", options={ + "distance": 100, + "arrow_spacing": 20, + "word_spacing": 30 + }) + # Ajustar dimensiones del SVG + html = html.replace('height="375"', 'height="200"') + html = re.sub(r'
Error generando diagrama
" + +########################################################################### +def display_morphosyntax_interface(lang_code, nlp_models, morpho_t): + """ + Interfaz principal para la visualización de diagramas de arco + (Texto Base vs Iteraciones). + """ + # CSS para layout vertical y estable + st.markdown(""" + + """, unsafe_allow_html=True) + + # 1) Inicializar estados + initialize_arc_analysis_state() + arc_state = st.session_state.arc_analysis_state + + # 2) Creamos pestañas: "Texto Base" y "Iteraciones" + tabs = st.tabs(["Texto Base", "Iteraciones"]) + + # =================== PESTAÑA 1: Texto Base ========================== + with tabs[0]: + st.subheader("Análisis de Texto Base") + + # Botón para iniciar nuevo análisis + if st.button("Nuevo Análisis", key="btn_reset_base"): + # Solo limpiamos el estado; si requieres forzar reload, + # descomenta la siguiente línea: + # st.experimental_rerun() + reset_arc_analysis_state() + + # Textarea de texto base + arc_state["base_text"] = st.text_area( + "Ingrese su texto inicial", + value=arc_state["base_text"], + key="base_text_input", + height=150 + ) + + # Botón para analizar texto base + if st.button("Analizar Texto Base", key="btn_analyze_base"): + if not arc_state["base_text"].strip(): + st.warning("Ingrese un texto para analizar.") + else: + try: + # Procesar con spaCy + doc = nlp_models[lang_code](arc_state["base_text"]) + # Generar HTML del arco + arc_html = display_arc_diagram(doc) + arc_state["base_diagram"] = arc_html + + # Guardar en Mongo + analysis = perform_advanced_morphosyntactic_analysis( + arc_state["base_text"], + nlp_models[lang_code] + ) + base_id = store_student_morphosyntax_base( + username=st.session_state.username, + text=arc_state["base_text"], + arc_diagrams=analysis["arc_diagrams"] + ) + if base_id: + arc_state["base_id"] = base_id + st.success(f"Análisis base guardado. ID: {base_id}") + + except Exception as exc: + st.error("Error procesando texto base") + logger.error(f"Error en análisis base: {str(exc)}") + + # Mostrar diagrama base + if arc_state["base_diagram"]: + st.markdown("", unsafe_allow_html=True) + st.markdown("#### Diagrama de Arco (Texto Base)") + st.write(arc_state["base_diagram"], unsafe_allow_html=True) + + # ================== PESTAÑA 2: Iteraciones ========================== + with tabs[1]: + st.subheader("Análisis de Cambios / Iteraciones") + + # Verificar que exista texto base analizado + if not arc_state["base_id"]: + st.info("Primero analiza un texto base en la pestaña anterior.") + return + + # Mostrar texto base como referencia (solo lectura) + st.text_area( + "Texto Base (solo lectura)", + value=arc_state["base_text"], + height=80, + disabled=True + ) + + # Caja de texto para la iteración + arc_state["iteration_text"] = st.text_area( + "Texto de Iteración", + value=arc_state["iteration_text"], + height=150 + ) + + # Botón analizar iteración + if st.button("Analizar Cambios", key="btn_analyze_iteration"): + if not arc_state["iteration_text"].strip(): + st.warning("Ingrese texto de iteración.") + else: + try: + # Procesar con spaCy + doc_iter = nlp_models[lang_code](arc_state["iteration_text"]) + arc_html_iter = display_arc_diagram(doc_iter) + arc_state["iteration_diagram"] = arc_html_iter + + # Guardar en Mongo + analysis_iter = perform_advanced_morphosyntactic_analysis( + arc_state["iteration_text"], + nlp_models[lang_code] + ) + iteration_id = store_student_morphosyntax_iteration( + username=st.session_state.username, + base_id=arc_state["base_id"], + original_text=arc_state["base_text"], + iteration_text=arc_state["iteration_text"], + arc_diagrams=analysis_iter["arc_diagrams"] + ) + if iteration_id: + st.success(f"Iteración guardada. ID: {iteration_id}") + + except Exception as exc: + st.error("Error procesando iteración") + logger.error(f"Error en iteración: {str(exc)}") + + # Mostrar diagrama de iteración + if arc_state["iteration_diagram"]: + st.markdown("
", unsafe_allow_html=True) + st.markdown("#### Diagrama de Arco (Iteración)") + st.write(arc_state["iteration_diagram"], unsafe_allow_html=True) + + # Comparación vertical (uno abajo del otro) + if arc_state["base_diagram"] and arc_state["iteration_diagram"]: + st.markdown("
", unsafe_allow_html=True) + st.markdown("### Comparación Vertical: Base vs. Iteración") + + st.markdown("**Diagrama Base**") + st.write(arc_state["base_diagram"], unsafe_allow_html=True) + + st.markdown("---") + st.markdown("**Diagrama Iterado**") + st.write(arc_state["iteration_diagram"], unsafe_allow_html=True) \ No newline at end of file diff --git a/src/modules/morphosyntax/morphosyntax_process-Back1910-25-9-24.py b/src/modules/morphosyntax/morphosyntax_process-Back1910-25-9-24.py new file mode 100644 index 0000000000000000000000000000000000000000..191855b00ca8237f7dfd88afc925a314e82a2dc4 --- /dev/null +++ b/src/modules/morphosyntax/morphosyntax_process-Back1910-25-9-24.py @@ -0,0 +1,29 @@ +#modules/morphosyntax/morphosyntax_process.py +from ..text_analysis.morpho_analysis import perform_advanced_morphosyntactic_analysis +from ..database.database_oldFromV2 import store_morphosyntax_result +import streamlit as st + +def process_morphosyntactic_input(user_input, lang_code, nlp_models, t): + if user_input.startswith('/analisis_morfosintactico'): + # Extraer el texto entre corchetes + text_to_analyze = user_input.split('[', 1)[1].rsplit(']', 1)[0] + + # Realizar el análisis morfosintáctico + result = perform_advanced_morphosyntactic_analysis(text_to_analyze, nlp_models[lang_code]) + + if result is None: + response = t.get('morphosyntactic_analysis_error', 'Error in morphosyntactic analysis') + return response, None, None + + # Preparar la respuesta + response = t.get('morphosyntactic_analysis_completed', 'Morphosyntactic analysis completed') + + # Obtener todos los diagramas de arco + visualizations = result['arc_diagram'] + + return response, visualizations, result + else: + # Para otros tipos de input, simplemente devolver la respuesta del chatbot + chatbot = st.session_state.morphosyntax_chatbot + response = chatbot.generate_response(user_input, lang_code) + return response, None, None diff --git a/src/modules/morphosyntax/morphosyntax_process.py b/src/modules/morphosyntax/morphosyntax_process.py new file mode 100644 index 0000000000000000000000000000000000000000..407d29a66a20998b951d842619e354ee4dac803b --- /dev/null +++ b/src/modules/morphosyntax/morphosyntax_process.py @@ -0,0 +1,132 @@ +#modules/morphosyntax/morphosyntax_process.py +import streamlit as st + +from ..text_analysis.morpho_analysis import ( + get_repeated_words_colors, + highlight_repeated_words, + generate_arc_diagram, + get_detailed_pos_analysis, + get_morphological_analysis, + get_sentence_structure_analysis, + perform_advanced_morphosyntactic_analysis, + POS_COLORS, + POS_TRANSLATIONS +) + +from ..database.morphosintax_mongo_db import store_student_morphosyntax_result + +import logging +logger = logging.getLogger(__name__) + + +def process_morphosyntactic_input(text, lang_code, nlp_models, t): + """ + Procesa el texto ingresado para realizar el análisis morfosintáctico. + + Args: + text: Texto a analizar + lang_code: Código del idioma + nlp_models: Diccionario de modelos spaCy + t: Diccionario de traducciones + + Returns: + tuple: (análisis, visualizaciones, texto_resaltado, mensaje) + """ + try: + # Realizar el análisis morfosintáctico + doc = nlp_models[lang_code](text) + + # Obtener el análisis avanzado + analysis = perform_advanced_morphosyntactic_analysis(text, nlp_models[lang_code]) + + # Generar visualizaciones - AQUÍ ESTÁ EL CAMBIO + arc_diagrams = generate_arc_diagram(doc) # Quitamos lang_code + + # Obtener palabras repetidas y texto resaltado + word_colors = get_repeated_words_colors(doc) + highlighted_text = highlight_repeated_words(doc, word_colors) + + # Guardar el análisis en la base de datos + store_student_morphosyntax_result( + st.session_state.username, + text, + { + 'arc_diagrams': arc_diagrams, + 'pos_analysis': analysis['pos_analysis'], + 'morphological_analysis': analysis['morphological_analysis'], + 'sentence_structure': analysis['sentence_structure'] + } + ) + + return { + 'analysis': analysis, + 'visualizations': arc_diagrams, + 'highlighted_text': highlighted_text, + 'success': True, + 'message': t.get('MORPHOSYNTACTIC', {}).get('success_message', 'Analysis completed successfully') + } + + except Exception as e: + logger.error(f"Error en el análisis morfosintáctico: {str(e)}") + return { + 'analysis': None, + 'visualizations': None, + 'highlighted_text': None, + 'success': False, + 'message': t.get('MORPHOSYNTACTIC', {}).get('error_message', f'Error in analysis: {str(e)}') + } + + +def format_analysis_results(analysis_result, t): + """ + Formatea los resultados del análisis para su visualización. + + Args: + analysis_result: Resultado del análisis morfosintáctico + t: Diccionario de traducciones + + Returns: + dict: Resultados formateados para visualización + """ + morpho_t = t.get('MORPHOSYNTACTIC', {}) + + if not analysis_result['success']: + return { + 'formatted_text': analysis_result['message'], + 'visualizations': None + } + + formatted_sections = [] + + # Formato para análisis POS + if 'pos_analysis' in analysis_result['analysis']: + pos_section = [f"### {morpho_t.get('pos_analysis', 'Part of Speech Analysis')}"] + for pos_item in analysis_result['analysis']['pos_analysis']: + pos_section.append( + f"- {morpho_t.get(pos_item['pos'], pos_item['pos'])}: " + f"{pos_item['count']} ({pos_item['percentage']}%)\n " + f"Ejemplos: {', '.join(pos_item['examples'])}" + ) + formatted_sections.append('\n'.join(pos_section)) + + # Agregar otras secciones de formato según sea necesario + + return { + 'formatted_text': '\n\n'.join(formatted_sections), + 'visualizations': analysis_result['visualizations'], + 'highlighted_text': analysis_result['highlighted_text'] + } + +# Re-exportar las funciones y constantes necesarias +__all__ = [ + 'process_morphosyntactic_input', + 'highlight_repeated_words', + 'generate_arc_diagram', + 'get_repeated_words_colors', + 'get_detailed_pos_analysis', + 'get_morphological_analysis', + 'get_sentence_structure_analysis', + 'perform_advanced_morphosyntactic_analysis', + 'POS_COLORS', + 'POS_TRANSLATIONS' +] \ No newline at end of file diff --git a/src/modules/morphosyntax/morphosyntax_process_BackUp_Dec24_Ok.py b/src/modules/morphosyntax/morphosyntax_process_BackUp_Dec24_Ok.py new file mode 100644 index 0000000000000000000000000000000000000000..407d29a66a20998b951d842619e354ee4dac803b --- /dev/null +++ b/src/modules/morphosyntax/morphosyntax_process_BackUp_Dec24_Ok.py @@ -0,0 +1,132 @@ +#modules/morphosyntax/morphosyntax_process.py +import streamlit as st + +from ..text_analysis.morpho_analysis import ( + get_repeated_words_colors, + highlight_repeated_words, + generate_arc_diagram, + get_detailed_pos_analysis, + get_morphological_analysis, + get_sentence_structure_analysis, + perform_advanced_morphosyntactic_analysis, + POS_COLORS, + POS_TRANSLATIONS +) + +from ..database.morphosintax_mongo_db import store_student_morphosyntax_result + +import logging +logger = logging.getLogger(__name__) + + +def process_morphosyntactic_input(text, lang_code, nlp_models, t): + """ + Procesa el texto ingresado para realizar el análisis morfosintáctico. + + Args: + text: Texto a analizar + lang_code: Código del idioma + nlp_models: Diccionario de modelos spaCy + t: Diccionario de traducciones + + Returns: + tuple: (análisis, visualizaciones, texto_resaltado, mensaje) + """ + try: + # Realizar el análisis morfosintáctico + doc = nlp_models[lang_code](text) + + # Obtener el análisis avanzado + analysis = perform_advanced_morphosyntactic_analysis(text, nlp_models[lang_code]) + + # Generar visualizaciones - AQUÍ ESTÁ EL CAMBIO + arc_diagrams = generate_arc_diagram(doc) # Quitamos lang_code + + # Obtener palabras repetidas y texto resaltado + word_colors = get_repeated_words_colors(doc) + highlighted_text = highlight_repeated_words(doc, word_colors) + + # Guardar el análisis en la base de datos + store_student_morphosyntax_result( + st.session_state.username, + text, + { + 'arc_diagrams': arc_diagrams, + 'pos_analysis': analysis['pos_analysis'], + 'morphological_analysis': analysis['morphological_analysis'], + 'sentence_structure': analysis['sentence_structure'] + } + ) + + return { + 'analysis': analysis, + 'visualizations': arc_diagrams, + 'highlighted_text': highlighted_text, + 'success': True, + 'message': t.get('MORPHOSYNTACTIC', {}).get('success_message', 'Analysis completed successfully') + } + + except Exception as e: + logger.error(f"Error en el análisis morfosintáctico: {str(e)}") + return { + 'analysis': None, + 'visualizations': None, + 'highlighted_text': None, + 'success': False, + 'message': t.get('MORPHOSYNTACTIC', {}).get('error_message', f'Error in analysis: {str(e)}') + } + + +def format_analysis_results(analysis_result, t): + """ + Formatea los resultados del análisis para su visualización. + + Args: + analysis_result: Resultado del análisis morfosintáctico + t: Diccionario de traducciones + + Returns: + dict: Resultados formateados para visualización + """ + morpho_t = t.get('MORPHOSYNTACTIC', {}) + + if not analysis_result['success']: + return { + 'formatted_text': analysis_result['message'], + 'visualizations': None + } + + formatted_sections = [] + + # Formato para análisis POS + if 'pos_analysis' in analysis_result['analysis']: + pos_section = [f"### {morpho_t.get('pos_analysis', 'Part of Speech Analysis')}"] + for pos_item in analysis_result['analysis']['pos_analysis']: + pos_section.append( + f"- {morpho_t.get(pos_item['pos'], pos_item['pos'])}: " + f"{pos_item['count']} ({pos_item['percentage']}%)\n " + f"Ejemplos: {', '.join(pos_item['examples'])}" + ) + formatted_sections.append('\n'.join(pos_section)) + + # Agregar otras secciones de formato según sea necesario + + return { + 'formatted_text': '\n\n'.join(formatted_sections), + 'visualizations': analysis_result['visualizations'], + 'highlighted_text': analysis_result['highlighted_text'] + } + +# Re-exportar las funciones y constantes necesarias +__all__ = [ + 'process_morphosyntactic_input', + 'highlight_repeated_words', + 'generate_arc_diagram', + 'get_repeated_words_colors', + 'get_detailed_pos_analysis', + 'get_morphological_analysis', + 'get_sentence_structure_analysis', + 'perform_advanced_morphosyntactic_analysis', + 'POS_COLORS', + 'POS_TRANSLATIONS' +] \ No newline at end of file diff --git a/src/modules/morphosyntax/txt.txt b/src/modules/morphosyntax/txt.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/modules/semantic/__init_.py b/src/modules/semantic/__init_.py new file mode 100644 index 0000000000000000000000000000000000000000..ba6219c1088c717ac77136cb933347733d716a35 --- /dev/null +++ b/src/modules/semantic/__init_.py @@ -0,0 +1,17 @@ +# modules/semantic/__init_.py + +from .semantic_interface import ( + display_semantic_interface, + display_semantic_results +) +from .semantic_process import ( + process_semantic_input, + format_semantic_results +) + +__all__ = [ + 'display_semantic_interface', + 'display_semantic_results', + 'process_semantic_input', + 'format_semantic_results' +] \ No newline at end of file diff --git a/src/modules/semantic/__pycache__/flexible_analysis_handler.cpython-311.pyc b/src/modules/semantic/__pycache__/flexible_analysis_handler.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee65f50c83dd3bfd0530139fa905960ce57b8a24 Binary files /dev/null and b/src/modules/semantic/__pycache__/flexible_analysis_handler.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_float.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_float.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..afb9426ea5597b3d85ac0f0500d665a49b1a147b Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_float.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_float68ok.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_float68ok.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2736c7be7b369af9c9368810c98d590ef66db70e Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_float68ok.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_float86ok.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_float86ok.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0640e8983813bc16ee13251e6d6d65ffa23c823a Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_float86ok.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_float_reset.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_float_reset.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..021862ba760cca86a770a4d0c46349894e389ae6 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_float_reset.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8a9a3c5527bfc1667cf12cb816298b9b8dc4314 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interfaceBackUp_2092024_1800.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interfaceBackUp_2092024_1800.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b49443b6b818aef2248867278c43369ca51a662 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interfaceBackUp_2092024_1800.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interfaceBorrados.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interfaceBorrados.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef8bf460009df8fd59e3d489ebdce3163f2588f6 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interfaceBorrados.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interfaceKoKo.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interfaceKoKo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c42b43be508ed128eac77ae0f753dc575a9113e Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interfaceKoKo.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_1.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_1.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c9f0fef968b2f37b43dfc116c5f2ce2eb3d9e099 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_1.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_2.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46222222f83623c6b7de8bb0a92c634af86f8744 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_2.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_2192024_1632.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_2192024_1632.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d62dabaaf573d5de0a760a242a43332955c9f36 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_2192024_1632.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_3.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9b5eec9852b9159bbf76c1f7d8482108c099803 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_3.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_4.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..701cbc0e83a28b4a25fd8aa80465fd5e79e7b01a Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_4.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_5.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..52ee832d6ece08e1f92d23f223e56796b1a2cc54 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_5.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_6.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_6.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dcbe12108da351a568e772abfbb883d25b08c517 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_6.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_61.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_61.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..386c8ac736aeeb2a120880d3e6bfae0facc9f7f2 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_61.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_610.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_610.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f60c48f197a142f57c9f59cb1055ae57db32407f Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_610.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_62.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_62.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fedd207e2531dc00d3ee98645be42383e194e8db Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_62.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_63.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_63.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..78b98d5ffad8ec43b02cdcafab3a6752e4a27ef7 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_63.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_64.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_64.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e94c4a23f3a5c2098964ce3f8d5d67d561e0a944 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_64.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_65.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_65.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e45c7073838ffe64539d9470f4efecc2dad75b0 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_65.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_66.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_66.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0bd5c0b21aba6451de1963b18e79e2e8121f69f0 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_66.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_67.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_67.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4fa300c5559d94da29f1c2dc3a5c0712e028ea6f Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_67.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_68.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_68.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5bc6395eabbac5e54d20a38a4eb1aaf61e4e171e Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_68.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_681.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_681.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d13664fec98f1609721ede6a5ab8abf88480f375 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_681.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_68ok.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_68ok.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..85965738ee096cba107008fa62c5d60004d3fad7 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_68ok.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_69.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_69.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..66c5867ad061bca00a6ec984d824ea694fe26adc Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_69.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_7.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_7.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef2c5bc6d30879a47186e7e17858e0b3a001bb04 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_7.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_StreamLitChat.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_StreamLitChat.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d43c979fafff38614b9565936d755342894b7abf Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_StreamLitChat.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_Test.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_Test.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f5c14d8bf89c9a1e8f5887e40f3c307ea0f43fbf Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_Test.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_afterParty.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_afterParty.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cce4f330ccd69352a6f6ec411dfa26d5fd01789c Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_afterParty.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_backup2092024_1930.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_backup2092024_1930.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7940c44b2027728a9e8478d2c5a508ed44070469 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_backup2092024_1930.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_backup_2092024.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_backup_2092024.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3db97b9995c894928a31892cda744d6c4da483f9 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_backup_2092024.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_backup_2192024_1230.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_backup_2192024_1230.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..64b09631b0b72880568c8077ba29bb75283d88c1 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_backup_2192024_1230.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_interface_vOk.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_interface_vOk.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c9f2fa094a416e6429b9a3bccb0312558c955c02 Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_interface_vOk.cpython-311.pyc differ diff --git a/src/modules/semantic/__pycache__/semantic_process.cpython-311.pyc b/src/modules/semantic/__pycache__/semantic_process.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..58e1056dd70a702aa4ea3f67e4ff20e54923fd9c Binary files /dev/null and b/src/modules/semantic/__pycache__/semantic_process.cpython-311.pyc differ diff --git a/src/modules/semantic/flexible_analysis_handler.py b/src/modules/semantic/flexible_analysis_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..3e4396ab87a2a3559c06d41b388e7cdc4b843048 --- /dev/null +++ b/src/modules/semantic/flexible_analysis_handler.py @@ -0,0 +1,59 @@ +from typing import Dict, Any +import base64 +from io import BytesIO +from matplotlib.figure import Figure + +class FlexibleAnalysisHandler: + def __init__(self, analysis_data): + self.data = analysis_data + + def get_key_concepts(self): + return self.data.get('key_concepts', []) + + def get_concept_graph(self): + return self.data.get('concept_graph') + + def get_entity_graph(self): + return self.data.get('entity_graph') + + # Método genérico para obtener cualquier tipo de grafo + def get_graph(self, graph_type): + return self.data.get(graph_type) + + # Agrega más métodos según sea necesario + + +''' +class FlexibleAnalysisHandler: + def __init__(self, analysis_data: Dict[str, Any]): + self.data = analysis_data + + def get_key_concepts(self): + if 'key_concepts' in self.data: + return self.data['key_concepts'] + elif 'word_count' in self.data: + # Convertir word_count a un formato similar a key_concepts + return [(word, count) for word, count in self.data['word_count'].items()] + return [] + + def get_graph(self): + if 'graph' in self.data: + # Decodificar la imagen base64 + image_data = base64.b64decode(self.data['graph']) + return BytesIO(image_data) + elif 'arc_diagrams' in self.data: + # Devolver el primer diagrama de arco como SVG + return self.data['arc_diagrams'][0] + return None + + def get_pos_analysis(self): + return self.data.get('pos_analysis', []) + + def get_morphological_analysis(self): + return self.data.get('morphological_analysis', []) + + def get_sentence_structure(self): + return self.data.get('sentence_structure', []) + + # Agregar más métodos según sea necesario para otros tipos de análisis +''' \ No newline at end of file diff --git a/src/modules/semantic/logV6ite5.txt b/src/modules/semantic/logV6ite5.txt new file mode 100644 index 0000000000000000000000000000000000000000..27ff0010ade774a6e958f97c6f380c6b08050b14 --- /dev/null +++ b/src/modules/semantic/logV6ite5.txt @@ -0,0 +1,63 @@ +Request headers: + 'Cache-Control': 'no-cache' + 'x-ms-version': 'REDACTED' + 'x-ms-documentdb-query-iscontinuationexpected': 'REDACTED' + 'x-ms-consistency-level': 'REDACTED' + 'x-ms-documentdb-isquery': 'REDACTED' + 'Content-Type': 'application/query+json' + 'x-ms-session-token': 'REDACTED' + 'x-ms-documentdb-query-enablecrosspartition': 'REDACTED' + 'x-ms-date': 'REDACTED' + 'authorization': 'REDACTED' + 'Accept': 'application/json' + 'x-ms-cosmos-correlated-activityid': 'REDACTED' + 'Content-Length': '154' + 'User-Agent': 'azsdk-python-cosmos/4.7.0 Python/3.11.5 (Windows-10-10.0.22631-SP0)' +A body is sent with the request +INFO:azure.core.pipeline.policies.http_logging_policy:Response status: 200 +Response headers: + 'Content-Length': '377' + 'Date': 'Mon, 23 Sep 2024 16:50:28 GMT' + 'Content-Type': 'application/json' + 'Server': 'Compute' + 'x-ms-gatewayversion': 'REDACTED' + 'x-ms-activity-id': 'REDACTED' + 'x-ms-last-state-change-utc': 'REDACTED' + 'x-ms-resource-quota': 'REDACTED' + 'x-ms-resource-usage': 'REDACTED' + 'x-ms-schemaversion': 'REDACTED' + 'lsn': 'REDACTED' + 'x-ms-item-count': 'REDACTED' + 'x-ms-request-charge': 'REDACTED' + 'x-ms-alt-content-path': 'REDACTED' + 'x-ms-content-path': 'REDACTED' + 'x-ms-documentdb-partitionkeyrangeid': 'REDACTED' + 'x-ms-xp-role': 'REDACTED' + 'x-ms-cosmos-query-execution-info': 'REDACTED' + 'x-ms-global-Committed-lsn': 'REDACTED' + 'x-ms-number-of-read-regions': 'REDACTED' + 'x-ms-transport-request-id': 'REDACTED' + 'x-ms-cosmos-llsn': 'REDACTED' + 'x-ms-session-token': 'REDACTED' + 'x-ms-request-duration-ms': 'REDACTED' + 'x-ms-serviceversion': 'REDACTED' + 'x-ms-cosmos-is-partition-key-delete-pending': 'REDACTED' + 'x-ms-cosmos-physical-partition-id': 'REDACTED' +2024-09-23 10:50:28.499 `label` got an empty value. This is discouraged for accessibility reasons and may be disallowed in the future by raising an exception. Please provide a non-empty label and hide it with label_visibility if needed. +ERROR:modules.database.database:Error al obtener detalles de análisis para el usuario sebastian.marroquin@aideatext.ai: Error=2, Details='Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 1232e510-97a7-434e-a4c1-fca9fcdb4820; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 1232e510-97a7-434e-a4c1-fca9fcdb4820; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 1232e510-97a7-434e-a4c1-fca9fcdb4820; Reason: (Message: {"Errors":["The index path corresponding to the specified order-by item is excluded."]} +ActivityId: 1232e510-97a7-434e-a4c1-fca9fcdb4820, Request URI: /apps/8198d87f-2a8c-48ce-b2aa-d600d8339179/services/8cde3c70-163e-4ffe-9ef7-2e635e3612a9/partitions/617356c9-0748-483a-9063-d83f8fa10f24/replicas/133658946384147008s/, RequestStats: Microsoft.Azure.Cosmos.Tracing.TraceData.ClientSideRequestStatisticsTraceDatum, SDK: Windows/10.0.20348 cosmos-netstandard-sdk/3.18.0);););, full error: {'ok': 0.0, 'errmsg': 'Error=2, Details=\'Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 1232e510-97a7-434e-a4c1-fca9fcdb4820; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 1232e510-97a7-434e-a4c1-fca9fcdb4820; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 1232e510-97a7-434e-a4c1-fca9fcdb4820; Reason: (Message: {"Errors":["The index path corresponding to the specified order-by item is excluded."]}\r\nActivityId: 1232e510-97a7-434e-a4c1-fca9fcdb4820, Request URI: /apps/8198d87f-2a8c-48ce-b2aa-d600d8339179/services/8cde3c70-163e-4ffe-9ef7-2e635e3612a9/partitions/617356c9-0748-483a-9063-d83f8fa10f24/replicas/133658946384147008s/, RequestStats: Microsoft.Azure.Cosmos.Tracing.TraceData.ClientSideRequestStatisticsTraceDatum, SDK: Windows/10.0.20348 cosmos-netstandard-sdk/3.18.0);););', 'code': 2, 'codeName': 'BadValue'} +ERROR:modules.database.database:Error al obtener detalles de análisis para el usuario sebastian.marroquin@aideatext.ai: Error=2, Details='Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 42ca6540-5e85-417e-ac10-84c49e87515c; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 42ca6540-5e85-417e-ac10-84c49e87515c; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 42ca6540-5e85-417e-ac10-84c49e87515c; Reason: (Message: {"Errors":["The index path corresponding to the specified order-by item is excluded."]} +ActivityId: 42ca6540-5e85-417e-ac10-84c49e87515c, Request URI: /apps/8198d87f-2a8c-48ce-b2aa-d600d8339179/services/8cde3c70-163e-4ffe-9ef7-2e635e3612a9/partitions/617356c9-0748-483a-9063-d83f8fa10f24/replicas/133710761763567388s/, RequestStats: Microsoft.Azure.Cosmos.Tracing.TraceData.ClientSideRequestStatisticsTraceDatum, SDK: Windows/10.0.20348 cosmos-netstandard-sdk/3.18.0);););, full error: {'ok': 0.0, 'errmsg': 'Error=2, Details=\'Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 42ca6540-5e85-417e-ac10-84c49e87515c; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 42ca6540-5e85-417e-ac10-84c49e87515c; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 42ca6540-5e85-417e-ac10-84c49e87515c; Reason: (Message: {"Errors":["The index path corresponding to the specified order-by item is excluded."]}\r\nActivityId: 42ca6540-5e85-417e-ac10-84c49e87515c, Request URI: /apps/8198d87f-2a8c-48ce-b2aa-d600d8339179/services/8cde3c70-163e-4ffe-9ef7-2e635e3612a9/partitions/617356c9-0748-483a-9063-d83f8fa10f24/replicas/133710761763567388s/, RequestStats: Microsoft.Azure.Cosmos.Tracing.TraceData.ClientSideRequestStatisticsTraceDatum, SDK: Windows/10.0.20348 cosmos-netstandard-sdk/3.18.0);););', 'code': 2, 'codeName': 'BadValue'} +ERROR:modules.database.database:Error al obtener detalles de análisis para el usuario sebastian.marroquin@aideatext.ai: Error=2, Details='Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 20b3da1e-1bb8-4857-8d0d-80fd19d49e32; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 20b3da1e-1bb8-4857-8d0d-80fd19d49e32; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 20b3da1e-1bb8-4857-8d0d-80fd19d49e32; Reason: (Message: {"Errors":["The index path corresponding to the specified order-by item is excluded."]} +ActivityId: 20b3da1e-1bb8-4857-8d0d-80fd19d49e32, Request URI: /apps/8198d87f-2a8c-48ce-b2aa-d600d8339179/services/8cde3c70-163e-4ffe-9ef7-2e635e3612a9/partitions/617356c9-0748-483a-9063-d83f8fa10f24/replicas/133710761763567388s/, RequestStats: Microsoft.Azure.Cosmos.Tracing.TraceData.ClientSideRequestStatisticsTraceDatum, SDK: Windows/10.0.20348 cosmos-netstandard-sdk/3.18.0);););, full error: {'ok': 0.0, 'errmsg': 'Error=2, Details=\'Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 20b3da1e-1bb8-4857-8d0d-80fd19d49e32; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 20b3da1e-1bb8-4857-8d0d-80fd19d49e32; Reason: (Response status code does not indicate success: BadRequest (400); Substatus: 0; ActivityId: 20b3da1e-1bb8-4857-8d0d-80fd19d49e32; Reason: (Message: {"Errors":["The index path corresponding to the specified order-by item is excluded."]}\r\nActivityId: 20b3da1e-1bb8-4857-8d0d-80fd19d49e32, Request URI: /apps/8198d87f-2a8c-48ce-b2aa-d600d8339179/services/8cde3c70-163e-4ffe-9ef7-2e635e3612a9/partitions/617356c9-0748-483a-9063-d83f8fa10f24/replicas/133710761763567388s/, RequestStats: Microsoft.Azure.Cosmos.Tracing.TraceData.ClientSideRequestStatisticsTraceDatum, SDK: Windows/10.0.20348 cosmos-netstandard-sdk/3.18.0);););', 'code': 2, 'codeName': 'BadValue'} +ERROR:modules.ui.ui:Error en la pestaña 3: 'timestamp' +Traceback (most recent call last): + File "M:\test-3dev\modules\ui\ui.py", line 177, in user_page + func(st.session_state.username, st.session_state.lang_code, t) + File "M:\test-3dev\modules\studentact\student_activities.py", line 88, in display_student_progress + st.subheader(f"Conversación {i+1} - {chat['timestamp']}") + ~~~~^^^^^^^^^^^^^ +KeyError: 'timestamp' +INFO:root:display_feedback_form called with lang_code: es +INFO:modules.ui.ui:Finalizada la renderización de user_page +INFO:modules.ui.ui:Estado final de la sesión: {'semantic_file_selector_sebastian.marroquin@aideatext.ai': 'Uso de stanza en el análisis sintác.txt', 'graph_visible': True, 'logout_button_sebastian.marroquin@aideatext.ai_es': False, 'discourse_chatbot':
+
+
+ """, height=0)
+ return box_id
+
+def toggle_float_visibility(box_id, visible):
+ display = "block" if visible else "none"
+ components.html(f"""
+
+ """, height=0)
+
+def update_float_content(box_id, new_content):
+ components.html(f"""
+
+ """, height=0)
+'''
+
+
+# Lista de estilos de sombra (puedes ajustar según tus preferencias)
+shadow_list = [
+ "box-shadow: rgba(0, 0, 0, 0.1) 0px 4px 12px;",
+ "box-shadow: rgba(0, 0, 0, 0.15) 0px 5px 15px 0px;",
+ "box-shadow: rgba(0, 0, 0, 0.05) 0px 6px 24px 0px, rgba(0, 0, 0, 0.08) 0px 0px 0px 1px;",
+ "box-shadow: rgba(0, 0, 0, 0.16) 0px 10px 36px 0px, rgba(0, 0, 0, 0.06) 0px 0px 0px 1px;",
+]
+
+# Lista de estilos de transición
+transition_list = [
+ "transition: all 0.3s ease;",
+ "transition: all 0.5s cubic-bezier(0.25, 0.8, 0.25, 1);",
+ "transition: all 0.4s cubic-bezier(0.165, 0.84, 0.44, 1);",
+]
+
+def semantic_float_init():
+ """Inicializa los estilos necesarios para los elementos flotantes en la interfaz semántica."""
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+def float_graph(content, width="40%", height="60%", position="bottom-right", shadow=0, transition=0):
+ """
+ Crea un contenedor flotante para el gráfico de visualización semántica.
+
+ :param content: Contenido HTML o Markdown para el gráfico
+ :param width: Ancho del contenedor
+ :param height: Altura del contenedor
+ :param position: Posición del contenedor ('top-left', 'top-right', 'bottom-left', 'bottom-right')
+ :param shadow: Índice del estilo de sombra a utilizar
+ :param transition: Índice del estilo de transición a utilizar
+ """
+ position_css = {
+ "top-left": "top: 20px; left: 20px;",
+ "top-right": "top: 20px; right: 20px;",
+ "bottom-left": "bottom: 20px; left: 20px;",
+ "bottom-right": "bottom: 20px; right: 20px;",
+ }
+
+ css = f"""
+ width: {width};
+ height: {height};
+ {position_css.get(position, position_css['bottom-right'])}
+ {shadow_list[shadow % len(shadow_list)]}
+ {transition_list[transition % len(transition_list)]}
+ """
+
+ return float_box(content, css=css)
+
+def float_box(content, css=""):
+ """
+ Crea un contenedor flotante genérico.
+
+ :param content: Contenido HTML o Markdown para el contenedor
+ :param css: Estilos CSS adicionales
+ """
+ box_id = f"semantic-float-{str(uuid.uuid4())[:8]}"
+ st.markdown(f"""
+
+ {content}
+
+
+
+ """, unsafe_allow_html=True)
+ return box_id
+
+def toggle_float_visibility(box_id, visible):
+ """
+ Cambia la visibilidad de un contenedor flotante.
+
+ :param box_id: ID del contenedor flotante
+ :param visible: True para mostrar, False para ocultar
+ """
+ display = "block" if visible else "none"
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+def update_float_content(box_id, new_content):
+ """
+ Actualiza el contenido de un contenedor flotante.
+
+ :param box_id: ID del contenedor flotante
+ :param new_content: Nuevo contenido HTML o Markdown
+ """
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+# Puedes agregar más funciones específicas para la interfaz semántica según sea necesario
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_float68ok.py b/src/modules/semantic/semantic_float68ok.py
new file mode 100644
index 0000000000000000000000000000000000000000..a57a08d49e3c3945b90a1a358305e520a6e1d650
--- /dev/null
+++ b/src/modules/semantic/semantic_float68ok.py
@@ -0,0 +1,467 @@
+import streamlit as st
+import uuid
+import streamlit.components.v1 as components
+import streamlit.components.v1 as stc
+
+########################## PRUEBA 1 #########################
+ # COMBINADO CON SEMANCTIC_INTERFACE_68OK APARECEN DOS BOX FLOTANTES
+# Lista de estilos de sombra (puedes ajustar según tus preferencias)
+
+'''
+shadow_list = [
+ "box-shadow: rgba(0, 0, 0, 0.1) 0px 4px 12px;",
+ "box-shadow: rgba(0, 0, 0, 0.15) 0px 5px 15px 0px;",
+ "box-shadow: rgba(0, 0, 0, 0.05) 0px 6px 24px 0px, rgba(0, 0, 0, 0.08) 0px 0px 0px 1px;",
+ "box-shadow: rgba(0, 0, 0, 0.16) 0px 10px 36px 0px, rgba(0, 0, 0, 0.06) 0px 0px 0px 1px;",
+]
+
+# Lista de estilos de transición
+transition_list = [
+ "transition: all 0.3s ease;",
+ "transition: all 0.5s cubic-bezier(0.25, 0.8, 0.25, 1);",
+ "transition: all 0.4s cubic-bezier(0.165, 0.84, 0.44, 1);",
+]
+
+def semantic_float_init():
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+####################################################
+def float_graph(content, width="40%", height="60%", position="bottom-right", shadow=0, transition=0):
+ position_css = {
+ "top-left": "top: 20px; left: 20px;",
+ "top-right": "top: 20px; right: 20px;",
+ "bottom-left": "bottom: 20px; left: 20px;",
+ "bottom-right": "bottom: 20px; right: 20px;",
+ }
+ css = f"""
+ width: {width};
+ height: {height};
+ position: fixed;
+ z-index: 9999;
+ background-color: white;
+ border: 1px solid #ddd;
+ padding: 10px;
+ overflow: auto;
+ {position_css.get(position, position_css['bottom-right'])}
+ {shadow_list[shadow % len(shadow_list)]}
+ {transition_list[transition % len(transition_list)]}
+ """
+ return float_box(content, css=css)
+
+#########################################################
+def float_box(content, css=""):
+ box_id = f"semantic-float-{str(uuid.uuid4())[:8]}"
+ st.markdown(f"""
+
+ {content}
+
+
+ {content}
+
+ """, unsafe_allow_html=True)
+ return box_id
+
+#########################################################
+
+def toggle_float_visibility(box_id, visible):
+ """
+ Cambia la visibilidad de un contenedor flotante.
+
+ :param box_id: ID del contenedor flotante
+ :param visible: True para mostrar, False para ocultar
+ """
+ display = "block" if visible else "none"
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+###########################################################
+def update_float_content(box_id, new_content):
+ """
+ Actualiza el contenido de un contenedor flotante.
+
+ :param box_id: ID del contenedor flotante
+ :param new_content: Nuevo contenido HTML o Markdown
+ """
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+# Puedes agregar más funciones específicas para la interfaz semántica según sea necesario
+'''
+
+################################################# version backup #########################
+ # COMBINADO CON SEMANCTIC_INTERFACE_68OK APARECEN SOLO UN CUADRO A LA DERECJHA Y AL CENTRO
+ # Lista de estilos de sombra (puedes ajustar según tus preferencias)
+shadow_list = [
+ "box-shadow: rgba(0, 0, 0, 0.1) 0px 4px 12px;",
+ "box-shadow: rgba(0, 0, 0, 0.15) 0px 5px 15px 0px;",
+ "box-shadow: rgba(0, 0, 0, 0.05) 0px 6px 24px 0px, rgba(0, 0, 0, 0.08) 0px 0px 0px 1px;",
+ "box-shadow: rgba(0, 0, 0, 0.16) 0px 10px 36px 0px, rgba(0, 0, 0, 0.06) 0px 0px 0px 1px;",
+]
+
+# Lista de estilos de transición
+transition_list = [
+ "transition: all 0.3s ease;",
+ "transition: all 0.5s cubic-bezier(0.25, 0.8, 0.25, 1);",
+ "transition: all 0.4s cubic-bezier(0.165, 0.84, 0.44, 1);",
+]
+
+
+def semantic_float_init():
+ """Inicializa los estilos necesarios para los elementos flotantes en la interfaz semántica."""
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+def float_graph(content, width="40%", height="60%", position="bottom-right", shadow=0, transition=0):
+ """
+ Crea un contenedor flotante para el gráfico de visualización semántica.
+
+ :param content: Contenido HTML o Markdown para el gráfico
+ :param width: Ancho del contenedor
+ :param height: Altura del contenedor
+ :param position: Posición del contenedor ('top-left', 'top-right', 'bottom-left', 'bottom-right')
+ :param shadow: Índice del estilo de sombra a utilizar
+ :param transition: Índice del estilo de transición a utilizar
+ """
+ position_css = {
+ "top-left": "top: 20px; left: 20px;",
+ "top-right": "top: 20px; right: 20px;",
+ "bottom-left": "bottom: 20px; left: 20px;",
+ "bottom-right": "bottom: 20px; right: 20px;",
+ }
+
+ css = f"""
+ width: {width};
+ height: {height};
+ {position_css.get(position, position_css['bottom-right'])}
+ {shadow_list[shadow % len(shadow_list)]}
+ {transition_list[transition % len(transition_list)]}
+ """
+
+ return float_box(content, css=css)
+
+def float_box(content, css=""):
+ """
+ Crea un contenedor flotante genérico.
+
+ :param content: Contenido HTML o Markdown para el contenedor
+ :param css: Estilos CSS adicionales
+ """
+ box_id = f"semantic-float-{str(uuid.uuid4())[:8]}"
+ st.markdown(f"""
+
+
+ """, unsafe_allow_html=True)
+ return box_id
+
+def toggle_float_visibility(box_id, visible):
+ """
+ Cambia la visibilidad de un contenedor flotante.
+
+ :param box_id: ID del contenedor flotante
+ :param visible: True para mostrar, False para ocultar
+ """
+ display = "block" if visible else "none"
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+def update_float_content(box_id, new_content):
+ """
+ Actualiza el contenido de un contenedor flotante.
+
+ :param box_id: ID del contenedor flotante
+ :param new_content: Nuevo contenido HTML o Markdown
+ """
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+# Puedes agregar más funciones específicas para la interfaz semántica según sea necesario
+#################FIN BLOQUE DEL BACK UP#################################################
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+'''
+############ TEST #########################################
+def semantic_float_init():
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+def float_graph(content, width="40%", height="60%", position="center-right", shadow=0, transition=0):
+ position_css = {
+ "top-left": "top: 20px; left: 20px;",
+ "top-right": "top: 20px; right: 20px;",
+ "bottom-left": "bottom: 20px; left: 20px;",
+ "bottom-right": "bottom: 20px; right: 20px;",
+ "center-right": "top: 50%; right: 20px; transform: translateY(-50%);"
+ }
+
+ css = f"""
+ position: fixed;
+ width: {width};
+ height: {height};
+ {position_css.get(position, position_css['center-right'])}
+ {shadow_list[shadow % len(shadow_list)]}
+ {transition_list[transition % len(transition_list)]}
+ z-index: 9999;
+ display: block !important;
+ background-color: white;
+ border: 1px solid #ddd;
+ border-radius: 5px;
+ padding: 10px;
+ overflow: auto;
+ """
+
+ box_id = f"semantic-float-{str(uuid.uuid4())[:8]}"
+ html_content = f"""
+
+ {content}
+
+
+ {content}
+
+
+ """
+
+ components.html(html_content, height=600, scrolling=True)
+ return box_id
+
+def toggle_float_visibility(box_id, visible):
+ display = "block" if visible else "none"
+ components.html(f"""
+
+ """, height=0)
+
+def update_float_content(box_id, new_content):
+ components.html(f"""
+
+ """, height=0)
+
+
+
+
+
+
+
+
+
+
+############BackUp #########################################
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Lista de estilos de sombra y transición (sin cambios)
+shadow_list = [
+ "box-shadow: rgba(0, 0, 0, 0.1) 0px 4px 12px;",
+ "box-shadow: rgba(0, 0, 0, 0.15) 0px 5px 15px 0px;",
+ "box-shadow: rgba(0, 0, 0, 0.05) 0px 6px 24px 0px, rgba(0, 0, 0, 0.08) 0px 0px 0px 1px;",
+ "box-shadow: rgba(0, 0, 0, 0.16) 0px 10px 36px 0px, rgba(0, 0, 0, 0.06) 0px 0px 0px 1px;",
+]
+
+transition_list = [
+ "transition: all 0.3s ease;",
+ "transition: all 0.5s cubic-bezier(0.25, 0.8, 0.25, 1);",
+ "transition: all 0.4s cubic-bezier(0.165, 0.84, 0.44, 1);",
+]
+
+def semantic_float_init():
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+def float_graph(content, width="40%", height="60%", position="bottom-right", shadow=0, transition=0):
+ position_css = {
+ "top-left": "top: 20px; left: 20px;",
+ "top-right": "top: 20px; right: 20px;",
+ "bottom-left": "bottom: 20px; left: 20px;",
+ "bottom-right": "bottom: 20px; right: 20px;",
+ "center-right": "top: 50%; right: 20px; transform: translateY(-50%);"
+ }
+
+ css = f"""
+ width: {width};
+ height: {height};
+ {position_css.get(position, position_css['bottom-right'])}
+ {shadow_list[shadow % len(shadow_list)]}
+ {transition_list[transition % len(transition_list)]}
+ """
+
+ return float_box(content, css=css)
+
+def float_box(content, css=""):
+ box_id = f"semantic-float-{str(uuid.uuid4())[:8]}"
+ components.html(f"""
+
+
+
+ """, height=0)
+ return box_id
+
+def toggle_float_visibility(box_id, visible):
+ display = "block" if visible else "none"
+ components.html(f"""
+
+ """, height=0)
+
+def update_float_content(box_id, new_content):
+ components.html(f"""
+
+ """, height=0)
+'''
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_float_old.py b/src/modules/semantic/semantic_float_old.py
new file mode 100644
index 0000000000000000000000000000000000000000..192c7a46004ab8b35c2046cde482a001088475c7
--- /dev/null
+++ b/src/modules/semantic/semantic_float_old.py
@@ -0,0 +1,220 @@
+import streamlit as st
+import uuid
+import streamlit.components.v1 as components
+import base64
+
+'''
+
+# Lista de estilos de sombra y transición (sin cambios)
+shadow_list = [
+ "box-shadow: rgba(0, 0, 0, 0.1) 0px 4px 12px;",
+ "box-shadow: rgba(0, 0, 0, 0.15) 0px 5px 15px 0px;",
+ "box-shadow: rgba(0, 0, 0, 0.05) 0px 6px 24px 0px, rgba(0, 0, 0, 0.08) 0px 0px 0px 1px;",
+ "box-shadow: rgba(0, 0, 0, 0.16) 0px 10px 36px 0px, rgba(0, 0, 0, 0.06) 0px 0px 0px 1px;",
+]
+
+transition_list = [
+ "transition: all 0.3s ease;",
+ "transition: all 0.5s cubic-bezier(0.25, 0.8, 0.25, 1);",
+ "transition: all 0.4s cubic-bezier(0.165, 0.84, 0.44, 1);",
+]
+
+def semantic_float_init():
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+def float_graph(content, width="40%", height="60%", position="bottom-right", shadow=0, transition=0):
+ position_css = {
+ "top-left": "top: 20px; left: 20px;",
+ "top-right": "top: 20px; right: 20px;",
+ "bottom-left": "bottom: 20px; left: 20px;",
+ "bottom-right": "bottom: 20px; right: 20px;",
+ "center-right": "top: 50%; right: 20px; transform: translateY(-50%);"
+ }
+
+ css = f"""
+ width: {width};
+ height: {height};
+ {position_css.get(position, position_css['bottom-right'])}
+ {shadow_list[shadow % len(shadow_list)]}
+ {transition_list[transition % len(transition_list)]}
+ """
+
+ return float_box(content, css=css)
+
+def float_box(content, css=""):
+ box_id = f"semantic-float-{str(uuid.uuid4())[:8]}"
+ components.html(f"""
+
+ {content}
+
+
+
+
+ """, height=0)
+ return box_id
+
+def toggle_float_visibility(box_id, visible):
+ display = "block" if visible else "none"
+ components.html(f"""
+
+ """, height=0)
+
+def update_float_content(box_id, new_content):
+ components.html(f"""
+
+ """, height=0)
+'''
+
+
+# Lista de estilos de sombra (puedes ajustar según tus preferencias)
+shadow_list = [
+ "box-shadow: rgba(0, 0, 0, 0.1) 0px 4px 12px;",
+ "box-shadow: rgba(0, 0, 0, 0.15) 0px 5px 15px 0px;",
+ "box-shadow: rgba(0, 0, 0, 0.05) 0px 6px 24px 0px, rgba(0, 0, 0, 0.08) 0px 0px 0px 1px;",
+ "box-shadow: rgba(0, 0, 0, 0.16) 0px 10px 36px 0px, rgba(0, 0, 0, 0.06) 0px 0px 0px 1px;",
+]
+
+# Lista de estilos de transición
+transition_list = [
+ "transition: all 0.3s ease;",
+ "transition: all 0.5s cubic-bezier(0.25, 0.8, 0.25, 1);",
+ "transition: all 0.4s cubic-bezier(0.165, 0.84, 0.44, 1);",
+]
+
+
+def encode_image_to_base64(image_path):
+ with open(image_path, "rb") as image_file:
+ encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
+ return f"data:image/png;base64,{encoded_string}"
+
+
+def semantic_float_init():
+ """Inicializa los estilos necesarios para los elementos flotantes en la interfaz semántica."""
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+def float_graph(content, width="40%", height="60%", position="bottom-right", shadow=0, transition=0):
+ """
+ Crea un contenedor flotante para el gráfico de visualización semántica.
+
+ :param content: Contenido HTML o Markdown para el gráfico
+ :param width: Ancho del contenedor
+ :param height: Altura del contenedor
+ :param position: Posición del contenedor ('top-left', 'top-right', 'bottom-left', 'bottom-right')
+ :param shadow: Índice del estilo de sombra a utilizar
+ :param transition: Índice del estilo de transición a utilizar
+ """
+ position_css = {
+ "top-left": "top: 20px; left: 20px;",
+ "top-right": "top: 20px; right: 20px;",
+ "bottom-left": "bottom: 20px; left: 20px;",
+ "bottom-right": "bottom: 20px; right: 20px;",
+ }
+
+ css = f"""
+ width: {width};
+ height: {height};
+ {position_css.get(position, position_css['bottom-right'])}
+ {shadow_list[shadow % len(shadow_list)]}
+ {transition_list[transition % len(transition_list)]}
+ """
+
+ return float_box(content, css=css)
+
+def float_box(content, css=""):
+ """
+ Crea un contenedor flotante genérico.
+
+ :param content: Contenido HTML o Markdown para el contenedor
+ :param css: Estilos CSS adicionales
+ """
+ box_id = f"semantic-float-{str(uuid.uuid4())[:8]}"
+ st.markdown(f"""
+
+ {content}
+
+
+
+ """, unsafe_allow_html=True)
+ return box_id
+
+def toggle_float_visibility(box_id, visible):
+ """
+ Cambia la visibilidad de un contenedor flotante.
+
+ :param box_id: ID del contenedor flotante
+ :param visible: True para mostrar, False para ocultar
+ """
+ display = "block" if visible else "none"
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+def update_float_content(box_id, new_content):
+ """
+ Actualiza el contenido de un contenedor flotante.
+
+ :param box_id: ID del contenedor flotante
+ :param new_content: Nuevo contenido HTML o Markdown
+ """
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+# Puedes agregar más funciones específicas para la interfaz semántica según sea necesario
diff --git a/src/modules/semantic/semantic_float_reset.py b/src/modules/semantic/semantic_float_reset.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d782eb27f4493283de556391ef49334ed6e7256
--- /dev/null
+++ b/src/modules/semantic/semantic_float_reset.py
@@ -0,0 +1,94 @@
+import streamlit as st
+import uuid
+import streamlit.components.v1 as components
+import base64
+
+# Lista de estilos de sombra
+shadow_list = [
+ "box-shadow: rgba(0, 0, 0, 0.1) 0px 4px 12px;",
+ "box-shadow: rgba(0, 0, 0, 0.15) 0px 5px 15px 0px;",
+ "box-shadow: rgba(0, 0, 0, 0.05) 0px 6px 24px 0px, rgba(0, 0, 0, 0.08) 0px 0px 0px 1px;",
+ "box-shadow: rgba(0, 0, 0, 0.16) 0px 10px 36px 0px, rgba(0, 0, 0, 0.06) 0px 0px 0px 1px;",
+]
+
+# Lista de estilos de transición
+transition_list = [
+ "transition: all 0.3s ease;",
+ "transition: all 0.5s cubic-bezier(0.25, 0.8, 0.25, 1);",
+ "transition: all 0.4s cubic-bezier(0.165, 0.84, 0.44, 1);",
+
+]
+
+###################################################################################
+def semantic_float_init():
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ components.html("""
+
+
+ """, height=0)
+
+def float_graph(content):
+ js = f"""
+
+ """
+ components.html(js, height=0)
+
+def toggle_float_visibility(visible):
+ js = f"""
+
+ """
+ components.html(js, height=0)
+
+def update_float_content(new_content):
+ js = f"""
+
+ """
+ components.html(js, height=0)
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_float_reset_23-9-2024.py b/src/modules/semantic/semantic_float_reset_23-9-2024.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d8fb602fec66518348fcfa37e1a272284a7adf4
--- /dev/null
+++ b/src/modules/semantic/semantic_float_reset_23-9-2024.py
@@ -0,0 +1,128 @@
+import streamlit as st
+import uuid
+import streamlit.components.v1 as components
+import base64
+
+# Lista de estilos de sombra
+shadow_list = [
+ "box-shadow: rgba(0, 0, 0, 0.1) 0px 4px 12px;",
+ "box-shadow: rgba(0, 0, 0, 0.15) 0px 5px 15px 0px;",
+ "box-shadow: rgba(0, 0, 0, 0.05) 0px 6px 24px 0px, rgba(0, 0, 0, 0.08) 0px 0px 0px 1px;",
+ "box-shadow: rgba(0, 0, 0, 0.16) 0px 10px 36px 0px, rgba(0, 0, 0, 0.06) 0px 0px 0px 1px;",
+]
+
+# Lista de estilos de transición
+transition_list = [
+ "transition: all 0.3s ease;",
+ "transition: all 0.5s cubic-bezier(0.25, 0.8, 0.25, 1);",
+ "transition: all 0.4s cubic-bezier(0.165, 0.84, 0.44, 1);",
+]
+
+def semantic_float_init():
+ components.html("""
+
+ """, height=0)
+
+def float_graph(content, width="40%", height="60%", position="center-right", shadow=0, transition=0):
+ position_css = {
+ "top-left": "top: 20px; left: 20px;",
+ "top-right": "top: 20px; right: 20px;",
+ "bottom-left": "bottom: 20px; left: 20px;",
+ "bottom-right": "bottom: 20px; right: 20px;",
+ "center-right": "top: 50%; right: 20px; transform: translateY(-50%);"
+ }
+
+ css = f"""
+ position: fixed;
+ width: {width};
+ height: {height};
+ {position_css.get(position, position_css['center-right'])}
+ {shadow_list[shadow % len(shadow_list)]}
+ {transition_list[transition % len(transition_list)]}
+ z-index: 9999;
+ display: block !important;
+ background-color: white;
+ border: 1px solid #ddd;
+ border-radius: 5px;
+ padding: 10px;
+ overflow: auto;
+ """
+
+ box_id = f"semantic-float-{str(uuid.uuid4())[:8]}"
+ components.html(f"""
+
+ {content}
+
+
+ {content}
+
+
+ """, height=0)
+ return box_id
+
+def float_box(content, css=""):
+ box_id = f"semantic-float-{str(uuid.uuid4())[:8]}"
+ components.html(f"""
+
+ {content}
+
+
+ """, height=0)
+ return box_id
+
+def toggle_float_visibility(box_id, visible):
+ display = "block" if visible else "none"
+ components.html(f"""
+
+ """, height=0)
+
+def update_float_content(box_id, new_content):
+ components.html(f"""
+
+ """, height=0)
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface.py b/src/modules/semantic/semantic_interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..db991fb859817405bd7be3033d6a58824331dde2
--- /dev/null
+++ b/src/modules/semantic/semantic_interface.py
@@ -0,0 +1,290 @@
+#modules/semantic/semantic_interface.py
+import streamlit as st
+from streamlit_float import *
+from streamlit_antd_components import *
+from streamlit.components.v1 import html
+import spacy_streamlit
+import io
+from io import BytesIO
+import base64
+import matplotlib.pyplot as plt
+import pandas as pd
+import re
+
+import logging
+
+# Configuración del logger
+logger = logging.getLogger(__name__)
+
+# Importaciones locales
+from .semantic_process import (
+ process_semantic_input,
+ format_semantic_results
+)
+
+from ..utils.widget_utils import generate_unique_key
+from ..database.semantic_mongo_db import store_student_semantic_result
+from ..database.chat_mongo_db import store_chat_history, get_chat_history
+
+from ..semantic.semantic_agent_interaction import display_semantic_chat
+from ..chatbot.sidebar_chat import display_sidebar_chat
+
+# from ..database.semantic_export import export_user_interactions
+
+###############################
+
+def display_semantic_interface(lang_code, nlp_models, semantic_t):
+ try:
+ # 1. Inicializar el estado de la sesión
+ if 'semantic_state' not in st.session_state:
+ st.session_state.semantic_state = {
+ 'analysis_count': 0,
+ 'last_analysis': None,
+ 'current_file': None,
+ 'pending_analysis': False # Nuevo flag para controlar el análisis pendiente
+ }
+
+ # 2. Área de carga de archivo con mensaje informativo
+ uploaded_file = st.file_uploader(
+ semantic_t.get('semantic_file_uploader', 'Upload a text file for semantic analysis'),
+ type=['txt'],
+ key=f"semantic_file_uploader_{st.session_state.semantic_state['analysis_count']}"
+ )
+
+ # 2.1 Verificar si hay un archivo cargado y un análisis pendiente
+
+ if uploaded_file is not None and st.session_state.semantic_state.get('pending_analysis', False):
+
+ try:
+ with st.spinner(semantic_t.get('processing', 'Processing...')):
+ # Realizar análisis
+ text_content = uploaded_file.getvalue().decode('utf-8')
+ st.session_state.semantic_state['text_content'] = text_content # <-- Guardar el texto
+
+ analysis_result = process_semantic_input(
+ text_content,
+ lang_code,
+ nlp_models,
+ semantic_t
+ )
+
+ if analysis_result['success']:
+ # Guardar resultado
+ st.session_state.semantic_result = analysis_result
+ st.session_state.semantic_state['analysis_count'] += 1
+ st.session_state.semantic_state['current_file'] = uploaded_file.name
+
+ # Preparar datos para MongoDB
+ analysis_data = {
+ 'key_concepts': analysis_result['analysis'].get('key_concepts', []),
+ 'concept_centrality': analysis_result['analysis'].get('concept_centrality', {}),
+ 'concept_graph': analysis_result['analysis'].get('concept_graph')
+ }
+
+ # Guardar en base de datos
+ storage_success = store_student_semantic_result(
+ st.session_state.username,
+ text_content,
+ analysis_result['analysis'],
+ lang_code # Pasamos el código de idioma directamente
+ )
+
+ if storage_success:
+ st.success(
+ semantic_t.get('analysis_complete',
+ 'Análisis completado y guardado. Para realizar un nuevo análisis, cargue otro archivo.')
+ )
+ else:
+ st.error(semantic_t.get('error_message', 'Error saving analysis'))
+ else:
+ st.error(analysis_result['message'])
+
+ # Restablecer el flag de análisis pendiente
+ st.session_state.semantic_state['pending_analysis'] = False
+
+ except Exception as e:
+ logger.error(f"Error en análisis semántico: {str(e)}")
+ st.error(semantic_t.get('error_processing', f'Error processing text: {str(e)}'))
+ # Restablecer el flag de análisis pendiente en caso de error
+ st.session_state.semantic_state['pending_analysis'] = False
+
+ # 3. Columnas para los botones y mensajes
+ col1, col2 = st.columns([1,4])
+
+ # 4. Botón de análisis
+ with col1:
+ analyze_button = st.button(
+ semantic_t.get('semantic_analyze_button', 'Analyze'),
+ key=f"semantic_analyze_button_{st.session_state.semantic_state['analysis_count']}",
+ type="primary",
+ icon="🔍",
+ disabled=uploaded_file is None,
+ use_container_width=True
+ )
+
+ # 5. Procesar análisis
+ if analyze_button and uploaded_file is not None:
+ # En lugar de realizar el análisis inmediatamente, establecer el flag
+ st.session_state.semantic_state['pending_analysis'] = True
+ # Forzar la recarga de la aplicación
+ st.rerun()
+
+ # 6. Mostrar resultados previos o mensaje inicial
+ elif 'semantic_result' in st.session_state and st.session_state.semantic_result is not None:
+ # Mostrar mensaje sobre el análisis actual
+ #st.info(
+ # semantic_t.get('current_analysis_message',
+ # 'Mostrando análisis del archivo: {}. Para realizar un nuevo análisis, cargue otro archivo.'
+ # ).format(st.session_state.semantic_state["current_file"])
+ #)
+
+ display_semantic_results(
+ st.session_state.semantic_result,
+ lang_code,
+ semantic_t
+ )
+
+ # --- BOTÓN PARA ACTIVAR EL AGENTE VIRTUAL (NUEVA POSICIÓN CORRECTA) ---
+ if st.button("💬 Consultar con Asistente"):
+ if 'semantic_result' not in st.session_state:
+ st.error("Primero complete el análisis semántico")
+ return
+
+ # Guardar TODOS los datos necesarios
+ st.session_state.semantic_agent_data = {
+ 'text': st.session_state.semantic_state['text_content'], # Texto completo
+ 'metrics': st.session_state.semantic_result['analysis'], # Métricas
+ 'graph_data': st.session_state.semantic_result['analysis'].get('concept_graph')
+ }
+ st.session_state.semantic_agent_active = True
+ st.rerun()
+
+ # Mostrar notificación si el agente está activo
+ if st.session_state.get('semantic_agent_active', False):
+ st.success(semantic_t.get('semantic_agent_ready_message', 'El agente virtual está listo. Abre el chat en la barra lateral.'))
+
+ else:
+ st.info(semantic_t.get('upload_prompt', 'Cargue un archivo para comenzar el análisis'))
+
+ except Exception as e:
+ logger.error(f"Error general en interfaz semántica: {str(e)}")
+ st.error(semantic_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
+
+
+#######################################
+
+def display_semantic_results(semantic_result, lang_code, semantic_t):
+ """
+ Muestra los resultados del análisis semántico de conceptos clave.
+ """
+ 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']
+
+ # Mostrar conceptos clave en formato horizontal (se mantiene igual)
+ st.subheader(semantic_t.get('key_concepts', 'Key Concepts'))
+ if 'key_concepts' in analysis and analysis['key_concepts']:
+ df = pd.DataFrame(
+ analysis['key_concepts'],
+ columns=[
+ semantic_t.get('concept', 'Concept'),
+ semantic_t.get('frequency', 'Frequency')
+ ]
+ )
+
+ st.write(
+ """
+
+
+ """ +
+ ''.join([
+ f'
",
+ unsafe_allow_html=True
+ )
+ else:
+ st.info(semantic_t.get('no_concepts', 'No key concepts found'))
+
+ # Gráfico de conceptos (versión modificada)
+ if 'concept_graph' in analysis and analysis['concept_graph'] is not None:
+ try:
+ # Sección del gráfico (sin div contenedor)
+ st.image(
+ analysis['concept_graph'],
+ use_container_width=True
+ )
+
+ # --- SOLO ESTE BLOQUE ES NUEVO ---
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+ # ---------------------------------
+
+ # Expandible con la interpretación (se mantiene igual)
+ with st.expander("📊 " + semantic_t.get('semantic_graph_interpretation', "Interpretación del gráfico semántico")):
+ st.markdown(f"""
+ - 🔀 {semantic_t.get('semantic_arrow_meaning', 'Las flechas indican la dirección de la relación entre conceptos')}
+ - 🎨 {semantic_t.get('semantic_color_meaning', 'Los colores más intensos indican conceptos más centrales en el texto')}
+ - ⭕ {semantic_t.get('semantic_size_meaning', 'El tamaño de los nodos representa la frecuencia del concepto')}
+ - ↔️ {semantic_t.get('semantic_thickness_meaning', 'El grosor de las líneas indica la fuerza de la conexión')}
+ """)
+
+ # Contenedor para botones (se mantiene igual pero centrado)
+ st.markdown("""
+
+ {concept}'
+ f'({freq:.2f})
'
+ for concept, freq in df.values
+ ]) +
+ "
+ """, unsafe_allow_html=True)
+
+ st.download_button(
+ label="📥 " + semantic_t.get('download_semantic_network_graph', "Descargar gráfico de red semántica"),
+ data=analysis['concept_graph'],
+ file_name="semantic_graph.png",
+ mime="image/png",
+ use_container_width=True
+ )
+
+ st.markdown("
", unsafe_allow_html=True)
+
+ 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'))
diff --git a/src/modules/semantic/semantic_interfaceBackUp_2092024_1800.py b/src/modules/semantic/semantic_interfaceBackUp_2092024_1800.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9ef8533a44841e7fdcc66abd8b4c7a25b9e2914
--- /dev/null
+++ b/src/modules/semantic/semantic_interfaceBackUp_2092024_1800.py
@@ -0,0 +1,146 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2, tab3, tab4, tab5 = st.tabs(["Upload", "Analyze", "Results", "Chat", "Export"])
+
+ with tab1:
+ tab21, tab22 = st.tabs(["File Management", "File Analysis"])
+
+ with tab21:
+ st.subheader("Upload and Manage Files")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.write("No files uploaded yet.")
+
+ with tab22:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ with tab2:
+ st.subheader("Analysis Results")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ col1, col2 = st.columns(2)
+ with col1:
+ if 'concept_graph' in st.session_state:
+ st.subheader("Concept Graph")
+ st.pyplot(st.session_state.concept_graph)
+ with col2:
+ if 'entity_graph' in st.session_state:
+ st.subheader("Entity Graph")
+ st.pyplot(st.session_state.entity_graph)
+
+ with tab3:
+ st.subheader("Chat with AI")
+ chat_container = st.container()
+
+ with chat_container:
+ chat_history = st.session_state.get('semantic_chat_history', [])
+ for message in chat_history:
+ with st.chat_message(message["role"]):
+ st.write(message["content"])
+
+ user_input = st.chat_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+
+ if user_input:
+ chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code)
+
+ chat_history.append({"role": "assistant", "content": response})
+ st.session_state.semantic_chat_history = chat_history
+
+ if st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat')):
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with tab4:
+ st.subheader("Export Results")
+ # Add export functionality here
+
+ with tab5:
+ st.subheader("Help")
+ # Add help information here
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interfaceBorrados.py b/src/modules/semantic/semantic_interfaceBorrados.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b2167adff34762e28fbd9ee65c64dd371ef713c
--- /dev/null
+++ b/src/modules/semantic/semantic_interfaceBorrados.py
@@ -0,0 +1,196 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ with st.container():
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader("Chat with AI")
+
+ chat_container = st.container()
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
diff --git a/src/modules/semantic/semantic_interfaceKoKo.py b/src/modules/semantic/semantic_interfaceKoKo.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a704b30129e521564b9222face9ec5c818bafea
--- /dev/null
+++ b/src/modules/semantic/semantic_interfaceKoKo.py
@@ -0,0 +1,239 @@
+import streamlit as st
+from streamlit_float import *
+import logging
+import sys
+import io
+from io import BytesIO
+from datetime import datetime
+import re
+import base64
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+import pandas as pd
+import numpy as np
+
+from .flexible_analysis_handler import FlexibleAnalysisHandler
+
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+from .semantic_process import process_semantic_analysis
+
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import manage_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+
+semantic_float_init()
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+
+##
+def fig_to_base64(fig):
+ buf = io.BytesIO()
+ fig.savefig(buf, format='png')
+ buf.seek(0)
+ img_str = base64.b64encode(buf.getvalue()).decode()
+ return f'
'
+##
+
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ #st.set_page_config(layout="wide")
+
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ if 'show_graph' not in st.session_state:
+ st.session_state.show_graph = False
+
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = None
+
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ if 'show_graph' not in st.session_state:
+ st.session_state.show_graph = False
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ col1, col2 = st.columns([2, 1])
+
+ with col1:
+ st.subheader("Chat with AI")
+
+ chat_container = st.container()
+ with chat_container:
+ st.markdown('', unsafe_allow_html=True)
+
+ st.markdown('', unsafe_allow_html=True)
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+ st.markdown('
', unsafe_allow_html=True)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col2:
+ st.subheader("Document Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("Select a file to analyze", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = manage_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ logger.debug("Calling process_semantic_analysis")
+ analysis_result = process_semantic_analysis(file_contents, nlp_model, lang_code)
+
+ # Crear una instancia de FlexibleAnalysisHandler con los resultados del análisis
+ handler = FlexibleAnalysisHandler(analysis_result)
+
+ logger.debug(f"Type of analysis_result: {type(analysis_result)}")
+ logger.debug(f"Keys in analysis_result: {analysis_result.keys() if isinstance(analysis_result, dict) else 'Not a dict'}")
+
+ st.session_state.concept_graph = handler.get_concept_graph()
+ st.session_state.entity_graph = handler.get_entity_graph()
+ st.session_state.key_concepts = handler.get_key_concepts()
+ st.session_state.show_graph = True
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("File Management")
+
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if manage_file_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+
+ st.subheader("Manage Uploaded Files")
+
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ #########################################################################################################################
+ # Floating graph visualization
+ if st.session_state.show_graph:
+ if st.session_state.graph_id is None:
+ st.session_state.graph_id = float_graph(
+ content="Loading graph...
",
+ width="40%",
+ height="60%",
+ position="bottom-right",
+ shadow=2,
+ transition=1
+ )
+
+ graph_id = st.session_state.graph_id
+
+ if 'key_concepts' in st.session_state:
+ key_concepts_html = "Key Concepts:
" + ', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]) + "
" + update_float_content(graph_id, key_concepts_html) + + tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"]) + + with tab_concept: + if 'concept_graph' in st.session_state: + update_float_content(graph_id, st.session_state.concept_graph) + else: + update_float_content(graph_id, "No concept graph available.") + + with tab_entity: + if 'entity_graph' in st.session_state: + update_float_content(graph_id, st.session_state.entity_graph) + else: + update_float_content(graph_id, "No entity graph available.") + + if st.button("Close Graph", key="close_graph"): + toggle_float_visibility(graph_id, False) + st.session_state.show_graph = False + st.session_state.graph_id = None + st.rerun() \ No newline at end of file diff --git a/src/modules/semantic/semantic_interfaceSideBar.py b/src/modules/semantic/semantic_interfaceSideBar.py new file mode 100644 index 0000000000000000000000000000000000000000..79f0777328d68330ea531f7104abbf8a4ab0fdfb --- /dev/null +++ b/src/modules/semantic/semantic_interfaceSideBar.py @@ -0,0 +1,207 @@ +import streamlit as st +from streamlit_float import * +import logging +from .semantic_process import process_semantic_analysis +from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input +from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files +from ..utils.widget_utils import generate_unique_key + +logger = logging.getLogger(__name__) + +def get_translation(t, key, default): + return t.get(key, default) + +def display_semantic_interface(lang_code, nlp_models, t): + # Inicializar el chatbot y el historial del chat al principio de la función + if 'semantic_chatbot' not in st.session_state: + st.session_state.semantic_chatbot = initialize_chatbot('semantic') + + if 'semantic_chat_history' not in st.session_state: + st.session_state.semantic_chat_history = [] + + st.markdown(""" + + """, unsafe_allow_html=True) + + # Sidebar for chat + with st.sidebar: + st.subheader("Chat with AI") + + messages = st.container(height=400) + + # Display chat messages + for message in st.session_state.semantic_chat_history: + with messages.chat_message(message["role"]): + st.markdown(message["content"]) + + # Chat input + if prompt := st.chat_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input')): + st.session_state.semantic_chat_history.append({"role": "user", "content": prompt}) + + with messages.chat_message("user"): + st.markdown(prompt) + + with messages.chat_message("assistant"): + message_placeholder = st.empty() + full_response = "" + + if prompt.startswith('/analyze_current'): + assistant_response = process_semantic_chat_input(prompt, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', '')) + else: + assistant_response = st.session_state.semantic_chatbot.generate_response(prompt, lang_code, context=st.session_state.get('file_contents', '')) + + # Simulate stream of response with milliseconds delay + for chunk in assistant_response.split(): + full_response += chunk + " " + message_placeholder.markdown(full_response + "▌") + message_placeholder.markdown(full_response) + + st.session_state.semantic_chat_history.append({"role": "assistant", "content": full_response}) + + if st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat')): + st.session_state.semantic_chat_history = [] + st.rerun() + + # Main content area + st.title("Semantic Analysis") + + # Mostrar el mensaje inicial como un párrafo estilizado + st.markdown(f""" + + """, unsafe_allow_html=True) + + tab1, tab2 = st.tabs(["Upload", "Analyze"]) + + with tab1: + st.subheader("File Management") + uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader')) + if uploaded_file is not None: + file_contents = uploaded_file.getvalue().decode('utf-8') + if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents): + st.success(f"File {uploaded_file.name} uploaded and saved successfully") + else: + st.error("Error uploading file") + + st.markdown("---") # Línea separadora + + st.subheader("Manage Uploaded Files") + user_files = get_user_files(st.session_state.username, 'semantic') + if user_files: + for file in user_files: + col1, col2 = st.columns([3, 1]) + with col1: + st.write(file['file_name']) + with col2: + if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"): + if delete_file(st.session_state.username, file['file_name'], 'semantic'): + st.success(f"File {file['file_name']} deleted successfully") + st.rerun() + else: + st.error(f"Error deleting file {file['file_name']}") + else: + st.info("No files uploaded yet.") + + with tab2: + st.subheader("Select File for Analysis") + user_files = get_user_files(st.session_state.username, 'semantic') + file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files] + selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector')) + + if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')): + if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'): + file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic') + if file_contents: + st.session_state.file_contents = file_contents + with st.spinner("Analyzing..."): + try: + nlp_model = nlp_models[lang_code] + concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code) + st.session_state.concept_graph = concept_graph + st.session_state.entity_graph = entity_graph + st.session_state.key_concepts = key_concepts + st.success("Analysis completed successfully") + except Exception as e: + logger.error(f"Error during analysis: {str(e)}") + st.error(f"Error during analysis: {str(e)}") + else: + st.error("Error loading file contents") + else: + st.error("Please select a file to analyze") + + # Visualization + st.subheader("Visualization") + if 'key_concepts' in st.session_state: + st.write("Key Concepts:") + st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts])) + + tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"]) + + with tab_concept: + if 'concept_graph' in st.session_state: + st.pyplot(st.session_state.concept_graph) + else: + st.info("No concept graph available. Please analyze a document first.") + + with tab_entity: + if 'entity_graph' in st.session_state: + st.pyplot(st.session_state.entity_graph) + else: + st.info("No entity graph available. Please analyze a document first.") \ No newline at end of file diff --git a/src/modules/semantic/semantic_interface_1.py b/src/modules/semantic/semantic_interface_1.py new file mode 100644 index 0000000000000000000000000000000000000000..29c22b3d1f16b0574cd5ad4b2cbd12d188b19784 --- /dev/null +++ b/src/modules/semantic/semantic_interface_1.py @@ -0,0 +1,55 @@ +import streamlit as st +from .semantic_process import process_semantic_analysis +from ..chatbot.chatbot import initialize_chatbot +from ..database.database_oldFromV2 import store_semantic_result +from ..text_analysis.semantic_analysis import perform_semantic_analysis +from ..utils.widget_utils import generate_unique_key + +def display_semantic_interface(lang_code, nlp_models, t): + st.subheader(t['title']) + + # Inicializar el chatbot si no existe + if 'semantic_chatbot' not in st.session_state: + st.session_state.semantic_chatbot = initialize_chatbot('semantic') + + # Sección para cargar archivo + uploaded_file = st.file_uploader(t['file_uploader'], type=['txt', 'pdf', 'docx', 'doc', 'odt']) + if uploaded_file: + file_contents = uploaded_file.getvalue().decode('utf-8') + st.session_state.file_contents = file_contents + + # Mostrar el historial del chat + chat_history = st.session_state.get('semantic_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['semantic_initial_message'], key=generate_unique_key('semantic', st.session_state.username)) + + if user_input: + # Procesar el input del usuario + response, visualization = process_semantic_analysis(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.semantic_chat_history = chat_history + + # Mostrar el resultado más reciente + with st.chat_message("assistant"): + st.write(response) + if visualization: + st.pyplot(visualization) + + # Guardar el resultado en la base de datos si es un análisis + if user_input.startswith('/analisis_semantico'): + result = perform_semantic_analysis(st.session_state.file_contents, nlp_models[lang_code], lang_code) + store_semantic_result(st.session_state.username, st.session_state.file_contents, result) + + # Botón para limpiar el historial del chat + if st.button(t['clear_chat'], key=generate_unique_key('semantic', 'clear_chat')): + st.session_state.semantic_chat_history = [] + st.rerun() \ No newline at end of file diff --git a/src/modules/semantic/semantic_interface_2.py b/src/modules/semantic/semantic_interface_2.py new file mode 100644 index 0000000000000000000000000000000000000000..9b24e101d56541b3f533183b78dceda8f961880c --- /dev/null +++ b/src/modules/semantic/semantic_interface_2.py @@ -0,0 +1,167 @@ +import streamlit as st +from .semantic_process import process_semantic_analysis +from ..chatbot.chatbot import initialize_chatbot +from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files +from ..utils.widget_utils import generate_unique_key + +def get_translation(t, key, default): + return t.get(key, default) + +def display_semantic_interface(lang_code, nlp_models, t): + #st.set_page_config(layout="wide") + + # Estilo CSS personalizado + st.markdown(""" + + """, unsafe_allow_html=True) + + # Mostrar el mensaje inicial como un párrafo estilizado + st.markdown(f""" + + """, unsafe_allow_html=True) + + # Inicializar el chatbot si no existe + if 'semantic_chatbot' not in st.session_state: + st.session_state.semantic_chatbot = initialize_chatbot('semantic') + + # Contenedor para la gestión de archivos + with st.container(): + st.markdown('', unsafe_allow_html=True)
+ col1, col2, col3, col4 = st.columns(4)
+
+ with col1:
+ if st.button(get_translation(t, 'upload_file', 'Upload File'), key=generate_unique_key('semantic', 'upload_button')):
+ uploaded_file = st.file_uploader(get_translation(t, 'file_uploader', 'Choose a file'), type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(get_translation(t, 'file_uploaded_success', 'File uploaded and saved to database successfully'))
+ st.session_state.file_contents = file_contents
+ st.rerun()
+ else:
+ st.error(get_translation(t, 'file_upload_error', 'Error uploading file'))
+
+ with col2:
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_file', 'Select a file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox(get_translation(t, 'file_list', 'File List'), options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+ if selected_file != get_translation(t, 'select_file', 'Select a file'):
+ if st.button(get_translation(t, 'load_file', 'Load File'), key=generate_unique_key('semantic', 'load_file')):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ st.success(get_translation(t, 'file_loaded_success', 'File loaded successfully'))
+ else:
+ st.error(get_translation(t, 'file_load_error', 'Error loading file'))
+
+ with col3:
+ if st.button(get_translation(t, 'analyze_document', 'Analyze Document'), key=generate_unique_key('semantic', 'analyze_document')):
+ if 'file_contents' in st.session_state:
+ with st.spinner(get_translation(t, 'analyzing', 'Analyzing...')):
+ graph, key_concepts = process_semantic_analysis(st.session_state.file_contents, nlp_models[lang_code], lang_code)
+ st.session_state.graph = graph
+ st.session_state.key_concepts = key_concepts
+ st.success(get_translation(t, 'analysis_completed', 'Analysis completed'))
+ else:
+ st.error(get_translation(t, 'no_file_uploaded', 'No file uploaded'))
+
+ with col4:
+ if st.button(get_translation(t, 'delete_file', 'Delete File'), key=generate_unique_key('semantic', 'delete_file')):
+ if selected_file and selected_file != get_translation(t, 'select_file', 'Select a file'):
+ if delete_file(st.session_state.username, selected_file, 'semantic'):
+ st.success(get_translation(t, 'file_deleted_success', 'File deleted successfully'))
+ if 'file_contents' in st.session_state:
+ del st.session_state.file_contents
+ st.rerun()
+ else:
+ st.error(get_translation(t, 'file_delete_error', 'Error deleting file'))
+ else:
+ st.error(get_translation(t, 'no_file_selected', 'No file selected'))
+
+ st.markdown('
', unsafe_allow_html=True)
+
+ # Crear dos columnas: una para el chat y otra para la visualización
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader(get_translation(t, 'chat_title', 'Semantic Analysis Chat'))
+ # Chat interface
+ chat_container = st.container()
+
+ with chat_container:
+ # Mostrar el historial del chat
+ chat_history = st.session_state.get('semantic_chat_history', [])
+ for message in chat_history:
+ with st.chat_message(message["role"]):
+ st.write(message["content"])
+
+ # Input del usuario
+ user_input = st.chat_input(get_translation(t, 'semantic_chat_input', 'Type your message here...'), key=generate_unique_key('semantic', 'chat_input'))
+
+ if user_input:
+ # Añadir el mensaje del usuario al historial
+ chat_history.append({"role": "user", "content": user_input})
+
+ # Generar respuesta del chatbot
+ chatbot = st.session_state.semantic_chatbot
+ response = chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents'))
+
+ # Añadir la respuesta del chatbot al historial
+ chat_history.append({"role": "assistant", "content": response})
+
+ # Actualizar el historial en session_state
+ st.session_state.semantic_chat_history = chat_history
+
+ # Forzar la actualización de la interfaz
+ st.rerun()
+
+ with col_graph:
+ st.subheader(get_translation(t, 'graph_title', 'Semantic Graph'))
+
+ # Mostrar conceptos clave en un expander horizontal
+ with st.expander(get_translation(t, 'key_concepts_title', 'Key Concepts'), expanded=True):
+ if 'key_concepts' in st.session_state:
+ st.markdown('', unsafe_allow_html=True)
+ for concept, freq in st.session_state.key_concepts:
+ st.markdown(f'{concept}: {freq:.2f}', unsafe_allow_html=True)
+ st.markdown('
', unsafe_allow_html=True)
+
+ if 'graph' in st.session_state:
+ st.pyplot(st.session_state.graph)
+
+ # Botón para limpiar el historial del chat
+ if st.button(get_translation(t, 'clear_chat', 'Clear chat'), key=generate_unique_key('semantic', 'clear_chat')):
+ st.session_state.semantic_chat_history = []
+ st.rerun()
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_2192024_1632.py b/src/modules/semantic/semantic_interface_2192024_1632.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd2aff2f6a40d46999fd4548dd5697dd09f16e80
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_2192024_1632.py
@@ -0,0 +1,244 @@
+import streamlit as st
+import logging
+import time
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization --1
+ with st.container():
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader("Chat with AI")
+
+ # Create a container for the chat messages
+ chat_container = st.container()
+
+ # Display chat messages from history on app rerun
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+'''
+ # Accept user input
+ if prompt := st.chat_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input')):
+ # Add user message to chat history
+ st.session_state.semantic_chat_history.append({"role": "user", "content": prompt})
+ # Display user message in chat message container
+ with st.chat_message("user"):
+ st.markdown(prompt)
+
+ # Generate and display assistant response
+ with st.chat_message("assistant"):
+ message_placeholder = st.empty()
+ full_response = ""
+
+ if prompt.startswith('/analyze_current'):
+ assistant_response = process_semantic_chat_input(prompt, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ assistant_response = st.session_state.semantic_chatbot.generate_response(prompt, lang_code, context=st.session_state.get('file_contents', ''))
+
+ # Simulate stream of response with milliseconds delay
+ for chunk in assistant_response.split():
+ full_response += chunk + " "
+ time.sleep(0.05)
+ # Add a blinking cursor to simulate typing
+ message_placeholder.markdown(full_response + "▌")
+ message_placeholder.markdown(full_response)
+
+ # Add assistant response to chat history
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": full_response})
+
+ # Add a clear chat button
+ if st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat')):
+ st.session_state.semantic_chat_history = [{"role": "assistant", "content": "Chat cleared. How can I assist you?"}]
+ st.rerun()
+
+'''
+
+'''
+ with col_graph:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
+'''
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_3.py b/src/modules/semantic/semantic_interface_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..b42b4101804f09c8cf78d9458a9c4ad20f2ece4d
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_3.py
@@ -0,0 +1,182 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ # Contenedor para la gestión de archivos
+ with st.container():
+ st.markdown('', unsafe_allow_html=True)
+ col1, col2, col3, col4 = st.columns(4)
+
+ with col1:
+ uploaded_file = st.file_uploader(get_translation(t, 'upload_file', 'Upload File'), type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.session_state.file_contents = file_contents
+ st.success(get_translation(t, 'file_uploaded_success', 'File uploaded and saved successfully'))
+ st.rerun()
+ else:
+ st.error(get_translation(t, 'file_upload_error', 'Error uploading file'))
+
+ with col2:
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ st.success(get_translation(t, 'file_loaded_success', 'File loaded successfully'))
+ else:
+ st.error(get_translation(t, 'file_load_error', 'Error loading file'))
+
+ with col3:
+ if st.button(get_translation(t, 'analyze_document', 'Analyze Document'), key=generate_unique_key('semantic', 'analyze_document')):
+ if 'file_contents' in st.session_state:
+ with st.spinner(get_translation(t, 'analyzing', 'Analyzing...')):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(st.session_state.file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success(get_translation(t, 'analysis_completed', 'Analysis completed'))
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error(get_translation(t, 'no_file_uploaded', 'No file uploaded'))
+
+ with col4:
+ if st.button(get_translation(t, 'delete_file', 'Delete File'), key=generate_unique_key('semantic', 'delete_file')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ if delete_file(st.session_state.username, selected_file, 'semantic'):
+ st.success(get_translation(t, 'file_deleted_success', 'File deleted successfully'))
+ if 'file_contents' in st.session_state:
+ del st.session_state.file_contents
+ st.rerun()
+ else:
+ st.error(get_translation(t, 'file_delete_error', 'Error deleting file'))
+ else:
+ st.error(get_translation(t, 'no_file_selected', 'No file selected'))
+
+ st.markdown('
', unsafe_allow_html=True)
+
+ # Contenedor para la sección de análisis
+ st.markdown('', unsafe_allow_html=True)
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader(get_translation(t, 'chat_title', 'Semantic Analysis Chat'))
+ chat_container = st.container()
+
+ with chat_container:
+ chat_history = st.session_state.get('semantic_chat_history', [])
+ for message in chat_history:
+ with st.chat_message(message["role"]):
+ st.write(message["content"])
+
+ user_input = st.chat_input(get_translation(t, 'semantic_chat_input', 'Type your message here...'), key=generate_unique_key('semantic', 'chat_input'))
+
+ if user_input:
+ chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code)
+
+ chat_history.append({"role": "assistant", "content": response})
+ st.session_state.semantic_chat_history = chat_history
+
+ with col_graph:
+ st.subheader(get_translation(t, 'graph_title', 'Semantic Graphs'))
+
+ # Mostrar conceptos clave y entidades horizontalmente
+ if 'key_concepts' in st.session_state:
+ st.write(get_translation(t, 'key_concepts_title', 'Key Concepts'))
+ st.markdown('
', unsafe_allow_html=True)
+
+ if st.button(get_translation(t, 'clear_chat', 'Clear chat'), key=generate_unique_key('semantic', 'clear_chat')):
+ st.session_state.semantic_chat_history = []
+ st.rerun()
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_4.py b/src/modules/semantic/semantic_interface_4.py
new file mode 100644
index 0000000000000000000000000000000000000000..fab61a80830dc404e0c3d7694f93803f900061b5
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_4.py
@@ -0,0 +1,188 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader("Chat with AI")
+ st.markdown('', unsafe_allow_html=True)
+ for concept, freq in st.session_state.key_concepts:
+ st.markdown(f'{concept}: {freq:.2f}', unsafe_allow_html=True)
+ st.markdown('
', unsafe_allow_html=True)
+
+ if 'entities' in st.session_state:
+ st.write(get_translation(t, 'entities_title', 'Entities'))
+ st.markdown('', unsafe_allow_html=True)
+ for entity, type in st.session_state.entities.items():
+ st.markdown(f'{entity}: {type}', unsafe_allow_html=True)
+ st.markdown('
', unsafe_allow_html=True)
+
+ # Usar pestañas para mostrar los gráficos
+ tab1, tab2 = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab1:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+
+ with tab2:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+
+ st.markdown('', unsafe_allow_html=True)
+ chat_history = st.session_state.get('semantic_chat_history', [])
+ for message in chat_history:
+ with st.chat_message(message["role"]):
+ st.write(message["content"])
+ st.markdown('
', unsafe_allow_html=True)
+
+ user_input = st.chat_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+
+ if user_input:
+ chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code)
+
+ chat_history.append({"role": "assistant", "content": response})
+ st.session_state.semantic_chat_history = chat_history
+
+ if st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat')):
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ st.markdown('', unsafe_allow_html=True)
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
+ st.markdown('
', unsafe_allow_html=True)
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_5.py b/src/modules/semantic/semantic_interface_5.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9c2c13e29ee1fe2b8048e233b65bcaaa02af6fc
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_5.py
@@ -0,0 +1,195 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Estilo CSS personalizado
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ with st.container():
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader("Chat with AI")
+
+ chat_container = st.container()
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_6.py b/src/modules/semantic/semantic_interface_6.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b9e483a32c03f1fc3dbf0a6aa2e65f71a284e35
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_6.py
@@ -0,0 +1,223 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+
+ # Crear el grafo flotante
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(
+ content="Loading graph...
",
+ width="40%",
+ height="60%",
+ position="bottom-right",
+ shadow=2,
+ transition=1
+ )
+
+ # Actualizar el contenido del grafo flotante
+ update_float_content(st.session_state.graph_id, f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """)
+
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ with st.container():
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ with st.expander("Chat with AI", expanded=True):
+ chat_container = st.container()
+
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state and st.session_state.concept_graph:
+ st.image(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state and st.session_state.entity_graph:
+ st.image(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
+
+ # Botón para cerrar el grafo flotante
+ if st.button("Close Graph", key="close_graph"):
+ if 'graph_id' in st.session_state:
+ toggle_float_visibility(st.session_state.graph_id, False)
+ del st.session_state.graph_id
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_61.py b/src/modules/semantic/semantic_interface_61.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2ac1e16628009ab14da1eb7cf94c967a22805ea
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_61.py
@@ -0,0 +1,198 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+ col_left, col_right = st.columns([1, 1])
+
+ with col_left:
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(
+ content="Loading graph...
",
+ width="40%",
+ height="60%",
+ position="bottom-right",
+ shadow=2,
+ transition=1
+ )
+
+ update_float_content(st.session_state.graph_id, f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """)
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+ chat_container = st.container()
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2, col3 = st.columns([2, 1, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+ with col3:
+ if 'graph_id' in st.session_state:
+ toggle_button = st.button("Toggle Graph", key="toggle_graph")
+ if toggle_button:
+ toggle_float_visibility(st.session_state.graph_id, not st.session_state.get('graph_visible', True))
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_right:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+ with tab_concept:
+ if 'concept_graph' in st.session_state and st.session_state.concept_graph:
+ st.image(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+ with tab_entity:
+ if 'entity_graph' in st.session_state and st.session_state.entity_graph:
+ st.image(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_610.py b/src/modules/semantic/semantic_interface_610.py
new file mode 100644
index 0000000000000000000000000000000000000000..7584017bdca599b7345e9728e5cdd887be94c885
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_610.py
@@ -0,0 +1,186 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import *
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ # Inicializar el estado del grafo si no existe
+ if 'graph_visible' not in st.session_state:
+ st.session_state.graph_visible = False
+ if 'graph_content' not in st.session_state:
+ st.session_state.graph_content = ""
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ # Crear o actualizar el elemento flotante con el grafo
+ graph_content = f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """
+ st.session_state.graph_id = float_graph(graph_content, width="30%", height="80%", position="center-right", shadow=2)
+ st.session_state.graph_visible = True
+
+ # Depuración: Mostrar los primeros 100 caracteres del grafo
+ st.write(f"Debug: Concept graph base64 (first 100 chars): {concept_graph[:100]}")
+ st.write(f"Debug: Graph ID: {st.session_state.graph_id}")
+
+ except Exception as e:
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+
+ # Mostrar el historial del chat
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+
+ # Colocar la entrada de usuario y los botones en la parte inferior
+ st.markdown('', unsafe_allow_html=True)
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2, col3 = st.columns([3, 1, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+ with col3:
+ if 'graph_id' in st.session_state:
+ toggle_button = st.button("Toggle Graph", key="toggle_graph")
+ if toggle_button:
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
+ toggle_float_visibility(st.session_state.graph_id, st.session_state.graph_visible)
+ st.markdown('
', unsafe_allow_html=True)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ # Asegurarse de que el grafo flotante permanezca visible después de las interacciones
+ if 'graph_id' in st.session_state and st.session_state.get('graph_visible', False):
+ toggle_float_visibility(st.session_state.graph_id, True)
+
+
+# Al final del archivo, después de todo el código:
+if 'graph_id' in st.session_state and st.session_state.get('graph_visible', False):
+ components.html(f"""
+
+ """, height=0)
+
+# Añadir un botón para alternar la visibilidad del grafo
+if st.button("Toggle Graph Visibility"):
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', False)
+ if st.session_state.graph_visible:
+ st.write("Graph should be visible now")
+ else:
+ st.write("Graph should be hidden now")
+ st.experimental_rerun()
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_62.py b/src/modules/semantic/semantic_interface_62.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cf56020a9772617f5f09a69450887c7e50614a8
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_62.py
@@ -0,0 +1,206 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+ col_left, col_right = st.columns([3, 2])
+
+ with col_left:
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ # Crear o actualizar el grafo flotante
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(
+ content="Loading graph...
",
+ width="40%",
+ height="60%",
+ position="bottom-right",
+ shadow=2,
+ transition=1
+ )
+ update_float_content(st.session_state.graph_id, f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """)
+ st.session_state.graph_visible = True
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+ chat_container = st.container()
+ with chat_container:
+ st.markdown('', unsafe_allow_html=True)
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+ st.markdown('
', unsafe_allow_html=True)
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat and Graph", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ if st.session_state.semantic_chat_history:
+ if st.button("Do you want to export the analysis before clearing?"):
+ # Aquí puedes implementar la lógica para exportar el análisis
+ st.success("Analysis exported successfully")
+ st.session_state.semantic_chat_history = []
+ if 'graph_id' in st.session_state:
+ toggle_float_visibility(st.session_state.graph_id, False)
+ del st.session_state.graph_id
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ st.rerun()
+
+ with col_right:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state and st.session_state.key_concepts:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+ with tab_concept:
+ if 'concept_graph' in st.session_state and st.session_state.concept_graph:
+ st.image(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+ with tab_entity:
+ if 'entity_graph' in st.session_state and st.session_state.entity_graph:
+ st.image(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_63.py b/src/modules/semantic/semantic_interface_63.py
new file mode 100644
index 0000000000000000000000000000000000000000..c32cf8d098b8ffb30163db19deef434fb2653d50
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_63.py
@@ -0,0 +1,215 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ # Barra de progreso
+ progress_bar = st.progress(0)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+ col_left, col_right = st.columns([2, 3]) # Invertimos las proporciones
+
+ with col_left:
+ st.subheader("File Selection and Chat")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ progress_bar.progress(10)
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ progress_bar.progress(30)
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ progress_bar.progress(70)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ progress_bar.progress(100)
+ st.success("Analysis completed successfully")
+
+ # Crear o actualizar el grafo flotante
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(
+ content="Loading graph...
",
+ width="40%",
+ height="60%",
+ position="bottom-right",
+ shadow=2,
+ transition=1
+ )
+ update_float_content(st.session_state.graph_id, f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """)
+ st.session_state.graph_visible = True
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ finally:
+ progress_bar.empty()
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+ chat_container = st.container()
+ with chat_container:
+ st.markdown('', unsafe_allow_html=True)
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+ st.markdown('
', unsafe_allow_html=True)
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat and Graph", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ if st.session_state.semantic_chat_history:
+ if st.button("Do you want to export the analysis before clearing?"):
+ # Aquí puedes implementar la lógica para exportar el análisis
+ st.success("Analysis exported successfully")
+ st.session_state.semantic_chat_history = []
+ if 'graph_id' in st.session_state:
+ toggle_float_visibility(st.session_state.graph_id, False)
+ del st.session_state.graph_id
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ st.rerun()
+
+ with col_right:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state and st.session_state.key_concepts:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+ with tab_concept:
+ if 'concept_graph' in st.session_state and st.session_state.concept_graph:
+ st.image(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+ with tab_entity:
+ if 'entity_graph' in st.session_state and st.session_state.entity_graph:
+ st.image(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_64.py b/src/modules/semantic/semantic_interface_64.py
new file mode 100644
index 0000000000000000000000000000000000000000..731678c700b81bdb8043dfa75ef875544ef44860
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_64.py
@@ -0,0 +1,170 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ # Actualizar el grafo flotante
+ graph_content = f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(graph_content, width="40%", height="60%", position="top-right")
+ else:
+ update_float_content(st.session_state.graph_id, graph_content)
+ toggle_float_visibility(st.session_state.graph_id, True)
+ st.session_state.graph_visible = True
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+ chat_container = st.container()
+ with chat_container:
+ st.markdown('', unsafe_allow_html=True)
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+ st.markdown('
', unsafe_allow_html=True)
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ # Botón para alternar la visibilidad del grafo flotante
+ if 'graph_id' in st.session_state:
+ if st.button("Toggle Graph Visibility"):
+ toggle_float_visibility(st.session_state.graph_id, not st.session_state.get('graph_visible', True))
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_65.py b/src/modules/semantic/semantic_interface_65.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ea2f629e954c34ed7407e1d06241dc5040f1879
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_65.py
@@ -0,0 +1,176 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ # Actualizar el grafo flotante
+ graph_content = f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(graph_content, width="40%", height="auto", position="center-right")
+ else:
+ update_float_content(st.session_state.graph_id, graph_content)
+ toggle_float_visibility(st.session_state.graph_id, True)
+ st.session_state.graph_visible = True
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+ chat_container = st.container()
+ with chat_container:
+ st.markdown('', unsafe_allow_html=True)
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+ st.markdown('
', unsafe_allow_html=True)
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2, col3 = st.columns([3, 1, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+ with col3:
+ if 'graph_id' in st.session_state:
+ toggle_button = st.button("Toggle Graph", key="toggle_graph")
+ if toggle_button:
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
+ toggle_float_visibility(st.session_state.graph_id, st.session_state.graph_visible)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ # Asegurarse de que el grafo flotante permanezca visible después de las interacciones
+ if 'graph_id' in st.session_state and st.session_state.get('graph_visible', False):
+ toggle_float_visibility(st.session_state.graph_id, True)
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_66.py b/src/modules/semantic/semantic_interface_66.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfa57fb062f09215e606e80cdbe9dfdacfcda759
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_66.py
@@ -0,0 +1,186 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ # Inicializar el estado del grafo si no existe
+ if 'graph_visible' not in st.session_state:
+ st.session_state.graph_visible = False
+ if 'graph_content' not in st.session_state:
+ st.session_state.graph_content = ""
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ # Actualizar el contenido del grafo
+ st.session_state.graph_content = f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(st.session_state.graph_content, width="40%", height="auto", position="center-right")
+ else:
+ update_float_content(st.session_state.graph_id, st.session_state.graph_content)
+ toggle_float_visibility(st.session_state.graph_id, True)
+ st.session_state.graph_visible = True
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+ chat_container = st.container()
+ with chat_container:
+ st.markdown('', unsafe_allow_html=True)
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+ st.markdown('
', unsafe_allow_html=True)
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2, col3 = st.columns([3, 1, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+ with col3:
+ if 'graph_id' in st.session_state:
+ toggle_button = st.button("Toggle Graph", key="toggle_graph")
+ if toggle_button:
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
+ toggle_float_visibility(st.session_state.graph_id, st.session_state.graph_visible)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ # Asegurarse de que el grafo flotante permanezca visible después de las interacciones
+ if 'graph_id' in st.session_state and st.session_state.get('graph_visible', False):
+ toggle_float_visibility(st.session_state.graph_id, True)
+
+ # Mostrar el grafo flotante si está visible
+ if st.session_state.get('graph_visible', False) and 'graph_content' in st.session_state:
+ st.markdown(
+ f"""
+
+ {st.session_state.graph_content}
+
+ """,
+ unsafe_allow_html=True
+ )
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_67.py b/src/modules/semantic/semantic_interface_67.py
new file mode 100644
index 0000000000000000000000000000000000000000..952286e515d0b2aaded7d0e4ae21e5d4f6de8115
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_67.py
@@ -0,0 +1,189 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ # Inicializar el estado del grafo si no existe
+ if 'graph_visible' not in st.session_state:
+ st.session_state.graph_visible = False
+ if 'graph_content' not in st.session_state:
+ st.session_state.graph_content = ""
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ # Actualizar el contenido del grafo
+ st.session_state.graph_content = f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(st.session_state.graph_content, width="540px", height="540px", position="center-right")
+ else:
+ update_float_content(st.session_state.graph_id, st.session_state.graph_content)
+ toggle_float_visibility(st.session_state.graph_id, True)
+ st.session_state.graph_visible = True
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2, col3 = st.columns([3, 1, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+ with col3:
+ if 'graph_id' in st.session_state:
+ toggle_button = st.button("Toggle Graph", key="toggle_graph")
+ if toggle_button:
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
+ toggle_float_visibility(st.session_state.graph_id, st.session_state.graph_visible)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ # Mostrar el historial del chat
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+
+ # Asegurarse de que el grafo flotante permanezca visible después de las interacciones
+ if 'graph_id' in st.session_state and st.session_state.get('graph_visible', False):
+ toggle_float_visibility(st.session_state.graph_id, True)
+
+ # Mostrar el grafo flotante si está visible
+ if st.session_state.get('graph_visible', False) and 'graph_content' in st.session_state:
+ st.markdown(
+ f"""
+
+ {st.session_state.graph_content}
+
+ """,
+ unsafe_allow_html=True
+ )
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_68.py b/src/modules/semantic/semantic_interface_68.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d76233b4405d8e141d906c75f98c4cba2cb822e
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_68.py
@@ -0,0 +1,195 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ # Inicializar el estado del grafo si no existe
+ if 'graph_visible' not in st.session_state:
+ st.session_state.graph_visible = False
+ if 'graph_content' not in st.session_state:
+ st.session_state.graph_content = ""
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph_base64, entity_graph_base64, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ # Aquí cambiamos el contenido del elemento flotante para mostrar un video de YouTube
+ youtube_video_id = "dQw4w9WgXcQ" # Cambia esto por el ID del video que quieras mostrar
+ video_content = f"""
+
+ """
+ st.session_state.graph_id = float_graph(video_content, width="800px", height="600px", position="center-right")
+ st.session_state.graph_visible = True
+ st.session_state.graph_content = video_content
+
+ # Log para depuración
+ st.write(f"Debug: Graph ID: {st.session_state.get('graph_id')}")
+ st.write(f"Debug: Graph visible: {st.session_state.get('graph_visible')}")
+
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+
+ # Mostrar el historial del chat
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+
+ # Colocar la entrada de usuario y los botones en la parte inferior
+ st.markdown('', unsafe_allow_html=True)
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2, col3 = st.columns([3, 1, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+ with col3:
+ if 'graph_id' in st.session_state:
+ toggle_button = st.button("Toggle Graph", key="toggle_graph")
+ if toggle_button:
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
+ toggle_float_visibility(st.session_state.graph_id, st.session_state.graph_visible)
+ st.markdown('
', unsafe_allow_html=True)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ # Asegurarse de que el grafo flotante permanezca visible después de las interacciones
+ if 'graph_id' in st.session_state and st.session_state.get('graph_visible', False):
+ toggle_float_visibility(st.session_state.graph_id, True)
+
+ # Mostrar el grafo flotante si está visible
+ if st.session_state.get('graph_visible', False) and 'graph_content' in st.session_state:
+ st.markdown(
+ f"""
+
+ {st.session_state.graph_content}
+
+ """,
+ unsafe_allow_html=True
+ )
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_681.py b/src/modules/semantic/semantic_interface_681.py
new file mode 100644
index 0000000000000000000000000000000000000000..9384c9f712a4145c14d5d43a1657e11e92cbeaea
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_681.py
@@ -0,0 +1,165 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ # Inicializar el estado del grafo si no existe
+ if 'graph_visible' not in st.session_state:
+ st.session_state.graph_visible = False
+
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ analyze_button = st.button("Analyze Document")
+ with col2:
+ toggle_graph = st.checkbox("Show Graph", value=st.session_state.graph_visible)
+
+ if analyze_button:
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ graph_content = f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """
+ float_graph(graph_content)
+ st.session_state.graph_visible = True
+ toggle_float_visibility(True)
+
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ if toggle_graph != st.session_state.graph_visible:
+ st.session_state.graph_visible = toggle_graph
+ toggle_float_visibility(toggle_graph)
+
+ st.subheader("Chat with AI")
+
+ # Mostrar el historial del chat
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+
+ # Colocar la entrada de usuario y los botones en la parte inferior
+ st.markdown('', unsafe_allow_html=True)
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+ st.markdown('
', unsafe_allow_html=True)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ # Asegurarse de que el grafo flotante permanezca visible si está activado
+ if st.session_state.graph_visible:
+ toggle_float_visibility(True)
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_681_23-9-24.py b/src/modules/semantic/semantic_interface_681_23-9-24.py
new file mode 100644
index 0000000000000000000000000000000000000000..69477b49cf6dd9be21b06e330813aa2fe274e3ec
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_681_23-9-24.py
@@ -0,0 +1,222 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import *
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ # Inicializar el estado del grafo si no existe
+ if 'graph_visible' not in st.session_state:
+ st.session_state.graph_visible = False
+ if 'graph_content' not in st.session_state:
+ st.session_state.graph_content = ""
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ graph_content = f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """
+
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(graph_content, width="800px", height="600px", position="center-right")
+ st.write(f"New graph created with ID: {st.session_state.graph_id}")
+ else:
+ update_float_content(st.session_state.graph_id, graph_content)
+ st.write(f"Existing graph updated with ID: {st.session_state.graph_id}")
+
+ toggle_float_visibility(st.session_state.graph_id, True)
+ st.session_state.graph_visible = True
+
+ # Depuración
+ st.write(f"Debug: Graph ID: {st.session_state.graph_id}")
+ st.write(f"Debug: Graph visible: {st.session_state.graph_visible}")
+ st.write(f"Debug: Concept graph base64 (first 100 chars): {concept_graph[:100]}")
+
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+
+ st.subheader("Chat with AI")
+
+ # Mostrar el historial del chat
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+
+ # Colocar la entrada de usuario y los botones en la parte inferior
+
+ st.markdown('', unsafe_allow_html=True)
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+
+ col1, col2, col3 = st.columns([3, 1, 1])
+
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ with col3:
+ if 'graph_id' in st.session_state:
+ toggle_button = st.button("Toggle Graph", key="toggle_graph")
+ if toggle_button:
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
+ toggle_float_visibility(st.session_state.graph_id, st.session_state.graph_visible)
+
+ st.markdown('
', unsafe_allow_html=True)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ # Añadir botones para controlar el elemento flotante
+ col1, col2 = st.columns(2)
+ with col1:
+ if st.button("Show Graph"):
+ if 'graph_id' in st.session_state:
+ toggle_float_visibility(st.session_state.graph_id, True)
+ st.session_state.graph_visible = True
+ st.write(f"Showing graph with ID: {st.session_state.graph_id}")
+ else:
+ st.write("No graph available to show")
+
+ with col2:
+ if st.button("Hide Graph"):
+ if 'graph_id' in st.session_state:
+ toggle_float_visibility(st.session_state.graph_id, False)
+ st.session_state.graph_visible = False
+ st.write(f"Hiding graph with ID: {st.session_state.graph_id}")
+ else:
+ st.write("No graph available to hide")
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_68ok copy.py b/src/modules/semantic/semantic_interface_68ok copy.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc16cf6f6c19e45753d432af4e13c32f5880841a
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_68ok copy.py
@@ -0,0 +1,215 @@
+import streamlit as st
+import streamlit_float
+import streamlit_option_menu
+import streamlit_antd_components
+import streamlit.components.v1 as components
+import streamlit.components.v1 as stc
+import logging
+from .semantic_process import *
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float68ok import *
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ # Inicializar el estado del grafo si no existe
+ if 'graph_visible' not in st.session_state:
+ st.session_state.graph_visible = False
+ if 'graph_content' not in st.session_state:
+ st.session_state.graph_content = ""
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph_base64, entity_graph_base64, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ if concept_graph_base64:
+ graph_content = f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """
+ st.session_state.graph_id = float_graph(graph_content, width="800px", height="600px", position="center-right")
+ st.session_state.graph_visible = True
+ st.session_state.graph_content = graph_content
+
+ if entity_graph_base64:
+ entity_graph_content = f"""
+ Entity Graph:
+
+ """
+ st.session_state.entity_graph_id = float_graph(entity_graph_content, width="800px", height="600px", position="bottom-left")
+
+ # Log para depuración
+ st.write(f"Debug: Graph ID: {st.session_state.get('graph_id')}")
+ st.write(f"Debug: Graph visible: {st.session_state.get('graph_visible')}")
+ st.write(f"Debug: Concept graph base64 (first 100 chars): {concept_graph_base64[:100]}")
+
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+
+ # Mostrar el historial del chat
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+
+ # Colocar la entrada de usuario y los botones en la parte inferior
+ st.markdown('', unsafe_allow_html=True)
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+
+ col1, col2, col3 = st.columns([3, 1, 1])
+
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ with col3:
+ if 'graph_id' in st.session_state:
+ toggle_button = st.button("Toggle Graph", key="toggle_graph")
+ if toggle_button:
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
+ toggle_float_visibility(st.session_state.graph_id, st.session_state.graph_visible)
+ st.markdown('
', unsafe_allow_html=True)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+# Asegurarse de que el grafo flotante permanezca visible después de las interacciones
+if 'graph_id' in st.session_state and st.session_state.get('graph_visible', False):
+ toggle_float_visibility(st.session_state.graph_id, True)
+
+# Mostrar el grafo flotante si está visible
+if st.session_state.get('graph_visible', False) and 'graph_content' in st.session_state:
+ components.html(
+ f"""
+
+ {st.session_state.graph_content}
+
+ """,
+ height=600,
+ scrolling=True
+ )
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_68ok.py b/src/modules/semantic/semantic_interface_68ok.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a34d56f794a81dca38b251a21fba4ca16b5a6ad
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_68ok.py
@@ -0,0 +1,98 @@
+import streamlit as st
+import logging
+from ..database.database_oldFromV2 import manage_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ st.subheader(t['semantic_title'])
+
+ text_input = st.text_area(
+ t['warning_message'],
+ height=150,
+ key=generate_unique_key("semantic", "text_area")
+ )
+
+ if st.button(
+ t['results_title'],
+ key=generate_unique_key("semantic", "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_semantic_interface(lang_code, nlp_models, t):
+ st.title("Semantic Analysis")
+
+ tab1, tab2 = st.tabs(["File Management", "Analysis"])
+
+ with tab1:
+ display_file_management(lang_code, t)
+
+ with tab2:
+ # Aquí irá el código para el análisis semántico (lo implementaremos después)
+ st.write("Semantic analysis section will be implemented here.")
+
+def display_file_management(lang_code, t):
+ st.header("File Management")
+
+ # File Upload Section
+ st.subheader("Upload New File")
+ uploaded_file = st.file_uploader(
+ "Choose a file to upload",
+ type=['txt', 'pdf', 'docx', 'doc', 'odt'],
+ key=generate_unique_key('semantic', 'file_uploader')
+ )
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if manage_file_contents(st.session_state.username, uploaded_file.name, file_contents, 'semantic'):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+
+
+ # File Management Section
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ try:
+ logger.info(f"Attempting to delete file: {file['file_name']} for user: {st.session_state.username}")
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ logger.info(f"File {file['file_name']} deleted successfully for user: {st.session_state.username}")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ logger.error(f"Failed to delete file {file['file_name']} for user: {st.session_state.username}")
+ except Exception as e:
+ st.error(f"An error occurred while deleting file {file['file_name']}: {str(e)}")
+ logger.exception(f"Exception occurred while deleting file {file['file_name']} for user: {st.session_state.username}")
+
+ else:
+ st.info("No files uploaded yet.")
+
+if __name__ == "__main__":
+ # This is just for testing purposes
+ class MockTranslation(dict):
+ def __getitem__(self, key):
+ return key
+
+ display_semantic_interface('en', {}, MockTranslation())
+
+ '''
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_68okBackUp.py b/src/modules/semantic/semantic_interface_68okBackUp.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8d8eaeafca312b1fa3d6ef2fc81bf2bf7a844ad
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_68okBackUp.py
@@ -0,0 +1,209 @@
+import streamlit as st
+import streamlit.components.v1 as components
+import streamlit.components.v1 as stc
+import logging
+from .semantic_process import *
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float68ok import *
+
+concept_graph_base64, entity_graph_base64, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ # Inicializar el estado del grafo si no existe
+ if 'graph_visible' not in st.session_state:
+ st.session_state.graph_visible = False
+ if 'graph_content' not in st.session_state:
+ st.session_state.graph_content = ""
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ # Actualizar el contenido del grafo
+ st.session_state.graph_content = f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(st.session_state.graph_content, width="540px", height="540px", position="center-right")
+ else:
+ update_float_content(st.session_state.graph_id, st.session_state.graph_content)
+ toggle_float_visibility(st.session_state.graph_id, True)
+ st.session_state.graph_visible = True
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+
+ # Mostrar el historial del chat
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+
+ # Colocar la entrada de usuario y los botones en la parte inferior
+ st.markdown('', unsafe_allow_html=True)
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+
+ col1, col2, col3 = st.columns([3, 1, 1])
+
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ with col3:
+ if 'graph_id' in st.session_state:
+ toggle_button = st.button("Toggle Graph", key="toggle_graph")
+ if toggle_button:
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
+ toggle_float_visibility(st.session_state.graph_id, st.session_state.graph_visible)
+ st.markdown('
', unsafe_allow_html=True)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ # Asegurarse de que el grafo flotante permanezca visible después de las interacciones
+ if 'graph_id' in st.session_state and st.session_state.get('graph_visible', False):
+ toggle_float_visibility(st.session_state.graph_id, True)
+
+ # Mostrar el grafo flotante si está visible
+ if st.session_state.get('graph_visible', False) and 'graph_content' in st.session_state:
+ st.markdown(
+ f"""
+
+ {st.session_state.graph_content}
+
+ """,
+ unsafe_allow_html=True
+ )
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_69.py b/src/modules/semantic/semantic_interface_69.py
new file mode 100644
index 0000000000000000000000000000000000000000..9491c4a0cd7e20c82eeb3bed69d2f3417e92e1d4
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_69.py
@@ -0,0 +1,167 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import *
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ # Inicializar el estado del grafo si no existe
+ if 'graph_visible' not in st.session_state:
+ st.session_state.graph_visible = False
+ if 'graph_content' not in st.session_state:
+ st.session_state.graph_content = ""
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ # Crear o actualizar el elemento flotante con el grafo
+ graph_content = f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(graph_content, width="540px", height="540px", position="center-right")
+ else:
+ update_float_content(st.session_state.graph_id, graph_content)
+
+ toggle_float_visibility(st.session_state.graph_id, True)
+ st.session_state.graph_visible = True
+
+ # Depuración: Mostrar el grafo directamente en la interfaz
+ #st.image(f"data:image/png;base64,{concept_graph}", caption="Concept Graph (Debug View)", use_column_width=True)
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+
+ # Mostrar el historial del chat
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+
+ # Colocar la entrada de usuario y los botones en la parte inferior
+ st.markdown('', unsafe_allow_html=True)
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2, col3 = st.columns([3, 1, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+ with col3:
+ if 'graph_id' in st.session_state:
+ toggle_button = st.button("Toggle Graph", key="toggle_graph")
+ if toggle_button:
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
+ toggle_float_visibility(st.session_state.graph_id, st.session_state.graph_visible)
+ st.markdown('
', unsafe_allow_html=True)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ # Asegurarse de que el grafo flotante permanezca visible después de las interacciones
+ if 'graph_id' in st.session_state and st.session_state.get('graph_visible', False):
+ toggle_float_visibility(st.session_state.graph_id, True)
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_6_Ok-23-9-24.py b/src/modules/semantic/semantic_interface_6_Ok-23-9-24.py
new file mode 100644
index 0000000000000000000000000000000000000000..c56fcc1da26f832d7e3e5037453ed17469943284
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_6_Ok-23-9-24.py
@@ -0,0 +1,223 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+
+ # Crear el grafo flotante
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(
+ content="Loading graph...
",
+ width="40%",
+ height="60%",
+ position="bottom-right",
+ shadow=2,
+ transition=1
+ )
+
+ # Actualizar el contenido del grafo flotante
+ update_float_content(st.session_state.graph_id, f"""
+ Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """)
+
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ with st.container():
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ with st.expander("Chat with AI", expanded=True):
+ chat_container = st.container()
+
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state and st.session_state.concept_graph:
+ st.image(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state and st.session_state.entity_graph:
+ st.image(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
+
+ # Botón para cerrar el grafo flotante
+ if st.button("Close Graph", key="close_graph"):
+ if 'graph_id' in st.session_state:
+ toggle_float_visibility(st.session_state.graph_id, False)
+ del st.session_state.graph_id
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_6_StarPoint.py b/src/modules/semantic/semantic_interface_6_StarPoint.py
new file mode 100644
index 0000000000000000000000000000000000000000..128c21dd4422f723c9b35a7484ab0b2af79f69d2
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_6_StarPoint.py
@@ -0,0 +1,196 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ with st.container():
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ with st.expander("Chat with AI", expanded=True):
+ chat_container = st.container()
+
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+
+ col1, col2 = st.columns([3, 1])
+
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_7.py b/src/modules/semantic/semantic_interface_7.py
new file mode 100644
index 0000000000000000000000000000000000000000..26893a836e36378aad6d6fbc4a259bb7a9126b22
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_7.py
@@ -0,0 +1,201 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ with st.container():
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader("Chat with AI")
+
+ chat_container = st.container()
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_BackUp_18-5-2025.py b/src/modules/semantic/semantic_interface_BackUp_18-5-2025.py
new file mode 100644
index 0000000000000000000000000000000000000000..720b92ae9dca3db9f560de190b2581ae0e24bfb4
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_BackUp_18-5-2025.py
@@ -0,0 +1,261 @@
+#modules/semantic/semantic_interface.py
+import streamlit as st
+from streamlit_float import *
+from streamlit_antd_components import *
+from streamlit.components.v1 import html
+import spacy_streamlit
+import io
+from io import BytesIO
+import base64
+import matplotlib.pyplot as plt
+import pandas as pd
+import re
+import logging
+
+# Configuración del logger
+logger = logging.getLogger(__name__)
+
+# Importaciones locales
+from .semantic_process import (
+ process_semantic_input,
+ format_semantic_results
+)
+
+from ..utils.widget_utils import generate_unique_key
+from ..database.semantic_mongo_db import store_student_semantic_result
+from ..database.chat_mongo_db import store_chat_history, get_chat_history
+
+# from ..database.semantic_export import export_user_interactions
+
+
+###############################
+
+# En semantic_interface.py
+def display_semantic_interface(lang_code, nlp_models, semantic_t):
+ try:
+ # 1. Inicializar el estado de la sesión
+ if 'semantic_state' not in st.session_state:
+ st.session_state.semantic_state = {
+ 'analysis_count': 0,
+ 'last_analysis': None,
+ 'current_file': None,
+ 'pending_analysis': False # Nuevo flag para controlar el análisis pendiente
+ }
+
+ # 2. Área de carga de archivo con mensaje informativo
+ st.info(semantic_t.get('initial_instruction',
+ 'Para comenzar un nuevo análisis semántico, cargue un archivo de texto (.txt)'))
+
+ uploaded_file = st.file_uploader(
+ semantic_t.get('semantic_file_uploader', 'Upload a text file for semantic analysis'),
+ type=['txt'],
+ key=f"semantic_file_uploader_{st.session_state.semantic_state['analysis_count']}"
+ )
+
+ # 2.1 Verificar si hay un archivo cargado y un análisis pendiente
+ if uploaded_file is not None and st.session_state.semantic_state.get('pending_analysis', False):
+ try:
+ with st.spinner(semantic_t.get('processing', 'Processing...')):
+ # Realizar análisis
+ text_content = uploaded_file.getvalue().decode('utf-8')
+
+ analysis_result = process_semantic_input(
+ text_content,
+ lang_code,
+ nlp_models,
+ semantic_t
+ )
+
+ if analysis_result['success']:
+ # Guardar resultado
+ st.session_state.semantic_result = analysis_result
+ st.session_state.semantic_state['analysis_count'] += 1
+ st.session_state.semantic_state['current_file'] = uploaded_file.name
+
+ # Guardar en base de datos
+ storage_success = store_student_semantic_result(
+ st.session_state.username,
+ text_content,
+ analysis_result['analysis']
+ )
+
+ if storage_success:
+ st.success(
+ semantic_t.get('analysis_complete',
+ 'Análisis completado y guardado. Para realizar un nuevo análisis, cargue otro archivo.')
+ )
+ else:
+ st.error(semantic_t.get('error_message', 'Error saving analysis'))
+ else:
+ st.error(analysis_result['message'])
+
+ # Restablecer el flag de análisis pendiente
+ st.session_state.semantic_state['pending_analysis'] = False
+
+ except Exception as e:
+ logger.error(f"Error en análisis semántico: {str(e)}")
+ st.error(semantic_t.get('error_processing', f'Error processing text: {str(e)}'))
+ # Restablecer el flag de análisis pendiente en caso de error
+ st.session_state.semantic_state['pending_analysis'] = False
+
+ # 3. Columnas para los botones y mensajes
+ col1, col2 = st.columns([1,4])
+
+ # 4. Botón de análisis
+ with col1:
+ analyze_button = st.button(
+ semantic_t.get('semantic_analyze_button', 'Analyze'),
+ key=f"semantic_analyze_button_{st.session_state.semantic_state['analysis_count']}",
+ type="primary",
+ icon="🔍",
+ disabled=uploaded_file is None,
+ use_container_width=True
+ )
+
+ # 5. Procesar análisis
+ if analyze_button and uploaded_file is not None:
+ # En lugar de realizar el análisis inmediatamente, establecer el flag
+ st.session_state.semantic_state['pending_analysis'] = True
+ # Forzar la recarga de la aplicación
+ st.rerun()
+
+ # 6. Mostrar resultados previos o mensaje inicial
+ elif 'semantic_result' in st.session_state and st.session_state.semantic_result is not None:
+ # Mostrar mensaje sobre el análisis actual
+ st.info(
+ semantic_t.get('current_analysis_message',
+ 'Mostrando análisis del archivo: {}. Para realizar un nuevo análisis, cargue otro archivo.'
+ ).format(st.session_state.semantic_state["current_file"])
+ )
+
+ display_semantic_results(
+ st.session_state.semantic_result,
+ lang_code,
+ semantic_t
+ )
+ else:
+ st.info(semantic_t.get('upload_prompt', 'Cargue un archivo para comenzar el análisis'))
+
+ except Exception as e:
+ logger.error(f"Error general en interfaz semántica: {str(e)}")
+ st.error(semantic_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
+
+
+#######################################
+
+def display_semantic_results(semantic_result, lang_code, semantic_t):
+ """
+ Muestra los resultados del análisis semántico de conceptos clave.
+ """
+ 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']
+
+ # Mostrar conceptos clave en formato horizontal (se mantiene igual)
+ st.subheader(semantic_t.get('key_concepts', 'Key Concepts'))
+ if 'key_concepts' in analysis and analysis['key_concepts']:
+ df = pd.DataFrame(
+ analysis['key_concepts'],
+ columns=[
+ semantic_t.get('concept', 'Concept'),
+ semantic_t.get('frequency', 'Frequency')
+ ]
+ )
+
+ st.write(
+ """
+
+
+ """ +
+ ''.join([
+ f'
",
+ unsafe_allow_html=True
+ )
+ else:
+ st.info(semantic_t.get('no_concepts', 'No key concepts found'))
+
+ # Gráfico de conceptos (versión modificada)
+ if 'concept_graph' in analysis and analysis['concept_graph'] is not None:
+ try:
+ # Sección del gráfico (sin div contenedor)
+ st.image(
+ analysis['concept_graph'],
+ use_container_width=True
+ )
+
+ # --- SOLO ESTE BLOQUE ES NUEVO ---
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+ # ---------------------------------
+
+ # Expandible con la interpretación (se mantiene igual)
+ with st.expander("📊 " + semantic_t.get('semantic_graph_interpretation', "Interpretación del gráfico semántico")):
+ st.markdown(f"""
+ - 🔀 {semantic_t.get('semantic_arrow_meaning', 'Las flechas indican la dirección de la relación entre conceptos')}
+ - 🎨 {semantic_t.get('semantic_color_meaning', 'Los colores más intensos indican conceptos más centrales en el texto')}
+ - ⭕ {semantic_t.get('semantic_size_meaning', 'El tamaño de los nodos representa la frecuencia del concepto')}
+ - ↔️ {semantic_t.get('semantic_thickness_meaning', 'El grosor de las líneas indica la fuerza de la conexión')}
+ """)
+
+ # Contenedor para botones (se mantiene igual pero centrado)
+ st.markdown("""
+
+ {concept}'
+ f'({freq:.2f})
'
+ for concept, freq in df.values
+ ]) +
+ "
+ """, unsafe_allow_html=True)
+
+ st.download_button(
+ label="📥 " + semantic_t.get('download_semantic_network_graph', "Descargar gráfico de red semántica"),
+ data=analysis['concept_graph'],
+ file_name="semantic_graph.png",
+ mime="image/png",
+ use_container_width=True
+ )
+
+ st.markdown("
", unsafe_allow_html=True)
+
+ 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'))
+
diff --git "a/src/modules/semantic/semantic_interface_Despu\303\251s.py" "b/src/modules/semantic/semantic_interface_Despu\303\251s.py"
new file mode 100644
index 0000000000000000000000000000000000000000..2d289197b51402d9a108eacfd06668a2394fbdfe
--- /dev/null
+++ "b/src/modules/semantic/semantic_interface_Despu\303\251s.py"
@@ -0,0 +1,116 @@
+import streamlit as st
+import logging
+from io import BytesIO
+import base64
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import (
+ initialize_mongodb_connection,
+ initialize_database_connections,
+ create_admin_user,
+ create_student_user,
+ get_user,
+ get_student_data,
+ store_file_contents,
+ retrieve_file_contents,
+ get_user_files,
+ delete_file,
+ store_application_request,
+ store_user_feedback,
+ store_morphosyntax_result,
+ store_semantic_result,
+ store_discourse_analysis_result,
+ store_chat_history,
+ export_analysis_and_chat,
+ get_user_analysis_summary,
+ get_user_recents_chats,
+ get_user_analysis_details
+ )
+
+from ..utils.widget_utils import generate_unique_key
+from .flexible_analysis_handler import FlexibleAnalysisHandler
+
+semantic_float_init()
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def fig_to_base64(fig):
+ buf = BytesIO()
+ fig.savefig(buf, format='png')
+ buf.seek(0)
+ img_str = base64.b64encode(buf.getvalue()).decode()
+ return f''
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ st.set_page_config(layout="wide")
+
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+ if 'show_graph' not in st.session_state:
+ st.session_state.show_graph = False
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = None
+
+ st.header(t['title'])
+
+ # Opción para introducir texto
+ text_input = st.text_area(
+ t['text_input_label'],
+ height=150,
+ placeholder=t['text_input_placeholder'],
+ )
+
+ # Opción para cargar archivo
+ uploaded_file = st.file_uploader(t['file_uploader'], type=['txt'])
+
+ if st.button(t['analyze_button']):
+ if text_input or uploaded_file is not None:
+ if uploaded_file:
+ text_content = uploaded_file.getvalue().decode('utf-8')
+ else:
+ text_content = text_input
+
+ # Realizar el análisis
+ analysis_result = process_semantic_analysis(text_content, nlp_models[lang_code], lang_code)
+
+ # Guardar el resultado en el estado de la sesión
+ st.session_state.semantic_result = analysis_result
+
+ # Mostrar resultados
+ display_semantic_results(st.session_state.semantic_result, lang_code, t)
+
+ # Guardar el resultado del análisis
+ if store_semantic_result(st.session_state.username, text_content, analysis_result):
+ st.success(t['success_message'])
+ else:
+ st.error(t['error_message'])
+ else:
+ st.warning(t['warning_message'])
+
+ elif 'semantic_result' in st.session_state:
+
+ # Si hay un resultado guardado, mostrarlo
+ display_semantic_results(st.session_state.semantic_result, lang_code, t)
+
+ else:
+ st.info(t['initial_message']) # Asegúrate de que 'initial_message' esté en tus traducciones
+
+def display_semantic_results(result, lang_code, t):
+ if result is None:
+ st.warning(t['no_results']) # Asegúrate de que 'no_results' esté en tus traducciones
+ return
+
+ # Mostrar conceptos clave
+ with st.expander(t['key_concepts'], expanded=True):
+ concept_text = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in result['key_concepts']])
+ st.write(concept_text)
+
+ # Mostrar el gráfico de relaciones conceptuales
+ with st.expander(t['conceptual_relations'], expanded=True):
+ st.pyplot(result['relations_graph'])
diff --git a/src/modules/semantic/semantic_interface_StreamLitChat.py b/src/modules/semantic/semantic_interface_StreamLitChat.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0eb527289912cd0295833c4e93cd2e91bd3b6d2
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_StreamLitChat.py
@@ -0,0 +1,157 @@
+import streamlit as st
+import logging
+from streamlit_chat import message
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'messages' not in st.session_state:
+ st.session_state.messages = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+
+ st.title("Semantic Analysis")
+
+ # Crear dos columnas principales: una para el chat y otra para la visualización
+ chat_col, viz_col = st.columns([1, 1])
+
+ with chat_col:
+ st.subheader("Chat with AI")
+
+ # Contenedor para los mensajes del chat
+ chat_container = st.container()
+
+ # Input para el chat
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+
+ if user_input:
+ # Añadir mensaje del usuario
+ st.session_state.messages.append({"role": "user", "content": user_input})
+
+ # Generar respuesta del asistente
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ # Añadir respuesta del asistente
+ st.session_state.messages.append({"role": "assistant", "content": response})
+
+ # Mostrar mensajes en el contenedor del chat
+ with chat_container:
+ for i, msg in enumerate(st.session_state.messages):
+ message(msg['content'], is_user=msg['role'] == 'user', key=f"{i}_{msg['role']}")
+
+ # Botón para limpiar el chat
+ if st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat')):
+ st.session_state.messages = []
+ st.rerun()
+
+ with viz_col:
+ st.subheader("Visualization")
+
+ # Selector de archivo y botón de análisis
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("Select a file to analyze", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Visualización de conceptos clave
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ # Pestañas para los gráficos
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
+
+ # Sección de carga de archivos
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+
+ # Gestión de archivos cargados
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_Test.py b/src/modules/semantic/semantic_interface_Test.py
new file mode 100644
index 0000000000000000000000000000000000000000..435d574d8c6ff1b985807249e9a02061e0bd4a54
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_Test.py
@@ -0,0 +1,22 @@
+import streamlit as st
+from streamlit_float import *
+
+# Limpiar el caché al inicio
+st.cache_data.clear()
+st.cache_resource.clear()
+
+
+# initialize float feature/capability
+float_init()
+
+col1, col2 = st.columns(2)
+
+# Fix/float the whole column
+col1.write("This entire column is fixed/floating")
+col1.float()
+
+with col2:
+ container = st.container()
+ # Fix/float a single container inside
+ container.write("This text is in a container that is fixed")
+ container.float()
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_afterParty.py b/src/modules/semantic/semantic_interface_afterParty.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d289197b51402d9a108eacfd06668a2394fbdfe
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_afterParty.py
@@ -0,0 +1,116 @@
+import streamlit as st
+import logging
+from io import BytesIO
+import base64
+from .semantic_float_reset import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import (
+ initialize_mongodb_connection,
+ initialize_database_connections,
+ create_admin_user,
+ create_student_user,
+ get_user,
+ get_student_data,
+ store_file_contents,
+ retrieve_file_contents,
+ get_user_files,
+ delete_file,
+ store_application_request,
+ store_user_feedback,
+ store_morphosyntax_result,
+ store_semantic_result,
+ store_discourse_analysis_result,
+ store_chat_history,
+ export_analysis_and_chat,
+ get_user_analysis_summary,
+ get_user_recents_chats,
+ get_user_analysis_details
+ )
+
+from ..utils.widget_utils import generate_unique_key
+from .flexible_analysis_handler import FlexibleAnalysisHandler
+
+semantic_float_init()
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def fig_to_base64(fig):
+ buf = BytesIO()
+ fig.savefig(buf, format='png')
+ buf.seek(0)
+ img_str = base64.b64encode(buf.getvalue()).decode()
+ return f''
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ st.set_page_config(layout="wide")
+
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+ if 'show_graph' not in st.session_state:
+ st.session_state.show_graph = False
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = None
+
+ st.header(t['title'])
+
+ # Opción para introducir texto
+ text_input = st.text_area(
+ t['text_input_label'],
+ height=150,
+ placeholder=t['text_input_placeholder'],
+ )
+
+ # Opción para cargar archivo
+ uploaded_file = st.file_uploader(t['file_uploader'], type=['txt'])
+
+ if st.button(t['analyze_button']):
+ if text_input or uploaded_file is not None:
+ if uploaded_file:
+ text_content = uploaded_file.getvalue().decode('utf-8')
+ else:
+ text_content = text_input
+
+ # Realizar el análisis
+ analysis_result = process_semantic_analysis(text_content, nlp_models[lang_code], lang_code)
+
+ # Guardar el resultado en el estado de la sesión
+ st.session_state.semantic_result = analysis_result
+
+ # Mostrar resultados
+ display_semantic_results(st.session_state.semantic_result, lang_code, t)
+
+ # Guardar el resultado del análisis
+ if store_semantic_result(st.session_state.username, text_content, analysis_result):
+ st.success(t['success_message'])
+ else:
+ st.error(t['error_message'])
+ else:
+ st.warning(t['warning_message'])
+
+ elif 'semantic_result' in st.session_state:
+
+ # Si hay un resultado guardado, mostrarlo
+ display_semantic_results(st.session_state.semantic_result, lang_code, t)
+
+ else:
+ st.info(t['initial_message']) # Asegúrate de que 'initial_message' esté en tus traducciones
+
+def display_semantic_results(result, lang_code, t):
+ if result is None:
+ st.warning(t['no_results']) # Asegúrate de que 'no_results' esté en tus traducciones
+ return
+
+ # Mostrar conceptos clave
+ with st.expander(t['key_concepts'], expanded=True):
+ concept_text = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in result['key_concepts']])
+ st.write(concept_text)
+
+ # Mostrar el gráfico de relaciones conceptuales
+ with st.expander(t['conceptual_relations'], expanded=True):
+ st.pyplot(result['relations_graph'])
diff --git a/src/modules/semantic/semantic_interface_backup2092024_1930 copy.py b/src/modules/semantic/semantic_interface_backup2092024_1930 copy.py
new file mode 100644
index 0000000000000000000000000000000000000000..fab61a80830dc404e0c3d7694f93803f900061b5
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_backup2092024_1930 copy.py
@@ -0,0 +1,188 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader("Chat with AI")
+ st.markdown('', unsafe_allow_html=True)
+ chat_history = st.session_state.get('semantic_chat_history', [])
+ for message in chat_history:
+ with st.chat_message(message["role"]):
+ st.write(message["content"])
+ st.markdown('
', unsafe_allow_html=True)
+
+ user_input = st.chat_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+
+ if user_input:
+ chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code)
+
+ chat_history.append({"role": "assistant", "content": response})
+ st.session_state.semantic_chat_history = chat_history
+
+ if st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat')):
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ st.markdown('', unsafe_allow_html=True)
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
+ st.markdown('
', unsafe_allow_html=True)
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_backup2092024_1930.py b/src/modules/semantic/semantic_interface_backup2092024_1930.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d97ce833c0da8a58ea642ca760ba50503b998a9
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_backup2092024_1930.py
@@ -0,0 +1,192 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+from .flexible_analysis_handler import FlexibleAnalysisHandler # Añade esta línea
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ analysis_result = process_semantic_analysis(file_contents, nlp_model, lang_code)
+
+ handler = FlexibleAnalysisHandler(analysis_result)
+
+ st.session_state.concept_graph = handler.get_concept_graph()
+ st.session_state.entity_graph = handler.get_entity_graph()
+ st.session_state.key_concepts = handler.get_key_concepts()
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader("Chat with AI")
+ st.markdown('', unsafe_allow_html=True)
+ chat_history = st.session_state.get('semantic_chat_history', [])
+ for message in chat_history:
+ with st.chat_message(message["role"]):
+ st.write(message["content"])
+ st.markdown('
', unsafe_allow_html=True)
+
+ user_input = st.chat_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+
+ if user_input:
+ chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code)
+
+ chat_history.append({"role": "assistant", "content": response})
+ st.session_state.semantic_chat_history = chat_history
+
+ if st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat')):
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ st.markdown('', unsafe_allow_html=True)
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
+ st.markdown('
', unsafe_allow_html=True)
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_backup_2092024.py b/src/modules/semantic/semantic_interface_backup_2092024.py
new file mode 100644
index 0000000000000000000000000000000000000000..549e15f8d5e26c1ecfbe0bff01c05f539da7a296
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_backup_2092024.py
@@ -0,0 +1,165 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ # File management container
+ st.markdown('', unsafe_allow_html=True)
+ col1, col2, col3, col4 = st.columns(4)
+
+ with col1:
+ if st.button("Upload File", key=generate_unique_key('semantic', 'upload_button')):
+ st.session_state.show_uploader = True
+
+ with col2:
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ with col3:
+ analyze_button = st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document'))
+
+ with col4:
+ delete_button = st.button("Delete File", key=generate_unique_key('semantic', 'delete_file'))
+
+ st.markdown('
', unsafe_allow_html=True)
+
+ # File uploader (hidden by default)
+ if st.session_state.get('show_uploader', False):
+ uploaded_file = st.file_uploader("Choose a file", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.session_state.file_contents = file_contents
+ st.success(get_translation(t, 'file_uploaded_success', 'File uploaded and saved successfully'))
+ st.session_state.show_uploader = False # Hide uploader after successful upload
+ else:
+ st.error(get_translation(t, 'file_upload_error', 'Error uploading file'))
+
+
+ # Contenedor para la sección de análisis
+ st.markdown('', unsafe_allow_html=True)
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader(get_translation(t, 'chat_title', 'Semantic Analysis Chat'))
+ chat_container = st.container()
+
+ with chat_container:
+ chat_history = st.session_state.get('semantic_chat_history', [])
+ for message in chat_history:
+ with st.chat_message(message["role"]):
+ st.write(message["content"])
+
+ user_input = st.chat_input(get_translation(t, 'semantic_chat_input', 'Type your message here...'), key=generate_unique_key('semantic', 'chat_input'))
+
+ if user_input:
+ chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code)
+
+ chat_history.append({"role": "assistant", "content": response})
+ st.session_state.semantic_chat_history = chat_history
+
+ with col_graph:
+ st.subheader(get_translation(t, 'graph_title', 'Semantic Graphs'))
+
+ # Mostrar conceptos clave y entidades horizontalmente
+ if 'key_concepts' in st.session_state:
+ st.write(get_translation(t, 'key_concepts_title', 'Key Concepts'))
+ st.markdown('
', unsafe_allow_html=True)
+
+ if st.button(get_translation(t, 'clear_chat', 'Clear chat'), key=generate_unique_key('semantic', 'clear_chat')):
+ st.session_state.semantic_chat_history = []
+ st.rerun()
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_backup_2192024_1230.py b/src/modules/semantic/semantic_interface_backup_2192024_1230.py
new file mode 100644
index 0000000000000000000000000000000000000000..241407616ae3ce590be4cb7268b82eef2325d8a8
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_backup_2192024_1230.py
@@ -0,0 +1,194 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ with st.container():
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ with st.expander("Chat with AI", expanded=True):
+ chat_container = st.container()
+
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_chatforup.py b/src/modules/semantic/semantic_interface_chatforup.py
new file mode 100644
index 0000000000000000000000000000000000000000..47c5d8789c4fa9de0c544bad98ecc137cfc2825c
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_chatforup.py
@@ -0,0 +1,196 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ with st.container():
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader("Chat with AI")
+
+ chat_container = st.container()
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_stcontainerforchat.py b/src/modules/semantic/semantic_interface_stcontainerforchat.py
new file mode 100644
index 0000000000000000000000000000000000000000..47c5d8789c4fa9de0c544bad98ecc137cfc2825c
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_stcontainerforchat.py
@@ -0,0 +1,196 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ with st.container():
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader("Chat with AI")
+
+ chat_container = st.container()
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_test610.py b/src/modules/semantic/semantic_interface_test610.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ae439ec0086c3baa0bc74374358a81e8f865135
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_test610.py
@@ -0,0 +1,212 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+#from .semantic_float import semantic_float_init, float_graph, toggle_float_visibility, update_float_content
+from .semantic_float_reset import *
+
+logger = logging.getLogger(__name__)
+semantic_float_init()
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicialización del chatbot y el historial del chat
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ # Inicializar el estado del grafo si no existe
+ if 'graph_visible' not in st.session_state:
+ st.session_state.graph_visible = False
+ if 'graph_content' not in st.session_state:
+ st.session_state.graph_content = ""
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown(f"", unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---")
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Semantic Analysis")
+
+ st.subheader("File Selection and Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document"):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.session_state.current_file_contents = file_contents
+ st.success("Analysis completed successfully")
+
+ # Depuración: Mostrar los primeros 100 caracteres del grafo
+ logger.debug(f"Concept graph base64 (first 100 chars): {concept_graph[:100]}")
+ st.write(f"Debug: Concept graph base64 (first 100 chars): {concept_graph[:100]}")
+
+ # Actualizar el contenido del grafo
+ st.session_state.graph_content = f"""
+ ', unsafe_allow_html=True)
+ for concept, freq in st.session_state.key_concepts:
+ st.markdown(f'{concept}: {freq:.2f}', unsafe_allow_html=True)
+ st.markdown('
', unsafe_allow_html=True)
+
+ if 'entities' in st.session_state:
+ st.write(get_translation(t, 'entities_title', 'Entities'))
+ st.markdown('', unsafe_allow_html=True)
+ for entity, type in st.session_state.entities.items():
+ st.markdown(f'{entity}: {type}', unsafe_allow_html=True)
+ st.markdown('
', unsafe_allow_html=True)
+
+ # Usar pestañas para mostrar los gráficos
+ tab1, tab2 = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab1:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+
+ with tab2:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+
+ st.markdown('Key Concepts:
+{', '.join([f"{concept}: {freq:.2f}" for concept, freq in key_concepts])}
+
+ """
+ if 'graph_id' not in st.session_state:
+ st.session_state.graph_id = float_graph(st.session_state.graph_content, width="540px", height="540px", position="center-right")
+ else:
+ update_float_content(st.session_state.graph_id, st.session_state.graph_content)
+ toggle_float_visibility(st.session_state.graph_id, True)
+ st.session_state.graph_visible = True
+
+ # Depuración: Verificar si el grafo se está creando
+ logger.debug(f"Graph ID: {st.session_state.graph_id}")
+ logger.debug(f"Graph visible: {st.session_state.graph_visible}")
+
+ # Mostrar el grafo directamente en la interfaz para verificación
+ st.image(f"data:image/png;base64,{concept_graph}", caption="Concept Graph (Debug View)", use_column_width=True)
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ st.session_state.concept_graph = None
+ st.session_state.entity_graph = None
+ st.session_state.key_concepts = []
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ st.subheader("Chat with AI")
+
+ # Mostrar el historial del chat
+ for message in st.session_state.semantic_chat_history:
+ message_class = "user-message" if message["role"] == "user" else "assistant-message"
+ st.markdown(f'', unsafe_allow_html=True)
+
+ # Colocar la entrada de usuario y los botones en la parte inferior
+ st.markdown('', unsafe_allow_html=True)
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2, col3 = st.columns([3, 1, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+ with col3:
+ if 'graph_id' in st.session_state:
+ toggle_button = st.button("Toggle Graph", key="toggle_graph")
+ if toggle_button:
+ st.session_state.graph_visible = not st.session_state.get('graph_visible', True)
+ toggle_float_visibility(st.session_state.graph_id, st.session_state.graph_visible)
+ st.markdown('
', unsafe_allow_html=True)
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('current_file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('current_file_contents', ''))
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ # Asegurarse de que el grafo flotante permanezca visible después de las interacciones
+ if 'graph_id' in st.session_state and st.session_state.get('graph_visible', False):
+ toggle_float_visibility(st.session_state.graph_id, True)
+
+ # Mostrar el grafo flotante si está visible
+ if st.session_state.get('graph_visible', False) and 'graph_content' in st.session_state:
+ st.markdown(
+ f"""
+
+ {st.session_state.graph_content}
+
+ """,
+ unsafe_allow_html=True
+ )
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_interface_vOk.py b/src/modules/semantic/semantic_interface_vOk.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b2167adff34762e28fbd9ee65c64dd371ef713c
--- /dev/null
+++ b/src/modules/semantic/semantic_interface_vOk.py
@@ -0,0 +1,196 @@
+import streamlit as st
+import logging
+from .semantic_process import process_semantic_analysis
+from ..chatbot.chatbot import initialize_chatbot, process_semantic_chat_input
+from ..database.database_oldFromV2 import store_file_semantic_contents, retrieve_file_contents, delete_file, get_user_files
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+def get_translation(t, key, default):
+ return t.get(key, default)
+
+def display_semantic_interface(lang_code, nlp_models, t):
+ # Inicializar el chatbot y el historial del chat al principio de la función
+ if 'semantic_chatbot' not in st.session_state:
+ st.session_state.semantic_chatbot = initialize_chatbot('semantic')
+
+ if 'semantic_chat_history' not in st.session_state:
+ st.session_state.semantic_chat_history = []
+
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Mostrar el mensaje inicial como un párrafo estilizado
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ tab1, tab2 = st.tabs(["Upload", "Analyze"])
+
+ with tab1:
+ st.subheader("File Management")
+ uploaded_file = st.file_uploader("Choose a file to upload", type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=generate_unique_key('semantic', 'file_uploader'))
+ if uploaded_file is not None:
+ file_contents = uploaded_file.getvalue().decode('utf-8')
+ if store_file_semantic_contents(st.session_state.username, uploaded_file.name, file_contents):
+ st.success(f"File {uploaded_file.name} uploaded and saved successfully")
+ else:
+ st.error("Error uploading file")
+
+ st.markdown("---") # Línea separadora
+
+ st.subheader("Manage Uploaded Files")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ if user_files:
+ for file in user_files:
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ st.write(file['file_name'])
+ with col2:
+ if st.button("Delete", key=f"delete_{file['file_name']}", help=f"Delete {file['file_name']}"):
+ if delete_file(st.session_state.username, file['file_name'], 'semantic'):
+ st.success(f"File {file['file_name']} deleted successfully")
+ st.rerun()
+ else:
+ st.error(f"Error deleting file {file['file_name']}")
+ else:
+ st.info("No files uploaded yet.")
+
+ with tab2:
+ st.subheader("Select File for Analysis")
+ user_files = get_user_files(st.session_state.username, 'semantic')
+ file_options = [get_translation(t, 'select_saved_file', 'Select a saved file')] + [file['file_name'] for file in user_files]
+ selected_file = st.selectbox("", options=file_options, key=generate_unique_key('semantic', 'file_selector'))
+
+ if st.button("Analyze Document", key=generate_unique_key('semantic', 'analyze_document')):
+ if selected_file and selected_file != get_translation(t, 'select_saved_file', 'Select a saved file'):
+ file_contents = retrieve_file_contents(st.session_state.username, selected_file, 'semantic')
+ if file_contents:
+ st.session_state.file_contents = file_contents
+ with st.spinner("Analyzing..."):
+ try:
+ nlp_model = nlp_models[lang_code]
+ concept_graph, entity_graph, key_concepts = process_semantic_analysis(file_contents, nlp_model, lang_code)
+ st.session_state.concept_graph = concept_graph
+ st.session_state.entity_graph = entity_graph
+ st.session_state.key_concepts = key_concepts
+ st.success("Analysis completed successfully")
+ except Exception as e:
+ logger.error(f"Error during analysis: {str(e)}")
+ st.error(f"Error during analysis: {str(e)}")
+ else:
+ st.error("Error loading file contents")
+ else:
+ st.error("Please select a file to analyze")
+
+ # Chat and Visualization
+ with st.container():
+ col_chat, col_graph = st.columns([1, 1])
+
+ with col_chat:
+ st.subheader("Chat with AI")
+
+ chat_container = st.container()
+ with chat_container:
+ for message in st.session_state.semantic_chat_history:
+ with st.chat_message(message["role"]):
+ st.markdown(message["content"])
+
+ user_input = st.text_input("Type your message here...", key=generate_unique_key('semantic', 'chat_input'))
+ col1, col2 = st.columns([3, 1])
+ with col1:
+ send_button = st.button("Send", key=generate_unique_key('semantic', 'send_message'))
+ with col2:
+ clear_button = st.button("Clear Chat", key=generate_unique_key('semantic', 'clear_chat'))
+
+ if send_button and user_input:
+ st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
+
+ if user_input.startswith('/analyze_current'):
+ response = process_semantic_chat_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents', ''))
+ else:
+ response = st.session_state.semantic_chatbot.generate_response(user_input, lang_code, context=st.session_state.get('file_contents', ''))
+
+ st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
+ st.rerun()
+
+ if clear_button:
+ st.session_state.semantic_chat_history = []
+ st.rerun()
+
+ with col_graph:
+ st.subheader("Visualization")
+ if 'key_concepts' in st.session_state:
+ st.write("Key Concepts:")
+ st.write(', '.join([f"{concept}: {freq:.2f}" for concept, freq in st.session_state.key_concepts]))
+
+ tab_concept, tab_entity = st.tabs(["Concept Graph", "Entity Graph"])
+
+ with tab_concept:
+ if 'concept_graph' in st.session_state:
+ st.pyplot(st.session_state.concept_graph)
+ else:
+ st.info("No concept graph available. Please analyze a document first.")
+
+ with tab_entity:
+ if 'entity_graph' in st.session_state:
+ st.pyplot(st.session_state.entity_graph)
+ else:
+ st.info("No entity graph available. Please analyze a document first.")
diff --git a/src/modules/semantic/semantic_live_interface.py b/src/modules/semantic/semantic_live_interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4251d304deda779ea88a7d1a8c784317b58db31
--- /dev/null
+++ b/src/modules/semantic/semantic_live_interface.py
@@ -0,0 +1,197 @@
+# modules/semantic/semantic_live_interface.py
+import streamlit as st
+from streamlit_float import *
+from streamlit_antd_components import *
+import pandas as pd
+import logging
+
+# Configuración del logger
+logger = logging.getLogger(__name__)
+
+# Importaciones locales
+from .semantic_process import (
+ process_semantic_input,
+ format_semantic_results
+)
+
+from ..utils.widget_utils import generate_unique_key
+from ..database.semantic_mongo_db import store_student_semantic_result
+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 con proporciones de columna ajustadas
+ """
+ try:
+ # 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,
+ 'current_text': '',
+ 'last_result': None,
+ 'text_changed': False
+ }
+
+ # 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 input_col:
+ st.subheader(semantic_t.get('enter_text', 'Ingrese su texto'))
+
+ # Á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=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 y procesamiento
+ analyze_button = st.button(
+ semantic_t.get('analyze_button', 'Analizar'),
+ key="semantic_live_analyze",
+ type="primary",
+ icon="🔍",
+ disabled=not text_input,
+ use_container_width=True
+ )
+
+ if analyze_button and text_input:
+ try:
+ with st.spinner(semantic_t.get('processing', 'Procesando...')):
+ analysis_result = process_semantic_input(
+ text_input,
+ lang_code,
+ nlp_models,
+ semantic_t
+ )
+
+ if analysis_result['success']:
+ 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
+
+ store_student_semantic_result(
+ st.session_state.username,
+ text_input,
+ analysis_result['analysis']
+ )
+ else:
+ st.error(analysis_result.get('message', 'Error en el análisis'))
+
+ except Exception as 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("""
+
+ """, unsafe_allow_html=True)
+
+ with st.container():
+ # Conceptos en una sola línea
+ concepts_html = """
+
+
"
+ 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."))
+
diff --git a/src/modules/semantic/semantic_process.py b/src/modules/semantic/semantic_process.py
new file mode 100644
index 0000000000000000000000000000000000000000..2af775603e809f255f4d0d5e66707c0b33ff6c48
--- /dev/null
+++ b/src/modules/semantic/semantic_process.py
@@ -0,0 +1,109 @@
+# modules/semantic/semantic_process.py
+import streamlit as st
+import matplotlib.pyplot as plt
+import io
+import base64
+import logging
+
+from ..text_analysis.semantic_analysis import (
+ perform_semantic_analysis,
+ identify_key_concepts,
+ create_concept_graph,
+ visualize_concept_graph
+)
+from ..database.semantic_mongo_db import store_student_semantic_result
+
+logger = logging.getLogger(__name__)
+
+def process_semantic_input(text, lang_code, nlp_models, t):
+ """
+ Procesa el texto ingresado para realizar el análisis semántico.
+ """
+ try:
+ logger.info(f"Iniciando análisis semántico para texto de {len(text)} caracteres")
+
+ # Realizar el análisis semántico
+ nlp = nlp_models[lang_code]
+ analysis_result = perform_semantic_analysis(text, nlp, lang_code)
+
+ if not analysis_result['success']:
+ return {
+ 'success': False,
+ 'message': analysis_result['error'],
+ 'analysis': None
+ }
+
+ logger.info("Análisis semántico completado. Guardando resultados...")
+
+ # Intentar guardar en la base de datos
+ try:
+ store_result = store_student_semantic_result(
+ st.session_state.username,
+ text,
+ analysis_result,
+ lang_code
+ )
+ if not store_result:
+ logger.warning("No se pudo guardar el análisis en la base de datos")
+ except Exception as db_error:
+ logger.error(f"Error al guardar en base de datos: {str(db_error)}")
+
+ # Devolver el resultado incluso si falla el guardado
+ return {
+ 'success': True,
+ 'message': t.get('success_message', 'Analysis completed successfully'),
+ 'analysis': {
+ 'key_concepts': analysis_result['key_concepts'],
+ 'concept_graph': analysis_result['concept_graph']
+ }
+ }
+
+ except Exception as e:
+ logger.error(f"Error en process_semantic_input: {str(e)}")
+ return {
+ 'success': False,
+ 'message': str(e),
+ 'analysis': None
+ }
+
+def format_semantic_results(analysis_result, t):
+ """
+ Formatea los resultados del análisis para su visualización.
+ """
+ try:
+ if not analysis_result['success']:
+ return {
+ 'formatted_text': analysis_result['message'],
+ 'visualizations': None
+ }
+
+ formatted_sections = []
+ analysis = analysis_result['analysis']
+
+ # Formatear conceptos clave
+ if 'key_concepts' in analysis:
+ concepts_section = [f"### {t.get('key_concepts', 'Key Concepts')}"]
+ concepts_section.extend([
+ f"- {concept}: {frequency:.2f}"
+ for concept, frequency in analysis['key_concepts']
+ ])
+ formatted_sections.append('\n'.join(concepts_section))
+
+ return {
+ 'formatted_text': '\n\n'.join(formatted_sections),
+ 'visualizations': {
+ 'concept_graph': analysis.get('concept_graph')
+ }
+ }
+
+ except Exception as e:
+ logger.error(f"Error en format_semantic_results: {str(e)}")
+ return {
+ 'formatted_text': str(e),
+ 'visualizations': None
+ }
+
+__all__ = [
+ 'process_semantic_input',
+ 'format_semantic_results'
+]
\ No newline at end of file
diff --git a/src/modules/semantic/semantic_process_23-9-24.py b/src/modules/semantic/semantic_process_23-9-24.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f3a7adb62c8f15ccd4616fd3e4b20beddf33be3
--- /dev/null
+++ b/src/modules/semantic/semantic_process_23-9-24.py
@@ -0,0 +1,62 @@
+import logging
+import io
+import base64
+import matplotlib.pyplot as plt
+from ..text_analysis.semantic_analysis import perform_semantic_analysis
+from .flexible_analysis_handler import FlexibleAnalysisHandler
+
+logger = logging.getLogger(__name__)
+
+def encode_image_to_base64(image_data):
+ if isinstance(image_data, str): # Si es una ruta de archivo
+ with open(image_data, "rb") as image_file:
+ encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
+ elif isinstance(image_data, bytes): # Si son datos de imagen en memoria
+ encoded_string = base64.b64encode(image_data).decode("utf-8")
+ else:
+ raise ValueError("Invalid image data type. Expected string (file path) or bytes.")
+ return encoded_string #
+
+def process_semantic_analysis(file_contents, nlp_model, lang_code):
+ logger.info(f"Starting semantic analysis processing for language: {lang_code}")
+ try:
+ result = perform_semantic_analysis(file_contents, nlp_model, lang_code)
+ #handler = FlexibleAnalysisHandler(result)
+
+ #concept_graph = handler.get_graph('concept_graph')
+ #entity_graph = handler.get_graph('entity_graph')
+ #key_concepts = handler.get_key_concepts()
+
+ concept_graph = result['concept_graph']
+ entity_graph = result['entity_graph']
+ key_concepts = result['key_concepts']
+
+ # Convertir los gráficos a base64
+ concept_graph_base64 = fig_to_base64(concept_graph) if concept_graph else None
+ entity_graph_base64 = fig_to_base64(entity_graph) if entity_graph else None
+
+ logger.info("Semantic analysis processing completed successfully")
+ return concept_graph_base64, entity_graph_base64, key_concepts
+ except Exception as e:
+ logger.error(f"Error in semantic analysis processing: {str(e)}")
+ return None, None, [] # Retorna valores vacíos en caso de error
+
+'''
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.DEBUG)
+
+def process_semantic_analysis(file_contents, nlp_model, lang_code):
+ logger.info(f"Starting semantic analysis for language: {lang_code}")
+ try:
+ logger.debug("Calling perform_semantic_analysis")
+ result = perform_semantic_analysis(file_contents, nlp_model, lang_code)
+ logger.debug(f"Result keys: {result.keys()}")
+ logger.debug(f"Type of concept_graph: {type(result['concept_graph'])}")
+ logger.debug(f"Type of entity_graph: {type(result['entity_graph'])}")
+ logger.debug(f"Number of key_concepts: {len(result['key_concepts'])}")
+ logger.info("Semantic analysis completed successfully")
+ return result['concept_graph'], result['entity_graph'], result['key_concepts']
+ except Exception as e:
+ logger.error(f"Error in semantic analysis: {str(e)}")
+ raise
+'''
\ No newline at end of file
diff --git a/src/modules/studentact/6-3-2025_current_situation_interface.py b/src/modules/studentact/6-3-2025_current_situation_interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0a081ebd3cbb0846071b7ff68bfb5ee5c1e075a
--- /dev/null
+++ b/src/modules/studentact/6-3-2025_current_situation_interface.py
@@ -0,0 +1,486 @@
+# modules/studentact/current_situation_interface-vOK.py
+
+import streamlit as st
+import logging
+from ..utils.widget_utils import generate_unique_key
+import matplotlib.pyplot as plt
+import numpy as np
+from ..database.current_situation_mongo_db import store_current_situation_result
+
+# Importaciones locales
+from translations import get_translations
+
+from .current_situation_analysis import (
+ analyze_text_dimensions,
+ analyze_clarity,
+ analyze_vocabulary_diversity,
+ analyze_cohesion,
+ analyze_structure,
+ get_dependency_depths,
+ normalize_score,
+ generate_sentence_graphs,
+ generate_word_connections,
+ generate_connection_paths,
+ create_vocabulary_network,
+ create_syntax_complexity_graph,
+ create_cohesion_heatmap,
+ generate_recommendations
+)
+
+# Configuración del estilo de matplotlib para el gráfico de radar
+plt.rcParams['font.family'] = 'sans-serif'
+plt.rcParams['axes.grid'] = True
+plt.rcParams['axes.spines.top'] = False
+plt.rcParams['axes.spines.right'] = False
+
+logger = logging.getLogger(__name__)
+####################################
+
+TEXT_TYPES = {
+ 'academic_article': {
+ 'name': 'Artículo Académico',
+ 'thresholds': {
+ 'vocabulary': {'min': 0.70, 'target': 0.85},
+ 'structure': {'min': 0.75, 'target': 0.90},
+ 'cohesion': {'min': 0.65, 'target': 0.80},
+ 'clarity': {'min': 0.70, 'target': 0.85}
+ }
+ },
+ 'student_essay': {
+ 'name': 'Trabajo Universitario',
+ 'thresholds': {
+ 'vocabulary': {'min': 0.60, 'target': 0.75},
+ 'structure': {'min': 0.65, 'target': 0.80},
+ 'cohesion': {'min': 0.55, 'target': 0.70},
+ 'clarity': {'min': 0.60, 'target': 0.75}
+ }
+ },
+ 'general_communication': {
+ 'name': 'Comunicación General',
+ 'thresholds': {
+ 'vocabulary': {'min': 0.50, 'target': 0.65},
+ 'structure': {'min': 0.55, 'target': 0.70},
+ 'cohesion': {'min': 0.45, 'target': 0.60},
+ 'clarity': {'min': 0.50, 'target': 0.65}
+ }
+ }
+}
+####################################
+
+def display_current_situation_interface(lang_code, nlp_models, t):
+ """
+ Interfaz simplificada con gráfico de radar para visualizar métricas.
+ """
+ # Inicializar estados si no existen
+ if 'text_input' not in st.session_state:
+ st.session_state.text_input = ""
+ if 'text_area' not in st.session_state: # Añadir inicialización de text_area
+ st.session_state.text_area = ""
+ if 'show_results' not in st.session_state:
+ st.session_state.show_results = False
+ if 'current_doc' not in st.session_state:
+ st.session_state.current_doc = None
+ if 'current_metrics' not in st.session_state:
+ st.session_state.current_metrics = None
+
+ try:
+ # Container principal con dos columnas
+ with st.container():
+ input_col, results_col = st.columns([1,2])
+
+ with input_col:
+ # Text area con manejo de estado
+ text_input = st.text_area(
+ t.get('input_prompt', "Escribe o pega tu texto aquí:"),
+ height=400,
+ key="text_area",
+ value=st.session_state.text_input,
+ help="Este texto será analizado para darte recomendaciones personalizadas"
+ )
+
+ # Función para manejar cambios de texto
+ if text_input != st.session_state.text_input:
+ st.session_state.text_input = text_input
+ st.session_state.show_results = False
+
+ if st.button(
+ t.get('analyze_button', "Analizar mi escritura"),
+ type="primary",
+ disabled=not text_input.strip(),
+ use_container_width=True,
+ ):
+ try:
+ with st.spinner(t.get('processing', "Analizando...")):
+ doc = nlp_models[lang_code](text_input)
+ metrics = analyze_text_dimensions(doc)
+
+ storage_success = store_current_situation_result(
+ username=st.session_state.username,
+ text=text_input,
+ metrics=metrics,
+ feedback=None
+ )
+
+ if not storage_success:
+ logger.warning("No se pudo guardar el análisis en la base de datos")
+
+ st.session_state.current_doc = doc
+ st.session_state.current_metrics = metrics
+ st.session_state.show_results = True
+
+ except Exception as e:
+ logger.error(f"Error en análisis: {str(e)}")
+ st.error(t.get('analysis_error', "Error al analizar el texto"))
+
+ # Mostrar resultados en la columna derecha
+ with results_col:
+ if st.session_state.show_results and st.session_state.current_metrics is not None:
+ # Primero los radio buttons para tipo de texto
+ st.markdown("### Tipo de texto")
+ text_type = st.radio(
+ "",
+ options=list(TEXT_TYPES.keys()),
+ format_func=lambda x: TEXT_TYPES[x]['name'],
+ horizontal=True,
+ key="text_type_radio",
+ help="Selecciona el tipo de texto para ajustar los criterios de evaluación"
+ )
+
+ st.session_state.current_text_type = text_type
+
+ # Luego mostrar los resultados
+ display_results(
+ metrics=st.session_state.current_metrics,
+ text_type=text_type
+ )
+
+ except Exception as e:
+ logger.error(f"Error en interfaz principal: {str(e)}")
+ st.error("Ocurrió un error al cargar la interfaz")
+
+###################################3333
+
+'''
+def display_results(metrics, text_type=None):
+ """
+ Muestra los resultados del análisis: métricas verticalmente y gráfico radar.
+ """
+ try:
+ # Usar valor por defecto si no se especifica tipo
+ text_type = text_type or 'student_essay'
+
+ # Obtener umbrales según el tipo de texto
+ thresholds = TEXT_TYPES[text_type]['thresholds']
+
+ # Crear dos columnas para las métricas y el gráfico
+ metrics_col, graph_col = st.columns([1, 1.5])
+
+ # Columna de métricas
+ with metrics_col:
+ metrics_config = [
+ {
+ 'label': "Vocabulario",
+ 'key': 'vocabulary',
+ 'value': metrics['vocabulary']['normalized_score'],
+ 'help': "Riqueza y variedad del vocabulario",
+ 'thresholds': thresholds['vocabulary']
+ },
+ {
+ 'label': "Estructura",
+ 'key': 'structure',
+ 'value': metrics['structure']['normalized_score'],
+ 'help': "Organización y complejidad de oraciones",
+ 'thresholds': thresholds['structure']
+ },
+ {
+ 'label': "Cohesión",
+ 'key': 'cohesion',
+ 'value': metrics['cohesion']['normalized_score'],
+ 'help': "Conexión y fluidez entre ideas",
+ 'thresholds': thresholds['cohesion']
+ },
+ {
+ 'label': "Claridad",
+ 'key': 'clarity',
+ 'value': metrics['clarity']['normalized_score'],
+ 'help': "Facilidad de comprensión del texto",
+ 'thresholds': thresholds['clarity']
+ }
+ ]
+
+ # Mostrar métricas
+ for metric in metrics_config:
+ value = metric['value']
+ if value < metric['thresholds']['min']:
+ status = "⚠️ Por mejorar"
+ color = "inverse"
+ elif value < metric['thresholds']['target']:
+ status = "📈 Aceptable"
+ color = "off"
+ else:
+ status = "✅ Óptimo"
+ color = "normal"
+
+ st.metric(
+ metric['label'],
+ f"{value:.2f}",
+ f"{status} (Meta: {metric['thresholds']['target']:.2f})",
+ delta_color=color,
+ help=metric['help']
+ )
+ st.markdown("", unsafe_allow_html=True)
+
+ # Gráfico radar en la columna derecha
+ with graph_col:
+ display_radar_chart(metrics_config, thresholds)
+
+ except Exception as e:
+ logger.error(f"Error mostrando resultados: {str(e)}")
+ st.error("Error al mostrar los resultados")
+'''
+
+######################################
+######################################
+def display_results(metrics, text_type=None):
+ """
+ Muestra los resultados del análisis: métricas verticalmente y gráfico radar.
+ """
+ try:
+ # Usar valor por defecto si no se especifica tipo
+ text_type = text_type or 'student_essay'
+
+ # Obtener umbrales según el tipo de texto
+ thresholds = TEXT_TYPES[text_type]['thresholds']
+
+ # Crear dos columnas para las métricas y el gráfico
+ metrics_col, graph_col = st.columns([1, 1.5])
+
+ # Columna de métricas
+ with metrics_col:
+ metrics_config = [
+ {
+ 'label': "Vocabulario",
+ 'key': 'vocabulary',
+ 'value': metrics['vocabulary']['normalized_score'],
+ 'help': "Riqueza y variedad del vocabulario",
+ 'thresholds': thresholds['vocabulary']
+ },
+ {
+ 'label': "Estructura",
+ 'key': 'structure',
+ 'value': metrics['structure']['normalized_score'],
+ 'help': "Organización y complejidad de oraciones",
+ 'thresholds': thresholds['structure']
+ },
+ {
+ 'label': "Cohesión",
+ 'key': 'cohesion',
+ 'value': metrics['cohesion']['normalized_score'],
+ 'help': "Conexión y fluidez entre ideas",
+ 'thresholds': thresholds['cohesion']
+ },
+ {
+ 'label': "Claridad",
+ 'key': 'clarity',
+ 'value': metrics['clarity']['normalized_score'],
+ 'help': "Facilidad de comprensión del texto",
+ 'thresholds': thresholds['clarity']
+ }
+ ]
+
+ # Mostrar métricas
+ for metric in metrics_config:
+ value = metric['value']
+ if value < metric['thresholds']['min']:
+ status = "⚠️ Por mejorar"
+ color = "inverse"
+ elif value < metric['thresholds']['target']:
+ status = "📈 Aceptable"
+ color = "off"
+ else:
+ status = "✅ Óptimo"
+ color = "normal"
+
+ st.metric(
+ metric['label'],
+ f"{value:.2f}",
+ f"{status} (Meta: {metric['thresholds']['target']:.2f})",
+ delta_color=color,
+ help=metric['help']
+ )
+ st.markdown("", unsafe_allow_html=True)
+
+ # Gráfico radar en la columna derecha
+ with graph_col:
+ display_radar_chart(metrics_config, thresholds)
+
+ recommendations = generate_recommendations(
+ metrics=metrics,
+ text_type=text_type,
+ lang_code=st.session_state.lang_code
+ )
+
+ # Separador visual
+ st.markdown("---")
+
+ # Título para la sección de recomendaciones
+ st.subheader("Recomendaciones para mejorar tu escritura")
+
+ # Mostrar las recomendaciones
+ display_recommendations(recommendations, get_translations(st.session_state.lang_code))
+
+ except Exception as e:
+ logger.error(f"Error mostrando resultados: {str(e)}")
+ st.error("Error al mostrar los resultados")
+
+
+######################################
+######################################
+def display_radar_chart(metrics_config, thresholds):
+ """
+ Muestra el gráfico radar con los resultados.
+ """
+ try:
+ # Preparar datos para el gráfico
+ categories = [m['label'] for m in metrics_config]
+ values_user = [m['value'] for m in metrics_config]
+ min_values = [m['thresholds']['min'] for m in metrics_config]
+ target_values = [m['thresholds']['target'] for m in metrics_config]
+
+ # Crear y configurar gráfico
+ fig = plt.figure(figsize=(8, 8))
+ ax = fig.add_subplot(111, projection='polar')
+
+ # Configurar radar
+ angles = [n / float(len(categories)) * 2 * np.pi for n in range(len(categories))]
+ angles += angles[:1]
+ values_user += values_user[:1]
+ min_values += min_values[:1]
+ target_values += target_values[:1]
+
+ # Configurar ejes
+ ax.set_xticks(angles[:-1])
+ ax.set_xticklabels(categories, fontsize=10)
+ circle_ticks = np.arange(0, 1.1, 0.2)
+ ax.set_yticks(circle_ticks)
+ ax.set_yticklabels([f'{tick:.1f}' for tick in circle_ticks], fontsize=8)
+ ax.set_ylim(0, 1)
+
+ # Dibujar áreas de umbrales
+ ax.plot(angles, min_values, '#e74c3c', linestyle='--', linewidth=1, label='Mínimo', alpha=0.5)
+ ax.plot(angles, target_values, '#2ecc71', linestyle='--', linewidth=1, label='Meta', alpha=0.5)
+ ax.fill_between(angles, target_values, [1]*len(angles), color='#2ecc71', alpha=0.1)
+ ax.fill_between(angles, [0]*len(angles), min_values, color='#e74c3c', alpha=0.1)
+
+ # Dibujar valores del usuario
+ ax.plot(angles, values_user, '#3498db', linewidth=2, label='Tu escritura')
+ ax.fill(angles, values_user, '#3498db', alpha=0.2)
+
+ # Ajustar leyenda
+ ax.legend(
+ loc='upper right',
+ bbox_to_anchor=(1.3, 1.1), # Cambiado de (0.1, 0.1) a (1.3, 1.1)
+ fontsize=10,
+ frameon=True,
+ facecolor='white',
+ edgecolor='none',
+ shadow=True
+ )
+
+ plt.tight_layout()
+ st.pyplot(fig)
+ plt.close()
+
+ except Exception as e:
+ logger.error(f"Error mostrando gráfico radar: {str(e)}")
+ st.error("Error al mostrar el gráfico")
+
+#####################################################
+def display_recommendations(recommendations, t):
+ """
+ Muestra las recomendaciones con un diseño de tarjetas.
+ """
+ # Definir colores para cada categoría
+ colors = {
+ 'vocabulary': '#2E86C1', # Azul
+ 'structure': '#28B463', # Verde
+ 'cohesion': '#F39C12', # Naranja
+ 'clarity': '#9B59B6', # Púrpura
+ 'priority': '#E74C3C' # Rojo para la categoría prioritaria
+ }
+
+ # Iconos para cada categoría
+ icons = {
+ 'vocabulary': '📚',
+ 'structure': '🏗️',
+ 'cohesion': '🔄',
+ 'clarity': '💡',
+ 'priority': '⭐'
+ }
+
+ # Obtener traducciones para cada dimensión
+ dimension_names = {
+ 'vocabulary': t.get('SITUATION_ANALYSIS', {}).get('vocabulary', "Vocabulario"),
+ 'structure': t.get('SITUATION_ANALYSIS', {}).get('structure', "Estructura"),
+ 'cohesion': t.get('SITUATION_ANALYSIS', {}).get('cohesion', "Cohesión"),
+ 'clarity': t.get('SITUATION_ANALYSIS', {}).get('clarity', "Claridad"),
+ 'priority': t.get('SITUATION_ANALYSIS', {}).get('priority', "Prioridad")
+ }
+
+ # Título de la sección prioritaria
+ priority_focus = t.get('SITUATION_ANALYSIS', {}).get('priority_focus', 'Área prioritaria para mejorar')
+ st.markdown(f"### {icons['priority']} {priority_focus}")
+
+ # Determinar área prioritaria (la que tiene menor puntuación)
+ priority_area = recommendations.get('priority', 'vocabulary')
+ priority_title = dimension_names.get(priority_area, "Área prioritaria")
+
+ # Determinar el contenido para mostrar
+ if isinstance(recommendations[priority_area], dict) and 'title' in recommendations[priority_area]:
+ priority_title = recommendations[priority_area]['title']
+ priority_content = recommendations[priority_area]['content']
+ else:
+ priority_content = recommendations[priority_area]
+
+ # Mostrar la recomendación prioritaria con un estilo destacado
+ with st.container():
+ st.markdown(
+ f"""
+
+ """
+ concepts_html += ''.join(
+ f'
{concept}'
+ f'({freq:.2f})
'
+ for concept, freq in analysis['key_concepts']
+ )
+ concepts_html += "
+
+ """,
+ unsafe_allow_html=True
+ )
+
+ # Crear dos columnas para las tarjetas de recomendaciones restantes
+ col1, col2 = st.columns(2)
+
+ # Distribuir las recomendaciones en las columnas
+ categories = ['vocabulary', 'structure', 'cohesion', 'clarity']
+ for i, category in enumerate(categories):
+ # Saltar si esta categoría ya es la prioritaria
+ if category == priority_area:
+ continue
+
+ # Determinar título y contenido
+ if isinstance(recommendations[category], dict) and 'title' in recommendations[category]:
+ category_title = recommendations[category]['title']
+ category_content = recommendations[category]['content']
+ else:
+ category_title = dimension_names.get(category, category)
+ category_content = recommendations[category]
+
+ # Alternar entre columnas
+ with col1 if i % 2 == 0 else col2:
+ # Crear tarjeta para cada recomendación
+ st.markdown(
+ f"""
+ {priority_title}
+{priority_content}
+
+
+ """,
+ unsafe_allow_html=True
+ )
\ No newline at end of file
diff --git a/src/modules/studentact/__pycache__/student_activities.cpython-311.pyc b/src/modules/studentact/__pycache__/student_activities.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e2b820fda86da0621440ebd0d0aabd60e9e259d
Binary files /dev/null and b/src/modules/studentact/__pycache__/student_activities.cpython-311.pyc differ
diff --git a/src/modules/studentact/__pycache__/student_activities_v2.cpython-311.pyc b/src/modules/studentact/__pycache__/student_activities_v2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6b2ea707d57df5d3e7a4171dd1065ddf0c25bdd9
Binary files /dev/null and b/src/modules/studentact/__pycache__/student_activities_v2.cpython-311.pyc differ
diff --git a/src/modules/studentact/claude_recommendations.py b/src/modules/studentact/claude_recommendations.py
new file mode 100644
index 0000000000000000000000000000000000000000..0663ae48abb5564fb06f9c8f0725c0bf5e36798e
--- /dev/null
+++ b/src/modules/studentact/claude_recommendations.py
@@ -0,0 +1,347 @@
+# modules/studentact/claude_recommendations.py
+import os
+import anthropic
+import streamlit as st
+import logging
+import time
+import json
+from datetime import datetime, timezone
+
+# Local imports
+from ..utils.widget_utils import generate_unique_key
+from ..database.current_situation_mongo_db import store_current_situation_result
+
+logger = logging.getLogger(__name__)
+
+# Define text types
+TEXT_TYPES = {
+ 'es': {
+ 'academic_article': 'artículo académico',
+ 'university_work': 'trabajo universitario',
+ 'general_communication': 'comunicación general'
+ },
+ 'en': {
+ 'academic_article': 'academic article',
+ 'university_work': 'university work',
+ 'general_communication': 'general communication'
+ },
+ 'fr': {
+ 'academic_article': 'article académique',
+ 'university_work': 'travail universitaire',
+ 'general_communication': 'communication générale'
+ },
+ 'pt': {
+ 'academic_article': 'artigo acadêmico',
+ 'university_work': 'trabalho universitário',
+ 'general_communication': 'comunicação geral'
+ }
+}
+
+# Cache for recommendations to avoid redundant API calls
+recommendation_cache = {}
+
+def get_recommendation_cache_key(text, metrics, text_type, lang_code):
+ """
+ Generate a cache key for recommendations.
+ """
+ # Create a simple hash based on text content and metrics
+ text_hash = hash(text[:1000]) # Only use first 1000 chars for hashing
+ metrics_hash = hash(json.dumps(metrics, sort_keys=True))
+ return f"{text_hash}_{metrics_hash}_{text_type}_{lang_code}"
+
+def format_metrics_for_claude(metrics, lang_code, text_type):
+ """
+ Format metrics in a way that's readable for Claude
+ """
+ formatted_metrics = {}
+ for key, value in metrics.items():
+ if isinstance(value, (int, float)):
+ formatted_metrics[key] = round(value, 2)
+ else:
+ formatted_metrics[key] = value
+
+ # Add context about what type of text this is
+ text_type_label = TEXT_TYPES.get(lang_code, {}).get(text_type, text_type)
+ formatted_metrics['text_type'] = text_type_label
+
+ return formatted_metrics
+
+def generate_claude_recommendations(text, metrics, text_type, lang_code):
+ """
+ Generate personalized recommendations using Claude API.
+ """
+ try:
+ api_key = os.environ.get("ANTHROPIC_API_KEY")
+ if not api_key:
+ logger.error("Claude API key not found in environment variables")
+ return get_fallback_recommendations(lang_code)
+
+ # Check cache first
+ cache_key = get_recommendation_cache_key(text, metrics, text_type, lang_code)
+ if cache_key in recommendation_cache:
+ logger.info("Using cached recommendations")
+ return recommendation_cache[cache_key]
+
+ # Format metrics for Claude
+ formatted_metrics = format_metrics_for_claude(metrics, lang_code, text_type)
+
+ # Determine language for prompt
+ if lang_code == 'es':
+ system_prompt = """Eres un asistente especializado en análisis de textos académicos y comunicación escrita.
+ Tu tarea es analizar el texto del usuario y proporcionar recomendaciones personalizadas.
+ Usa un tono constructivo y específico. Sé claro y directo con tus sugerencias.
+ """
+ user_prompt = f"""Por favor, analiza este texto de tipo '{formatted_metrics['text_type']}'
+ y proporciona recomendaciones personalizadas para mejorarlo.
+
+ MÉTRICAS DE ANÁLISIS:
+ {json.dumps(formatted_metrics, indent=2, ensure_ascii=False)}
+
+ TEXTO A ANALIZAR:
+ {text[:2000]} # Limitamos el texto para evitar exceder tokens
+
+ Proporciona tu análisis con el siguiente formato:
+ 1. Un resumen breve (2-3 frases) del análisis general
+ 2. 3-4 recomendaciones específicas y accionables (cada una de 1-2 frases)
+ 3. Un ejemplo concreto de mejora tomado del propio texto del usuario
+ 4. Una sugerencia sobre qué herramienta de AIdeaText usar (Análisis Morfosintáctico, Análisis Semántico o Análisis del Discurso)
+
+ Tu respuesta debe ser concisa y no exceder los 300 palabras."""
+
+ elif lang_code == 'fr':
+ system_prompt = """Vous êtes un assistant spécialisé dans l'analyse de textes académiques et de communication écrite.
+ Votre tâche est d'analyser le texte de l'utilisateur et de fournir des recommandations personnalisées.
+ Utilisez un ton constructif et spécifique. Soyez clair et direct dans vos suggestions.
+ """
+ user_prompt = f"""Veuillez analyser ce texte de type '{formatted_metrics['text_type']}'
+ et fournir des recommandations personnalisées pour l'améliorer.
+
+ MÉTRIQUES D'ANALYSE:
+ {json.dumps(formatted_metrics, indent=2, ensure_ascii=False)}
+
+ TEXTE À ANALYSER:
+ {text[:2000]}
+
+ Fournissez votre analyse avec le format suivant:
+ 1. Un résumé bref (2-3 phrases) de l'analyse générale
+ 2. 3-4 recommandations spécifiques et réalisables (chacune de 1-2 phrases)
+ 3. Un exemple concret d'amélioration tiré du texte même de l'utilisateur
+ 4. Une suggestion sur quel outil AIdeaText utiliser (Analyse Morphosyntaxique, Analyse Sémantique ou Analyse du Discours)
+
+ Votre réponse doit être concise et ne pas dépasser 300 mots."""
+
+ elif lang_code == 'pt':
+ system_prompt = """Você é um assistente especializado na análise de textos acadêmicos e comunicação escrita.
+ Sua tarefa é analisar o texto do usuário e fornecer recomendações personalizadas.
+ Use um tom construtivo e específico. Seja claro e direto com suas sugestões.
+ """
+ user_prompt = f"""Por favor, analise este texto do tipo '{formatted_metrics['text_type']}'
+ e forneça recomendações personalizadas para melhorá-lo.
+
+ MÉTRICAS DE ANÁLISE:
+ {json.dumps(formatted_metrics, indent=2, ensure_ascii=False)}
+
+ TEXTO PARA ANALISAR:
+ {text[:2000]}
+
+ Forneça sua análise com o seguinte formato:
+ 1. Um breve resumo (2-3 frases) da análise geral
+ 2. 3-4 recomendações específicas e acionáveis (cada uma com 1-2 frases)
+ 3. Um exemplo concreto de melhoria retirado do próprio texto do usuário
+ 4. Uma sugestão sobre qual ferramenta do AIdeaText usar (Análise Morfossintática, Análise Semântica ou Análise do Discurso)
+
+ Sua resposta deve ser concisa e não exceder 300 palavras."""
+
+ else:
+ # Default to English
+ system_prompt = """You are an assistant specialized in analyzing academic texts and written communication.
+ Your task is to analyze the user's text and provide personalized recommendations.
+ Use a constructive and specific tone. Be clear and direct with your suggestions.
+ """
+ user_prompt = f"""Please analyze this text of type '{formatted_metrics['text_type']}'
+ and provide personalized recommendations to improve it.
+
+ ANALYSIS METRICS:
+ {json.dumps(formatted_metrics, indent=2, ensure_ascii=False)}
+
+ TEXT TO ANALYZE:
+ {text[:2000]} # Limiting text to avoid exceeding tokens
+
+ Provide your analysis with the following format:
+ 1. A brief summary (2-3 sentences) of the general analysis
+ 2. 3-4 specific and actionable recommendations (each 1-2 sentences)
+ 3. A concrete example of improvement taken from the user's own text
+ 4. A suggestion about which AIdeaText tool to use (Morphosyntactic Analysis, Semantic Analysis or Discourse Analysis)
+
+ Your response should be concise and not exceed 300 words."""
+
+ # Initialize Claude client
+ client = anthropic.Anthropic(api_key=api_key)
+
+ # Call Claude API
+ start_time = time.time()
+ response = client.messages.create(
+ model="claude-3-5-sonnet-20241022",
+ max_tokens=1024,
+ temperature=0.7,
+ system=system_prompt,
+ messages=[
+ {"role": "user", "content": user_prompt}
+ ]
+ )
+ logger.info(f"Claude API call completed in {time.time() - start_time:.2f} seconds")
+
+ # Extract recommendations
+ recommendations = response.content[0].text
+
+ # Cache the result
+ recommendation_cache[cache_key] = recommendations
+
+ return recommendations
+ except Exception as e:
+ logger.error(f"Error generating recommendations with Claude: {str(e)}")
+ return get_fallback_recommendations(lang_code)
+
+##################################################################################
+##################################################################################
+def get_fallback_recommendations(lang_code):
+ """
+ Return fallback recommendations if Claude API fails
+ """
+ if lang_code == 'es':
+ return """
+ **Análisis General**
+ Tu texto presenta una estructura básica adecuada, pero hay áreas que pueden mejorarse para mayor claridad y cohesión.
+ **Recomendaciones**:
+ - Intenta variar tu vocabulario para evitar repeticiones innecesarias
+ - Considera revisar la longitud de tus oraciones para mantener un mejor ritmo
+ - Asegúrate de establecer conexiones claras entre las ideas principales
+ - Revisa la consistencia en el uso de tiempos verbales
+ **Herramienta recomendada**:
+ Te sugerimos utilizar el Análisis Morfosintáctico para identificar patrones en tu estructura de oraciones.
+ """
+
+ elif lang_code == 'fr':
+ return """
+ **Analyse Générale**
+ Votre texte présente une structure de base adéquate, mais certains aspects pourraient être améliorés pour plus de clarté et de cohésion.
+
+ **Recommandations**:
+ - Essayez de varier votre vocabulaire pour éviter les répétitions inutiles
+ - Envisagez de revoir la longueur de vos phrases pour maintenir un meilleur rythme
+ - Assurez-vous d'établir des liens clairs entre les idées principales
+ - Vérifiez la cohérence dans l'utilisation des temps verbaux
+
+ **Outil recommandé**:
+ Nous vous suggérons d'utiliser l'Analyse Morphosyntaxique pour identifier les modèles dans la structure de vos phrases.
+ """
+
+ elif lang_code == 'pt':
+ return """
+ **Análise Geral**
+ Seu texto apresenta uma estrutura básica adequada, mas há áreas que podem ser melhoradas para maior clareza e coesão.
+
+ **Recomendações**:
+ - Tente variar seu vocabulário para evitar repetições desnecessárias
+ - Considere revisar o comprimento de suas frases para manter um melhor ritmo
+ - Certifique-se de estabelecer conexões claras entre as ideias principais
+ - Revise a consistência no uso dos tempos verbais
+
+ **Ferramenta recomendada**:
+ Sugerimos utilizar a Análise Morfossintática para identificar padrões na sua estrutura de frases.
+ """
+
+ else:
+ return """
+ **General Analysis**
+ Your text presents an adequate basic structure, but there are areas that can be improved for better clarity and cohesion.
+
+ **Recommendations**:
+ - Try to vary your vocabulary to avoid unnecessary repetition
+ - Consider reviewing the length of your sentences to maintain a better rhythm
+ - Make sure to establish clear connections between main ideas
+ - Check consistency in the use of verb tenses
+
+ **Recommended tool**:
+ We suggest using Morphosyntactic Analysis to identify patterns in your sentence structure.
+ """
+
+
+#######################################
+#######################################
+def store_recommendations(username, text, metrics, text_type, recommendations):
+ """
+ Store the recommendations in the database
+ """
+ try:
+ # Importar la función de almacenamiento de recomendaciones
+ from ..database.claude_recommendations_mongo_db import store_claude_recommendation
+
+ # Guardar usando la nueva función especializada
+ result = store_claude_recommendation(
+ username=username,
+ text=text,
+ metrics=metrics,
+ text_type=text_type,
+ recommendations=recommendations
+ )
+
+ logger.info(f"Recommendations stored successfully: {result}")
+ return result
+ except Exception as e:
+ logger.error(f"Error storing recommendations: {str(e)}")
+ return False
+
+
+##########################################
+##########################################
+def display_personalized_recommendations(text, metrics, text_type, lang_code, t):
+ """
+ Display personalized recommendations based on text analysis
+ """
+ try:
+ # Generate recommendations
+ recommendations = generate_claude_recommendations(text, metrics, text_type, lang_code)
+
+ # Format and display recommendations in a nice container
+ st.markdown("### 📝 " + t.get('recommendations_title', 'Personalized Recommendations'))
+
+ with st.container():
+ st.markdown(f"""
+ {icons[category]} {category_title}
+{category_content}
+
+ {recommendations}
+
+ """, unsafe_allow_html=True)
+
+ # Add prompt to use assistant
+ st.info("💡 **" + t.get('assistant_prompt', 'For further improvement:') + "** " +
+ t.get('assistant_message', 'Open the virtual assistant (powered by Claude AI) in the upper left corner by clicking the arrow next to the logo.'))
+
+ # Add save button
+ col1, col2, col3 = st.columns([1,1,1])
+ with col2:
+ if st.button(
+ t.get('save_button', 'Save Analysis'),
+ key=generate_unique_key("claude_recommendations", "save"),
+ type="primary",
+ use_container_width=True
+ ):
+ if 'username' in st.session_state:
+ success = store_recommendations(
+ st.session_state.username,
+ text,
+ metrics,
+ text_type,
+ recommendations
+ )
+ if success:
+ st.success(t.get('save_success', 'Analysis saved successfully'))
+ else:
+ st.error(t.get('save_error', 'Error saving analysis'))
+ else:
+ st.error(t.get('login_required', 'Please log in to save analysis'))
+
+ except Exception as e:
+ logger.error(f"Error displaying recommendations: {str(e)}")
+ st.error(t.get('recommendations_error', 'Error generating recommendations. Please try again later.'))
\ No newline at end of file
diff --git a/src/modules/studentact/current_situation_analysis-FAIL.py b/src/modules/studentact/current_situation_analysis-FAIL.py
new file mode 100644
index 0000000000000000000000000000000000000000..873a8de350242c563ff7d0257be106e305927e4e
--- /dev/null
+++ b/src/modules/studentact/current_situation_analysis-FAIL.py
@@ -0,0 +1,810 @@
+#v3/modules/studentact/current_situation_analysis.py
+
+import streamlit as st
+import matplotlib.pyplot as plt
+import networkx as nx
+import seaborn as sns
+from collections import Counter
+from itertools import combinations
+import numpy as np
+import matplotlib.patches as patches
+import logging
+
+# 2. Configuración básica del logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[
+ logging.StreamHandler(),
+ logging.FileHandler('app.log')
+ ]
+)
+
+# 3. Obtener el logger específico para este módulo
+logger = logging.getLogger(__name__)
+
+#########################################################################
+
+def correlate_metrics(scores):
+ """
+ Ajusta los scores para mantener correlaciones lógicas entre métricas.
+
+ Args:
+ scores: dict con scores iniciales de vocabulario, estructura, cohesión y claridad
+
+ Returns:
+ dict con scores ajustados
+ """
+ try:
+ # 1. Correlación estructura-cohesión
+ # La cohesión no puede ser menor que estructura * 0.7
+ min_cohesion = scores['structure']['normalized_score'] * 0.7
+ if scores['cohesion']['normalized_score'] < min_cohesion:
+ scores['cohesion']['normalized_score'] = min_cohesion
+
+ # 2. Correlación vocabulario-cohesión
+ # La cohesión léxica depende del vocabulario
+ vocab_influence = scores['vocabulary']['normalized_score'] * 0.6
+ scores['cohesion']['normalized_score'] = max(
+ scores['cohesion']['normalized_score'],
+ vocab_influence
+ )
+
+ # 3. Correlación cohesión-claridad
+ # La claridad no puede superar cohesión * 1.2
+ max_clarity = scores['cohesion']['normalized_score'] * 1.2
+ if scores['clarity']['normalized_score'] > max_clarity:
+ scores['clarity']['normalized_score'] = max_clarity
+
+ # 4. Correlación estructura-claridad
+ # La claridad no puede superar estructura * 1.1
+ struct_max_clarity = scores['structure']['normalized_score'] * 1.1
+ scores['clarity']['normalized_score'] = min(
+ scores['clarity']['normalized_score'],
+ struct_max_clarity
+ )
+
+ # Normalizar todos los scores entre 0 y 1
+ for metric in scores:
+ scores[metric]['normalized_score'] = max(0.0, min(1.0, scores[metric]['normalized_score']))
+
+ return scores
+
+ except Exception as e:
+ logger.error(f"Error en correlate_metrics: {str(e)}")
+ return scores
+
+##########################################################################
+
+def analyze_text_dimensions(doc):
+ """
+ Analiza las dimensiones principales del texto manteniendo correlaciones lógicas.
+ """
+ try:
+ # Obtener scores iniciales
+ vocab_score, vocab_details = analyze_vocabulary_diversity(doc)
+ struct_score = analyze_structure(doc)
+ cohesion_score = analyze_cohesion(doc)
+ clarity_score, clarity_details = analyze_clarity(doc)
+
+ # Crear diccionario de scores inicial
+ scores = {
+ 'vocabulary': {
+ 'normalized_score': vocab_score,
+ 'details': vocab_details
+ },
+ 'structure': {
+ 'normalized_score': struct_score,
+ 'details': None
+ },
+ 'cohesion': {
+ 'normalized_score': cohesion_score,
+ 'details': None
+ },
+ 'clarity': {
+ 'normalized_score': clarity_score,
+ 'details': clarity_details
+ }
+ }
+
+ # Ajustar correlaciones entre métricas
+ adjusted_scores = correlate_metrics(scores)
+
+ # Logging para diagnóstico
+ logger.info(f"""
+ Scores originales vs ajustados:
+ Vocabulario: {vocab_score:.2f} -> {adjusted_scores['vocabulary']['normalized_score']:.2f}
+ Estructura: {struct_score:.2f} -> {adjusted_scores['structure']['normalized_score']:.2f}
+ Cohesión: {cohesion_score:.2f} -> {adjusted_scores['cohesion']['normalized_score']:.2f}
+ Claridad: {clarity_score:.2f} -> {adjusted_scores['clarity']['normalized_score']:.2f}
+ """)
+
+ return adjusted_scores
+
+ except Exception as e:
+ logger.error(f"Error en analyze_text_dimensions: {str(e)}")
+ return {
+ 'vocabulary': {'normalized_score': 0.0, 'details': {}},
+ 'structure': {'normalized_score': 0.0, 'details': {}},
+ 'cohesion': {'normalized_score': 0.0, 'details': {}},
+ 'clarity': {'normalized_score': 0.0, 'details': {}}
+ }
+
+
+
+#############################################################################################
+
+def analyze_clarity(doc):
+ """
+ Analiza la claridad del texto considerando múltiples factores.
+ """
+ try:
+ sentences = list(doc.sents)
+ if not sentences:
+ return 0.0, {}
+
+ # 1. Longitud de oraciones
+ sentence_lengths = [len(sent) for sent in sentences]
+ avg_length = sum(sentence_lengths) / len(sentences)
+
+ # Normalizar usando los umbrales definidos para clarity
+ length_score = normalize_score(
+ value=avg_length,
+ metric_type='clarity',
+ optimal_length=20, # Una oración ideal tiene ~20 palabras
+ min_threshold=0.60, # Consistente con METRIC_THRESHOLDS
+ target_threshold=0.75 # Consistente con METRIC_THRESHOLDS
+ )
+
+ # 2. Análisis de conectores
+ connector_count = 0
+ connector_weights = {
+ 'CCONJ': 1.0, # Coordinantes
+ 'SCONJ': 1.2, # Subordinantes
+ 'ADV': 0.8 # Adverbios conectivos
+ }
+
+ for token in doc:
+ if token.pos_ in connector_weights and token.dep_ in ['cc', 'mark', 'advmod']:
+ connector_count += connector_weights[token.pos_]
+
+ # Normalizar conectores por oración
+ connectors_per_sentence = connector_count / len(sentences) if sentences else 0
+ connector_score = normalize_score(
+ value=connectors_per_sentence,
+ metric_type='clarity',
+ optimal_connections=1.5, # ~1.5 conectores por oración es óptimo
+ min_threshold=0.60,
+ target_threshold=0.75
+ )
+
+ # 3. Complejidad estructural
+ clause_count = 0
+ for sent in sentences:
+ verbs = [token for token in sent if token.pos_ == 'VERB']
+ clause_count += len(verbs)
+
+ complexity_raw = clause_count / len(sentences) if sentences else 0
+ complexity_score = normalize_score(
+ value=complexity_raw,
+ metric_type='clarity',
+ optimal_depth=2.0, # ~2 cláusulas por oración es óptimo
+ min_threshold=0.60,
+ target_threshold=0.75
+ )
+
+ # 4. Densidad léxica
+ content_words = len([token for token in doc if token.pos_ in ['NOUN', 'VERB', 'ADJ', 'ADV']])
+ total_words = len([token for token in doc if token.is_alpha])
+ density = content_words / total_words if total_words > 0 else 0
+
+ density_score = normalize_score(
+ value=density,
+ metric_type='clarity',
+ optimal_connections=0.6, # 60% de palabras de contenido es óptimo
+ min_threshold=0.60,
+ target_threshold=0.75
+ )
+
+ # Score final ponderado
+ weights = {
+ 'length': 0.3,
+ 'connectors': 0.3,
+ 'complexity': 0.2,
+ 'density': 0.2
+ }
+
+ clarity_score = (
+ weights['length'] * length_score +
+ weights['connectors'] * connector_score +
+ weights['complexity'] * complexity_score +
+ weights['density'] * density_score
+ )
+
+ details = {
+ 'length_score': length_score,
+ 'connector_score': connector_score,
+ 'complexity_score': complexity_score,
+ 'density_score': density_score,
+ 'avg_sentence_length': avg_length,
+ 'connectors_per_sentence': connectors_per_sentence,
+ 'density': density
+ }
+
+ # Agregar logging para diagnóstico
+ logger.info(f"""
+ Scores de Claridad:
+ - Longitud: {length_score:.2f} (avg={avg_length:.1f} palabras)
+ - Conectores: {connector_score:.2f} (avg={connectors_per_sentence:.1f} por oración)
+ - Complejidad: {complexity_score:.2f} (avg={complexity_raw:.1f} cláusulas)
+ - Densidad: {density_score:.2f} ({density*100:.1f}% palabras de contenido)
+ - Score Final: {clarity_score:.2f}
+ """)
+
+ return clarity_score, details
+
+ except Exception as e:
+ logger.error(f"Error en analyze_clarity: {str(e)}")
+ return 0.0, {}
+
+
+def analyze_vocabulary_diversity(doc):
+ """Análisis mejorado de la diversidad y calidad del vocabulario"""
+ try:
+ # 1. Análisis básico de diversidad
+ unique_lemmas = {token.lemma_ for token in doc if token.is_alpha}
+ total_words = len([token for token in doc if token.is_alpha])
+ basic_diversity = len(unique_lemmas) / total_words if total_words > 0 else 0
+
+ # 2. Análisis de registro
+ academic_words = 0
+ narrative_words = 0
+ technical_terms = 0
+
+ # Clasificar palabras por registro
+ for token in doc:
+ if token.is_alpha:
+ # Detectar términos académicos/técnicos
+ if token.pos_ in ['NOUN', 'VERB', 'ADJ']:
+ if any(parent.pos_ == 'NOUN' for parent in token.ancestors):
+ technical_terms += 1
+ # Detectar palabras narrativas
+ if token.pos_ in ['VERB', 'ADV'] and token.dep_ in ['ROOT', 'advcl']:
+ narrative_words += 1
+
+ # 3. Análisis de complejidad sintáctica
+ avg_sentence_length = sum(len(sent) for sent in doc.sents) / len(list(doc.sents))
+
+ # 4. Calcular score ponderado
+ weights = {
+ 'diversity': 0.3,
+ 'technical': 0.3,
+ 'narrative': 0.2,
+ 'complexity': 0.2
+ }
+
+ scores = {
+ 'diversity': basic_diversity,
+ 'technical': technical_terms / total_words if total_words > 0 else 0,
+ 'narrative': narrative_words / total_words if total_words > 0 else 0,
+ 'complexity': min(1.0, avg_sentence_length / 20) # Normalizado a 20 palabras
+ }
+
+ # Score final ponderado
+ final_score = sum(weights[key] * scores[key] for key in weights)
+
+ # Información adicional para diagnóstico
+ details = {
+ 'text_type': 'narrative' if scores['narrative'] > scores['technical'] else 'academic',
+ 'scores': scores
+ }
+
+ return final_score, details
+
+ except Exception as e:
+ logger.error(f"Error en analyze_vocabulary_diversity: {str(e)}")
+ return 0.0, {}
+
+def analyze_cohesion(doc):
+ """Analiza la cohesión textual"""
+ try:
+ sentences = list(doc.sents)
+ if len(sentences) < 2:
+ logger.warning("Texto demasiado corto para análisis de cohesión")
+ return 0.0
+
+ # 1. Análisis de conexiones léxicas
+ lexical_connections = 0
+ total_possible_connections = 0
+
+ for i in range(len(sentences)-1):
+ # Obtener lemmas significativos (no stopwords)
+ sent1_words = {token.lemma_ for token in sentences[i]
+ if token.is_alpha and not token.is_stop}
+ sent2_words = {token.lemma_ for token in sentences[i+1]
+ if token.is_alpha and not token.is_stop}
+
+ if sent1_words and sent2_words: # Verificar que ambos conjuntos no estén vacíos
+ intersection = len(sent1_words.intersection(sent2_words))
+ total_possible = min(len(sent1_words), len(sent2_words))
+
+ if total_possible > 0:
+ lexical_score = intersection / total_possible
+ lexical_connections += lexical_score
+ total_possible_connections += 1
+
+ # 2. Análisis de conectores
+ connector_count = 0
+ connector_types = {
+ 'CCONJ': 1.0, # Coordinantes
+ 'SCONJ': 1.2, # Subordinantes
+ 'ADV': 0.8 # Adverbios conectivos
+ }
+
+ for token in doc:
+ if (token.pos_ in connector_types and
+ token.dep_ in ['cc', 'mark', 'advmod'] and
+ not token.is_stop):
+ connector_count += connector_types[token.pos_]
+
+ # 3. Cálculo de scores normalizados
+ if total_possible_connections > 0:
+ lexical_cohesion = lexical_connections / total_possible_connections
+ else:
+ lexical_cohesion = 0
+
+ if len(sentences) > 1:
+ connector_cohesion = min(1.0, connector_count / (len(sentences) - 1))
+ else:
+ connector_cohesion = 0
+
+ # 4. Score final ponderado
+ weights = {
+ 'lexical': 0.7,
+ 'connectors': 0.3
+ }
+
+ cohesion_score = (
+ weights['lexical'] * lexical_cohesion +
+ weights['connectors'] * connector_cohesion
+ )
+
+ # 5. Logging para diagnóstico
+ logger.info(f"""
+ Análisis de Cohesión:
+ - Conexiones léxicas encontradas: {lexical_connections}
+ - Conexiones posibles: {total_possible_connections}
+ - Lexical cohesion score: {lexical_cohesion}
+ - Conectores encontrados: {connector_count}
+ - Connector cohesion score: {connector_cohesion}
+ - Score final: {cohesion_score}
+ """)
+
+ return cohesion_score
+
+ except Exception as e:
+ logger.error(f"Error en analyze_cohesion: {str(e)}")
+ return 0.0
+
+def analyze_structure(doc):
+ try:
+ if len(doc) == 0:
+ return 0.0
+
+ structure_scores = []
+ for token in doc:
+ if token.dep_ == 'ROOT':
+ result = get_dependency_depths(token)
+ structure_scores.append(result['final_score'])
+
+ if not structure_scores:
+ return 0.0
+
+ return min(1.0, sum(structure_scores) / len(structure_scores))
+
+ except Exception as e:
+ logger.error(f"Error en analyze_structure: {str(e)}")
+ return 0.0
+
+# Funciones auxiliares de análisis
+
+def get_dependency_depths(token, depth=0, analyzed_tokens=None):
+ """
+ Analiza la profundidad y calidad de las relaciones de dependencia.
+
+ Args:
+ token: Token a analizar
+ depth: Profundidad actual en el árbol
+ analyzed_tokens: Set para evitar ciclos en el análisis
+
+ Returns:
+ dict: Información detallada sobre las dependencias
+ - depths: Lista de profundidades
+ - relations: Diccionario con tipos de relaciones encontradas
+ - complexity_score: Puntuación de complejidad
+ """
+ if analyzed_tokens is None:
+ analyzed_tokens = set()
+
+ # Evitar ciclos
+ if token.i in analyzed_tokens:
+ return {
+ 'depths': [],
+ 'relations': {},
+ 'complexity_score': 0
+ }
+
+ analyzed_tokens.add(token.i)
+
+ # Pesos para diferentes tipos de dependencias
+ dependency_weights = {
+ # Dependencias principales
+ 'nsubj': 1.2, # Sujeto nominal
+ 'obj': 1.1, # Objeto directo
+ 'iobj': 1.1, # Objeto indirecto
+ 'ROOT': 1.3, # Raíz
+
+ # Modificadores
+ 'amod': 0.8, # Modificador adjetival
+ 'advmod': 0.8, # Modificador adverbial
+ 'nmod': 0.9, # Modificador nominal
+
+ # Estructuras complejas
+ 'csubj': 1.4, # Cláusula como sujeto
+ 'ccomp': 1.3, # Complemento clausal
+ 'xcomp': 1.2, # Complemento clausal abierto
+ 'advcl': 1.2, # Cláusula adverbial
+
+ # Coordinación y subordinación
+ 'conj': 1.1, # Conjunción
+ 'cc': 0.7, # Coordinación
+ 'mark': 0.8, # Marcador
+
+ # Otros
+ 'det': 0.5, # Determinante
+ 'case': 0.5, # Caso
+ 'punct': 0.1 # Puntuación
+ }
+
+ # Inicializar resultados
+ current_result = {
+ 'depths': [depth],
+ 'relations': {token.dep_: 1},
+ 'complexity_score': dependency_weights.get(token.dep_, 0.5) * (depth + 1)
+ }
+
+ # Analizar hijos recursivamente
+ for child in token.children:
+ child_result = get_dependency_depths(child, depth + 1, analyzed_tokens)
+
+ # Combinar profundidades
+ current_result['depths'].extend(child_result['depths'])
+
+ # Combinar relaciones
+ for rel, count in child_result['relations'].items():
+ current_result['relations'][rel] = current_result['relations'].get(rel, 0) + count
+
+ # Acumular score de complejidad
+ current_result['complexity_score'] += child_result['complexity_score']
+
+ # Calcular métricas adicionales
+ current_result['max_depth'] = max(current_result['depths'])
+ current_result['avg_depth'] = sum(current_result['depths']) / len(current_result['depths'])
+ current_result['relation_diversity'] = len(current_result['relations'])
+
+ # Calcular score ponderado por tipo de estructura
+ structure_bonus = 0
+
+ # Bonus por estructuras complejas
+ if 'csubj' in current_result['relations'] or 'ccomp' in current_result['relations']:
+ structure_bonus += 0.3
+
+ # Bonus por coordinación balanceada
+ if 'conj' in current_result['relations'] and 'cc' in current_result['relations']:
+ structure_bonus += 0.2
+
+ # Bonus por modificación rica
+ if len(set(['amod', 'advmod', 'nmod']) & set(current_result['relations'])) >= 2:
+ structure_bonus += 0.2
+
+ current_result['final_score'] = (
+ current_result['complexity_score'] * (1 + structure_bonus)
+ )
+
+ return current_result
+
+def normalize_score(value, metric_type,
+ min_threshold=0.0, target_threshold=1.0,
+ range_factor=2.0, optimal_length=None,
+ optimal_connections=None, optimal_depth=None):
+ """
+ Normaliza un valor considerando umbrales específicos por tipo de métrica.
+
+ Args:
+ value: Valor a normalizar
+ metric_type: Tipo de métrica ('vocabulary', 'structure', 'cohesion', 'clarity')
+ min_threshold: Valor mínimo aceptable
+ target_threshold: Valor objetivo
+ range_factor: Factor para ajustar el rango
+ optimal_length: Longitud óptima (opcional)
+ optimal_connections: Número óptimo de conexiones (opcional)
+ optimal_depth: Profundidad óptima de estructura (opcional)
+
+ Returns:
+ float: Valor normalizado entre 0 y 1
+ """
+ try:
+ # Definir umbrales por tipo de métrica
+ METRIC_THRESHOLDS = {
+ 'vocabulary': {
+ 'min': 0.60,
+ 'target': 0.75,
+ 'range_factor': 1.5
+ },
+ 'structure': {
+ 'min': 0.65,
+ 'target': 0.80,
+ 'range_factor': 1.8
+ },
+ 'cohesion': {
+ 'min': 0.55,
+ 'target': 0.70,
+ 'range_factor': 1.6
+ },
+ 'clarity': {
+ 'min': 0.60,
+ 'target': 0.75,
+ 'range_factor': 1.7
+ }
+ }
+
+ # Validar valores negativos o cero
+ if value < 0:
+ logger.warning(f"Valor negativo recibido: {value}")
+ return 0.0
+
+ # Manejar caso donde el valor es cero
+ if value == 0:
+ logger.warning("Valor cero recibido")
+ return 0.0
+
+ # Obtener umbrales específicos para el tipo de métrica
+ thresholds = METRIC_THRESHOLDS.get(metric_type, {
+ 'min': min_threshold,
+ 'target': target_threshold,
+ 'range_factor': range_factor
+ })
+
+ # Identificar el valor de referencia a usar
+ if optimal_depth is not None:
+ reference = optimal_depth
+ elif optimal_connections is not None:
+ reference = optimal_connections
+ elif optimal_length is not None:
+ reference = optimal_length
+ else:
+ reference = thresholds['target']
+
+ # Validar valor de referencia
+ if reference <= 0:
+ logger.warning(f"Valor de referencia inválido: {reference}")
+ return 0.0
+
+ # Calcular score basado en umbrales
+ if value < thresholds['min']:
+ # Valor por debajo del mínimo
+ score = (value / thresholds['min']) * 0.5 # Máximo 0.5 para valores bajo el mínimo
+ elif value < thresholds['target']:
+ # Valor entre mínimo y objetivo
+ range_size = thresholds['target'] - thresholds['min']
+ progress = (value - thresholds['min']) / range_size
+ score = 0.5 + (progress * 0.5) # Escala entre 0.5 y 1.0
+ else:
+ # Valor alcanza o supera el objetivo
+ score = 1.0
+
+ # Penalizar valores muy por encima del objetivo
+ if value > (thresholds['target'] * thresholds['range_factor']):
+ excess = (value - thresholds['target']) / (thresholds['target'] * thresholds['range_factor'])
+ score = max(0.7, 1.0 - excess) # No bajar de 0.7 para valores altos
+
+ # Asegurar que el resultado esté entre 0 y 1
+ return max(0.0, min(1.0, score))
+
+ except Exception as e:
+ logger.error(f"Error en normalize_score: {str(e)}")
+ return 0.0
+
+
+# Funciones de generación de gráficos
+def generate_sentence_graphs(doc):
+ """Genera visualizaciones de estructura de oraciones"""
+ fig, ax = plt.subplots(figsize=(10, 6))
+ # Implementar visualización
+ plt.close()
+ return fig
+
+def generate_word_connections(doc):
+ """Genera red de conexiones de palabras"""
+ fig, ax = plt.subplots(figsize=(10, 6))
+ # Implementar visualización
+ plt.close()
+ return fig
+
+def generate_connection_paths(doc):
+ """Genera patrones de conexión"""
+ fig, ax = plt.subplots(figsize=(10, 6))
+ # Implementar visualización
+ plt.close()
+ return fig
+
+def create_vocabulary_network(doc):
+ """
+ Genera el grafo de red de vocabulario.
+ """
+ G = nx.Graph()
+
+ # Crear nodos para palabras significativas
+ words = [token.text.lower() for token in doc if token.is_alpha and not token.is_stop]
+ word_freq = Counter(words)
+
+ # Añadir nodos con tamaño basado en frecuencia
+ for word, freq in word_freq.items():
+ G.add_node(word, size=freq)
+
+ # Crear conexiones basadas en co-ocurrencia
+ window_size = 5
+ for i in range(len(words) - window_size):
+ window = words[i:i+window_size]
+ for w1, w2 in combinations(set(window), 2):
+ if G.has_edge(w1, w2):
+ G[w1][w2]['weight'] += 1
+ else:
+ G.add_edge(w1, w2, weight=1)
+
+ # Crear visualización
+ fig, ax = plt.subplots(figsize=(12, 8))
+ pos = nx.spring_layout(G)
+
+ # Dibujar nodos
+ nx.draw_networkx_nodes(G, pos,
+ node_size=[G.nodes[node]['size']*100 for node in G.nodes],
+ node_color='lightblue',
+ alpha=0.7)
+
+ # Dibujar conexiones
+ nx.draw_networkx_edges(G, pos,
+ width=[G[u][v]['weight']*0.5 for u,v in G.edges],
+ alpha=0.5)
+
+ # Añadir etiquetas
+ nx.draw_networkx_labels(G, pos)
+
+ plt.title("Red de Vocabulario")
+ plt.axis('off')
+ return fig
+
+def create_syntax_complexity_graph(doc):
+ """
+ Genera el diagrama de arco de complejidad sintáctica.
+ Muestra la estructura de dependencias con colores basados en la complejidad.
+ """
+ try:
+ # Preparar datos para la visualización
+ sentences = list(doc.sents)
+ if not sentences:
+ return None
+
+ # Crear figura para el gráfico
+ fig, ax = plt.subplots(figsize=(12, len(sentences) * 2))
+
+ # Colores para diferentes niveles de profundidad
+ depth_colors = plt.cm.viridis(np.linspace(0, 1, 6))
+
+ y_offset = 0
+ max_x = 0
+
+ for sent in sentences:
+ words = [token.text for token in sent]
+ x_positions = range(len(words))
+ max_x = max(max_x, len(words))
+
+ # Dibujar palabras
+ plt.plot(x_positions, [y_offset] * len(words), 'k-', alpha=0.2)
+ plt.scatter(x_positions, [y_offset] * len(words), alpha=0)
+
+ # Añadir texto
+ for i, word in enumerate(words):
+ plt.annotate(word, (i, y_offset), xytext=(0, -10),
+ textcoords='offset points', ha='center')
+
+ # Dibujar arcos de dependencia
+ for token in sent:
+ if token.dep_ != "ROOT":
+ # Calcular profundidad de dependencia
+ depth = 0
+ current = token
+ while current.head != current:
+ depth += 1
+ current = current.head
+
+ # Determinar posiciones para el arco
+ start = token.i - sent[0].i
+ end = token.head.i - sent[0].i
+
+ # Altura del arco basada en la distancia entre palabras
+ height = 0.5 * abs(end - start)
+
+ # Color basado en la profundidad
+ color = depth_colors[min(depth, len(depth_colors)-1)]
+
+ # Crear arco
+ arc = patches.Arc((min(start, end) + abs(end - start)/2, y_offset),
+ width=abs(end - start),
+ height=height,
+ angle=0,
+ theta1=0,
+ theta2=180,
+ color=color,
+ alpha=0.6)
+ ax.add_patch(arc)
+
+ y_offset -= 2
+
+ # Configurar el gráfico
+ plt.xlim(-1, max_x)
+ plt.ylim(y_offset - 1, 1)
+ plt.axis('off')
+ plt.title("Complejidad Sintáctica")
+
+ return fig
+
+ except Exception as e:
+ logger.error(f"Error en create_syntax_complexity_graph: {str(e)}")
+ return None
+
+
+def create_cohesion_heatmap(doc):
+ """Genera un mapa de calor que muestra la cohesión entre párrafos/oraciones."""
+ try:
+ sentences = list(doc.sents)
+ n_sentences = len(sentences)
+
+ if n_sentences < 2:
+ return None
+
+ similarity_matrix = np.zeros((n_sentences, n_sentences))
+
+ for i in range(n_sentences):
+ for j in range(n_sentences):
+ sent1_lemmas = {token.lemma_ for token in sentences[i]
+ if token.is_alpha and not token.is_stop}
+ sent2_lemmas = {token.lemma_ for token in sentences[j]
+ if token.is_alpha and not token.is_stop}
+
+ if sent1_lemmas and sent2_lemmas:
+ intersection = len(sent1_lemmas & sent2_lemmas) # Corregido aquí
+ union = len(sent1_lemmas | sent2_lemmas) # Y aquí
+ similarity_matrix[i, j] = intersection / union if union > 0 else 0
+
+ # Crear visualización
+ fig, ax = plt.subplots(figsize=(10, 8))
+
+ sns.heatmap(similarity_matrix,
+ cmap='YlOrRd',
+ square=True,
+ xticklabels=False,
+ yticklabels=False,
+ cbar_kws={'label': 'Cohesión'},
+ ax=ax)
+
+ plt.title("Mapa de Cohesión Textual")
+ plt.xlabel("Oraciones")
+ plt.ylabel("Oraciones")
+
+ plt.tight_layout()
+ return fig
+
+ except Exception as e:
+ logger.error(f"Error en create_cohesion_heatmap: {str(e)}")
+ return None
diff --git a/src/modules/studentact/current_situation_analysis.py b/src/modules/studentact/current_situation_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..bed8c89f985243da6b00f2a1f8319448a0017f16
--- /dev/null
+++ b/src/modules/studentact/current_situation_analysis.py
@@ -0,0 +1,1009 @@
+#v3/modules/studentact/current_situation_analysis.py
+
+import streamlit as st
+import matplotlib.pyplot as plt
+import networkx as nx
+import seaborn as sns
+from collections import Counter
+from itertools import combinations
+import numpy as np
+import matplotlib.patches as patches
+import logging
+
+
+# 2. Configuración básica del logging
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[
+ logging.StreamHandler(),
+ logging.FileHandler('app.log')
+ ]
+)
+
+# 3. Obtener el logger específico para este módulo
+logger = logging.getLogger(__name__)
+
+#########################################################################
+
+def correlate_metrics(scores):
+ """
+ Ajusta los scores para mantener correlaciones lógicas entre métricas.
+
+ Args:
+ scores: dict con scores iniciales de vocabulario, estructura, cohesión y claridad
+
+ Returns:
+ dict con scores ajustados
+ """
+ try:
+ # 1. Correlación estructura-cohesión
+ # La cohesión no puede ser menor que estructura * 0.7
+ min_cohesion = scores['structure']['normalized_score'] * 0.7
+ if scores['cohesion']['normalized_score'] < min_cohesion:
+ scores['cohesion']['normalized_score'] = min_cohesion
+
+ # 2. Correlación vocabulario-cohesión
+ # La cohesión léxica depende del vocabulario
+ vocab_influence = scores['vocabulary']['normalized_score'] * 0.6
+ scores['cohesion']['normalized_score'] = max(
+ scores['cohesion']['normalized_score'],
+ vocab_influence
+ )
+
+ # 3. Correlación cohesión-claridad
+ # La claridad no puede superar cohesión * 1.2
+ max_clarity = scores['cohesion']['normalized_score'] * 1.2
+ if scores['clarity']['normalized_score'] > max_clarity:
+ scores['clarity']['normalized_score'] = max_clarity
+
+ # 4. Correlación estructura-claridad
+ # La claridad no puede superar estructura * 1.1
+ struct_max_clarity = scores['structure']['normalized_score'] * 1.1
+ scores['clarity']['normalized_score'] = min(
+ scores['clarity']['normalized_score'],
+ struct_max_clarity
+ )
+
+ # Normalizar todos los scores entre 0 y 1
+ for metric in scores:
+ scores[metric]['normalized_score'] = max(0.0, min(1.0, scores[metric]['normalized_score']))
+
+ return scores
+
+ except Exception as e:
+ logger.error(f"Error en correlate_metrics: {str(e)}")
+ return scores
+
+##########################################################################
+
+def analyze_text_dimensions(doc):
+ """
+ Analiza las dimensiones principales del texto manteniendo correlaciones lógicas.
+ """
+ try:
+ # Obtener scores iniciales
+ vocab_score, vocab_details = analyze_vocabulary_diversity(doc)
+ struct_score = analyze_structure(doc)
+ cohesion_score = analyze_cohesion(doc)
+ clarity_score, clarity_details = analyze_clarity(doc)
+
+ # Crear diccionario de scores inicial
+ scores = {
+ 'vocabulary': {
+ 'normalized_score': vocab_score,
+ 'details': vocab_details
+ },
+ 'structure': {
+ 'normalized_score': struct_score,
+ 'details': None
+ },
+ 'cohesion': {
+ 'normalized_score': cohesion_score,
+ 'details': None
+ },
+ 'clarity': {
+ 'normalized_score': clarity_score,
+ 'details': clarity_details
+ }
+ }
+
+ # Ajustar correlaciones entre métricas
+ adjusted_scores = correlate_metrics(scores)
+
+ # Logging para diagnóstico
+ logger.info(f"""
+ Scores originales vs ajustados:
+ Vocabulario: {vocab_score:.2f} -> {adjusted_scores['vocabulary']['normalized_score']:.2f}
+ Estructura: {struct_score:.2f} -> {adjusted_scores['structure']['normalized_score']:.2f}
+ Cohesión: {cohesion_score:.2f} -> {adjusted_scores['cohesion']['normalized_score']:.2f}
+ Claridad: {clarity_score:.2f} -> {adjusted_scores['clarity']['normalized_score']:.2f}
+ """)
+
+ return adjusted_scores
+
+ except Exception as e:
+ logger.error(f"Error en analyze_text_dimensions: {str(e)}")
+ return {
+ 'vocabulary': {'normalized_score': 0.0, 'details': {}},
+ 'structure': {'normalized_score': 0.0, 'details': {}},
+ 'cohesion': {'normalized_score': 0.0, 'details': {}},
+ 'clarity': {'normalized_score': 0.0, 'details': {}}
+ }
+
+
+
+#############################################################################################
+
+def analyze_clarity(doc):
+ """
+ Analiza la claridad del texto considerando múltiples factores.
+ """
+ try:
+ sentences = list(doc.sents)
+ if not sentences:
+ return 0.0, {}
+
+ # 1. Longitud de oraciones
+ sentence_lengths = [len(sent) for sent in sentences]
+ avg_length = sum(sentence_lengths) / len(sentences)
+
+ # Normalizar usando los umbrales definidos para clarity
+ length_score = normalize_score(
+ value=avg_length,
+ metric_type='clarity',
+ optimal_length=20, # Una oración ideal tiene ~20 palabras
+ min_threshold=0.60, # Consistente con METRIC_THRESHOLDS
+ target_threshold=0.75 # Consistente con METRIC_THRESHOLDS
+ )
+
+ # 2. Análisis de conectores
+ connector_count = 0
+ connector_weights = {
+ 'CCONJ': 1.0, # Coordinantes
+ 'SCONJ': 1.2, # Subordinantes
+ 'ADV': 0.8 # Adverbios conectivos
+ }
+
+ for token in doc:
+ if token.pos_ in connector_weights and token.dep_ in ['cc', 'mark', 'advmod']:
+ connector_count += connector_weights[token.pos_]
+
+ # Normalizar conectores por oración
+ connectors_per_sentence = connector_count / len(sentences) if sentences else 0
+ connector_score = normalize_score(
+ value=connectors_per_sentence,
+ metric_type='clarity',
+ optimal_connections=1.5, # ~1.5 conectores por oración es óptimo
+ min_threshold=0.60,
+ target_threshold=0.75
+ )
+
+ # 3. Complejidad estructural
+ clause_count = 0
+ for sent in sentences:
+ verbs = [token for token in sent if token.pos_ == 'VERB']
+ clause_count += len(verbs)
+
+ complexity_raw = clause_count / len(sentences) if sentences else 0
+ complexity_score = normalize_score(
+ value=complexity_raw,
+ metric_type='clarity',
+ optimal_depth=2.0, # ~2 cláusulas por oración es óptimo
+ min_threshold=0.60,
+ target_threshold=0.75
+ )
+
+ # 4. Densidad léxica
+ content_words = len([token for token in doc if token.pos_ in ['NOUN', 'VERB', 'ADJ', 'ADV']])
+ total_words = len([token for token in doc if token.is_alpha])
+ density = content_words / total_words if total_words > 0 else 0
+
+ density_score = normalize_score(
+ value=density,
+ metric_type='clarity',
+ optimal_connections=0.6, # 60% de palabras de contenido es óptimo
+ min_threshold=0.60,
+ target_threshold=0.75
+ )
+
+ # Score final ponderado
+ weights = {
+ 'length': 0.3,
+ 'connectors': 0.3,
+ 'complexity': 0.2,
+ 'density': 0.2
+ }
+
+ clarity_score = (
+ weights['length'] * length_score +
+ weights['connectors'] * connector_score +
+ weights['complexity'] * complexity_score +
+ weights['density'] * density_score
+ )
+
+ details = {
+ 'length_score': length_score,
+ 'connector_score': connector_score,
+ 'complexity_score': complexity_score,
+ 'density_score': density_score,
+ 'avg_sentence_length': avg_length,
+ 'connectors_per_sentence': connectors_per_sentence,
+ 'density': density
+ }
+
+ # Agregar logging para diagnóstico
+ logger.info(f"""
+ Scores de Claridad:
+ - Longitud: {length_score:.2f} (avg={avg_length:.1f} palabras)
+ - Conectores: {connector_score:.2f} (avg={connectors_per_sentence:.1f} por oración)
+ - Complejidad: {complexity_score:.2f} (avg={complexity_raw:.1f} cláusulas)
+ - Densidad: {density_score:.2f} ({density*100:.1f}% palabras de contenido)
+ - Score Final: {clarity_score:.2f}
+ """)
+
+ return clarity_score, details
+
+ except Exception as e:
+ logger.error(f"Error en analyze_clarity: {str(e)}")
+ return 0.0, {}
+
+#########################################################################
+def analyze_vocabulary_diversity(doc):
+ """Análisis mejorado de la diversidad y calidad del vocabulario"""
+ try:
+ # 1. Análisis básico de diversidad
+ unique_lemmas = {token.lemma_ for token in doc if token.is_alpha}
+ total_words = len([token for token in doc if token.is_alpha])
+ basic_diversity = len(unique_lemmas) / total_words if total_words > 0 else 0
+
+ # 2. Análisis de registro
+ academic_words = 0
+ narrative_words = 0
+ technical_terms = 0
+
+ # Clasificar palabras por registro
+ for token in doc:
+ if token.is_alpha:
+ # Detectar términos académicos/técnicos
+ if token.pos_ in ['NOUN', 'VERB', 'ADJ']:
+ if any(parent.pos_ == 'NOUN' for parent in token.ancestors):
+ technical_terms += 1
+ # Detectar palabras narrativas
+ if token.pos_ in ['VERB', 'ADV'] and token.dep_ in ['ROOT', 'advcl']:
+ narrative_words += 1
+
+ # 3. Análisis de complejidad sintáctica
+ avg_sentence_length = sum(len(sent) for sent in doc.sents) / len(list(doc.sents))
+
+ # 4. Calcular score ponderado
+ weights = {
+ 'diversity': 0.3,
+ 'technical': 0.3,
+ 'narrative': 0.2,
+ 'complexity': 0.2
+ }
+
+ scores = {
+ 'diversity': basic_diversity,
+ 'technical': technical_terms / total_words if total_words > 0 else 0,
+ 'narrative': narrative_words / total_words if total_words > 0 else 0,
+ 'complexity': min(1.0, avg_sentence_length / 20) # Normalizado a 20 palabras
+ }
+
+ # Score final ponderado
+ final_score = sum(weights[key] * scores[key] for key in weights)
+
+ # Información adicional para diagnóstico
+ details = {
+ 'text_type': 'narrative' if scores['narrative'] > scores['technical'] else 'academic',
+ 'scores': scores
+ }
+
+ return final_score, details
+
+ except Exception as e:
+ logger.error(f"Error en analyze_vocabulary_diversity: {str(e)}")
+ return 0.0, {}
+
+#########################################################################
+def analyze_cohesion(doc):
+ """Analiza la cohesión textual"""
+ try:
+ sentences = list(doc.sents)
+ if len(sentences) < 2:
+ logger.warning("Texto demasiado corto para análisis de cohesión")
+ return 0.0
+
+ # 1. Análisis de conexiones léxicas
+ lexical_connections = 0
+ total_possible_connections = 0
+
+ for i in range(len(sentences)-1):
+ # Obtener lemmas significativos (no stopwords)
+ sent1_words = {token.lemma_ for token in sentences[i]
+ if token.is_alpha and not token.is_stop}
+ sent2_words = {token.lemma_ for token in sentences[i+1]
+ if token.is_alpha and not token.is_stop}
+
+ if sent1_words and sent2_words: # Verificar que ambos conjuntos no estén vacíos
+ intersection = len(sent1_words.intersection(sent2_words))
+ total_possible = min(len(sent1_words), len(sent2_words))
+
+ if total_possible > 0:
+ lexical_score = intersection / total_possible
+ lexical_connections += lexical_score
+ total_possible_connections += 1
+
+ # 2. Análisis de conectores
+ connector_count = 0
+ connector_types = {
+ 'CCONJ': 1.0, # Coordinantes
+ 'SCONJ': 1.2, # Subordinantes
+ 'ADV': 0.8 # Adverbios conectivos
+ }
+
+ for token in doc:
+ if (token.pos_ in connector_types and
+ token.dep_ in ['cc', 'mark', 'advmod'] and
+ not token.is_stop):
+ connector_count += connector_types[token.pos_]
+
+ # 3. Cálculo de scores normalizados
+ if total_possible_connections > 0:
+ lexical_cohesion = lexical_connections / total_possible_connections
+ else:
+ lexical_cohesion = 0
+
+ if len(sentences) > 1:
+ connector_cohesion = min(1.0, connector_count / (len(sentences) - 1))
+ else:
+ connector_cohesion = 0
+
+ # 4. Score final ponderado
+ weights = {
+ 'lexical': 0.7,
+ 'connectors': 0.3
+ }
+
+ cohesion_score = (
+ weights['lexical'] * lexical_cohesion +
+ weights['connectors'] * connector_cohesion
+ )
+
+ # 5. Logging para diagnóstico
+ logger.info(f"""
+ Análisis de Cohesión:
+ - Conexiones léxicas encontradas: {lexical_connections}
+ - Conexiones posibles: {total_possible_connections}
+ - Lexical cohesion score: {lexical_cohesion}
+ - Conectores encontrados: {connector_count}
+ - Connector cohesion score: {connector_cohesion}
+ - Score final: {cohesion_score}
+ """)
+
+ return cohesion_score
+
+ except Exception as e:
+ logger.error(f"Error en analyze_cohesion: {str(e)}")
+ return 0.0
+
+#########################################################################
+def analyze_structure(doc):
+ try:
+ if len(doc) == 0:
+ return 0.0
+
+ structure_scores = []
+ for token in doc:
+ if token.dep_ == 'ROOT':
+ result = get_dependency_depths(token)
+ structure_scores.append(result['final_score'])
+
+ if not structure_scores:
+ return 0.0
+
+ return min(1.0, sum(structure_scores) / len(structure_scores))
+
+ except Exception as e:
+ logger.error(f"Error en analyze_structure: {str(e)}")
+ return 0.0
+
+#########################################################################
+# Funciones auxiliares de análisis
+def get_dependency_depths(token, depth=0, analyzed_tokens=None):
+ """
+ Analiza la profundidad y calidad de las relaciones de dependencia.
+
+ Args:
+ token: Token a analizar
+ depth: Profundidad actual en el árbol
+ analyzed_tokens: Set para evitar ciclos en el análisis
+
+ Returns:
+ dict: Información detallada sobre las dependencias
+ - depths: Lista de profundidades
+ - relations: Diccionario con tipos de relaciones encontradas
+ - complexity_score: Puntuación de complejidad
+ """
+ if analyzed_tokens is None:
+ analyzed_tokens = set()
+
+ # Evitar ciclos
+ if token.i in analyzed_tokens:
+ return {
+ 'depths': [],
+ 'relations': {},
+ 'complexity_score': 0
+ }
+
+ analyzed_tokens.add(token.i)
+
+ # Pesos para diferentes tipos de dependencias
+ dependency_weights = {
+ # Dependencias principales
+ 'nsubj': 1.2, # Sujeto nominal
+ 'obj': 1.1, # Objeto directo
+ 'iobj': 1.1, # Objeto indirecto
+ 'ROOT': 1.3, # Raíz
+
+ # Modificadores
+ 'amod': 0.8, # Modificador adjetival
+ 'advmod': 0.8, # Modificador adverbial
+ 'nmod': 0.9, # Modificador nominal
+
+ # Estructuras complejas
+ 'csubj': 1.4, # Cláusula como sujeto
+ 'ccomp': 1.3, # Complemento clausal
+ 'xcomp': 1.2, # Complemento clausal abierto
+ 'advcl': 1.2, # Cláusula adverbial
+
+ # Coordinación y subordinación
+ 'conj': 1.1, # Conjunción
+ 'cc': 0.7, # Coordinación
+ 'mark': 0.8, # Marcador
+
+ # Otros
+ 'det': 0.5, # Determinante
+ 'case': 0.5, # Caso
+ 'punct': 0.1 # Puntuación
+ }
+
+ # Inicializar resultados
+ current_result = {
+ 'depths': [depth],
+ 'relations': {token.dep_: 1},
+ 'complexity_score': dependency_weights.get(token.dep_, 0.5) * (depth + 1)
+ }
+
+ # Analizar hijos recursivamente
+ for child in token.children:
+ child_result = get_dependency_depths(child, depth + 1, analyzed_tokens)
+
+ # Combinar profundidades
+ current_result['depths'].extend(child_result['depths'])
+
+ # Combinar relaciones
+ for rel, count in child_result['relations'].items():
+ current_result['relations'][rel] = current_result['relations'].get(rel, 0) + count
+
+ # Acumular score de complejidad
+ current_result['complexity_score'] += child_result['complexity_score']
+
+ # Calcular métricas adicionales
+ current_result['max_depth'] = max(current_result['depths'])
+ current_result['avg_depth'] = sum(current_result['depths']) / len(current_result['depths'])
+ current_result['relation_diversity'] = len(current_result['relations'])
+
+ # Calcular score ponderado por tipo de estructura
+ structure_bonus = 0
+
+ # Bonus por estructuras complejas
+ if 'csubj' in current_result['relations'] or 'ccomp' in current_result['relations']:
+ structure_bonus += 0.3
+
+ # Bonus por coordinación balanceada
+ if 'conj' in current_result['relations'] and 'cc' in current_result['relations']:
+ structure_bonus += 0.2
+
+ # Bonus por modificación rica
+ if len(set(['amod', 'advmod', 'nmod']) & set(current_result['relations'])) >= 2:
+ structure_bonus += 0.2
+
+ current_result['final_score'] = (
+ current_result['complexity_score'] * (1 + structure_bonus)
+ )
+
+ return current_result
+
+#########################################################################
+def normalize_score(value, metric_type,
+ min_threshold=0.0, target_threshold=1.0,
+ range_factor=2.0, optimal_length=None,
+ optimal_connections=None, optimal_depth=None):
+ """
+ Normaliza un valor considerando umbrales específicos por tipo de métrica.
+
+ Args:
+ value: Valor a normalizar
+ metric_type: Tipo de métrica ('vocabulary', 'structure', 'cohesion', 'clarity')
+ min_threshold: Valor mínimo aceptable
+ target_threshold: Valor objetivo
+ range_factor: Factor para ajustar el rango
+ optimal_length: Longitud óptima (opcional)
+ optimal_connections: Número óptimo de conexiones (opcional)
+ optimal_depth: Profundidad óptima de estructura (opcional)
+
+ Returns:
+ float: Valor normalizado entre 0 y 1
+ """
+ try:
+ # Definir umbrales por tipo de métrica
+ METRIC_THRESHOLDS = {
+ 'vocabulary': {
+ 'min': 0.60,
+ 'target': 0.75,
+ 'range_factor': 1.5
+ },
+ 'structure': {
+ 'min': 0.65,
+ 'target': 0.80,
+ 'range_factor': 1.8
+ },
+ 'cohesion': {
+ 'min': 0.55,
+ 'target': 0.70,
+ 'range_factor': 1.6
+ },
+ 'clarity': {
+ 'min': 0.60,
+ 'target': 0.75,
+ 'range_factor': 1.7
+ }
+ }
+
+ # Validar valores negativos o cero
+ if value < 0:
+ logger.warning(f"Valor negativo recibido: {value}")
+ return 0.0
+
+ # Manejar caso donde el valor es cero
+ if value == 0:
+ logger.warning("Valor cero recibido")
+ return 0.0
+
+ # Obtener umbrales específicos para el tipo de métrica
+ thresholds = METRIC_THRESHOLDS.get(metric_type, {
+ 'min': min_threshold,
+ 'target': target_threshold,
+ 'range_factor': range_factor
+ })
+
+ # Identificar el valor de referencia a usar
+ if optimal_depth is not None:
+ reference = optimal_depth
+ elif optimal_connections is not None:
+ reference = optimal_connections
+ elif optimal_length is not None:
+ reference = optimal_length
+ else:
+ reference = thresholds['target']
+
+ # Validar valor de referencia
+ if reference <= 0:
+ logger.warning(f"Valor de referencia inválido: {reference}")
+ return 0.0
+
+ # Calcular score basado en umbrales
+ if value < thresholds['min']:
+ # Valor por debajo del mínimo
+ score = (value / thresholds['min']) * 0.5 # Máximo 0.5 para valores bajo el mínimo
+ elif value < thresholds['target']:
+ # Valor entre mínimo y objetivo
+ range_size = thresholds['target'] - thresholds['min']
+ progress = (value - thresholds['min']) / range_size
+ score = 0.5 + (progress * 0.5) # Escala entre 0.5 y 1.0
+ else:
+ # Valor alcanza o supera el objetivo
+ score = 1.0
+
+ # Penalizar valores muy por encima del objetivo
+ if value > (thresholds['target'] * thresholds['range_factor']):
+ excess = (value - thresholds['target']) / (thresholds['target'] * thresholds['range_factor'])
+ score = max(0.7, 1.0 - excess) # No bajar de 0.7 para valores altos
+
+ # Asegurar que el resultado esté entre 0 y 1
+ return max(0.0, min(1.0, score))
+
+ except Exception as e:
+ logger.error(f"Error en normalize_score: {str(e)}")
+ return 0.0
+
+#########################################################################
+#########################################################################
+
+def generate_recommendations(metrics, text_type, lang_code='es'):
+ """
+ Genera recomendaciones personalizadas basadas en las métricas del texto y el tipo de texto.
+
+ Args:
+ metrics: Diccionario con las métricas analizadas
+ text_type: Tipo de texto ('academic_article', 'student_essay', 'general_communication')
+ lang_code: Código del idioma para las recomendaciones (es, en, uk)
+
+ Returns:
+ dict: Recomendaciones organizadas por categoría en el idioma correspondiente
+ """
+ try:
+ # Añadir debug log para verificar el código de idioma recibido
+ logger.info(f"generate_recommendations llamado con idioma: {lang_code}")
+
+ # Comprobar que importamos RECOMMENDATIONS correctamente
+ logger.info(f"Idiomas disponibles en RECOMMENDATIONS: {list(RECOMMENDATIONS.keys())}")
+
+ # Obtener umbrales según el tipo de texto
+ thresholds = TEXT_TYPES[text_type]['thresholds']
+
+ # Verificar que el idioma esté soportado, usar español como respaldo
+ if lang_code not in RECOMMENDATIONS:
+ logger.warning(f"Idioma {lang_code} no soportado para recomendaciones, usando español")
+ lang_code = 'es'
+
+ # Obtener traducciones para el idioma seleccionado
+ translations = RECOMMENDATIONS[lang_code]
+
+ # Inicializar diccionario de recomendaciones
+ recommendations = {
+ 'vocabulary': [],
+ 'structure': [],
+ 'cohesion': [],
+ 'clarity': [],
+ 'specific': [],
+ 'priority': {
+ 'area': 'general',
+ 'tips': []
+ },
+ 'text_type_name': translations['text_types'][text_type],
+ 'dimension_names': translations['dimension_names'],
+ 'ui_text': {
+ 'priority_intro': translations['priority_intro'],
+ 'detailed_recommendations': translations['detailed_recommendations'],
+ 'save_button': translations['save_button'],
+ 'save_success': translations['save_success'],
+ 'save_error': translations['save_error'],
+ 'area_priority': translations['area_priority']
+ }
+ }
+
+ # Determinar nivel para cada dimensión y asignar recomendaciones
+ dimensions = ['vocabulary', 'structure', 'cohesion', 'clarity']
+ scores = {}
+
+ for dim in dimensions:
+ score = metrics[dim]['normalized_score']
+ scores[dim] = score
+
+ # Determinar nivel (bajo, medio, alto)
+ if score < thresholds[dim]['min']:
+ level = 'low'
+ elif score < thresholds[dim]['target']:
+ level = 'medium'
+ else:
+ level = 'high'
+
+ # Asignar recomendaciones para ese nivel
+ recommendations[dim] = translations[dim][level]
+
+ # Asignar recomendaciones específicas por tipo de texto
+ recommendations['specific'] = translations[text_type]
+
+ # Determinar área prioritaria (la que tiene menor puntuación)
+ priority_dimension = min(scores, key=scores.get)
+ recommendations['priority']['area'] = priority_dimension
+ recommendations['priority']['tips'] = recommendations[priority_dimension]
+
+ logger.info(f"Generadas recomendaciones en {lang_code} para texto tipo {text_type}")
+ return recommendations
+
+ except Exception as e:
+ logger.error(f"Error en generate_recommendations: {str(e)}")
+
+ # Utilizar un enfoque basado en el idioma actual en lugar de casos codificados
+ # Esto permite manejar ucraniano y cualquier otro idioma futuro
+ fallback_translations = {
+ 'en': {
+ 'basic_recommendations': {
+ 'vocabulary': ["Try enriching your vocabulary"],
+ 'structure': ["Work on the structure of your sentences"],
+ 'cohesion': ["Improve the connection between your ideas"],
+ 'clarity': ["Try to express your ideas more clearly"],
+ 'specific': ["Adapt your text according to its purpose"],
+ },
+ 'dimension_names': {
+ 'vocabulary': 'Vocabulary',
+ 'structure': 'Structure',
+ 'cohesion': 'Cohesion',
+ 'clarity': 'Clarity',
+ 'general': 'General'
+ },
+ 'ui_text': {
+ 'priority_intro': "This is where you should focus your efforts.",
+ 'detailed_recommendations': "Detailed recommendations",
+ 'save_button': "Save analysis",
+ 'save_success': "Analysis saved successfully",
+ 'save_error': "Error saving analysis",
+ 'area_priority': "Priority area"
+ }
+ },
+ 'uk': {
+ 'basic_recommendations': {
+ 'vocabulary': ["Розширте свій словниковий запас"],
+ 'structure': ["Покращіть структуру ваших речень"],
+ 'cohesion': ["Покращіть зв'язок між вашими ідеями"],
+ 'clarity': ["Висловлюйте свої ідеї ясніше"],
+ 'specific': ["Адаптуйте свій текст відповідно до його мети"],
+ },
+ 'dimension_names': {
+ 'vocabulary': 'Словниковий запас',
+ 'structure': 'Структура',
+ 'cohesion': 'Зв\'язність',
+ 'clarity': 'Ясність',
+ 'general': 'Загальне'
+ },
+ 'ui_text': {
+ 'priority_intro': "Це область, де ви повинні зосередити свої зусилля.",
+ 'detailed_recommendations': "Детальні рекомендації",
+ 'save_button': "Зберегти аналіз",
+ 'save_success': "Аналіз успішно збережено",
+ 'save_error': "Помилка при збереженні аналізу",
+ 'area_priority': "Пріоритетна область"
+ }
+ },
+ 'es': {
+ 'basic_recommendations': {
+ 'vocabulary': ["Intenta enriquecer tu vocabulario"],
+ 'structure': ["Trabaja en la estructura de tus oraciones"],
+ 'cohesion': ["Mejora la conexión entre tus ideas"],
+ 'clarity': ["Busca expresar tus ideas con mayor claridad"],
+ 'specific': ["Adapta tu texto según su propósito"],
+ },
+ 'dimension_names': {
+ 'vocabulary': 'Vocabulario',
+ 'structure': 'Estructura',
+ 'cohesion': 'Cohesión',
+ 'clarity': 'Claridad',
+ 'general': 'General'
+ },
+ 'ui_text': {
+ 'priority_intro': "Esta es el área donde debes concentrar tus esfuerzos.",
+ 'detailed_recommendations': "Recomendaciones detalladas",
+ 'save_button': "Guardar análisis",
+ 'save_success': "Análisis guardado con éxito",
+ 'save_error': "Error al guardar el análisis",
+ 'area_priority': "Área prioritaria"
+ }
+ }
+ }
+
+ # Usar el idioma actual si está disponible, o inglés, o español como última opción
+ current_lang = fallback_translations.get(lang_code,
+ fallback_translations.get('en',
+ fallback_translations['es']))
+
+ basic_recommendations = current_lang['basic_recommendations']
+
+ return {
+ 'vocabulary': basic_recommendations['vocabulary'],
+ 'structure': basic_recommendations['structure'],
+ 'cohesion': basic_recommendations['cohesion'],
+ 'clarity': basic_recommendations['clarity'],
+ 'specific': basic_recommendations['specific'],
+ 'priority': {
+ 'area': 'general',
+ 'tips': ["Busca retroalimentación específica de un tutor o profesor"]
+ },
+ 'dimension_names': current_lang['dimension_names'],
+ 'ui_text': current_lang['ui_text']
+ }
+
+
+
+
+#########################################################################
+#########################################################################
+# Funciones de generación de gráficos
+def generate_sentence_graphs(doc):
+ """Genera visualizaciones de estructura de oraciones"""
+ fig, ax = plt.subplots(figsize=(10, 6))
+ # Implementar visualización
+ plt.close()
+ return fig
+
+############################################################################
+def generate_word_connections(doc):
+ """Genera red de conexiones de palabras"""
+ fig, ax = plt.subplots(figsize=(10, 6))
+ # Implementar visualización
+ plt.close()
+ return fig
+
+############################################################################
+def generate_connection_paths(doc):
+ """Genera patrones de conexión"""
+ fig, ax = plt.subplots(figsize=(10, 6))
+ # Implementar visualización
+ plt.close()
+ return fig
+
+############################################################################
+def create_vocabulary_network(doc):
+ """
+ Genera el grafo de red de vocabulario.
+ """
+ G = nx.Graph()
+
+ # Crear nodos para palabras significativas
+ words = [token.text.lower() for token in doc if token.is_alpha and not token.is_stop]
+ word_freq = Counter(words)
+
+ # Añadir nodos con tamaño basado en frecuencia
+ for word, freq in word_freq.items():
+ G.add_node(word, size=freq)
+
+ # Crear conexiones basadas en co-ocurrencia
+ window_size = 5
+ for i in range(len(words) - window_size):
+ window = words[i:i+window_size]
+ for w1, w2 in combinations(set(window), 2):
+ if G.has_edge(w1, w2):
+ G[w1][w2]['weight'] += 1
+ else:
+ G.add_edge(w1, w2, weight=1)
+
+ # Crear visualización
+ fig, ax = plt.subplots(figsize=(12, 8))
+ pos = nx.spring_layout(G)
+
+ # Dibujar nodos
+ nx.draw_networkx_nodes(G, pos,
+ node_size=[G.nodes[node]['size']*100 for node in G.nodes],
+ node_color='lightblue',
+ alpha=0.7)
+
+ # Dibujar conexiones
+ nx.draw_networkx_edges(G, pos,
+ width=[G[u][v]['weight']*0.5 for u,v in G.edges],
+ alpha=0.5)
+
+ # Añadir etiquetas
+ nx.draw_networkx_labels(G, pos)
+
+ plt.title("Red de Vocabulario")
+ plt.axis('off')
+ return fig
+
+############################################################################
+def create_syntax_complexity_graph(doc):
+ """
+ Genera el diagrama de arco de complejidad sintáctica.
+ Muestra la estructura de dependencias con colores basados en la complejidad.
+ """
+ try:
+ # Preparar datos para la visualización
+ sentences = list(doc.sents)
+ if not sentences:
+ return None
+
+ # Crear figura para el gráfico
+ fig, ax = plt.subplots(figsize=(12, len(sentences) * 2))
+
+ # Colores para diferentes niveles de profundidad
+ depth_colors = plt.cm.viridis(np.linspace(0, 1, 6))
+
+ y_offset = 0
+ max_x = 0
+
+ for sent in sentences:
+ words = [token.text for token in sent]
+ x_positions = range(len(words))
+ max_x = max(max_x, len(words))
+
+ # Dibujar palabras
+ plt.plot(x_positions, [y_offset] * len(words), 'k-', alpha=0.2)
+ plt.scatter(x_positions, [y_offset] * len(words), alpha=0)
+
+ # Añadir texto
+ for i, word in enumerate(words):
+ plt.annotate(word, (i, y_offset), xytext=(0, -10),
+ textcoords='offset points', ha='center')
+
+ # Dibujar arcos de dependencia
+ for token in sent:
+ if token.dep_ != "ROOT":
+ # Calcular profundidad de dependencia
+ depth = 0
+ current = token
+ while current.head != current:
+ depth += 1
+ current = current.head
+
+ # Determinar posiciones para el arco
+ start = token.i - sent[0].i
+ end = token.head.i - sent[0].i
+
+ # Altura del arco basada en la distancia entre palabras
+ height = 0.5 * abs(end - start)
+
+ # Color basado en la profundidad
+ color = depth_colors[min(depth, len(depth_colors)-1)]
+
+ # Crear arco
+ arc = patches.Arc((min(start, end) + abs(end - start)/2, y_offset),
+ width=abs(end - start),
+ height=height,
+ angle=0,
+ theta1=0,
+ theta2=180,
+ color=color,
+ alpha=0.6)
+ ax.add_patch(arc)
+
+ y_offset -= 2
+
+ # Configurar el gráfico
+ plt.xlim(-1, max_x)
+ plt.ylim(y_offset - 1, 1)
+ plt.axis('off')
+ plt.title("Complejidad Sintáctica")
+
+ return fig
+
+ except Exception as e:
+ logger.error(f"Error en create_syntax_complexity_graph: {str(e)}")
+ return None
+
+############################################################################
+def create_cohesion_heatmap(doc):
+ """Genera un mapa de calor que muestra la cohesión entre párrafos/oraciones."""
+ try:
+ sentences = list(doc.sents)
+ n_sentences = len(sentences)
+
+ if n_sentences < 2:
+ return None
+
+ similarity_matrix = np.zeros((n_sentences, n_sentences))
+
+ for i in range(n_sentences):
+ for j in range(n_sentences):
+ sent1_lemmas = {token.lemma_ for token in sentences[i]
+ if token.is_alpha and not token.is_stop}
+ sent2_lemmas = {token.lemma_ for token in sentences[j]
+ if token.is_alpha and not token.is_stop}
+
+ if sent1_lemmas and sent2_lemmas:
+ intersection = len(sent1_lemmas & sent2_lemmas) # Corregido aquí
+ union = len(sent1_lemmas | sent2_lemmas) # Y aquí
+ similarity_matrix[i, j] = intersection / union if union > 0 else 0
+
+ # Crear visualización
+ fig, ax = plt.subplots(figsize=(10, 8))
+
+ sns.heatmap(similarity_matrix,
+ cmap='YlOrRd',
+ square=True,
+ xticklabels=False,
+ yticklabels=False,
+ cbar_kws={'label': 'Cohesión'},
+ ax=ax)
+
+ plt.title("Mapa de Cohesión Textual")
+ plt.xlabel("Oraciones")
+ plt.ylabel("Oraciones")
+
+ plt.tight_layout()
+ return fig
+
+ except Exception as e:
+ logger.error(f"Error en create_cohesion_heatmap: {str(e)}")
+ return None
diff --git a/src/modules/studentact/current_situation_interface--FAIL.py b/src/modules/studentact/current_situation_interface--FAIL.py
new file mode 100644
index 0000000000000000000000000000000000000000..cae6e5be1412c8006108b6c8c77719bd5d684e63
--- /dev/null
+++ b/src/modules/studentact/current_situation_interface--FAIL.py
@@ -0,0 +1,608 @@
+# modules/studentact/current_situation_interface.py
+
+import streamlit as st
+import logging
+from ..utils.widget_utils import generate_unique_key
+import matplotlib.pyplot as plt
+import numpy as np
+
+from ..database.current_situation_mongo_db import store_current_situation_result
+
+from ..database.writing_progress_mongo_db import (
+ store_writing_baseline,
+ store_writing_progress,
+ get_writing_baseline,
+ get_writing_progress,
+ get_latest_writing_metrics
+)
+
+from .current_situation_analysis import (
+ analyze_text_dimensions,
+ analyze_clarity,
+ analyze_vocabulary_diversity,
+ analyze_cohesion,
+ analyze_structure,
+ get_dependency_depths,
+ normalize_score,
+ generate_sentence_graphs,
+ generate_word_connections,
+ generate_connection_paths,
+ create_vocabulary_network,
+ create_syntax_complexity_graph,
+ create_cohesion_heatmap
+)
+
+# Configuración del estilo de matplotlib para el gráfico de radar
+plt.rcParams['font.family'] = 'sans-serif'
+plt.rcParams['axes.grid'] = True
+plt.rcParams['axes.spines.top'] = False
+plt.rcParams['axes.spines.right'] = False
+
+logger = logging.getLogger(__name__)
+####################################
+
+TEXT_TYPES = {
+ 'academic_article': {
+ 'name': 'Artículo Académico',
+ 'thresholds': {
+ 'vocabulary': {'min': 0.70, 'target': 0.85},
+ 'structure': {'min': 0.75, 'target': 0.90},
+ 'cohesion': {'min': 0.65, 'target': 0.80},
+ 'clarity': {'min': 0.70, 'target': 0.85}
+ }
+ },
+ 'student_essay': {
+ 'name': 'Trabajo Universitario',
+ 'thresholds': {
+ 'vocabulary': {'min': 0.60, 'target': 0.75},
+ 'structure': {'min': 0.65, 'target': 0.80},
+ 'cohesion': {'min': 0.55, 'target': 0.70},
+ 'clarity': {'min': 0.60, 'target': 0.75}
+ }
+ },
+ 'general_communication': {
+ 'name': 'Comunicación General',
+ 'thresholds': {
+ 'vocabulary': {'min': 0.50, 'target': 0.65},
+ 'structure': {'min': 0.55, 'target': 0.70},
+ 'cohesion': {'min': 0.45, 'target': 0.60},
+ 'clarity': {'min': 0.50, 'target': 0.65}
+ }
+ }
+}
+####################################
+
+ANALYSIS_DIMENSION_MAPPING = {
+ 'morphosyntactic': {
+ 'primary': ['vocabulary', 'clarity'],
+ 'secondary': ['structure'],
+ 'tools': ['arc_diagrams', 'word_repetition']
+ },
+ 'semantic': {
+ 'primary': ['cohesion', 'structure'],
+ 'secondary': ['vocabulary'],
+ 'tools': ['concept_graphs', 'semantic_networks']
+ },
+ 'discourse': {
+ 'primary': ['cohesion', 'structure'],
+ 'secondary': ['clarity'],
+ 'tools': ['comparative_analysis']
+ }
+}
+
+##############################################################################
+# FUNCIÓN PRINCIPAL
+##############################################################################
+def display_current_situation_interface(lang_code, nlp_models, t):
+ """
+ TAB:
+ - Expander con radio para tipo de texto
+ Contenedor-1 con expanders:
+ - Expander "Métricas de la línea base"
+ - Expander "Métricas de la iteración"
+ Contenedor-2 (2 columnas):
+ - Col1: Texto base
+ - Col2: Texto iteración
+ Al final, Recomendaciones en un expander (una sola “fila”).
+ """
+
+ # --- Inicializar session_state ---
+ if 'base_text' not in st.session_state:
+ st.session_state.base_text = ""
+ if 'iter_text' not in st.session_state:
+ st.session_state.iter_text = ""
+ if 'base_metrics' not in st.session_state:
+ st.session_state.base_metrics = {}
+ if 'iter_metrics' not in st.session_state:
+ st.session_state.iter_metrics = {}
+ if 'show_base' not in st.session_state:
+ st.session_state.show_base = False
+ if 'show_iter' not in st.session_state:
+ st.session_state.show_iter = False
+
+ # Creamos un tab
+ tabs = st.tabs(["Análisis de Texto"])
+ with tabs[0]:
+ # [1] Expander con radio para seleccionar tipo de texto
+ with st.expander("Selecciona el tipo de texto", expanded=True):
+ text_type = st.radio(
+ "¿Qué tipo de texto quieres analizar?",
+ options=list(TEXT_TYPES.keys()),
+ format_func=lambda x: TEXT_TYPES[x]['name'],
+ index=0
+ )
+ st.session_state.current_text_type = text_type
+
+ st.markdown("---")
+
+ # ---------------------------------------------------------------------
+ # CONTENEDOR-1: Expanders para métricas base e iteración
+ # ---------------------------------------------------------------------
+ with st.container():
+ # --- Expander para la línea base ---
+ with st.expander("Métricas de la línea base", expanded=False):
+ if st.session_state.show_base and st.session_state.base_metrics:
+ # Mostramos los valores reales
+ display_metrics_in_one_row(st.session_state.base_metrics, text_type)
+ else:
+ # Mostramos la maqueta vacía
+ display_empty_metrics_row()
+
+ # --- Expander para la iteración ---
+ with st.expander("Métricas de la iteración", expanded=False):
+ if st.session_state.show_iter and st.session_state.iter_metrics:
+ display_metrics_in_one_row(st.session_state.iter_metrics, text_type)
+ else:
+ display_empty_metrics_row()
+
+ st.markdown("---")
+
+ # ---------------------------------------------------------------------
+ # CONTENEDOR-2: 2 columnas (texto base | texto iteración)
+ # ---------------------------------------------------------------------
+ with st.container():
+ col_left, col_right = st.columns(2)
+
+ # Columna izquierda: Texto base
+ with col_left:
+ st.markdown("**Texto base**")
+ text_base = st.text_area(
+ label="",
+ value=st.session_state.base_text,
+ key="text_base_area",
+ placeholder="Pega aquí tu texto base",
+ )
+ if st.button("Analizar Base"):
+ with st.spinner("Analizando texto base..."):
+ doc = nlp_models[lang_code](text_base)
+ metrics = analyze_text_dimensions(doc)
+
+ st.session_state.base_text = text_base
+ st.session_state.base_metrics = metrics
+ st.session_state.show_base = True
+ # Al analizar base, reiniciamos la iteración
+ st.session_state.show_iter = False
+
+ # Columna derecha: Texto iteración
+ with col_right:
+ st.markdown("**Texto de iteración**")
+ text_iter = st.text_area(
+ label="",
+ value=st.session_state.iter_text,
+ key="text_iter_area",
+ placeholder="Edita y mejora tu texto...",
+ disabled=not st.session_state.show_base
+ )
+ if st.button("Analizar Iteración", disabled=not st.session_state.show_base):
+ with st.spinner("Analizando iteración..."):
+ doc = nlp_models[lang_code](text_iter)
+ metrics = analyze_text_dimensions(doc)
+
+ st.session_state.iter_text = text_iter
+ st.session_state.iter_metrics = metrics
+ st.session_state.show_iter = True
+
+ # ---------------------------------------------------------------------
+ # Recomendaciones al final en un expander (una sola “fila”)
+ # ---------------------------------------------------------------------
+ if st.session_state.show_iter:
+ with st.expander("Recomendaciones", expanded=False):
+ reco_list = []
+ for dimension, values in st.session_state.iter_metrics.items():
+ score = values['normalized_score']
+ target = TEXT_TYPES[text_type]['thresholds'][dimension]['target']
+ if score < target:
+ # Aquí, en lugar de get_dimension_suggestions, unificamos con:
+ suggestions = suggest_improvement_tools_list(dimension)
+ reco_list.extend(suggestions)
+
+ if reco_list:
+ # Todas en una sola línea
+ st.write(" | ".join(reco_list))
+ else:
+ st.info("¡No hay recomendaciones! Todas las métricas superan la meta.")
+
+
+
+
+
+
+
+#Funciones de visualización ##################################
+############################################################
+# Funciones de visualización para las métricas
+############################################################
+
+def display_metrics_in_one_row(metrics, text_type):
+ """
+ Muestra las cuatro dimensiones (Vocabulario, Estructura, Cohesión, Claridad)
+ en una sola línea, usando 4 columnas con ancho uniforme.
+ """
+ thresholds = TEXT_TYPES[text_type]['thresholds']
+ dimensions = ["vocabulary", "structure", "cohesion", "clarity"]
+
+ col1, col2, col3, col4 = st.columns([1,1,1,1])
+ cols = [col1, col2, col3, col4]
+
+ for dim, col in zip(dimensions, cols):
+ score = metrics[dim]['normalized_score']
+ target = thresholds[dim]['target']
+ min_val = thresholds[dim]['min']
+
+ if score < min_val:
+ status = "⚠️ Por mejorar"
+ color = "inverse"
+ elif score < target:
+ status = "📈 Aceptable"
+ color = "off"
+ else:
+ status = "✅ Óptimo"
+ color = "normal"
+
+ with col:
+ col.metric(
+ label=dim.capitalize(),
+ value=f"{score:.2f}",
+ delta=f"{status} (Meta: {target:.2f})",
+ delta_color=color,
+ border=True
+ )
+
+
+# -------------------------------------------------------------------------
+# Función que muestra una fila de 4 columnas “vacías”
+# -------------------------------------------------------------------------
+def display_empty_metrics_row():
+ """
+ Muestra una fila de 4 columnas vacías (Vocabulario, Estructura, Cohesión, Claridad).
+ Cada columna se dibuja con st.metric en blanco (“-”).
+ """
+ empty_cols = st.columns([1,1,1,1])
+ labels = ["Vocabulario", "Estructura", "Cohesión", "Claridad"]
+
+ for col, lbl in zip(empty_cols, labels):
+ with col:
+ col.metric(
+ label=lbl,
+ value="-",
+ delta="",
+ border=True
+ )
+
+
+
+####################################################################
+
+def display_metrics_analysis(metrics, text_type=None):
+ """
+ Muestra los resultados del análisis: métricas verticalmente y gráfico radar.
+ """
+ try:
+ # Usar valor por defecto si no se especifica tipo
+ text_type = text_type or 'student_essay'
+
+ # Obtener umbrales según el tipo de texto
+ thresholds = TEXT_TYPES[text_type]['thresholds']
+
+ # Crear dos columnas para las métricas y el gráfico
+ metrics_col, graph_col = st.columns([1, 1.5])
+
+ # Columna de métricas
+ with metrics_col:
+ metrics_config = [
+ {
+ 'label': "Vocabulario",
+ 'key': 'vocabulary',
+ 'value': metrics['vocabulary']['normalized_score'],
+ 'help': "Riqueza y variedad del vocabulario",
+ 'thresholds': thresholds['vocabulary']
+ },
+ {
+ 'label': "Estructura",
+ 'key': 'structure',
+ 'value': metrics['structure']['normalized_score'],
+ 'help': "Organización y complejidad de oraciones",
+ 'thresholds': thresholds['structure']
+ },
+ {
+ 'label': "Cohesión",
+ 'key': 'cohesion',
+ 'value': metrics['cohesion']['normalized_score'],
+ 'help': "Conexión y fluidez entre ideas",
+ 'thresholds': thresholds['cohesion']
+ },
+ {
+ 'label': "Claridad",
+ 'key': 'clarity',
+ 'value': metrics['clarity']['normalized_score'],
+ 'help': "Facilidad de comprensión del texto",
+ 'thresholds': thresholds['clarity']
+ }
+ ]
+
+ # Mostrar métricas
+ for metric in metrics_config:
+ value = metric['value']
+ if value < metric['thresholds']['min']:
+ status = "⚠️ Por mejorar"
+ color = "inverse"
+ elif value < metric['thresholds']['target']:
+ status = "📈 Aceptable"
+ color = "off"
+ else:
+ status = "✅ Óptimo"
+ color = "normal"
+
+ st.metric(
+ metric['label'],
+ f"{value:.2f}",
+ f"{status} (Meta: {metric['thresholds']['target']:.2f})",
+ delta_color=color,
+ help=metric['help']
+ )
+ st.markdown("", unsafe_allow_html=True)
+
+ except Exception as e:
+ logger.error(f"Error mostrando resultados: {str(e)}")
+ st.error("Error al mostrar los resultados")
+
+def display_comparison_results(baseline_metrics, current_metrics):
+ """Muestra comparación entre línea base y métricas actuales"""
+
+ # Crear columnas para métricas y gráfico
+ metrics_col, graph_col = st.columns([1, 1.5])
+
+ with metrics_col:
+ for dimension in ['vocabulary', 'structure', 'cohesion', 'clarity']:
+ baseline = baseline_metrics[dimension]['normalized_score']
+ current = current_metrics[dimension]['normalized_score']
+ delta = current - baseline
+
+ st.metric(
+ dimension.title(),
+ f"{current:.2f}",
+ f"{delta:+.2f}",
+ delta_color="normal" if delta >= 0 else "inverse"
+ )
+
+ # Sugerir herramientas de mejora
+ if delta < 0:
+ suggest_improvement_tools(dimension)
+
+ with graph_col:
+ display_radar_chart_comparison(
+ baseline_metrics,
+ current_metrics
+ )
+
+def display_metrics_and_suggestions(metrics, text_type, title, show_suggestions=False):
+ """
+ Muestra métricas y opcionalmente sugerencias de mejora.
+ Args:
+ metrics: Diccionario con las métricas analizadas
+ text_type: Tipo de texto seleccionado
+ title: Título para las métricas ("Base" o "Iteración")
+ show_suggestions: Booleano para mostrar sugerencias
+ """
+ try:
+ thresholds = TEXT_TYPES[text_type]['thresholds']
+
+ st.markdown(f"### Métricas {title}")
+
+ for dimension, values in metrics.items():
+ score = values['normalized_score']
+ target = thresholds[dimension]['target']
+ min_val = thresholds[dimension]['min']
+
+ # Determinar estado y color
+ if score < min_val:
+ status = "⚠️ Por mejorar"
+ color = "inverse"
+ elif score < target:
+ status = "📈 Aceptable"
+ color = "off"
+ else:
+ status = "✅ Óptimo"
+ color = "normal"
+
+ # Mostrar métrica
+ st.metric(
+ dimension.title(),
+ f"{score:.2f}",
+ f"{status} (Meta: {target:.2f})",
+ delta_color=color,
+ help=f"Meta: {target:.2f}, Mínimo: {min_val:.2f}"
+ )
+
+ # Mostrar sugerencias si es necesario
+ if show_suggestions and score < target:
+ suggest_improvement_tools(dimension)
+
+ # Agregar espacio entre métricas
+ st.markdown("", unsafe_allow_html=True)
+
+ except Exception as e:
+ logger.error(f"Error mostrando métricas: {str(e)}")
+ st.error("Error al mostrar métricas")
+
+def display_radar_chart(metrics_config, thresholds, baseline_metrics=None):
+ """
+ Muestra el gráfico radar con los resultados.
+ Args:
+ metrics_config: Configuración actual de métricas
+ thresholds: Umbrales para las métricas
+ baseline_metrics: Métricas de línea base (opcional)
+ """
+ try:
+ # Preparar datos para el gráfico
+ categories = [m['label'] for m in metrics_config]
+ values_current = [m['value'] for m in metrics_config]
+ min_values = [m['thresholds']['min'] for m in metrics_config]
+ target_values = [m['thresholds']['target'] for m in metrics_config]
+
+ # Crear y configurar gráfico
+ fig = plt.figure(figsize=(8, 8))
+ ax = fig.add_subplot(111, projection='polar')
+
+ # Configurar radar
+ angles = [n / float(len(categories)) * 2 * np.pi for n in range(len(categories))]
+ angles += angles[:1]
+ values_current += values_current[:1]
+ min_values += min_values[:1]
+ target_values += target_values[:1]
+
+ # Configurar ejes
+ ax.set_xticks(angles[:-1])
+ ax.set_xticklabels(categories, fontsize=10)
+ circle_ticks = np.arange(0, 1.1, 0.2)
+ ax.set_yticks(circle_ticks)
+ ax.set_yticklabels([f'{tick:.1f}' for tick in circle_ticks], fontsize=8)
+ ax.set_ylim(0, 1)
+
+ # Dibujar áreas de umbrales
+ ax.plot(angles, min_values, '#e74c3c', linestyle='--', linewidth=1,
+ label='Mínimo', alpha=0.5)
+ ax.plot(angles, target_values, '#2ecc71', linestyle='--', linewidth=1,
+ label='Meta', alpha=0.5)
+ ax.fill_between(angles, target_values, [1]*len(angles),
+ color='#2ecc71', alpha=0.1)
+ ax.fill_between(angles, [0]*len(angles), min_values,
+ color='#e74c3c', alpha=0.1)
+
+ # Si hay línea base, dibujarla primero
+ if baseline_metrics is not None:
+ values_baseline = [baseline_metrics[m['key']]['normalized_score']
+ for m in metrics_config]
+ values_baseline += values_baseline[:1]
+ ax.plot(angles, values_baseline, '#888888', linewidth=2,
+ label='Línea base', linestyle='--')
+ ax.fill(angles, values_baseline, '#888888', alpha=0.1)
+
+ # Dibujar valores actuales
+ label = 'Actual' if baseline_metrics else 'Tu escritura'
+ color = '#3498db' if baseline_metrics else '#3498db'
+
+ ax.plot(angles, values_current, color, linewidth=2, label=label)
+ ax.fill(angles, values_current, color, alpha=0.2)
+
+ # Ajustar leyenda
+ legend_handles = []
+ if baseline_metrics:
+ legend_handles.extend([
+ plt.Line2D([], [], color='#888888', linestyle='--',
+ label='Línea base'),
+ plt.Line2D([], [], color='#3498db', label='Actual')
+ ])
+ else:
+ legend_handles.extend([
+ plt.Line2D([], [], color='#3498db', label='Tu escritura')
+ ])
+
+ legend_handles.extend([
+ plt.Line2D([], [], color='#e74c3c', linestyle='--', label='Mínimo'),
+ plt.Line2D([], [], color='#2ecc71', linestyle='--', label='Meta')
+ ])
+
+ ax.legend(
+ handles=legend_handles,
+ loc='upper right',
+ bbox_to_anchor=(1.3, 1.1),
+ fontsize=10,
+ frameon=True,
+ facecolor='white',
+ edgecolor='none',
+ shadow=True
+ )
+
+ plt.tight_layout()
+ st.pyplot(fig)
+ plt.close()
+
+ except Exception as e:
+ logger.error(f"Error mostrando gráfico radar: {str(e)}")
+ st.error("Error al mostrar el gráfico")
+
+#Funciones auxiliares ##################################
+
+
+############################################################
+# Unificamos la lógica de sugerencias en una función
+############################################################
+def suggest_improvement_tools_list(dimension):
+ """
+ Retorna en forma de lista las herramientas sugeridas
+ basadas en 'ANALYSIS_DIMENSION_MAPPING'.
+ """
+ suggestions = []
+ for analysis, mapping in ANALYSIS_DIMENSION_MAPPING.items():
+ # Verificamos si la dimensión está en primary o secondary
+ if dimension in mapping['primary'] or dimension in mapping['secondary']:
+ suggestions.extend(mapping['tools'])
+ # Si no hay nada, al menos retornamos un placeholder
+ return suggestions if suggestions else ["Sin sugerencias específicas."]
+
+
+def prepare_metrics_config(metrics, text_type='student_essay'):
+ """
+ Prepara la configuración de métricas en el mismo formato que display_results.
+ Args:
+ metrics: Diccionario con las métricas analizadas
+ text_type: Tipo de texto para los umbrales
+ Returns:
+ list: Lista de configuraciones de métricas
+ """
+ # Obtener umbrales según el tipo de texto
+ thresholds = TEXT_TYPES[text_type]['thresholds']
+
+ # Usar la misma estructura que en display_results
+ return [
+ {
+ 'label': "Vocabulario",
+ 'key': 'vocabulary',
+ 'value': metrics['vocabulary']['normalized_score'],
+ 'help': "Riqueza y variedad del vocabulario",
+ 'thresholds': thresholds['vocabulary']
+ },
+ {
+ 'label': "Estructura",
+ 'key': 'structure',
+ 'value': metrics['structure']['normalized_score'],
+ 'help': "Organización y complejidad de oraciones",
+ 'thresholds': thresholds['structure']
+ },
+ {
+ 'label': "Cohesión",
+ 'key': 'cohesion',
+ 'value': metrics['cohesion']['normalized_score'],
+ 'help': "Conexión y fluidez entre ideas",
+ 'thresholds': thresholds['cohesion']
+ },
+ {
+ 'label': "Claridad",
+ 'key': 'clarity',
+ 'value': metrics['clarity']['normalized_score'],
+ 'help': "Facilidad de comprensión del texto",
+ 'thresholds': thresholds['clarity']
+ }
+ ]
+
diff --git a/src/modules/studentact/current_situation_interface-v1.py b/src/modules/studentact/current_situation_interface-v1.py
new file mode 100644
index 0000000000000000000000000000000000000000..6119f6bf146976da43fe9311b5fc54551173341a
--- /dev/null
+++ b/src/modules/studentact/current_situation_interface-v1.py
@@ -0,0 +1,272 @@
+# modules/studentact/current_situation_interface.py
+
+import streamlit as st
+import logging
+from ..utils.widget_utils import generate_unique_key
+from .current_situation_analysis import (
+ analyze_text_dimensions,
+ analyze_clarity,
+ analyze_reference_clarity,
+ analyze_vocabulary_diversity,
+ analyze_cohesion,
+ analyze_structure,
+ get_dependency_depths,
+ normalize_score,
+ generate_sentence_graphs,
+ generate_word_connections,
+ generate_connection_paths,
+ create_vocabulary_network,
+ create_syntax_complexity_graph,
+ create_cohesion_heatmap,
+)
+
+logger = logging.getLogger(__name__)
+####################################
+def display_current_situation_interface(lang_code, nlp_models, t):
+ """
+ Interfaz simplificada para el análisis inicial, enfocada en recomendaciones directas.
+ """
+ # Inicializar estados si no existen
+ if 'text_input' not in st.session_state:
+ st.session_state.text_input = ""
+ if 'show_results' not in st.session_state:
+ st.session_state.show_results = False
+ if 'current_doc' not in st.session_state:
+ st.session_state.current_doc = None
+ if 'current_metrics' not in st.session_state:
+ st.session_state.current_metrics = None
+
+ st.markdown("## Análisis Inicial de Escritura")
+
+ # Container principal con dos columnas
+ with st.container():
+ input_col, results_col = st.columns([1,2])
+
+ with input_col:
+ st.markdown("### Ingresa tu texto")
+
+ # Función para manejar cambios en el texto
+ def on_text_change():
+ st.session_state.text_input = st.session_state.text_area
+ st.session_state.show_results = False # Resetear resultados cuando el texto cambia
+
+ # Text area con manejo de estado
+ text_input = st.text_area(
+ t.get('input_prompt', "Escribe o pega tu texto aquí:"),
+ height=400,
+ key="text_area",
+ value=st.session_state.text_input,
+ on_change=on_text_change,
+ help="Este texto será analizado para darte recomendaciones personalizadas"
+ )
+
+ # Botón de análisis
+ if st.button(
+ t.get('analyze_button', "Analizar mi escritura"),
+ type="primary",
+ disabled=not text_input.strip(),
+ use_container_width=True,
+ ):
+ try:
+ with st.spinner(t.get('processing', "Analizando...")):
+ # Procesar texto y obtener métricas
+ doc = nlp_models[lang_code](text_input)
+ metrics = analyze_text_dimensions(doc)
+
+ # Actualizar estado con nuevos resultados
+ st.session_state.current_doc = doc
+ st.session_state.current_metrics = metrics
+ st.session_state.show_results = True
+
+ # Mantener el texto en el estado
+ st.session_state.text_input = text_input
+
+ except Exception as e:
+ logger.error(f"Error en análisis: {str(e)}")
+ st.error(t.get('analysis_error', "Error al analizar el texto"))
+
+ # Mostrar resultados en la columna derecha
+ with results_col:
+ if st.session_state.show_results and st.session_state.current_metrics is not None:
+ display_recommendations(st.session_state.current_metrics, t)
+
+ # Opción para ver detalles
+ with st.expander("🔍 Ver análisis detallado", expanded=False):
+ display_current_situation_visual(
+ st.session_state.current_doc,
+ st.session_state.current_metrics
+ )
+
+def display_current_situation_visual(doc, metrics):
+ """
+ Muestra visualizaciones detalladas del análisis.
+ """
+ try:
+ st.markdown("### 📊 Visualizaciones Detalladas")
+
+ # 1. Visualización de vocabulario
+ with st.expander("Análisis de Vocabulario", expanded=True):
+ vocab_graph = create_vocabulary_network(doc)
+ if vocab_graph:
+ st.pyplot(vocab_graph)
+ plt.close(vocab_graph)
+
+ # 2. Visualización de estructura
+ with st.expander("Análisis de Estructura", expanded=True):
+ syntax_graph = create_syntax_complexity_graph(doc)
+ if syntax_graph:
+ st.pyplot(syntax_graph)
+ plt.close(syntax_graph)
+
+ # 3. Visualización de cohesión
+ with st.expander("Análisis de Cohesión", expanded=True):
+ cohesion_graph = create_cohesion_heatmap(doc)
+ if cohesion_graph:
+ st.pyplot(cohesion_graph)
+ plt.close(cohesion_graph)
+
+ except Exception as e:
+ logger.error(f"Error en visualización: {str(e)}")
+ st.error("Error al generar las visualizaciones")
+
+
+####################################
+def display_recommendations(metrics, t):
+ """
+ Muestra recomendaciones basadas en las métricas del texto.
+ """
+ # 1. Resumen Visual con Explicación
+ st.markdown("### 📊 Resumen de tu Análisis")
+
+ # Explicación del sistema de medición
+ st.markdown("""
+ **¿Cómo interpretar los resultados?**
+
+ Cada métrica se mide en una escala de 0.0 a 1.0, donde:
+ - 0.0 - 0.4: Necesita atención prioritaria
+ - 0.4 - 0.6: En desarrollo
+ - 0.6 - 0.8: Buen nivel
+ - 0.8 - 1.0: Nivel avanzado
+ """)
+
+ # Métricas con explicaciones detalladas
+ col1, col2, col3, col4 = st.columns(4)
+
+ with col1:
+ st.metric(
+ "Vocabulario",
+ f"{metrics['vocabulary']['normalized_score']:.2f}",
+ help="Mide la variedad y riqueza de tu vocabulario. Un valor alto indica un uso diverso de palabras sin repeticiones excesivas."
+ )
+ with st.expander("ℹ️ Detalles"):
+ st.write("""
+ **Vocabulario**
+ - Evalúa la diversidad léxica
+ - Considera palabras únicas vs. totales
+ - Detecta repeticiones innecesarias
+ - Valor óptimo: > 0.7
+ """)
+
+ with col2:
+ st.metric(
+ "Estructura",
+ f"{metrics['structure']['normalized_score']:.2f}",
+ help="Evalúa la complejidad y variedad de las estructuras sintácticas en tus oraciones."
+ )
+ with st.expander("ℹ️ Detalles"):
+ st.write("""
+ **Estructura**
+ - Analiza la complejidad sintáctica
+ - Mide variación en construcciones
+ - Evalúa longitud de oraciones
+ - Valor óptimo: > 0.6
+ """)
+
+ with col3:
+ st.metric(
+ "Cohesión",
+ f"{metrics['cohesion']['normalized_score']:.2f}",
+ help="Indica qué tan bien conectadas están tus ideas y párrafos entre sí."
+ )
+ with st.expander("ℹ️ Detalles"):
+ st.write("""
+ **Cohesión**
+ - Mide conexiones entre ideas
+ - Evalúa uso de conectores
+ - Analiza progresión temática
+ - Valor óptimo: > 0.65
+ """)
+
+ with col4:
+ st.metric(
+ "Claridad",
+ f"{metrics['clarity']['normalized_score']:.2f}",
+ help="Evalúa la facilidad de comprensión general de tu texto."
+ )
+ with st.expander("ℹ️ Detalles"):
+ st.write("""
+ **Claridad**
+ - Evalúa comprensibilidad
+ - Considera estructura lógica
+ - Mide precisión expresiva
+ - Valor óptimo: > 0.7
+ """)
+
+ st.markdown("---")
+
+ # 2. Recomendaciones basadas en puntuaciones
+ st.markdown("### 💡 Recomendaciones Personalizadas")
+
+ # Recomendaciones morfosintácticas
+ if metrics['structure']['normalized_score'] < 0.6:
+ st.warning("""
+ #### 📝 Análisis Morfosintáctico Recomendado
+
+ **Tu nivel actual sugiere que sería beneficioso:**
+ 1. Realizar el análisis morfosintáctico de 3 párrafos diferentes
+ 2. Practicar la combinación de oraciones simples en compuestas
+ 3. Identificar y clasificar tipos de oraciones en textos académicos
+ 4. Ejercitar la variación sintáctica
+
+ *Hacer clic en "Comenzar ejercicios" para acceder al módulo morfosintáctico*
+ """)
+
+ # Recomendaciones semánticas
+ if metrics['vocabulary']['normalized_score'] < 0.7:
+ st.warning("""
+ #### 📚 Análisis Semántico Recomendado
+
+ **Para mejorar tu vocabulario y expresión:**
+ A. Realiza el análisis semántico de un texto académico
+ B. Identifica y agrupa campos semánticos relacionados
+ C. Practica la sustitución léxica en tus párrafos
+ D. Construye redes de conceptos sobre tu tema
+ E. Analiza las relaciones entre ideas principales
+
+ *Hacer clic en "Comenzar ejercicios" para acceder al módulo semántico*
+ """)
+
+ # Recomendaciones de cohesión
+ if metrics['cohesion']['normalized_score'] < 0.65:
+ st.warning("""
+ #### 🔄 Análisis del Discurso Recomendado
+
+ **Para mejorar la conexión entre ideas:**
+ 1. Realizar el análisis del discurso de un texto modelo
+ 2. Practicar el uso de diferentes conectores textuales
+ 3. Identificar cadenas de referencia en textos académicos
+ 4. Ejercitar la progresión temática en tus escritos
+
+ *Hacer clic en "Comenzar ejercicios" para acceder al módulo de análisis del discurso*
+ """)
+
+ # Botón de acción
+ st.markdown("---")
+ col1, col2, col3 = st.columns([1,2,1])
+ with col2:
+ st.button(
+ "🎯 Comenzar ejercicios recomendados",
+ type="primary",
+ use_container_width=True,
+ key="start_exercises"
+ )
\ No newline at end of file
diff --git a/src/modules/studentact/current_situation_interface-v2.py b/src/modules/studentact/current_situation_interface-v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..64316c76a1bc41b01bdfd35d76e7f47117aefa24
--- /dev/null
+++ b/src/modules/studentact/current_situation_interface-v2.py
@@ -0,0 +1,291 @@
+# modules/studentact/current_situation_interface.py
+
+import streamlit as st
+import logging
+from ..utils.widget_utils import generate_unique_key
+
+from ..database.current_situation_mongo_db import store_current_situation_result
+
+from .current_situation_analysis import (
+ analyze_text_dimensions,
+ analyze_clarity,
+ analyze_reference_clarity,
+ analyze_vocabulary_diversity,
+ analyze_cohesion,
+ analyze_structure,
+ get_dependency_depths,
+ normalize_score,
+ generate_sentence_graphs,
+ generate_word_connections,
+ generate_connection_paths,
+ create_vocabulary_network,
+ create_syntax_complexity_graph,
+ create_cohesion_heatmap,
+)
+
+logger = logging.getLogger(__name__)
+####################################
+
+def display_current_situation_interface(lang_code, nlp_models, t):
+ """
+ Interfaz simplificada para el análisis inicial, enfocada en recomendaciones directas.
+ """
+ try:
+ # Inicializar estados si no existen
+ if 'text_input' not in st.session_state:
+ st.session_state.text_input = ""
+ if 'show_results' not in st.session_state:
+ st.session_state.show_results = False
+ if 'current_doc' not in st.session_state:
+ st.session_state.current_doc = None
+ if 'current_metrics' not in st.session_state:
+ st.session_state.current_metrics = None
+
+ st.markdown("## Análisis Inicial de Escritura")
+
+ # Container principal con dos columnas
+ with st.container():
+ input_col, results_col = st.columns([1,2])
+
+ with input_col:
+ st.markdown("### Ingresa tu texto")
+
+ # Función para manejar cambios en el texto
+ def on_text_change():
+ st.session_state.text_input = st.session_state.text_area
+ st.session_state.show_results = False # Resetear resultados cuando el texto cambia
+
+ # Text area con manejo de estado
+ text_input = st.text_area(
+ t.get('input_prompt', "Escribe o pega tu texto aquí:"),
+ height=400,
+ key="text_area",
+ value=st.session_state.text_input,
+ on_change=on_text_change,
+ help="Este texto será analizado para darte recomendaciones personalizadas"
+ )
+
+ if st.button(
+ t.get('analyze_button', "Analizar mi escritura"),
+ type="primary",
+ disabled=not text_input.strip(),
+ use_container_width=True,
+ ):
+ try:
+ with st.spinner(t.get('processing', "Analizando...")):
+ # Procesar texto y obtener métricas
+ doc = nlp_models[lang_code](text_input)
+ metrics = analyze_text_dimensions(doc)
+
+ # Guardar en MongoDB
+ storage_success = store_current_situation_result(
+ username=st.session_state.username,
+ text=text_input,
+ metrics=metrics,
+ feedback=None # Por ahora sin feedback
+ )
+
+ if not storage_success:
+ logger.warning("No se pudo guardar el análisis en la base de datos")
+
+ # Actualizar estado
+ st.session_state.current_doc = doc
+ st.session_state.current_metrics = metrics
+ st.session_state.show_results = True
+ st.session_state.text_input = text_input
+
+ except Exception as e:
+ logger.error(f"Error en análisis: {str(e)}")
+ st.error(t.get('analysis_error', "Error al analizar el texto"))
+
+ # Mostrar resultados en la columna derecha
+ with results_col:
+ if st.session_state.show_results and st.session_state.current_metrics is not None:
+ display_recommendations(st.session_state.current_metrics, t)
+
+ # Opción para ver detalles
+ with st.expander("🔍 Ver análisis detallado", expanded=False):
+ display_current_situation_visual(
+ st.session_state.current_doc,
+ st.session_state.current_metrics
+ )
+
+ except Exception as e:
+ logger.error(f"Error en interfaz: {str(e)}")
+ st.error("Ocurrió un error. Por favor, intente de nuevo.")
+
+
+
+def display_current_situation_visual(doc, metrics):
+ """
+ Muestra visualizaciones detalladas del análisis.
+ """
+ try:
+ st.markdown("### 📊 Visualizaciones Detalladas")
+
+ # 1. Visualización de vocabulario
+ with st.expander("Análisis de Vocabulario", expanded=True):
+ vocab_graph = create_vocabulary_network(doc)
+ if vocab_graph:
+ st.pyplot(vocab_graph)
+ plt.close(vocab_graph)
+
+ # 2. Visualización de estructura
+ with st.expander("Análisis de Estructura", expanded=True):
+ syntax_graph = create_syntax_complexity_graph(doc)
+ if syntax_graph:
+ st.pyplot(syntax_graph)
+ plt.close(syntax_graph)
+
+ # 3. Visualización de cohesión
+ with st.expander("Análisis de Cohesión", expanded=True):
+ cohesion_graph = create_cohesion_heatmap(doc)
+ if cohesion_graph:
+ st.pyplot(cohesion_graph)
+ plt.close(cohesion_graph)
+
+ except Exception as e:
+ logger.error(f"Error en visualización: {str(e)}")
+ st.error("Error al generar las visualizaciones")
+
+
+####################################
+def display_recommendations(metrics, t):
+ """
+ Muestra recomendaciones basadas en las métricas del texto.
+ """
+ # 1. Resumen Visual con Explicación
+ st.markdown("### 📊 Resumen de tu Análisis")
+
+ # Explicación del sistema de medición
+ st.markdown("""
+ **¿Cómo interpretar los resultados?**
+
+ Cada métrica se mide en una escala de 0.0 a 1.0, donde:
+ - 0.0 - 0.4: Necesita atención prioritaria
+ - 0.4 - 0.6: En desarrollo
+ - 0.6 - 0.8: Buen nivel
+ - 0.8 - 1.0: Nivel avanzado
+ """)
+
+ # Métricas con explicaciones detalladas
+ col1, col2, col3, col4 = st.columns(4)
+
+ with col1:
+ st.metric(
+ "Vocabulario",
+ f"{metrics['vocabulary']['normalized_score']:.2f}",
+ help="Mide la variedad y riqueza de tu vocabulario. Un valor alto indica un uso diverso de palabras sin repeticiones excesivas."
+ )
+ with st.expander("ℹ️ Detalles"):
+ st.write("""
+ **Vocabulario**
+ - Evalúa la diversidad léxica
+ - Considera palabras únicas vs. totales
+ - Detecta repeticiones innecesarias
+ - Valor óptimo: > 0.7
+ """)
+
+ with col2:
+ st.metric(
+ "Estructura",
+ f"{metrics['structure']['normalized_score']:.2f}",
+ help="Evalúa la complejidad y variedad de las estructuras sintácticas en tus oraciones."
+ )
+ with st.expander("ℹ️ Detalles"):
+ st.write("""
+ **Estructura**
+ - Analiza la complejidad sintáctica
+ - Mide variación en construcciones
+ - Evalúa longitud de oraciones
+ - Valor óptimo: > 0.6
+ """)
+
+ with col3:
+ st.metric(
+ "Cohesión",
+ f"{metrics['cohesion']['normalized_score']:.2f}",
+ help="Indica qué tan bien conectadas están tus ideas y párrafos entre sí."
+ )
+ with st.expander("ℹ️ Detalles"):
+ st.write("""
+ **Cohesión**
+ - Mide conexiones entre ideas
+ - Evalúa uso de conectores
+ - Analiza progresión temática
+ - Valor óptimo: > 0.65
+ """)
+
+ with col4:
+ st.metric(
+ "Claridad",
+ f"{metrics['clarity']['normalized_score']:.2f}",
+ help="Evalúa la facilidad de comprensión general de tu texto."
+ )
+ with st.expander("ℹ️ Detalles"):
+ st.write("""
+ **Claridad**
+ - Evalúa comprensibilidad
+ - Considera estructura lógica
+ - Mide precisión expresiva
+ - Valor óptimo: > 0.7
+ """)
+
+ st.markdown("---")
+
+ # 2. Recomendaciones basadas en puntuaciones
+ st.markdown("### 💡 Recomendaciones Personalizadas")
+
+ # Recomendaciones morfosintácticas
+ if metrics['structure']['normalized_score'] < 0.6:
+ st.warning("""
+ #### 📝 Análisis Morfosintáctico Recomendado
+
+ **Tu nivel actual sugiere que sería beneficioso:**
+ 1. Realizar el análisis morfosintáctico de 3 párrafos diferentes
+ 2. Practicar la combinación de oraciones simples en compuestas
+ 3. Identificar y clasificar tipos de oraciones en textos académicos
+ 4. Ejercitar la variación sintáctica
+
+ *Hacer clic en "Comenzar ejercicios" para acceder al módulo morfosintáctico*
+ """)
+
+ # Recomendaciones semánticas
+ if metrics['vocabulary']['normalized_score'] < 0.7:
+ st.warning("""
+ #### 📚 Análisis Semántico Recomendado
+
+ **Para mejorar tu vocabulario y expresión:**
+ A. Realiza el análisis semántico de un texto académico
+ B. Identifica y agrupa campos semánticos relacionados
+ C. Practica la sustitución léxica en tus párrafos
+ D. Construye redes de conceptos sobre tu tema
+ E. Analiza las relaciones entre ideas principales
+
+ *Hacer clic en "Comenzar ejercicios" para acceder al módulo semántico*
+ """)
+
+ # Recomendaciones de cohesión
+ if metrics['cohesion']['normalized_score'] < 0.65:
+ st.warning("""
+ #### 🔄 Análisis del Discurso Recomendado
+
+ **Para mejorar la conexión entre ideas:**
+ 1. Realizar el análisis del discurso de un texto modelo
+ 2. Practicar el uso de diferentes conectores textuales
+ 3. Identificar cadenas de referencia en textos académicos
+ 4. Ejercitar la progresión temática en tus escritos
+
+ *Hacer clic en "Comenzar ejercicios" para acceder al módulo de análisis del discurso*
+ """)
+
+ # Botón de acción
+ st.markdown("---")
+ col1, col2, col3 = st.columns([1,2,1])
+ with col2:
+ st.button(
+ "🎯 Comenzar ejercicios recomendados",
+ type="primary",
+ use_container_width=True,
+ key="start_exercises"
+ )
diff --git a/src/modules/studentact/current_situation_interface-v3.py b/src/modules/studentact/current_situation_interface-v3.py
new file mode 100644
index 0000000000000000000000000000000000000000..599801971ea94f92e107469154a201bf248825cd
--- /dev/null
+++ b/src/modules/studentact/current_situation_interface-v3.py
@@ -0,0 +1,190 @@
+# modules/studentact/current_situation_interface.py
+
+import streamlit as st
+import logging
+from ..utils.widget_utils import generate_unique_key
+import matplotlib.pyplot as plt
+import numpy as np
+from ..database.current_situation_mongo_db import store_current_situation_result
+
+from .current_situation_analysis import (
+ analyze_text_dimensions,
+ analyze_clarity,
+ analyze_reference_clarity,
+ analyze_vocabulary_diversity,
+ analyze_cohesion,
+ analyze_structure,
+ get_dependency_depths,
+ normalize_score,
+ generate_sentence_graphs,
+ generate_word_connections,
+ generate_connection_paths,
+ create_vocabulary_network,
+ create_syntax_complexity_graph,
+ create_cohesion_heatmap,
+)
+
+# Configuración del estilo de matplotlib para el gráfico de radar
+plt.rcParams['font.family'] = 'sans-serif'
+plt.rcParams['axes.grid'] = True
+plt.rcParams['axes.spines.top'] = False
+plt.rcParams['axes.spines.right'] = False
+
+logger = logging.getLogger(__name__)
+####################################
+
+def display_current_situation_interface(lang_code, nlp_models, t):
+ """
+ Interfaz simplificada con gráfico de radar para visualizar métricas.
+ """
+ try:
+ # Inicializar estados si no existen
+ if 'text_input' not in st.session_state:
+ st.session_state.text_input = ""
+ if 'show_results' not in st.session_state:
+ st.session_state.show_results = False
+ if 'current_doc' not in st.session_state:
+ st.session_state.current_doc = None
+ if 'current_metrics' not in st.session_state:
+ st.session_state.current_metrics = None
+
+ st.markdown("## Análisis Inicial de Escritura")
+
+ # Container principal con dos columnas
+ with st.container():
+ input_col, results_col = st.columns([1,2])
+
+ with input_col:
+ #st.markdown("### Ingresa tu texto")
+
+ # Función para manejar cambios en el texto
+ def on_text_change():
+ st.session_state.text_input = st.session_state.text_area
+ st.session_state.show_results = False
+
+ # Text area con manejo de estado
+ text_input = st.text_area(
+ t.get('input_prompt', "Escribe o pega tu texto aquí:"),
+ height=400,
+ key="text_area",
+ value=st.session_state.text_input,
+ on_change=on_text_change,
+ help="Este texto será analizado para darte recomendaciones personalizadas"
+ )
+
+ if st.button(
+ t.get('analyze_button', "Analizar mi escritura"),
+ type="primary",
+ disabled=not text_input.strip(),
+ use_container_width=True,
+ ):
+ try:
+ with st.spinner(t.get('processing', "Analizando...")):
+ doc = nlp_models[lang_code](text_input)
+ metrics = analyze_text_dimensions(doc)
+
+ # Guardar en MongoDB
+ storage_success = store_current_situation_result(
+ username=st.session_state.username,
+ text=text_input,
+ metrics=metrics,
+ feedback=None
+ )
+
+ if not storage_success:
+ logger.warning("No se pudo guardar el análisis en la base de datos")
+
+ st.session_state.current_doc = doc
+ st.session_state.current_metrics = metrics
+ st.session_state.show_results = True
+ st.session_state.text_input = text_input
+
+ except Exception as e:
+ logger.error(f"Error en análisis: {str(e)}")
+ st.error(t.get('analysis_error', "Error al analizar el texto"))
+
+ # Mostrar resultados en la columna derecha
+ with results_col:
+ if st.session_state.show_results and st.session_state.current_metrics is not None:
+ display_radar_chart(st.session_state.current_metrics)
+
+ except Exception as e:
+ logger.error(f"Error en interfaz: {str(e)}")
+ st.error("Ocurrió un error. Por favor, intente de nuevo.")
+
+def display_radar_chart(metrics):
+ """
+ Muestra un gráfico de radar con las métricas del usuario y el patrón ideal.
+ """
+ try:
+ # Container con proporción reducida
+ with st.container():
+ # Métricas en la parte superior
+ col1, col2, col3, col4 = st.columns(4)
+ with col1:
+ st.metric("Vocabulario", f"{metrics['vocabulary']['normalized_score']:.2f}", "1.00")
+ with col2:
+ st.metric("Estructura", f"{metrics['structure']['normalized_score']:.2f}", "1.00")
+ with col3:
+ st.metric("Cohesión", f"{metrics['cohesion']['normalized_score']:.2f}", "1.00")
+ with col4:
+ st.metric("Claridad", f"{metrics['clarity']['normalized_score']:.2f}", "1.00")
+
+ # Contenedor para el gráfico con ancho controlado
+ _, graph_col, _ = st.columns([1,2,1])
+
+ with graph_col:
+ # Preparar datos
+ categories = ['Vocabulario', 'Estructura', 'Cohesión', 'Claridad']
+ values_user = [
+ metrics['vocabulary']['normalized_score'],
+ metrics['structure']['normalized_score'],
+ metrics['cohesion']['normalized_score'],
+ metrics['clarity']['normalized_score']
+ ]
+ values_pattern = [1.0, 1.0, 1.0, 1.0] # Patrón ideal
+
+ # Crear figura más compacta
+ fig = plt.figure(figsize=(6, 6))
+ ax = fig.add_subplot(111, projection='polar')
+
+ # Número de variables
+ num_vars = len(categories)
+
+ # Calcular ángulos
+ angles = [n / float(num_vars) * 2 * np.pi for n in range(num_vars)]
+ angles += angles[:1]
+
+ # Extender valores para cerrar polígonos
+ values_user += values_user[:1]
+ values_pattern += values_pattern[:1]
+
+ # Configurar ejes y etiquetas
+ ax.set_xticks(angles[:-1])
+ ax.set_xticklabels(categories, fontsize=8)
+
+ # Círculos concéntricos y etiquetas
+ circle_ticks = np.arange(0, 1.1, 0.2) # Reducido a 5 niveles
+ ax.set_yticks(circle_ticks)
+ ax.set_yticklabels([f'{tick:.1f}' for tick in circle_ticks], fontsize=8)
+ ax.set_ylim(0, 1)
+
+ # Dibujar patrón ideal
+ ax.plot(angles, values_pattern, 'g--', linewidth=1, label='Patrón', alpha=0.5)
+ ax.fill(angles, values_pattern, 'g', alpha=0.1)
+
+ # Dibujar valores del usuario
+ ax.plot(angles, values_user, 'b-', linewidth=2, label='Tu escritura')
+ ax.fill(angles, values_user, 'b', alpha=0.2)
+
+ # Leyenda
+ ax.legend(loc='upper right', bbox_to_anchor=(0.1, 0.1), fontsize=8)
+
+ # Ajustes finales
+ plt.tight_layout()
+ st.pyplot(fig)
+ plt.close()
+
+ except Exception as e:
+ logger.error(f"Error generando gráfico de radar: {str(e)}")
+ st.error("Error al generar la visualización")
\ No newline at end of file
diff --git a/src/modules/studentact/current_situation_interface.py b/src/modules/studentact/current_situation_interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..27d522bea7a017121700e993e9155d787f3e3aea
--- /dev/null
+++ b/src/modules/studentact/current_situation_interface.py
@@ -0,0 +1,448 @@
+# modules/studentact/current_situation_interface.py
+
+import streamlit as st
+import logging
+from ..utils.widget_utils import generate_unique_key
+import matplotlib.pyplot as plt
+import numpy as np
+from ..database.current_situation_mongo_db import store_current_situation_result
+
+# Importaciones locales
+from translations import get_translations
+
+# Importamos la función de recomendaciones personalizadas si existe
+try:
+ from .claude_recommendations import display_personalized_recommendations
+except ImportError:
+ # Si no existe el módulo, definimos una función placeholder
+ def display_personalized_recommendations(text, metrics, text_type, lang_code, t):
+ # Obtener el mensaje de advertencia traducido si está disponible
+ warning = t.get('module_not_available', "Módulo de recomendaciones personalizadas no disponible. Por favor, contacte al administrador.")
+ st.warning(warning)
+
+from .current_situation_analysis import (
+ analyze_text_dimensions,
+ analyze_clarity,
+ analyze_vocabulary_diversity,
+ analyze_cohesion,
+ analyze_structure,
+ get_dependency_depths,
+ normalize_score,
+ generate_sentence_graphs,
+ generate_word_connections,
+ generate_connection_paths,
+ create_vocabulary_network,
+ create_syntax_complexity_graph,
+ create_cohesion_heatmap
+)
+
+# Configuración del estilo de matplotlib para el gráfico de radar
+plt.rcParams['font.family'] = 'sans-serif'
+plt.rcParams['axes.grid'] = True
+plt.rcParams['axes.spines.top'] = False
+plt.rcParams['axes.spines.right'] = False
+
+logger = logging.getLogger(__name__)
+
+# Definición de tipos de texto con umbrales
+TEXT_TYPES = {
+ 'academic_article': {
+ # Los nombres se obtendrán de las traducciones
+ 'thresholds': {
+ 'vocabulary': {'min': 0.70, 'target': 0.85},
+ 'structure': {'min': 0.75, 'target': 0.90},
+ 'cohesion': {'min': 0.65, 'target': 0.80},
+ 'clarity': {'min': 0.70, 'target': 0.85}
+ }
+ },
+ 'student_essay': {
+ 'thresholds': {
+ 'vocabulary': {'min': 0.60, 'target': 0.75},
+ 'structure': {'min': 0.65, 'target': 0.80},
+ 'cohesion': {'min': 0.55, 'target': 0.70},
+ 'clarity': {'min': 0.60, 'target': 0.75}
+ }
+ },
+ 'general_communication': {
+ 'thresholds': {
+ 'vocabulary': {'min': 0.50, 'target': 0.65},
+ 'structure': {'min': 0.55, 'target': 0.70},
+ 'cohesion': {'min': 0.45, 'target': 0.60},
+ 'clarity': {'min': 0.50, 'target': 0.65}
+ }
+ }
+}
+
+####################################################
+####################################################
+def display_current_situation_interface(lang_code, nlp_models, t):
+ """
+ Interfaz simplificada con gráfico de radar para visualizar métricas.
+ """
+ # Agregar logs para depuración
+ logger.info(f"Idioma: {lang_code}")
+ logger.info(f"Claves en t: {list(t.keys())}")
+
+ # Inicializar estados si no existen
+ if 'text_input' not in st.session_state:
+ st.session_state.text_input = ""
+ if 'text_area' not in st.session_state:
+ st.session_state.text_area = ""
+ if 'show_results' not in st.session_state:
+ st.session_state.show_results = False
+ if 'current_doc' not in st.session_state:
+ st.session_state.current_doc = None
+ if 'current_metrics' not in st.session_state:
+ st.session_state.current_metrics = None
+ if 'current_recommendations' not in st.session_state:
+ st.session_state.current_recommendations = None
+
+ try:
+ # Container principal con dos columnas
+ with st.container():
+ input_col, results_col = st.columns([1,2])
+
+###############################################################################################
+ # CSS personalizado para que el formulario ocupe todo el alto disponible
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+###############################################################################################
+ with input_col:
+ with st.form(key=f"text_input_form_{lang_code}"):
+ text_input = st.text_area(
+ t.get('input_prompt', "Escribe o pega tu texto aquí:"),
+ height=800,
+ key=f"text_area_{lang_code}",
+ value=st.session_state.text_input,
+ help=t.get('help', "Este texto será analizado para darte recomendaciones personalizadas")
+ )
+
+ submit_button = st.form_submit_button(
+ t.get('analyze_button', "Analizar mi escritura"),
+ type="primary",
+ use_container_width=True
+ )
+
+ if submit_button:
+ if text_input.strip():
+ st.session_state.text_input = text_input
+
+#######################################################################
+ # Código para análisis...
+ try:
+ with st.spinner(t.get('processing', "Analizando...")): # Usando t.get directamente
+ doc = nlp_models[lang_code](text_input)
+ metrics = analyze_text_dimensions(doc)
+
+ storage_success = store_current_situation_result(
+ username=st.session_state.username,
+ text=text_input,
+ metrics=metrics,
+ feedback=None
+ )
+
+ if not storage_success:
+ logger.warning("No se pudo guardar el análisis en la base de datos")
+
+ st.session_state.current_doc = doc
+ st.session_state.current_metrics = metrics
+ st.session_state.show_results = True
+
+ except Exception as e:
+ logger.error(f"Error en análisis: {str(e)}")
+ st.error(t.get('analysis_error', "Error al analizar el texto")) # Usando t.get directamente
+
+ # Mostrar resultados en la columna derecha
+ with results_col:
+ if st.session_state.show_results and st.session_state.current_metrics is not None:
+ # Primero los radio buttons para tipo de texto - usando t.get directamente
+ st.markdown(f"### {t.get('text_type_header', 'Tipo de texto')}")
+
+ # Preparar opciones de tipos de texto con nombres traducidos
+ text_type_options = {}
+ for text_type_key in TEXT_TYPES.keys():
+ # Fallback a nombres genéricos si no hay traducción
+ default_names = {
+ 'academic_article': 'Academic Article' if lang_code == 'en' else 'Article Académique' if lang_code == 'fr' else 'Artigo Acadêmico' if lang_code == 'pt' else 'Artículo Académico',
+ 'student_essay': 'Student Essay' if lang_code == 'en' else 'Devoir Universitaire' if lang_code == 'fr' else 'Trabalho Universitário' if lang_code == 'pt' else 'Trabajo Universitario',
+ 'general_communication': 'General Communication' if lang_code == 'en' else 'Communication Générale' if lang_code == 'fr' else 'Comunicação Geral' if lang_code == 'pt' else 'Comunicación General'
+ }
+ text_type_options[text_type_key] = default_names.get(text_type_key, text_type_key)
+
+ text_type = st.radio(
+ label=t.get('text_type_header', "Tipo de texto"), # Usando t.get directamente
+ options=list(TEXT_TYPES.keys()),
+ format_func=lambda x: text_type_options.get(x, x),
+ horizontal=True,
+ key="text_type_radio",
+ label_visibility="collapsed",
+ help=t.get('text_type_help', "Selecciona el tipo de texto para ajustar los criterios de evaluación") # Usando t.get directamente
+ )
+
+ st.session_state.current_text_type = text_type
+
+ # Crear subtabs con nombres traducidos
+ diagnosis_tab = "Diagnosis" if lang_code == 'en' else "Diagnostic" if lang_code == 'fr' else "Diagnóstico" if lang_code == 'pt' else "Diagnóstico"
+ recommendations_tab = "Recommendations" if lang_code == 'en' else "Recommandations" if lang_code == 'fr' else "Recomendações" if lang_code == 'pt' else "Recomendaciones"
+
+ subtab1, subtab2 = st.tabs([diagnosis_tab, recommendations_tab])
+
+ # Mostrar resultados en el primer subtab
+ with subtab1:
+ display_diagnosis(
+ metrics=st.session_state.current_metrics,
+ text_type=text_type,
+ lang_code=lang_code,
+ t=t # Pasar t directamente, no current_situation_t
+ )
+
+ # Mostrar recomendaciones en el segundo subtab
+ with subtab2:
+ # Llamar directamente a la función de recomendaciones personalizadas
+ display_personalized_recommendations(
+ text=text_input,
+ metrics=st.session_state.current_metrics,
+ text_type=text_type,
+ lang_code=lang_code,
+ t=t
+ )
+
+ except Exception as e:
+ logger.error(f"Error en interfaz principal: {str(e)}")
+ st.error(t.get('error_interface', "Ocurrió un error al cargar la interfaz")) # Usando t.get directamente
+
+#################################################################
+#################################################################
+def display_diagnosis(metrics, text_type=None, lang_code='es', t=None):
+ """
+ Muestra los resultados del análisis: métricas verticalmente y gráfico radar.
+ """
+ try:
+ # Asegurar que tenemos traducciones
+ if t is None:
+ t = {}
+
+ # Traducciones para títulos y etiquetas
+ dimension_labels = {
+ 'es': {
+ 'title': "Tipo de texto",
+ 'vocabulary': "Vocabulario",
+ 'structure': "Estructura",
+ 'cohesion': "Cohesión",
+ 'clarity': "Claridad",
+ 'improvement': "⚠️ Por mejorar",
+ 'acceptable': "📈 Aceptable",
+ 'optimal': "✅ Óptimo",
+ 'target': "Meta: {:.2f}"
+ },
+ 'en': {
+ 'title': "Text Type",
+ 'vocabulary': "Vocabulary",
+ 'structure': "Structure",
+ 'cohesion': "Cohesion",
+ 'clarity': "Clarity",
+ 'improvement': "⚠️ Needs improvement",
+ 'acceptable': "📈 Acceptable",
+ 'optimal': "✅ Optimal",
+ 'target': "Target: {:.2f}"
+ },
+ 'fr': {
+ 'title': "Type de texte",
+ 'vocabulary': "Vocabulaire",
+ 'structure': "Structure",
+ 'cohesion': "Cohésion",
+ 'clarity': "Clarté",
+ 'improvement': "⚠️ À améliorer",
+ 'acceptable': "📈 Acceptable",
+ 'optimal': "✅ Optimal",
+ 'target': "Objectif: {:.2f}"
+ },
+ 'pt': {
+ 'title': "Tipo de texto",
+ 'vocabulary': "Vocabulário",
+ 'structure': "Estrutura",
+ 'cohesion': "Coesão",
+ 'clarity': "Clareza",
+ 'improvement': "⚠️ Precisa melhorar",
+ 'acceptable': "📈 Aceitável",
+ 'optimal': "✅ Ótimo",
+ 'target': "Meta: {:.2f}"
+ }
+ }
+
+ # Obtener traducciones para el idioma actual, con fallback a español
+ labels = dimension_labels.get(lang_code, dimension_labels['es'])
+
+ # Usar valor por defecto si no se especifica tipo
+ text_type = text_type or 'student_essay'
+
+ # Obtener umbrales según el tipo de texto
+ thresholds = TEXT_TYPES[text_type]['thresholds']
+
+ # Crear dos columnas para las métricas y el gráfico
+ metrics_col, graph_col = st.columns([1, 1.5])
+
+ # Columna de métricas
+ with metrics_col:
+ metrics_config = [
+ {
+ 'label': labels['vocabulary'],
+ 'key': 'vocabulary',
+ 'value': metrics['vocabulary']['normalized_score'],
+ 'help': t.get('vocabulary_help', "Riqueza y variedad del vocabulario"),
+ 'thresholds': thresholds['vocabulary']
+ },
+ {
+ 'label': labels['structure'],
+ 'key': 'structure',
+ 'value': metrics['structure']['normalized_score'],
+ 'help': t.get('structure_help', "Organización y complejidad de oraciones"),
+ 'thresholds': thresholds['structure']
+ },
+ {
+ 'label': labels['cohesion'],
+ 'key': 'cohesion',
+ 'value': metrics['cohesion']['normalized_score'],
+ 'help': t.get('cohesion_help', "Conexión y fluidez entre ideas"),
+ 'thresholds': thresholds['cohesion']
+ },
+ {
+ 'label': labels['clarity'],
+ 'key': 'clarity',
+ 'value': metrics['clarity']['normalized_score'],
+ 'help': t.get('clarity_help', "Facilidad de comprensión del texto"),
+ 'thresholds': thresholds['clarity']
+ }
+ ]
+
+ # Mostrar métricas con textos traducidos
+ for metric in metrics_config:
+ value = metric['value']
+ if value < metric['thresholds']['min']:
+ status = labels['improvement']
+ color = "inverse"
+ elif value < metric['thresholds']['target']:
+ status = labels['acceptable']
+ color = "off"
+ else:
+ status = labels['optimal']
+ color = "normal"
+
+ target_text = labels['target'].format(metric['thresholds']['target'])
+
+ st.metric(
+ metric['label'],
+ f"{value:.2f}",
+ f"{status} ({target_text})",
+ delta_color=color,
+ help=metric['help']
+ )
+ st.markdown("", unsafe_allow_html=True)
+
+ # Gráfico radar en la columna derecha
+ with graph_col:
+ display_radar_chart(metrics_config, thresholds, lang_code) # Pasar el parámetro lang_code
+
+ except Exception as e:
+ logger.error(f"Error mostrando resultados: {str(e)}")
+ st.error(t.get('error_results', "Error al mostrar los resultados"))
+
+##################################################################
+##################################################################
+def display_radar_chart(metrics_config, thresholds, lang_code='es'):
+ """
+ Muestra el gráfico radar con los resultados.
+ """
+ try:
+ # Traducción de las etiquetas de leyenda según el idioma
+ legend_translations = {
+ 'es': {'min': 'Mínimo', 'target': 'Meta', 'user': 'Tu escritura'},
+ 'en': {'min': 'Minimum', 'target': 'Target', 'user': 'Your writing'},
+ 'fr': {'min': 'Minimum', 'target': 'Objectif', 'user': 'Votre écriture'},
+ 'pt': {'min': 'Mínimo', 'target': 'Meta', 'user': 'Sua escrita'}
+ }
+
+ # Usar español por defecto si el idioma no está soportado
+ translations = legend_translations.get(lang_code, legend_translations['es'])
+
+ # Preparar datos para el gráfico
+ categories = [m['label'] for m in metrics_config]
+ values_user = [m['value'] for m in metrics_config]
+ min_values = [m['thresholds']['min'] for m in metrics_config]
+ target_values = [m['thresholds']['target'] for m in metrics_config]
+
+ # Crear y configurar gráfico
+ fig = plt.figure(figsize=(8, 8))
+ ax = fig.add_subplot(111, projection='polar')
+
+ # Configurar radar
+ angles = [n / float(len(categories)) * 2 * np.pi for n in range(len(categories))]
+ angles += angles[:1]
+ values_user += values_user[:1]
+ min_values += min_values[:1]
+ target_values += target_values[:1]
+
+ # Configurar ejes
+ ax.set_xticks(angles[:-1])
+ ax.set_xticklabels(categories, fontsize=10)
+ circle_ticks = np.arange(0, 1.1, 0.2)
+ ax.set_yticks(circle_ticks)
+ ax.set_yticklabels([f'{tick:.1f}' for tick in circle_ticks], fontsize=8)
+ ax.set_ylim(0, 1)
+
+ # Dibujar áreas de umbrales con etiquetas traducidas
+ ax.plot(angles, min_values, '#e74c3c', linestyle='--', linewidth=1, label=translations['min'], alpha=0.5)
+ ax.plot(angles, target_values, '#2ecc71', linestyle='--', linewidth=1, label=translations['target'], alpha=0.5)
+ ax.fill_between(angles, target_values, [1]*len(angles), color='#2ecc71', alpha=0.1)
+ ax.fill_between(angles, [0]*len(angles), min_values, color='#e74c3c', alpha=0.1)
+
+ # Dibujar valores del usuario con etiqueta traducida
+ ax.plot(angles, values_user, '#3498db', linewidth=2, label=translations['user'])
+ ax.fill(angles, values_user, '#3498db', alpha=0.2)
+
+ # Ajustar leyenda
+ ax.legend(
+ loc='upper right',
+ bbox_to_anchor=(1.3, 1.1),
+ fontsize=10,
+ frameon=True,
+ facecolor='white',
+ edgecolor='none',
+ shadow=True
+ )
+
+ plt.tight_layout()
+ st.pyplot(fig)
+ plt.close()
+
+ except Exception as e:
+ logger.error(f"Error mostrando gráfico radar: {str(e)}")
+ st.error("Error al mostrar el gráfico")
\ No newline at end of file
diff --git a/src/modules/studentact/student_activities.py b/src/modules/studentact/student_activities.py
new file mode 100644
index 0000000000000000000000000000000000000000..40b8e2a4ed849660561e2e7fb030d269f9080c07
--- /dev/null
+++ b/src/modules/studentact/student_activities.py
@@ -0,0 +1,111 @@
+#modules/studentact/student_activities.py
+
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import base64
+from io import BytesIO
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter
+from docx import Document
+from odf.opendocument import OpenDocumentText
+from odf.text import P
+from datetime import datetime, timedelta
+import pytz
+import logging
+
+# Configuración de logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Importaciones locales
+try:
+ from ..database.morphosintax_mongo_db import get_student_morphosyntax_data
+ from ..database.semantic_mongo_db import get_student_semantic_data
+ from ..database.discourse_mongo_db import get_student_discourse_data
+
+ from ..database.chat_mongo_db import get_chat_history
+
+ logger.info("Importaciones locales exitosas")
+except ImportError as e:
+ logger.error(f"Error en las importaciones locales: {e}")
+
+def display_student_progress(username, lang_code, t):
+ logger.debug(f"Iniciando display_student_progress para {username}")
+
+ st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
+
+ # Obtener los datos del estudiante
+ student_data = get_student_morphosyntax_data(username)
+
+ if not student_data or len(student_data.get('entries', [])) == 0:
+ logger.warning(f"No se encontraron datos para el estudiante {username}")
+ st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
+ st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
+ return
+
+ logger.debug(f"Datos del estudiante obtenidos: {len(student_data['entries'])} entradas")
+
+ # Resumen de actividades
+ with st.expander(t.get("activities_summary", "Resumen de Actividades"), expanded=True):
+ total_entries = len(student_data['entries'])
+ st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
+
+ # Gráfico de tipos de análisis
+ try:
+ analysis_types = [entry.get('analysis_type', 'unknown') for entry in student_data['entries']]
+ analysis_counts = pd.Series(analysis_types).value_counts()
+ fig, ax = plt.subplots()
+ sns.barplot(x=analysis_counts.index, y=analysis_counts.values, ax=ax)
+ ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
+ ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
+ ax.set_ylabel(t.get("count", "Cantidad"))
+ st.pyplot(fig)
+ except Exception as e:
+ logger.error(f"Error al crear el gráfico: {e}")
+ st.error("No se pudo crear el gráfico de tipos de análisis.")
+
+ # Función para generar el contenido del archivo de actividades de las últimas 48 horas
+ def generate_activity_content_48h():
+ content = f"Actividades de {username} en las últimas 48 horas\n\n"
+
+ two_days_ago = datetime.now(pytz.utc) - timedelta(days=2)
+
+ try:
+ morphosyntax_analyses = get_student_morphosyntax_data(username)
+ recent_morphosyntax = [a for a in morphosyntax_analyses if datetime.fromisoformat(a['timestamp']) > two_days_ago]
+
+ content += f"Análisis morfosintácticos: {len(recent_morphosyntax)}\n"
+ for analysis in recent_morphosyntax:
+ content += f"- Análisis del {analysis['timestamp']}: {analysis['text'][:50]}...\n"
+
+ chat_history = get_chat_history(username, None)
+ recent_chats = [c for c in chat_history if datetime.fromisoformat(c['timestamp']) > two_days_ago]
+
+ content += f"\nConversaciones de chat: {len(recent_chats)}\n"
+ for chat in recent_chats:
+ content += f"- Chat del {chat['timestamp']}: {len(chat['messages'])} mensajes\n"
+ except Exception as e:
+ logger.error(f"Error al generar el contenido de actividades: {e}")
+ content += "Error al recuperar los datos de actividades.\n"
+
+ return content
+
+ # Botones para descargar el histórico de actividades de las últimas 48 horas
+ st.subheader(t.get("download_history_48h", "Descargar Histórico de Actividades (Últimas 48 horas)"))
+ if st.button("Generar reporte de 48 horas"):
+ try:
+ report_content = generate_activity_content_48h()
+ st.text_area("Reporte de 48 horas", report_content, height=300)
+ st.download_button(
+ label="Descargar TXT (48h)",
+ data=report_content,
+ file_name="actividades_48h.txt",
+ mime="text/plain"
+ )
+ except Exception as e:
+ logger.error(f"Error al generar el reporte: {e}")
+ st.error("No se pudo generar el reporte. Por favor, verifica los logs para más detalles.")
+
+ logger.debug("Finalizando display_student_progress")
\ No newline at end of file
diff --git a/src/modules/studentact/student_activities_v2-complet.py b/src/modules/studentact/student_activities_v2-complet.py
new file mode 100644
index 0000000000000000000000000000000000000000..638797e45d311fa223873be6058fb6093a4fbcc8
--- /dev/null
+++ b/src/modules/studentact/student_activities_v2-complet.py
@@ -0,0 +1,794 @@
+##############
+###modules/studentact/student_activities_v2.py
+
+import streamlit as st
+import re
+import io
+from io import BytesIO
+import pandas as pd
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from datetime import datetime
+from spacy import displacy
+import random
+import base64
+import seaborn as sns
+import logging
+
+# Importaciones de la base de datos
+from ..database.morphosintax_mongo_db import get_student_morphosyntax_analysis
+from ..database.semantic_mongo_db import get_student_semantic_analysis
+from ..database.discourse_mongo_db import get_student_discourse_analysis
+from ..database.chat_mongo_db import get_chat_history
+
+logger = logging.getLogger(__name__)
+
+###################################################################################
+
+def display_student_activities(username: str, lang_code: str, t: dict):
+ """
+ Muestra todas las actividades del estudiante
+ Args:
+ username: Nombre del estudiante
+ lang_code: Código del idioma
+ t: Diccionario de traducciones
+ """
+ try:
+ st.header(t.get('activities_title', 'Mis Actividades'))
+
+ # Tabs para diferentes tipos de análisis
+ tabs = st.tabs([
+ t.get('morpho_activities', 'Análisis Morfosintáctico'),
+ t.get('semantic_activities', 'Análisis Semántico'),
+ t.get('discourse_activities', 'Análisis del Discurso'),
+ t.get('chat_activities', 'Conversaciones con el Asistente')
+ ])
+
+ # Tab de Análisis Morfosintáctico
+ with tabs[0]:
+ display_morphosyntax_activities(username, t)
+
+ # Tab de Análisis Semántico
+ with tabs[1]:
+ display_semantic_activities(username, t)
+
+ # Tab de Análisis del Discurso
+ with tabs[2]:
+ display_discourse_activities(username, t)
+
+ # Tab de Conversaciones del Chat
+ with tabs[3]:
+ display_chat_activities(username, t)
+
+ except Exception as e:
+ logger.error(f"Error mostrando actividades: {str(e)}")
+ st.error(t.get('error_loading_activities', 'Error al cargar las actividades'))
+
+
+###############################################################################################
+def display_morphosyntax_activities(username: str, t: dict):
+ """Muestra actividades de análisis morfosintáctico"""
+ try:
+ analyses = get_student_morphosyntax_analysis(username)
+ if not analyses:
+ st.info(t.get('no_morpho_analyses', 'No hay análisis morfosintácticos registrados'))
+ return
+
+ for analysis in analyses:
+ with st.expander(
+ f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}",
+ expanded=False
+ ):
+ st.text(f"{t.get('analyzed_text', 'Texto analizado')}:")
+ st.write(analysis['text'])
+
+ if 'arc_diagrams' in analysis:
+ st.subheader(t.get('syntactic_diagrams', 'Diagramas sintácticos'))
+ for diagram in analysis['arc_diagrams']:
+ st.write(diagram, unsafe_allow_html=True)
+
+ except Exception as e:
+ logger.error(f"Error mostrando análisis morfosintáctico: {str(e)}")
+ st.error(t.get('error_morpho', 'Error al mostrar análisis morfosintáctico'))
+
+
+###############################################################################################
+def display_semantic_activities(username: str, t: dict):
+ """Muestra actividades de análisis semántico"""
+ try:
+ logger.info(f"Recuperando análisis semántico para {username}")
+ analyses = get_student_semantic_analysis(username)
+
+ if not analyses:
+ logger.info("No se encontraron análisis semánticos")
+ st.info(t.get('no_semantic_analyses', 'No hay análisis semánticos registrados'))
+ return
+
+ logger.info(f"Procesando {len(analyses)} análisis semánticos")
+ for analysis in analyses:
+ try:
+ # Verificar campos mínimos necesarios
+ if not all(key in analysis for key in ['timestamp', 'concept_graph']):
+ logger.warning(f"Análisis incompleto: {analysis.keys()}")
+ continue
+
+ # Formatear fecha
+ timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
+ formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+
+ with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
+ if analysis['concept_graph']:
+ logger.debug("Decodificando gráfico de conceptos")
+ try:
+ image_bytes = base64.b64decode(analysis['concept_graph'])
+ st.image(image_bytes, use_column_width=True)
+ logger.debug("Gráfico mostrado exitosamente")
+ except Exception as img_error:
+ logger.error(f"Error decodificando imagen: {str(img_error)}")
+ st.error(t.get('error_loading_graph', 'Error al cargar el gráfico'))
+ else:
+ st.info(t.get('no_graph', 'No hay visualización disponible'))
+
+ except Exception as e:
+ logger.error(f"Error procesando análisis individual: {str(e)}")
+ continue
+
+ except Exception as e:
+ logger.error(f"Error mostrando análisis semántico: {str(e)}")
+ st.error(t.get('error_semantic', 'Error al mostrar análisis semántico'))
+
+
+###################################################################################################
+def display_discourse_activities(username: str, t: dict):
+ """Muestra actividades de análisis del discurso"""
+ try:
+ logger.info(f"Recuperando análisis del discurso para {username}")
+ analyses = get_student_discourse_analysis(username)
+
+ if not analyses:
+ logger.info("No se encontraron análisis del discurso")
+ st.info(t.get('no_discourse_analyses', 'No hay análisis del discurso registrados'))
+ return
+
+ logger.info(f"Procesando {len(analyses)} análisis del discurso")
+ for analysis in analyses:
+ try:
+ # Verificar campos mínimos necesarios
+ if not all(key in analysis for key in ['timestamp', 'combined_graph']):
+ logger.warning(f"Análisis incompleto: {analysis.keys()}")
+ continue
+
+ # Formatear fecha
+ timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
+ formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+
+ with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
+ if analysis['combined_graph']:
+ logger.debug("Decodificando gráfico combinado")
+ try:
+ image_bytes = base64.b64decode(analysis['combined_graph'])
+ st.image(image_bytes, use_column_width=True)
+ logger.debug("Gráfico mostrado exitosamente")
+ except Exception as img_error:
+ logger.error(f"Error decodificando imagen: {str(img_error)}")
+ st.error(t.get('error_loading_graph', 'Error al cargar el gráfico'))
+ else:
+ st.info(t.get('no_visualization', 'No hay visualización comparativa disponible'))
+
+ except Exception as e:
+ logger.error(f"Error procesando análisis individual: {str(e)}")
+ continue
+
+ except Exception as e:
+ logger.error(f"Error mostrando análisis del discurso: {str(e)}")
+ st.error(t.get('error_discourse', 'Error al mostrar análisis del discurso'))
+
+#################################################################################
+def display_discourse_comparison(analysis: dict, t: dict):
+ """Muestra la comparación de análisis del discurso"""
+ st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
+
+ col1, col2 = st.columns(2)
+ with col1:
+ st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
+ df1 = pd.DataFrame(analysis['key_concepts1'])
+ st.dataframe(df1)
+
+ with col2:
+ st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+ df2 = pd.DataFrame(analysis['key_concepts2'])
+ st.dataframe(df2)
+
+#################################################################################
+def display_chat_activities(username: str, t: dict):
+ """
+ Muestra historial de conversaciones del chat
+ """
+ try:
+ # Obtener historial del chat
+ chat_history = get_chat_history(
+ username=username,
+ analysis_type='sidebar',
+ limit=50
+ )
+
+ if not chat_history:
+ st.info(t.get('no_chat_history', 'No hay conversaciones registradas'))
+ return
+
+ for chat in reversed(chat_history): # Mostrar las más recientes primero
+ try:
+ # Convertir timestamp a datetime para formato
+ timestamp = datetime.fromisoformat(chat['timestamp'].replace('Z', '+00:00'))
+ formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+
+ with st.expander(
+ f"{t.get('chat_date', 'Fecha de conversación')}: {formatted_date}",
+ expanded=False
+ ):
+ if 'messages' in chat and chat['messages']:
+ # Mostrar cada mensaje en la conversación
+ for message in chat['messages']:
+ role = message.get('role', 'unknown')
+ content = message.get('content', '')
+
+ # Usar el componente de chat de Streamlit
+ with st.chat_message(role):
+ st.markdown(content)
+
+ # Agregar separador entre mensajes
+ st.divider()
+ else:
+ st.warning(t.get('invalid_chat_format', 'Formato de chat no válido'))
+
+ except Exception as e:
+ logger.error(f"Error mostrando conversación: {str(e)}")
+ continue
+
+ except Exception as e:
+ logger.error(f"Error mostrando historial del chat: {str(e)}")
+ st.error(t.get('error_chat', 'Error al mostrar historial del chat'))
+
+
+
+
+
+
+
+
+
+'''
+##########versión 25-9-2024---02:30 ################ OK (username)####################
+
+def display_student_progress(username, lang_code, t, student_data):
+ st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
+
+ if not student_data or len(student_data.get('entries', [])) == 0:
+ st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
+ st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
+ return
+
+ with st.expander(t.get("activities_summary", "Resumen de Actividades"), expanded=True):
+ total_entries = len(student_data['entries'])
+ st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
+
+ # Gráfico de tipos de análisis
+ analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
+ analysis_counts = pd.Series(analysis_types).value_counts()
+ fig, ax = plt.subplots()
+ analysis_counts.plot(kind='bar', ax=ax)
+ ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
+ ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
+ ax.set_ylabel(t.get("count", "Cantidad"))
+ st.pyplot(fig)
+
+ # Mostrar los últimos análisis morfosintácticos
+ with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
+ morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
+ for entry in morphosyntax_entries[:5]: # Mostrar los últimos 5
+ st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
+ if 'arc_diagrams' in entry and entry['arc_diagrams']:
+ st.components.v1.html(entry['arc_diagrams'][0], height=300, scrolling=True)
+
+ # Añadir secciones similares para análisis semánticos y discursivos si es necesario
+
+ # Mostrar el historial de chat
+ with st.expander(t.get("chat_history", "Historial de Chat")):
+ if 'chat_history' in student_data:
+ for chat in student_data['chat_history'][:5]: # Mostrar las últimas 5 conversaciones
+ st.subheader(f"{t.get('chat_from', 'Chat del')} {chat['timestamp']}")
+ for message in chat['messages']:
+ st.write(f"{message['role'].capitalize()}: {message['content']}")
+ st.write("---")
+ else:
+ st.write(t.get("no_chat_history", "No hay historial de chat disponible."))
+
+
+##########versión 24-9-2024---17:30 ################ OK FROM--V2 de def get_student_data(username)####################
+
+def display_student_progress(username, lang_code, t, student_data):
+ if not student_data or len(student_data['entries']) == 0:
+ st.warning(t.get("no_data_warning", "No se encontraron datos para este estudiante."))
+ st.info(t.get("try_analysis", "Intenta realizar algunos análisis de texto primero."))
+ return
+
+ st.title(f"{t.get('progress_of', 'Progreso de')} {username}")
+
+ with st.expander(t.get("activities_summary", "Resumen de Actividades y Progreso"), expanded=True):
+ total_entries = len(student_data['entries'])
+ st.write(f"{t.get('total_analyses', 'Total de análisis realizados')}: {total_entries}")
+
+ # Gráfico de tipos de análisis
+ analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
+ analysis_counts = pd.Series(analysis_types).value_counts()
+
+ fig, ax = plt.subplots(figsize=(8, 4))
+ analysis_counts.plot(kind='bar', ax=ax)
+ ax.set_title(t.get("analysis_types_chart", "Tipos de análisis realizados"))
+ ax.set_xlabel(t.get("analysis_type", "Tipo de análisis"))
+ ax.set_ylabel(t.get("count", "Cantidad"))
+ st.pyplot(fig)
+
+ # Histórico de Análisis Morfosintácticos
+ with st.expander(t.get("morphosyntax_history", "Histórico de Análisis Morfosintácticos")):
+ morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
+ if not morphosyntax_entries:
+ st.warning("No se encontraron análisis morfosintácticos.")
+ for entry in morphosyntax_entries:
+ st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
+ if 'arc_diagrams' in entry and entry['arc_diagrams']:
+ try:
+ st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
+ except Exception as e:
+ logger.error(f"Error al mostrar diagrama de arco: {str(e)}")
+ st.error("Error al mostrar el diagrama de arco.")
+ else:
+ st.write(t.get("no_arc_diagram", "No se encontró diagrama de arco para este análisis."))
+
+ # Histórico de Análisis Semánticos
+ with st.expander(t.get("semantic_history", "Histórico de Análisis Semánticos")):
+ semantic_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
+ if not semantic_entries:
+ st.warning("No se encontraron análisis semánticos.")
+ for entry in semantic_entries:
+ st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
+ if 'key_concepts' in entry:
+ st.write(t.get("key_concepts", "Conceptos clave:"))
+ concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts']])
+ st.markdown(f"{concepts_str}
", unsafe_allow_html=True)
+ if 'graph' in entry:
+ try:
+ img_bytes = base64.b64decode(entry['graph'])
+ st.image(img_bytes, caption=t.get("conceptual_relations_graph", "Gráfico de relaciones conceptuales"))
+ except Exception as e:
+ logger.error(f"Error al mostrar gráfico semántico: {str(e)}")
+ st.error(t.get("graph_display_error", f"No se pudo mostrar el gráfico: {str(e)}"))
+
+ # Histórico de Análisis Discursivos
+ with st.expander(t.get("discourse_history", "Histórico de Análisis Discursivos")):
+ discourse_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
+ for entry in discourse_entries:
+ st.subheader(f"{t.get('analysis_of', 'Análisis del')} {entry['timestamp']}")
+ for i in [1, 2]:
+ if f'key_concepts{i}' in entry:
+ st.write(f"{t.get('key_concepts', 'Conceptos clave')} {t.get('document', 'documento')} {i}:")
+ concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry[f'key_concepts{i}']])
+ st.markdown(f"{concepts_str}
", unsafe_allow_html=True)
+ try:
+ if 'combined_graph' in entry and entry['combined_graph']:
+ img_bytes = base64.b64decode(entry['combined_graph'])
+ st.image(img_bytes, caption=t.get("combined_graph", "Gráfico combinado"))
+ elif 'graph1' in entry and 'graph2' in entry:
+ col1, col2 = st.columns(2)
+ with col1:
+ if entry['graph1']:
+ img_bytes1 = base64.b64decode(entry['graph1'])
+ st.image(img_bytes1, caption=t.get("graph_doc1", "Gráfico documento 1"))
+ with col2:
+ if entry['graph2']:
+ img_bytes2 = base64.b64decode(entry['graph2'])
+ st.image(img_bytes2, caption=t.get("graph_doc2", "Gráfico documento 2"))
+ except Exception as e:
+ st.error(t.get("graph_display_error", f"No se pudieron mostrar los gráficos: {str(e)}"))
+
+ # Histórico de Conversaciones con el ChatBot
+ with st.expander(t.get("chatbot_history", "Histórico de Conversaciones con el ChatBot")):
+ if 'chat_history' in student_data and student_data['chat_history']:
+ for i, chat in enumerate(student_data['chat_history']):
+ st.subheader(f"{t.get('conversation', 'Conversación')} {i+1} - {chat['timestamp']}")
+ for message in chat['messages']:
+ if message['role'] == 'user':
+ st.write(f"{t.get('user', 'Usuario')}: {message['content']}")
+ else:
+ st.write(f"{t.get('assistant', 'Asistente')}: {message['content']}")
+ st.write("---")
+ else:
+ st.write(t.get("no_chat_history", "No se encontraron conversaciones con el ChatBot."))
+
+ # Añadir logs para depuración
+ if st.checkbox(t.get("show_debug_data", "Mostrar datos de depuración")):
+ st.write(t.get("student_debug_data", "Datos del estudiante (para depuración):"))
+ st.json(student_data)
+
+ # Mostrar conteo de tipos de análisis
+ analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
+ type_counts = {t: analysis_types.count(t) for t in set(analysis_types)}
+ st.write("Conteo de tipos de análisis:")
+ st.write(type_counts)
+
+
+#############################--- Update 16:00 24-9 #########################################
+def display_student_progress(username, lang_code, t, student_data):
+ try:
+ st.subheader(t.get('student_activities', 'Student Activitie'))
+
+ if not student_data or all(len(student_data.get(key, [])) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
+ st.warning(t.get('no_data_warning', 'No analysis data found for this student.'))
+ return
+
+ # Resumen de actividades
+ total_analyses = sum(len(student_data.get(key, [])) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
+ st.write(f"{t.get('total_analyses', 'Total analyses performed')}: {total_analyses}")
+
+ # Gráfico de tipos de análisis
+ analysis_counts = {
+ t.get('morpho_analyses', 'Morphosyntactic Analyses'): len(student_data.get('morphosyntax_analyses', [])),
+ t.get('semantic_analyses', 'Semantic Analyses'): len(student_data.get('semantic_analyses', [])),
+ t.get('discourse_analyses', 'Discourse Analyses'): len(student_data.get('discourse_analyses', []))
+ }
+ # Configurar el estilo de seaborn para un aspecto más atractivo
+ sns.set_style("whitegrid")
+
+ # Crear una figura más pequeña
+ fig, ax = plt.subplots(figsize=(6, 4))
+
+ # Usar colores más atractivos
+ colors = ['#ff9999', '#66b3ff', '#99ff99']
+
+ # Crear el gráfico de barras
+ bars = ax.bar(analysis_counts.keys(), analysis_counts.values(), color=colors)
+
+ # Añadir etiquetas de valor encima de cada barra
+ for bar in bars:
+ height = bar.get_height()
+ ax.text(bar.get_x() + bar.get_width()/2., height,
+ f'{height}',
+ ha='center', va='bottom')
+
+ # Configurar el título y las etiquetas
+ ax.set_title(t.get('analysis_types_chart', 'Types of analyses performed'), fontsize=12)
+ ax.set_ylabel(t.get('count', 'Count'), fontsize=10)
+
+ # Rotar las etiquetas del eje x para mejor legibilidad
+ plt.xticks(rotation=45, ha='right')
+
+ # Ajustar el diseño para que todo quepa
+ plt.tight_layout()
+
+ # Mostrar el gráfico en Streamlit
+ st.pyplot(fig)
+
+ # Mostrar los últimos análisis
+ for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
+ with st.expander(t.get(f'{analysis_type}_expander', f'{analysis_type.capitalize()} History')):
+ for analysis in student_data.get(analysis_type, [])[:5]: # Mostrar los últimos 5
+ st.subheader(f"{t.get('analysis_from', 'Analysis from')} {analysis.get('timestamp', 'N/A')}")
+ if analysis_type == 'morphosyntax_analyses':
+ if 'arc_diagrams' in analysis:
+ st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
+ elif analysis_type == 'semantic_analyses':
+ if 'key_concepts' in analysis:
+ st.write(t.get('key_concepts', 'Key concepts'))
+ st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
+ if 'graph' in analysis:
+ st.image(base64.b64decode(analysis['graph']))
+ elif analysis_type == 'discourse_analyses':
+ for i in [1, 2]:
+ if f'key_concepts{i}' in analysis:
+ st.write(f"{t.get('key_concepts', 'Key concepts')} {t.get('document', 'Document')} {i}")
+ st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
+ if 'combined_graph' in analysis:
+ st.image(base64.b64decode(analysis['combined_graph']))
+
+ # Mostrar el historial de chat
+ with st.expander(t.get('chat_history_expander', 'Chat History')):
+ for chat in student_data.get('chat_history', [])[:5]: # Mostrar las últimas 5 conversaciones
+ st.subheader(f"{t.get('chat_from', 'Chat from')} {chat.get('timestamp', 'N/A')}")
+ for message in chat.get('messages', []):
+ st.write(f"{message.get('role', 'Unknown').capitalize()}: {message.get('content', 'No content')}")
+ st.write("---")
+
+ except Exception as e:
+ logger.error(f"Error in display_student_progress: {str(e)}", exc_info=True)
+ st.error(t.get('error_loading_progress', 'Error loading student progress. Please try again later.'))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#####################################################################
+def display_student_progress(username, lang_code, t, student_data):
+ st.subheader(t['student_progress'])
+
+ if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
+ st.warning(t['no_data_warning'])
+ return
+
+ # Resumen de actividades
+ total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
+ st.write(f"{t['total_analyses']}: {total_analyses}")
+
+ # Gráfico de tipos de análisis
+ analysis_counts = {
+ t['morpho_analyses']: len(student_data['morphosyntax_analyses']),
+ t['semantic_analyses']: len(student_data['semantic_analyses']),
+ t['discourse_analyses']: len(student_data['discourse_analyses'])
+ }
+ fig, ax = plt.subplots()
+ ax.bar(analysis_counts.keys(), analysis_counts.values())
+ ax.set_title(t['analysis_types_chart'])
+ st.pyplot(fig)
+
+ # Mostrar los últimos análisis
+ for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
+ with st.expander(t[f'{analysis_type}_expander']):
+ for analysis in student_data[analysis_type][:5]: # Mostrar los últimos 5
+ st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
+ if analysis_type == 'morphosyntax_analyses':
+ if 'arc_diagrams' in analysis:
+ st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
+ elif analysis_type == 'semantic_analyses':
+ if 'key_concepts' in analysis:
+ st.write(t['key_concepts'])
+ st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
+ if 'graph' in analysis:
+ st.image(base64.b64decode(analysis['graph']))
+ elif analysis_type == 'discourse_analyses':
+ for i in [1, 2]:
+ if f'key_concepts{i}' in analysis:
+ st.write(f"{t['key_concepts']} {t['document']} {i}")
+ st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
+ if 'combined_graph' in analysis:
+ st.image(base64.b64decode(analysis['combined_graph']))
+
+ # Mostrar el historial de chat
+ with st.expander(t['chat_history_expander']):
+ for chat in student_data['chat_history'][:5]: # Mostrar las últimas 5 conversaciones
+ st.subheader(f"{t['chat_from']} {chat['timestamp']}")
+ for message in chat['messages']:
+ st.write(f"{message['role'].capitalize()}: {message['content']}")
+ st.write("---")
+
+
+
+def display_student_progress(username, lang_code, t, student_data):
+ st.subheader(t['student_activities'])
+
+ if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
+ st.warning(t['no_data_warning'])
+ return
+
+ # Resumen de actividades
+ total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
+ st.write(f"{t['total_analyses']}: {total_analyses}")
+
+ # Gráfico de tipos de análisis
+ analysis_counts = {
+ t['morphological_analysis']: len(student_data['morphosyntax_analyses']),
+ t['semantic_analyses']: len(student_data['semantic_analyses']),
+ t['discourse_analyses']: len(student_data['discourse_analyses'])
+ }
+ fig, ax = plt.subplots()
+ ax.bar(analysis_counts.keys(), analysis_counts.values())
+ ax.set_title(t['analysis_types_chart'])
+ st.pyplot(fig)
+
+ # Mostrar los últimos análisis
+ for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
+ with st.expander(t[f'{analysis_type}_expander']):
+ for analysis in student_data[analysis_type][:5]: # Mostrar los últimos 5
+ st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
+ if analysis_type == 'morphosyntax_analyses':
+ if 'arc_diagrams' in analysis:
+ st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
+ elif analysis_type == 'semantic_analyses':
+ if 'key_concepts' in analysis:
+ st.write(t['key_concepts'])
+ st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
+ if 'graph' in analysis:
+ st.image(base64.b64decode(analysis['graph']))
+ elif analysis_type == 'discourse_analyses':
+ for i in [1, 2]:
+ if f'key_concepts{i}' in analysis:
+ st.write(f"{t['key_concepts']} {t['document']} {i}")
+ st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
+ if 'combined_graph' in analysis:
+ st.image(base64.b64decode(analysis['combined_graph']))
+
+ # Mostrar el historial de chat
+ with st.expander(t['chat_history_expander']):
+ for chat in student_data['chat_history'][:5]: # Mostrar las últimas 5 conversaciones
+ st.subheader(f"{t['chat_from']} {chat['timestamp']}")
+ for message in chat['messages']:
+ st.write(f"{message['role'].capitalize()}: {message['content']}")
+ st.write("---")
+
+
+
+
+def display_student_progress(username, lang_code, t, student_data):
+ st.subheader(t['student_activities'])
+
+ if not student_data or all(len(student_data[key]) == 0 for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']):
+ st.warning(t['no_data_warning'])
+ return
+
+ # Resumen de actividades
+ total_analyses = sum(len(student_data[key]) for key in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses'])
+ st.write(f"{t['total_analyses']}: {total_analyses}")
+
+ # Gráfico de tipos de análisis
+ analysis_counts = {
+ t['morphological_analysis']: len(student_data['morphosyntax_analyses']),
+ t['semantic_analyses']: len(student_data['semantic_analyses']),
+ t['discourse_analyses']: len(student_data['discourse_analyses'])
+ }
+ fig, ax = plt.subplots()
+ ax.bar(analysis_counts.keys(), analysis_counts.values())
+ ax.set_title(t['analysis_types_chart'])
+ st.pyplot(fig)
+
+ # Mostrar los últimos análisis
+ for analysis_type in ['morphosyntax_analyses', 'semantic_analyses', 'discourse_analyses']:
+ with st.expander(t[f'{analysis_type}_expander']):
+ for analysis in student_data[analysis_type][:5]: # Mostrar los últimos 5
+ st.subheader(f"{t['analysis_from']} {analysis['timestamp']}")
+ if analysis_type == 'morphosyntax_analyses':
+ if 'arc_diagrams' in analysis:
+ st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
+ elif analysis_type == 'semantic_analyses':
+ if 'key_concepts' in analysis:
+ st.write(t['key_concepts'])
+ st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis['key_concepts']]))
+ if 'graph' in analysis:
+ st.image(base64.b64decode(analysis['graph']))
+ elif analysis_type == 'discourse_analyses':
+ for i in [1, 2]:
+ if f'key_concepts{i}' in analysis:
+ st.write(f"{t['key_concepts']} {t['document']} {i}")
+ st.write(", ".join([f"{concept} ({freq:.2f})" for concept, freq in analysis[f'key_concepts{i}']]))
+ if 'combined_graph' in analysis:
+ st.image(base64.b64decode(analysis['combined_graph']))
+
+ # Mostrar el historial de chat
+ with st.expander(t['chat_history_expander']):
+ for chat in student_data['chat_history'][:5]: # Mostrar las últimas 5 conversaciones
+ st.subheader(f"{t['chat_from']} {chat['timestamp']}")
+ for message in chat['messages']:
+ st.write(f"{message['role'].capitalize()}: {message['content']}")
+ st.write("---")
+
+
+
+
+def display_student_progress(username, lang_code, t):
+ st.subheader(t['student_activities'])
+ st.write(f"{t['activities_message']} {username}")
+
+ # Aquí puedes agregar más contenido estático o placeholder
+ st.info(t['activities_placeholder'])
+
+ # Si necesitas mostrar algún dato, puedes usar datos de ejemplo o placeholders
+ col1, col2, col3 = st.columns(3)
+ col1.metric(t['morpho_analyses'], "5") # Ejemplo de dato
+ col2.metric(t['semantic_analyses'], "3") # Ejemplo de dato
+ col3.metric(t['discourse_analyses'], "2") # Ejemplo de dato
+
+
+
+def display_student_progress(username, lang_code, t):
+ st.title(f"Actividades de {username}")
+
+ # Obtener todos los datos del estudiante
+ student_data = get_student_data(username)
+
+ if not student_data or len(student_data.get('entries', [])) == 0:
+ st.warning("No se encontraron datos de análisis para este estudiante.")
+ st.info("Intenta realizar algunos análisis de texto primero.")
+ return
+
+ # Resumen de actividades
+ with st.expander("Resumen de Actividades", expanded=True):
+ total_entries = len(student_data['entries'])
+ st.write(f"Total de análisis realizados: {total_entries}")
+
+ # Gráfico de tipos de análisis
+ analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
+ analysis_counts = pd.Series(analysis_types).value_counts()
+ fig, ax = plt.subplots()
+ analysis_counts.plot(kind='bar', ax=ax)
+ ax.set_title("Tipos de análisis realizados")
+ ax.set_xlabel("Tipo de análisis")
+ ax.set_ylabel("Cantidad")
+ st.pyplot(fig)
+
+ # Histórico de Análisis Morfosintácticos
+ with st.expander("Histórico de Análisis Morfosintácticos"):
+ morpho_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
+ for analysis in morpho_analyses[:5]: # Mostrar los últimos 5
+ st.subheader(f"Análisis del {analysis['timestamp']}")
+ if 'arc_diagrams' in analysis:
+ st.write(analysis['arc_diagrams'][0], unsafe_allow_html=True)
+
+ # Histórico de Análisis Semánticos
+ with st.expander("Histórico de Análisis Semánticos"):
+ semantic_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
+ for analysis in semantic_analyses[:5]: # Mostrar los últimos 5
+ st.subheader(f"Análisis del {analysis['timestamp']}")
+ if 'key_concepts' in analysis:
+ concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis['key_concepts']])
+ st.markdown(f"{concepts_str}
", unsafe_allow_html=True)
+ if 'graph' in analysis:
+ try:
+ img_bytes = base64.b64decode(analysis['graph'])
+ st.image(img_bytes, caption="Gráfico de relaciones conceptuales")
+ except Exception as e:
+ st.error(f"No se pudo mostrar el gráfico: {str(e)}")
+
+ # Histórico de Análisis Discursivos
+ with st.expander("Histórico de Análisis Discursivos"):
+ discourse_analyses = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
+ for analysis in discourse_analyses[:5]: # Mostrar los últimos 5
+ st.subheader(f"Análisis del {analysis['timestamp']}")
+ for i in [1, 2]:
+ if f'key_concepts{i}' in analysis:
+ concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in analysis[f'key_concepts{i}']])
+ st.write(f"Conceptos clave del documento {i}:")
+ st.markdown(f"{concepts_str}
", unsafe_allow_html=True)
+ if 'combined_graph' in analysis:
+ try:
+ img_bytes = base64.b64decode(analysis['combined_graph'])
+ st.image(img_bytes)
+ except Exception as e:
+ st.error(f"No se pudo mostrar el gráfico combinado: {str(e)}")
+
+ # Histórico de Conversaciones con el ChatBot
+ with st.expander("Histórico de Conversaciones con el ChatBot"):
+ if 'chat_history' in student_data:
+ for i, chat in enumerate(student_data['chat_history'][:5]): # Mostrar las últimas 5 conversaciones
+ st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
+ for message in chat['messages']:
+ st.write(f"{message['role'].capitalize()}: {message['content']}")
+ st.write("---")
+ else:
+ st.write("No se encontraron conversaciones con el ChatBot.")
+
+ # Opción para mostrar datos de depuración
+ if st.checkbox("Mostrar datos de depuración"):
+ st.write("Datos del estudiante (para depuración):")
+ st.json(student_data)
+
+'''
\ No newline at end of file
diff --git a/src/modules/studentact/student_activities_v2-error.py b/src/modules/studentact/student_activities_v2-error.py
new file mode 100644
index 0000000000000000000000000000000000000000..864574edcf68c27f3fd935eda8799efa8308d28e
--- /dev/null
+++ b/src/modules/studentact/student_activities_v2-error.py
@@ -0,0 +1,251 @@
+##############
+###modules/studentact/student_activities_v2.py
+
+import streamlit as st
+import re
+import io
+from io import BytesIO
+import pandas as pd
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from datetime import datetime
+from spacy import displacy
+import random
+import base64
+import seaborn as sns
+import logging
+
+# Importaciones de la base de datos
+from ..database.morphosintax_mongo_db import get_student_morphosyntax_analysis
+from ..database.semantic_mongo_db import get_student_semantic_analysis
+from ..database.discourse_mongo_db import get_student_discourse_analysis
+from ..database.chat_mongo_db import get_chat_history
+
+logger = logging.getLogger(__name__)
+
+###################################################################################
+def display_student_activities(username: str, lang_code: str, t: dict):
+ """
+ Muestra todas las actividades del estudiante
+ Args:
+ username: Nombre del estudiante
+ lang_code: Código del idioma
+ t: Diccionario de traducciones
+ """
+ try:
+ st.header(t.get('activities_title', 'Mis Actividades'))
+
+ # Tabs para diferentes tipos de análisis
+ tabs = st.tabs([
+ t.get('morpho_activities', 'Análisis Morfosintáctico'),
+ t.get('semantic_activities', 'Análisis Semántico'),
+ t.get('discourse_activities', 'Análisis del Discurso'),
+ t.get('chat_activities', 'Conversaciones con el Asistente')
+ ])
+
+ # Tab de Análisis Morfosintáctico
+ with tabs[0]:
+ display_morphosyntax_activities(username, t)
+
+ # Tab de Análisis Semántico
+ with tabs[1]:
+ display_semantic_activities(username, t)
+
+ # Tab de Análisis del Discurso
+ with tabs[2]:
+ display_discourse_activities(username, t)
+
+ # Tab de Conversaciones del Chat
+ with tabs[3]:
+ display_chat_activities(username, t)
+
+ except Exception as e:
+ logger.error(f"Error mostrando actividades: {str(e)}")
+ st.error(t.get('error_loading_activities', 'Error al cargar las actividades'))
+
+###################################################################################
+def display_morphosyntax_activities(username: str, t: dict):
+ """Muestra actividades de análisis morfosintáctico"""
+ try:
+ analyses = get_student_morphosyntax_analysis(username)
+ if not analyses:
+ st.info(t.get('no_morpho_analyses', 'No hay análisis morfosintácticos registrados'))
+ return
+
+ for analysis in analyses:
+ with st.expander(
+ f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}",
+ expanded=False
+ ):
+ st.text(f"{t.get('analyzed_text', 'Texto analizado')}:")
+ st.write(analysis['text'])
+
+ if 'arc_diagrams' in analysis:
+ st.subheader(t.get('syntactic_diagrams', 'Diagramas sintácticos'))
+ for diagram in analysis['arc_diagrams']:
+ st.write(diagram, unsafe_allow_html=True)
+
+ except Exception as e:
+ logger.error(f"Error mostrando análisis morfosintáctico: {str(e)}")
+ st.error(t.get('error_morpho', 'Error al mostrar análisis morfosintáctico'))
+
+###################################################################################
+def display_semantic_activities(username: str, t: dict):
+ """Muestra actividades de análisis semántico"""
+ try:
+ analyses = get_student_semantic_analysis(username)
+ if not analyses:
+ st.info(t.get('no_semantic_analyses', 'No hay análisis semánticos registrados'))
+ return
+
+ for analysis in analyses:
+ with st.expander(
+ f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}",
+ expanded=False
+ ):
+
+ # Mostrar conceptos clave
+ if 'key_concepts' in analysis:
+ st.subheader(t.get('key_concepts', 'Conceptos clave'))
+ df = pd.DataFrame(
+ analysis['key_concepts'],
+ columns=['Concepto', 'Frecuencia']
+ )
+ st.dataframe(df)
+
+ # Mostrar gráfico de conceptos
+ if 'concept_graph' in analysis and analysis['concept_graph']:
+ st.subheader(t.get('concept_graph', 'Grafo de conceptos'))
+ image_bytes = base64.b64decode(analysis['concept_graph'])
+ st.image(image_bytes)
+
+ except Exception as e:
+ logger.error(f"Error mostrando análisis semántico: {str(e)}")
+ st.error(t.get('error_semantic', 'Error al mostrar análisis semántico'))
+
+###################################################################################
+
+def display_discourse_activities(username: str, t: dict):
+ """Muestra actividades de análisis del discurso"""
+ try:
+ analyses = get_student_discourse_analysis(username)
+ if not analyses:
+ st.info(t.get('no_discourse_analyses', 'No hay análisis del discurso registrados'))
+ return
+
+ for analysis in analyses:
+ with st.expander(
+ f"{t.get('analysis_date', 'Fecha')}: {analysis['timestamp']}",
+ expanded=False
+ ):
+
+ # Mostrar conceptos clave
+ if 'key_concepts1' in analysis and 'key_concepts2' in analysis:
+ st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
+
+ col1, col2 = st.columns(2)
+ with col1:
+ st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
+ df1 = pd.DataFrame(
+ analysis['key_concepts1'],
+ columns=['Concepto', 'Frecuencia']
+ )
+ st.dataframe(df1)
+
+ with col2:
+ st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+ df2 = pd.DataFrame(
+ analysis['key_concepts2'],
+ columns=['Concepto', 'Frecuencia']
+ )
+ st.dataframe(df2)
+
+ # Mostrar gráficos
+ if all(key in analysis for key in ['graph1', 'graph2']):
+ st.subheader(t.get('visualizations', 'Visualizaciones'))
+
+ col1, col2 = st.columns(2)
+ with col1:
+ st.markdown(f"**{t.get('graph_text_1', 'Grafo Texto 1')}**")
+ if analysis['graph1']:
+ image_bytes = base64.b64decode(analysis['graph1'])
+ st.image(image_bytes)
+
+ with col2:
+ st.markdown(f"**{t.get('graph_text_2', 'Grafo Texto 2')}**")
+ if analysis['graph2']:
+ image_bytes = base64.b64decode(analysis['graph2'])
+ st.image(image_bytes)
+
+ except Exception as e:
+ logger.error(f"Error mostrando análisis del discurso: {str(e)}")
+ st.error(t.get('error_discourse', 'Error al mostrar análisis del discurso'))
+#################################################################################
+
+def display_discourse_comparison(analysis: dict, t: dict):
+ """Muestra la comparación de análisis del discurso"""
+ st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
+
+ col1, col2 = st.columns(2)
+ with col1:
+ st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
+ df1 = pd.DataFrame(analysis['key_concepts1'])
+ st.dataframe(df1)
+
+ with col2:
+ st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+ df2 = pd.DataFrame(analysis['key_concepts2'])
+ st.dataframe(df2)
+
+#################################################################################
+
+
+def display_chat_activities(username: str, t: dict):
+ """
+ Muestra historial de conversaciones del chat
+ """
+ try:
+ # Obtener historial del chat
+ chat_history = get_chat_history(
+ username=username,
+ analysis_type='sidebar',
+ limit=50
+ )
+
+ if not chat_history:
+ st.info(t.get('no_chat_history', 'No hay conversaciones registradas'))
+ return
+
+ for chat in reversed(chat_history): # Mostrar las más recientes primero
+ try:
+ # Convertir timestamp a datetime para formato
+ timestamp = datetime.fromisoformat(chat['timestamp'].replace('Z', '+00:00'))
+ formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+
+ with st.expander(
+ f"{t.get('chat_date', 'Fecha de conversación')}: {formatted_date}",
+ expanded=False
+ ):
+ if 'messages' in chat and chat['messages']:
+ # Mostrar cada mensaje en la conversación
+ for message in chat['messages']:
+ role = message.get('role', 'unknown')
+ content = message.get('content', '')
+
+ # Usar el componente de chat de Streamlit
+ with st.chat_message(role):
+ st.markdown(content)
+
+ # Agregar separador entre mensajes
+ st.divider()
+ else:
+ st.warning(t.get('invalid_chat_format', 'Formato de chat no válido'))
+
+ except Exception as e:
+ logger.error(f"Error mostrando conversación: {str(e)}")
+ continue
+
+ except Exception as e:
+ logger.error(f"Error mostrando historial del chat: {str(e)}")
+ st.error(t.get('error_chat', 'Error al mostrar historial del chat'))
\ No newline at end of file
diff --git a/src/modules/studentact/student_activities_v2.py b/src/modules/studentact/student_activities_v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f8eac7f06cd9d1ee1ba97b59dea5d31f03873c2
--- /dev/null
+++ b/src/modules/studentact/student_activities_v2.py
@@ -0,0 +1,780 @@
+##############
+###modules/studentact/student_activities_v2.py
+
+import streamlit as st
+import re
+import io
+from io import BytesIO
+import pandas as pd
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from datetime import datetime, timedelta
+from spacy import displacy
+import random
+import base64
+import seaborn as sns
+import logging
+
+# Importaciones de la base de datos
+from ..database.morphosintax_mongo_db import get_student_morphosyntax_analysis
+from ..database.semantic_mongo_db import get_student_semantic_analysis
+from ..database.discourse_mongo_db import get_student_discourse_analysis
+from ..database.chat_mongo_db import get_chat_history
+from ..database.current_situation_mongo_db import get_current_situation_analysis
+from ..database.claude_recommendations_mongo_db import get_claude_recommendations
+
+# Importar la función generate_unique_key
+from ..utils.widget_utils import generate_unique_key
+
+logger = logging.getLogger(__name__)
+
+###################################################################################
+
+def display_student_activities(username: str, lang_code: str, t: dict):
+ """
+ Muestra todas las actividades del estudiante
+ Args:
+ username: Nombre del estudiante
+ lang_code: Código del idioma
+ t: Diccionario de traducciones
+ """
+ try:
+ # Cambiado de "Mis Actividades" a "Registro de mis actividades"
+ #st.header(t.get('activities_title', 'Registro de mis actividades'))
+
+ # Tabs para diferentes tipos de análisis
+ # Cambiado "Análisis del Discurso" a "Análisis comparado de textos"
+ tabs = st.tabs([
+ t.get('current_situation_activities', 'Registros de la función: Mi Situación Actual'),
+ t.get('morpho_activities', 'Registros de mis análisis morfosintácticos'),
+ t.get('semantic_activities', 'Registros de mis análisis semánticos'),
+ t.get('discourse_activities', 'Registros de mis análisis comparado de textos'),
+ t.get('chat_activities', 'Registros de mis conversaciones con el tutor virtual')
+ ])
+
+ # Tab de Situación Actual
+ with tabs[0]:
+ display_current_situation_activities(username, t)
+
+ # Tab de Análisis Morfosintáctico
+ with tabs[1]:
+ display_morphosyntax_activities(username, t)
+
+ # Tab de Análisis Semántico
+ with tabs[2]:
+ display_semantic_activities(username, t)
+
+ # Tab de Análisis del Discurso (mantiene nombre interno pero UI muestra "Análisis comparado de textos")
+ with tabs[3]:
+ display_discourse_activities(username, t)
+
+ # Tab de Conversaciones del Chat
+ with tabs[4]:
+ display_chat_activities(username, t)
+
+ except Exception as e:
+ logger.error(f"Error mostrando actividades: {str(e)}")
+ st.error(t.get('error_loading_activities', 'Error al cargar las actividades'))
+
+
+###############################################################################################
+
+def display_current_situation_activities(username: str, t: dict):
+ """
+ Muestra análisis de situación actual junto con las recomendaciones de Claude
+ unificando la información de ambas colecciones y emparejándolas por cercanía temporal.
+ """
+ try:
+ # Recuperar datos de ambas colecciones
+ logger.info(f"Recuperando análisis de situación actual para {username}")
+ situation_analyses = get_current_situation_analysis(username, limit=10)
+
+ # Verificar si hay datos
+ if situation_analyses:
+ logger.info(f"Recuperados {len(situation_analyses)} análisis de situación")
+ # Depurar para ver la estructura de datos
+ for i, analysis in enumerate(situation_analyses):
+ logger.info(f"Análisis #{i+1}: Claves disponibles: {list(analysis.keys())}")
+ if 'metrics' in analysis:
+ logger.info(f"Métricas disponibles: {list(analysis['metrics'].keys())}")
+ else:
+ logger.warning("No se encontraron análisis de situación actual")
+
+ logger.info(f"Recuperando recomendaciones de Claude para {username}")
+ claude_recommendations = get_claude_recommendations(username)
+
+ if claude_recommendations:
+ logger.info(f"Recuperadas {len(claude_recommendations)} recomendaciones de Claude")
+ else:
+ logger.warning("No se encontraron recomendaciones de Claude")
+
+ # Verificar si hay algún tipo de análisis disponible
+ if not situation_analyses and not claude_recommendations:
+ logger.info("No se encontraron análisis de situación actual ni recomendaciones")
+ st.info(t.get('no_current_situation', 'No hay análisis de situación actual registrados'))
+ return
+
+ # Crear pares combinados emparejando diagnósticos y recomendaciones cercanos en tiempo
+ logger.info("Creando emparejamientos temporales de análisis")
+
+ # Convertir timestamps a objetos datetime para comparación
+ situation_times = []
+ for analysis in situation_analyses:
+ if 'timestamp' in analysis:
+ try:
+ timestamp_str = analysis['timestamp']
+ dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
+ situation_times.append((dt, analysis))
+ except Exception as e:
+ logger.error(f"Error parseando timestamp de situación: {str(e)}")
+
+ recommendation_times = []
+ for recommendation in claude_recommendations:
+ if 'timestamp' in recommendation:
+ try:
+ timestamp_str = recommendation['timestamp']
+ dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
+ recommendation_times.append((dt, recommendation))
+ except Exception as e:
+ logger.error(f"Error parseando timestamp de recomendación: {str(e)}")
+
+ # Ordenar por tiempo
+ situation_times.sort(key=lambda x: x[0], reverse=True)
+ recommendation_times.sort(key=lambda x: x[0], reverse=True)
+
+ # Crear pares combinados
+ combined_items = []
+
+ # Primero, procesar todas las situaciones encontrando la recomendación más cercana
+ for sit_time, situation in situation_times:
+ # Buscar la recomendación más cercana en tiempo
+ best_match = None
+ min_diff = timedelta(minutes=30) # Máxima diferencia de tiempo aceptable (30 minutos)
+ best_rec_time = None
+
+ for rec_time, recommendation in recommendation_times:
+ time_diff = abs(sit_time - rec_time)
+ if time_diff < min_diff:
+ min_diff = time_diff
+ best_match = recommendation
+ best_rec_time = rec_time
+
+ # Crear un elemento combinado
+ if best_match:
+ timestamp_key = sit_time.isoformat()
+ combined_items.append((timestamp_key, {
+ 'situation': situation,
+ 'recommendation': best_match,
+ 'time_diff': min_diff.total_seconds()
+ }))
+ # Eliminar la recomendación usada para no reutilizarla
+ recommendation_times = [(t, r) for t, r in recommendation_times if t != best_rec_time]
+ logger.info(f"Emparejado: Diagnóstico {sit_time} con Recomendación {best_rec_time} (diferencia: {min_diff})")
+ else:
+ # Si no hay recomendación cercana, solo incluir la situación
+ timestamp_key = sit_time.isoformat()
+ combined_items.append((timestamp_key, {
+ 'situation': situation
+ }))
+ logger.info(f"Sin emparejar: Diagnóstico {sit_time} sin recomendación cercana")
+
+ # Agregar recomendaciones restantes sin situación
+ for rec_time, recommendation in recommendation_times:
+ timestamp_key = rec_time.isoformat()
+ combined_items.append((timestamp_key, {
+ 'recommendation': recommendation
+ }))
+ logger.info(f"Sin emparejar: Recomendación {rec_time} sin diagnóstico cercano")
+
+ # Ordenar por tiempo (más reciente primero)
+ combined_items.sort(key=lambda x: x[0], reverse=True)
+
+ logger.info(f"Procesando {len(combined_items)} elementos combinados")
+
+ # Mostrar cada par combinado
+ for i, (timestamp_key, analysis_pair) in enumerate(combined_items):
+ try:
+ # Obtener datos de situación y recomendación
+ situation_data = analysis_pair.get('situation', {})
+ recommendation_data = analysis_pair.get('recommendation', {})
+ time_diff = analysis_pair.get('time_diff')
+
+ # Si no hay ningún dato, continuar al siguiente
+ if not situation_data and not recommendation_data:
+ continue
+
+ # Determinar qué texto mostrar (priorizar el de la situación)
+ text_to_show = situation_data.get('text', recommendation_data.get('text', ''))
+ text_type = situation_data.get('text_type', recommendation_data.get('text_type', ''))
+
+ # Formatear fecha para mostrar
+ try:
+ # Usar timestamp del key que ya es un formato ISO
+ dt = datetime.fromisoformat(timestamp_key)
+ formatted_date = dt.strftime("%d/%m/%Y %H:%M:%S")
+ except Exception as date_error:
+ logger.error(f"Error formateando fecha: {str(date_error)}")
+ formatted_date = timestamp_key
+
+ # Determinar el título del expander
+ title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
+ if text_type:
+ text_type_display = {
+ 'academic_article': t.get('academic_article', 'Artículo académico'),
+ 'student_essay': t.get('student_essay', 'Trabajo universitario'),
+ 'general_communication': t.get('general_communication', 'Comunicación general')
+ }.get(text_type, text_type)
+ title += f" - {text_type_display}"
+
+ # Añadir indicador de emparejamiento si existe
+ if time_diff is not None:
+ if time_diff < 60: # menos de un minuto
+ title += f" 🔄 (emparejados)"
+ else:
+ title += f" 🔄 (emparejados, diferencia: {int(time_diff//60)} min)"
+
+ # Usar un ID único para cada expander
+ expander_id = f"analysis_{i}_{timestamp_key.replace(':', '_')}"
+
+ # Mostrar el análisis en un expander
+ with st.expander(title, expanded=False):
+ # Mostrar texto analizado con key único
+ st.subheader(t.get('analyzed_text', 'Texto analizado'))
+ st.text_area(
+ "Text Content",
+ value=text_to_show,
+ height=100,
+ disabled=True,
+ label_visibility="collapsed",
+ key=f"text_area_{expander_id}"
+ )
+
+ # Crear tabs para separar diagnóstico y recomendaciones
+ diagnosis_tab, recommendations_tab = st.tabs([
+ t.get('diagnosis_tab', 'Diagnóstico'),
+ t.get('recommendations_tab', 'Recomendaciones')
+ ])
+
+ # Tab de diagnóstico
+ with diagnosis_tab:
+ if situation_data and 'metrics' in situation_data:
+ metrics = situation_data['metrics']
+
+ # Dividir en dos columnas
+ col1, col2 = st.columns(2)
+
+ # Principales métricas en formato de tarjetas
+ with col1:
+ st.subheader(t.get('key_metrics', 'Métricas clave'))
+
+ # Mostrar cada métrica principal
+ for metric_name, metric_data in metrics.items():
+ try:
+ # Determinar la puntuación
+ score = None
+ if isinstance(metric_data, dict):
+ # Intentar diferentes nombres de campo
+ if 'normalized_score' in metric_data:
+ score = metric_data['normalized_score']
+ elif 'score' in metric_data:
+ score = metric_data['score']
+ elif 'value' in metric_data:
+ score = metric_data['value']
+ elif isinstance(metric_data, (int, float)):
+ score = metric_data
+
+ if score is not None:
+ # Asegurarse de que score es numérico
+ if isinstance(score, (int, float)):
+ # Determinar color y emoji basado en la puntuación
+ if score < 0.5:
+ emoji = "🔴"
+ color = "#ffcccc" # light red
+ elif score < 0.75:
+ emoji = "🟡"
+ color = "#ffffcc" # light yellow
+ else:
+ emoji = "🟢"
+ color = "#ccffcc" # light green
+
+ # Mostrar la métrica con estilo
+ st.markdown(f"""
+
+ {emoji} {metric_name.capitalize()}: {score:.2f}
+
+ """, unsafe_allow_html=True)
+ else:
+ # Si no es numérico, mostrar como texto
+ st.markdown(f"""
+
+ ℹ️ {metric_name.capitalize()}: {str(score)}
+
+ """, unsafe_allow_html=True)
+ except Exception as e:
+ logger.error(f"Error procesando métrica {metric_name}: {str(e)}")
+
+ # Mostrar detalles adicionales si están disponibles
+ with col2:
+ st.subheader(t.get('details', 'Detalles'))
+
+ # Para cada métrica, mostrar sus detalles si existen
+ for metric_name, metric_data in metrics.items():
+ try:
+ if isinstance(metric_data, dict):
+ # Mostrar detalles directamente o buscar en subcampos
+ details = None
+ if 'details' in metric_data and metric_data['details']:
+ details = metric_data['details']
+ else:
+ # Crear un diccionario con los detalles excluyendo 'normalized_score' y similares
+ details = {k: v for k, v in metric_data.items()
+ if k not in ['normalized_score', 'score', 'value']}
+
+ if details:
+ st.write(f"**{metric_name.capitalize()}**")
+ st.json(details, expanded=False)
+ except Exception as e:
+ logger.error(f"Error mostrando detalles de {metric_name}: {str(e)}")
+ else:
+ st.info(t.get('no_diagnosis', 'No hay datos de diagnóstico disponibles'))
+
+ # Tab de recomendaciones
+ with recommendations_tab:
+ if recommendation_data and 'recommendations' in recommendation_data:
+ st.markdown(f"""
+
+ {recommendation_data['recommendations']}
+
+ """, unsafe_allow_html=True)
+ elif recommendation_data and 'feedback' in recommendation_data:
+ st.markdown(f"""
+
+ {recommendation_data['feedback']}
+
+ """, unsafe_allow_html=True)
+ else:
+ st.info(t.get('no_recommendations', 'No hay recomendaciones disponibles'))
+
+ except Exception as e:
+ logger.error(f"Error procesando par de análisis: {str(e)}")
+ continue
+
+ except Exception as e:
+ logger.error(f"Error mostrando actividades de situación actual: {str(e)}")
+ st.error(t.get('error_current_situation', 'Error al mostrar análisis de situación actual'))
+
+###############################################################################################
+
+def display_morphosyntax_activities(username: str, t: dict):
+ """
+ Muestra actividades de análisis morfosintáctico, incluyendo base e iteraciones
+ desde las nuevas colecciones: student_morphosyntax_analysis_base y student_morphosyntax_iterations
+ """
+ try:
+ # Importación inline para evitar problemas de circularidad
+ # Utilizamos la función de la nueva estructura de DB iterativa
+ from ..database.morphosyntax_iterative_mongo_db import get_student_morphosyntax_analysis
+
+ logger.info(f"Recuperando análisis morfosintáctico para {username}")
+
+ # Esta función ahora trae tanto las bases como sus iteraciones
+ base_analyses = get_student_morphosyntax_analysis(username)
+
+ if not base_analyses:
+ logger.info("No se encontraron análisis morfosintácticos")
+ st.info(t.get('no_morpho_analyses', 'No hay análisis morfosintácticos registrados'))
+ return
+
+ logger.info(f"Procesando {len(base_analyses)} análisis morfosintácticos base")
+
+ # Procesar cada análisis base con sus iteraciones
+ for base_analysis in base_analyses:
+ try:
+ # Formatear fecha
+ timestamp = datetime.fromisoformat(base_analysis['timestamp'].replace('Z', '+00:00'))
+ formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+
+ # Título del expander: incluir información de si tiene iteraciones
+ expander_title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
+ if base_analysis.get('has_iterations', False):
+ expander_title += f" ({t.get('has_iterations', 'Con iteraciones')})"
+
+ with st.expander(expander_title, expanded=False):
+ # Mostrar texto base
+ st.subheader(t.get('base_text', 'Texto original'))
+ st.text_area(
+ "Base Text Content",
+ value=base_analysis.get('text', ''),
+ height=100,
+ disabled=True,
+ label_visibility="collapsed",
+ key=f"base_text_{str(base_analysis['_id'])}"
+ )
+
+ # Mostrar diagrama de arco base si existe
+ if 'arc_diagrams' in base_analysis and base_analysis['arc_diagrams']:
+ st.subheader(t.get('syntactic_diagrams', 'Diagrama sintáctico (original)'))
+ # Mostrar cada diagrama (normalmente solo uno por oración)
+ for diagram in base_analysis['arc_diagrams']:
+ st.write(diagram, unsafe_allow_html=True)
+
+ # Procesar iteraciones si existen
+ if 'iterations' in base_analysis and base_analysis['iterations']:
+ st.markdown("---") # Línea divisoria
+ st.subheader(t.get('iterations', 'Versiones mejoradas'))
+
+ # Crear tabs para cada iteración
+ iteration_tabs = st.tabs([
+ f"{t.get('iteration', 'Versión')} {i+1}"
+ for i in range(len(base_analysis['iterations']))
+ ])
+
+ # Mostrar cada iteración en su propia pestaña
+ for i, (tab, iteration) in enumerate(zip(iteration_tabs, base_analysis['iterations'])):
+ with tab:
+ # Timestamp de la iteración
+ iter_timestamp = datetime.fromisoformat(
+ iteration['timestamp'].replace('Z', '+00:00'))
+ iter_formatted_date = iter_timestamp.strftime("%d/%m/%Y %H:%M:%S")
+ st.caption(f"{t.get('iteration_date', 'Fecha de versión')}: {iter_formatted_date}")
+
+ # Texto de la iteración
+ st.text_area(
+ f"Iteration Text {i+1}",
+ value=iteration.get('iteration_text', ''),
+ height=100,
+ disabled=True,
+ label_visibility="collapsed",
+ key=f"iter_text_{str(iteration['_id'])}"
+ )
+
+ # Diagrama de arco de la iteración
+ if 'arc_diagrams' in iteration and iteration['arc_diagrams']:
+ st.subheader(t.get('iteration_diagram', 'Diagrama sintáctico (mejorado)'))
+ for diagram in iteration['arc_diagrams']:
+ st.write(diagram, unsafe_allow_html=True)
+
+ except Exception as e:
+ logger.error(f"Error procesando análisis morfosintáctico: {str(e)}")
+ st.error(t.get('error_processing_analysis', 'Error procesando este análisis'))
+ continue
+
+ except Exception as e:
+ logger.error(f"Error mostrando análisis morfosintáctico: {str(e)}")
+ st.error(t.get('error_morpho', 'Error al mostrar análisis morfosintáctico'))
+
+
+###############################################################################################
+
+def display_semantic_activities(username: str, t: dict):
+ """Muestra actividades de análisis semántico"""
+ try:
+ logger.info(f"Recuperando análisis semántico para {username}")
+ analyses = get_student_semantic_analysis(username)
+
+ if not analyses:
+ logger.info("No se encontraron análisis semánticos")
+ st.info(t.get('no_semantic_analyses', 'No hay análisis semánticos registrados'))
+ return
+
+ logger.info(f"Procesando {len(analyses)} análisis semánticos")
+
+ for analysis in analyses:
+ try:
+ # Verificar campos necesarios
+ if not all(key in analysis for key in ['timestamp', 'concept_graph']):
+ logger.warning(f"Análisis incompleto: {analysis.keys()}")
+ continue
+
+ # Formatear fecha
+ timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
+ formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+
+ # Crear expander
+ with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
+ # Procesar y mostrar gráfico
+ if analysis.get('concept_graph'):
+ try:
+ # Convertir de base64 a bytes
+ logger.debug("Decodificando gráfico de conceptos")
+ image_data = analysis['concept_graph']
+
+ # Si el gráfico ya es bytes, usarlo directamente
+ if isinstance(image_data, bytes):
+ image_bytes = image_data
+ else:
+ # Si es string base64, decodificar
+ image_bytes = base64.b64decode(image_data)
+
+ logger.debug(f"Longitud de bytes de imagen: {len(image_bytes)}")
+
+ # Mostrar imagen
+ st.image(
+ image_bytes,
+ caption=t.get('concept_network', 'Red de Conceptos'),
+ use_container_width=True
+ )
+ logger.debug("Gráfico mostrado exitosamente")
+
+ except Exception as img_error:
+ logger.error(f"Error procesando gráfico: {str(img_error)}")
+ st.error(t.get('error_loading_graph', 'Error al cargar el gráfico'))
+ else:
+ st.info(t.get('no_graph', 'No hay visualización disponible'))
+
+ except Exception as e:
+ logger.error(f"Error procesando análisis individual: {str(e)}")
+ continue
+
+ except Exception as e:
+ logger.error(f"Error mostrando análisis semántico: {str(e)}")
+ st.error(t.get('error_semantic', 'Error al mostrar análisis semántico'))
+
+
+###################################################################################################
+
+def display_discourse_activities(username: str, t: dict):
+ """Muestra actividades de análisis del discurso (mostrado como 'Análisis comparado de textos' en la UI)"""
+ try:
+ logger.info(f"Recuperando análisis del discurso para {username}")
+ analyses = get_student_discourse_analysis(username)
+
+ if not analyses:
+ logger.info("No se encontraron análisis del discurso")
+ # Usamos el término "análisis comparado de textos" en la UI
+ st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
+ return
+
+ logger.info(f"Procesando {len(analyses)} análisis del discurso")
+ for analysis in analyses:
+ try:
+ # Verificar campos mínimos necesarios
+ if not all(key in analysis for key in ['timestamp']):
+ logger.warning(f"Análisis incompleto: {analysis.keys()}")
+ continue
+
+ # Formatear fecha
+ timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
+ formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+
+ with st.expander(f"{t.get('analysis_date', 'Fecha')}: {formatted_date}", expanded=False):
+ # Crear dos columnas para mostrar los documentos lado a lado
+ col1, col2 = st.columns(2)
+
+ # Documento 1 - Columna izquierda
+ with col1:
+ st.subheader(t.get('doc1_title', 'Documento 1'))
+ st.markdown(t.get('key_concepts', 'Conceptos Clave'))
+
+ # Mostrar conceptos clave en formato de etiquetas
+ if 'key_concepts1' in analysis and analysis['key_concepts1']:
+ concepts_html = f"""
+
+ {''.join([
+ f'
+ """
+ st.markdown(concepts_html, unsafe_allow_html=True)
+ else:
+ st.info(t.get('no_concepts', 'No hay conceptos disponibles'))
+
+ # Mostrar grafo 1
+ if 'graph1' in analysis:
+ try:
+ if isinstance(analysis['graph1'], bytes):
+ st.image(
+ analysis['graph1'],
+ use_container_width=True
+ )
+ else:
+ logger.warning(f"graph1 no es bytes: {type(analysis['graph1'])}")
+ st.warning(t.get('graph_not_available', 'Gráfico no disponible'))
+ except Exception as e:
+ logger.error(f"Error mostrando graph1: {str(e)}")
+ st.error(t.get('error_loading_graph', 'Error al cargar el gráfico'))
+ else:
+ st.info(t.get('no_visualization', 'No hay visualización disponible'))
+
+ # Interpretación del grafo
+ 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
+ """)
+
+ # Documento 2 - Columna derecha
+ with col2:
+ st.subheader(t.get('doc2_title', 'Documento 2'))
+ st.markdown(t.get('key_concepts', 'Conceptos Clave'))
+
+ # Mostrar conceptos clave en formato de etiquetas
+ if 'key_concepts2' in analysis and analysis['key_concepts2']:
+ concepts_html = f"""
+ '
+ f'{concept}'
+ f'({freq:.2f})
'
+ for concept, freq in analysis['key_concepts1']
+ ])}
+
+ {''.join([
+ f'
+ """
+ st.markdown(concepts_html, unsafe_allow_html=True)
+ else:
+ st.info(t.get('no_concepts', 'No hay conceptos disponibles'))
+
+ # Mostrar grafo 2
+ if 'graph2' in analysis:
+ try:
+ if isinstance(analysis['graph2'], bytes):
+ st.image(
+ analysis['graph2'],
+ use_container_width=True
+ )
+ else:
+ logger.warning(f"graph2 no es bytes: {type(analysis['graph2'])}")
+ st.warning(t.get('graph_not_available', 'Gráfico no disponible'))
+ except Exception as e:
+ logger.error(f"Error mostrando graph2: {str(e)}")
+ st.error(t.get('error_loading_graph', 'Error al cargar el gráfico'))
+ else:
+ st.info(t.get('no_visualization', 'No hay visualización disponible'))
+
+ # Interpretación del grafo
+ 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
+ """)
+
+ except Exception as e:
+ logger.error(f"Error procesando análisis individual: {str(e)}")
+ continue
+
+ except Exception as e:
+ logger.error(f"Error mostrando análisis del discurso: {str(e)}")
+ # Usamos el término "análisis comparado de textos" en la UI
+ st.error(t.get('error_discourse', 'Error al mostrar análisis comparado de textos'))
+
+
+
+#################################################################################
+
+def display_discourse_comparison(analysis: dict, t: dict):
+ """
+ Muestra la comparación de conceptos clave en análisis del discurso.
+ Formato horizontal simplificado.
+ """
+ st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
+
+ # Verificar si tenemos los conceptos necesarios
+ if not ('key_concepts1' in analysis and analysis['key_concepts1']):
+ st.info(t.get('no_concepts', 'No hay conceptos disponibles para comparar'))
+ return
+
+ # Conceptos del Texto 1 - Formato horizontal
+ st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}:**")
+ try:
+ # Comprobar formato y mostrar horizontalmente
+ if isinstance(analysis['key_concepts1'], list) and len(analysis['key_concepts1']) > 0:
+ if isinstance(analysis['key_concepts1'][0], list) and len(analysis['key_concepts1'][0]) == 2:
+ # Formatear como "concepto (valor), concepto2 (valor2), ..."
+ concepts_text = ", ".join([f"{c[0]} ({c[1]})" for c in analysis['key_concepts1'][:10]])
+ st.markdown(f"*{concepts_text}*")
+ else:
+ # Si no tiene el formato esperado, mostrar como lista simple
+ st.markdown(", ".join(str(c) for c in analysis['key_concepts1'][:10]))
+ else:
+ st.write(str(analysis['key_concepts1']))
+ except Exception as e:
+ logger.error(f"Error mostrando key_concepts1: {str(e)}")
+ st.error(t.get('error_concepts1', 'Error mostrando conceptos del Texto 1'))
+
+ # Conceptos del Texto 2 - Formato horizontal
+ st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}:**")
+ if 'key_concepts2' in analysis and analysis['key_concepts2']:
+ try:
+ # Comprobar formato y mostrar horizontalmente
+ if isinstance(analysis['key_concepts2'], list) and len(analysis['key_concepts2']) > 0:
+ if isinstance(analysis['key_concepts2'][0], list) and len(analysis['key_concepts2'][0]) == 2:
+ # Formatear como "concepto (valor), concepto2 (valor2), ..."
+ concepts_text = ", ".join([f"{c[0]} ({c[1]})" for c in analysis['key_concepts2'][:10]])
+ st.markdown(f"*{concepts_text}*")
+ else:
+ # Si no tiene el formato esperado, mostrar como lista simple
+ st.markdown(", ".join(str(c) for c in analysis['key_concepts2'][:10]))
+ else:
+ st.write(str(analysis['key_concepts2']))
+ except Exception as e:
+ logger.error(f"Error mostrando key_concepts2: {str(e)}")
+ st.error(t.get('error_concepts2', 'Error mostrando conceptos del Texto 2'))
+ else:
+ st.info(t.get('no_concepts2', 'No hay conceptos disponibles para el Texto 2'))
+
+
+#################################################################################
+def display_chat_activities(username: str, t: dict):
+ """
+ Muestra historial de conversaciones del chat
+ """
+ try:
+ # Obtener historial del chat
+ chat_history = get_chat_history(
+ username=username,
+ analysis_type='sidebar',
+ limit=50
+ )
+
+ if not chat_history:
+ st.info(t.get('no_chat_history', 'No hay conversaciones registradas'))
+ return
+
+ for chat in reversed(chat_history): # Mostrar las más recientes primero
+ try:
+ # Convertir timestamp a datetime para formato
+ timestamp = datetime.fromisoformat(chat['timestamp'].replace('Z', '+00:00'))
+ formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
+
+ with st.expander(
+ f"{t.get('chat_date', 'Fecha de conversación')}: {formatted_date}",
+ expanded=False
+ ):
+ if 'messages' in chat and chat['messages']:
+ # Mostrar cada mensaje en la conversación
+ for message in chat['messages']:
+ role = message.get('role', 'unknown')
+ content = message.get('content', '')
+
+ # Usar el componente de chat de Streamlit
+ with st.chat_message(role):
+ st.markdown(content)
+
+ # Agregar separador entre mensajes
+ st.divider()
+ else:
+ st.warning(t.get('invalid_chat_format', 'Formato de chat no válido'))
+
+ except Exception as e:
+ logger.error(f"Error mostrando conversación: {str(e)}")
+ continue
+
+ except Exception as e:
+ logger.error(f"Error mostrando historial del chat: {str(e)}")
+ st.error(t.get('error_chat', 'Error al mostrar historial del chat'))
+
+#################################################################################
diff --git a/src/modules/studentact/temp_current_situation_interface.py b/src/modules/studentact/temp_current_situation_interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5c62f53c8f66bfd658f68862f06b5624f34b0bf
--- /dev/null
+++ b/src/modules/studentact/temp_current_situation_interface.py
@@ -0,0 +1,311 @@
+# modules/studentact/current_situation_interface.py
+
+import streamlit as st
+import logging
+from ..utils.widget_utils import generate_unique_key
+from .current_situation_analysis import (
+ analyze_text_dimensions,
+ create_vocabulary_network,
+ create_syntax_complexity_graph,
+ create_cohesion_heatmap
+)
+
+logger = logging.getLogger(__name__)
+
+def display_current_situation_interface(lang_code, nlp_models, t):
+ """
+ Interfaz modular para el análisis de la situación actual del estudiante.
+ Esta función maneja la presentación y la interacción con el usuario.
+
+ Args:
+ lang_code: Código del idioma actual
+ nlp_models: Diccionario de modelos de spaCy cargados
+ t: Diccionario de traducciones
+ """
+ st.markdown("## Mi Situación Actual de Escritura")
+
+ # Container principal para mejor organización visual
+ with st.container():
+ # Columnas para entrada y visualización
+ text_col, visual_col = st.columns([1,2])
+
+ with text_col:
+ # Área de entrada de texto
+ text_input = st.text_area(
+ t.get('current_situation_input', "Ingresa tu texto para analizar:"),
+ height=400,
+ key=generate_unique_key("current_situation", "input")
+ )
+
+ # Botón de análisis
+ if st.button(
+ t.get('analyze_button', "Explorar mi escritura"),
+ type="primary",
+ disabled=not text_input,
+ key=generate_unique_key("current_situation", "analyze")
+ ):
+ try:
+ with st.spinner(t.get('processing', "Analizando texto...")):
+ # 1. Procesar el texto
+ doc = nlp_models[lang_code](text_input)
+ metrics = analyze_text_dimensions(doc)
+
+ # 2. Mostrar visualizaciones en la columna derecha
+ with visual_col:
+ display_current_situation_visual(doc, metrics)
+
+ # 3. Obtener retroalimentación de Claude
+ feedback = get_claude_feedback(metrics, text_input)
+
+ # 4. Guardar los resultados
+ from ..database.current_situation_mongo_db import store_current_situation_result
+
+ if st.button(t.get('analyze_button', "Explorar mi escritura")):
+ with st.spinner(t.get('processing', "Analizando texto...")):
+ # Procesar y analizar
+ doc = nlp_models[lang_code](text_input)
+
+ # Obtener métricas con manejo de errores
+ try:
+ metrics = analyze_text_dimensions(doc)
+ except Exception as e:
+ logger.error(f"Error en análisis: {str(e)}")
+ st.error("Error en el análisis de dimensiones")
+ return
+
+ # Obtener feedback
+ try:
+ feedback = get_claude_feedback(metrics, text_input)
+ except Exception as e:
+ logger.error(f"Error obteniendo feedback: {str(e)}")
+ st.error("Error obteniendo retroalimentación")
+ return
+
+ # Guardar resultados con verificación
+ if store_current_situation_result(
+ st.session_state.username,
+ text_input,
+ metrics,
+ feedback
+ ):
+ st.success(t.get('save_success', "Análisis guardado"))
+
+ # Mostrar visualizaciones y recomendaciones
+ display_current_situation_visual(doc, metrics)
+ show_recommendations(feedback, t)
+ else:
+ st.error("Error al guardar el análisis")
+
+ except Exception as e:
+ logger.error(f"Error en interfaz: {str(e)}")
+ st.error("Error general en la interfaz")
+
+################################################################
+def display_current_situation_visual(doc, metrics):
+ """Visualización mejorada de resultados con interpretaciones"""
+ try:
+ with st.container():
+ # Estilos CSS mejorados para los contenedores
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # 1. Riqueza de Vocabulario
+ with st.expander("📚 Riqueza de Vocabulario", expanded=True):
+ st.markdown(''
+ f'{concept}'
+ f'({freq:.2f})
'
+ for concept, freq in analysis['key_concepts2']
+ ])}
+ ', unsafe_allow_html=True)
+ vocabulary_graph = create_vocabulary_network(doc)
+ if vocabulary_graph:
+ # Mostrar gráfico
+ st.pyplot(vocabulary_graph)
+ plt.close(vocabulary_graph)
+
+ # Interpretación
+ st.markdown('
", unsafe_allow_html=True)
+
+ # 2. Estructura de Oraciones
+ with st.expander("🏗️ Complejidad Estructural", expanded=True):
+ st.markdown('', unsafe_allow_html=True)
+ st.markdown("**¿Qué significa este gráfico?**")
+ st.markdown("""
+ - 🔵 Los nodos azules representan palabras clave en tu texto
+ - 📏 El tamaño de cada nodo indica su frecuencia de uso
+ - 🔗 Las líneas conectan palabras que aparecen juntas frecuentemente
+ - 🎨 Los colores más intensos indican palabras más centrales
+ """)
+ st.markdown("
", unsafe_allow_html=True)
+ st.markdown("', unsafe_allow_html=True)
+ syntax_graph = create_syntax_complexity_graph(doc)
+ if syntax_graph:
+ st.pyplot(syntax_graph)
+ plt.close(syntax_graph)
+
+ st.markdown('
", unsafe_allow_html=True)
+
+ # 3. Cohesión Textual
+ with st.expander("🔄 Cohesión del Texto", expanded=True):
+ st.markdown('', unsafe_allow_html=True)
+ st.markdown("**Análisis de la estructura:**")
+ st.markdown("""
+ - 📊 Las barras muestran la complejidad de cada oración
+ - 📈 Mayor altura indica estructuras más elaboradas
+ - 🎯 La línea punteada indica el nivel óptimo de complejidad
+ - 🔄 Variación en las alturas sugiere dinamismo en la escritura
+ """)
+ st.markdown("
", unsafe_allow_html=True)
+ st.markdown("', unsafe_allow_html=True)
+ cohesion_map = create_cohesion_heatmap(doc)
+ if cohesion_map:
+ st.pyplot(cohesion_map)
+ plt.close(cohesion_map)
+
+ st.markdown('
", unsafe_allow_html=True)
+
+ # 4. Métricas Generales
+ with st.expander("📊 Resumen de Métricas", expanded=True):
+ col1, col2, col3 = st.columns(3)
+
+ with col1:
+ st.metric(
+ "Diversidad Léxica",
+ f"{metrics['vocabulary_richness']:.2f}/1.0",
+ help="Mide la variedad de palabras diferentes utilizadas"
+ )
+
+ with col2:
+ st.metric(
+ "Complejidad Estructural",
+ f"{metrics['structural_complexity']:.2f}/1.0",
+ help="Indica qué tan elaboradas son las estructuras de las oraciones"
+ )
+
+ with col3:
+ st.metric(
+ "Cohesión Textual",
+ f"{metrics['cohesion_score']:.2f}/1.0",
+ help="Evalúa qué tan bien conectadas están las ideas entre sí"
+ )
+
+ except Exception as e:
+ logger.error(f"Error en visualización: {str(e)}")
+ st.error("Error al generar las visualizaciones")
+
+################################################################
+def show_recommendations(feedback, t):
+ """
+ Muestra las recomendaciones y ejercicios personalizados para el estudiante,
+ permitiendo el seguimiento de su progreso.
+
+ Args:
+ feedback: Diccionario con retroalimentación y ejercicios recomendados
+ t: Diccionario de traducciones
+ """
+ st.markdown("### " + t.get('recommendations_title', "Recomendaciones para mejorar"))
+
+ for area, exercises in feedback['recommendations'].items():
+ with st.expander(f"💡 {area}"):
+ try:
+ # Descripción del área de mejora
+ st.markdown(exercises['description'])
+
+ # Obtener el historial de ejercicios del estudiante
+ from ..database.current_situation_mongo_db import get_student_exercises_history
+ exercises_history = get_student_exercises_history(st.session_state.username)
+
+ # Separar ejercicios en completados y pendientes
+ completed = exercises_history.get(area, [])
+
+ # Mostrar estado actual
+ progress_col1, progress_col2 = st.columns([3,1])
+ with progress_col1:
+ st.markdown("**Ejercicio sugerido:**")
+ st.markdown(exercises['activity'])
+
+ with progress_col2:
+ # Verificar si el ejercicio ya está completado
+ exercise_key = f"{area}_{exercises['activity']}"
+ is_completed = exercise_key in completed
+
+ if is_completed:
+ st.success("✅ Completado")
+ else:
+ # Botón para marcar ejercicio como completado
+ if st.button(
+ t.get('mark_complete', "Marcar como completado"),
+ key=generate_unique_key("exercise", area),
+ type="primary"
+ ):
+ try:
+ from ..database.current_situation_mongo_db import update_exercise_status
+
+ # Actualizar estado del ejercicio
+ success = update_exercise_status(
+ username=st.session_state.username,
+ area=area,
+ exercise=exercises['activity'],
+ completed=True
+ )
+
+ if success:
+ st.success(t.get(
+ 'exercise_completed',
+ "¡Ejercicio marcado como completado!"
+ ))
+ st.rerun()
+ else:
+ st.error(t.get(
+ 'exercise_error',
+ "Error al actualizar el estado del ejercicio"
+ ))
+ except Exception as e:
+ logger.error(f"Error actualizando estado del ejercicio: {str(e)}")
+ st.error(t.get('update_error', "Error al actualizar el ejercicio"))
+
+ # Mostrar recursos adicionales si existen
+ if 'resources' in exercises:
+ st.markdown("**Recursos adicionales:**")
+ for resource in exercises['resources']:
+ st.markdown(f"- {resource}")
+
+ # Mostrar fecha de finalización si está completado
+ if is_completed:
+ completion_date = exercises_history[exercise_key].get('completion_date')
+ if completion_date:
+ st.caption(
+ t.get('completed_on', "Completado el") +
+ f": {completion_date.strftime('%d/%m/%Y %H:%M')}"
+ )
+
+ except Exception as e:
+ logger.error(f"Error mostrando recomendaciones para {area}: {str(e)}")
+ st.error(t.get(
+ 'recommendations_error',
+ f"Error al mostrar las recomendaciones para {area}"
+ ))
\ No newline at end of file
diff --git a/src/modules/text_analysis/__init__.py b/src/modules/text_analysis/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8781ff2d1a28dde08cad6688e7efb909aeabaa9
--- /dev/null
+++ b/src/modules/text_analysis/__init__.py
@@ -0,0 +1,29 @@
+# modules/text_analysis/__init__.py
+import logging
+
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+# Importaciones de morpho_analysis
+from .morpho_analysis import (
+ perform_advanced_morphosyntactic_analysis,
+ get_repeated_words_colors,
+ highlight_repeated_words,
+ generate_arc_diagram,
+ get_detailed_pos_analysis,
+ get_morphological_analysis,
+ get_sentence_structure_analysis,
+ POS_COLORS,
+ POS_TRANSLATIONS
+)
+
+# Importaciones de semantic_analysis
+from .semantic_analysis import (
+ create_concept_graph,
+ visualize_concept_graph,
+ identify_key_concepts
+)
+
+
diff --git a/src/modules/text_analysis/__pycache__/__init__.cpython-311.pyc b/src/modules/text_analysis/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e7768ec60cb4a06cdaec79228f7036c906df7b0
Binary files /dev/null and b/src/modules/text_analysis/__pycache__/__init__.cpython-311.pyc differ
diff --git a/src/modules/text_analysis/__pycache__/discourse_analysis.cpython-311.pyc b/src/modules/text_analysis/__pycache__/discourse_analysis.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5f526ab04a41ca07b198c4e4aaf1337b595c5f33
Binary files /dev/null and b/src/modules/text_analysis/__pycache__/discourse_analysis.cpython-311.pyc differ
diff --git a/src/modules/text_analysis/__pycache__/morpho_analysis.cpython-311.pyc b/src/modules/text_analysis/__pycache__/morpho_analysis.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d74855a63b98e328d11eb2b08352b26f31a23655
Binary files /dev/null and b/src/modules/text_analysis/__pycache__/morpho_analysis.cpython-311.pyc differ
diff --git a/src/modules/text_analysis/__pycache__/semantic_analysis.cpython-311.pyc b/src/modules/text_analysis/__pycache__/semantic_analysis.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..53c63e092b99349668b992be27100905c36bb707
Binary files /dev/null and b/src/modules/text_analysis/__pycache__/semantic_analysis.cpython-311.pyc differ
diff --git a/src/modules/text_analysis/coherence_analysis.py b/src/modules/text_analysis/coherence_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..d3f5a12faa99758192ecc4ed3fc22c9249232e86
--- /dev/null
+++ b/src/modules/text_analysis/coherence_analysis.py
@@ -0,0 +1 @@
+
diff --git a/src/modules/text_analysis/complex_structures.py b/src/modules/text_analysis/complex_structures.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/text_analysis/discourse_analysis.py b/src/modules/text_analysis/discourse_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..d674ff959495afc8ef0cf2541bfa9115f1edd500
--- /dev/null
+++ b/src/modules/text_analysis/discourse_analysis.py
@@ -0,0 +1,286 @@
+# modules/text_analysis/discourse_analysis.py
+# Configuración de matplotlib
+
+import streamlit as st
+import spacy
+import networkx as nx
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+import logging
+import io
+import base64
+from collections import Counter, defaultdict
+import logging
+
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+from .semantic_analysis import (
+ create_concept_graph,
+ visualize_concept_graph,
+ identify_key_concepts
+)
+
+
+from .stopwords import (
+ get_custom_stopwords,
+ process_text,
+ get_stopwords_for_spacy
+)
+
+
+#####################
+POS_TRANSLATIONS = {
+ 'es': {
+ 'ADJ': 'Adjetivo', 'ADP': 'Preposición', 'ADV': 'Adverbio', 'AUX': 'Auxiliar',
+ 'CCONJ': 'Conjunción Coordinante', 'DET': 'Determinante', 'INTJ': 'Interjección',
+ 'NOUN': 'Sustantivo', 'NUM': 'Número', 'PART': 'Partícula', 'PRON': 'Pronombre',
+ 'PROPN': 'Nombre Propio', 'SCONJ': 'Conjunción Subordinante', 'SYM': 'Símbolo',
+ 'VERB': 'Verbo', 'X': 'Otro',
+ },
+ 'en': {
+ 'ADJ': 'Adjective', 'ADP': 'Preposition', 'ADV': 'Adverb', 'AUX': 'Auxiliary',
+ 'CCONJ': 'Coordinating Conjunction', 'DET': 'Determiner', 'INTJ': 'Interjection',
+ 'NOUN': 'Noun', 'NUM': 'Number', 'PART': 'Particle', 'PRON': 'Pronoun',
+ 'PROPN': 'Proper Noun', 'SCONJ': 'Subordinating Conjunction', 'SYM': 'Symbol',
+ 'VERB': 'Verb', 'X': 'Other',
+ },
+ 'fr': {
+ 'ADJ': 'Adjectif', 'ADP': 'Préposition', 'ADV': 'Adverbe', 'AUX': 'Auxiliaire',
+ 'CCONJ': 'Conjonction de Coordination', 'DET': 'Déterminant', 'INTJ': 'Interjection',
+ 'NOUN': 'Nom', 'NUM': 'Nombre', 'PART': 'Particule', 'PRON': 'Pronom',
+ 'PROPN': 'Nom Propre', 'SCONJ': 'Conjonction de Subordination', 'SYM': 'Symbole',
+ 'VERB': 'Verbe', 'X': 'Autre',
+ },
+ 'pt': {
+ 'ADJ': 'Adjetivo', 'ADP': 'Preposição', 'ADV': 'Advérbio', 'AUX': 'Auxiliar',
+ 'CCONJ': 'Conjunção Coordenativa', 'DET': 'Determinante', 'INTJ': 'Interjeição',
+ 'NOUN': 'Substantivo', 'NUM': 'Número', 'PART': 'Partícula', 'PRON': 'Pronome',
+ 'PROPN': 'Nome Próprio', 'SCONJ': 'Conjunção Subordinativa', 'SYM': 'Símbolo',
+ 'VERB': 'Verbo', 'X': 'Outro',
+ }
+}
+
+ENTITY_LABELS = {
+ 'es': {
+ "Personas": "lightblue",
+ "Lugares": "lightcoral",
+ "Inventos": "lightgreen",
+ "Fechas": "lightyellow",
+ "Conceptos": "lightpink"
+ },
+ 'en': {
+ "People": "lightblue",
+ "Places": "lightcoral",
+ "Inventions": "lightgreen",
+ "Dates": "lightyellow",
+ "Concepts": "lightpink"
+ },
+ 'fr': {
+ "Personnes": "lightblue",
+ "Lieux": "lightcoral",
+ "Inventions": "lightgreen",
+ "Dates": "lightyellow",
+ "Concepts": "lightpink"
+ },
+ 'pt': {
+ "Pessoas": "lightblue",
+ "Lugares": "lightcoral",
+ "Invenções": "lightgreen",
+ "Datas": "lightyellow",
+ "Conceitos": "lightpink"
+ }
+}
+
+#################
+
+def fig_to_bytes(fig, dpi=100):
+ """Convierte una figura de matplotlib a bytes."""
+ try:
+ buf = io.BytesIO()
+ fig.savefig(buf, format='png', dpi=dpi, bbox_inches='tight') # Sin compression
+ buf.seek(0)
+ return buf.getvalue()
+ except Exception as e:
+ logger.error(f"Error en fig_to_bytes: {str(e)}")
+ return None
+
+################################################################################################
+def compare_semantic_analysis(text1, text2, nlp, lang):
+ """
+ Realiza el análisis semántico comparativo entre dos textos
+ """
+ try:
+ # Diccionario de traducciones para los títulos de los gráficos COMPARATIVOS
+ COMPARE_GRAPH_TITLES = {
+ 'es': {
+ 'doc1_network': 'Relaciones entre conceptos clave del documento 1',
+ 'doc1_centrality': 'Centralidad de los conceptos clave del documento 1',
+ 'doc2_network': 'Relaciones entre conceptos clave del documento 2',
+ 'doc2_centrality': 'Centralidad de los conceptos clave del documento 2'
+ },
+ 'en': {
+ 'doc1_network': 'Key concept relationships in document 1',
+ 'doc1_centrality': 'Key concept centrality in document 1',
+ 'doc2_network': 'Key concept relationships in document 2',
+ 'doc2_centrality': 'Key concept centrality in document 2'
+ },
+ 'fr': {
+ 'doc1_network': 'Relations entre concepts clés du document 1',
+ 'doc1_centrality': 'Centralité des concepts clés du document 1',
+ 'doc2_network': 'Relations entre concepts clés du document 2',
+ 'doc2_centrality': 'Centralité des concepts clés du document 2'
+ },
+ 'pt': {
+ 'doc1_network': 'Relações entre conceitos-chave do documento 1',
+ 'doc1_centrality': 'Centralidade dos conceitos-chave do documento 1',
+ 'doc2_network': 'Relações entre conceitos-chave do documento 2',
+ 'doc2_centrality': 'Centralidade dos conceitos-chave do documento 2'
+ }
+ }
+
+ # Obtener traducciones (inglés por defecto)
+ titles = COMPARE_GRAPH_TITLES.get(lang, COMPARE_GRAPH_TITLES['en'])
+
+ logger.info(f"Iniciando análisis comparativo para idioma: {lang}")
+
+ # Resto del código permanece exactamente igual...
+ stopwords = get_custom_stopwords(lang)
+ logger.info(f"Obtenidas {len(stopwords)} stopwords para el idioma {lang}")
+
+ doc1 = nlp(text1)
+ doc2 = nlp(text2)
+
+ key_concepts1 = identify_key_concepts(doc1, stopwords=stopwords, min_freq=2, min_length=3)
+ key_concepts2 = identify_key_concepts(doc2, stopwords=stopwords, min_freq=2, min_length=3)
+
+ if not key_concepts1 or not key_concepts2:
+ raise ValueError("No se pudieron identificar conceptos clave en uno o ambos textos")
+
+ G1 = create_concept_graph(doc1, key_concepts1)
+ G2 = create_concept_graph(doc2, key_concepts2)
+
+ # Primer grafo con título traducido
+ plt.figure(figsize=(12, 8))
+ fig1 = visualize_concept_graph(G1, lang)
+ plt.title(titles['doc1_network'], pad=20)
+ plt.tight_layout()
+
+ # Segundo grafo con título traducido
+ plt.figure(figsize=(12, 8))
+ fig2 = visualize_concept_graph(G2, lang)
+ plt.title(titles['doc2_network'], pad=20)
+ plt.tight_layout()
+
+ return fig1, fig2, key_concepts1, key_concepts2
+
+ except Exception as e:
+ logger.error(f"Error en compare_semantic_analysis: {str(e)}")
+ plt.close('all')
+ raise
+ finally:
+ plt.close('all')
+
+############################################
+def create_concept_table(key_concepts):
+ """
+ Crea una tabla de conceptos clave con sus frecuencias
+ Args:
+ key_concepts: Lista de tuplas (concepto, frecuencia)
+ Returns:
+ pandas.DataFrame: Tabla formateada de conceptos
+ """
+ try:
+ if not key_concepts:
+ logger.warning("Lista de conceptos vacía")
+ return pd.DataFrame(columns=['Concepto', 'Frecuencia'])
+
+ df = pd.DataFrame(key_concepts, columns=['Concepto', 'Frecuencia'])
+ df['Frecuencia'] = df['Frecuencia'].round(2)
+ return df
+ except Exception as e:
+ logger.error(f"Error en create_concept_table: {str(e)}")
+ return pd.DataFrame(columns=['Concepto', 'Frecuencia'])
+
+
+##########################################################
+
+def perform_discourse_analysis(text1, text2, nlp, lang):
+ """
+ Realiza el análisis completo del discurso
+ Args:
+ text1: Primer texto a analizar
+ text2: Segundo texto a analizar
+ nlp: Modelo de spaCy cargado
+ lang: Código de idioma
+ Returns:
+ dict: Resultados del análisis con gráficos convertidos a bytes
+ """
+ try:
+ logger.info("Iniciando análisis del discurso...")
+
+ # Verificar inputs
+ if not text1 or not text2:
+ raise ValueError("Los textos de entrada no pueden estar vacíos")
+
+ if not nlp:
+ raise ValueError("Modelo de lenguaje no inicializado")
+
+ # Realizar análisis comparativo
+ fig1, fig2, key_concepts1, key_concepts2 = compare_semantic_analysis(
+ text1, text2, nlp, lang
+ )
+
+ logger.info("Análisis comparativo completado, convirtiendo figuras a bytes...")
+
+ # Convertir figuras a bytes para almacenamiento
+ graph1_bytes = fig_to_bytes(fig1)
+ graph2_bytes = fig_to_bytes(fig2)
+
+ logger.info(f"Figura 1 convertida a {len(graph1_bytes) if graph1_bytes else 0} bytes")
+ logger.info(f"Figura 2 convertida a {len(graph2_bytes) if graph2_bytes else 0} bytes")
+
+ # Verificar que las conversiones fueron exitosas antes de continuar
+ if not graph1_bytes or not graph2_bytes:
+ logger.error("Error al convertir figuras a bytes - obteniendo 0 bytes")
+ # Opción 1: Devolver error
+ raise ValueError("No se pudieron convertir las figuras a bytes")
+
+ # Crear tablas de resultados
+ table1 = create_concept_table(key_concepts1)
+ table2 = create_concept_table(key_concepts2)
+
+ # Cerrar figuras para liberar memoria
+ plt.close(fig1)
+ plt.close(fig2)
+
+ result = {
+ 'graph1': graph1_bytes, # Bytes en lugar de figura
+ 'graph2': graph2_bytes, # Bytes en lugar de figura
+ 'combined_graph': None, # No hay gráfico combinado por ahora
+ 'key_concepts1': key_concepts1,
+ 'key_concepts2': key_concepts2,
+ 'table1': table1,
+ 'table2': table2,
+ 'success': True
+ }
+
+ logger.info("Análisis del discurso completado y listo para almacenamiento")
+ return result
+
+ except Exception as e:
+ logger.error(f"Error en perform_discourse_analysis: {str(e)}")
+ # Asegurar limpieza de recursos
+ plt.close('all')
+ return {
+ 'success': False,
+ 'error': str(e)
+ }
+ finally:
+ # Asegurar limpieza en todos los casos
+ plt.close('all')
+
+#################################################################
\ No newline at end of file
diff --git a/src/modules/text_analysis/entity_analysis.py b/src/modules/text_analysis/entity_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/text_analysis/idiom_detection.py b/src/modules/text_analysis/idiom_detection.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/text_analysis/intertextual_analysis.py b/src/modules/text_analysis/intertextual_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/text_analysis/morpho_analysis-Back1910-25-9-24.py b/src/modules/text_analysis/morpho_analysis-Back1910-25-9-24.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a0823063d965ac2ca3715fc1484046dd8be39a6
--- /dev/null
+++ b/src/modules/text_analysis/morpho_analysis-Back1910-25-9-24.py
@@ -0,0 +1,253 @@
+import spacy
+from spacy import displacy
+from streamlit.components.v1 import html
+import base64
+
+from collections import Counter
+import re
+from ..utils.widget_utils import generate_unique_key
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+# Define colors for grammatical categories
+POS_COLORS = {
+ 'ADJ': '#FFA07A', # Light Salmon
+ 'ADP': '#98FB98', # Pale Green
+ 'ADV': '#87CEFA', # Light Sky Blue
+ 'AUX': '#DDA0DD', # Plum
+ 'CCONJ': '#F0E68C', # Khaki
+ 'DET': '#FFB6C1', # Light Pink
+ 'INTJ': '#FF6347', # Tomato
+ 'NOUN': '#90EE90', # Light Green
+ 'NUM': '#FAFAD2', # Light Goldenrod Yellow
+ 'PART': '#D3D3D3', # Light Gray
+ 'PRON': '#FFA500', # Orange
+ 'PROPN': '#20B2AA', # Light Sea Green
+ 'SCONJ': '#DEB887', # Burlywood
+ 'SYM': '#7B68EE', # Medium Slate Blue
+ 'VERB': '#FF69B4', # Hot Pink
+ 'X': '#A9A9A9', # Dark Gray
+}
+
+POS_TRANSLATIONS = {
+ 'es': {
+ 'ADJ': 'Adjetivo',
+ 'ADP': 'Preposición',
+ 'ADV': 'Adverbio',
+ 'AUX': 'Auxiliar',
+ 'CCONJ': 'Conjunción Coordinante',
+ 'DET': 'Determinante',
+ 'INTJ': 'Interjección',
+ 'NOUN': 'Sustantivo',
+ 'NUM': 'Número',
+ 'PART': 'Partícula',
+ 'PRON': 'Pronombre',
+ 'PROPN': 'Nombre Propio',
+ 'SCONJ': 'Conjunción Subordinante',
+ 'SYM': 'Símbolo',
+ 'VERB': 'Verbo',
+ 'X': 'Otro',
+ },
+ 'en': {
+ 'ADJ': 'Adjective',
+ 'ADP': 'Preposition',
+ 'ADV': 'Adverb',
+ 'AUX': 'Auxiliary',
+ 'CCONJ': 'Coordinating Conjunction',
+ 'DET': 'Determiner',
+ 'INTJ': 'Interjection',
+ 'NOUN': 'Noun',
+ 'NUM': 'Number',
+ 'PART': 'Particle',
+ 'PRON': 'Pronoun',
+ 'PROPN': 'Proper Noun',
+ 'SCONJ': 'Subordinating Conjunction',
+ 'SYM': 'Symbol',
+ 'VERB': 'Verb',
+ 'X': 'Other',
+ },
+ 'fr': {
+ 'ADJ': 'Adjectif',
+ 'ADP': 'Préposition',
+ 'ADV': 'Adverbe',
+ 'AUX': 'Auxiliaire',
+ 'CCONJ': 'Conjonction de Coordination',
+ 'DET': 'Déterminant',
+ 'INTJ': 'Interjection',
+ 'NOUN': 'Nom',
+ 'NUM': 'Nombre',
+ 'PART': 'Particule',
+ 'PRON': 'Pronom',
+ 'PROPN': 'Nom Propre',
+ 'SCONJ': 'Conjonction de Subordination',
+ 'SYM': 'Symbole',
+ 'VERB': 'Verbe',
+ 'X': 'Autre',
+ }
+}
+
+def generate_arc_diagram(doc):
+ arc_diagrams = []
+ for sent in doc.sents:
+ words = [token.text for token in sent]
+ # Calculamos el ancho del SVG basado en la longitud de la oración
+ svg_width = max(100, len(words) * 120)
+ # Altura fija para cada oración
+ svg_height = 300 # Controla la altura del SVG
+
+ # Renderizamos el diagrama de dependencias
+ html = displacy.render(sent, style="dep", options={
+ "add_lemma":False, # Introduced in version 2.2.4, this argument prints the lemma’s in a separate row below the token texts.
+ "arrow_spacing": 12, #This argument is used for adjusting the spacing between arrows in px to avoid overlaps.
+ "arrow_width": 2, #This argument is used for adjusting the width of arrow head in px.
+ "arrow_stroke": 2, #This argument is used for adjusting the width of arrow path in px.
+ "collapse_punct": True, #It attaches punctuation to the tokens.
+ "collapse_phrases": False, # This argument merges the noun phrases into one token.
+ "compact":False, # If you will take this argument as true, you will get the “Compact mode” with square arrows that takes up less space.
+ "color": "#ffffff",
+ "bg": "#0d6efd",
+ "compact": False, #Put the value of this argument True, if you want to use fine-grained part-of-speech tags (Token.tag_), instead of coarse-grained tags (Token.pos_).
+ "distance": 100, # Aumentamos la distancia entre palabras
+ "fine_grained": False, #Put the value of this argument True, if you want to use fine-grained part-of-speech tags (Token.tag_), instead of coarse-grained tags (Token.pos_).
+ "offset_x": 0, # This argument is used for spacing on left side of the SVG in px.
+ "word_spacing": 25, #This argument is used for adjusting the vertical spacing between words and arcs in px.
+ })
+
+ # Ajustamos el tamaño del SVG y el viewBox
+ html = re.sub(r'width="(\d+)"', f'width="{svg_width}"', html)
+ html = re.sub(r'height="(\d+)"', f'height="{svg_height}"', html)
+ html = re.sub(r'', unsafe_allow_html=True)
+ st.markdown("**¿Cómo leer el mapa de calor?**")
+ st.markdown("""
+ - 🌈 Colores más intensos indican mayor conexión entre oraciones
+ - 📝 La diagonal muestra la coherencia interna de cada oración
+ - 🔗 Las zonas claras sugieren oportunidades de mejorar conexiones
+ - 🎯 Un buen texto muestra patrones de color consistentes
+ """)
+ st.markdown("
", unsafe_allow_html=True)
+ st.markdown("'
+
+
+
+def identify_key_concepts(doc, min_freq=2, min_length=3):
+ """
+ Identifica conceptos clave en el texto.
+ Args:
+ doc: Documento procesado por spaCy
+ min_freq: Frecuencia mínima para considerar un concepto
+ min_length: Longitud mínima de palabra para considerar
+ Returns:
+ list: Lista de tuplas (concepto, frecuencia)
+ """
+ try:
+ # Obtener stopwords para el idioma
+ stopwords = get_stopwords(doc.lang_)
+
+ # Contar frecuencias de palabras
+ word_freq = Counter()
+
+ 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):
+
+ word_freq[token.lemma_.lower()] += 1
+
+ # Filtrar por frecuencia mínima
+ concepts = [(word, freq) for word, freq in word_freq.items()
+ if freq >= min_freq]
+
+ # Ordenar por frecuencia
+ concepts.sort(key=lambda x: x[1], reverse=True)
+
+ return concepts[:10] # Retornar los 10 conceptos más frecuentes
+
+ except Exception as e:
+ logger.error(f"Error en identify_key_concepts: {str(e)}")
+ return [] # Retornar lista vacía en caso de error
+
+
+def create_concept_graph(doc, key_concepts):
+ """
+ Crea un grafo de relaciones entre conceptos.
+ Args:
+ doc: Documento procesado por spaCy
+ key_concepts: Lista de tuplas (concepto, frecuencia)
+ Returns:
+ nx.Graph: Grafo de conceptos
+ """
+ try:
+ G = nx.Graph()
+
+ # Crear un conjunto de conceptos clave para búsqueda rápida
+ concept_words = {concept[0].lower() for concept in key_concepts}
+
+ # 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
+ current_concepts = []
+ for token in sent:
+ if 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)
+
+ return G
+
+ 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.
+ Args:
+ G: Grafo de networkx
+ lang_code: Código del idioma
+ Returns:
+ matplotlib.figure.Figure: Figura con el grafo visualizado
+ """
+ try:
+ plt.figure(figsize=(12, 8))
+
+ # Calcular el layout del grafo
+ pos = nx.spring_layout(G)
+
+ # Obtener pesos de nodos y aristas
+ node_weights = [G.nodes[node].get('weight', 1) * 500 for node in G.nodes()]
+ edge_weights = [G[u][v].get('weight', 1) for u, v in G.edges()]
+
+ # Dibujar el 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')
+
+ nx.draw_networkx_labels(G, pos,
+ font_size=10,
+ font_weight='bold')
+
+ plt.title("Red de conceptos relacionados")
+ plt.axis('off')
+
+ return plt.gcf()
+
+ except Exception as e:
+ logger.error(f"Error en visualize_concept_graph: {str(e)}")
+ # Retornar una figura vacía en caso de error
+ return plt.figure()
+
+def create_entity_graph(entities):
+ G = nx.Graph()
+ for entity_type, entity_list in entities.items():
+ for entity in entity_list:
+ G.add_node(entity, type=entity_type)
+ for i, entity1 in enumerate(entity_list):
+ for entity2 in entity_list[i+1:]:
+ G.add_edge(entity1, entity2)
+ return G
+
+def visualize_entity_graph(G, lang_code):
+ fig, ax = plt.subplots(figsize=(12, 8))
+ pos = nx.spring_layout(G)
+ for entity_type, color in ENTITY_LABELS[lang_code].items():
+ node_list = [node for node, data in G.nodes(data=True) if data['type'] == entity_type]
+ nx.draw_networkx_nodes(G, pos, nodelist=node_list, node_color=color, node_size=500, alpha=0.8, ax=ax)
+ nx.draw_networkx_edges(G, pos, width=1, alpha=0.5, ax=ax)
+ nx.draw_networkx_labels(G, pos, font_size=8, font_weight="bold", ax=ax)
+ ax.set_title(f"Relaciones entre Entidades ({lang_code})", fontsize=16)
+ ax.axis('off')
+ plt.tight_layout()
+ return fig
+
+
+#################################################################################
+def create_topic_graph(topics, doc):
+ G = nx.Graph()
+ for topic in topics:
+ G.add_node(topic, weight=doc.text.count(topic))
+ for i, topic1 in enumerate(topics):
+ for topic2 in topics[i+1:]:
+ weight = sum(1 for sent in doc.sents if topic1 in sent.text and topic2 in sent.text)
+ if weight > 0:
+ G.add_edge(topic1, topic2, weight=weight)
+ return G
+
+def visualize_topic_graph(G, lang_code):
+ fig, ax = plt.subplots(figsize=(12, 8))
+ pos = nx.spring_layout(G)
+ node_sizes = [G.nodes[node]['weight'] * 100 for node in G.nodes()]
+ nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color='lightgreen', alpha=0.8, ax=ax)
+ nx.draw_networkx_labels(G, pos, font_size=10, font_weight="bold", ax=ax)
+ edge_weights = [G[u][v]['weight'] for u, v in G.edges()]
+ nx.draw_networkx_edges(G, pos, width=edge_weights, alpha=0.5, ax=ax)
+ ax.set_title(f"Relaciones entre Temas ({lang_code})", fontsize=16)
+ ax.axis('off')
+ plt.tight_layout()
+ return fig
+
+###########################################################################################
+def generate_summary(doc, lang_code):
+ sentences = list(doc.sents)
+ summary = sentences[:3] # Toma las primeras 3 oraciones como resumen
+ return " ".join([sent.text for sent in summary])
+
+def extract_entities(doc, lang_code):
+ entities = defaultdict(list)
+ for ent in doc.ents:
+ if ent.label_ in ENTITY_LABELS[lang_code]:
+ entities[ent.label_].append(ent.text)
+ return dict(entities)
+
+def analyze_sentiment(doc, lang_code):
+ positive_words = sum(1 for token in doc if token.sentiment > 0)
+ negative_words = sum(1 for token in doc if token.sentiment < 0)
+ total_words = len(doc)
+ if positive_words > negative_words:
+ return "Positivo"
+ elif negative_words > positive_words:
+ return "Negativo"
+ else:
+ return "Neutral"
+
+def extract_topics(doc, lang_code):
+ vectorizer = TfidfVectorizer(stop_words='english', max_features=5)
+ tfidf_matrix = vectorizer.fit_transform([doc.text])
+ feature_names = vectorizer.get_feature_names_out()
+ return list(feature_names)
+
+# Asegúrate de que todas las funciones necesarias estén exportadas
+__all__ = [
+ 'perform_semantic_analysis',
+ 'identify_key_concepts',
+ 'create_concept_graph',
+ 'visualize_concept_graph',
+ 'create_entity_graph',
+ 'visualize_entity_graph',
+ 'generate_summary',
+ 'extract_entities',
+ 'analyze_sentiment',
+ 'create_topic_graph',
+ 'visualize_topic_graph',
+ 'extract_topics',
+ 'ENTITY_LABELS',
+ 'POS_COLORS',
+ 'POS_TRANSLATIONS'
+]
\ No newline at end of file
diff --git a/src/modules/text_analysis/semantic_analysis.py b/src/modules/text_analysis/semantic_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f7cc5004e47a2831e19c60e710348a42650d53a
--- /dev/null
+++ b/src/modules/text_analysis/semantic_analysis.py
@@ -0,0 +1,475 @@
+# modules/text_analysis/semantic_analysis.py
+
+# 1. Importaciones estándar del sistema
+import logging
+import io
+import base64
+from collections import Counter, defaultdict
+
+# 2. Importaciones de terceros
+import streamlit as st
+import spacy
+import networkx as nx
+import matplotlib.pyplot as plt
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Solo configurar si no hay handlers ya configurados
+logger = logging.getLogger(__name__)
+
+# 4. Importaciones locales
+from .stopwords import (
+ process_text,
+ clean_text,
+ get_custom_stopwords,
+ get_stopwords_for_spacy
+)
+
+
+# Define colors for grammatical categories
+POS_COLORS = {
+ 'ADJ': '#FFA07A', 'ADP': '#98FB98', 'ADV': '#87CEFA', 'AUX': '#DDA0DD',
+ 'CCONJ': '#F0E68C', 'DET': '#FFB6C1', 'INTJ': '#FF6347', 'NOUN': '#90EE90',
+ 'NUM': '#FAFAD2', 'PART': '#D3D3D3', 'PRON': '#FFA500', 'PROPN': '#20B2AA',
+ 'SCONJ': '#DEB887', 'SYM': '#7B68EE', 'VERB': '#FF69B4', 'X': '#A9A9A9',
+}
+
+POS_TRANSLATIONS = {
+ 'es': {
+ 'ADJ': 'Adjetivo', 'ADP': 'Preposición', 'ADV': 'Adverbio', 'AUX': 'Auxiliar',
+ 'CCONJ': 'Conjunción Coordinante', 'DET': 'Determinante', 'INTJ': 'Interjección',
+ 'NOUN': 'Sustantivo', 'NUM': 'Número', 'PART': 'Partícula', 'PRON': 'Pronombre',
+ 'PROPN': 'Nombre Propio', 'SCONJ': 'Conjunción Subordinante', 'SYM': 'Símbolo',
+ 'VERB': 'Verbo', 'X': 'Otro',
+ },
+ 'en': {
+ 'ADJ': 'Adjective', 'ADP': 'Preposition', 'ADV': 'Adverb', 'AUX': 'Auxiliary',
+ 'CCONJ': 'Coordinating Conjunction', 'DET': 'Determiner', 'INTJ': 'Interjection',
+ 'NOUN': 'Noun', 'NUM': 'Number', 'PART': 'Particle', 'PRON': 'Pronoun',
+ 'PROPN': 'Proper Noun', 'SCONJ': 'Subordinating Conjunction', 'SYM': 'Symbol',
+ 'VERB': 'Verb', 'X': 'Other',
+ },
+ 'fr': {
+ 'ADJ': 'Adjectif', 'ADP': 'Préposition', 'ADV': 'Adverbe', 'AUX': 'Auxiliaire',
+ 'CCONJ': 'Conjonction de Coordination', 'DET': 'Déterminant', 'INTJ': 'Interjection',
+ 'NOUN': 'Nom', 'NUM': 'Nombre', 'PART': 'Particule', 'PRON': 'Pronom',
+ 'PROPN': 'Nom Propre', 'SCONJ': 'Conjonction de Subordination', 'SYM': 'Symbole',
+ 'VERB': 'Verbe', 'X': 'Autre',
+ }
+}
+
+ENTITY_LABELS = {
+ 'es': {
+ "Personas": "lightblue",
+ "Lugares": "lightcoral",
+ "Inventos": "lightgreen",
+ "Fechas": "lightyellow",
+ "Conceptos": "lightpink"
+ },
+ 'en': {
+ "People": "lightblue",
+ "Places": "lightcoral",
+ "Inventions": "lightgreen",
+ "Dates": "lightyellow",
+ "Concepts": "lightpink"
+ },
+ 'fr': {
+ "Personnes": "lightblue",
+ "Lieux": "lightcoral",
+ "Inventions": "lightgreen",
+ "Dates": "lightyellow",
+ "Concepts": "lightpink"
+ }
+}
+
+###########################################################
+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 perform_semantic_analysis(text, nlp, lang_code):
+ """
+ Realiza el análisis semántico completo del texto.
+ """
+ if not text or not nlp or not lang_code:
+ logger.error("Parámetros inválidos para el análisis semántico")
+ return {
+ 'success': False,
+ 'error': 'Parámetros inválidos'
+ }
+
+ try:
+ logger.info(f"Starting semantic analysis for language: {lang_code}")
+
+ # Procesar texto y remover stopwords
+ doc = nlp(text)
+ if not doc:
+ logger.error("Error al procesar el texto con spaCy")
+ return {
+ 'success': False,
+ 'error': 'Error al procesar el texto'
+ }
+
+ # Identificar conceptos clave
+ logger.info("Identificando conceptos clave...")
+ stopwords = get_custom_stopwords(lang_code)
+ key_concepts = identify_key_concepts(doc, stopwords=stopwords)
+
+ if not key_concepts:
+ logger.warning("No se identificaron conceptos clave")
+ return {
+ 'success': False,
+ 'error': 'No se pudieron identificar conceptos clave'
+ }
+
+ # Crear grafo de conceptos
+ logger.info(f"Creando grafo de conceptos con {len(key_concepts)} conceptos...")
+ concept_graph = create_concept_graph(doc, key_concepts)
+
+ if not concept_graph.nodes():
+ logger.warning("Se creó un grafo vacío")
+ return {
+ 'success': False,
+ 'error': 'No se pudo crear el grafo de conceptos'
+ }
+
+ # Visualizar grafo
+ logger.info("Visualizando grafo...")
+ plt.clf() # Limpiar figura actual
+ concept_graph_fig = visualize_concept_graph(concept_graph, lang_code)
+
+ # Convertir a bytes
+ logger.info("Convirtiendo grafo a bytes...")
+ graph_bytes = fig_to_bytes(concept_graph_fig)
+
+ if not graph_bytes:
+ logger.error("Error al convertir grafo a bytes")
+ return {
+ 'success': False,
+ 'error': 'Error al generar visualización'
+ }
+
+ # Limpiar recursos
+ plt.close(concept_graph_fig)
+ plt.close('all')
+
+ result = {
+ 'success': True,
+ 'key_concepts': key_concepts,
+ 'concept_graph': graph_bytes
+ }
+
+ logger.info("Análisis semántico completado exitosamente")
+ return result
+
+ except Exception as e:
+ logger.error(f"Error in perform_semantic_analysis: {str(e)}")
+ plt.close('all') # Asegurarse de limpiar recursos
+ return {
+ 'success': False,
+ 'error': str(e)
+ }
+ finally:
+ plt.close('all') # Asegurar limpieza incluso si hay error
+
+############################################################
+
+def identify_key_concepts(doc, stopwords, min_freq=2, min_length=3):
+ """
+ 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:
+ # 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 after excluding entities")
+ return concepts[:10]
+
+ except Exception as e:
+ logger.error(f"Error en identify_key_concepts: {str(e)}")
+ return []
+
+########################################################################
+
+def create_concept_graph(doc, key_concepts):
+ """
+ Crea un grafo de relaciones entre conceptos, ignorando entidades.
+ Args:
+ doc: Documento procesado por spaCy
+ key_concepts: Lista de tuplas (concepto, frecuencia)
+ Returns:
+ nx.Graph: Grafo de conceptos
+ """
+ try:
+ G = nx.Graph()
+
+ # 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, excluyendo entidades
+ current_concepts = []
+ for token in sent:
+ 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:
+ if G.has_edge(concept1, concept2):
+ G[concept1][concept2]['weight'] += 1
+ else:
+ G.add_edge(concept1, concept2, weight=1)
+
+ return G
+
+ except Exception as e:
+ logger.error(f"Error en create_concept_graph: {str(e)}")
+ return nx.Graph()
+
+###############################################################################
+
+def visualize_concept_graph(G, lang_code):
+ try:
+ # 1. Diccionario de traducciones
+ GRAPH_LABELS = {
+ 'es': {
+ 'concept_network': 'Relaciones entre conceptos clave',
+ 'concept_centrality': 'Centralidad de conceptos clave'
+ },
+ 'en': {
+ 'concept_network': 'Relationships between key concepts',
+ 'concept_centrality': 'Concept centrality'
+ },
+ 'fr': {
+ 'concept_network': 'Relations entre concepts clés',
+ 'concept_centrality': 'Centralité des concepts'
+ },
+ 'pt': {
+ 'concept_network': 'Relações entre conceitos-chave',
+ 'concept_centrality': 'Centralidade dos conceitos'
+ }
+ }
+
+ # 2. Obtener traducciones (inglés por defecto)
+ translations = GRAPH_LABELS.get(lang_code, GRAPH_LABELS['en'])
+
+ # Configuración de la figura
+ fig, ax = plt.subplots(figsize=(15, 10))
+
+ if not G.nodes():
+ logger.warning("Grafo vacío, retornando figura vacía")
+ return fig
+
+ # Convertir a grafo dirigido para flechas
+ DG = nx.DiGraph(G)
+ centrality = nx.degree_centrality(G)
+
+ # Layout consistente
+ pos = nx.spring_layout(DG, k=2, iterations=50, seed=42)
+
+ # Escalado de elementos visuales
+ num_nodes = len(DG.nodes())
+ scale_factor = 1000 if num_nodes < 10 else 500 if num_nodes < 20 else 200
+ node_sizes = [DG.nodes[node].get('weight', 1) * scale_factor for node in DG.nodes()]
+ edge_widths = [DG[u][v].get('weight', 1) for u, v in DG.edges()]
+ node_colors = [plt.cm.viridis(centrality[node]) for node in DG.nodes()]
+
+ # Dibujar elementos del grafo
+ nx.draw_networkx_nodes(
+ DG, pos,
+ node_size=node_sizes,
+ node_color=node_colors,
+ alpha=0.7,
+ ax=ax
+ )
+
+ nx.draw_networkx_edges(
+ DG, pos,
+ width=edge_widths,
+ alpha=0.6,
+ edge_color='gray',
+ arrows=True,
+ arrowsize=20,
+ arrowstyle='->',
+ connectionstyle='arc3,rad=0.2',
+ ax=ax
+ )
+
+ # Etiquetas de nodos
+ font_size = 12 if num_nodes < 10 else 10 if num_nodes < 20 else 8
+ nx.draw_networkx_labels(
+ DG, pos,
+ font_size=font_size,
+ font_weight='bold',
+ bbox=dict(facecolor='white', edgecolor='none', alpha=0.7),
+ ax=ax
+ )
+
+ # Barra de color (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=translations['concept_centrality'])
+
+ # Título del gráfico
+ plt.title(translations['concept_network'], pad=20, fontsize=14)
+ ax.set_axis_off()
+ plt.tight_layout()
+
+ return fig
+
+ except Exception as e:
+ logger.error(f"Error en visualize_concept_graph: {str(e)}")
+ return plt.figure()
+
+########################################################################
+def create_entity_graph(entities):
+ G = nx.Graph()
+ for entity_type, entity_list in entities.items():
+ for entity in entity_list:
+ G.add_node(entity, type=entity_type)
+ for i, entity1 in enumerate(entity_list):
+ for entity2 in entity_list[i+1:]:
+ G.add_edge(entity1, entity2)
+ return G
+
+
+#############################################################
+def visualize_entity_graph(G, lang_code):
+ fig, ax = plt.subplots(figsize=(12, 8))
+ pos = nx.spring_layout(G)
+ for entity_type, color in ENTITY_LABELS[lang_code].items():
+ node_list = [node for node, data in G.nodes(data=True) if data['type'] == entity_type]
+ nx.draw_networkx_nodes(G, pos, nodelist=node_list, node_color=color, node_size=500, alpha=0.8, ax=ax)
+ nx.draw_networkx_edges(G, pos, width=1, alpha=0.5, ax=ax)
+ nx.draw_networkx_labels(G, pos, font_size=8, font_weight="bold", ax=ax)
+ ax.set_title(f"Relaciones entre Entidades ({lang_code})", fontsize=16)
+ ax.axis('off')
+ plt.tight_layout()
+ return fig
+
+
+#################################################################################
+def create_topic_graph(topics, doc):
+ G = nx.Graph()
+ for topic in topics:
+ G.add_node(topic, weight=doc.text.count(topic))
+ for i, topic1 in enumerate(topics):
+ for topic2 in topics[i+1:]:
+ weight = sum(1 for sent in doc.sents if topic1 in sent.text and topic2 in sent.text)
+ if weight > 0:
+ G.add_edge(topic1, topic2, weight=weight)
+ return G
+
+def visualize_topic_graph(G, lang_code):
+ fig, ax = plt.subplots(figsize=(12, 8))
+ pos = nx.spring_layout(G)
+ node_sizes = [G.nodes[node]['weight'] * 100 for node in G.nodes()]
+ nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color='lightgreen', alpha=0.8, ax=ax)
+ nx.draw_networkx_labels(G, pos, font_size=10, font_weight="bold", ax=ax)
+ edge_weights = [G[u][v]['weight'] for u, v in G.edges()]
+ nx.draw_networkx_edges(G, pos, width=edge_weights, alpha=0.5, ax=ax)
+ ax.set_title(f"Relaciones entre Temas ({lang_code})", fontsize=16)
+ ax.axis('off')
+ plt.tight_layout()
+ return fig
+
+###########################################################################################
+def generate_summary(doc, lang_code):
+ sentences = list(doc.sents)
+ summary = sentences[:3] # Toma las primeras 3 oraciones como resumen
+ return " ".join([sent.text for sent in summary])
+
+def extract_entities(doc, lang_code):
+ entities = defaultdict(list)
+ for ent in doc.ents:
+ if ent.label_ in ENTITY_LABELS[lang_code]:
+ entities[ent.label_].append(ent.text)
+ return dict(entities)
+
+def analyze_sentiment(doc, lang_code):
+ positive_words = sum(1 for token in doc if token.sentiment > 0)
+ negative_words = sum(1 for token in doc if token.sentiment < 0)
+ total_words = len(doc)
+ if positive_words > negative_words:
+ return "Positivo"
+ elif negative_words > positive_words:
+ return "Negativo"
+ else:
+ return "Neutral"
+
+def extract_topics(doc, lang_code):
+ vectorizer = TfidfVectorizer(stop_words='english', max_features=5)
+ tfidf_matrix = vectorizer.fit_transform([doc.text])
+ feature_names = vectorizer.get_feature_names_out()
+ return list(feature_names)
+
+# Asegúrate de que todas las funciones necesarias estén exportadas
+__all__ = [
+ 'perform_semantic_analysis',
+ 'identify_key_concepts',
+ 'create_concept_graph',
+ 'visualize_concept_graph',
+ 'fig_to_bytes', # Faltaba esta coma
+ 'ENTITY_LABELS',
+ 'POS_COLORS',
+ 'POS_TRANSLATIONS'
+]
\ No newline at end of file
diff --git a/src/modules/text_analysis/semantic_analysis_v0.py b/src/modules/text_analysis/semantic_analysis_v0.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1b4d7c9379a0c76f686b8be2e529cf4311cceb5
--- /dev/null
+++ b/src/modules/text_analysis/semantic_analysis_v0.py
@@ -0,0 +1,264 @@
+#semantic_analysis.py
+import streamlit as st
+import spacy
+import networkx as nx
+import matplotlib.pyplot as plt
+from collections import Counter
+from collections import defaultdict
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Define colors for grammatical categories
+POS_COLORS = {
+ 'ADJ': '#FFA07A', # Light Salmon
+ 'ADP': '#98FB98', # Pale Green
+ 'ADV': '#87CEFA', # Light Sky Blue
+ 'AUX': '#DDA0DD', # Plum
+ 'CCONJ': '#F0E68C', # Khaki
+ 'DET': '#FFB6C1', # Light Pink
+ 'INTJ': '#FF6347', # Tomato
+ 'NOUN': '#90EE90', # Light Green
+ 'NUM': '#FAFAD2', # Light Goldenrod Yellow
+ 'PART': '#D3D3D3', # Light Gray
+ 'PRON': '#FFA500', # Orange
+ 'PROPN': '#20B2AA', # Light Sea Green
+ 'SCONJ': '#DEB887', # Burlywood
+ 'SYM': '#7B68EE', # Medium Slate Blue
+ 'VERB': '#FF69B4', # Hot Pink
+ 'X': '#A9A9A9', # Dark Gray
+}
+
+POS_TRANSLATIONS = {
+ 'es': {
+ 'ADJ': 'Adjetivo',
+ 'ADP': 'Preposición',
+ 'ADV': 'Adverbio',
+ 'AUX': 'Auxiliar',
+ 'CCONJ': 'Conjunción Coordinante',
+ 'DET': 'Determinante',
+ 'INTJ': 'Interjección',
+ 'NOUN': 'Sustantivo',
+ 'NUM': 'Número',
+ 'PART': 'Partícula',
+ 'PRON': 'Pronombre',
+ 'PROPN': 'Nombre Propio',
+ 'SCONJ': 'Conjunción Subordinante',
+ 'SYM': 'Símbolo',
+ 'VERB': 'Verbo',
+ 'X': 'Otro',
+ },
+ 'en': {
+ 'ADJ': 'Adjective',
+ 'ADP': 'Preposition',
+ 'ADV': 'Adverb',
+ 'AUX': 'Auxiliary',
+ 'CCONJ': 'Coordinating Conjunction',
+ 'DET': 'Determiner',
+ 'INTJ': 'Interjection',
+ 'NOUN': 'Noun',
+ 'NUM': 'Number',
+ 'PART': 'Particle',
+ 'PRON': 'Pronoun',
+ 'PROPN': 'Proper Noun',
+ 'SCONJ': 'Subordinating Conjunction',
+ 'SYM': 'Symbol',
+ 'VERB': 'Verb',
+ 'X': 'Other',
+ },
+ 'fr': {
+ 'ADJ': 'Adjectif',
+ 'ADP': 'Préposition',
+ 'ADV': 'Adverbe',
+ 'AUX': 'Auxiliaire',
+ 'CCONJ': 'Conjonction de Coordination',
+ 'DET': 'Déterminant',
+ 'INTJ': 'Interjection',
+ 'NOUN': 'Nom',
+ 'NUM': 'Nombre',
+ 'PART': 'Particule',
+ 'PRON': 'Pronom',
+ 'PROPN': 'Nom Propre',
+ 'SCONJ': 'Conjonction de Subordination',
+ 'SYM': 'Symbole',
+ 'VERB': 'Verbe',
+ 'X': 'Autre',
+ }
+}
+########################################################################################################################################
+
+# Definimos las etiquetas y colores para cada idioma
+ENTITY_LABELS = {
+ 'es': {
+ "Personas": "lightblue",
+ "Conceptos": "lightgreen",
+ "Lugares": "lightcoral",
+ "Fechas": "lightyellow"
+ },
+ 'en': {
+ "People": "lightblue",
+ "Concepts": "lightgreen",
+ "Places": "lightcoral",
+ "Dates": "lightyellow"
+ },
+ 'fr': {
+ "Personnes": "lightblue",
+ "Concepts": "lightgreen",
+ "Lieux": "lightcoral",
+ "Dates": "lightyellow"
+ }
+}
+
+#########################################################################################################
+def count_pos(doc):
+ return Counter(token.pos_ for token in doc if token.pos_ != 'PUNCT')
+
+#####################################################################################################################
+
+def create_semantic_graph(doc, lang):
+ G = nx.Graph()
+ word_freq = defaultdict(int)
+ lemma_to_word = {}
+ lemma_to_pos = {}
+
+ # Count frequencies of lemmas and map lemmas to their most common word form and POS
+ for token in doc:
+ if token.pos_ in ['NOUN', 'VERB']:
+ lemma = token.lemma_.lower()
+ word_freq[lemma] += 1
+ if lemma not in lemma_to_word or token.text.lower() == lemma:
+ lemma_to_word[lemma] = token.text
+ lemma_to_pos[lemma] = token.pos_
+
+ # Get top 20 most frequent lemmas
+ top_lemmas = [lemma for lemma, _ in sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:20]]
+
+ # Add nodes
+ for lemma in top_lemmas:
+ word = lemma_to_word[lemma]
+ G.add_node(word, pos=lemma_to_pos[lemma])
+
+ # Add edges
+ for token in doc:
+ if token.lemma_.lower() in top_lemmas:
+ if token.head.lemma_.lower() in top_lemmas:
+ source = lemma_to_word[token.lemma_.lower()]
+ target = lemma_to_word[token.head.lemma_.lower()]
+ if source != target: # Avoid self-loops
+ G.add_edge(source, target, label=token.dep_)
+
+ return G, word_freq
+
+############################################################################################################################################
+
+def visualize_semantic_relations(doc, lang):
+ G = nx.Graph()
+ word_freq = defaultdict(int)
+ lemma_to_word = {}
+ lemma_to_pos = {}
+
+ # Count frequencies of lemmas and map lemmas to their most common word form and POS
+ for token in doc:
+ if token.pos_ in ['NOUN', 'VERB']:
+ lemma = token.lemma_.lower()
+ word_freq[lemma] += 1
+ if lemma not in lemma_to_word or token.text.lower() == lemma:
+ lemma_to_word[lemma] = token.text
+ lemma_to_pos[lemma] = token.pos_
+
+ # Get top 20 most frequent lemmas
+ top_lemmas = [lemma for lemma, _ in sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:20]]
+
+ # Add nodes
+ for lemma in top_lemmas:
+ word = lemma_to_word[lemma]
+ G.add_node(word, pos=lemma_to_pos[lemma])
+
+ # Add edges
+ for token in doc:
+ if token.lemma_.lower() in top_lemmas:
+ if token.head.lemma_.lower() in top_lemmas:
+ source = lemma_to_word[token.lemma_.lower()]
+ target = lemma_to_word[token.head.lemma_.lower()]
+ if source != target: # Avoid self-loops
+ G.add_edge(source, target, label=token.dep_)
+
+ fig, ax = plt.subplots(figsize=(36, 27))
+ pos = nx.spring_layout(G, k=0.7, iterations=50)
+
+ node_colors = [POS_COLORS.get(G.nodes[node]['pos'], '#CCCCCC') for node in G.nodes()]
+
+ nx.draw(G, pos, node_color=node_colors, with_labels=True,
+ node_size=10000,
+ font_size=16,
+ font_weight='bold',
+ arrows=True,
+ arrowsize=30,
+ width=3,
+ edge_color='gray',
+ ax=ax)
+
+ edge_labels = nx.get_edge_attributes(G, 'label')
+ nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=14, ax=ax)
+
+ title = {
+ 'es': "Relaciones Semánticas Relevantes",
+ 'en': "Relevant Semantic Relations",
+ 'fr': "Relations Sémantiques Pertinentes"
+ }
+ ax.set_title(title[lang], fontsize=24, fontweight='bold')
+ ax.axis('off')
+
+ legend_elements = [plt.Rectangle((0,0),1,1,fc=POS_COLORS.get(pos, '#CCCCCC'), edgecolor='none',
+ label=f"{POS_TRANSLATIONS[lang].get(pos, pos)}")
+ for pos in ['NOUN', 'VERB']]
+ ax.legend(handles=legend_elements, loc='center left', bbox_to_anchor=(1, 0.5), fontsize=16)
+
+ return fig
+
+############################################################################################################################################
+def identify_and_contextualize_entities(doc, lang):
+ entities = []
+ for ent in doc.ents:
+ # Obtener el contexto (3 palabras antes y después de la entidad)
+ start = max(0, ent.start - 3)
+ end = min(len(doc), ent.end + 3)
+ context = doc[start:end].text
+
+ entities.append({
+ 'text': ent.text,
+ 'label': ent.label_,
+ 'start': ent.start,
+ 'end': ent.end,
+ 'context': context
+ })
+
+ # Identificar conceptos clave (usando sustantivos y verbos más frecuentes)
+ word_freq = Counter([token.lemma_.lower() for token in doc if token.pos_ in ['NOUN', 'VERB'] and not token.is_stop])
+ key_concepts = word_freq.most_common(10) # Top 10 conceptos clave
+
+ return entities, key_concepts
+
+
+############################################################################################################################################
+def perform_semantic_analysis(text, nlp, lang):
+ doc = nlp(text)
+
+ # Identificar entidades y conceptos clave
+ entities, key_concepts = identify_and_contextualize_entities(doc, lang)
+
+ # Visualizar relaciones semánticas
+ relations_graph = visualize_semantic_relations(doc, lang)
+
+ # Imprimir entidades para depuración
+ print(f"Entidades encontradas ({lang}):")
+ for ent in doc.ents:
+ print(f"{ent.text} - {ent.label_}")
+
+ relations_graph = visualize_semantic_relations(doc, lang)
+ return {
+ 'entities': entities,
+ 'key_concepts': key_concepts,
+ 'relations_graph': relations_graph
+ }
+
+__all__ = ['visualize_semantic_relations', 'create_semantic_graph', 'POS_COLORS', 'POS_TRANSLATIONS', 'identify_and_contextualize_entities']
\ No newline at end of file
diff --git a/src/modules/text_analysis/semantic_analysis_v00.py b/src/modules/text_analysis/semantic_analysis_v00.py
new file mode 100644
index 0000000000000000000000000000000000000000..22a37a74e462656aeb061fc8b6a65723d1a654a5
--- /dev/null
+++ b/src/modules/text_analysis/semantic_analysis_v00.py
@@ -0,0 +1,153 @@
+#semantic_analysis.py
+import streamlit as st
+import spacy
+import networkx as nx
+import matplotlib.pyplot as plt
+from collections import Counter, defaultdict
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Define colors for grammatical categories
+POS_COLORS = {
+ 'ADJ': '#FFA07A', 'ADP': '#98FB98', 'ADV': '#87CEFA', 'AUX': '#DDA0DD',
+ 'CCONJ': '#F0E68C', 'DET': '#FFB6C1', 'INTJ': '#FF6347', 'NOUN': '#90EE90',
+ 'NUM': '#FAFAD2', 'PART': '#D3D3D3', 'PRON': '#FFA500', 'PROPN': '#20B2AA',
+ 'SCONJ': '#DEB887', 'SYM': '#7B68EE', 'VERB': '#FF69B4', 'X': '#A9A9A9',
+}
+
+POS_TRANSLATIONS = {
+ 'es': {
+ 'ADJ': 'Adjetivo', 'ADP': 'Preposición', 'ADV': 'Adverbio', 'AUX': 'Auxiliar',
+ 'CCONJ': 'Conjunción Coordinante', 'DET': 'Determinante', 'INTJ': 'Interjección',
+ 'NOUN': 'Sustantivo', 'NUM': 'Número', 'PART': 'Partícula', 'PRON': 'Pronombre',
+ 'PROPN': 'Nombre Propio', 'SCONJ': 'Conjunción Subordinante', 'SYM': 'Símbolo',
+ 'VERB': 'Verbo', 'X': 'Otro',
+ },
+ 'en': {
+ 'ADJ': 'Adjective', 'ADP': 'Preposition', 'ADV': 'Adverb', 'AUX': 'Auxiliary',
+ 'CCONJ': 'Coordinating Conjunction', 'DET': 'Determiner', 'INTJ': 'Interjection',
+ 'NOUN': 'Noun', 'NUM': 'Number', 'PART': 'Particle', 'PRON': 'Pronoun',
+ 'PROPN': 'Proper Noun', 'SCONJ': 'Subordinating Conjunction', 'SYM': 'Symbol',
+ 'VERB': 'Verb', 'X': 'Other',
+ },
+ 'fr': {
+ 'ADJ': 'Adjectif', 'ADP': 'Préposition', 'ADV': 'Adverbe', 'AUX': 'Auxiliaire',
+ 'CCONJ': 'Conjonction de Coordination', 'DET': 'Déterminant', 'INTJ': 'Interjection',
+ 'NOUN': 'Nom', 'NUM': 'Nombre', 'PART': 'Particule', 'PRON': 'Pronom',
+ 'PROPN': 'Nom Propre', 'SCONJ': 'Conjonction de Subordination', 'SYM': 'Symbole',
+ 'VERB': 'Verbe', 'X': 'Autre',
+ }
+}
+
+ENTITY_LABELS = {
+ 'es': {
+ "Personas": "lightblue",
+ "Lugares": "lightcoral",
+ "Inventos": "lightgreen",
+ "Fechas": "lightyellow",
+ "Conceptos": "lightpink"
+ },
+ 'en': {
+ "People": "lightblue",
+ "Places": "lightcoral",
+ "Inventions": "lightgreen",
+ "Dates": "lightyellow",
+ "Concepts": "lightpink"
+ },
+ 'fr': {
+ "Personnes": "lightblue",
+ "Lieux": "lightcoral",
+ "Inventions": "lightgreen",
+ "Dates": "lightyellow",
+ "Concepts": "lightpink"
+ }
+}
+
+def identify_and_contextualize_entities(doc, lang):
+ entities = []
+ for ent in doc.ents:
+ # Obtener el contexto (3 palabras antes y después de la entidad)
+ start = max(0, ent.start - 3)
+ end = min(len(doc), ent.end + 3)
+ context = doc[start:end].text
+
+ # Mapear las etiquetas de spaCy a nuestras categorías
+ if ent.label_ in ['PERSON', 'ORG']:
+ category = "Personas" if lang == 'es' else "People" if lang == 'en' else "Personnes"
+ elif ent.label_ in ['LOC', 'GPE']:
+ category = "Lugares" if lang == 'es' else "Places" if lang == 'en' else "Lieux"
+ elif ent.label_ in ['PRODUCT']:
+ category = "Inventos" if lang == 'es' else "Inventions" if lang == 'en' else "Inventions"
+ elif ent.label_ in ['DATE', 'TIME']:
+ category = "Fechas" if lang == 'es' else "Dates" if lang == 'en' else "Dates"
+ else:
+ category = "Conceptos" if lang == 'es' else "Concepts" if lang == 'en' else "Concepts"
+
+ entities.append({
+ 'text': ent.text,
+ 'label': category,
+ 'start': ent.start,
+ 'end': ent.end,
+ 'context': context
+ })
+
+ # Identificar conceptos clave (usando sustantivos y verbos más frecuentes)
+ word_freq = Counter([token.lemma_.lower() for token in doc if token.pos_ in ['NOUN', 'VERB'] and not token.is_stop])
+ key_concepts = word_freq.most_common(10) # Top 10 conceptos clave
+
+ return entities, key_concepts
+
+def create_concept_graph(text, concepts):
+ vectorizer = TfidfVectorizer()
+ tfidf_matrix = vectorizer.fit_transform([text])
+ concept_vectors = vectorizer.transform(concepts)
+ similarity_matrix = cosine_similarity(concept_vectors, concept_vectors)
+
+ G = nx.Graph()
+ for i, concept in enumerate(concepts):
+ G.add_node(concept)
+ for j in range(i+1, len(concepts)):
+ if similarity_matrix[i][j] > 0.1:
+ G.add_edge(concept, concepts[j], weight=similarity_matrix[i][j])
+
+ return G
+
+def visualize_concept_graph(G, lang):
+ fig, ax = plt.subplots(figsize=(12, 8))
+ pos = nx.spring_layout(G)
+
+ nx.draw_networkx_nodes(G, pos, node_size=3000, node_color='lightblue', ax=ax)
+ nx.draw_networkx_labels(G, pos, font_size=10, font_weight="bold", ax=ax)
+ nx.draw_networkx_edges(G, pos, width=1, ax=ax)
+
+ edge_labels = nx.get_edge_attributes(G, 'weight')
+ nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8, ax=ax)
+
+ title = {
+ 'es': "Relaciones Conceptuales",
+ 'en': "Conceptual Relations",
+ 'fr': "Relations Conceptuelles"
+ }
+ ax.set_title(title[lang], fontsize=16)
+ ax.axis('off')
+
+ return fig
+
+def perform_semantic_analysis(text, nlp, lang):
+ doc = nlp(text)
+
+ # Identificar entidades y conceptos clave
+ entities, key_concepts = identify_and_contextualize_entities(doc, lang)
+
+ # Crear y visualizar grafo de conceptos
+ concepts = [concept for concept, _ in key_concepts]
+ concept_graph = create_concept_graph(text, concepts)
+ relations_graph = visualize_concept_graph(concept_graph, lang)
+
+ return {
+ 'entities': entities,
+ 'key_concepts': key_concepts,
+ 'relations_graph': relations_graph
+ }
+
+__all__ = ['perform_semantic_analysis', 'ENTITY_LABELS', 'POS_TRANSLATIONS']
\ No newline at end of file
diff --git a/src/modules/text_analysis/semantic_analysis_v23-9-2024.py b/src/modules/text_analysis/semantic_analysis_v23-9-2024.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e1c435e13ca0c6b33bcb707ad5079c48707c581
--- /dev/null
+++ b/src/modules/text_analysis/semantic_analysis_v23-9-2024.py
@@ -0,0 +1,247 @@
+#semantic_analysis.py
+import streamlit as st
+import spacy
+import networkx as nx
+import matplotlib.pyplot as plt
+import io
+import base64
+from collections import Counter, defaultdict
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# Define colors for grammatical categories
+POS_COLORS = {
+ 'ADJ': '#FFA07A', 'ADP': '#98FB98', 'ADV': '#87CEFA', 'AUX': '#DDA0DD',
+ 'CCONJ': '#F0E68C', 'DET': '#FFB6C1', 'INTJ': '#FF6347', 'NOUN': '#90EE90',
+ 'NUM': '#FAFAD2', 'PART': '#D3D3D3', 'PRON': '#FFA500', 'PROPN': '#20B2AA',
+ 'SCONJ': '#DEB887', 'SYM': '#7B68EE', 'VERB': '#FF69B4', 'X': '#A9A9A9',
+}
+
+POS_TRANSLATIONS = {
+ 'es': {
+ 'ADJ': 'Adjetivo', 'ADP': 'Preposición', 'ADV': 'Adverbio', 'AUX': 'Auxiliar',
+ 'CCONJ': 'Conjunción Coordinante', 'DET': 'Determinante', 'INTJ': 'Interjección',
+ 'NOUN': 'Sustantivo', 'NUM': 'Número', 'PART': 'Partícula', 'PRON': 'Pronombre',
+ 'PROPN': 'Nombre Propio', 'SCONJ': 'Conjunción Subordinante', 'SYM': 'Símbolo',
+ 'VERB': 'Verbo', 'X': 'Otro',
+ },
+ 'en': {
+ 'ADJ': 'Adjective', 'ADP': 'Preposition', 'ADV': 'Adverb', 'AUX': 'Auxiliary',
+ 'CCONJ': 'Coordinating Conjunction', 'DET': 'Determiner', 'INTJ': 'Interjection',
+ 'NOUN': 'Noun', 'NUM': 'Number', 'PART': 'Particle', 'PRON': 'Pronoun',
+ 'PROPN': 'Proper Noun', 'SCONJ': 'Subordinating Conjunction', 'SYM': 'Symbol',
+ 'VERB': 'Verb', 'X': 'Other',
+ },
+ 'fr': {
+ 'ADJ': 'Adjectif', 'ADP': 'Préposition', 'ADV': 'Adverbe', 'AUX': 'Auxiliaire',
+ 'CCONJ': 'Conjonction de Coordination', 'DET': 'Déterminant', 'INTJ': 'Interjection',
+ 'NOUN': 'Nom', 'NUM': 'Nombre', 'PART': 'Particule', 'PRON': 'Pronom',
+ 'PROPN': 'Nom Propre', 'SCONJ': 'Conjonction de Subordination', 'SYM': 'Symbole',
+ 'VERB': 'Verbe', 'X': 'Autre',
+ }
+}
+
+ENTITY_LABELS = {
+ 'es': {
+ "Personas": "lightblue",
+ "Lugares": "lightcoral",
+ "Inventos": "lightgreen",
+ "Fechas": "lightyellow",
+ "Conceptos": "lightpink"
+ },
+ 'en': {
+ "People": "lightblue",
+ "Places": "lightcoral",
+ "Inventions": "lightgreen",
+ "Dates": "lightyellow",
+ "Concepts": "lightpink"
+ },
+ 'fr': {
+ "Personnes": "lightblue",
+ "Lieux": "lightcoral",
+ "Inventions": "lightgreen",
+ "Dates": "lightyellow",
+ "Concepts": "lightpink"
+ }
+}
+
+##############################################################################################################
+def perform_semantic_analysis(text, nlp, lang_code):
+ logger.info(f"Starting semantic analysis for language: {lang_code}")
+ try:
+ doc = nlp(text)
+
+ # Conceptos clave y grafo de conceptos
+ key_concepts = identify_key_concepts(doc)
+ concept_graph = create_concept_graph(doc, key_concepts)
+ concept_graph_fig = visualize_concept_graph(concept_graph, lang_code)
+ #concept_graph_html = fig_to_html(concept_graph_fig)
+
+ # Entidades y grafo de entidades
+ entities = extract_entities(doc, lang_code)
+ entity_graph = create_entity_graph(entities)
+ entity_graph_fig = visualize_entity_graph(entity_graph, lang_code)
+ #entity_graph_html = fig_to_html(entity_graph_fig)
+
+ logger.info("Semantic analysis completed successfully")
+ return {
+ 'doc': doc,
+ 'key_concepts': key_concepts,
+ 'concept_graph': concept_graph_fig,
+ 'entities': entities,
+ 'entity_graph': entity_graph_fig
+ }
+ except Exception as e:
+ logger.error(f"Error in perform_semantic_analysis: {str(e)}")
+ raise
+
+'''
+def fig_to_html(fig):
+ buf = io.BytesIO()
+ fig.savefig(buf, format='png')
+ buf.seek(0)
+ img_str = base64.b64encode(buf.getvalue()).decode()
+ return f''
+'''
+
+
+def identify_key_concepts(doc):
+ logger.info("Identifying key concepts")
+ word_freq = Counter([token.lemma_.lower() for token in doc if token.pos_ in ['NOUN', 'VERB'] and not token.is_stop])
+ key_concepts = word_freq.most_common(10)
+ return [(concept, float(freq)) for concept, freq in key_concepts]
+
+
+def create_concept_graph(doc, key_concepts):
+ G = nx.Graph()
+ for concept, freq in key_concepts:
+ G.add_node(concept, weight=freq)
+ for sent in doc.sents:
+ sent_concepts = [token.lemma_.lower() for token in sent if token.lemma_.lower() in dict(key_concepts)]
+ for i, concept1 in enumerate(sent_concepts):
+ for concept2 in sent_concepts[i+1:]:
+ if G.has_edge(concept1, concept2):
+ G[concept1][concept2]['weight'] += 1
+ else:
+ G.add_edge(concept1, concept2, weight=1)
+ return G
+
+def visualize_concept_graph(G, lang_code):
+ fig, ax = plt.subplots(figsize=(12, 8))
+ pos = nx.spring_layout(G, k=0.5, iterations=50)
+ node_sizes = [G.nodes[node]['weight'] * 100 for node in G.nodes()]
+ nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color='lightblue', alpha=0.8, ax=ax)
+ nx.draw_networkx_labels(G, pos, font_size=10, font_weight="bold", ax=ax)
+ edge_weights = [G[u][v]['weight'] for u, v in G.edges()]
+ nx.draw_networkx_edges(G, pos, width=edge_weights, alpha=0.5, ax=ax)
+ title = {
+ 'es': "Relaciones entre Conceptos Clave",
+ 'en': "Key Concept Relations",
+ 'fr': "Relations entre Concepts Clés"
+ }
+ ax.set_title(title[lang_code], fontsize=16)
+ ax.axis('off')
+ plt.tight_layout()
+ return fig
+
+def create_entity_graph(entities):
+ G = nx.Graph()
+ for entity_type, entity_list in entities.items():
+ for entity in entity_list:
+ G.add_node(entity, type=entity_type)
+ for i, entity1 in enumerate(entity_list):
+ for entity2 in entity_list[i+1:]:
+ G.add_edge(entity1, entity2)
+ return G
+
+def visualize_entity_graph(G, lang_code):
+ fig, ax = plt.subplots(figsize=(12, 8))
+ pos = nx.spring_layout(G)
+ for entity_type, color in ENTITY_LABELS[lang_code].items():
+ node_list = [node for node, data in G.nodes(data=True) if data['type'] == entity_type]
+ nx.draw_networkx_nodes(G, pos, nodelist=node_list, node_color=color, node_size=500, alpha=0.8, ax=ax)
+ nx.draw_networkx_edges(G, pos, width=1, alpha=0.5, ax=ax)
+ nx.draw_networkx_labels(G, pos, font_size=8, font_weight="bold", ax=ax)
+ ax.set_title(f"Relaciones entre Entidades ({lang_code})", fontsize=16)
+ ax.axis('off')
+ plt.tight_layout()
+ return fig
+
+
+#################################################################################
+def create_topic_graph(topics, doc):
+ G = nx.Graph()
+ for topic in topics:
+ G.add_node(topic, weight=doc.text.count(topic))
+ for i, topic1 in enumerate(topics):
+ for topic2 in topics[i+1:]:
+ weight = sum(1 for sent in doc.sents if topic1 in sent.text and topic2 in sent.text)
+ if weight > 0:
+ G.add_edge(topic1, topic2, weight=weight)
+ return G
+
+def visualize_topic_graph(G, lang_code):
+ fig, ax = plt.subplots(figsize=(12, 8))
+ pos = nx.spring_layout(G)
+ node_sizes = [G.nodes[node]['weight'] * 100 for node in G.nodes()]
+ nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color='lightgreen', alpha=0.8, ax=ax)
+ nx.draw_networkx_labels(G, pos, font_size=10, font_weight="bold", ax=ax)
+ edge_weights = [G[u][v]['weight'] for u, v in G.edges()]
+ nx.draw_networkx_edges(G, pos, width=edge_weights, alpha=0.5, ax=ax)
+ ax.set_title(f"Relaciones entre Temas ({lang_code})", fontsize=16)
+ ax.axis('off')
+ plt.tight_layout()
+ return fig
+
+###########################################################################################
+def generate_summary(doc, lang_code):
+ sentences = list(doc.sents)
+ summary = sentences[:3] # Toma las primeras 3 oraciones como resumen
+ return " ".join([sent.text for sent in summary])
+
+def extract_entities(doc, lang_code):
+ entities = defaultdict(list)
+ for ent in doc.ents:
+ if ent.label_ in ENTITY_LABELS[lang_code]:
+ entities[ent.label_].append(ent.text)
+ return dict(entities)
+
+def analyze_sentiment(doc, lang_code):
+ positive_words = sum(1 for token in doc if token.sentiment > 0)
+ negative_words = sum(1 for token in doc if token.sentiment < 0)
+ total_words = len(doc)
+ if positive_words > negative_words:
+ return "Positivo"
+ elif negative_words > positive_words:
+ return "Negativo"
+ else:
+ return "Neutral"
+
+def extract_topics(doc, lang_code):
+ vectorizer = TfidfVectorizer(stop_words='english', max_features=5)
+ tfidf_matrix = vectorizer.fit_transform([doc.text])
+ feature_names = vectorizer.get_feature_names_out()
+ return list(feature_names)
+
+# Asegúrate de que todas las funciones necesarias estén exportadas
+__all__ = [
+ 'perform_semantic_analysis',
+ 'identify_key_concepts',
+ 'create_concept_graph',
+ 'visualize_concept_graph',
+ 'create_entity_graph',
+ 'visualize_entity_graph',
+ 'generate_summary',
+ 'extract_entities',
+ 'analyze_sentiment',
+ 'create_topic_graph',
+ 'visualize_topic_graph',
+ 'extract_topics',
+ 'ENTITY_LABELS',
+ 'POS_COLORS',
+ 'POS_TRANSLATIONS'
+]
\ No newline at end of file
diff --git a/src/modules/text_analysis/stopwords.py b/src/modules/text_analysis/stopwords.py
new file mode 100644
index 0000000000000000000000000000000000000000..844d14f3a10108599907f31e65e63d0189e744d0
--- /dev/null
+++ b/src/modules/text_analysis/stopwords.py
@@ -0,0 +1,188 @@
+# modules/text_analysis/stopwords.py
+import spacy
+from typing import Set, List
+
+def get_custom_stopwords(lang_code: str) -> Set[str]:
+ """
+ Retorna un conjunto de stopwords personalizadas según el idioma.
+ """
+ # Stopwords base en español
+ # Símbolos, números y caracteres especiales
+
+ SYMBOLS_AND_NUMBERS = {
+ # Números
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+
+ # Signos de puntuación básicos
+ '.', ',', ';', ':', '!', '¡', '?', '¿', '"', "'",
+
+ # Símbolos matemáticos
+ '+', '-', '*', '/', '=', '<', '>', '%',
+
+ # Paréntesis y otros delimitadores
+ '(', ')', '[', ']', '{', '}',
+
+ # Otros símbolos comunes
+ '@', '#', '$', '€', '£', '¥', '&', '_', '|', '\\', '/',
+
+ # Caracteres especiales
+ '•', '·', '…', '—', '–', '°', '´', '`', '^', '¨',
+
+ # Símbolos de ordenamiento
+ '§', '†', '‡', '¶',
+
+ # Símbolos de copyright y marcas registradas
+ '©', '®', '™',
+
+ # Fracciones comunes
+ '½', '¼', '¾', '⅓', '⅔',
+
+ # Otros caracteres especiales
+ '±', '×', '÷', '∞', '≠', '≤', '≥', '≈', '∑', '∏', '√',
+
+ # Espacios y caracteres de control
+ ' ', '\t', '\n', '\r', '\f', '\v'
+}
+ spanish_stopwords = {
+ 'el', 'la', 'los', 'las', 'un', 'una', 'unos', 'unas', 'y', 'o', 'pero', 'si',
+ 'de', 'del', 'al', 'a', 'ante', 'bajo', 'cabe', 'con', 'contra', 'de', 'desde',
+ 'en', 'entre', 'hacia', 'hasta', 'para', 'por', 'según', 'sin', 'sobre', 'tras',
+ 'que', 'más', 'este', 'esta', 'estos', 'estas', 'ese', 'esa', 'esos', 'esas',
+ 'muy', 'mucho', 'muchos', 'muchas', 'ser', 'estar', 'tener', 'hacer', 'como',
+ 'cuando', 'donde', 'quien', 'cual', 'mientras', 'sino', 'pues', 'porque',
+ 'cada', 'cual', 'cuales', 'cuanta', 'cuantas', 'cuanto', 'cuantos', 'uno', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete', 'ocho', 'nueve', 'diez',
+ 'once', 'doce', 'trece', 'catorce', 'quince', 'dieciséis', 'diecisiete', 'dieciocho', 'diecinueve', 'veinte',
+ 'treinta', 'cuarenta', 'cincuenta', 'sesenta', 'setenta', 'ochenta', 'noventa', 'cien', 'mil', 'millón',
+ 'primero', 'segundo', 'tercero', 'cuarto', 'quinto', 'sexto', 'séptimo', 'octavo', 'noveno', 'décimo'
+ }
+
+ # Stopwords base en inglés
+ english_stopwords = {
+ 'the', 'be', 'to', 'of', 'and', 'a', 'in', 'that', 'have', 'i', 'it', 'for',
+ 'not', 'on', 'with', 'he', 'as', 'you', 'do', 'at', 'this', 'but', 'his',
+ 'by', 'from', 'they', 'we', 'say', 'her', 'she', 'or', 'an', 'will', 'my',
+ 'one', 'all', 'would', 'there', 'their', 'what', 'so', 'up', 'out', 'if',
+ 'about', 'who', 'get', 'which', 'go', 'me', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten',
+ 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen', 'twenty',
+ 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety', 'hundred', 'thousand', 'million',
+ 'first', 'second', 'third', 'fourth', 'fifth', 'sixth', 'seventh', 'eighth', 'ninth', 'tenth'
+ }
+
+ french_stopwords = {
+ 'le', 'la', 'les', 'un', 'une', 'des', 'du', 'de', 'et', 'ou', 'mais', 'si',
+ 'à', 'dans', 'sur', 'pour', 'en', 'vers', 'par', 'avec', 'sans', 'sous', 'sur',
+ 'que', 'qui', 'quoi', 'dont', 'où', 'quand', 'comment', 'pourquoi',
+ 'ce', 'cet', 'cette', 'ces', 'mon', 'ton', 'son', 'ma', 'ta', 'sa',
+ 'mes', 'tes', 'ses', 'notre', 'votre', 'leur', 'nos', 'vos', 'leurs',
+ 'je', 'tu', 'il', 'elle', 'nous', 'vous', 'ils', 'elles',
+ 'me', 'te', 'se', 'lui', 'leur', 'y', 'en', 'plus', 'moins',
+ 'très', 'trop', 'peu', 'beaucoup', 'assez', 'tout', 'toute', 'tous', 'toutes',
+ 'autre', 'autres', 'même', 'mêmes', 'tel', 'telle', 'tels', 'telles',
+ 'quel', 'quelle', 'quels', 'quelles', 'quelque', 'quelques',
+ 'aucun', 'aucune', 'aucuns', 'aucunes', 'plusieurs', 'chaque',
+ 'être', 'avoir', 'faire', 'dire', 'aller', 'venir', 'voir', 'savoir',
+ 'pouvoir', 'vouloir', 'falloir', 'devoir', 'croire', 'sembler',
+ 'alors', 'ainsi', 'car', 'donc', 'or', 'ni', 'ne', 'pas', 'plus',
+ 'jamais', 'toujours', 'parfois', 'souvent', 'maintenant', 'après',
+ 'avant', 'pendant', 'depuis', 'déjà', 'encore', 'ici', 'là',
+ 'oui', 'non', 'peut-être', 'bien', 'mal', 'aussi', 'surtout',
+ 'c\'est', 'j\'ai', 'n\'est', 'd\'un', 'd\'une', 'qu\'il', 'qu\'elle',
+ 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept', 'huit', 'neuf', 'dix',
+ 'onze', 'douze', 'treize', 'quatorze', 'quinze', 'seize', 'dix-sept', 'dix-huit', 'dix-neuf', 'vingt',
+ 'trente', 'quarante', 'cinquante', 'soixante', 'soixante-dix', 'quatre-vingts', 'quatre-vingt-dix', 'cent', 'mille', 'million',
+ 'premier', 'deuxième', 'troisième', 'quatrième', 'cinquième', 'sixième', 'septième', 'huitième', 'neuvième', 'dixième'
+}
+
+ stopwords_dict = {
+ 'es': spanish_stopwords,
+ 'en': english_stopwords,
+ 'fr': french_stopwords
+ }
+
+ # Obtener stopwords del idioma especificado o devolver conjunto vacío si no existe
+ return stopwords_dict.get(lang_code, set())
+
+def process_text(text: str, lang_code: str, nlp) -> List[str]:
+ """
+ Procesa un texto completo, removiendo stopwords, símbolos y números.
+
+ Args:
+ text (str): Texto a procesar
+ lang_code (str): Código del idioma ('es', 'en', 'fr')
+ nlp: Modelo de spaCy cargado
+
+ Returns:
+ List[str]: Lista de tokens procesados
+ """
+ try:
+ # Obtener stopwords personalizadas
+ custom_stopwords = get_custom_stopwords(lang_code)
+
+ # Procesar el texto con spaCy
+ doc = nlp(text)
+
+ # Filtrar y procesar tokens
+ processed_tokens = []
+ for token in doc:
+ # Convertir a minúsculas y obtener el lema
+ lemma = token.lemma_.lower()
+
+ # Aplicar filtros
+ if (len(lemma) >= 2 and # Longitud mínima
+ lemma not in custom_stopwords and # No es stopword
+ not token.is_punct and # No es puntuación
+ not token.is_space and # No es espacio
+ lemma not in SYMBOLS_AND_NUMBERS and # No es símbolo o número
+ not any(char in string.punctuation for char in lemma) and # No contiene puntuación
+ not any(char.isdigit() for char in lemma)): # No contiene números
+
+ processed_tokens.append(lemma)
+
+ return processed_tokens
+
+ except Exception as e:
+ logger.error(f"Error en process_text: {str(e)}")
+ return []
+
+def clean_text(text: str) -> str:
+ """
+ Limpia un texto removiendo caracteres especiales y normalizando espacios.
+
+ Args:
+ text (str): Texto a limpiar
+
+ Returns:
+ str: Texto limpio
+ """
+ # Remover caracteres especiales y números
+ cleaned = ''.join(char for char in text if char not in SYMBOLS_AND_NUMBERS)
+
+ # Normalizar espacios
+ cleaned = ' '.join(cleaned.split())
+
+ return cleaned.strip()
+
+def get_stopwords_for_spacy(lang_code: str, nlp) -> Set[str]:
+ """
+ Combina stopwords personalizadas con las de spaCy.
+
+ Args:
+ lang_code (str): Código del idioma
+ nlp: Modelo de spaCy
+
+ Returns:
+ Set[str]: Conjunto combinado de stopwords
+ """
+ custom_stops = get_custom_stopwords(lang_code)
+ spacy_stops = nlp.Defaults.stop_words if hasattr(nlp.Defaults, 'stop_words') else set()
+
+ return custom_stops.union(spacy_stops)
+
+# Asegúrate de exportar todas las funciones necesarias
+__all__ = [
+ 'get_custom_stopwords',
+ 'process_text',
+ 'clean_text',
+ 'get_stopwords_for_spacy',
+ 'SYMBOLS_AND_NUMBERS'
+]
\ No newline at end of file
diff --git a/src/modules/text_analysis/structure_analysis.py b/src/modules/text_analysis/structure_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/text_analysis/style_analysis.py b/src/modules/text_analysis/style_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/text_analysis/thematic_analysis.py b/src/modules/text_analysis/thematic_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/text_analysis/txt.txt b/src/modules/text_analysis/txt.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/text_analysis/vocabulary_analysis.py b/src/modules/text_analysis/vocabulary_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/ui/__init__.py b/src/modules/ui/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/ui/__pycache__/__init__.cpython-311.pyc b/src/modules/ui/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ac9684e4704cf8e942f2a15e5fea186fe3be7a0
Binary files /dev/null and b/src/modules/ui/__pycache__/__init__.cpython-311.pyc differ
diff --git a/src/modules/ui/__pycache__/ui.cpython-311.pyc b/src/modules/ui/__pycache__/ui.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dcda6c057d448090e4adece4b140c7714344d570
Binary files /dev/null and b/src/modules/ui/__pycache__/ui.cpython-311.pyc differ
diff --git a/src/modules/ui/txt.txt b/src/modules/ui/txt.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/modules/ui/ui backUpError_24-9-24.py b/src/modules/ui/ui backUpError_24-9-24.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5ce2b4a89d3c1f9bba42093a838ff9b97f7cc17
--- /dev/null
+++ b/src/modules/ui/ui backUpError_24-9-24.py
@@ -0,0 +1,473 @@
+# Importaciones generales
+import streamlit as st
+from streamlit_player import st_player # Necesitarás instalar esta librería: pip install streamlit-player
+from streamlit_float import *
+from streamlit_antd_components import *
+from streamlit_option_menu import *
+from streamlit_chat import *
+import logging
+import time
+from datetime import datetime
+import re
+import io
+from io import BytesIO
+import base64
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+import pandas as pd
+import numpy as np
+from spacy import displacy
+import random
+
+# Configuración del logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Importaciones locales
+from translations import get_translations
+
+# Importaciones locales
+from ..studentact.student_activities_v2 import display_student_progress
+
+# Importaciones directas de los módulos necesarios
+from ..auth.auth import authenticate_user, register_user
+
+
+from ..database.database_oldFromV2 import (
+ get_student_data,
+ store_application_request,
+ store_morphosyntax_result,
+ store_semantic_result,
+ store_discourse_analysis_result,
+ store_chat_history,
+ create_admin_user,
+ create_student_user,
+ store_user_feedback
+)
+
+from ..admin.admin_ui import admin_page
+
+from ..morphosyntax.morphosyntax_interface import display_morphosyntax_interface
+
+from ..semantic.semantic_interface_68ok import display_semantic_interface
+
+from ..discourse.discourse_interface import display_discourse_interface
+
+# Nueva importación para semantic_float_init
+#from ..semantic.semantic_float import semantic_float_init
+from ..semantic.semantic_float68ok import semantic_float_init
+
+
+############### Iniciar sesión ######################
+
+
+def initialize_session_state():
+ if 'initialized' not in st.session_state:
+ st.session_state.clear()
+ st.session_state.initialized = True
+ st.session_state.logged_in = False
+ st.session_state.page = 'login'
+ st.session_state.username = None
+ st.session_state.role = None
+ st.session_state.lang_code = 'es' # Idioma por defecto
+
+def main():
+ logger.info(f"Entrando en main() - Página actual: {st.session_state.page}")
+
+ if 'nlp_models' not in st.session_state:
+ st.error("Los modelos NLP no están inicializados. Por favor, reinicie la aplicación.")
+ return
+
+ semantic_float_init()
+
+ if st.session_state.page == 'login':
+ login_register_page()
+ elif st.session_state.page == 'admin':
+ logger.info("Mostrando página de admin")
+ admin_page()
+ elif st.session_state.page == 'user':
+ user_page()
+ else:
+ logger.warning(f"Página no reconocida: {st.session_state.page}")
+ st.error(f"Página no reconocida: {st.session_state.page}")
+
+ logger.info(f"Saliendo de main() - Estado final de la sesión: {st.session_state}")
+
+############### Después de iniciar sesión ######################
+
+def user_page():
+ logger.info(f"Entrando en user_page para el usuario: {st.session_state.username}")
+
+ if 'user_data' not in st.session_state or time.time() - st.session_state.get('last_data_fetch', 0) > 60:
+ with st.spinner("Cargando tus datos..."):
+ try:
+ st.session_state.user_data = get_student_data(st.session_state.username)
+ st.session_state.last_data_fetch = time.time()
+ except Exception as e:
+ logger.error(f"Error al obtener datos del usuario: {str(e)}")
+ st.error("Hubo un problema al cargar tus datos. Por favor, intenta recargar la página.")
+ return
+
+ logger.info(f"Idioma actual: {st.session_state.lang_code}")
+ logger.info(f"Modelos NLP cargados: {'nlp_models' in st.session_state}")
+
+ languages = {'Español': 'es', 'English': 'en', 'Français': 'fr'}
+
+ if 'lang_code' not in st.session_state:
+ st.session_state.lang_code = 'es' # Idioma por defecto
+ elif not isinstance(st.session_state.lang_code, str) or st.session_state.lang_code not in ['es', 'en', 'fr']:
+ logger.warning(f"Invalid lang_code: {st.session_state.lang_code}. Setting to default 'es'")
+ st.session_state.lang_code = 'es'
+
+ # Obtener traducciones
+ t = get_translations(st.session_state.lang_code)
+
+ # Estilos CSS personalizados (mantener los estilos existentes)
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Crear un contenedor para la barra superior
+ with st.container():
+ col1, col2, col3 = st.columns([2, 2, 1])
+ with col1:
+ st.markdown(f"{t['welcome']}, {st.session_state.username}
", unsafe_allow_html=True) + with col2: + selected_lang = st.selectbox( + t['select_language'], + list(languages.keys()), + index=list(languages.values()).index(st.session_state.lang_code), + key=f"language_selector_{st.session_state.username}_{st.session_state.lang_code}" + ) + new_lang_code = languages[selected_lang] + if st.session_state.lang_code != new_lang_code: + st.session_state.lang_code = new_lang_code + st.rerun() # Esto recargará la página con el nuevo idioma + with col3: + if st.button(t['logout'], key=f"logout_button_{st.session_state.username}_{st.session_state.lang_code}"): + # Implementación temporal de logout + for key in list(st.session_state.keys()): + del st.session_state[key] + st.rerun() + + st.markdown("---") + + # Mostrar resumen de análisis + #st.subheader(t['analysis_summary']) + #col1, col2, col3 = st.columns(3) + #col1.metric(t['morpho_analyses'], len(st.session_state.user_data['morphosyntax_analyses'])) + #col2.metric(t['semantic_analyses'], len(st.session_state.user_data['semantic_analyses'])) + #col3.metric(t['discourse_analyses'], len(st.session_state.user_data['discourse_analyses'])) + + + # Opción para exportar datos + #if st.button(t['export_all_analyses']): + # st.info(t['export_in_progress']) + # Aquí iría la llamada a export_data cuando esté implementada + # export_data(st.session_state.user_data, t) + + # Crear las pestañas + tabs = st.tabs([ + t['morpho_tab'], + t['semantic_tab'], + t['discourse_tab'], + t['activities_tab'], + t['feedback_tab'] + ]) + + # Usar las pestañas creadas + for i, (tab, func) in enumerate(zip(tabs, [ + display_morphosyntax_interface, + display_semantic_interface, + display_discourse_interface, + display_student_progress, + display_feedback_form + ])): + with tab: + try: + if i < 5: # Para las primeras tres pestañas (análisis) + func(st.session_state.lang_code, st.session_state.nlp_models, t, st.session_state.user_data) + elif i == 3: # Para la pestaña de progreso del estudiante + func(st.session_state.username, st.session_state.lang_code, t, st.session_state.user_data) + else: # Para la pestaña de feedback + func(st.session_state.lang_code, t) + except Exception as e: + st.error(f"Error al cargar la pestaña: {str(e)}") + logger.error(f"Error en la pestaña {i}: {str(e)}", exc_info=True) + + logger.debug(f"Translations loaded: {t}") # Log para depuración + logger.info("Finalizada la renderización de user_page") + + + +##################################### + +def login_register_page(): + logger.info("Renderizando página de login/registro") + st.title("AIdeaText") + st.write("Bienvenido. Por favor, inicie sesión o regístrese.") + + left_column, right_column = st.columns([1, 3]) + + with left_column: + tab1, tab2 = st.tabs(["Iniciar Sesión", "Registrarse"]) + + with tab1: + login_form() + + with tab2: + register_form() + + with right_column: + display_videos_and_info() + + +################################################### +def login_form(): + with st.form("login_form"): + username = st.text_input("Correo electrónico") + password = st.text_input("Contraseña", type="password") + submit_button = st.form_submit_button("Iniciar Sesión") + + if submit_button: + success, role = authenticate_user(username, password) + if success: + st.session_state.logged_in = True + st.session_state.username = username + st.session_state.role = role + st.session_state.page = 'admin' if role == 'Administrador' else 'user' + st.rerun() + else: + st.error("Credenciales incorrectas") + + +################################################### +def register_form(): + st.header("Solicitar prueba de la aplicación") + + name = st.text_input("Nombre completo") + email = st.text_input("Correo electrónico institucional") + institution = st.text_input("Institución") + role = st.selectbox("Rol", ["Estudiante", "Profesor", "Investigador", "Otro"]) + reason = st.text_area("¿Por qué estás interesado en probar AIdeaText?") + + if st.button("Enviar solicitud"): + if not name or not email or not institution or not reason: + st.error("Por favor, completa todos los campos.") + elif not is_institutional_email(email): + st.error("Por favor, utiliza un correo electrónico institucional.") + else: + success = store_application_request(name, email, institution, role, reason) + if success: + st.success("Tu solicitud ha sido enviada. Te contactaremos pronto.") + else: + st.error("Hubo un problema al enviar tu solicitud. Por favor, intenta de nuevo más tarde.") + + + +################################################### +def is_institutional_email(email): + forbidden_domains = ['gmail.com', 'hotmail.com', 'yahoo.com', 'outlook.com'] + return not any(domain in email.lower() for domain in forbidden_domains) + + +################################################### +def display_videos_and_info(): + st.header("Videos: pitch, demos, entrevistas, otros") + + videos = { + "Presentación en PyCon Colombia, Medellín, 2024": "https://www.youtube.com/watch?v=Jn545-IKx5Q", + "Presentación fundación Ser Maaestro": "https://www.youtube.com/watch?v=imc4TI1q164", + "Pitch IFE Explora": "https://www.youtube.com/watch?v=Fqi4Di_Rj_s", + "Entrevista Dr. Guillermo Ruíz": "https://www.youtube.com/watch?v=_ch8cRja3oc", + "Demo versión desktop": "https://www.youtube.com/watch?v=nP6eXbog-ZY" + } + + selected_title = st.selectbox("Selecciona un video tutorial:", list(videos.keys())) + + if selected_title in videos: + try: + st_player(videos[selected_title]) + except Exception as e: + st.error(f"Error al cargar el video: {str(e)}") + + st.markdown(""" + ## Novedades de la versión actual + - Nueva función de análisis semántico + - Soporte para múltiples idiomas + - Interfaz mejorada para una mejor experiencia de usuario + """) + +def display_feedback_form(lang_code, t): + logging.info(f"display_feedback_form called with lang_code: {lang_code}") + + st.header(t['title']) + + name = st.text_input(t['name'], key=f"feedback_name_{lang_code}") + email = st.text_input(t['email'], key=f"feedback_email_{lang_code}") + feedback = st.text_area(t['feedback'], key=f"feedback_text_{lang_code}") + + if st.button(t['submit'], key=f"feedback_submit_{lang_code}"): + if name and email and feedback: + if store_user_feedback(st.session_state.username, name, email, feedback): + st.success(t['success']) + else: + st.error(t['error']) + else: + st.warning("Por favor, completa todos los campos.") + +''' +def display_student_progress(username, lang_code, t): + student_data = get_student_data(username) + + if student_data is None or len(student_data['entries']) == 0: + st.warning("No se encontraron datos para este estudiante.") + st.info("Intenta realizar algunos análisis de texto primero.") + return + + st.title(f"Progreso de {username}") + + with st.expander("Resumen de Actividades y Progreso", expanded=True): + # Resumen de actividades + total_entries = len(student_data['entries']) + st.write(f"Total de análisis realizados: {total_entries}") + + # Gráfico de tipos de análisis + analysis_types = [entry['analysis_type'] for entry in student_data['entries']] + analysis_counts = pd.Series(analysis_types).value_counts() + + fig, ax = plt.subplots() + analysis_counts.plot(kind='bar', ax=ax) + ax.set_title("Tipos de análisis realizados") + ax.set_xlabel("Tipo de análisis") + ax.set_ylabel("Cantidad") + st.pyplot(fig) + + # Progreso a lo largo del tiempo + dates = [datetime.fromisoformat(entry['timestamp']) for entry in student_data['entries']] + analysis_counts = pd.Series(dates).value_counts().sort_index() + + fig, ax = plt.subplots() + analysis_counts.plot(kind='line', ax=ax) + ax.set_title("Análisis realizados a lo largo del tiempo") + ax.set_xlabel("Fecha") + ax.set_ylabel("Cantidad de análisis") + st.pyplot(fig) + +########################################################## + with st.expander("Histórico de Análisis Morfosintácticos"): + morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax'] + for entry in morphosyntax_entries: + st.subheader(f"Análisis del {entry['timestamp']}") + if entry['arc_diagrams']: + st.write(entry['arc_diagrams'][0], unsafe_allow_html=True) + + + ########################################################## + with st.expander("Histórico de Análisis Semánticos"): + semantic_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic'] + for entry in semantic_entries: + st.subheader(f"Análisis del {entry['timestamp']}") + + # Mostrar conceptos clave + if 'key_concepts' in entry: + st.write("Conceptos clave:") + concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts']]) + #st.write("Conceptos clave:") + #st.write(concepts_str) + st.markdown(f"{concepts_str}
", unsafe_allow_html=True)
+
+ # Mostrar gráfico
+ if 'graph' in entry:
+ try:
+ img_bytes = base64.b64decode(entry['graph'])
+ st.image(img_bytes, caption="Gráfico de relaciones conceptuales")
+ except Exception as e:
+ st.error(f"No se pudo mostrar el gráfico: {str(e)}")
+
+##########################################################
+ with st.expander("Histórico de Análisis Discursivos"):
+ discourse_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
+ for entry in discourse_entries:
+ st.subheader(f"Análisis del {entry['timestamp']}")
+
+ # Mostrar conceptos clave para ambos documentos
+ if 'key_concepts1' in entry:
+ concepts_str1 = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts1']])
+ st.write("Conceptos clave del documento 1:")
+ #st.write(concepts_str1)
+ st.markdown(f"{concepts_str1}
", unsafe_allow_html=True)
+
+ if 'key_concepts2' in entry:
+ concepts_str2 = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts2']])
+ st.write("Conceptos clave del documento 2:")
+ #st.write(concepts_str2)
+ st.markdown(f"{concepts_str2}
", unsafe_allow_html=True)
+
+ try:
+ if 'combined_graph' in entry and entry['combined_graph']:
+ img_bytes = base64.b64decode(entry['combined_graph'])
+ st.image(img_bytes)
+ elif 'graph1' in entry and 'graph2' in entry:
+ col1, col2 = st.columns(2)
+ with col1:
+ if entry['graph1']:
+ img_bytes1 = base64.b64decode(entry['graph1'])
+ st.image(img_bytes1)
+ with col2:
+ if entry['graph2']:
+ img_bytes2 = base64.b64decode(entry['graph2'])
+ st.image(img_bytes2)
+ else:
+ st.write("No se encontraron gráficos para este análisis.")
+ except Exception as e:
+ st.error(f"No se pudieron mostrar los gráficos: {str(e)}")
+ st.write("Datos de los gráficos (para depuración):")
+ if 'graph1' in entry:
+ st.write("Graph 1:", entry['graph1'][:100] + "...")
+ if 'graph2' in entry:
+ st.write("Graph 2:", entry['graph2'][:100] + "...")
+ if 'combined_graph' in entry:
+ st.write("Combined Graph:", entry['combined_graph'][:100] + "...")
+
+##########################################################
+ with st.expander("Histórico de Conversaciones con el ChatBot"):
+ if 'chat_history' in student_data:
+ for i, chat in enumerate(student_data['chat_history']):
+ st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
+ for message in chat['messages']:
+ if message['role'] == 'user':
+ st.write("Usuario: " + message['content'])
+ else:
+ st.write("Asistente: " + message['content'])
+ st.write("---")
+ else:
+ st.write("No se encontraron conversaciones con el ChatBot.")
+
+ # Añadir logs para depuración
+ if st.checkbox("Mostrar datos de depuración"):
+ st.write("Datos del estudiante (para depuración):")
+ st.json(student_data)
+
+
+'''
+
+# Definición de __all__ para especificar qué se exporta
+__all__ = ['main', 'login_register_page', 'initialize_session_state']
+
+# Bloque de ejecución condicional
+if __name__ == "__main__":
+ main()
diff --git a/src/modules/ui/ui.py b/src/modules/ui/ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..17c073a935ca865a5a186fbbbfe60830f268007e
--- /dev/null
+++ b/src/modules/ui/ui.py
@@ -0,0 +1,342 @@
+# modules/ui/ui.py
+import streamlit as st
+from streamlit_player import st_player
+import logging
+from datetime import datetime
+from dateutil.parser import parse
+
+# Configura el logger PRIMERO, antes de cualquier uso
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Importaciones locales
+from session_state import initialize_session_state, logout
+from translations import get_translations, get_landing_translations
+from ..auth.auth import authenticate_user, authenticate_student, authenticate_admin
+from ..database.sql_db import store_application_request
+
+# Intento de importación con logger YA DEFINIDO
+try:
+ from .user_page import user_page
+except ImportError as e:
+ logger.error(f"No se pudo importar user_page: {str(e)}. Asegúrate de que el archivo existe.")
+
+ # Función de respaldo
+ def user_page(lang_code, t):
+ st.error("La página de usuario no está disponible. Por favor, contacta al administrador.")
+
+from ..admin.admin_ui import admin_page
+
+#############################################################
+def main():
+ logger.info(f"Entrando en main() - Página actual: {st.session_state.page}")
+
+ if 'nlp_models' not in st.session_state:
+ logger.error("Los modelos NLP no están inicializados.")
+ st.error("Los modelos NLP no están inicializados. Por favor, reinicie la aplicación.")
+ return
+
+ lang_code = st.session_state.get('lang_code', 'es')
+ t = get_translations(lang_code)
+
+ logger.info(f"Página actual antes de la lógica de enrutamiento: {st.session_state.page}")
+
+ if st.session_state.get('logged_out', False):
+ st.session_state.logged_out = False
+ st.session_state.page = 'login'
+ st.rerun()
+
+ if not st.session_state.get('logged_in', False):
+ logger.info("Usuario no ha iniciado sesión. Mostrando página de login/registro")
+ login_register_page(lang_code, t)
+ elif st.session_state.page == 'user':
+ if st.session_state.role == 'Administrador':
+ logger.info("Redirigiendo a la página de administrador")
+ st.session_state.page = 'Admin'
+ st.rerun()
+ else:
+ logger.info("Renderizando página de usuario")
+ user_page(lang_code, t)
+ elif st.session_state.page == "Admin":
+ logger.info("Renderizando página de administrador")
+ admin_page()
+ else:
+ logger.error(f"Página no reconocida: {st.session_state.page}")
+ st.error(t.get('unrecognized_page', 'Página no reconocida'))
+ # Redirigir a la página de usuario en caso de error
+ st.session_state.page = 'user'
+ st.rerun()
+
+ logger.info(f"Saliendo de main() - Estado final de la sesión: {st.session_state}")
+
+#############################################################
+#############################################################
+def login_register_page(lang_code, t):
+ # Obtener traducciones específicas para landing page
+ landing_t = get_landing_translations(lang_code)
+
+ # Language selection dropdown at the top
+ languages = {'Español': 'es', 'English': 'en', 'Français': 'fr', 'Português': 'pt'}
+
+ # Estilo personalizado para mejorar el espaciado y alineación
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ # Crear contenedor para logos y selector de idioma usando columnas de Streamlit
+ col1, col2, col3, col4, col5 = st.columns([0.25, 0.25, 1, 1, 1])
+
+ with col1:
+ # Logo de ALPHA
+ st.image("https://huggingface.co/spaces/AIdeaText/v3/resolve/main/assets/img/ALPHA_Startup%20Badges.png", width=100)
+
+ with col2:
+ # Logo de AIdeaText
+ st.image("https://huggingface.co/spaces/AIdeaText/v3/resolve/main/assets/img/AIdeaText_Logo_vectores.png", width=100)
+
+ with col5:
+ # Selector de idioma
+ selected_lang = st.selectbox(
+ landing_t['select_language'],
+ list(languages.keys()),
+ index=list(languages.values()).index(lang_code),
+ key=f"landing_language_selector_{lang_code}"
+ )
+ new_lang_code = languages[selected_lang]
+ if lang_code != new_lang_code:
+ st.session_state.lang_code = new_lang_code
+ st.rerun()
+
+ # Main content with columns
+ left_column, right_column = st.columns([1, 3])
+
+ with left_column:
+ tab1, tab2 = st.tabs([landing_t['login'], landing_t['register']])
+
+ with tab1:
+ login_form(lang_code, landing_t)
+
+ with tab2:
+ register_form(lang_code, landing_t)
+
+ with right_column:
+ display_videos_and_info(lang_code, landing_t)
+
+#############################################################
+#############################################################
+def login_form(lang_code, landing_t):
+ with st.form("login_form"):
+ username = st.text_input(landing_t['email'])
+ password = st.text_input(landing_t['password'], type="password")
+ submit_button = st.form_submit_button(landing_t['login_button'])
+
+ if submit_button:
+ success, role = authenticate_user(username, password)
+ if success:
+ st.session_state.logged_in = True
+ st.session_state.username = username
+ st.session_state.role = role
+ if role == 'Administrador':
+ st.session_state.page = 'Admin'
+ else:
+ st.session_state.page = 'user'
+ logger.info(f"Usuario autenticado: {username}, Rol: {role}")
+ st.rerun()
+ else:
+ st.error(landing_t['invalid_credentials'])
+
+
+#############################################################
+#############################################################
+def register_form(lang_code, landing_t):
+ name = st.text_input(landing_t['name'])
+ lastname = st.text_input(landing_t['lastname'])
+ institution = st.text_input(landing_t['institution'])
+ current_role = st.selectbox(landing_t['current_role'],
+ [landing_t['professor'], landing_t['student'], landing_t['administrative']])
+
+ # Definimos el rol por defecto como estudiante
+ desired_role = landing_t['student']
+
+ email = st.text_input(landing_t['institutional_email'])
+ reason = st.text_area(landing_t['interest_reason'])
+
+ if st.button(landing_t['submit_application']):
+ logger.info(f"Intentando enviar solicitud para {email}")
+ logger.debug(f"Datos del formulario: name={name}, lastname={lastname}, email={email}, institution={institution}, current_role={current_role}, desired_role={desired_role}, reason={reason}")
+
+ if not name or not lastname or not email or not institution or not reason:
+ logger.warning("Envío de formulario incompleto")
+ st.error(landing_t['complete_all_fields'])
+ elif not is_institutional_email(email):
+ logger.warning(f"Email no institucional utilizado: {email}")
+ st.error(landing_t['use_institutional_email'])
+ else:
+ logger.info(f"Intentando almacenar solicitud para {email}")
+ success = store_application_request(name, lastname, email, institution, current_role, desired_role, reason)
+ if success:
+ st.success(landing_t['application_sent'])
+ logger.info(f"Solicitud almacenada exitosamente para {email}")
+ else:
+ st.error(landing_t['application_error'])
+ logger.error(f"Error al almacenar solicitud para {email}")
+
+
+#############################################################
+#############################################################
+def is_institutional_email(email):
+ forbidden_domains = ['gmail.com', 'hotmail.com', 'yahoo.com', 'outlook.com']
+ return not any(domain in email.lower() for domain in forbidden_domains)
+
+
+#############################################################
+#############################################################
+def display_videos_and_info(lang_code, landing_t):
+ # Crear tabs para cada sección
+ tab_use_case, tab_videos, tab_events, tab_gallery, tab_news = st.tabs([
+ landing_t['use_cases'],
+ landing_t['presentation_videos'],
+ landing_t['academic_presentations'],
+ landing_t['event_photos'],
+ landing_t['version_control']
+ ])
+
+ # Tab de Casos de uso
+ with tab_use_case:
+ use_case_videos = {
+ "English - Radar use chart": "https://youtu.be/fFbbtlIewgs",
+ "English - Use AI Bot and arcs charts fuctions": "https://youtu.be/XjM-1oOl-ao",
+ "English - Arcs use charts, example 1": "https://youtu.be/PdK_bgigVaM",
+ "English - Arcs use charts, excample 2": "https://youtu.be/7uaV1njPOng",
+ "Español - Uso del diagrama radar para verificar redacción": "https://www.youtube.com/watch?v=nJP6xscPLBU",
+ "Español - Uso de los diagramas de arco, ejemplo 1": "https://www.youtube.com/watch?v=ApBIAr2S-bE",
+ "Español - Uso de los diagramas de arco, ejemplo 2": "https://www.youtube.com/watch?v=JnP2U1Fm0rc",
+ "Español - Uso de los diagramas de arco, ejemplo 3": "https://www.youtube.com/watch?v=waWWwPTaI-Y",
+ "Español - Uso del bot para buscar respuestas" : "https://www.youtube.com/watch?v=GFKDS0K2s7E"
+ }
+
+ selected_title = st.selectbox(landing_t['select_use_case'], list(use_case_videos.keys()))
+ if selected_title in use_case_videos:
+ try:
+ st_player(use_case_videos[selected_title])
+ except Exception as e:
+ st.error(f"Error al cargar el video: {str(e)}")
+
+ # Tab de Videos
+ with tab_videos:
+ videos = {
+ "Reel AIdeaText": "https://youtu.be/hXnwUvN1Q9Q",
+ "Presentación en SENDA, UNAM. Ciudad de México, México" : "https://www.youtube.com/watch?v=XFLvjST2cE0",
+ "Presentación en PyCon 2024. Colombia, Medellín": "https://www.youtube.com/watch?v=Jn545-IKx5Q",
+ "Presentación en Fundación Ser Maaestro. Lima, Perú": "https://www.youtube.com/watch?v=imc4TI1q164",
+ "Presentación en Explora del IFE, TEC de Monterrey, Nuevo León, México": "https://www.youtube.com/watch?v=Fqi4Di_Rj_s",
+ "Entrevista con el Dr. Guillermo Ruíz. Lima, Perú": "https://www.youtube.com/watch?v=_ch8cRja3oc",
+ "Demo de la versión de escritorio.": "https://www.youtube.com/watch?v=nP6eXbog-ZY"
+ }
+
+ selected_title = st.selectbox(landing_t['select_presentation'], list(videos.keys()))
+ if selected_title in videos:
+ try:
+ st_player(videos[selected_title])
+ except Exception as e:
+ st.error(f"Error al cargar el video: {str(e)}")
+
+ # Tab de Eventos
+ with tab_events:
+ st.markdown("""
+ ## 2025
+
+ **El Agente Cognitivo Vinculante como Innovación en el Aprendizaje Adaptativo: el caso de AIdeaText**
+ IFE CONFERENCE 2025. Organizado por el Instituto para el Futuro de la Educación del TEC de Monterrey.
+ Nuevo León, México. Del 28 al 30 enero 2025
+
+ ## 2024
+ [1]
+ AIdeaText, AIdeaText, recurso digital que emplea la técnica de Análisis de Resonancia Central para perfeccionar textos académicos**
+ V Temporada SENDA - Organizado por el Seminario de Entornos y Narrativas Digitales en la Academia del
+ Instituto de Investigaciones Antropológicas (IIA) de la Universidad Autonóma de México (UNAM). 22 noviembre 2024
+
+ [2]
+ Aproximación al Agente Cognitivo Vinculante (ACV) desde la Teoría del Actor Red (TAR)**
+ Congreso HeETI 2024: Horizontes Expandidos de la Educación, la Tecnología y la Innovación
+ Universidad el Claustro de Sor Juana. Del 25 al 27 septiembre 2024
+
+ [3]
+ AIdeaText, visualización de mapas semánticos**
+ PyCon 2024, Organizado por el grupo de desarrolladores independientes de Python.
+ Universidad EAFIT, Medellín, Colombia. Del 7 al 9 de junio de 2024.
+
+ ## 2023
+ **Aproximación al Agente Cognitivo Vinculante (ACV) desde la Teoría del Actor Red (TAR)**
+ [1]
+ XVII Congreso Nacional de Investigación Educativa - VII Encuentro de Estudiantes de Posgrado Educación.
+ Consejo Mexicano de Investigación Educativa (COMIE)
+ Villahermosa, Tabasco, México.
+ Del 4 al 8 de diciembre 2023
+
+ [2]
+ XXXI Encuentro Internacional de Educación a Distancia
+ Universidad de Guadalajara. Jalisco, México.
+ Del 27 al 30 noviembre 2023
+
+ [3]
+ IV Temporada SENDA - Seminario de Entornos y Narrativas Digitales en la Academia
+ Instituto de Investigaciones Antropológicas (IIA), UNAM.
+ 22 noviembre 2023
+
+ [4]
+ 1er Congreso Internacional de Educación Digital
+ Instituto Politécnico Nacional, sede Zacatecas. México.
+ Del 23 al 24 de noviembre de 2023
+
+ [5]
+ La cuestión de la centralidad del maestro frente a las tecnologías digitales generativas**
+ Innova Fórum: Ecosistemas de Aprendizaje
+ Universidad de Guadalajara. Jalisco, México.
+ Del 16 al 18 de mayo 2023
+ """)
+
+ # Tab de Galería
+ with tab_gallery:
+ # Contenedor con ancho máximo
+ with st.container():
+ # Dividimos en dos columnas principales
+ col_left, col_right = st.columns(2)
+
+ # Columna izquierda: Foto 1 grande
+ with col_left:
+ # Foto 2 arriba
+ st.image("assets/img/socialmedia/_MG_2845.JPG",
+ caption="MakerFaire CDMX 2024",
+ width=480) # Ajusta este valor según necesites
+ # use_column_width=True)
+
+ # Foto 3 abajo
+ st.image("assets/img/socialmedia/Facebook_CoverPhoto-1_820x312.jpg",
+ caption="MakerFaire CDMX 2024",
+ width=480) # Ajusta este valor según necesites
+ # use_column_width=True)
+
+ # Columna derecha: Fotos 2 y 3 una encima de otra
+ with col_right:
+ st.image("assets/img/socialmedia/_MG_2790.jpg",
+ caption="MakerFaire CDMX 2024",
+ width=540) # Ajusta este valor según necesites
+
+
+ # Tab de Novedades - Usar contenido traducido
+ with tab_news:
+ st.markdown(f"### {landing_t['latest_version_title']}")
+ for update in landing_t['version_updates']:
+ st.markdown(f"- {update}")
+
+# Definición de __all__ para especificar qué se exporta
+__all__ = ['main', 'login_register_page', 'initialize_session_state']
+
+# Bloque de ejecución condicional
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/src/modules/ui/ui_BackUp-19-9-2024.py b/src/modules/ui/ui_BackUp-19-9-2024.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a8e1fb7c1daf723d04cbd2ca1fa301b4dd78091
--- /dev/null
+++ b/src/modules/ui/ui_BackUp-19-9-2024.py
@@ -0,0 +1,1160 @@
+# Importaciones generales
+import sys
+import streamlit as st
+import re
+import io
+from io import BytesIO
+import base64
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+import pandas as pd
+import numpy as np
+import time
+from datetime import datetime
+from streamlit_player import st_player # Necesitarás instalar esta librería: pip install streamlit-player
+from spacy import displacy
+import logging
+import random
+
+######################################################
+# Configuración del logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+######################################################
+#imporraciones locales de traducción
+from translations import get_translations
+
+######################################################
+# Importaciones locales
+from ..email.email import send_email_notification
+
+######################################################
+# Importaciones locales de autenticación y base de datos
+from ..auth.auth import (
+ authenticate_user,
+ register_user
+)
+
+######################################################
+from ..database.database_oldFromV2 import (
+ create_admin_user,
+ create_student_user,
+ get_user,
+ get_student_data,
+ store_file_contents, #gestión archivos
+ retrieve_file_contents, #gestión archivos
+ get_user_files, #gestión archivos
+ delete_file, # #gestión archivos
+ store_application_request, # form
+ store_user_feedback, # form
+ store_morphosyntax_result,
+ store_semantic_result,
+ store_discourse_analysis_result,
+ store_chat_history,
+ export_analysis_and_chat
+)
+
+######################################################
+# Importaciones locales de uiadmin
+from ..admin.admin_ui import admin_page
+
+######################################################
+# Importaciones locales funciones de análisis
+from ..text_analysis.morpho_analysis import (
+ generate_arc_diagram,
+ get_repeated_words_colors,
+ highlight_repeated_words,
+ POS_COLORS,
+ POS_TRANSLATIONS,
+ perform_advanced_morphosyntactic_analysis
+)
+
+######################################################
+from ..text_analysis.semantic_analysis import (
+ #visualize_semantic_relations,
+ perform_semantic_analysis,
+ create_concept_graph,
+ visualize_concept_graph
+)
+
+######################################################
+from ..text_analysis.discourse_analysis import (
+ perform_discourse_analysis,
+ display_discourse_analysis_results
+)
+
+######################################################
+from ..chatbot.chatbot import (
+ initialize_chatbot,
+ process_morphosyntactic_input,
+ process_semantic_input,
+ process_discourse_input,
+ process_chat_input,
+ get_connectors,
+ #handle_semantic_commands,
+ generate_topics_visualization,
+ extract_topics,
+ get_semantic_chatbot_response
+)
+
+#####################-- Funciones de inicialización y configuración--- ##############################################################################
+def initialize_session_state():
+ if 'initialized' not in st.session_state:
+ st.session_state.clear()
+ st.session_state.initialized = True
+ st.session_state.logged_in = False
+ st.session_state.page = 'login'
+ st.session_state.username = None
+ st.session_state.role = None
+
+def main():
+ initialize_session_state()
+
+ print(f"Página actual: {st.session_state.page}")
+ print(f"Rol del usuario: {st.session_state.role}")
+
+ if st.session_state.page == 'login':
+ login_register_page()
+ elif st.session_state.page == 'admin':
+ print("Intentando mostrar página de admin")
+ admin_page()
+ elif st.session_state.page == 'user':
+ user_page()
+ else:
+ print(f"Página no reconocida: {st.session_state.page}")
+
+ print(f"Estado final de la sesión: {st.session_state}")
+
+#############################--- # Funciones de autenticación y registro --- #####################################################################
+def login_register_page():
+ st.title("AIdeaText")
+
+ left_column, right_column = st.columns([1, 3])
+
+ with left_column:
+ tab1, tab2 = st.tabs(["Iniciar Sesión", "Registrarse"])
+
+ with tab1:
+ login_form()
+
+ with tab2:
+ register_form()
+
+ with right_column:
+ display_videos_and_info()
+
+def login_form():
+ with st.form("login_form"):
+ username = st.text_input("Correo electrónico")
+ password = st.text_input("Contraseña", type="password")
+ submit_button = st.form_submit_button("Iniciar Sesión")
+
+ if submit_button:
+ success, role = authenticate_user(username, password)
+ if success:
+ st.session_state.logged_in = True
+ st.session_state.username = username
+ st.session_state.role = role
+ st.session_state.page = 'admin' if role == 'Administrador' else 'user'
+ st.rerun()
+ else:
+ st.error("Credenciales incorrectas")
+
+def register_form():
+ st.header("Solicitar prueba de la aplicación")
+
+ name = st.text_input("Nombre completo")
+ email = st.text_input("Correo electrónico institucional")
+ institution = st.text_input("Institución")
+ role = st.selectbox("Rol", ["Estudiante", "Profesor", "Investigador", "Otro"])
+ reason = st.text_area("¿Por qué estás interesado en probar AIdeaText?")
+
+ if st.button("Enviar solicitud"):
+ logger.info(f"Attempting to submit application for {email}")
+ logger.debug(f"Form data: name={name}, email={email}, institution={institution}, role={role}, reason={reason}")
+
+ if not name or not email or not institution or not reason:
+ logger.warning("Incomplete form submission")
+ st.error("Por favor, completa todos los campos.")
+ elif not is_institutional_email(email):
+ logger.warning(f"Non-institutional email used: {email}")
+ st.error("Por favor, utiliza un correo electrónico institucional.")
+ else:
+ logger.info(f"Attempting to store application for {email}")
+ success = store_application_request(name, email, institution, role, reason)
+ if success:
+ st.success("Tu solicitud ha sido enviada. Te contactaremos pronto.")
+ logger.info(f"Application request stored successfully for {email}")
+ else:
+ st.error("Hubo un problema al enviar tu solicitud. Por favor, intenta de nuevo más tarde.")
+ logger.error(f"Failed to store application request for {email}")
+
+def is_institutional_email(email):
+ forbidden_domains = ['gmail.com', 'hotmail.com', 'yahoo.com', 'outlook.com']
+ return not any(domain in email.lower() for domain in forbidden_domains)
+
+###########################################--- Funciones de interfaz general --- ######################################################
+
+def user_page():
+ # Asumimos que el idioma seleccionado está almacenado en st.session_state.lang_code
+ # Si no está definido, usamos 'es' como valor predeterminado
+ t = get_translations(lang_code)
+
+ st.title(t['welcome'])
+ st.write(f"{t['hello']}, {st.session_state.username}")
+
+ # Dividir la pantalla en dos columnas
+ col1, col2 = st.columns(2)
+
+ with col1:
+ st.subheader(t['chat_title'])
+ display_chatbot_interface(lang_code)
+
+ with col2:
+ st.subheader(t['results_title'])
+ if 'current_analysis' in st.session_state and st.session_state.current_analysis is not None:
+ display_analysis_results(st.session_state.current_analysis, lang_code)
+ if st.button(t['export_button']):
+ if export_analysis_and_chat(st.session_state.username, st.session_state.current_analysis, st.session_state.messages):
+ st.success(t['export_success'])
+ else:
+ st.error(t['export_error'])
+ else:
+ st.info(t['no_analysis'])
+
+def admin_page():
+ st.title("Panel de Administración")
+ st.write(f"Bienvenida, {st.session_state.username}")
+
+ st.header("Crear Nuevo Usuario Estudiante")
+ new_username = st.text_input("Correo electrónico del nuevo usuario", key="admin_new_username")
+ new_password = st.text_input("Contraseña", type="password", key="admin_new_password")
+ if st.button("Crear Usuario", key="admin_create_user"):
+ if create_student_user(new_username, new_password):
+ st.success(f"Usuario estudiante {new_username} creado exitosamente")
+ else:
+ st.error("Error al crear el usuario estudiante")
+
+ # Aquí puedes añadir más funcionalidades para el panel de administración
+
+def display_videos_and_info():
+ st.header("Videos: pitch, demos, entrevistas, otros")
+
+ videos = {
+ "Presentación en PyCon Colombia, Medellín, 2024": "https://www.youtube.com/watch?v=Jn545-IKx5Q",
+ "Presentación fundación Ser Maaestro": "https://www.youtube.com/watch?v=imc4TI1q164",
+ "Pitch IFE Explora": "https://www.youtube.com/watch?v=Fqi4Di_Rj_s",
+ "Entrevista Dr. Guillermo Ruíz": "https://www.youtube.com/watch?v=_ch8cRja3oc",
+ "Demo versión desktop": "https://www.youtube.com/watch?v=nP6eXbog-ZY"
+ }
+
+ selected_title = st.selectbox("Selecciona un video tutorial:", list(videos.keys()))
+
+ if selected_title in videos:
+ try:
+ st_player(videos[selected_title])
+ except Exception as e:
+ st.error(f"Error al cargar el video: {str(e)}")
+
+ st.markdown("""
+ ## Novedades de la versión actual
+ - Nueva función de análisis semántico
+ - Soporte para múltiples idiomas
+ - Interfaz mejorada para una mejor experiencia de usuario
+ """)
+
+def display_feedback_form(lang_code, t):
+ logging.info(f"display_feedback_form called with lang_code: {lang_code}")
+
+ st.header(t['title'])
+
+ name = st.text_input(t['name'], key=f"feedback_name_{lang_code}")
+ email = st.text_input(t['email'], key=f"feedback_email_{lang_code}")
+ feedback = st.text_area(t['feedback'], key=f"feedback_text_{lang_code}")
+
+ if st.button(t['submit'], key=f"feedback_submit_{lang_code}"):
+ if name and email and feedback:
+ if store_user_feedback(st.session_state.username, name, email, feedback):
+ st.success(t['success'])
+ else:
+ st.error(t['error'])
+ else:
+ st.warning("Por favor, completa todos los campos.")
+
+def display_student_progress(username, lang_code, t):
+ student_data = get_student_data(username)
+
+ if student_data is None or len(student_data['entries']) == 0:
+ st.warning("No se encontraron datos para este estudiante.")
+ st.info("Intenta realizar algunos análisis de texto primero.")
+ return
+
+ st.title(f"Progreso de {username}")
+
+ with st.expander("Resumen de Actividades y Progreso", expanded=True):
+ # Resumen de actividades
+ total_entries = len(student_data['entries'])
+ st.write(f"Total de análisis realizados: {total_entries}")
+
+ # Gráfico de tipos de análisis
+ analysis_types = [entry['analysis_type'] for entry in student_data['entries']]
+ analysis_counts = pd.Series(analysis_types).value_counts()
+
+ fig, ax = plt.subplots()
+ analysis_counts.plot(kind='bar', ax=ax)
+ ax.set_title("Tipos de análisis realizados")
+ ax.set_xlabel("Tipo de análisis")
+ ax.set_ylabel("Cantidad")
+ st.pyplot(fig)
+
+ # Progreso a lo largo del tiempo
+ dates = [datetime.fromisoformat(entry['timestamp']) for entry in student_data['entries']]
+ analysis_counts = pd.Series(dates).value_counts().sort_index()
+
+ fig, ax = plt.subplots()
+ analysis_counts.plot(kind='line', ax=ax)
+ ax.set_title("Análisis realizados a lo largo del tiempo")
+ ax.set_xlabel("Fecha")
+ ax.set_ylabel("Cantidad de análisis")
+ st.pyplot(fig)
+
+##########################################################
+ with st.expander("Histórico de Análisis Morfosintácticos"):
+ morphosyntax_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'morphosyntax']
+ for entry in morphosyntax_entries:
+ st.subheader(f"Análisis del {entry['timestamp']}")
+ if entry['arc_diagrams']:
+ st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
+
+
+ ##########################################################
+ with st.expander("Histórico de Análisis Semánticos"):
+ semantic_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'semantic']
+ for entry in semantic_entries:
+ st.subheader(f"Análisis del {entry['timestamp']}")
+
+ # Mostrar conceptos clave
+ if 'key_concepts' in entry:
+ st.write("Conceptos clave:")
+ concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts']])
+ #st.write("Conceptos clave:")
+ #st.write(concepts_str)
+ st.markdown(f"{concepts_str}
", unsafe_allow_html=True)
+
+ # Mostrar gráfico
+ if 'graph' in entry:
+ try:
+ img_bytes = base64.b64decode(entry['graph'])
+ st.image(img_bytes, caption="Gráfico de relaciones conceptuales")
+ except Exception as e:
+ st.error(f"No se pudo mostrar el gráfico: {str(e)}")
+
+##########################################################
+ with st.expander("Histórico de Análisis Discursivos"):
+ discourse_entries = [entry for entry in student_data['entries'] if entry['analysis_type'] == 'discourse']
+ for entry in discourse_entries:
+ st.subheader(f"Análisis del {entry['timestamp']}")
+
+ # Mostrar conceptos clave para ambos documentos
+ if 'key_concepts1' in entry:
+ concepts_str1 = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts1']])
+ st.write("Conceptos clave del documento 1:")
+ #st.write(concepts_str1)
+ st.markdown(f"{concepts_str1}
", unsafe_allow_html=True)
+
+ if 'key_concepts2' in entry:
+ concepts_str2 = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts2']])
+ st.write("Conceptos clave del documento 2:")
+ #st.write(concepts_str2)
+ st.markdown(f"{concepts_str2}
", unsafe_allow_html=True)
+
+ try:
+ if 'combined_graph' in entry and entry['combined_graph']:
+ img_bytes = base64.b64decode(entry['combined_graph'])
+ st.image(img_bytes)
+ elif 'graph1' in entry and 'graph2' in entry:
+ col1, col2 = st.columns(2)
+ with col1:
+ if entry['graph1']:
+ img_bytes1 = base64.b64decode(entry['graph1'])
+ st.image(img_bytes1)
+ with col2:
+ if entry['graph2']:
+ img_bytes2 = base64.b64decode(entry['graph2'])
+ st.image(img_bytes2)
+ else:
+ st.write("No se encontraron gráficos para este análisis.")
+ except Exception as e:
+ st.error(f"No se pudieron mostrar los gráficos: {str(e)}")
+ st.write("Datos de los gráficos (para depuración):")
+ if 'graph1' in entry:
+ st.write("Graph 1:", entry['graph1'][:100] + "...")
+ if 'graph2' in entry:
+ st.write("Graph 2:", entry['graph2'][:100] + "...")
+ if 'combined_graph' in entry:
+ st.write("Combined Graph:", entry['combined_graph'][:100] + "...")
+
+##########################################################
+ with st.expander("Histórico de Conversaciones con el ChatBot"):
+ if 'chat_history' in student_data:
+ for i, chat in enumerate(student_data['chat_history']):
+ st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
+ for message in chat['messages']:
+ if message['role'] == 'user':
+ st.write("Usuario: " + message['content'])
+ else:
+ st.write("Asistente: " + message['content'])
+ st.write("---")
+ else:
+ st.write("No se encontraron conversaciones con el ChatBot.")
+
+ # Añadir logs para depuración
+ if st.checkbox("Mostrar datos de depuración"):
+ st.write("Datos del estudiante (para depuración):")
+ st.json(student_data)
+
+#####################--- Funciones de manejo de archivos --- #############################################################################
+
+def handle_file_upload(username, lang_code, nlp_models, t, analysis_type):
+ get_text = get_text if callable(get_text) else lambda key, section, default: t.get(key, default)
+ st.subheader(get_text('file_upload_section', analysis_type.upper(), 'File Upload'))
+
+ uploaded_file = st.file_uploader(
+ get_text('file_uploader', analysis_type.upper(), 'Upload a file'),
+ type=['txt', 'pdf', 'docx', 'doc', 'odt']
+ )
+
+ if uploaded_file is not None:
+ file_contents = read_file_contents(uploaded_file)
+
+ if store_file_contents(username, uploaded_file.name, file_contents, analysis_type):
+ st.success(get_text('file_upload_success', analysis_type.upper(), 'File uploaded successfully'))
+ return file_contents, uploaded_file.name
+ else:
+ st.error(get_text('file_upload_error', analysis_type.upper(), 'Error uploading file'))
+
+ return None, None
+
+def read_file_contents(uploaded_file):
+ # Implementar la lógica para leer diferentes tipos de archivos
+ # Por ahora, asumimos que es un archivo de texto
+ return uploaded_file.getvalue().decode('utf-8')
+
+######################--- Funciones generales de análisis ---########################################################
+def display_analysis_results(analysis, lang_code, t):
+ if analysis is None:
+ st.warning(t.get('no_analysis', "No hay análisis disponible."))
+ return
+
+ if not isinstance(analysis, dict):
+ st.error(f"Error: El resultado del análisis no es un diccionario. Tipo actual: {type(analysis)}")
+ return
+
+ if 'type' not in analysis:
+ st.error("Error: El resultado del análisis no contiene la clave 'type'")
+ st.write("Claves presentes en el resultado:", list(analysis.keys()))
+ return
+
+ if analysis['type'] == 'morphosyntactic':
+ st.subheader(t.get('morphosyntactic_title', "Análisis Morfosintáctico"))
+ display_morphosyntax_results(analysis['result'], lang_code, t)
+ elif analysis['type'] == 'semantic':
+ st.subheader(t.get('semantic_title', "Análisis Semántico"))
+ display_semantic_results(analysis['result'], lang_code, t)
+ elif analysis['type'] == 'discourse':
+ st.subheader(t.get('discourse_title', "Análisis del Discurso"))
+ display_discourse_results(analysis['result'], lang_code, t)
+ else:
+ st.warning(t.get('no_analysis', "No hay análisis disponible."))
+
+ # Mostrar el contenido completo del análisis para depuración
+ st.write("Contenido completo del análisis:", analysis)
+
+def handle_user_input(user_input, lang_code, nlp_models, analysis_type, file_contents=None):
+ response = process_chat_input(user_input, lang_code, nlp_models, analysis_type, file_contents, t)
+ # Procesa la respuesta y actualiza la interfaz de usuario
+
+
+###################################--- Funciones específicas de análisis morfosintáctico ---################################################################
+
+def display_morphosyntax_analysis_interface(user_input, nlp_models, lang_code, t):
+ get_text = get_text if callable(get_text) else lambda key, section, default: t.get(key, default)
+ logging.info(f"Displaying morphosyntax analysis interface. Language code: {lang_code}")
+
+ # Inicializar el historial del chat si no existe
+ if 'morphosyntax_chat_history' not in st.session_state:
+ initial_message = get_text('initial_message', 'MORPHOSYNTACTIC',
+ "Este es un chatbot para análisis morfosintáctico. Para generar un diagrama de arco, "
+ "use el comando /analisis_morfosintactico seguido del texto entre corchetes.")
+ st.session_state.morphosyntax_chat_history = [{"role": "assistant", "content": initial_message}]
+
+ # Contenedor para el chat
+ chat_container = st.container()
+
+ # Mostrar el historial del chat
+ with chat_container:
+ for message in st.session_state.morphosyntax_chat_history:
+ with st.chat_message(message["role"]):
+ st.write(message["content"])
+ if "visualization" in message:
+ st.components.v1.html(message["visualization"], height=450, scrolling=True)
+
+ # Input del usuario
+ user_input = st.chat_input(get_text('chat_placeholder', 'MORPHOSYNTACTIC',
+ "Ingrese su mensaje o use /analisis_morfosintactico [texto] para analizar"))
+
+ if user_input:
+ # Añadir el mensaje del usuario al historial
+ st.session_state.morphosyntax_chat_history.append({"role": "user", "content": user_input})
+
+ # Procesar el input del usuario
+ if user_input.startswith('/analisis_morfosintactico'):
+ text_to_analyze = user_input.split('[', 1)[1].rsplit(']', 1)[0]
+ try:
+ result = perform_advanced_morphosyntactic_analysis(text_to_analyze, nlp_models[lang_code])
+
+ # Guardar el resultado en el estado de la sesión
+ st.session_state.current_analysis = {
+ 'type': 'morphosyntactic',
+ 'result': result
+ }
+
+ # Añadir el resultado al historial del chat
+ response = get_text('analysis_completed', 'MORPHOSYNTACTIC', 'Análisis morfosintáctico completado.')
+ st.session_state.morphosyntax_chat_history.append({
+ "role": "assistant",
+ "content": response,
+ "visualization": result['arc_diagram'][0] if result['arc_diagram'] else None
+ })
+
+ # Guardar resultados en la base de datos
+ if store_morphosyntax_result(
+ st.session_state.username,
+ text_to_analyze,
+ get_repeated_words_colors(nlp_models[lang_code](text_to_analyze)),
+ result['arc_diagram'],
+ result['pos_analysis'],
+ result['morphological_analysis'],
+ result['sentence_structure']
+ ):
+ st.success(get_text('success_message', 'MORPHOSYNTACTIC', 'Análisis guardado correctamente.'))
+ else:
+ st.error(get_text('error_message', 'MORPHOSYNTACTIC', 'Hubo un problema al guardar el análisis.'))
+
+ except Exception as e:
+ error_message = get_text('analysis_error', 'MORPHOSYNTACTIC', f'Ocurrió un error durante el análisis: {str(e)}')
+ st.session_state.morphosyntax_chat_history.append({"role": "assistant", "content": error_message})
+ logging.error(f"Error in morphosyntactic analysis: {str(e)}")
+ else:
+ # Aquí puedes procesar otros tipos de inputs del usuario si es necesario
+ response = get_text('command_not_recognized', 'MORPHOSYNTACTIC',
+ "Comando no reconocido. Use /analisis_morfosintactico [texto] para realizar un análisis.")
+ st.session_state.morphosyntax_chat_history.append({"role": "assistant", "content": response})
+
+ # Forzar la actualización de la interfaz
+ st.rerun()
+
+ logging.info("Morphosyntax analysis interface displayed successfully")
+
+
+#################################################################################################
+def display_morphosyntax_results(result, lang_code, t):
+ if result is None:
+ st.warning(t['no_results']) # Añade esta traducción a tu diccionario
+ return
+
+ # doc = result['doc']
+ # advanced_analysis = result['advanced_analysis']
+ advanced_analysis = result
+
+ # Mostrar leyenda (código existente)
+ st.markdown(f"##### {t['legend']}")
+ legend_html = ""
+ for pos, color in POS_COLORS.items():
+ if pos in POS_TRANSLATIONS[lang_code]:
+ legend_html += f"
"
+ st.markdown(legend_html, unsafe_allow_html=True)
+
+ # Mostrar análisis de palabras repetidas (código existente)
+ if 'repeated_words' in advanced_analysis:
+ with st.expander(t['repeated_words'], expanded=True):
+ st.markdown(advanced_analysis['repeated_words'], unsafe_allow_html=True)
+
+ # Mostrar estructura de oraciones
+ if 'sentence_structure' in advanced_analysis:
+ 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)
+ else:
+ st.warning("No se encontró información sobre la estructura de las oraciones.")
+
+
+ # Mostrar análisis de categorías gramaticales # Mostrar análisis morfológico
+ col1, col2 = st.columns(2)
+
+ with col1:
+ with st.expander(t['pos_analysis'], expanded=True):
+ pos_df = pd.DataFrame(advanced_analysis['pos_analysis'])
+
+ # Traducir las etiquetas POS a sus nombres en el idioma seleccionado
+ pos_df['pos'] = pos_df['pos'].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+
+ # Renombrar las columnas para mayor claridad
+ pos_df = pos_df.rename(columns={
+ 'pos': t['grammatical_category'],
+ 'count': t['count'],
+ 'percentage': t['percentage'],
+ 'examples': t['examples']
+ })
+
+ # Mostrar el dataframe
+ st.dataframe(pos_df)
+
+ with col2:
+ with st.expander(t['morphological_analysis'], expanded=True):
+ morph_df = pd.DataFrame(advanced_analysis['morphological_analysis'])
+
+ # Definir el mapeo de columnas
+ column_mapping = {
+ 'text': t['word'],
+ 'lemma': t['lemma'],
+ 'pos': t['grammatical_category'],
+ 'dep': t['dependency'],
+ 'morph': t['morphology']
+ }
+
+ # Renombrar las columnas existentes
+ morph_df = morph_df.rename(columns={col: new_name for col, new_name in column_mapping.items() if col in morph_df.columns})
+
+ # Traducir las categorías gramaticales
+ morph_df[t['grammatical_category']] = morph_df[t['grammatical_category']].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+
+ # Traducir las dependencias
+ dep_translations = {
+ 'es': {
+ 'ROOT': 'RAÍZ', 'nsubj': 'sujeto nominal', 'obj': 'objeto', 'iobj': 'objeto indirecto',
+ 'csubj': 'sujeto clausal', 'ccomp': 'complemento clausal', 'xcomp': 'complemento clausal abierto',
+ 'obl': 'oblicuo', 'vocative': 'vocativo', 'expl': 'expletivo', 'dislocated': 'dislocado',
+ 'advcl': 'cláusula adverbial', 'advmod': 'modificador adverbial', 'discourse': 'discurso',
+ 'aux': 'auxiliar', 'cop': 'cópula', 'mark': 'marcador', 'nmod': 'modificador nominal',
+ 'appos': 'aposición', 'nummod': 'modificador numeral', 'acl': 'cláusula adjetiva',
+ 'amod': 'modificador adjetival', 'det': 'determinante', 'clf': 'clasificador',
+ 'case': 'caso', 'conj': 'conjunción', 'cc': 'coordinante', 'fixed': 'fijo',
+ 'flat': 'plano', 'compound': 'compuesto', 'list': 'lista', 'parataxis': 'parataxis',
+ 'orphan': 'huérfano', 'goeswith': 'va con', 'reparandum': 'reparación', 'punct': 'puntuación'
+ },
+ 'en': {
+ 'ROOT': 'ROOT', 'nsubj': 'nominal subject', 'obj': 'object',
+ 'iobj': 'indirect object', 'csubj': 'clausal subject', 'ccomp': 'clausal complement', 'xcomp': 'open clausal complement',
+ 'obl': 'oblique', 'vocative': 'vocative', 'expl': 'expletive', 'dislocated': 'dislocated', 'advcl': 'adverbial clause modifier',
+ 'advmod': 'adverbial modifier', 'discourse': 'discourse element', 'aux': 'auxiliary', 'cop': 'copula', 'mark': 'marker',
+ 'nmod': 'nominal modifier', 'appos': 'appositional modifier', 'nummod': 'numeric modifier', 'acl': 'clausal modifier of noun',
+ 'amod': 'adjectival modifier', 'det': 'determiner', 'clf': 'classifier', 'case': 'case marking',
+ 'conj': 'conjunct', 'cc': 'coordinating conjunction', 'fixed': 'fixed multiword expression',
+ 'flat': 'flat multiword expression', 'compound': 'compound', 'list': 'list', 'parataxis': 'parataxis', 'orphan': 'orphan',
+ 'goeswith': 'goes with', 'reparandum': 'reparandum', 'punct': 'punctuation'
+ },
+ 'fr': {
+ 'ROOT': 'RACINE', 'nsubj': 'sujet nominal', 'obj': 'objet', 'iobj': 'objet indirect',
+ 'csubj': 'sujet phrastique', 'ccomp': 'complément phrastique', 'xcomp': 'complément phrastique ouvert', 'obl': 'oblique',
+ 'vocative': 'vocatif', 'expl': 'explétif', 'dislocated': 'disloqué', 'advcl': 'clause adverbiale', 'advmod': 'modifieur adverbial',
+ 'discourse': 'élément de discours', 'aux': 'auxiliaire', 'cop': 'copule', 'mark': 'marqueur', 'nmod': 'modifieur nominal',
+ 'appos': 'apposition', 'nummod': 'modifieur numéral', 'acl': 'clause relative', 'amod': 'modifieur adjectival', 'det': 'déterminant',
+ 'clf': 'classificateur', 'case': 'marqueur de cas', 'conj': 'conjonction', 'cc': 'coordination', 'fixed': 'expression figée',
+ 'flat': 'construction plate', 'compound': 'composé', 'list': 'liste', 'parataxis': 'parataxe', 'orphan': 'orphelin',
+ 'goeswith': 'va avec', 'reparandum': 'réparation', 'punct': 'ponctuation'
+ }
+ }
+ morph_df[t['dependency']] = morph_df[t['dependency']].map(lambda x: dep_translations[lang_code].get(x, x))
+
+ # Traducir la morfología
+ def translate_morph(morph_string, lang_code):
+ morph_translations = {
+ 'es': {
+ 'Gender': 'Género', 'Number': 'Número', 'Case': 'Caso', 'Definite': 'Definido',
+ 'PronType': 'Tipo de Pronombre', 'Person': 'Persona', 'Mood': 'Modo',
+ 'Tense': 'Tiempo', 'VerbForm': 'Forma Verbal', 'Voice': 'Voz',
+ 'Fem': 'Femenino', 'Masc': 'Masculino', 'Sing': 'Singular', 'Plur': 'Plural',
+ 'Ind': 'Indicativo', 'Sub': 'Subjuntivo', 'Imp': 'Imperativo', 'Inf': 'Infinitivo',
+ 'Part': 'Participio', 'Ger': 'Gerundio', 'Pres': 'Presente', 'Past': 'Pasado',
+ 'Fut': 'Futuro', 'Perf': 'Perfecto', 'Imp': 'Imperfecto'
+ },
+ 'en': {
+ 'Gender': 'Gender', 'Number': 'Number', 'Case': 'Case', 'Definite': 'Definite', 'PronType': 'Pronoun Type', 'Person': 'Person',
+ 'Mood': 'Mood', 'Tense': 'Tense', 'VerbForm': 'Verb Form', 'Voice': 'Voice',
+ 'Fem': 'Feminine', 'Masc': 'Masculine', 'Sing': 'Singular', 'Plur': 'Plural', 'Ind': 'Indicative',
+ 'Sub': 'Subjunctive', 'Imp': 'Imperative', 'Inf': 'Infinitive', 'Part': 'Participle',
+ 'Ger': 'Gerund', 'Pres': 'Present', 'Past': 'Past', 'Fut': 'Future', 'Perf': 'Perfect', 'Imp': 'Imperfect'
+ },
+ 'fr': {
+ 'Gender': 'Genre', 'Number': 'Nombre', 'Case': 'Cas', 'Definite': 'Défini', 'PronType': 'Type de Pronom',
+ 'Person': 'Personne', 'Mood': 'Mode', 'Tense': 'Temps', 'VerbForm': 'Forme Verbale', 'Voice': 'Voix',
+ 'Fem': 'Féminin', 'Masc': 'Masculin', 'Sing': 'Singulier', 'Plur': 'Pluriel', 'Ind': 'Indicatif',
+ 'Sub': 'Subjonctif', 'Imp': 'Impératif', 'Inf': 'Infinitif', 'Part': 'Participe',
+ 'Ger': 'Gérondif', 'Pres': 'Présent', 'Past': 'Passé', 'Fut': 'Futur', 'Perf': 'Parfait', 'Imp': 'Imparfait'
+ }
+ }
+ for key, value in morph_translations[lang_code].items():
+ morph_string = morph_string.replace(key, value)
+ return morph_string
+
+ morph_df[t['morphology']] = morph_df[t['morphology']].apply(lambda x: translate_morph(x, lang_code))
+
+ # Seleccionar y ordenar las columnas a mostrar
+ columns_to_display = [t['word'], t['lemma'], t['grammatical_category'], t['dependency'], t['morphology']]
+ columns_to_display = [col for col in columns_to_display if col in morph_df.columns]
+
+ # Mostrar el DataFrame
+ st.dataframe(morph_df[columns_to_display])
+
+ # Mostrar diagramas de arco (código existente)
+ #with st.expander(t['arc_diagram'], expanded=True):
+ # sentences = list(doc.sents)
+ # arc_diagrams = []
+ # for i, sent in enumerate(sentences):
+ # st.subheader(f"{t['sentence']} {i+1}")
+ # html = displacy.render(sent, style="dep", options={"distance": 100})
+ # html = html.replace('height="375"', 'height="200"')
+ # html = re.sub(r'{POS_TRANSLATIONS[lang_code][pos]}
"
+ legend_html += "{concepts_str1}
", unsafe_allow_html=True)
+
+ if 'key_concepts2' in entry:
+ concepts_str2 = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts2']])
+ st.write("Conceptos clave del documento 2:")
+ #st.write(concepts_str2)
+ st.markdown(f"{concepts_str2}
", unsafe_allow_html=True)
+
+ try:
+ if 'combined_graph' in entry and entry['combined_graph']:
+ img_bytes = base64.b64decode(entry['combined_graph'])
+ st.image(img_bytes)
+ elif 'graph1' in entry and 'graph2' in entry:
+ col1, col2 = st.columns(2)
+ with col1:
+ if entry['graph1']:
+ img_bytes1 = base64.b64decode(entry['graph1'])
+ st.image(img_bytes1)
+ with col2:
+ if entry['graph2']:
+ img_bytes2 = base64.b64decode(entry['graph2'])
+ st.image(img_bytes2)
+ else:
+ st.write("No se encontraron gráficos para este análisis.")
+ except Exception as e:
+ st.error(f"No se pudieron mostrar los gráficos: {str(e)}")
+ st.write("Datos de los gráficos (para depuración):")
+ if 'graph1' in entry:
+ st.write("Graph 1:", entry['graph1'][:100] + "...")
+ if 'graph2' in entry:
+ st.write("Graph 2:", entry['graph2'][:100] + "...")
+ if 'combined_graph' in entry:
+ st.write("Combined Graph:", entry['combined_graph'][:100] + "...")
+
+##########################################################
+ with st.expander("Histórico de Conversaciones con el ChatBot"):
+ if 'chat_history' in student_data:
+ for i, chat in enumerate(student_data['chat_history']):
+ st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
+ for message in chat['messages']:
+ if message['role'] == 'user':
+ st.write("Usuario: " + message['content'])
+ else:
+ st.write("Asistente: " + message['content'])
+ st.write("---")
+ else:
+ st.write("No se encontraron conversaciones con el ChatBot.")
+
+ # Añadir logs para depuración
+ if st.checkbox("Mostrar datos de depuración"):
+ st.write("Datos del estudiante (para depuración):")
+ st.json(student_data)
+
+#####################--- Funciones de manejo de archivos --- #############################################################################
+
+def handle_file_upload(username, lang_code, nlp_models, t, analysis_type):
+ st.subheader(t['get_text']('file_upload_section', analysis_type.upper(), 'File Upload'))
+
+ uploaded_file = st.file_uploader(
+ t['get_text']('file_uploader', analysis_type.upper(), 'Upload a file'),
+ type=['txt', 'pdf', 'docx', 'doc', 'odt']
+ )
+
+ if uploaded_file is not None:
+ file_contents = read_file_contents(uploaded_file)
+
+ if store_file_contents(username, uploaded_file.name, file_contents, analysis_type):
+ st.success(t['get_text']('file_upload_success', analysis_type.upper(), 'File uploaded successfully'))
+ return file_contents, uploaded_file.name
+ else:
+ st.error(t['get_text']('file_upload_error', analysis_type.upper(), 'Error uploading file'))
+
+ return None, None
+
+def read_file_contents(uploaded_file):
+ # Implementar la lógica para leer diferentes tipos de archivos
+ # Por ahora, asumimos que es un archivo de texto
+ return uploaded_file.getvalue().decode('utf-8')
+
+######################--- Funciones generales de análisis ---########################################################
+def display_analysis_results(analysis, lang_code, t):
+ if analysis is None:
+ st.warning(t.get('no_analysis', "No hay análisis disponible."))
+ return
+
+ if not isinstance(analysis, dict):
+ st.error(f"Error: El resultado del análisis no es un diccionario. Tipo actual: {type(analysis)}")
+ return
+
+ if 'type' not in analysis:
+ st.error("Error: El resultado del análisis no contiene la clave 'type'")
+ st.write("Claves presentes en el resultado:", list(analysis.keys()))
+ return
+
+ if analysis['type'] == 'morphosyntactic':
+ st.subheader(t.get('morphosyntactic_title', "Análisis Morfosintáctico"))
+ display_morphosyntax_results(analysis['result'], lang_code, t)
+ elif analysis['type'] == 'semantic':
+ st.subheader(t.get('semantic_title', "Análisis Semántico"))
+ display_semantic_results(analysis['result'], lang_code, t)
+ elif analysis['type'] == 'discourse':
+ st.subheader(t.get('discourse_title', "Análisis del Discurso"))
+ display_discourse_results(analysis['result'], lang_code, t)
+ else:
+ st.warning(t.get('no_analysis', "No hay análisis disponible."))
+
+ # Mostrar el contenido completo del análisis para depuración
+ st.write("Contenido completo del análisis:", analysis)
+
+def handle_user_input(user_input, lang_code, nlp_models, analysis_type, file_contents=None):
+ response = process_chat_input(user_input, lang_code, nlp_models, analysis_type, file_contents, t)
+ # Procesa la respuesta y actualiza la interfaz de usuario
+
+
+###################################--- Funciones específicas de análisis morfosintáctico ---################################################################
+
+def display_morphosyntax_analysis_interface(user_input, nlp_models, lang_code, t):
+ logging.info(f"Displaying morphosyntax analysis interface. Language code: {lang_code}")
+
+ # Inicializar el historial del chat si no existe
+ if 'morphosyntax_chat_history' not in st.session_state:
+ initial_message = t['get_text']('initial_message', 'MORPHOSYNTACTIC',
+ "Este es un chatbot para análisis morfosintáctico. Para generar un diagrama de arco, "
+ "use el comando /analisis_morfosintactico seguido del texto entre corchetes.")
+ st.session_state.morphosyntax_chat_history = [{"role": "assistant", "content": initial_message}]
+
+ # Contenedor para el chat
+ chat_container = st.container()
+
+ # Mostrar el historial del chat
+ with chat_container:
+ for message in st.session_state.morphosyntax_chat_history:
+ with st.chat_message(message["role"]):
+ st.write(message["content"])
+ if "visualization" in message:
+ st.components.v1.html(message["visualization"], height=450, scrolling=True)
+
+ # Input del usuario
+ user_input = st.chat_input(t['get_text']('chat_placeholder', 'MORPHOSYNTACTIC',
+ "Ingrese su mensaje o use /analisis_morfosintactico [texto] para analizar"))
+
+ if user_input:
+ # Añadir el mensaje del usuario al historial
+ st.session_state.morphosyntax_chat_history.append({"role": "user", "content": user_input})
+
+ # Procesar el input del usuario
+ if user_input.startswith('/analisis_morfosintactico'):
+ text_to_analyze = user_input.split('[', 1)[1].rsplit(']', 1)[0]
+ try:
+ result = perform_advanced_morphosyntactic_analysis(text_to_analyze, nlp_models[lang_code])
+
+ # Guardar el resultado en el estado de la sesión
+ st.session_state.current_analysis = {
+ 'type': 'morphosyntactic',
+ 'result': result
+ }
+
+ # Añadir el resultado al historial del chat
+ response = t['get_text']('analysis_completed', 'MORPHOSYNTACTIC', 'Análisis morfosintáctico completado.')
+ st.session_state.morphosyntax_chat_history.append({
+ "role": "assistant",
+ "content": response,
+ "visualization": result['arc_diagram'][0] if result['arc_diagram'] else None
+ })
+
+ # Guardar resultados en la base de datos
+ if store_morphosyntax_result(
+ st.session_state.username,
+ text_to_analyze,
+ get_repeated_words_colors(nlp_models[lang_code](text_to_analyze)),
+ result['arc_diagram'],
+ result['pos_analysis'],
+ result['morphological_analysis'],
+ result['sentence_structure']
+ ):
+ st.success(t['get_text']('success_message', 'MORPHOSYNTACTIC', 'Análisis guardado correctamente.'))
+ else:
+ st.error(t['get_text']('error_message', 'MORPHOSYNTACTIC', 'Hubo un problema al guardar el análisis.'))
+
+ except Exception as e:
+ error_message = t['get_text']('analysis_error', 'MORPHOSYNTACTIC', f'Ocurrió un error durante el análisis: {str(e)}')
+ st.session_state.morphosyntax_chat_history.append({"role": "assistant", "content": error_message})
+ logging.error(f"Error in morphosyntactic analysis: {str(e)}")
+ else:
+ # Aquí puedes procesar otros tipos de inputs del usuario si es necesario
+ response = t['get_text']('command_not_recognized', 'MORPHOSYNTACTIC',
+ "Comando no reconocido. Use /analisis_morfosintactico [texto] para realizar un análisis.")
+ st.session_state.morphosyntax_chat_history.append({"role": "assistant", "content": response})
+
+ # Forzar la actualización de la interfaz
+ st.experimental_rerun()
+
+ logging.info("Morphosyntax analysis interface displayed successfully")
+
+
+#################################################################################################
+def display_morphosyntax_results(result, lang_code, t):
+ if result is None:
+ st.warning(t['no_results']) # Añade esta traducción a tu diccionario
+ return
+
+ # doc = result['doc']
+ # advanced_analysis = result['advanced_analysis']
+ advanced_analysis = result
+
+ # Mostrar leyenda (código existente)
+ st.markdown(f"##### {t['legend']}")
+ legend_html = ""
+ for pos, color in POS_COLORS.items():
+ if pos in POS_TRANSLATIONS[lang_code]:
+ legend_html += f"
"
+ st.markdown(legend_html, unsafe_allow_html=True)
+
+ # Mostrar análisis de palabras repetidas (código existente)
+ if 'repeated_words' in advanced_analysis:
+ with st.expander(t['repeated_words'], expanded=True):
+ st.markdown(advanced_analysis['repeated_words'], unsafe_allow_html=True)
+
+ # Mostrar estructura de oraciones
+ if 'sentence_structure' in advanced_analysis:
+ 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)
+ else:
+ st.warning("No se encontró información sobre la estructura de las oraciones.")
+
+
+ # Mostrar análisis de categorías gramaticales # Mostrar análisis morfológico
+ col1, col2 = st.columns(2)
+
+ with col1:
+ with st.expander(t['pos_analysis'], expanded=True):
+ pos_df = pd.DataFrame(advanced_analysis['pos_analysis'])
+
+ # Traducir las etiquetas POS a sus nombres en el idioma seleccionado
+ pos_df['pos'] = pos_df['pos'].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+
+ # Renombrar las columnas para mayor claridad
+ pos_df = pos_df.rename(columns={
+ 'pos': t['grammatical_category'],
+ 'count': t['count'],
+ 'percentage': t['percentage'],
+ 'examples': t['examples']
+ })
+
+ # Mostrar el dataframe
+ st.dataframe(pos_df)
+
+ with col2:
+ with st.expander(t['morphological_analysis'], expanded=True):
+ morph_df = pd.DataFrame(advanced_analysis['morphological_analysis'])
+
+ # Definir el mapeo de columnas
+ column_mapping = {
+ 'text': t['word'],
+ 'lemma': t['lemma'],
+ 'pos': t['grammatical_category'],
+ 'dep': t['dependency'],
+ 'morph': t['morphology']
+ }
+
+ # Renombrar las columnas existentes
+ morph_df = morph_df.rename(columns={col: new_name for col, new_name in column_mapping.items() if col in morph_df.columns})
+
+ # Traducir las categorías gramaticales
+ morph_df[t['grammatical_category']] = morph_df[t['grammatical_category']].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+
+ # Traducir las dependencias
+ dep_translations = {
+ 'es': {
+ 'ROOT': 'RAÍZ', 'nsubj': 'sujeto nominal', 'obj': 'objeto', 'iobj': 'objeto indirecto',
+ 'csubj': 'sujeto clausal', 'ccomp': 'complemento clausal', 'xcomp': 'complemento clausal abierto',
+ 'obl': 'oblicuo', 'vocative': 'vocativo', 'expl': 'expletivo', 'dislocated': 'dislocado',
+ 'advcl': 'cláusula adverbial', 'advmod': 'modificador adverbial', 'discourse': 'discurso',
+ 'aux': 'auxiliar', 'cop': 'cópula', 'mark': 'marcador', 'nmod': 'modificador nominal',
+ 'appos': 'aposición', 'nummod': 'modificador numeral', 'acl': 'cláusula adjetiva',
+ 'amod': 'modificador adjetival', 'det': 'determinante', 'clf': 'clasificador',
+ 'case': 'caso', 'conj': 'conjunción', 'cc': 'coordinante', 'fixed': 'fijo',
+ 'flat': 'plano', 'compound': 'compuesto', 'list': 'lista', 'parataxis': 'parataxis',
+ 'orphan': 'huérfano', 'goeswith': 'va con', 'reparandum': 'reparación', 'punct': 'puntuación'
+ },
+ 'en': {
+ 'ROOT': 'ROOT', 'nsubj': 'nominal subject', 'obj': 'object',
+ 'iobj': 'indirect object', 'csubj': 'clausal subject', 'ccomp': 'clausal complement', 'xcomp': 'open clausal complement',
+ 'obl': 'oblique', 'vocative': 'vocative', 'expl': 'expletive', 'dislocated': 'dislocated', 'advcl': 'adverbial clause modifier',
+ 'advmod': 'adverbial modifier', 'discourse': 'discourse element', 'aux': 'auxiliary', 'cop': 'copula', 'mark': 'marker',
+ 'nmod': 'nominal modifier', 'appos': 'appositional modifier', 'nummod': 'numeric modifier', 'acl': 'clausal modifier of noun',
+ 'amod': 'adjectival modifier', 'det': 'determiner', 'clf': 'classifier', 'case': 'case marking',
+ 'conj': 'conjunct', 'cc': 'coordinating conjunction', 'fixed': 'fixed multiword expression',
+ 'flat': 'flat multiword expression', 'compound': 'compound', 'list': 'list', 'parataxis': 'parataxis', 'orphan': 'orphan',
+ 'goeswith': 'goes with', 'reparandum': 'reparandum', 'punct': 'punctuation'
+ },
+ 'fr': {
+ 'ROOT': 'RACINE', 'nsubj': 'sujet nominal', 'obj': 'objet', 'iobj': 'objet indirect',
+ 'csubj': 'sujet phrastique', 'ccomp': 'complément phrastique', 'xcomp': 'complément phrastique ouvert', 'obl': 'oblique',
+ 'vocative': 'vocatif', 'expl': 'explétif', 'dislocated': 'disloqué', 'advcl': 'clause adverbiale', 'advmod': 'modifieur adverbial',
+ 'discourse': 'élément de discours', 'aux': 'auxiliaire', 'cop': 'copule', 'mark': 'marqueur', 'nmod': 'modifieur nominal',
+ 'appos': 'apposition', 'nummod': 'modifieur numéral', 'acl': 'clause relative', 'amod': 'modifieur adjectival', 'det': 'déterminant',
+ 'clf': 'classificateur', 'case': 'marqueur de cas', 'conj': 'conjonction', 'cc': 'coordination', 'fixed': 'expression figée',
+ 'flat': 'construction plate', 'compound': 'composé', 'list': 'liste', 'parataxis': 'parataxe', 'orphan': 'orphelin',
+ 'goeswith': 'va avec', 'reparandum': 'réparation', 'punct': 'ponctuation'
+ }
+ }
+ morph_df[t['dependency']] = morph_df[t['dependency']].map(lambda x: dep_translations[lang_code].get(x, x))
+
+ # Traducir la morfología
+ def translate_morph(morph_string, lang_code):
+ morph_translations = {
+ 'es': {
+ 'Gender': 'Género', 'Number': 'Número', 'Case': 'Caso', 'Definite': 'Definido',
+ 'PronType': 'Tipo de Pronombre', 'Person': 'Persona', 'Mood': 'Modo',
+ 'Tense': 'Tiempo', 'VerbForm': 'Forma Verbal', 'Voice': 'Voz',
+ 'Fem': 'Femenino', 'Masc': 'Masculino', 'Sing': 'Singular', 'Plur': 'Plural',
+ 'Ind': 'Indicativo', 'Sub': 'Subjuntivo', 'Imp': 'Imperativo', 'Inf': 'Infinitivo',
+ 'Part': 'Participio', 'Ger': 'Gerundio', 'Pres': 'Presente', 'Past': 'Pasado',
+ 'Fut': 'Futuro', 'Perf': 'Perfecto', 'Imp': 'Imperfecto'
+ },
+ 'en': {
+ 'Gender': 'Gender', 'Number': 'Number', 'Case': 'Case', 'Definite': 'Definite', 'PronType': 'Pronoun Type', 'Person': 'Person',
+ 'Mood': 'Mood', 'Tense': 'Tense', 'VerbForm': 'Verb Form', 'Voice': 'Voice',
+ 'Fem': 'Feminine', 'Masc': 'Masculine', 'Sing': 'Singular', 'Plur': 'Plural', 'Ind': 'Indicative',
+ 'Sub': 'Subjunctive', 'Imp': 'Imperative', 'Inf': 'Infinitive', 'Part': 'Participle',
+ 'Ger': 'Gerund', 'Pres': 'Present', 'Past': 'Past', 'Fut': 'Future', 'Perf': 'Perfect', 'Imp': 'Imperfect'
+ },
+ 'fr': {
+ 'Gender': 'Genre', 'Number': 'Nombre', 'Case': 'Cas', 'Definite': 'Défini', 'PronType': 'Type de Pronom',
+ 'Person': 'Personne', 'Mood': 'Mode', 'Tense': 'Temps', 'VerbForm': 'Forme Verbale', 'Voice': 'Voix',
+ 'Fem': 'Féminin', 'Masc': 'Masculin', 'Sing': 'Singulier', 'Plur': 'Pluriel', 'Ind': 'Indicatif',
+ 'Sub': 'Subjonctif', 'Imp': 'Impératif', 'Inf': 'Infinitif', 'Part': 'Participe',
+ 'Ger': 'Gérondif', 'Pres': 'Présent', 'Past': 'Passé', 'Fut': 'Futur', 'Perf': 'Parfait', 'Imp': 'Imparfait'
+ }
+ }
+ for key, value in morph_translations[lang_code].items():
+ morph_string = morph_string.replace(key, value)
+ return morph_string
+
+ morph_df[t['morphology']] = morph_df[t['morphology']].apply(lambda x: translate_morph(x, lang_code))
+
+ # Seleccionar y ordenar las columnas a mostrar
+ columns_to_display = [t['word'], t['lemma'], t['grammatical_category'], t['dependency'], t['morphology']]
+ columns_to_display = [col for col in columns_to_display if col in morph_df.columns]
+
+ # Mostrar el DataFrame
+ st.dataframe(morph_df[columns_to_display])
+
+ # Mostrar diagramas de arco (código existente)
+ #with st.expander(t['arc_diagram'], expanded=True):
+ # sentences = list(doc.sents)
+ # arc_diagrams = []
+ # for i, sent in enumerate(sentences):
+ # st.subheader(f"{t['sentence']} {i+1}")
+ # html = displacy.render(sent, style="dep", options={"distance": 100})
+ # html = html.replace('height="375"', 'height="200"')
+ # html = re.sub(r'{POS_TRANSLATIONS[lang_code][pos]}
"
+ legend_html += "{concepts_str1}
", unsafe_allow_html=True)
+
+ if 'key_concepts2' in entry:
+ concepts_str2 = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts2']])
+ st.write("Conceptos clave del documento 2:")
+ #st.write(concepts_str2)
+ st.markdown(f"{concepts_str2}
", unsafe_allow_html=True)
+
+ try:
+ if 'combined_graph' in entry and entry['combined_graph']:
+ img_bytes = base64.b64decode(entry['combined_graph'])
+ st.image(img_bytes)
+ elif 'graph1' in entry and 'graph2' in entry:
+ col1, col2 = st.columns(2)
+ with col1:
+ if entry['graph1']:
+ img_bytes1 = base64.b64decode(entry['graph1'])
+ st.image(img_bytes1)
+ with col2:
+ if entry['graph2']:
+ img_bytes2 = base64.b64decode(entry['graph2'])
+ st.image(img_bytes2)
+ else:
+ st.write("No se encontraron gráficos para este análisis.")
+ except Exception as e:
+ st.error(f"No se pudieron mostrar los gráficos: {str(e)}")
+ st.write("Datos de los gráficos (para depuración):")
+ if 'graph1' in entry:
+ st.write("Graph 1:", entry['graph1'][:100] + "...")
+ if 'graph2' in entry:
+ st.write("Graph 2:", entry['graph2'][:100] + "...")
+ if 'combined_graph' in entry:
+ st.write("Combined Graph:", entry['combined_graph'][:100] + "...")
+
+##########################################################
+ with st.expander("Histórico de Conversaciones con el ChatBot"):
+ if 'chat_history' in student_data:
+ for i, chat in enumerate(student_data['chat_history']):
+ st.subheader(f"Conversación {i+1} - {chat['timestamp']}")
+ for message in chat['messages']:
+ if message['role'] == 'user':
+ st.write("Usuario: " + message['content'])
+ else:
+ st.write("Asistente: " + message['content'])
+ st.write("---")
+ else:
+ st.write("No se encontraron conversaciones con el ChatBot.")
+
+ # Añadir logs para depuración
+ if st.checkbox("Mostrar datos de depuración"):
+ st.write("Datos del estudiante (para depuración):")
+ st.json(student_data)
+
+##################################################################################################
+def display_morphosyntax_analysis_interface(nlp_models, lang_code):
+ translations = {
+ 'es': {
+ 'title': "AIdeaText - Análisis morfológico y sintáctico",
+ 'input_label': "Ingrese un texto para analizar (máximo 5,000 palabras",
+ 'input_placeholder': "Esta funcionalidad le ayudará con dos competencias:\n"
+ "[1] \"Escribe diversos tipos de textos en su lengua materna\"\n"
+ "[2] \"Lee diversos tipos de textos escritos en su lengua materna\"\n\n"
+ "Ingrese su texto aquí para analizar...",
+ 'analyze_button': "Analizar texto",
+ 'repeated_words': "Palabras repetidas",
+ 'legend': "Leyenda: Categorías gramaticales",
+ 'arc_diagram': "Análisis sintáctico: Diagrama de arco",
+ 'sentence': "Oración",
+ 'success_message': "Análisis guardado correctamente.",
+ 'error_message': "Hubo un problema al guardar el análisis. Por favor, inténtelo de nuevo.",
+ 'warning_message': "Por favor, ingrese un texto para analizar.",
+ 'initial_message': "Ingrese un texto y presione 'Analizar texto' para comenzar.",
+ 'no_results': "No hay resultados disponibles. Por favor, realice un análisis primero.",
+ 'pos_analysis': "Análisis de categorías gramaticales",
+ 'morphological_analysis': "Análisis morfológico",
+ 'sentence_structure': "Estructura de oraciones",
+ 'word': "Palabra",
+ 'count': "Cantidad",
+ 'percentage': "Porcentaje",
+ 'examples': "Ejemplos",
+ 'lemma': "Lema",
+ 'tag': "Etiqueta",
+ 'dep': "Dependencia",
+ 'morph': "Morfología",
+ 'root': "Raíz",
+ 'subjects': "Sujetos",
+ 'objects': "Objetos",
+ 'verbs': "Verbos",
+ 'grammatical_category': "Categoría gramatical",
+ 'dependency': "Dependencia",
+ 'morphology': "Morfología"
+ },
+ 'en': {
+ 'title': "AIdeaText - Morphological and Syntactic Analysis",
+ 'input_label': "Enter a text to analyze (max 5,000 words):",
+ 'input_placeholder': "This functionality will help you with two competencies:\n"
+ "[1] \"Write various types of texts in your native language\"\n"
+ "[2] \"Read various types of written texts in your native language\"\n\n"
+ "Enter your text here to analyze...",
+ 'analyze_button': "Analyze text",
+ 'repeated_words': "Repeated words",
+ 'legend': "Legend: Grammatical categories",
+ 'arc_diagram': "Syntactic analysis: Arc diagram",
+ 'sentence': "Sentence",
+ 'success_message': "Analysis saved successfully.",
+ 'error_message': "There was a problem saving the analysis. Please try again.",
+ 'warning_message': "Please enter a text to analyze.",
+ 'initial_message': "Enter a text and press 'Analyze text' to start.",
+ 'no_results': "No results available. Please perform an analysis first.",
+ 'pos_analysis': "Part of Speech Analysis",
+ 'morphological_analysis': "Morphological Analysis",
+ 'sentence_structure': "Sentence Structure",
+ 'word': "Word",
+ 'count': "Count",
+ 'percentage': "Percentage",
+ 'examples': "Examples",
+ 'lemma': "Lemma",
+ 'tag': "Tag",
+ 'dep': "Dependency",
+ 'morph': "Morphology",
+ 'root': "Root",
+ 'subjects': "Subjects",
+ 'objects': "Objects",
+ 'verbs': "Verbs",
+ 'grammatical_category': "Grammatical category",
+ 'dependency': "Dependency",
+ 'morphology': "Morphology"
+ },
+ 'fr': {
+ 'title': "AIdeaText - Analyse morphologique et syntaxique",
+ 'input_label': "Entrez un texte à analyser (max 5 000 mots) :",
+ 'input_placeholder': "Cette fonctionnalité vous aidera avec deux compétences :\n"
+ "[1] \"Écrire divers types de textes dans votre langue maternelle\"\n"
+ "[2] \"Lire divers types de textes écrits dans votre langue maternelle\"\n\n"
+ "Entrez votre texte ici pour l'analyser...",
+ 'analyze_button': "Analyser le texte",
+ 'repeated_words': "Mots répétés",
+ 'legend': "Légende : Catégories grammaticales",
+ 'arc_diagram': "Analyse syntaxique : Diagramme en arc",
+ 'sentence': "Phrase",
+ 'success_message': "Analyse enregistrée avec succès.",
+ 'error_message': "Un problème est survenu lors de l'enregistrement de l'analyse. Veuillez réessayer.",
+ 'warning_message': "Veuillez entrer un texte à analyser.",
+ 'initial_message': "Entrez un texte et appuyez sur 'Analyser le texte' pour commencer.",
+ 'no_results': "Aucun résultat disponible. Veuillez d'abord effectuer une analyse.",
+ 'pos_analysis': "Analyse des parties du discours",
+ 'morphological_analysis': "Analyse morphologique",
+ 'sentence_structure': "Structure des phrases",
+ 'word': "Mot",
+ 'count': "Nombre",
+ 'percentage': "Pourcentage",
+ 'examples': "Exemples",
+ 'lemma': "Lemme",
+ 'tag': "Étiquette",
+ 'dep': "Dépendance",
+ 'morph': "Morphologie",
+ 'root': "Racine",
+ 'subjects': "Sujets",
+ 'objects': "Objets",
+ 'verbs': "Verbes",
+ 'grammatical_category': "Catégorie grammaticale",
+ 'dependency': "Dépendance",
+ 'morphology': "Morphologie"
+ }
+ }
+
+ t = translations[lang_code]
+
+ input_key = f"morphosyntax_input_{lang_code}"
+
+ if input_key not in st.session_state:
+ st.session_state[input_key] = ""
+
+ sentence_input = st.text_area(
+ t['input_label'],
+ height=150,
+ placeholder=t['input_placeholder'],
+ value=st.session_state[input_key],
+ key=f"text_area_{lang_code}",
+ on_change=lambda: setattr(st.session_state, input_key, st.session_state[f"text_area_{lang_code}"])
+ )
+
+ if st.button(t['analyze_button'], key=f"analyze_button_{lang_code}"):
+ current_input = st.session_state[input_key]
+ if current_input:
+ doc = nlp_models[lang_code](current_input)
+
+ # Análisis morfosintáctico avanzado
+ advanced_analysis = perform_advanced_morphosyntactic_analysis(current_input, nlp_models[lang_code])
+
+ # Guardar el resultado en el estado de la sesión
+ st.session_state.morphosyntax_result = {
+ 'doc': doc,
+ 'advanced_analysis': advanced_analysis
+ }
+
+ # Mostrar resultados
+ display_morphosyntax_results(st.session_state.morphosyntax_result, lang_code, t)
+
+ # Guardar resultados
+ if store_morphosyntax_result(
+ st.session_state.username,
+ current_input,
+ get_repeated_words_colors(doc),
+ advanced_analysis['arc_diagram'],
+ advanced_analysis['pos_analysis'],
+ advanced_analysis['morphological_analysis'],
+ advanced_analysis['sentence_structure']
+ ):
+ st.success(t['success_message'])
+ else:
+ st.error(t['error_message'])
+ else:
+ st.warning(t['warning_message'])
+ elif 'morphosyntax_result' in st.session_state and st.session_state.morphosyntax_result is not None:
+
+ # Si hay un resultado guardado, mostrarlo
+ display_morphosyntax_results(st.session_state.morphosyntax_result, lang_code, t)
+ else:
+ st.info(t['initial_message']) # Añade esta traducción a tu diccionario
+
+#################################################################################################
+#################################################################################################
+def display_morphosyntax_results(result, lang_code, t):
+ if result is None:
+ st.warning(t['no_results']) # Añade esta traducción a tu diccionario
+ return
+
+ # doc = result['doc']
+ # advanced_analysis = result['advanced_analysis']
+ advanced_analysis = result
+
+ # Mostrar leyenda (código existente)
+ st.markdown(f"##### {t['legend']}")
+ legend_html = ""
+ for pos, color in POS_COLORS.items():
+ if pos in POS_TRANSLATIONS[lang_code]:
+ legend_html += f"
"
+ st.markdown(legend_html, unsafe_allow_html=True)
+
+ # Mostrar análisis de palabras repetidas (código existente)
+ if 'repeated_words' in advanced_analysis:
+ with st.expander(t['repeated_words'], expanded=True):
+ st.markdown(advanced_analysis['repeated_words'], unsafe_allow_html=True)
+
+ # Mostrar estructura de oraciones
+ if 'sentence_structure' in advanced_analysis:
+ 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)
+ else:
+ st.warning("No se encontró información sobre la estructura de las oraciones.")
+
+
+ # Mostrar análisis de categorías gramaticales # Mostrar análisis morfológico
+ col1, col2 = st.columns(2)
+
+ with col1:
+ with st.expander(t['pos_analysis'], expanded=True):
+ pos_df = pd.DataFrame(advanced_analysis['pos_analysis'])
+
+ # Traducir las etiquetas POS a sus nombres en el idioma seleccionado
+ pos_df['pos'] = pos_df['pos'].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+
+ # Renombrar las columnas para mayor claridad
+ pos_df = pos_df.rename(columns={
+ 'pos': t['grammatical_category'],
+ 'count': t['count'],
+ 'percentage': t['percentage'],
+ 'examples': t['examples']
+ })
+
+ # Mostrar el dataframe
+ st.dataframe(pos_df)
+
+ with col2:
+ with st.expander(t['morphological_analysis'], expanded=True):
+ morph_df = pd.DataFrame(advanced_analysis['morphological_analysis'])
+
+ # Definir el mapeo de columnas
+ column_mapping = {
+ 'text': t['word'],
+ 'lemma': t['lemma'],
+ 'pos': t['grammatical_category'],
+ 'dep': t['dependency'],
+ 'morph': t['morphology']
+ }
+
+ # Renombrar las columnas existentes
+ morph_df = morph_df.rename(columns={col: new_name for col, new_name in column_mapping.items() if col in morph_df.columns})
+
+ # Traducir las categorías gramaticales
+ morph_df[t['grammatical_category']] = morph_df[t['grammatical_category']].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
+
+ # Traducir las dependencias
+ dep_translations = {
+ 'es': {
+ 'ROOT': 'RAÍZ', 'nsubj': 'sujeto nominal', 'obj': 'objeto', 'iobj': 'objeto indirecto',
+ 'csubj': 'sujeto clausal', 'ccomp': 'complemento clausal', 'xcomp': 'complemento clausal abierto',
+ 'obl': 'oblicuo', 'vocative': 'vocativo', 'expl': 'expletivo', 'dislocated': 'dislocado',
+ 'advcl': 'cláusula adverbial', 'advmod': 'modificador adverbial', 'discourse': 'discurso',
+ 'aux': 'auxiliar', 'cop': 'cópula', 'mark': 'marcador', 'nmod': 'modificador nominal',
+ 'appos': 'aposición', 'nummod': 'modificador numeral', 'acl': 'cláusula adjetiva',
+ 'amod': 'modificador adjetival', 'det': 'determinante', 'clf': 'clasificador',
+ 'case': 'caso', 'conj': 'conjunción', 'cc': 'coordinante', 'fixed': 'fijo',
+ 'flat': 'plano', 'compound': 'compuesto', 'list': 'lista', 'parataxis': 'parataxis',
+ 'orphan': 'huérfano', 'goeswith': 'va con', 'reparandum': 'reparación', 'punct': 'puntuación'
+ },
+ 'en': {
+ 'ROOT': 'ROOT', 'nsubj': 'nominal subject', 'obj': 'object',
+ 'iobj': 'indirect object', 'csubj': 'clausal subject', 'ccomp': 'clausal complement', 'xcomp': 'open clausal complement',
+ 'obl': 'oblique', 'vocative': 'vocative', 'expl': 'expletive', 'dislocated': 'dislocated', 'advcl': 'adverbial clause modifier',
+ 'advmod': 'adverbial modifier', 'discourse': 'discourse element', 'aux': 'auxiliary', 'cop': 'copula', 'mark': 'marker',
+ 'nmod': 'nominal modifier', 'appos': 'appositional modifier', 'nummod': 'numeric modifier', 'acl': 'clausal modifier of noun',
+ 'amod': 'adjectival modifier', 'det': 'determiner', 'clf': 'classifier', 'case': 'case marking',
+ 'conj': 'conjunct', 'cc': 'coordinating conjunction', 'fixed': 'fixed multiword expression',
+ 'flat': 'flat multiword expression', 'compound': 'compound', 'list': 'list', 'parataxis': 'parataxis', 'orphan': 'orphan',
+ 'goeswith': 'goes with', 'reparandum': 'reparandum', 'punct': 'punctuation'
+ },
+ 'fr': {
+ 'ROOT': 'RACINE', 'nsubj': 'sujet nominal', 'obj': 'objet', 'iobj': 'objet indirect',
+ 'csubj': 'sujet phrastique', 'ccomp': 'complément phrastique', 'xcomp': 'complément phrastique ouvert', 'obl': 'oblique',
+ 'vocative': 'vocatif', 'expl': 'explétif', 'dislocated': 'disloqué', 'advcl': 'clause adverbiale', 'advmod': 'modifieur adverbial',
+ 'discourse': 'élément de discours', 'aux': 'auxiliaire', 'cop': 'copule', 'mark': 'marqueur', 'nmod': 'modifieur nominal',
+ 'appos': 'apposition', 'nummod': 'modifieur numéral', 'acl': 'clause relative', 'amod': 'modifieur adjectival', 'det': 'déterminant',
+ 'clf': 'classificateur', 'case': 'marqueur de cas', 'conj': 'conjonction', 'cc': 'coordination', 'fixed': 'expression figée',
+ 'flat': 'construction plate', 'compound': 'composé', 'list': 'liste', 'parataxis': 'parataxe', 'orphan': 'orphelin',
+ 'goeswith': 'va avec', 'reparandum': 'réparation', 'punct': 'ponctuation'
+ }
+ }
+ morph_df[t['dependency']] = morph_df[t['dependency']].map(lambda x: dep_translations[lang_code].get(x, x))
+
+ # Traducir la morfología
+ def translate_morph(morph_string, lang_code):
+ morph_translations = {
+ 'es': {
+ 'Gender': 'Género', 'Number': 'Número', 'Case': 'Caso', 'Definite': 'Definido',
+ 'PronType': 'Tipo de Pronombre', 'Person': 'Persona', 'Mood': 'Modo',
+ 'Tense': 'Tiempo', 'VerbForm': 'Forma Verbal', 'Voice': 'Voz',
+ 'Fem': 'Femenino', 'Masc': 'Masculino', 'Sing': 'Singular', 'Plur': 'Plural',
+ 'Ind': 'Indicativo', 'Sub': 'Subjuntivo', 'Imp': 'Imperativo', 'Inf': 'Infinitivo',
+ 'Part': 'Participio', 'Ger': 'Gerundio', 'Pres': 'Presente', 'Past': 'Pasado',
+ 'Fut': 'Futuro', 'Perf': 'Perfecto', 'Imp': 'Imperfecto'
+ },
+ 'en': {
+ 'Gender': 'Gender', 'Number': 'Number', 'Case': 'Case', 'Definite': 'Definite', 'PronType': 'Pronoun Type', 'Person': 'Person',
+ 'Mood': 'Mood', 'Tense': 'Tense', 'VerbForm': 'Verb Form', 'Voice': 'Voice',
+ 'Fem': 'Feminine', 'Masc': 'Masculine', 'Sing': 'Singular', 'Plur': 'Plural', 'Ind': 'Indicative',
+ 'Sub': 'Subjunctive', 'Imp': 'Imperative', 'Inf': 'Infinitive', 'Part': 'Participle',
+ 'Ger': 'Gerund', 'Pres': 'Present', 'Past': 'Past', 'Fut': 'Future', 'Perf': 'Perfect', 'Imp': 'Imperfect'
+ },
+ 'fr': {
+ 'Gender': 'Genre', 'Number': 'Nombre', 'Case': 'Cas', 'Definite': 'Défini', 'PronType': 'Type de Pronom',
+ 'Person': 'Personne', 'Mood': 'Mode', 'Tense': 'Temps', 'VerbForm': 'Forme Verbale', 'Voice': 'Voix',
+ 'Fem': 'Féminin', 'Masc': 'Masculin', 'Sing': 'Singulier', 'Plur': 'Pluriel', 'Ind': 'Indicatif',
+ 'Sub': 'Subjonctif', 'Imp': 'Impératif', 'Inf': 'Infinitif', 'Part': 'Participe',
+ 'Ger': 'Gérondif', 'Pres': 'Présent', 'Past': 'Passé', 'Fut': 'Futur', 'Perf': 'Parfait', 'Imp': 'Imparfait'
+ }
+ }
+ for key, value in morph_translations[lang_code].items():
+ morph_string = morph_string.replace(key, value)
+ return morph_string
+
+ morph_df[t['morphology']] = morph_df[t['morphology']].apply(lambda x: translate_morph(x, lang_code))
+
+ # Seleccionar y ordenar las columnas a mostrar
+ columns_to_display = [t['word'], t['lemma'], t['grammatical_category'], t['dependency'], t['morphology']]
+ columns_to_display = [col for col in columns_to_display if col in morph_df.columns]
+
+ # Mostrar el DataFrame
+ st.dataframe(morph_df[columns_to_display])
+
+ # Mostrar diagramas de arco (código existente)
+ #with st.expander(t['arc_diagram'], expanded=True):
+ # sentences = list(doc.sents)
+ # arc_diagrams = []
+ # for i, sent in enumerate(sentences):
+ # st.subheader(f"{t['sentence']} {i+1}")
+ # html = displacy.render(sent, style="dep", options={"distance": 100})
+ # html = html.replace('height="375"', 'height="200"')
+ # html = re.sub(r'{POS_TRANSLATIONS[lang_code][pos]}
"
+ legend_html += "