Upload 11 files

src/23-7-2024_app.py

@@ -0,0 +1,62 @@
+## app.py
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+import streamlit as st
+from modules.database import initialize_mongodb_connection, get_student_data, store_analysis_result
+from modules.auth import authenticate_user, get_user_role
+from modules.ui import login_page, register_page, display_chat_interface, display_student_progress, display_text_analysis_interface
+from modules.morpho_analysis import get_repeated_words_colors, highlight_repeated_words, POS_COLORS, POS_TRANSLATIONS
+from modules.syntax_analysis import visualize_syntax
+from modules.spacy_utils import load_spacy_models
+
+st.set_page_config(page_title="AIdeaText", layout="wide", page_icon="random")
+
+def main_app():
+    nlp_models = load_spacy_models()
+    
+    languages = {'Español': 'es', 'English': 'en', 'Français': 'fr'}
+    selected_lang = st.sidebar.selectbox("Select Language / Seleccione el idioma / Choisissez la langue", list(languages.keys()))
+    lang_code = languages[selected_lang]
+    
+    col1, col2 = st.columns([1, 2])
+    
+    with col1:
+        display_chat_interface()
+    
+    with col2:
+        st.markdown("### AIdeaText - Análisis morfológico y sintáctico")
+        
+        if st.session_state.role == "Estudiante":
+            tabs = st.tabs(["Análisis de Texto", "Mi Progreso"])
+            with tabs[0]:
+                display_text_analysis_interface(nlp_models, lang_code)
+            with tabs[1]:
+                display_student_progress(st.session_state.username)
+        elif st.session_state.role == "Profesor":
+            st.write("Bienvenido, profesor. Aquí podrás ver el progreso de tus estudiantes.")
+            # Agregar lógica para mostrar el progreso de los estudiantes
+
+def main():
+    if not initialize_mongodb_connection():
+        st.warning("La conexión a la base de datos MongoDB no está disponible. Algunas funciones pueden no estar operativas.")
+    
+    if 'logged_in' not in st.session_state:
+        st.session_state.logged_in = False
+    
+    if not st.session_state.logged_in:
+        menu = ["Iniciar Sesión", "Registrarse"]
+        choice = st.sidebar.selectbox("Menu", menu)
+        if choice == "Iniciar Sesión":
+            login_page()
+        elif choice == "Registrarse":
+            register_page()
+    else:
+        if st.sidebar.button("Cerrar Sesión"):
+            st.session_state.logged_in = False
+            st.rerun()
+        main_app()
+
+if __name__ == "__main__":
+    main()

src/Test_app.py

@@ -0,0 +1,8 @@
+import streamlit as st
+
+def main():
+    st.title("Test de Streamlit")
+    st.write("Si puedes ver esto, Streamlit está funcionando correctamente.")
+
+if __name__ == "__main__":
+    main()

src/app.py

@@ -0,0 +1,173 @@
+# AIdeaText v3
+# app.py
+import logging
+import streamlit as st
+import sys
+import os
+from dotenv import load_dotenv
+from datetime import datetime
+from PIL import Image
+
+# Configuración básica
+load_dotenv()
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Configuración básica de la página
+st.set_page_config(
+    page_title="AIdeaText",
+    layout="wide",
+    initial_sidebar_state="collapsed"  # Para dar más espacio al logo
+)
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Importaciones locales
+from translations import get_translations, get_landing_translations
+from session_state import initialize_session_state
+from modules.ui.ui import main as ui_main
+from modules.utils.spacy_utils import load_spacy_models
+from modules.utils.widget_utils import generate_unique_key
+
+# Importaciones de interfaces
+from modules.morphosyntax.morphosyntax_interface import (
+    display_morphosyntax_interface,
+    display_arc_diagram
+    #display_morphosyntax_results
+)
+
+from modules.semantic.semantic_interface import (
+    display_semantic_interface, 
+    display_semantic_results
+)
+
+from modules.discourse.discourse_interface import (
+    display_discourse_interface, 
+    display_discourse_results
+)
+
+# Importaciones de base de datos
+
+from modules.database.database_init import initialize_database_connections
+
+from modules.database.sql_db import (
+     get_user,
+     get_admin_user,
+     get_student_user,
+     get_teacher_user,
+     create_user,
+     create_student_user,
+     create_teacher_user,
+     create_admin_user,
+     update_student_user,  # Agregada
+     delete_student_user,  # Agregada
+     record_login,
+     record_logout,
+     get_recent_sessions,
+     get_user_total_time,
+     store_application_request,
+     store_student_feedback
+)
+
+from modules.database.mongo_db import (
+    get_collection,
+    insert_document,
+    find_documents,
+    update_document,
+    delete_document
+)
+
+from modules.database.morphosintax_mongo_db import (
+    store_student_morphosyntax_result,
+    get_student_morphosyntax_analysis
+)
+
+from modules.database.semantic_mongo_db import (
+    store_student_semantic_result,
+    get_student_semantic_analysis
+)
+
+from modules.database.chat_mongo_db import ( 
+    store_chat_history,
+    get_chat_history
+)
+
+# Importaciones de base de datos
+from modules.studentact.student_activities_v2 import display_student_activities
+from modules.studentact.current_situation_interface import display_current_situation_interface
+
+from modules.auth.auth import (
+    authenticate_student,
+    register_student,
+    update_student_info,
+    delete_student
+)
+from modules.admin.admin_ui import admin_page
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@st.cache_resource(show_spinner=False)
+def initialize_nlp_models():
+    logger.info("Cargando modelos de spaCy")
+    models = load_spacy_models()
+    logger.info("Modelos de spaCy cargados exitosamente")
+    return models
+
+def app_main():
+    try:
+        logger.info("Entrando en app_main()")
+
+        # Inicializar el estado de la sesión
+        if 'initialized' not in st.session_state:
+            initialize_session_state()
+            st.session_state.initialized = True
+
+        # Inicializar conexiones a bases de datos si no se ha hecho
+        if 'db_initialized' not in st.session_state:
+            st.session_state.db_initialized = initialize_database_connections()
+
+        # Cargar modelos NLP si no se ha hecho
+        if 'nlp_models' not in st.session_state:
+            logger.info("Inicializando modelos NLP en la sesión")
+            st.session_state.nlp_models = initialize_nlp_models()
+            logger.info("Modelos NLP inicializados y almacenados en la sesión")
+
+        # Inicializar estados de análisis si no existen
+        if 'morphosyntax_state' not in st.session_state:
+            st.session_state.morphosyntax_state = {
+                'last_analysis': None,
+                'analysis_count': 0
+            }
+            
+        if 'semantic_state' not in st.session_state:
+            st.session_state.semantic_state = {
+                'last_analysis': None,
+                'analysis_count': 0
+            }
+
+        # Configurar la página inicial si no está configurada
+        if 'page' not in st.session_state:
+            st.session_state.page = 'login'
+
+        # Prevenir reinicios innecesarios preservando el estado
+        if 'selected_tab' not in st.session_state:
+            st.session_state.selected_tab = 0
+
+        logger.info(f"Página actual: {st.session_state.page}")
+        logger.info(f"Rol del usuario: {st.session_state.role}")
+
+        # Dirigir el flujo a la interfaz de usuario principal
+        logger.info(f"Llamando a ui_main() desde app_main()")
+        ui_main()
+
+    except Exception as e:
+        logger.error(f"Error en app_main: {str(e)}", exc_info=True)
+        st.error("Se ha producido un error en la aplicación. Por favor, inténtelo de nuevo más tarde.")
+        if st.button("Reiniciar aplicación", 
+                    key=generate_unique_key("app", "reset_button")):
+            st.session_state.clear()
+            st.rerun()
+
+if __name__ == "__main__":
+    app_main()

src/old_app.py

@@ -0,0 +1,464 @@
+#old.app.py
+
+import logging
+import datetime
+import io
+import base64
+import os
+import streamlit as st
+import spacy
+from spacy import displacy
+import re
+import numpy as np
+import certifi
+#from transformers import BlenderbotTokenizer, BlenderbotForConditionalGeneration
+from azure.cosmos import CosmosClient
+from azure.cosmos.exceptions import CosmosHttpResponseError
+from pymongo import MongoClient
+from pymongo.server_api import ServerApi
+from bson.objectid import ObjectId
+from datetime import datetime
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from modules.auth import (
+    clean_and_validate_key,
+    register_user,
+    authenticate_user,
+    get_user_role
+)
+
+from modules.morpho_analysis import get_repeated_words_colors, highlight_repeated_words, POS_COLORS, POS_TRANSLATIONS
+from modules.syntax_analysis import visualize_syntax
+
+# Azure Cosmos DB configuration
+cosmos_endpoint = os.environ.get("COSMOS_ENDPOINT")
+cosmos_key = os.environ.get("COSMOS_KEY")
+
+if not cosmos_endpoint or not cosmos_key:
+    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY deben estar configuradas")
+
+try:
+    cosmos_key = clean_and_validate_key(cosmos_key)
+    cosmos_client = CosmosClient(cosmos_endpoint, cosmos_key)
+
+    # SQL API database for user management
+    user_database = cosmos_client.get_database_client("user_database")
+    user_container = user_database.get_container_client("users")
+
+    print("Conexión a Cosmos DB SQL API exitosa")
+except Exception as e:
+    print(f"Error al conectar con Cosmos DB SQL API: {str(e)}")
+    raise
+
+# MongoDB API configuration for text analysis results
+#mongo_connection_string = os.environ.get("MONGODB_CONNECTION_STRING")
+cosmos_mongodb_connection_string = os.getenv("MONGODB_CONNECTION_STRING")
+if not cosmos_mongodb_connection_string:
+    logger.error("La variable de entorno MONGODB_CONNECTION_STRING no está configurada")
+else:
+    logger.info("La variable de entorno MONGODB_CONNECTION_STRING está configurada")
+
+# Variable global para el cliente de MongoDB
+mongo_client = None
+db = None
+analysis_collection = None
+####################################################################################################################
+def initialize_mongodb_connection():
+    global mongo_client, db, analysis_collection
+    try:
+        # Crear el cliente de MongoDB con configuración TLS
+        mongo_client = MongoClient(cosmos_mongodb_connection_string,
+                                   tls=True,
+                                   tlsCAFile=certifi.where(),
+                                   retryWrites=False,
+                                   serverSelectionTimeoutMS=5000,
+                                   connectTimeoutMS=10000,
+                                   socketTimeoutMS=10000)
+
+        # Forzar una conexión para verificar
+        mongo_client.admin.command('ping')
+
+        # Seleccionar la base de datos y la colección
+        db = mongo_client['aideatext_db']
+        analysis_collection = db['text_analysis']
+
+        logger.info("Conexión a Cosmos DB MongoDB API exitosa")
+        return True
+    except Exception as e:
+        logger.error(f"Error al conectar con Cosmos DB MongoDB API: {str(e)}", exc_info=True)
+        return False
+
+##################################################################################################################3
+def get_student_data(username):
+    if analysis_collection is None:
+        logger.error("La conexión a MongoDB no está inicializada")
+        return None
+
+    try:
+        # Buscar los datos del estudiante
+        student_data = analysis_collection.find({"username": username}).sort("timestamp", -1)
+
+        if not student_data:
+            return None
+
+        # Formatear los datos
+        formatted_data = {
+            "username": username,
+            "entries": [],
+            "entries_count": 0,
+            "word_count": {},
+            "arc_diagrams": [],
+            "network_diagrams": []
+        }
+
+        for entry in student_data:
+            formatted_data["entries"].append({
+                "timestamp": entry["timestamp"].isoformat(),
+                "text": entry["text"]
+            })
+            formatted_data["entries_count"] += 1
+
+            # Agregar conteo de palabras
+            for category, count in entry.get("word_count", {}).items():
+                if category in formatted_data["word_count"]:
+                    formatted_data["word_count"][category] += count
+                else:
+                    formatted_data["word_count"][category] = count
+
+            # Agregar diagramas
+            formatted_data["arc_diagrams"].extend(entry.get("arc_diagrams", []))
+            formatted_data["network_diagrams"].append(entry.get("network_diagram", ""))
+
+        return formatted_data
+    except Exception as e:
+        logger.error(f"Error al obtener datos del estudiante {username}: {str(e)}")
+        return None
+
+
+##################################################################################################################
+# Función para insertar un documento
+def insert_document(document):
+    try:
+        result = analysis_collection.insert_one(document)
+        logger.info(f"Documento insertado con ID: {result.inserted_id}")
+        return result.inserted_id
+    except Exception as e:
+        logger.error(f"Error al insertar documento: {str(e)}", exc_info=True)
+        return None
+
+# Configure the page to use the full width
+st.set_page_config(
+    page_title="AIdeaText",
+    layout="wide",
+    page_icon="random"
+)
+#####################################################################################################
+@st.cache_resource
+def load_chatbot_model():
+    try:
+        from transformers import BlenderbotTokenizer, BlenderbotForConditionalGeneration
+        tokenizer = BlenderbotTokenizer.from_pretrained("facebook/blenderbot-400M-distill")
+        model = BlenderbotForConditionalGeneration.from_pretrained("facebook/blenderbot-400M-distill")
+        return tokenizer, model
+    except Exception as e:
+        logger.error(f"Error al cargar el modelo del chatbot: {str(e)}")
+        return None, None
+
+# Load the chatbot model
+chatbot_tokenizer, chatbot_model = load_chatbot_model()
+
+def get_chatbot_response(input_text):
+    if chatbot_tokenizer is None or chatbot_model is None:
+        return "Lo siento, el chatbot no está disponible en este momento."
+    try:
+        inputs = chatbot_tokenizer(input_text, return_tensors="pt")
+        reply_ids = chatbot_model.generate(**inputs)
+        return chatbot_tokenizer.batch_decode(reply_ids, skip_special_tokens=True)[0]
+    except Exception as e:
+        logger.error(f"Error al generar respuesta del chatbot: {str(e)}")
+        return "Lo siento, hubo un error al procesar tu mensaje."
+########################################################################################################
+def load_spacy_models():
+    return {
+        'es': spacy.load("es_core_news_lg"),
+        'en': spacy.load("en_core_web_lg"),
+        'fr': spacy.load("fr_core_news_lg")
+    }
+#########################################################################################################
+def store_analysis_result(username, text, repeated_words, arc_diagrams, network_diagram):
+    if analysis_collection is None:
+        logging.error("La conexión a MongoDB no está inicializada")
+        return False
+
+    try:
+        # Convertir el gráfico de matplotlib a base64
+        buffer = io.BytesIO()
+        network_diagram.savefig(buffer, format='png')
+        buffer.seek(0)
+        network_diagram_base64 = base64.b64encode(buffer.getvalue()).decode()
+
+        # Contar palabras repetidas por categoría gramatical
+        word_count = {}
+        for word, color in repeated_words.items():
+            category = POS_TRANSLATIONS.get(color, 'Otros')
+            word_count[category] = word_count.get(category, 0) + 1
+
+        # Crear el documento para MongoDB
+        analysis_document = {
+            'username': username,  # Este campo se usará como sharded key
+            'timestamp': datetime.datetime.utcnow(),
+            'text': text,
+            'word_count': word_count,
+            'arc_diagrams': arc_diagrams,
+            'network_diagram': network_diagram_base64
+        }
+
+        # Insertar el documento en la colección
+        result = analysis_collection.insert_one(analysis_document)
+
+        logging.info(f"Análisis guardado con ID: {result.inserted_id} para el usuario: {username}")
+        return True
+    except Exception as e:
+        logging.error(f"Error al guardar el análisis para el usuario {username}: {str(e)}")
+        return False
+
+#############################################################################################33
+def login_page():
+    st.title("Iniciar Sesión")
+    username = st.text_input("Usuario")
+    password = st.text_input("Contraseña", type='password')
+    if st.button("Iniciar Sesión"):
+        if authenticate_user(username, password):
+            st.success(f"Bienvenido, {username}!")
+            st.session_state.logged_in = True
+            st.session_state.username = username
+            st.session_state.role = get_user_role(username)
+            st.experimental_rerun()
+        else:
+            st.error("Usuario o contraseña incorrectos")
+
+#####################################################################################################3
+def register_page():
+    st.title("Registrarse")
+    new_username = st.text_input("Nuevo Usuario")
+    new_password = st.text_input("Nueva Contraseña", type='password')
+    role = st.selectbox("Rol", ["Estudiante", "Profesor"])
+
+    additional_info = {}
+    if role == "Estudiante":
+        additional_info['carrera'] = st.text_input("Carrera")
+    elif role == "Profesor":
+        additional_info['departamento'] = st.text_input("Departamento")
+
+    if st.button("Registrarse"):
+        if register_user(new_username, new_password, role, additional_info):
+            st.success("Registro exitoso. Por favor, inicia sesión.")
+        else:
+            st.error("El usuario ya existe o ocurrió un error durante el registro")
+
+############################################################################################
+def main_app():
+    # Load spaCy models
+    nlp_models = load_spacy_models()
+
+    # Language selection
+    languages = {
+        'Español': 'es',
+        'English': 'en',
+        'Français': 'fr'
+    }
+    selected_lang = st.sidebar.selectbox("Select Language / Seleccione el idioma / Choisissez la langue", list(languages.keys()))
+    lang_code = languages[selected_lang]
+
+    # Translations
+    translations = {
+        'es': {
+            'title': "AIdeaText - Análisis morfológico y sintáctico",
+            'input_label': "Ingrese un texto para analizar (máx. 5,000 palabras):",
+            'input_placeholder': "El objetivo de esta aplicación es que mejore sus habilidades de redacción. Para ello, después de ingresar su texto y presionar el botón obtendrá tres vistas horizontales. La primera, le indicará las palabras que se repiten por categoría gramátical; la segunda, un diagrama de arco le indicara las conexiones sintácticas en cada oración; y la tercera, es un grafo en el cual visualizara la configuración de su texto.",
+            'analyze_button': "Analizar texto",
+            'repeated_words': "Palabras repetidas",
+            'legend': "Leyenda: Categorías gramaticales",
+            'arc_diagram': "Análisis sintáctico: Diagrama de arco",
+            'network_diagram': "Análisis sintáctico: Diagrama de red",
+            'sentence': "Oración"
+        },
+        'en': {
+            'title': "AIdeaText - Morphological and Syntactic Analysis",
+            'input_label': "Enter a text to analyze (max 5,000 words):",
+            'input_placeholder': "The goal of this app is for you to improve your writing skills. To do this, after entering your text and pressing the button you will get three horizontal views. The first will indicate the words that are repeated by grammatical category; second, an arc diagram will indicate the syntactic connections in each sentence; and the third is a graph in which you will visualize the configuration of your text.",
+            'analyze_button': "Analyze text",
+            'repeated_words': "Repeated words",
+            'legend': "Legend: Grammatical categories",
+            'arc_diagram': "Syntactic analysis: Arc diagram",
+            'network_diagram': "Syntactic analysis: Network diagram",
+            'sentence': "Sentence"
+        },
+        'fr': {
+            'title': "AIdeaText - Analyse morphologique et syntaxique",
+            'input_label': "Entrez un texte à analyser (max 5 000 mots) :",
+            'input_placeholder': "Le but de cette application est d'améliorer vos compétences en rédaction. Pour ce faire, après avoir saisi votre texte et appuyé sur le bouton vous obtiendrez trois vues horizontales. Le premier indiquera les mots répétés par catégorie grammaticale; deuxièmement, un diagramme en arcs indiquera les connexions syntaxiques dans chaque phrase; et le troisième est un graphique dans lequel vous visualiserez la configuration de votre texte.",
+            '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",
+            'network_diagram': "Analyse syntaxique : Diagramme de réseau",
+            'sentence': "Phrase"
+        }
+    }
+
+    # Use translations
+    t = translations[lang_code]
+
+    # Create two columns: one for chat and one for analysis
+    col1, col2 = st.columns([1, 2])
+
+    with col1:
+        st.markdown(f"### Chat con AIdeaText")
+
+        # Initialize chat history if it doesn't exist
+        if 'chat_history' not in st.session_state:
+            st.session_state.chat_history = []
+
+        # Display chat history
+        for i, (role, text) in enumerate(st.session_state.chat_history):
+            if role == "user":
+                st.text_area(f"Tú:", value=text, height=50, key=f"user_message_{i}", disabled=True)
+            else:
+                st.text_area(f"AIdeaText:", value=text, height=50, key=f"bot_message_{i}", disabled=True)
+
+        # User input field
+        user_input = st.text_input("Escribe tu mensaje aquí:")
+
+        if st.button("Enviar"):
+            if user_input:
+                # Add user message to history
+                st.session_state.chat_history.append(("user", user_input))
+
+                # Get chatbot response
+                response = get_chatbot_response(user_input)
+
+                # Add chatbot response to history
+                st.session_state.chat_history.append(("bot", response))
+
+                # Clear input field
+                st.experimental_rerun()
+
+    with col2:
+        st.markdown(f"### {t['title']}")
+
+        if st.session_state.role == "Estudiante":
+            # Agregar un botón para ver el progreso del estudiante
+            if st.button("Ver mi progreso"):
+                student_data = get_student_data(st.session_state.username)
+                if student_data:
+                    st.success("Datos obtenidos exitosamente")
+
+                    # Mostrar estadísticas generales
+                    st.subheader("Estadísticas generales")
+                    st.write(f"Total de entradas: {student_data['entries_count']}")
+
+                    # Mostrar gráfico de conteo de palabras
+                    st.subheader("Conteo de palabras por categoría")
+                    st.bar_chart(student_data['word_count'])
+
+                    # Mostrar entradas recientes
+                    st.subheader("Entradas recientes")
+                    for entry in student_data['entries'][:5]:  # Mostrar las 5 entradas más recientes
+                        st.text_area(f"Entrada del {entry['timestamp']}", entry['text'], height=100)
+
+                    # Aquí puedes agregar más visualizaciones según necesites
+                else:
+                    st.warning("No se encontraron datos para este estudiante")
+
+        if st.session_state.role == "Estudiante":
+            # Student interface code
+            if 'input_text' not in st.session_state:
+                st.session_state.input_text = ""
+
+            sentence_input = st.text_area(t['input_label'], height=150, placeholder=t['input_placeholder'], value=st.session_state.input_text)
+            st.session_state.input_text = sentence_input
+
+            if st.button(t['analyze_button']):
+                if sentence_input:
+                    doc = nlp_models[lang_code](sentence_input)
+
+                    # Highlighted Repeated Words
+                    with st.expander(t['repeated_words'], expanded=True):
+                        word_colors = get_repeated_words_colors(doc)
+                        highlighted_text = highlight_repeated_words(doc, word_colors)
+                        st.markdown(highlighted_text, unsafe_allow_html=True)
+
+                    # Legend for grammatical categories
+                    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:
+                            legend_html += f"<div style='margin-right: 10px;'><span style='background-color: {color}; padding: 2px 5px;'>{POS_TRANSLATIONS[pos]}</span></div>"
+                    legend_html += "</div>"
+                    st.markdown(legend_html, unsafe_allow_html=True)
+
+                    # Arc Diagram
+                    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'<svg[^>]*>', lambda m: m.group(0).replace('height="450"', 'height="300"'), html)
+                            html = re.sub(r'<g [^>]*transform="translate\((\d+),(\d+)\)"', lambda m: f'<g transform="translate({m.group(1)},50)"', html)
+                            st.write(html, unsafe_allow_html=True)
+                            arc_diagrams.append(html)
+
+                    # Network graph
+                    with st.expander(t['network_diagram'], expanded=True):
+                        fig = visualize_syntax(sentence_input, nlp_models[lang_code], lang_code)
+                        st.pyplot(fig)
+
+                    # Store analysis results
+                    if store_analysis_result(
+                        st.session_state.username,
+                        sentence_input,
+                        word_colors,
+                        arc_diagrams,
+                        fig
+                    ):
+                        st.success("Análisis guardado correctamente.")
+                    else:
+                        st.error("Hubo un problema al guardar el análisis. Por favor, inténtelo de nuevo.")
+                        logger.error(f"Falló el guardado del análisis. Username: {st.session_state.username}")
+
+        elif st.session_state.role == "Profesor":
+            # Teacher interface code
+            st.write("Bienvenido, profesor. Aquí podrás ver el progreso de tus estudiantes.")
+            # Add logic to display student progress
+
+#####################################################################################################
+def main():
+    if not initialize_mongodb_connection():
+        st.warning("La conexión a la base de datos MongoDB no está disponible. Algunas funciones pueden no estar operativas.")
+
+    if 'logged_in' not in st.session_state:
+        st.session_state.logged_in = False
+
+    if not st.session_state.logged_in:
+        menu = ["Iniciar Sesión", "Registrarse"]
+        choice = st.sidebar.selectbox("Menu", menu)
+        if choice == "Iniciar Sesión":
+            login_page()
+        elif choice == "Registrarse":
+            register_page()
+    else:
+        if st.sidebar.button("Cerrar Sesión"):
+            st.session_state.logged_in = False
+            st.experimental_rerun()
+        main_app()
+
+if __name__ == "__main__":
+    main()

src/pre-requirements.txt

@@ -0,0 +1,3 @@
+#https://huggingface.co/spacy/es_core_news_lg/resolve/main/es_core_news_lg-any-py3-none-any.whl
+#https://huggingface.co/spacy/en_core_web_lg/resolve/main/en_core_web_lg-any-py3-none-any.whl
+#https://huggingface.co/spacy/fr_core_news_lg/resolve/main/fr_core_news_lg-any-py3-none-any.whl

src/requirements.txt

@@ -0,0 +1,59 @@
+anthropic
+azure-identity
+azure-cosmos
+antiword
+bcrypt
+certifi
+cairosvg
+python-dotenv
+drawSvg
+docx2txt
+
+# Modelos de spaCy desde Hugging Face
+# https://huggingface.co/spacy/es_core_news_lg/resolve/main/es_core_news_lg-any-py3-none-any.whl
+# https://huggingface.co/spacy/en_core_web_lg/resolve/main/en_core_web_lg-any-py3-none-any.whl
+# https://huggingface.co/spacy/fr_core_news_lg/resolve/main/fr_core_news_lg-any-py3-none-any.whl
+
+# Enlaces alternativos desde GitHub (comentados)
+es-core-news-lg @ https://github.com/explosion/spacy-models/releases/download/es_core_news_lg-3.8.0/es_core_news_lg-3.8.0-py3-none-any.whl
+en-core-web-lg @ https://github.com/explosion/spacy-models/releases/download/en_core_web_lg-3.8.0/en_core_web_lg-3.8.0-py3-none-any.whl
+fr-core-news-lg @ https://github.com/explosion/spacy-models/releases/download/fr_core_news_lg-3.8.0/fr_core_news_lg-3.8.0-py3-none-any.whl
+pt-core-news-lg @ https://github.com/explosion/spacy-models/releases/download/pt_core_news_lg-3.8.0/pt_core_news_lg-3.8.0-py3-none-any.whl
+
+numpy
+networkx
+matplotlib
+odfpy
+plotly
+pydantic
+python-dateutil
+pandas
+python-docx
+#pywin32
+pymssql
+python-dotenv
+pymongo
+PyPDF2
+rlPyCairo
+requests
+reportlab
+#spacy>=3.7.0,<3.8.0
+#spacy=3.8.0
+#spacy
+spacy-streamlit
+seaborn
+squarify
+streamlit
+streamlit-float
+streamlit-player
+streamlit-chat
+streamlit-antd-components
+streamlit-option-menu
+scipy
+sentencepiece
+scikit-learn
+svglib
+transformers
+torch
+tqdm
+thinc

src/research_cosmos_database.py

@@ -0,0 +1,38 @@
+from azure.cosmos import CosmosClient, exceptions
+import os
+
+def diagnose_cosmos_connection():
+    endpoint = os.environ.get("COSMOS_ENDPOINT")
+    key = os.environ.get("COSMOS_KEY")
+
+    if not all([endpoint, key]):
+        raise ValueError("Please ensure COSMOS_ENDPOINT and COSMOS_KEY are set.")
+
+    client = CosmosClient(endpoint, key)
+
+    print("Attempting to connect to Cosmos DB...")
+    try:
+        # List databases
+        print("Listing databases:")
+        databases = list(client.list_databases())
+        for db in databases:
+            print(f"- {db['id']}")
+
+            # Try to list containers for each database
+            try:
+                containers = list(client.get_database_client(db['id']).list_containers())
+                print(f"  Containers in {db['id']}:")
+                for container in containers:
+                    print(f"  - {container['id']}")
+            except exceptions.CosmosResourceNotFoundError:
+                print(f"  Unable to list containers in {db['id']}")
+            except Exception as e:
+                print(f"  Error listing containers in {db['id']}: {str(e)}")
+
+            print()  # Add a blank line for readability
+
+    except Exception as e:
+        print(f"Error: {str(e)}")
+
+if __name__ == "__main__":
+    diagnose_cosmos_connection()

src/run_app.py

@@ -0,0 +1,7 @@
+import subprocess
+import sys
+from setup_logging import setup_logging
+
+if __name__ == "__main__":
+    setup_logging()
+    subprocess.run([sys.executable, "-m", "streamlit", "run", "app.py", "--server.runOnSave=true"])

src/session_state.py

@@ -0,0 +1,24 @@
+import streamlit as st
+
+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'
+
+        # Inicializar la estructura para el chat morfosintáctico
+        st.session_state.morphosyntax_chat_history = []
+        st.session_state.morphosyntax_chat_input = ""
+
+def logout():
+    for key in list(st.session_state.keys()):
+        del st.session_state[key]
+    initialize_session_state()
+    st.session_state.logged_out = True  # Añadimos esta bandera
+
+# Exportar las funciones
+__all__ = ['initialize_session_state', 'logout']

src/setup_logging.py

@@ -0,0 +1,29 @@
+import logging
+from datetime import datetime
+import os
+
+def setup_logging():
+    log_dir = 'logs'
+    if not os.path.exists(log_dir):
+        os.makedirs(log_dir)
+
+    current_time = datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_filename = f'{log_dir}/app_log_{current_time}.txt'
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        filename=log_filename,
+        filemode='w'
+    )
+
+    console = logging.StreamHandler()
+    console.setLevel(logging.INFO)
+    formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
+    console.setFormatter(formatter)
+    logging.getLogger('').addHandler(console)
+
+    logging.info(f"Logging iniciado. Archivo de log: {log_filename}")
+
+if __name__ == "__main__":
+    setup_logging()

src/update_cosmos_index.py

@@ -0,0 +1,46 @@
+from azure.cosmos import CosmosClient, PartitionKey, exceptions
+import os
+
+def update_cosmos_indexing():
+    endpoint = os.environ.get("COSMOS_ENDPOINT")
+    key = os.environ.get("COSMOS_KEY")
+    database_name = "user_database"  # Cambiado de "sqllink" a "user_database"
+    container_name = "users"
+
+    if not all([endpoint, key, database_name, container_name]):
+        raise ValueError("Please ensure all required parameters are set.")
+
+    client = CosmosClient(endpoint, key)
+    database = client.get_database_client(database_name)
+    container = database.get_container_client(container_name)
+
+    print(f"Updating indexing policy for container {container_name}...")
+
+    indexing_policy = {
+        "indexingMode": "consistent",
+        "automatic": True,
+        "includedPaths": [
+            {"path": "/*"}
+        ],
+        "excludedPaths": [
+            {"path": "/_etag/?"}
+        ]
+    }
+
+    try:
+        container_def = container.read()
+        container_def['indexingPolicy'] = indexing_policy
+        partition_key_path = container_def['partitionKey']['paths'][0]
+
+        database.replace_container(
+            container_def,
+            partition_key=PartitionKey(path=partition_key_path)
+        )
+        print("Indexing policy updated successfully")
+    except exceptions.CosmosResourceNotFoundError as e:
+        print(f"Error: Container not found. {str(e)}")
+    except Exception as e:
+        print(f"An error occurred: {str(e)}")
+
+if __name__ == "__main__":
+    update_cosmos_indexing()