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/modules/email/txt.txt b/modules/email/txt.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/modules/lost.py b/modules/lost.py new file mode 100644 index 0000000000000000000000000000000000000000..9a5a4fee0812e6dae79d898d23afedd8355961bd --- /dev/null +++ b/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/modules/morphosyntax/__init__.py b/modules/morphosyntax/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/modules/morphosyntax/__pycache__/__init__.cpython-311.pyc b/modules/morphosyntax/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d1de440bb8567809c523502b8eb53e8cbc879140 Binary files /dev/null and b/modules/morphosyntax/__pycache__/__init__.cpython-311.pyc differ diff --git a/modules/morphosyntax/__pycache__/morphosyntax_interface.cpython-311.pyc b/modules/morphosyntax/__pycache__/morphosyntax_interface.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..31626a87d30b5ef698ab28d4e18280c2ab3b2878 Binary files /dev/null and b/modules/morphosyntax/__pycache__/morphosyntax_interface.cpython-311.pyc differ diff --git a/modules/morphosyntax/__pycache__/morphosyntax_process.cpython-311.pyc b/modules/morphosyntax/__pycache__/morphosyntax_process.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46b24c65f61758eaa702d506363ec7f9d05ceeaa Binary files /dev/null and b/modules/morphosyntax/__pycache__/morphosyntax_process.cpython-311.pyc differ diff --git a/modules/morphosyntax/morphosyntax_interface-Back1910-25-9-24.py b/modules/morphosyntax/morphosyntax_interface-Back1910-25-9-24.py new file mode 100644 index 0000000000000000000000000000000000000000..e8bb9d5dda50e6e595246de2a292bf0e3fa4536d --- /dev/null +++ b/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/modules/morphosyntax/morphosyntax_interface.py b/modules/morphosyntax/morphosyntax_interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..6584642d36e300db456639bf5f83d1e14a02ed12
--- /dev/null
+++ b/modules/morphosyntax/morphosyntax_interface.py
@@ -0,0 +1,184 @@
+#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.morphosintax_mongo_db import store_student_morphosyntax_result
+from ..database.chat_db import store_chat_history
+from ..database.morphosintaxis_export import export_user_interactions
+
+import logging
+logger = logging.getLogger(__name__)
+
+def display_morphosyntax_interface(lang_code, nlp_models, t):
+ st.title("Análisis Morfosintáctico")
+
+ # Contenedor para el historial del chat
+ chat_container = st.container()
+
+ # Input del usuario (siempre visible en la parte inferior)
+ user_input = st.chat_input(t['morpho_input_label'])
+
+ # Procesar el input del usuario
+ if user_input:
+ # Añadir el mensaje del usuario al historial
+ st.session_state.morphosyntax_chat_history.append({"role": "user", "content": user_input})
+ store_chat_history(st.session_state.username, [{"role": "user", "content": user_input}], "morphosyntax")
+
+ response, visualizations, result = process_morphosyntactic_input(user_input, lang_code, nlp_models, t)
+
+ # Añadir la respuesta al historial
+ assistant_message = {
+ "role": "assistant",
+ "content": response,
+ "visualizations": visualizations if visualizations else []
+ }
+ st.session_state.morphosyntax_chat_history.append(assistant_message)
+ store_chat_history(st.session_state.username, [assistant_message], "morphosyntax")
+
+ # Si es un análisis, guardarlo en la base de datos
+ if user_input.startswith('/analisis_morfosintactico') and result:
+ store_student_morphosyntax_result(
+ st.session_state.username,
+ user_input.split('[', 1)[1].rsplit(']', 1)[0], # texto analizado
+ visualizations
+ )
+
+ # Mostrar el historial del chat
+ with chat_container:
+ if 'morphosyntax_chat_history' not in st.session_state:
+ st.session_state.morphosyntax_chat_history = []
+ for message in st.session_state.morphosyntax_chat_history:
+ with st.chat_message(message["role"]):
+ st.write(message["content"])
+ if "visualizations" in message and message["visualizations"]:
+ for i, viz in enumerate(message["visualizations"]):
+ st.markdown(f"**Oración {i+1} del párrafo analizado**")
+ st.components.v1.html(
+ f"""
+
+ {viz}
+
+
+
+ """,
+ height=370,
+ scrolling=True
+ )
+ if i < len(message["visualizations"]) - 1:
+ st.markdown("---") # Separador entre diagramas
+
+ # 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()
+
+ # Botón de exportación
+ if st.button("Exportar Interacciones"):
+ pdf_buffer = export_user_interactions(st.session_state.username, 'morphosyntax')
+ st.download_button(
+ label="Descargar PDF",
+ data=pdf_buffer,
+ file_name="interacciones_morfosintaxis.pdf",
+ mime="application/pdf"
+ )
+
+'''
+ 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 nuevo al 26-9-2024
+ response, visualizations, result = process_morphosyntactic_input(user_input, lang_code, nlp_models, t)
+
+ # 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.markdown(f"**Oración {i+1} del párrafo analizado**")
+ st.components.v1.html(
+ f"""
+
+ {viz}
+
+
+
+ """,
+ height=350,
+ scrolling=True
+ )
+ if i < len(visualizations) - 1:
+ st.markdown("---") # Separador entre diagramas
+
+ # 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)}")
+
+
+
+ # 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/modules/morphosyntax/morphosyntax_process-Back1910-25-9-24.py b/modules/morphosyntax/morphosyntax_process-Back1910-25-9-24.py
new file mode 100644
index 0000000000000000000000000000000000000000..191855b00ca8237f7dfd88afc925a314e82a2dc4
--- /dev/null
+++ b/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/modules/morphosyntax/morphosyntax_process.py b/modules/morphosyntax/morphosyntax_process.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfdc1fde99f3c1d52a19832917b980ed85aee0cc
--- /dev/null
+++ b/modules/morphosyntax/morphosyntax_process.py
@@ -0,0 +1,29 @@
+#modules/morphosyntax/morphosyntax_process.py
+import streamlit as st
+from ..text_analysis.morpho_analysis import perform_advanced_morphosyntactic_analysis
+from ..database.morphosintax_mongo_db import store_student_morphosyntax_result
+from ..chatbot.chatbot import process_chat_input
+
+def process_morphosyntactic_input(user_input, lang_code, nlp_models, t):
+ if user_input.startswith('/analisis_morfosintactico'):
+ text_to_analyze = user_input.split('[', 1)[1].rsplit(']', 1)[0]
+ result = perform_advanced_morphosyntactic_analysis(text_to_analyze, nlp_models[lang_code])
+
+ if result is None or 'arc_diagrams' not in result:
+ response = t.get('morphosyntactic_analysis_error', 'Error in morphosyntactic analysis')
+ return response, None, None
+
+ response = t.get('morphosyntactic_analysis_completed', 'Morphosyntactic analysis completed')
+ visualizations = result['arc_diagrams']
+
+ store_student_morphosyntax_result(
+ st.session_state.username,
+ text_to_analyze,
+ visualizations
+ )
+
+ return response, visualizations, result
+ else:
+ chatbot = st.session_state.morphosyntax_chat_input
+ response = chatbot.generate_response(user_input, lang_code)
+ return response, None, None
diff --git a/modules/morphosyntax/txt.txt b/modules/morphosyntax/txt.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/semantic/__init_.py b/modules/semantic/__init_.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc04bf76fe89672037c58d29484d6533457b2b07
--- /dev/null
+++ b/modules/semantic/__init_.py
@@ -0,0 +1 @@
+from .flexible_analysis_handler import FlexibleAnalysisHandler
\ No newline at end of file
diff --git a/modules/semantic/__pycache__/flexible_analysis_handler.cpython-311.pyc b/modules/semantic/__pycache__/flexible_analysis_handler.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ee65f50c83dd3bfd0530139fa905960ce57b8a24
Binary files /dev/null and b/modules/semantic/__pycache__/flexible_analysis_handler.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_float.cpython-311.pyc b/modules/semantic/__pycache__/semantic_float.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..afb9426ea5597b3d85ac0f0500d665a49b1a147b
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_float.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_float68ok.cpython-311.pyc b/modules/semantic/__pycache__/semantic_float68ok.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2736c7be7b369af9c9368810c98d590ef66db70e
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_float68ok.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_float86ok.cpython-311.pyc b/modules/semantic/__pycache__/semantic_float86ok.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0640e8983813bc16ee13251e6d6d65ffa23c823a
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_float86ok.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_float_reset.cpython-311.pyc b/modules/semantic/__pycache__/semantic_float_reset.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..021862ba760cca86a770a4d0c46349894e389ae6
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_float_reset.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c8a9a3c5527bfc1667cf12cb816298b9b8dc4314
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interfaceBackUp_2092024_1800.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interfaceBackUp_2092024_1800.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b49443b6b818aef2248867278c43369ca51a662
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interfaceBackUp_2092024_1800.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interfaceBorrados.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interfaceBorrados.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ef8bf460009df8fd59e3d489ebdce3163f2588f6
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interfaceBorrados.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interfaceKoKo.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interfaceKoKo.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8c42b43be508ed128eac77ae0f753dc575a9113e
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interfaceKoKo.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_1.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_1.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c9f0fef968b2f37b43dfc116c5f2ce2eb3d9e099
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_1.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_2.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..46222222f83623c6b7de8bb0a92c634af86f8744
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_2.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_2192024_1632.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_2192024_1632.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7d62dabaaf573d5de0a760a242a43332955c9f36
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_2192024_1632.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_3.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b9b5eec9852b9159bbf76c1f7d8482108c099803
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_3.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_4.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_4.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..701cbc0e83a28b4a25fd8aa80465fd5e79e7b01a
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_4.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_5.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_5.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..52ee832d6ece08e1f92d23f223e56796b1a2cc54
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_5.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_6.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_6.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dcbe12108da351a568e772abfbb883d25b08c517
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_6.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_61.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_61.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..386c8ac736aeeb2a120880d3e6bfae0facc9f7f2
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_61.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_610.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_610.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f60c48f197a142f57c9f59cb1055ae57db32407f
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_610.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_62.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_62.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fedd207e2531dc00d3ee98645be42383e194e8db
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_62.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_63.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_63.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..78b98d5ffad8ec43b02cdcafab3a6752e4a27ef7
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_63.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_64.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_64.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e94c4a23f3a5c2098964ce3f8d5d67d561e0a944
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_64.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_65.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_65.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e45c7073838ffe64539d9470f4efecc2dad75b0
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_65.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_66.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_66.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0bd5c0b21aba6451de1963b18e79e2e8121f69f0
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_66.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_67.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_67.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4fa300c5559d94da29f1c2dc3a5c0712e028ea6f
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_67.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_68.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_68.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5bc6395eabbac5e54d20a38a4eb1aaf61e4e171e
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_68.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_681.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_681.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d13664fec98f1609721ede6a5ab8abf88480f375
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_681.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_68ok.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_68ok.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..85965738ee096cba107008fa62c5d60004d3fad7
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_68ok.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_69.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_69.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..66c5867ad061bca00a6ec984d824ea694fe26adc
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_69.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_7.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_7.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ef2c5bc6d30879a47186e7e17858e0b3a001bb04
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_7.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_StreamLitChat.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_StreamLitChat.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d43c979fafff38614b9565936d755342894b7abf
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_StreamLitChat.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_Test.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_Test.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5c14d8bf89c9a1e8f5887e40f3c307ea0f43fbf
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_Test.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_afterParty.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_afterParty.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cce4f330ccd69352a6f6ec411dfa26d5fd01789c
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_afterParty.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_backup2092024_1930.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_backup2092024_1930.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7940c44b2027728a9e8478d2c5a508ed44070469
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_backup2092024_1930.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_backup_2092024.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_backup_2092024.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3db97b9995c894928a31892cda744d6c4da483f9
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_backup_2092024.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_backup_2192024_1230.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_backup_2192024_1230.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..64b09631b0b72880568c8077ba29bb75283d88c1
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_backup_2192024_1230.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_interface_vOk.cpython-311.pyc b/modules/semantic/__pycache__/semantic_interface_vOk.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c9f2fa094a416e6429b9a3bccb0312558c955c02
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_interface_vOk.cpython-311.pyc differ
diff --git a/modules/semantic/__pycache__/semantic_process.cpython-311.pyc b/modules/semantic/__pycache__/semantic_process.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58e1056dd70a702aa4ea3f67e4ff20e54923fd9c
Binary files /dev/null and b/modules/semantic/__pycache__/semantic_process.cpython-311.pyc differ
diff --git a/modules/semantic/flexible_analysis_handler.py b/modules/semantic/flexible_analysis_handler.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e4396ab87a2a3559c06d41b388e7cdc4b843048
--- /dev/null
+++ b/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/modules/semantic/logV6ite5.txt b/modules/semantic/logV6ite5.txt
new file mode 100644
index 0000000000000000000000000000000000000000..27ff0010ade774a6e958f97c6f380c6b08050b14
--- /dev/null
+++ b/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':
+ {viz}
+
+
+
+
+ """, 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/modules/semantic/semantic_float68ok.py b/modules/semantic/semantic_float68ok.py
new file mode 100644
index 0000000000000000000000000000000000000000..a57a08d49e3c3945b90a1a358305e520a6e1d650
--- /dev/null
+++ b/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/modules/semantic/semantic_float_old.py b/modules/semantic/semantic_float_old.py
new file mode 100644
index 0000000000000000000000000000000000000000..192c7a46004ab8b35c2046cde482a001088475c7
--- /dev/null
+++ b/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/modules/semantic/semantic_float_reset.py b/modules/semantic/semantic_float_reset.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d782eb27f4493283de556391ef49334ed6e7256
--- /dev/null
+++ b/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/modules/semantic/semantic_float_reset_23-9-2024.py b/modules/semantic/semantic_float_reset_23-9-2024.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d8fb602fec66518348fcfa37e1a272284a7adf4
--- /dev/null
+++ b/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/modules/semantic/semantic_interfaceBackUp_2092024_1800.py b/modules/semantic/semantic_interfaceBackUp_2092024_1800.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9ef8533a44841e7fdcc66abd8b4c7a25b9e2914
--- /dev/null
+++ b/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/modules/semantic/semantic_interfaceBorrados.py b/modules/semantic/semantic_interfaceBorrados.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b2167adff34762e28fbd9ee65c64dd371ef713c
--- /dev/null
+++ b/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/modules/semantic/semantic_interfaceKoKo.py b/modules/semantic/semantic_interfaceKoKo.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a704b30129e521564b9222face9ec5c818bafea
--- /dev/null
+++ b/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/modules/semantic/semantic_interfaceSideBar.py b/modules/semantic/semantic_interfaceSideBar.py new file mode 100644 index 0000000000000000000000000000000000000000..79f0777328d68330ea531f7104abbf8a4ab0fdfb --- /dev/null +++ b/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/modules/semantic/semantic_interface_1.py b/modules/semantic/semantic_interface_1.py new file mode 100644 index 0000000000000000000000000000000000000000..432858c935c551fef038a0d87eebc8602e139672 --- /dev/null +++ b/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/modules/semantic/semantic_interface_2.py b/modules/semantic/semantic_interface_2.py new file mode 100644 index 0000000000000000000000000000000000000000..351f0319ae784b409a289b112c79caac25a3fbc3 --- /dev/null +++ b/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/modules/semantic/semantic_interface_2192024_1632.py b/modules/semantic/semantic_interface_2192024_1632.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd2aff2f6a40d46999fd4548dd5697dd09f16e80
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_3.py b/modules/semantic/semantic_interface_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0f4b7392ea4e041d6885d07aa76e8209c6d03a9
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_4.py b/modules/semantic/semantic_interface_4.py
new file mode 100644
index 0000000000000000000000000000000000000000..e984b533ef5c21debf78bf317456523ffa13928a
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_5.py b/modules/semantic/semantic_interface_5.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9d8a0e565a92c0c140a7af0f672cf489b50ddb9
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_6.py b/modules/semantic/semantic_interface_6.py
new file mode 100644
index 0000000000000000000000000000000000000000..38df59957615774686e19ed33325ff346f948c7b
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_61.py b/modules/semantic/semantic_interface_61.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2ac1e16628009ab14da1eb7cf94c967a22805ea
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_610.py b/modules/semantic/semantic_interface_610.py
new file mode 100644
index 0000000000000000000000000000000000000000..7584017bdca599b7345e9728e5cdd887be94c885
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_62.py b/modules/semantic/semantic_interface_62.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cf56020a9772617f5f09a69450887c7e50614a8
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_63.py b/modules/semantic/semantic_interface_63.py
new file mode 100644
index 0000000000000000000000000000000000000000..c32cf8d098b8ffb30163db19deef434fb2653d50
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_64.py b/modules/semantic/semantic_interface_64.py
new file mode 100644
index 0000000000000000000000000000000000000000..731678c700b81bdb8043dfa75ef875544ef44860
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_65.py b/modules/semantic/semantic_interface_65.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ea2f629e954c34ed7407e1d06241dc5040f1879
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_66.py b/modules/semantic/semantic_interface_66.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfa57fb062f09215e606e80cdbe9dfdacfcda759
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_67.py b/modules/semantic/semantic_interface_67.py
new file mode 100644
index 0000000000000000000000000000000000000000..952286e515d0b2aaded7d0e4ae21e5d4f6de8115
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_68.py b/modules/semantic/semantic_interface_68.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d76233b4405d8e141d906c75f98c4cba2cb822e
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_681.py b/modules/semantic/semantic_interface_681.py
new file mode 100644
index 0000000000000000000000000000000000000000..9384c9f712a4145c14d5d43a1657e11e92cbeaea
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_681_23-9-24.py b/modules/semantic/semantic_interface_681_23-9-24.py
new file mode 100644
index 0000000000000000000000000000000000000000..69477b49cf6dd9be21b06e330813aa2fe274e3ec
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_68ok copy.py b/modules/semantic/semantic_interface_68ok copy.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc16cf6f6c19e45753d432af4e13c32f5880841a
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_68ok.py b/modules/semantic/semantic_interface_68ok.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a34d56f794a81dca38b251a21fba4ca16b5a6ad
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_68okBackUp.py b/modules/semantic/semantic_interface_68okBackUp.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8d8eaeafca312b1fa3d6ef2fc81bf2bf7a844ad
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_69.py b/modules/semantic/semantic_interface_69.py
new file mode 100644
index 0000000000000000000000000000000000000000..9491c4a0cd7e20c82eeb3bed69d2f3417e92e1d4
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_6_Ok-23-9-24.py b/modules/semantic/semantic_interface_6_Ok-23-9-24.py
new file mode 100644
index 0000000000000000000000000000000000000000..bcefdcf92a7c7f4f828d3ca74a88cd0132c3c27a
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_6_StarPoint.py b/modules/semantic/semantic_interface_6_StarPoint.py
new file mode 100644
index 0000000000000000000000000000000000000000..b251f023c01e4c0d042605a5a97477c2269670e9
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_7.py b/modules/semantic/semantic_interface_7.py
new file mode 100644
index 0000000000000000000000000000000000000000..650182ceb40ce32885615517efeb32786009d996
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_Despu\303\251s.py" "b/modules/semantic/semantic_interface_Despu\303\251s.py"
new file mode 100644
index 0000000000000000000000000000000000000000..2d289197b51402d9a108eacfd06668a2394fbdfe
--- /dev/null
+++ "b/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/modules/semantic/semantic_interface_StreamLitChat.py b/modules/semantic/semantic_interface_StreamLitChat.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0eb527289912cd0295833c4e93cd2e91bd3b6d2
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_Test.py b/modules/semantic/semantic_interface_Test.py
new file mode 100644
index 0000000000000000000000000000000000000000..435d574d8c6ff1b985807249e9a02061e0bd4a54
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_afterParty.py b/modules/semantic/semantic_interface_afterParty.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d289197b51402d9a108eacfd06668a2394fbdfe
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_backup2092024_1930 copy.py b/modules/semantic/semantic_interface_backup2092024_1930 copy.py
new file mode 100644
index 0000000000000000000000000000000000000000..fab61a80830dc404e0c3d7694f93803f900061b5
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_backup2092024_1930.py b/modules/semantic/semantic_interface_backup2092024_1930.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d97ce833c0da8a58ea642ca760ba50503b998a9
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_backup_2092024.py b/modules/semantic/semantic_interface_backup_2092024.py
new file mode 100644
index 0000000000000000000000000000000000000000..549e15f8d5e26c1ecfbe0bff01c05f539da7a296
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_backup_2192024_1230.py b/modules/semantic/semantic_interface_backup_2192024_1230.py
new file mode 100644
index 0000000000000000000000000000000000000000..241407616ae3ce590be4cb7268b82eef2325d8a8
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_chatforup.py b/modules/semantic/semantic_interface_chatforup.py
new file mode 100644
index 0000000000000000000000000000000000000000..47c5d8789c4fa9de0c544bad98ecc137cfc2825c
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_stcontainerforchat.py b/modules/semantic/semantic_interface_stcontainerforchat.py
new file mode 100644
index 0000000000000000000000000000000000000000..47c5d8789c4fa9de0c544bad98ecc137cfc2825c
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_test610.py b/modules/semantic/semantic_interface_test610.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ae439ec0086c3baa0bc74374358a81e8f865135
--- /dev/null
+++ b/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/modules/semantic/semantic_interface_vOk.py b/modules/semantic/semantic_interface_vOk.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b2167adff34762e28fbd9ee65c64dd371ef713c
--- /dev/null
+++ b/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/modules/semantic/semantic_process.py b/modules/semantic/semantic_process.py
new file mode 100644
index 0000000000000000000000000000000000000000..0245b0dfc24145b2c34195057173298942d7584b
--- /dev/null
+++ b/modules/semantic/semantic_process.py
@@ -0,0 +1,51 @@
+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):
+ return base64.b64encode(image_data).decode('utf-8')
+
+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)
+
+ concept_graph = result['concept_graph']
+ entity_graph = result['entity_graph']
+ key_concepts = result['key_concepts']
+
+ # Convertir los gráficos a base64
+ concept_graph_base64 = encode_image_to_base64(concept_graph)
+ entity_graph_base64 = encode_image_to_base64(entity_graph)
+
+ logger.info("Semantic analysis processing completed successfully")
+ logger.debug(f"Concept graph base64 (first 100 chars): {concept_graph_base64[:100]}")
+ 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, []
+
+'''
+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/modules/semantic/semantic_process_23-9-24.py b/modules/semantic/semantic_process_23-9-24.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f3a7adb62c8f15ccd4616fd3e4b20beddf33be3
--- /dev/null
+++ b/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/modules/studentact/__pycache__/student_activities.cpython-311.pyc b/modules/studentact/__pycache__/student_activities.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e2b820fda86da0621440ebd0d0aabd60e9e259d
Binary files /dev/null and b/modules/studentact/__pycache__/student_activities.cpython-311.pyc differ
diff --git a/modules/studentact/__pycache__/student_activities_v2.cpython-311.pyc b/modules/studentact/__pycache__/student_activities_v2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6b2ea707d57df5d3e7a4171dd1065ddf0c25bdd9
Binary files /dev/null and b/modules/studentact/__pycache__/student_activities_v2.cpython-311.pyc differ
diff --git a/modules/studentact/student_activities.py b/modules/studentact/student_activities.py
new file mode 100644
index 0000000000000000000000000000000000000000..1103fcd6e3d21d097845c1be5b161ecb6431d967
--- /dev/null
+++ b/modules/studentact/student_activities.py
@@ -0,0 +1,105 @@
+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.chat_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/modules/studentact/student_activities_v2.py b/modules/studentact/student_activities_v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2b3eb6913e28d7ad6e0eb71026980019f970202
--- /dev/null
+++ b/modules/studentact/student_activities_v2.py
@@ -0,0 +1,668 @@
+##############
+#########student_activities.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
+
+logger = logging.getLogger(__name__)
+
+###################################################################################
+
+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 username['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 username['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 username['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 username and username['chat_history']:
+ for i, chat in enumerate(username['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(username)
+
+ # Mostrar conteo de tipos de análisis
+ analysis_types = [entry['analysis_type'] for entry in username['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)
+
+
+
+
+'''
+##########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/modules/text_analysis/__init__.py b/modules/text_analysis/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/text_analysis/__pycache__/__init__.cpython-311.pyc b/modules/text_analysis/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e7768ec60cb4a06cdaec79228f7036c906df7b0
Binary files /dev/null and b/modules/text_analysis/__pycache__/__init__.cpython-311.pyc differ
diff --git a/modules/text_analysis/__pycache__/discourse_analysis.cpython-311.pyc b/modules/text_analysis/__pycache__/discourse_analysis.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5f526ab04a41ca07b198c4e4aaf1337b595c5f33
Binary files /dev/null and b/modules/text_analysis/__pycache__/discourse_analysis.cpython-311.pyc differ
diff --git a/modules/text_analysis/__pycache__/morpho_analysis.cpython-311.pyc b/modules/text_analysis/__pycache__/morpho_analysis.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d74855a63b98e328d11eb2b08352b26f31a23655
Binary files /dev/null and b/modules/text_analysis/__pycache__/morpho_analysis.cpython-311.pyc differ
diff --git a/modules/text_analysis/__pycache__/semantic_analysis.cpython-311.pyc b/modules/text_analysis/__pycache__/semantic_analysis.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..53c63e092b99349668b992be27100905c36bb707
Binary files /dev/null and b/modules/text_analysis/__pycache__/semantic_analysis.cpython-311.pyc differ
diff --git a/modules/text_analysis/coherence_analysis.py b/modules/text_analysis/coherence_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..d3f5a12faa99758192ecc4ed3fc22c9249232e86
--- /dev/null
+++ b/modules/text_analysis/coherence_analysis.py
@@ -0,0 +1 @@
+
diff --git a/modules/text_analysis/complex_structures.py b/modules/text_analysis/complex_structures.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/text_analysis/discourse_analysis.py b/modules/text_analysis/discourse_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1e19717a070b495c8e26314aeb2e4501b5c8fdb
--- /dev/null
+++ b/modules/text_analysis/discourse_analysis.py
@@ -0,0 +1,72 @@
+import streamlit as st
+import spacy
+import networkx as nx
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+from .semantic_analysis import (
+ create_concept_graph,
+ visualize_concept_graph,
+ identify_key_concepts,
+ POS_COLORS,
+ POS_TRANSLATIONS,
+ ENTITY_LABELS
+)
+
+def compare_semantic_analysis(text1, text2, nlp, lang):
+ doc1 = nlp(text1)
+ doc2 = nlp(text2)
+
+ # Identificar conceptos clave para ambos documentos
+ key_concepts1 = identify_key_concepts(doc1)
+ key_concepts2 = identify_key_concepts(doc2)
+
+ # Crear grafos de conceptos para ambos documentos
+ G1 = create_concept_graph(doc1, key_concepts1)
+ G2 = create_concept_graph(doc2, key_concepts2)
+
+ # Visualizar los grafos de conceptos
+ fig1 = visualize_concept_graph(G1, lang)
+ fig2 = visualize_concept_graph(G2, lang)
+
+ # Remover los títulos superpuestos
+ fig1.suptitle("")
+ fig2.suptitle("")
+
+ return fig1, fig2, key_concepts1, key_concepts2
+
+def create_concept_table(key_concepts):
+ df = pd.DataFrame(key_concepts, columns=['Concepto', 'Frecuencia'])
+ df['Frecuencia'] = df['Frecuencia'].round(2)
+ return df
+
+def perform_discourse_analysis(text1, text2, nlp, lang):
+ graph1, graph2, key_concepts1, key_concepts2 = compare_semantic_analysis(text1, text2, nlp, lang)
+
+ # Crear tablas de conceptos clave
+ table1 = create_concept_table(key_concepts1)
+ table2 = create_concept_table(key_concepts2)
+
+ return {
+ 'graph1': graph1,
+ 'graph2': graph2,
+ 'key_concepts1': key_concepts1,
+ 'key_concepts2': key_concepts2
+ }
+
+def display_discourse_analysis_results(analysis_result, lang_code):
+ t = get_translations(lang_code)
+
+ col1, col2 = st.columns(2)
+
+ with col1:
+ with st.expander(t['doc1_title'], expanded=True):
+ st.pyplot(analysis_result['graph1'])
+ st.subheader(t['key_concepts'])
+ st.table(analysis_result['table1'])
+
+ with col2:
+ with st.expander(t['doc2_title'], expanded=True):
+ st.pyplot(analysis_result['graph2'])
+ st.subheader(t['key_concepts'])
+ st.table(analysis_result['table2'])
\ No newline at end of file
diff --git a/modules/text_analysis/entity_analysis.py b/modules/text_analysis/entity_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/text_analysis/idiom_detection.py b/modules/text_analysis/idiom_detection.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/text_analysis/intertextual_analysis.py b/modules/text_analysis/intertextual_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/text_analysis/morpho_analysis-Back1910-25-9-24.py b/modules/text_analysis/morpho_analysis-Back1910-25-9-24.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a0823063d965ac2ca3715fc1484046dd8be39a6
--- /dev/null
+++ b/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''
+'''
+
+
+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/modules/text_analysis/structure_analysis.py b/modules/text_analysis/structure_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/text_analysis/style_analysis.py b/modules/text_analysis/style_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/text_analysis/thematic_analysis.py b/modules/text_analysis/thematic_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/text_analysis/txt.txt b/modules/text_analysis/txt.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/text_analysis/vocabulary_analysis.py b/modules/text_analysis/vocabulary_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/ui/__init__.py b/modules/ui/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/ui/__pycache__/__init__.cpython-311.pyc b/modules/ui/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ac9684e4704cf8e942f2a15e5fea186fe3be7a0
Binary files /dev/null and b/modules/ui/__pycache__/__init__.cpython-311.pyc differ
diff --git a/modules/ui/__pycache__/ui.cpython-311.pyc b/modules/ui/__pycache__/ui.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dcda6c057d448090e4adece4b140c7714344d570
Binary files /dev/null and b/modules/ui/__pycache__/ui.cpython-311.pyc differ
diff --git a/modules/ui/txt.txt b/modules/ui/txt.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/modules/ui/ui backUpError_24-9-24.py b/modules/ui/ui backUpError_24-9-24.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5ce2b4a89d3c1f9bba42093a838ff9b97f7cc17
--- /dev/null
+++ b/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/modules/ui/ui.py b/modules/ui/ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc326b7f57627b9815546d5db4a06ec668705f94
--- /dev/null
+++ b/modules/ui/ui.py
@@ -0,0 +1,313 @@
+# Importaciones generales
+import streamlit as st
+from streamlit_player import st_player
+import logging
+from datetime import datetime, timezone
+from dateutil.parser import parse
+
+# Configuración del logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Importaciones locales
+from session_state import initialize_session_state, logout
+
+from translations import get_translations
+
+from ..studentact.student_activities import display_student_progress
+
+from ..auth.auth import authenticate_user, authenticate_student, authenticate_admin
+
+from ..admin.admin_ui import admin_page
+
+##Importaciones desde la configuración de bases datos #######
+
+from ..database.sql_db import (
+ store_application_request,
+ store_student_feedback,
+ store_application_request
+)
+
+from ..database.mongo_db import (
+ get_collection,
+ insert_document,
+ find_documents,
+ update_document,
+ delete_document
+)
+
+from ..database.morphosintax_mongo_db import (
+ store_student_morphosyntax_result,
+ get_student_morphosyntax_analysis,
+ update_student_morphosyntax_analysis,
+ delete_student_morphosyntax_analysis,
+ get_student_morphosyntax_data
+)
+
+from ..morphosyntax.morphosyntax_interface import (
+ display_morphosyntax_interface
+)
+
+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'))
+
+ logger.info(f"Saliendo de main() - Estado final de la sesión: {st.session_state}")
+
+
+def login_register_page(lang_code, t):
+ st.title("AIdeaText")
+ st.write(t.get("welcome_message", "Bienvenido. Por favor, inicie sesión o regístrese."))
+
+ left_column, right_column = st.columns([1, 3])
+
+ with left_column:
+ tab1, tab2 = st.tabs([t.get("login", "Iniciar Sesión"), t.get("register", "Registrarse")])
+
+ with tab1:
+ login_form(lang_code, t)
+
+ with tab2:
+ register_form(lang_code, t)
+
+ with right_column:
+ display_videos_and_info(lang_code, t)
+
+def login_form(lang_code, t):
+ with st.form("login_form"):
+ username = st.text_input(t.get("email", "Correo electrónico"))
+ password = st.text_input(t.get("password", "Contraseña"), type="password")
+ submit_button = st.form_submit_button(t.get("login", "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
+ 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(t.get("invalid_credentials", "Credenciales incorrectas"))
+
+def register_form(lang_code, t):
+ st.header(t.get("request_trial", "Solicitar prueba de la aplicación"))
+
+ name = st.text_input(t.get("name", "Nombre"))
+ lastname = st.text_input(t.get("lastname", "Apellidos"))
+ institution = st.text_input(t.get("institution", "Institución"))
+ current_role = st.selectbox(t.get("current_role", "Rol en la institución donde labora"),
+ [t.get("professor", "Profesor"), t.get("student", "Estudiante"), t.get("administrative", "Administrativo")])
+ desired_role = st.selectbox(t.get("desired_role", "Rol con el que desea registrarse en AIdeaText"),
+ [t.get("professor", "Profesor"), t.get("student", "Estudiante")])
+ email = st.text_input(t.get("institutional_email", "Correo electrónico de su institución"))
+ reason = st.text_area(t.get("interest_reason", "¿Por qué estás interesado en probar AIdeaText?"))
+
+ if st.button(t.get("submit_application", "Enviar solicitud")):
+ logger.info(f"Attempting to submit application for {email}")
+ logger.debug(f"Form data: 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("Incomplete form submission")
+ st.error(t.get("complete_all_fields", "Por favor, completa todos los campos."))
+ elif not is_institutional_email(email):
+ logger.warning(f"Non-institutional email used: {email}")
+ st.error(t.get("use_institutional_email", "Por favor, utiliza un correo electrónico institucional."))
+ else:
+ logger.info(f"Attempting to store application for {email}")
+ success = store_application_request(name, lastname, email, institution, current_role, desired_role, reason)
+ if success:
+ st.success(t.get("application_sent", "Tu solicitud ha sido enviada. Te contactaremos pronto."))
+ logger.info(f"Application request stored successfully for {email}")
+ else:
+ st.error(t.get("application_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)
+
+def display_videos_and_info(lang_code, t):
+ 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",
+ }
+
+ 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
+ - Interfaz mejorada para una mejor experiencia de usuario
+ - Optimización del análisis morfosintáctico
+ - Soporte para múltiples idiomas
+ """)
+
+#Después de iniciar sesión
+
+def user_page(lang_code, t):
+ logger.info(f"Entrando en user_page para el estudiante: {st.session_state.username}")
+
+ current_time = datetime.now(timezone.utc)
+ last_fetch_time = st.session_state.get('last_data_fetch')
+
+ if last_fetch_time:
+ last_fetch_time = parse(last_fetch_time)
+ else:
+ last_fetch_time = datetime.min.replace(tzinfo=timezone.utc)
+
+ # Comprobar si necesitamos recargar los datos del usuario
+ if 'user_data' not in st.session_state or (current_time - last_fetch_time).total_seconds() > 60:
+ with st.spinner(t.get('loading_data', "Cargando tus datos...")):
+ try:
+ st.session_state.user_data = get_student_morphosyntax_data(st.session_state.username)
+ st.session_state.last_data_fetch = current_time.isoformat()
+ except Exception as e:
+ logger.error(f"Error al obtener datos del usuario: {str(e)}")
+ st.error(t.get('data_load_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'}
+
+ # Estilos CSS personalizados (mantener los estilos existentes)
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+
+ 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() + with col3: + if st.button(t['logout'], key=f"logout_button_{st.session_state.username}_{st.session_state.lang_code}"): + logout() + st.rerun() + + # Reinicializar el estado de la sesión + initialize_session_state() + + # Recargar la aplicación + st.rerun() + + st.markdown("---") + + tabs = st.tabs([ + t.get('morpho_tab', 'Análisis Morfosintáctico'), + t.get('activities_tab', 'Mis Actividades'), + t.get('feedback_tab', 'Formulario de Comentarios') + ]) + + with tabs[0]: + display_morphosyntax_interface(st.session_state.lang_code, st.session_state.nlp_models, t) + + with tabs[1]: + if 'user_data' in st.session_state and st.session_state.user_data: + display_student_progress(st.session_state.username, st.session_state.lang_code, t) + else: + st.warning(t.get('no_data_warning', 'No se encontraron datos para este estudiante.')) + + with tabs[2]: + display_feedback_form(st.session_state.lang_code, t) + + # Información de depuración + with st.expander("Debug Info"): + st.write(f"Página actual: {st.session_state.page}") + st.write(f"Usuario: {st.session_state.get('username', 'No logueado')}") + st.write(f"Rol: {st.session_state.get('role', 'No definido')}") + st.write(f"Idioma: {st.session_state.lang_code}") + st.write(f"Última actualización de datos: {st.session_state.get('last_data_fetch', 'Nunca')}") + +def display_feedback_form(lang_code, t): + logging.info(f"display_feedback_form called with lang_code: {lang_code}") + + st.header(t['feedback_title']) + + name = st.text_input(t['name']) + email = st.text_input(t['email']) + feedback = st.text_area(t['feedback']) + + if st.button(t['submit']): + if name and email and feedback: + if store_student_feedback(st.session_state.username, name, email, feedback): + st.success(t['feedback_success']) + else: + st.error(t['feedback_error']) + else: + st.warning(t['complete_all_fields']) + +# 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/modules/ui/ui_BackUp-19-9-2024.py b/modules/ui/ui_BackUp-19-9-2024.py new file mode 100644 index 0000000000000000000000000000000000000000..1a8e1fb7c1daf723d04cbd2ca1fa301b4dd78091 --- /dev/null +++ b/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 += "