|
|
| 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
|
| from spacy import displacy
|
| import logging
|
| import random
|
|
|
|
|
|
|
| logging.basicConfig(level=logging.INFO)
|
| logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
| from translations import get_translations
|
|
|
|
|
|
|
| from ..email.email import send_email_notification
|
|
|
|
|
|
|
| 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,
|
| 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
|
| )
|
|
|
|
|
|
|
| from ..admin.admin_ui import admin_page
|
|
|
|
|
|
|
| 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 (
|
|
|
| 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,
|
|
|
| generate_topics_visualization,
|
| extract_topics,
|
| get_semantic_chatbot_response
|
| )
|
|
|
|
|
| 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}")
|
|
|
|
|
| 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)
|
|
|
|
|
|
|
| def user_page():
|
|
|
|
|
| t = get_translations(lang_code)
|
|
|
| st.title(t['welcome'])
|
| st.write(f"{t['hello']}, {st.session_state.username}")
|
|
|
|
|
| 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")
|
|
|
|
|
|
|
| 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):
|
|
|
| total_entries = len(student_data['entries'])
|
| st.write(f"Total de an谩lisis realizados: {total_entries}")
|
|
|
|
|
| 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)
|
|
|
|
|
| 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']}")
|
|
|
|
|
| if 'key_concepts' in entry:
|
| st.write("Conceptos clave:")
|
| concepts_str = " | ".join([f"{concept} ({frequency:.2f})" for concept, frequency in entry['key_concepts']])
|
|
|
|
|
| st.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str}</div>", unsafe_allow_html=True)
|
|
|
|
|
| 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']}")
|
|
|
|
|
| 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.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str1}</div>", 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.markdown(f"<div style='background-color: #f0f2f6; padding: 10px; border-radius: 5px;'>{concepts_str2}</div>", 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.")
|
|
|
|
|
| if st.checkbox("Mostrar datos de depuraci贸n"):
|
| st.write("Datos del estudiante (para depuraci贸n):")
|
| st.json(student_data)
|
|
|
|
|
|
|
| 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):
|
|
|
|
|
| return uploaded_file.getvalue().decode('utf-8')
|
|
|
|
|
| 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."))
|
|
|
|
|
| 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)
|
|
|
|
|
|
|
|
|
|
|
| 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}")
|
|
|
|
|
| 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}]
|
|
|
|
|
| chat_container = st.container()
|
|
|
|
|
| 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)
|
|
|
|
|
| user_input = st.chat_input(get_text('chat_placeholder', 'MORPHOSYNTACTIC',
|
| "Ingrese su mensaje o use /analisis_morfosintactico [texto] para analizar"))
|
|
|
| if user_input:
|
|
|
| st.session_state.morphosyntax_chat_history.append({"role": "user", "content": user_input})
|
|
|
|
|
| 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])
|
|
|
|
|
| st.session_state.current_analysis = {
|
| 'type': 'morphosyntactic',
|
| 'result': result
|
| }
|
|
|
|
|
| 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
|
| })
|
|
|
|
|
| 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:
|
|
|
| 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})
|
|
|
|
|
| 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'])
|
| return
|
|
|
|
|
|
|
| advanced_analysis = result
|
|
|
|
|
| st.markdown(f"##### {t['legend']}")
|
| legend_html = "<div style='display: flex; flex-wrap: wrap;'>"
|
| for pos, color in POS_COLORS.items():
|
| if pos in POS_TRANSLATIONS[lang_code]:
|
| legend_html += f"<div style='margin-right: 10px;'><span style='background-color: {color}; padding: 2px 5px;'>{POS_TRANSLATIONS[lang_code][pos]}</span></div>"
|
| legend_html += "</div>"
|
| st.markdown(legend_html, unsafe_allow_html=True)
|
|
|
|
|
| if 'repeated_words' in advanced_analysis:
|
| with st.expander(t['repeated_words'], expanded=True):
|
| st.markdown(advanced_analysis['repeated_words'], unsafe_allow_html=True)
|
|
|
|
|
| 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.")
|
|
|
|
|
|
|
| col1, col2 = st.columns(2)
|
|
|
| with col1:
|
| with st.expander(t['pos_analysis'], expanded=True):
|
| pos_df = pd.DataFrame(advanced_analysis['pos_analysis'])
|
|
|
|
|
| pos_df['pos'] = pos_df['pos'].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
|
|
|
|
|
| pos_df = pos_df.rename(columns={
|
| 'pos': t['grammatical_category'],
|
| 'count': t['count'],
|
| 'percentage': t['percentage'],
|
| 'examples': t['examples']
|
| })
|
|
|
|
|
| st.dataframe(pos_df)
|
|
|
| with col2:
|
| with st.expander(t['morphological_analysis'], expanded=True):
|
| morph_df = pd.DataFrame(advanced_analysis['morphological_analysis'])
|
|
|
|
|
| column_mapping = {
|
| 'text': t['word'],
|
| 'lemma': t['lemma'],
|
| 'pos': t['grammatical_category'],
|
| 'dep': t['dependency'],
|
| 'morph': t['morphology']
|
| }
|
|
|
|
|
| morph_df = morph_df.rename(columns={col: new_name for col, new_name in column_mapping.items() if col in morph_df.columns})
|
|
|
|
|
| morph_df[t['grammatical_category']] = morph_df[t['grammatical_category']].map(lambda x: POS_TRANSLATIONS[lang_code].get(x, x))
|
|
|
|
|
| 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))
|
|
|
|
|
| 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))
|
|
|
|
|
| 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]
|
|
|
|
|
| st.dataframe(morph_df[columns_to_display])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| with st.expander(t['arc_diagram'], expanded=True):
|
| for i, arc_diagram in enumerate(advanced_analysis['arc_diagram']):
|
| st.subheader(f"{t['sentence']} {i+1}")
|
| st.write(arc_diagram, unsafe_allow_html=True)
|
|
|
|
|
|
|
| def display_semantic_analysis_interface(nlp_models, lang_code, file_contents, t):
|
| t = SEMANTIC_TRANSLATIONS[lang_code]
|
|
|
| col1, col2 = st.columns(2)
|
|
|
| with col1:
|
| st.markdown(f"##### {t['chat_title']}")
|
|
|
| if 'semantic_chat_container' not in st.session_state:
|
| st.session_state.semantic_chat_container = st.empty()
|
|
|
| with st.session_state.semantic_chat_container.container():
|
| if file_contents is None:
|
| uploaded_file = st.file_uploader(t['file_uploader'], type=['txt', 'pdf', 'docx', 'doc', 'odt'])
|
| if uploaded_file is not None:
|
| file_contents = read_file_contents(uploaded_file)
|
| st.experimental_rerun()
|
|
|
| if file_contents is not None:
|
| display_semantic_chatbot_interface(nlp_models, lang_code, file_contents, t)
|
| else:
|
| st.info(t['warning_message'])
|
|
|
| with col2:
|
| st.markdown(f"##### {t['graph_title']}")
|
| if 'semantic_graph' in st.session_state:
|
| st.pyplot(st.session_state.semantic_graph)
|
| elif file_contents is not None:
|
| analysis_result = perform_semantic_analysis(file_contents, nlp_models[lang_code], lang_code)
|
| st.session_state.semantic_graph = analysis_result['relations_graph']
|
| st.pyplot(st.session_state.semantic_graph)
|
|
|
| '''
|
| def display_semantic_analysis_interface(nlp_models, lang_code):
|
| t = SEMANTIC_TRANSLATIONS[lang_code]
|
| with col1:
|
| st.subheader("Chat de An谩lisis Sem谩ntico")
|
| display_semantic_chatbot_interface(nlp_models, lang_code)
|
|
|
| with col2:
|
| st.subheader("Grafo de Relaciones Sem谩nticas")
|
| display_semantic_graph()
|
| st.header(t['title'])
|
| col1, col2 = st.columns([1, 1])
|
| with col1:
|
| st.subheader(t['chat_title'])
|
|
|
| # Secci贸n para cargar/seleccionar archivo
|
| uploaded_file = st.file_uploader(t['file_uploader'], type=['txt', 'pdf', 'docx', 'doc', 'odt'])
|
| saved_files = get_user_files(st.session_state.username, "semantic")
|
|
|
| if saved_files:
|
| selected_file = st.selectbox(t['select_saved_file'], options=[file['file_name'] for file in saved_files])
|
| if st.button(t['load_selected_file']):
|
| file_contents = retrieve_file_contents(st.session_state.username, selected_file, "semantic")
|
| st.session_state.file_contents = file_contents
|
| st.session_state.file_name = selected_file
|
| if uploaded_file:
|
| file_contents = read_file_contents(uploaded_file)
|
| if store_file_contents(st.session_state.username, uploaded_file.name, file_contents, "semantic"):
|
| st.session_state.file_contents = file_contents
|
| st.session_state.file_name = uploaded_file.name
|
| if 'file_contents' in st.session_state:
|
| display_semantic_chatbot_interface(nlp_models, lang_code, st.session_state.file_contents, t)
|
| else:
|
| st.info(t['no_file'])
|
| with col2:
|
| st.subheader(t['graph_title'])
|
| if 'semantic_analysis_result' in st.session_state:
|
| display_semantic_results(st.session_state.semantic_analysis_result, lang_code, t)
|
| elif 'file_contents' in st.session_state:
|
| analysis_result = perform_semantic_analysis(st.session_state.file_contents, nlp_models[lang_code], lang_code)
|
| st.session_state.semantic_analysis_result = analysis_result
|
| display_semantic_results(analysis_result, lang_code, t)
|
| else:
|
| st.info(t['no_analysis'])
|
| '''
|
|
|
|
|
|
|
| def display_semantic_chatbot_interface(nlp_models, lang_code, file_contents, t):
|
|
|
| if 'semantic_chat_input_key' not in st.session_state:
|
| st.session_state.semantic_chat_input_key = f"semantic_chat_input_{id(st.session_state)}"
|
|
|
|
|
| if 'semantic_chat_history' not in st.session_state:
|
| st.session_state.semantic_chat_history = [{"role": "assistant", "content": t['initial_message']}]
|
|
|
|
|
| for message in st.session_state.semantic_chat_history:
|
| with st.chat_message(message["role"]):
|
| st.write(message["content"])
|
|
|
|
|
| user_input = st.chat_input(t['chat_placeholder'], key=st.session_state.semantic_chat_input_key)
|
|
|
| if user_input:
|
|
|
| st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
|
|
|
|
|
| response, graph = handle_semantic_commands(user_input, lang_code, file_contents, nlp_models)
|
|
|
|
|
| st.session_state.semantic_chat_history.append({"role": "assistant", "content": response})
|
|
|
| if graph is not None:
|
| st.session_state.semantic_graph = graph
|
|
|
|
|
| st.rerun()
|
|
|
|
|
| if st.button(t['clear_chat'], key=f"clear_chat_{st.session_state.semantic_chat_input_key}"):
|
| st.session_state.semantic_chat_history = [{"role": "assistant", "content": t['initial_message']}]
|
| st.rerun()
|
|
|
| '''
|
| def display_semantic_chatbot_interface(nlp_models, lang_code, file_contents, t):
|
| if 'semantic_chat_history' not in st.session_state:
|
| st.session_state.semantic_chat_history = [{"role": "assistant", "content": t['initial_message']}]
|
| for message in st.session_state.semantic_chat_history:
|
| with st.chat_message(message["role"]):
|
| st.write(message["content"])
|
| if "graph" in message:
|
| st.pyplot(message["graph"])
|
| user_input = st.chat_input(t['chat_placeholder'])
|
| if user_input:
|
| st.session_state.semantic_chat_history.append({"role": "user", "content": user_input})
|
|
|
| response, graph = handle_semantic_commands(user_input, lang_code, file_contents, nlp_models, t)
|
| message = {"role": "assistant", "content": response}
|
| if graph is not None:
|
| message["graph"] = graph
|
| st.session_state.semantic_chat_history.append(message)
|
| # Bot贸n para limpiar el historial del chat
|
| if st.button(t['clear_chat']):
|
| st.session_state.semantic_chat_history = [{"role": "assistant", "content": t['initial_message']}]
|
| '''
|
|
|
|
|
| def display_semantic_results(result, lang_code, t):
|
| get_text = get_text if callable(get_text) else lambda key, section, default: t.get(key, default)
|
| if result is None:
|
| st.warning(get_text('no_results', 'SEMANTIC'))
|
| return
|
|
|
|
|
| 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)
|
|
|
|
|
| with st.expander(t['conceptual_relations'], expanded=True):
|
| st.pyplot(result['relations_graph'])
|
|
|
|
|
|
|
| def display_semantic_graph():
|
| if 'semantic_graph' in st.session_state:
|
| st.pyplot(st.session_state.semantic_graph)
|
| else:
|
| st.info("Sube un archivo para generar el grafo sem谩ntico.")
|
|
|
|
|
|
|
| def display_discourse_analysis_interface(nlp_models, lang_code, t):
|
| get_text = get_text if callable(get_text) else lambda key, section, default: t.get(key, default)
|
| st.header(get_text('discourse_analysis_title', 'DISCOURSE', 'Discourse Analysis'))
|
|
|
|
|
| display_chatbot_interface(lang_code, nlp_models, t, analysis_type='discourse')
|
|
|
|
|
| col1, col2 = st.columns(2)
|
| with col1:
|
| uploaded_file1 = st.file_uploader(get_text('file_uploader1', 'DISCOURSE', 'Upload first file'), type=['txt'])
|
| with col2:
|
| uploaded_file2 = st.file_uploader(get_text('file_uploader2', 'DISCOURSE', 'Upload second file'), type=['txt'])
|
|
|
| if uploaded_file1 is not None and uploaded_file2 is not None:
|
| if st.button(get_text('analyze_button', 'DISCOURSE', 'Analyze')):
|
| text_content1 = uploaded_file1.getvalue().decode('utf-8')
|
| text_content2 = uploaded_file2.getvalue().decode('utf-8')
|
|
|
|
|
| analysis_result = perform_discourse_analysis(text_content1, text_content2, nlp_models[lang_code], lang_code)
|
|
|
|
|
| st.session_state.discourse_result = analysis_result
|
|
|
|
|
| display_discourse_results(analysis_result, lang_code, t)
|
|
|
|
|
| if store_discourse_analysis_result(st.session_state.username, text_content1, text_content2, analysis_result):
|
| st.success(get_text('success_message', 'DISCOURSE', 'Analysis result saved successfully'))
|
| else:
|
| st.error(get_text('error_message', 'DISCOURSE', 'Failed to save analysis result'))
|
| elif 'discourse_result' in st.session_state and st.session_state.discourse_result is not None:
|
|
|
| display_discourse_results(st.session_state.discourse_result, lang_code, t)
|
| else:
|
| st.info(get_text('DISCOURSE_initial_message', 'DISCOURSE', 'Upload two files and click "Analyze" to start the discourse analysis.'))
|
|
|
|
|
|
|
| def display_discourse_results(result, lang_code, t):
|
| if result is None:
|
| st.warning(t.get('no_results', "No hay resultados disponibles."))
|
| return
|
|
|
| col1, col2 = st.columns(2)
|
|
|
| with col1:
|
| with st.expander(t.get('file_uploader1', "Documento 1"), expanded=True):
|
| st.subheader(t.get('key_concepts', "Conceptos Clave"))
|
| if 'key_concepts1' in result:
|
| df1 = pd.DataFrame(result['key_concepts1'], columns=['Concepto', 'Frecuencia'])
|
| df1['Frecuencia'] = df1['Frecuencia'].round(2)
|
| st.table(df1)
|
| else:
|
| st.warning(t.get('concepts_not_available', "Los conceptos clave no est谩n disponibles."))
|
|
|
| if 'graph1' in result:
|
| st.pyplot(result['graph1'])
|
| else:
|
| st.warning(t.get('graph_not_available', "El gr谩fico no est谩 disponible."))
|
|
|
| with col2:
|
| with st.expander(t.get('file_uploader2', "Documento 2"), expanded=True):
|
| st.subheader(t.get('key_concepts', "Conceptos Clave"))
|
| if 'key_concepts2' in result:
|
| df2 = pd.DataFrame(result['key_concepts2'], columns=['Concepto', 'Frecuencia'])
|
| df2['Frecuencia'] = df2['Frecuencia'].round(2)
|
| st.table(df2)
|
| else:
|
| st.warning(t.get('concepts_not_available', "Los conceptos clave no est谩n disponibles."))
|
|
|
| if 'graph2' in result:
|
| st.pyplot(result['graph2'])
|
| else:
|
| st.warning(t.get('graph_not_available', "El gr谩fico no est谩 disponible."))
|
|
|
|
|
| st.subheader(t.get('comparison', "Relaci贸n de conceptos entre ambos documentos"))
|
| if 'key_concepts1' in result and 'key_concepts2' in result:
|
| df1 = pd.DataFrame(result['key_concepts1'], columns=['Concepto', 'Frecuencia'])
|
| df2 = pd.DataFrame(result['key_concepts2'], columns=['Concepto', 'Frecuencia'])
|
|
|
|
|
| all_concepts = list(set(df1['Concepto'].tolist() + df2['Concepto'].tolist()))
|
|
|
|
|
| color_scale = [f'rgb({random.randint(50,255)},{random.randint(50,255)},{random.randint(50,255)})' for _ in range(len(all_concepts))]
|
| color_map = dict(zip(all_concepts, color_scale))
|
|
|
|
|
| source = [0] * len(df1) + list(range(2, 2 + len(df1)))
|
| target = list(range(2, 2 + len(df1))) + [1] * len(df2)
|
| value = list(df1['Frecuencia']) + list(df2['Frecuencia'])
|
|
|
| node_colors = ['blue', 'red'] + [color_map[concept] for concept in df1['Concepto']] + [color_map[concept] for concept in df2['Concepto']]
|
| link_colors = [color_map[concept] for concept in df1['Concepto']] + [color_map[concept] for concept in df2['Concepto']]
|
|
|
| fig = go.Figure(data=[go.Sankey(
|
| node = dict(
|
| pad = 15,
|
| thickness = 20,
|
| line = dict(color = "black", width = 0.5),
|
| label = [t.get('file_uploader1', "Documento 1"), t.get('file_uploader2', "Documento 2")] + list(df1['Concepto']) + list(df2['Concepto']),
|
| color = node_colors
|
| ),
|
| link = dict(
|
| source = source,
|
| target = target,
|
| value = value,
|
| color = link_colors
|
| ))])
|
|
|
| fig.update_layout(title_text="Relaci贸n de conceptos entre documentos", font_size=10)
|
| st.plotly_chart(fig, use_container_width=True)
|
| else:
|
| st.warning(t.get('comparison_not_available', "La comparaci贸n no est谩 disponible."))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| def display_chatbot_interface(lang_code, nlp_models, t, analysis_type='morphosyntactic', file_contents=None):
|
| logger.debug(f"Displaying chatbot interface for {analysis_type} analysis")
|
|
|
| get_text = t['get_text'] if callable(t['get_text']) else lambda key, section, default: t.get(key, default)
|
|
|
| initial_message = get_text('initial_message', analysis_type.upper(), "Mensaje inicial no encontrado")
|
|
|
| if not all([lang_code, nlp_models, t]):
|
| st.error("Missing required arguments in display_chatbot_interface")
|
| return
|
|
|
| valid_types = ['morphosyntactic', 'semantic', 'discourse']
|
| if analysis_type not in valid_types:
|
| raise ValueError(f"Invalid analysis_type. Must be one of {valid_types}")
|
|
|
| chat_key = f'{analysis_type}_messages'
|
| if chat_key not in st.session_state:
|
| st.session_state[chat_key] = [{"role": "assistant", "content": initial_message, "visualizations": []}]
|
|
|
|
|
| chat_container = st.container()
|
|
|
| with chat_container:
|
|
|
| for message in st.session_state[chat_key]:
|
| with st.chat_message(message["role"]):
|
| st.write(message["content"])
|
| for visualization in message.get("visualizations", []):
|
| if isinstance(visualization, str):
|
| st.components.v1.html(visualization, height=450, scrolling=True)
|
| else:
|
| st.pyplot(visualization)
|
|
|
|
|
| chat_input_key = f"chat_input_{analysis_type}_{lang_code}"
|
| user_input = st.chat_input(
|
| get_text('input_placeholder', analysis_type.upper(), 'Ingrese su mensaje aqu铆...'),
|
| key=chat_input_key
|
| )
|
|
|
| if user_input:
|
| st.session_state[chat_key].append({"role": "user", "content": user_input})
|
|
|
| try:
|
| response, visualizations = process_chat_input(user_input, lang_code, nlp_models, analysis_type, t, file_contents)
|
|
|
| message = {"role": "assistant", "content": response, "visualizations": visualizations}
|
| st.session_state[chat_key].append(message)
|
| st.rerun()
|
|
|
| except Exception as e:
|
| error_message = get_text('error_message', 'COMMON', f"Lo siento, ocurri贸 un error: {str(e)}")
|
| st.error(error_message)
|
| st.session_state[chat_key].append({"role": "assistant", "content": error_message})
|
|
|
|
|
| if analysis_type in ['semantic', 'discourse']:
|
| file_key = f"{analysis_type}_file_uploader_{lang_code}"
|
|
|
| if analysis_type == 'discourse':
|
| col1, col2 = st.columns(2)
|
| with col1:
|
| uploaded_file1 = st.file_uploader(get_text('file_uploader1', 'DISCOURSE', 'Upload first file'), type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=f"{file_key}_1")
|
| with col2:
|
| uploaded_file2 = st.file_uploader(get_text('file_uploader2', 'DISCOURSE', 'Upload second file'), type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=f"{file_key}_2")
|
|
|
| if uploaded_file1 and uploaded_file2:
|
| if st.button(get_text('analyze_button', 'DISCOURSE', 'Analyze')):
|
| file_contents1 = read_file_contents(uploaded_file1)
|
| file_contents2 = read_file_contents(uploaded_file2)
|
| result = perform_discourse_analysis(file_contents1, file_contents2, nlp_models[lang_code], lang_code)
|
| st.session_state['discourse_result'] = result
|
| st.session_state['file_contents'] = (file_contents1, file_contents2)
|
| display_analysis_results(result, lang_code, t)
|
| else:
|
| uploaded_file = st.file_uploader(get_text('file_uploader', 'SEMANTIC', 'Upload a file'), type=['txt', 'pdf', 'docx', 'doc', 'odt'], key=file_key)
|
|
|
| if uploaded_file:
|
| if st.button(get_text('analyze_button', 'SEMANTIC', 'Analyze')):
|
| file_contents = read_file_contents(uploaded_file)
|
| result = perform_semantic_analysis(file_contents, nlp_models[lang_code], lang_code)
|
| st.session_state['semantic_result'] = result
|
| st.session_state['file_contents'] = file_contents
|
| display_analysis_results(result, lang_code, t)
|
|
|
|
|
| clear_chat_key = f"clear_chat_{analysis_type}_{lang_code}"
|
| if st.button(get_text('clear_chat', 'COMMON', 'Limpiar chat'), key=clear_chat_key):
|
| st.session_state[chat_key] = [{"role": "assistant", "content": initial_message}]
|
| st.rerun()
|
|
|
|
|
|
|
| def process_chat_input(user_input, lang_code, nlp_models, analysis_type, t, file_contents=None):
|
| chatbot_key = f'{analysis_type}_chatbot'
|
| if chatbot_key not in st.session_state:
|
| st.session_state[chatbot_key] = initialize_chatbot(analysis_type)
|
| chatbot = st.session_state[chatbot_key]
|
|
|
| if analysis_type == 'morphosyntactic':
|
| if user_input.startswith('/analisis_morfosintactico') or user_input.startswith('/morphosyntactic_analysis') or user_input.startswith('/analyse_morphosyntaxique'):
|
| text_to_analyze = user_input.split(' ', 1)[1].strip('[]')
|
| result = perform_advanced_morphosyntactic_analysis(text_to_analyze, nlp_models[lang_code])
|
| st.session_state['file_contents'] = text_to_analyze
|
| return get_text('analysis_completed', 'MORPHOSYNTACTIC', 'An谩lisis morfosint谩ctico completado.'), result.get('arc_diagram', [])
|
| else:
|
| response = chatbot.process_input(user_input, lang_code, nlp_models, t)
|
| return response, []
|
| elif analysis_type == 'semantic':
|
| response = chatbot.process_input(user_input, lang_code, nlp_models[lang_code], st.session_state.get('file_contents'), t)
|
| return response, []
|
| elif analysis_type == 'discourse':
|
| response = chatbot.process_input(user_input, lang_code, nlp_models, st.session_state.get('file_contents'), t)
|
| return response, []
|
| else:
|
| raise ValueError(f"Invalid analysis_type: {analysis_type}")
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
