Upload 9 files

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,14 +1,14 @@
----
-title: G1a
-emoji: 🏆
-colorFrom: red
-colorTo: red
-sdk: gradio
-sdk_version: 5.9.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: AIdeaText Gradio version
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: G1a
+emoji: 🏆
+colorFrom: red
+colorTo: red
+sdk: gradio
+sdk_version: 5.9.1
+app_file: app.py
+pinned: false
+license: mit
+short_description: AIdeaText Gradio version
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,64 +1,105 @@
-import gradio as gr
-import os
-import logging
-
-from modules.ui.landing_ui import create_landing_interface
-from modules.ui.login_ui import create_login_interface
-from modules.database.database_init import initialize_database_connections
-
-# Configuración básica
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Verificar variables de entorno
-COSMOS_ENDPOINT = os.getenv("COSMOS_ENDPOINT")
-COSMOS_KEY = os.getenv("COSMOS_KEY")
-if not COSMOS_ENDPOINT or not COSMOS_KEY:
-    raise ValueError("Faltan variables de entorno: COSMOS_ENDPOINT y COSMOS_KEY.")
-
-# Inicializar la conexión a la base de datos
-if not initialize_database_connections():
-    raise ValueError("No se pudo inicializar la conexión a la base de datos.")
-
-def main_interface():
-    """
-    Crea la interfaz principal con redirección al login o landing.
-    """
-    with gr.Blocks() as app_interface:
-        # Contenedores para las páginas
-        landing_container = gr.Group(visible=True)
-        login_container = gr.Group(visible=False)
-
-        # Crear interfaces
-        landing_page = create_landing_interface()
-        login_page = create_login_interface()
-
-        # Manejo de navegación
-        def handle_navigation(page="landing"):
-            """
-            Redirige entre Landing Page y Login.
-            """
-            if page == "login":
-                return {
-                    landing_container: gr.update(visible=False),
-                    login_container: gr.update(visible=True),
-                }
-            return {
-                landing_container: gr.update(visible=True),
-                login_container: gr.update(visible=False),
-            }
-
-        # Landing Page
-        with landing_container:
-            landing_page(navigate_to_login=lambda: handle_navigation("login"))
-
-        # Login Page
-        with login_container:
-            login_page(navigate_back=lambda: handle_navigation("landing"))
-
-    return app_interface
-
-# Lanzar la aplicación
-if __name__ == "__main__":
-    app = main_interface()
-    app.launch(server_name="0.0.0.0", server_port=7860, auth=None)
+import gradio as gr
+import os
+import logging
+
+from modules.auth.auth import (
+    # Autenticación
+    authenticate_user,
+    authenticate_student,
+    authenticate_admin,
+    # Manejo de contraseñas
+    hash_password,
+    verify_password,
+    # Manejo de usuarios
+    register_student,
+    update_student_info,
+    delete_student,
+    # Interfaz de Gradio
+    create_auth_interface,
+    create_user_page
+)
+
+from modules.database.database_init import initialize_database_connections
+import spaces
+import torch
+
+zero = torch.Tensor([0]).cuda()
+print(zero.device) # <-- 'cpu' 🤔
+
+@spaces.GPU
+def greet(n):
+    print(zero.device) # <-- 'cuda:0' 🤗
+    return f"Hello {zero + n} Tensor"
+
+# Configuración básica
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Verificar variables de entorno
+COSMOS_ENDPOINT = os.getenv("COSMOS_ENDPOINT")
+COSMOS_KEY = os.getenv("COSMOS_KEY")
+if not COSMOS_ENDPOINT or not COSMOS_KEY:
+    raise ValueError("Faltan variables de entorno: COSMOS_ENDPOINT y COSMOS_KEY.")
+
+# Inicializar la conexión a la base de datos
+if not initialize_database_connections():
+    raise ValueError("No se pudo inicializar la conexión a la base de datos.")
+
+# Crear la interfaz de login
+# app = create_auth_interface()
+
+# Crear la interfaz de usuario y login
+def main_interface():
+    """
+    Crea la interfaz principal con redirección al login o user page.
+    """
+    with gr.Blocks() as app_interface:
+        # Contenedores para manejo de redirección
+        login_container = gr.Group(visible=True)
+        user_container = gr.Group(visible=False)
+
+        # Crear login_page y user_page
+        login_page = create_auth_interface()
+        user_page = create_user_page()
+
+        # Manejo de login exitoso
+        def handle_login_redirect(username=None, role=None):
+            """
+            Redirige entre la página de login y la página de usuario.
+            Args:
+                username (str): Nombre de usuario.
+                role (str): Rol del usuario.
+            Returns:
+                dict: Actualización de visibilidad de los contenedores.
+            """
+            if username and role:
+                return {
+                    login_container: gr.update(visible=False),
+                    user_container: gr.update(visible=True)
+                }
+            return {
+                login_container: gr.update(visible=True),
+                user_container: gr.update(visible=False)
+            }
+
+        # Contenedor de Login
+        with login_container:
+            login_page.render()  # Renderiza la página de login
+
+        # Contenedor de Usuario
+        with user_container:
+            user_page.render()  # Renderiza la página de usuario
+
+        # Conectar el manejo del login al evento `load`
+        login_page.load(
+            fn=handle_login_redirect,
+            inputs=[],
+            outputs=[login_container, user_container]
+        )
+
+    return app_interface
+
+# Lanzar la aplicación
+if __name__ == "__main__":
+    app = main_interface()
+    app.launch(server_name="0.0.0.0", server_port=7860, auth=None)

app_Old-6-1-2025.py

@@ -1,14 +1,14 @@
-import gradio as gr
-import spaces
-import torch
-
-zero = torch.Tensor([0]).cuda()
-print(zero.device) # <-- 'cpu' 🤔
-
-@spaces.GPU
-def greet(n):
-    print(zero.device) # <-- 'cuda:0' 🤗
-    return f"Hello {zero + n} Tensor"
-
-demo = gr.Interface(fn=greet, inputs=gr.Number(), outputs=gr.Text())
+import gradio as gr
+import spaces
+import torch
+
+zero = torch.Tensor([0]).cuda()
+print(zero.device) # <-- 'cpu' 🤔
+
+@spaces.GPU
+def greet(n):
+    print(zero.device) # <-- 'cuda:0' 🤗
+    return f"Hello {zero + n} Tensor"
+
+demo = gr.Interface(fn=greet, inputs=gr.Number(), outputs=gr.Text())
 demo.launch()

modules/auth/auth.py

@@ -1,32 +1,217 @@
-# modules/auth/auth.py
-
-import os
-import logging
-import bcrypt
-from azure.cosmos import CosmosClient
-from modules.database.sql_db import get_user
-
-logger = logging.getLogger(__name__)
-
-# Verificar las variables de entorno
-COSMOS_ENDPOINT = os.getenv("COSMOS_ENDPOINT")
-COSMOS_KEY = os.getenv("COSMOS_KEY")
-if not COSMOS_ENDPOINT or not COSMOS_KEY:
-    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY no están configuradas.")
-
-cosmos_client = CosmosClient(COSMOS_ENDPOINT, COSMOS_KEY)
-
-def authenticate_user(username: str, password: str):
-    """
-    Autentica un usuario utilizando la base de datos.
-    """
-    try:
-        user = get_user(username)
-        if user and bcrypt.checkpw(password.encode("utf-8"), user["password"].encode("utf-8")):
-            logger.info(f"Usuario autenticado: {username}")
-            return True, user["role"]
-        logger.warning(f"Credenciales incorrectas para: {username}")
-        return False, None
-    except Exception as e:
-        logger.error(f"Error autenticando a {username}: {e}")
-        return False, None
+# modules/auth/auth.py
+
+import gradio as gr
+import os
+import logging
+import bcrypt
+import base64
+from azure.cosmos import CosmosClient
+from azure.cosmos.exceptions import CosmosHttpResponseError
+from datetime import datetime, timezone
+
+from ..database.sql_db import (
+    get_user,
+    get_student_user,
+    create_student_user,
+    update_student_user,
+    delete_student_user,
+    record_login,
+    record_logout,
+)
+
+logger = logging.getLogger(__name__)
+
+# Verificar las variables de entorno necesarias
+COSMOS_ENDPOINT = os.getenv("COSMOS_ENDPOINT")
+COSMOS_KEY = os.getenv("COSMOS_KEY")
+
+if not COSMOS_ENDPOINT or not COSMOS_KEY:
+    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY no están configuradas.")
+
+# Validar y limpiar la clave de Cosmos DB
+def clean_and_validate_key(key):
+    key = key.strip()
+    while len(key) % 4 != 0:
+        key += "="
+    try:
+        base64.b64decode(key)
+        return key
+    except Exception:
+        raise ValueError("La clave proporcionada no es válida.")
+
+COSMOS_KEY = clean_and_validate_key(COSMOS_KEY)
+cosmos_client = CosmosClient(COSMOS_ENDPOINT, COSMOS_KEY)
+
+########################################
+# ÍNDICE DE FUNCIONES (Referencia consolidada)
+########################################
+# Autenticación
+# - authenticate_user
+# - authenticate_student
+# - authenticate_admin
+
+# Manejo de contraseñas
+# - hash_password
+# - verify_password
+
+# Manejo de usuarios
+# - register_student
+# - update_student_info
+# - delete_student
+
+# Interfaz de Gradio
+# - create_auth_interface
+# - create_user_page
+
+########################################
+# Funciones de Autenticación
+########################################
+
+def authenticate_user(username: str, password: str) -> tuple[bool, str | None]:
+    """
+    Autentica un usuario utilizando la base de datos.
+    """
+    try:
+        user = get_user(username)
+        if user and verify_password(user["password"], password):
+            logger.info(f"Usuario autenticado: {username}, Rol: {user['role']}")
+            return True, user["role"]
+        logger.warning(f"Credenciales incorrectas para el usuario: {username}")
+        return False, None
+    except Exception as e:
+        logger.error(f"Error autenticando al usuario {username}: {str(e)}")
+        return False, None
+
+def authenticate_student(username, password):
+    """Autentica a un estudiante."""
+    success, role = authenticate_user(username, password)
+    return (success, role) if role == "Estudiante" else (False, None)
+
+def authenticate_admin(username, password):
+    """Autentica a un administrador."""
+    success, role = authenticate_user(username, password)
+    return (success, role) if role == "Administrador" else (False, None)
+
+########################################
+# Registro y Manejo de Usuarios
+########################################
+
+def register_student(username: str, password: str, additional_info=None) -> bool:
+    """
+    Registra un nuevo estudiante.
+    """
+    try:
+        if get_student_user(username):
+            logger.warning(f"El estudiante {username} ya existe.")
+            return False
+
+        hashed_password = hash_password(password)
+        additional_info = additional_info or {}
+        additional_info["role"] = "Estudiante"
+
+        create_student_user(username, hashed_password, additional_info)
+        logger.info(f"Estudiante registrado: {username}")
+        return True
+    except Exception as e:
+        logger.error(f"Error registrando al estudiante {username}: {str(e)}")
+        return False
+
+def update_student_info(username: str, new_info: dict) -> bool:
+    """
+    Actualiza la información de un estudiante.
+    """
+    try:
+        if "password" in new_info:
+            new_info["password"] = hash_password(new_info["password"])
+        return update_student_user(username, new_info)
+    except Exception as e:
+        logger.error(f"Error actualizando información del estudiante {username}: {str(e)}")
+        return False
+
+def delete_student(username: str) -> bool:
+    """
+    Elimina un estudiante de la base de datos.
+    """
+    try:
+        return delete_student_user(username)
+    except Exception as e:
+        logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
+        return False
+
+########################################
+# Manejo de Contraseñas
+########################################
+
+def hash_password(password: str) -> str:
+    """Hashea una contraseña utilizando bcrypt."""
+    return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
+
+def verify_password(stored_password: str, provided_password: str) -> bool:
+    """Verifica que una contraseña coincida con su hash."""
+    return bcrypt.checkpw(provided_password.encode("utf-8"), stored_password.encode("utf-8"))
+
+########################################
+# Interfaz Gradio para Login
+########################################
+
+def create_auth_interface():
+    """
+    Crea la interfaz de autenticación.
+    """
+    with gr.Blocks() as auth_interface:
+        gr.Markdown("# Login")
+        username = gr.Textbox(label="Usuario")
+        password = gr.Textbox(label="Contraseña", type="password")
+        login_btn = gr.Button("Iniciar Sesión")
+        message = gr.Markdown()
+
+        def handle_login(user, pwd):
+            success, role = authenticate_user(user, pwd)
+            return f"Bienvenido, {user} ({role})" if success else "Credenciales incorrectas."
+
+        login_btn.click(fn=handle_login, inputs=[username, password], outputs=message)
+    return auth_interface
+
+########################################
+# Página de Usuario
+########################################
+
+def create_user_page():
+    """
+    Crea una página de usuario simple tras el inicio de sesión.
+    """
+    with gr.Blocks() as user_page:
+        gr.Markdown("# Bienvenido a la Página de Usuario")
+        gr.Markdown("Esta página está disponible después de un inicio de sesión exitoso.")
+
+        username = gr.Textbox(label="Usuario", interactive=False)
+        role = gr.Textbox(label="Rol", interactive=False)
+
+        def load_user_info():
+            return "UsuarioPrueba", "Estudiante"  # Simula datos de sesión
+
+        user_page.load(fn=load_user_info, inputs=[], outputs=[username, role])
+
+        gr.Button("Cerrar Sesión").click(
+            fn=lambda: "Sesión cerrada",
+            inputs=[],
+            outputs=[user_page]
+        )
+    return user_page
+
+########################################
+# Exportar Funciones
+########################################
+
+__all__ = [
+    "create_auth_interface",
+    "create_user_page",
+    "register_student",
+    "authenticate_user",
+    "authenticate_student",
+    "authenticate_admin",
+    "update_student_info",
+    "delete_student",
+    "hash_password",
+    "verify_password",
+]

modules/database/database_init.py

@@ -1,116 +1,116 @@
-# 1. modules/database/database_init.py
-
-import os
-import logging
-from azure.cosmos import CosmosClient
-from pymongo import MongoClient
-import certifi
-
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-# Variables globales para Cosmos DB SQL API
-cosmos_client = None
-user_database = None
-user_container = None
-application_requests_container = None
-user_feedback_container = None
-user_sessions_container = None
-
-# Variables globales para Cosmos DB MongoDB API
-mongo_client = None
-mongo_db = None
-
-###################################################################
-def verify_container_partition_key(container, expected_path):
-    """Verifica la configuración de partition key de un contenedor"""
-    try:
-        container_props = container.read()
-        partition_key_paths = container_props['partitionKey']['paths']
-        logger.info(f"Container: {container.id}, Partition Key Paths: {partition_key_paths}")
-        return expected_path in partition_key_paths
-    except Exception as e:
-        logger.error(f"Error verificando partition key en {container.id}: {str(e)}")
-        return False
-
-###################################################################
-def get_container(container_name):
-    """Obtiene un contenedor específico"""
-    global user_container, user_sessions_container
-    
-    if not initialize_cosmos_sql_connection():
-        logger.error("No se pudo inicializar la conexión")
-        return None
-    
-    containers = {
-        "users": user_container,
-        "users_sessions": user_sessions_container
-    }
-    
-    return containers.get(container_name)
-
-###################################################################
-def initialize_cosmos_sql_connection():
-    """Inicializa la conexión a Cosmos DB SQL API"""
-    global cosmos_client, user_database, user_container, user_sessions_container
-
-    try:
-        if cosmos_client and user_database and user_container and user_sessions_container:
-            return True
-
-        cosmos_endpoint = os.environ.get("COSMOS_ENDPOINT")
-        cosmos_key = os.environ.get("COSMOS_KEY")
-        
-        if not cosmos_endpoint or not cosmos_key:
-            raise ValueError("COSMOS_ENDPOINT y COSMOS_KEY deben estar configurados")
-
-        cosmos_client = CosmosClient(cosmos_endpoint, cosmos_key)
-        user_database = cosmos_client.get_database_client("user_database")
-        
-        # Inicializar contenedores manteniendo la estructura existente
-        user_container = user_database.get_container_client("users")
-        user_sessions_container = user_database.get_container_client("users_sessions")
-        
-        logger.info("Conexión a Cosmos DB SQL API exitosa")
-        return True
-
-    except Exception as e:
-        logger.error(f"Error al conectar con Cosmos DB SQL API: {str(e)}")
-        return False
-        
-###################################################################
-def initialize_mongodb_connection():
-    """Inicializa la conexión a MongoDB"""
-    global mongo_client, mongo_db
-    try:
-        connection_string = os.getenv("MONGODB_CONNECTION_STRING")
-        if not connection_string:
-            raise ValueError("MONGODB_CONNECTION_STRING debe estar configurado")
-
-        mongo_client = MongoClient(
-            connection_string,
-            tls=True,
-            tlsCAFile=certifi.where(),
-            retryWrites=False,
-            serverSelectionTimeoutMS=5000,
-            connectTimeoutMS=10000,
-            socketTimeoutMS=10000
-        )
-        
-        mongo_db = mongo_client['aideatext_db']
-        return True
-    except Exception as e:
-        logger.error(f"Error conectando a MongoDB: {str(e)}")
-        return False
-
-###################################################################
-def initialize_database_connections():
-    """Inicializa todas las conexiones"""
-    return initialize_cosmos_sql_connection() and initialize_mongodb_connection()
-
-###################################################################
-def get_mongodb():
-    """Obtiene la conexión MongoDB"""
-    if mongo_db is None:
-        initialize_mongodb_connection()
+# 1. modules/database/database_init.py
+
+import os
+import logging
+from azure.cosmos import CosmosClient
+from pymongo import MongoClient
+import certifi
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Variables globales para Cosmos DB SQL API
+cosmos_client = None
+user_database = None
+user_container = None
+application_requests_container = None
+user_feedback_container = None
+user_sessions_container = None
+
+# Variables globales para Cosmos DB MongoDB API
+mongo_client = None
+mongo_db = None
+
+###################################################################
+def verify_container_partition_key(container, expected_path):
+    """Verifica la configuración de partition key de un contenedor"""
+    try:
+        container_props = container.read()
+        partition_key_paths = container_props['partitionKey']['paths']
+        logger.info(f"Container: {container.id}, Partition Key Paths: {partition_key_paths}")
+        return expected_path in partition_key_paths
+    except Exception as e:
+        logger.error(f"Error verificando partition key en {container.id}: {str(e)}")
+        return False
+
+###################################################################
+def get_container(container_name):
+    """Obtiene un contenedor específico"""
+    global user_container, user_sessions_container
+    
+    if not initialize_cosmos_sql_connection():
+        logger.error("No se pudo inicializar la conexión")
+        return None
+    
+    containers = {
+        "users": user_container,
+        "users_sessions": user_sessions_container
+    }
+    
+    return containers.get(container_name)
+
+###################################################################
+def initialize_cosmos_sql_connection():
+    """Inicializa la conexión a Cosmos DB SQL API"""
+    global cosmos_client, user_database, user_container, user_sessions_container
+
+    try:
+        if cosmos_client and user_database and user_container and user_sessions_container:
+            return True
+
+        cosmos_endpoint = os.environ.get("COSMOS_ENDPOINT")
+        cosmos_key = os.environ.get("COSMOS_KEY")
+        
+        if not cosmos_endpoint or not cosmos_key:
+            raise ValueError("COSMOS_ENDPOINT y COSMOS_KEY deben estar configurados")
+
+        cosmos_client = CosmosClient(cosmos_endpoint, cosmos_key)
+        user_database = cosmos_client.get_database_client("user_database")
+        
+        # Inicializar contenedores manteniendo la estructura existente
+        user_container = user_database.get_container_client("users")
+        user_sessions_container = user_database.get_container_client("users_sessions")
+        
+        logger.info("Conexión a Cosmos DB SQL API exitosa")
+        return True
+
+    except Exception as e:
+        logger.error(f"Error al conectar con Cosmos DB SQL API: {str(e)}")
+        return False
+        
+###################################################################
+def initialize_mongodb_connection():
+    """Inicializa la conexión a MongoDB"""
+    global mongo_client, mongo_db
+    try:
+        connection_string = os.getenv("MONGODB_CONNECTION_STRING")
+        if not connection_string:
+            raise ValueError("MONGODB_CONNECTION_STRING debe estar configurado")
+
+        mongo_client = MongoClient(
+            connection_string,
+            tls=True,
+            tlsCAFile=certifi.where(),
+            retryWrites=False,
+            serverSelectionTimeoutMS=5000,
+            connectTimeoutMS=10000,
+            socketTimeoutMS=10000
+        )
+        
+        mongo_db = mongo_client['aideatext_db']
+        return True
+    except Exception as e:
+        logger.error(f"Error conectando a MongoDB: {str(e)}")
+        return False
+
+###################################################################
+def initialize_database_connections():
+    """Inicializa todas las conexiones"""
+    return initialize_cosmos_sql_connection() and initialize_mongodb_connection()
+
+###################################################################
+def get_mongodb():
+    """Obtiene la conexión MongoDB"""
+    if mongo_db is None:
+        initialize_mongodb_connection()
     return mongo_db

modules/database/mongo_db.py

@@ -1,64 +1,64 @@
-
-
-from .database_init import get_mongodb
-import logging
-
-logger = logging.getLogger(__name__)
-
-def get_collection(collection_name):
-    try:
-        db = get_mongodb()
-        if db is None:
-            logger.error(f"No se pudo obtener la base de datos para {collection_name}")
-            return None
-            
-        collection = db[collection_name]
-        logger.info(f"Colección {collection_name} obtenida exitosamente")
-        return collection
-        
-    except Exception as e:
-        logger.error(f"Error al obtener colección {collection_name}: {str(e)}")
-        return None
-
-def insert_document(collection_name, document):
-    collection = get_collection(collection_name)
-    try:
-        result = collection.insert_one(document)
-        logger.info(f"Documento insertado en {collection_name} con ID: {result.inserted_id}")
-        return result.inserted_id
-    except Exception as e:
-        logger.error(f"Error al insertar documento en {collection_name}: {str(e)}")
-        return None
-
-def find_documents(collection_name, query, sort=None, limit=None):
-    collection = get_collection(collection_name)
-    try:
-        cursor = collection.find(query)
-        if sort:
-            cursor = cursor.sort(sort)
-        if limit:
-            cursor = cursor.limit(limit)
-        return list(cursor)
-    except Exception as e:
-        logger.error(f"Error al buscar documentos en {collection_name}: {str(e)}")
-        return []
-
-def update_document(collection_name, query, update):
-    collection = get_collection(collection_name)
-    try:
-        result = collection.update_one(query, update)
-        logger.info(f"Documento actualizado en {collection_name}: {result.modified_count} modificado(s)")
-        return result.modified_count
-    except Exception as e:
-        logger.error(f"Error al actualizar documento en {collection_name}: {str(e)}")
-        return 0
-
-def delete_document(collection_name, query):
-    collection = get_collection(collection_name)
-    try:
-        result = collection.delete_one(query)
-        logger.info(f"Documento eliminado de {collection_name}: {result.deleted_count} eliminado(s)")
-        return result.deleted_count
-    except Exception as e:
-        logger.error(f"Error al eliminar documento de {collection_name}: {str(e)}")
+
+
+from .database_init import get_mongodb
+import logging
+
+logger = logging.getLogger(__name__)
+
+def get_collection(collection_name):
+    try:
+        db = get_mongodb()
+        if db is None:
+            logger.error(f"No se pudo obtener la base de datos para {collection_name}")
+            return None
+            
+        collection = db[collection_name]
+        logger.info(f"Colección {collection_name} obtenida exitosamente")
+        return collection
+        
+    except Exception as e:
+        logger.error(f"Error al obtener colección {collection_name}: {str(e)}")
+        return None
+
+def insert_document(collection_name, document):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.insert_one(document)
+        logger.info(f"Documento insertado en {collection_name} con ID: {result.inserted_id}")
+        return result.inserted_id
+    except Exception as e:
+        logger.error(f"Error al insertar documento en {collection_name}: {str(e)}")
+        return None
+
+def find_documents(collection_name, query, sort=None, limit=None):
+    collection = get_collection(collection_name)
+    try:
+        cursor = collection.find(query)
+        if sort:
+            cursor = cursor.sort(sort)
+        if limit:
+            cursor = cursor.limit(limit)
+        return list(cursor)
+    except Exception as e:
+        logger.error(f"Error al buscar documentos en {collection_name}: {str(e)}")
+        return []
+
+def update_document(collection_name, query, update):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.update_one(query, update)
+        logger.info(f"Documento actualizado en {collection_name}: {result.modified_count} modificado(s)")
+        return result.modified_count
+    except Exception as e:
+        logger.error(f"Error al actualizar documento en {collection_name}: {str(e)}")
+        return 0
+
+def delete_document(collection_name, query):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.delete_one(query)
+        logger.info(f"Documento eliminado de {collection_name}: {result.deleted_count} eliminado(s)")
+        return result.deleted_count
+    except Exception as e:
+        logger.error(f"Error al eliminar documento de {collection_name}: {str(e)}")
         return 0

modules/database/sql_db.py

@@ -1,307 +1,307 @@
-#modules/database/sql_db.py
-
-from .database_init import get_container
-from datetime import datetime, timezone
-import logging
-import bcrypt
-import uuid
-
-logger = logging.getLogger(__name__)
-
-def get_user(username, role=None):
-    container = get_container("users")
-    try:
-        query = f"SELECT * FROM c WHERE c.id = '{username}'"
-        if role:
-            query += f" AND c.role = '{role}'"
-        items = list(container.query_items(
-            query=query,
-            enable_cross_partition_query=True
-        ))
-        return items[0] if items else None
-    except Exception as e:
-        logger.error(f"Error al obtener usuario {username}: {str(e)}")
-        return None
-
-def get_admin_user(username):
-    return get_user(username, role='Administrador')
-
-def get_student_user(username):
-    return get_user(username, role='Estudiante')
-
-def get_teacher_user(username):
-    return get_user(username, role='Profesor')
-
-#################################################################################
-#El error ocurre porque el parámetro `partition_key` 
-#no es soportado en la versión actual del SDK. 
-#Modifiquemos la función `create_user()` para incluir la partición en el cuerpo del documento:
-
-def create_user(username, password, role, additional_info=None):
-    container = get_container("users")
-    if not container:
-        logger.error("No se pudo obtener el contenedor de usuarios")
-        return False
-        
-    try:
-        # Generar salt y hash de la contraseña
-        salt = bcrypt.gensalt()
-        hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
-        
-        user_data = {
-            'id': username,
-            'password': hashed.decode('utf-8'),
-            'salt': salt.decode('utf-8'),
-            'role': role,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'additional_info': additional_info or {},
-            # La partición va dentro del documento
-            'partitionKey': username
-        }
-        
-        container.create_item(body=user_data)
-        logger.info(f"Usuario {role} creado: {username}")
-        return True
-        
-    except Exception as e:
-        logger.error(f"Error al crear usuario {role}: {str(e)}")
-        return False
-
-#########################################################################
-def create_student_user(username, password, additional_info=None):
-    return create_user(username, password, 'Estudiante', additional_info)
-
-def create_teacher_user(username, password, additional_info=None):
-    return create_user(username, password, 'Profesor', additional_info)
-
-def create_admin_user(username, password, additional_info=None):
-    return create_user(username, password, 'Administrador', additional_info)
-
-############-- Funciones de control del tiempo de sesión ##################
-
-###########################################################
-
-def record_login(username):
-    """Registra el inicio de sesión de un usuario"""
-    try:
-        container = get_container("users_sessions")
-        if not container:
-            logger.error("No se pudo obtener el contenedor users_sessions")
-            return None
-
-        session_id = str(uuid.uuid4())
-        session_doc = {
-            "id": session_id,
-            "type": "session",
-            "username": username,
-            "loginTime": datetime.now(timezone.utc).isoformat(),
-            "additional_info": {},
-            # El campo para partition key debe estar en el documento
-            "partitionKey": username
-        }
-
-        # Crear el documento usando options
-        result = container.create_item(
-            body=session_doc,
-            enable_cross_partition_query=True
-        )
-        logger.info(f"Sesión {session_id} registrada para {username}")
-        return session_id
-    except Exception as e:
-        logger.error(f"Error registrando login: {str(e)}")
-        return None
-
-
-###########################################################
-
-def record_logout(username, session_id):
-    """Registra el cierre de sesión y calcula la duración"""
-    try:
-        container = get_container("users_sessions")
-        if not container:
-            logger.error("No se pudo obtener el contenedor users_sessions")
-            return False
-
-        # Obtener la sesión actual
-        query = "SELECT * FROM c WHERE c.id = @id AND c.username = @username"
-        params = [
-            {"name": "@id", "value": session_id},
-            {"name": "@username", "value": username}
-        ]
-        
-        items = list(container.query_items(
-            query=query,
-            parameters=params,
-            enable_cross_partition_query=True
-        ))
-
-        if not items:
-            logger.warning(f"Sesión no encontrada: {session_id}")
-            return False
-
-        session = items[0]
-        login_time = datetime.fromisoformat(session['loginTime'].rstrip('Z'))
-        logout_time = datetime.now(timezone.utc)
-        duration = int((logout_time - login_time).total_seconds())
-
-        session.update({
-            "logoutTime": logout_time.isoformat(),
-            "sessionDuration": duration
-        })
-
-        # Actualizar el documento
-        container.upsert_item(
-            body=session
-        )
-        logger.info(f"Sesión {session_id} cerrada para {username}, duración: {duration}s")
-        return True
-    except Exception as e:
-        logger.error(f"Error registrando logout: {str(e)}")
-        return False
-
-
-###########################################################
-
-def get_recent_sessions(limit=10):
-    """Obtiene las sesiones más recientes"""
-    try:
-        container = get_container("users_sessions")
-        if not container:
-            logger.error("No se pudo obtener el contenedor users_sessions")
-            return []
-
-        query = """
-        SELECT c.username, c.loginTime, c.logoutTime, c.sessionDuration
-        FROM c
-        WHERE c.type = 'session'
-        ORDER BY c.loginTime DESC
-        OFFSET 0 LIMIT @limit
-        """
-        
-        sessions = list(container.query_items(
-            query=query,
-            parameters=[{"name": "@limit", "value": limit}],
-            enable_cross_partition_query=True
-        ))
-
-        # Validar y limpiar los datos
-        clean_sessions = []
-        for session in sessions:
-            try:
-                clean_sessions.append({
-                    "username": session["username"],
-                    "loginTime": session["loginTime"],
-                    "logoutTime": session.get("logoutTime", "Activo"),
-                    "sessionDuration": session.get("sessionDuration", 0)
-                })
-            except KeyError as e:
-                logger.warning(f"Sesión con datos incompletos: {e}")
-                continue
-
-        return clean_sessions
-    except Exception as e:
-        logger.error(f"Error obteniendo sesiones recientes: {str(e)}")
-        return []
-
-
-
-###########################################################
-
-def get_user_total_time(username):
-    """Obtiene el tiempo total que un usuario ha pasado en la plataforma"""
-    try:
-        container = get_container("users_sessions")
-        if not container:
-            return None
-
-        query = """
-        SELECT VALUE SUM(c.sessionDuration)
-        FROM c
-        WHERE c.type = 'session'
-        AND c.username = @username
-        AND IS_DEFINED(c.sessionDuration)
-        """
-        
-        result = list(container.query_items(
-            query=query,
-            parameters=[{"name": "@username", "value": username}],
-            enable_cross_partition_query=True
-        ))
-
-        return result[0] if result and result[0] is not None else 0
-    except Exception as e:
-        logger.error(f"Error obteniendo tiempo total: {str(e)}")
-        return 0
-
-###########################################################
-def update_student_user(username, new_info):
-    user_container, _, _ = get_sql_containers()
-    try:
-        user = get_student_user(username)
-        if user:
-            user['additional_info'].update(new_info)
-            user_container.upsert_item(body=user)
-            logger.info(f"Información del estudiante actualizada: {username}")
-            return True
-        else:
-            logger.warning(f"Intento de actualizar estudiante no existente: {username}")
-            return False
-    except Exception as e:
-        logger.error(f"Error al actualizar información del estudiante {username}: {str(e)}")
-        return False
-
-
-def delete_student_user(username):
-    user_container, _, _ = get_sql_containers()
-    try:
-        user = get_student_user(username)
-        if user:
-            user_container.delete_item(item=user['id'], partition_key=username)
-            logger.info(f"Estudiante eliminado: {username}")
-            return True
-        else:
-            logger.warning(f"Intento de eliminar estudiante no existente: {username}")
-            return False
-    except Exception as e:
-        logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
-        return False
-
-def store_application_request(name, lastname, email, institution, current_role, desired_role, reason):
-    _, application_requests_container, _ = get_sql_containers()
-    try:
-        application_request = {
-            "id": str(uuid.uuid4()),
-            "name": name,
-            "lastname": lastname,
-            "email": email,
-            "institution": institution,
-            "current_role": current_role,
-            "desired_role": desired_role,
-            "reason": reason,
-            "requestDate": datetime.utcnow().isoformat()
-        }
-        application_requests_container.create_item(body=application_request)
-        logger.info(f"Solicitud de aplicación almacenada para el email: {email}")
-        return True
-    except Exception as e:
-        logger.error(f"Error al almacenar la solicitud de aplicación: {str(e)}")
-        return False
-
-def store_student_feedback(username, name, email, feedback):
-    _, _, user_feedback_container = get_sql_containers()
-    try:
-        feedback_item = {
-            "id": str(uuid.uuid4()),
-            "username": username,
-            "name": name,
-            "email": email,
-            "feedback": feedback,
-            "role": "Estudiante",
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-        }
-        result = user_feedback_container.create_item(body=feedback_item)
-        logger.info(f"Feedback de estudiante almacenado con ID: {result['id']} para el usuario: {username}")
-        return True
-    except Exception as e:
-        logger.error(f"Error al almacenar el feedback del estudiante {username}: {str(e)}")
+#modules/database/sql_db.py
+
+from .database_init import get_container
+from datetime import datetime, timezone
+import logging
+import bcrypt
+import uuid
+
+logger = logging.getLogger(__name__)
+
+def get_user(username, role=None):
+    container = get_container("users")
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        if role:
+            query += f" AND c.role = '{role}'"
+        items = list(container.query_items(
+            query=query,
+            enable_cross_partition_query=True
+        ))
+        return items[0] if items else None
+    except Exception as e:
+        logger.error(f"Error al obtener usuario {username}: {str(e)}")
+        return None
+
+def get_admin_user(username):
+    return get_user(username, role='Administrador')
+
+def get_student_user(username):
+    return get_user(username, role='Estudiante')
+
+def get_teacher_user(username):
+    return get_user(username, role='Profesor')
+
+#################################################################################
+#El error ocurre porque el parámetro `partition_key` 
+#no es soportado en la versión actual del SDK. 
+#Modifiquemos la función `create_user()` para incluir la partición en el cuerpo del documento:
+
+def create_user(username, password, role, additional_info=None):
+    container = get_container("users")
+    if not container:
+        logger.error("No se pudo obtener el contenedor de usuarios")
+        return False
+        
+    try:
+        # Generar salt y hash de la contraseña
+        salt = bcrypt.gensalt()
+        hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
+        
+        user_data = {
+            'id': username,
+            'password': hashed.decode('utf-8'),
+            'salt': salt.decode('utf-8'),
+            'role': role,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'additional_info': additional_info or {},
+            # La partición va dentro del documento
+            'partitionKey': username
+        }
+        
+        container.create_item(body=user_data)
+        logger.info(f"Usuario {role} creado: {username}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error al crear usuario {role}: {str(e)}")
+        return False
+
+#########################################################################
+def create_student_user(username, password, additional_info=None):
+    return create_user(username, password, 'Estudiante', additional_info)
+
+def create_teacher_user(username, password, additional_info=None):
+    return create_user(username, password, 'Profesor', additional_info)
+
+def create_admin_user(username, password, additional_info=None):
+    return create_user(username, password, 'Administrador', additional_info)
+
+############-- Funciones de control del tiempo de sesión ##################
+
+###########################################################
+
+def record_login(username):
+    """Registra el inicio de sesión de un usuario"""
+    try:
+        container = get_container("users_sessions")
+        if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
+            return None
+
+        session_id = str(uuid.uuid4())
+        session_doc = {
+            "id": session_id,
+            "type": "session",
+            "username": username,
+            "loginTime": datetime.now(timezone.utc).isoformat(),
+            "additional_info": {},
+            # El campo para partition key debe estar en el documento
+            "partitionKey": username
+        }
+
+        # Crear el documento usando options
+        result = container.create_item(
+            body=session_doc,
+            enable_cross_partition_query=True
+        )
+        logger.info(f"Sesión {session_id} registrada para {username}")
+        return session_id
+    except Exception as e:
+        logger.error(f"Error registrando login: {str(e)}")
+        return None
+
+
+###########################################################
+
+def record_logout(username, session_id):
+    """Registra el cierre de sesión y calcula la duración"""
+    try:
+        container = get_container("users_sessions")
+        if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
+            return False
+
+        # Obtener la sesión actual
+        query = "SELECT * FROM c WHERE c.id = @id AND c.username = @username"
+        params = [
+            {"name": "@id", "value": session_id},
+            {"name": "@username", "value": username}
+        ]
+        
+        items = list(container.query_items(
+            query=query,
+            parameters=params,
+            enable_cross_partition_query=True
+        ))
+
+        if not items:
+            logger.warning(f"Sesión no encontrada: {session_id}")
+            return False
+
+        session = items[0]
+        login_time = datetime.fromisoformat(session['loginTime'].rstrip('Z'))
+        logout_time = datetime.now(timezone.utc)
+        duration = int((logout_time - login_time).total_seconds())
+
+        session.update({
+            "logoutTime": logout_time.isoformat(),
+            "sessionDuration": duration
+        })
+
+        # Actualizar el documento
+        container.upsert_item(
+            body=session
+        )
+        logger.info(f"Sesión {session_id} cerrada para {username}, duración: {duration}s")
+        return True
+    except Exception as e:
+        logger.error(f"Error registrando logout: {str(e)}")
+        return False
+
+
+###########################################################
+
+def get_recent_sessions(limit=10):
+    """Obtiene las sesiones más recientes"""
+    try:
+        container = get_container("users_sessions")
+        if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
+            return []
+
+        query = """
+        SELECT c.username, c.loginTime, c.logoutTime, c.sessionDuration
+        FROM c
+        WHERE c.type = 'session'
+        ORDER BY c.loginTime DESC
+        OFFSET 0 LIMIT @limit
+        """
+        
+        sessions = list(container.query_items(
+            query=query,
+            parameters=[{"name": "@limit", "value": limit}],
+            enable_cross_partition_query=True
+        ))
+
+        # Validar y limpiar los datos
+        clean_sessions = []
+        for session in sessions:
+            try:
+                clean_sessions.append({
+                    "username": session["username"],
+                    "loginTime": session["loginTime"],
+                    "logoutTime": session.get("logoutTime", "Activo"),
+                    "sessionDuration": session.get("sessionDuration", 0)
+                })
+            except KeyError as e:
+                logger.warning(f"Sesión con datos incompletos: {e}")
+                continue
+
+        return clean_sessions
+    except Exception as e:
+        logger.error(f"Error obteniendo sesiones recientes: {str(e)}")
+        return []
+
+
+
+###########################################################
+
+def get_user_total_time(username):
+    """Obtiene el tiempo total que un usuario ha pasado en la plataforma"""
+    try:
+        container = get_container("users_sessions")
+        if not container:
+            return None
+
+        query = """
+        SELECT VALUE SUM(c.sessionDuration)
+        FROM c
+        WHERE c.type = 'session'
+        AND c.username = @username
+        AND IS_DEFINED(c.sessionDuration)
+        """
+        
+        result = list(container.query_items(
+            query=query,
+            parameters=[{"name": "@username", "value": username}],
+            enable_cross_partition_query=True
+        ))
+
+        return result[0] if result and result[0] is not None else 0
+    except Exception as e:
+        logger.error(f"Error obteniendo tiempo total: {str(e)}")
+        return 0
+
+###########################################################
+def update_student_user(username, new_info):
+    user_container, _, _ = get_sql_containers()
+    try:
+        user = get_student_user(username)
+        if user:
+            user['additional_info'].update(new_info)
+            user_container.upsert_item(body=user)
+            logger.info(f"Información del estudiante actualizada: {username}")
+            return True
+        else:
+            logger.warning(f"Intento de actualizar estudiante no existente: {username}")
+            return False
+    except Exception as e:
+        logger.error(f"Error al actualizar información del estudiante {username}: {str(e)}")
+        return False
+
+
+def delete_student_user(username):
+    user_container, _, _ = get_sql_containers()
+    try:
+        user = get_student_user(username)
+        if user:
+            user_container.delete_item(item=user['id'], partition_key=username)
+            logger.info(f"Estudiante eliminado: {username}")
+            return True
+        else:
+            logger.warning(f"Intento de eliminar estudiante no existente: {username}")
+            return False
+    except Exception as e:
+        logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
+        return False
+
+def store_application_request(name, lastname, email, institution, current_role, desired_role, reason):
+    _, application_requests_container, _ = get_sql_containers()
+    try:
+        application_request = {
+            "id": str(uuid.uuid4()),
+            "name": name,
+            "lastname": lastname,
+            "email": email,
+            "institution": institution,
+            "current_role": current_role,
+            "desired_role": desired_role,
+            "reason": reason,
+            "requestDate": datetime.utcnow().isoformat()
+        }
+        application_requests_container.create_item(body=application_request)
+        logger.info(f"Solicitud de aplicación almacenada para el email: {email}")
+        return True
+    except Exception as e:
+        logger.error(f"Error al almacenar la solicitud de aplicación: {str(e)}")
+        return False
+
+def store_student_feedback(username, name, email, feedback):
+    _, _, user_feedback_container = get_sql_containers()
+    try:
+        feedback_item = {
+            "id": str(uuid.uuid4()),
+            "username": username,
+            "name": name,
+            "email": email,
+            "feedback": feedback,
+            "role": "Estudiante",
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+        }
+        result = user_feedback_container.create_item(body=feedback_item)
+        logger.info(f"Feedback de estudiante almacenado con ID: {result['id']} para el usuario: {username}")
+        return True
+    except Exception as e:
+        logger.error(f"Error al almacenar el feedback del estudiante {username}: {str(e)}")
         return False

requirements.txt

@@ -1,54 +1,54 @@
-gradio
-azure-cosmos
-bcrypt
-
-anthropic
-azure-identity
-azure-cosmos
-antiword
-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.7.0/es_core_news_lg-3.7.0-py3-none-any.whl
-en-core-web-lg @ https://github.com/explosion/spacy-models/releases/download/en_core_web_lg-3.7.1/en_core_web_lg-3.7.1-py3-none-any.whl
-fr-core-news-lg @ https://github.com/explosion/spacy-models/releases/download/fr_core_news_lg-3.7.0/fr_core_news_lg-3.7.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
-spacy-streamlit
-seaborn
-squarify
-scipy
-sentencepiece
-scikit-learn
-svglib
-transformers
-torch
-tqdm
+gradio
+azure-cosmos
+bcrypt
+
+anthropic
+azure-identity
+azure-cosmos
+antiword
+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.7.0/es_core_news_lg-3.7.0-py3-none-any.whl
+en-core-web-lg @ https://github.com/explosion/spacy-models/releases/download/en_core_web_lg-3.7.1/en_core_web_lg-3.7.1-py3-none-any.whl
+fr-core-news-lg @ https://github.com/explosion/spacy-models/releases/download/fr_core_news_lg-3.7.0/fr_core_news_lg-3.7.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
+spacy-streamlit
+seaborn
+squarify
+scipy
+sentencepiece
+scikit-learn
+svglib
+transformers
+torch
+tqdm
 thinc