Fitz_Studio/backend/backend_domains/text_manager/text_manager_srvc.py

from domains.TextManager.biblioteca import Biblioteca
from domains.TextManager.biblioteca_mmr import BibliotecaRepo
from domains.Llms.Embedders.Openai_embedder import OpenAIEmbedder
from domains.ApiKeys.openai_apikey_mmr import OpenAICredencialRepo
from domains.ConexionSql.Postgres_conexion import PostgresConexion
from domains.TextManager.nota import Nota
from domains.TextManager.notas_mmr import generar_tabla_nota_para_biblioteca, NotaRepo
from sqlalchemy import MetaData
from backend.backend_domains.text_manager.text_manager_schema import NotaInput

from entrypoint.init_db import db_credencial
from domains.Logger.logger_db import LoggerDB, logger
LoggerDB(db_credencial, "logger_textos", created_by="sistema")

def crear_biblioteca(nombre_biblioteca: str, conexion: PostgresConexion, descripcion: str = None):
    logger.info("[INICIO] Creando biblioteca...")

    try:
        logger.info("[Paso 1] Obteniendo credencial...")
        cred_repo = OpenAICredencialRepo(conexion)
        credencial = cred_repo.get_by_id("OPAK20250513-61b29978b7604031014")
        logger.debug(f"[OK] Credencial obtenida: {credencial.titulo if credencial else '❌ None'}")

        logger.info("[Paso 2] Instanciando embedder...")
        embedder = OpenAIEmbedder(credencial, model="text-embedding-3-large")
        logger.debug("[OK] Embedder instanciado")

        logger.info("[Paso 3] Instanciando biblioteca...")
        biblioteca = Biblioteca(
            nombre=nombre_biblioteca,
            embedder=embedder,
            descripcion=descripcion
        )
        logger.debug(f"[OK] Biblioteca instanciada con ID: {biblioteca.id}")

        logger.info("[Paso 4] Guardando en base de datos...")
        repo = BibliotecaRepo(conexion)
        repo.add(biblioteca=biblioteca)
        logger.success("[OK] Biblioteca guardada")

        logger.info("[Paso 5] Generando modelo de notas...")
        biblioteca.generar_modelo_notas(conexion)
        logger.success("[OK] Modelo de notas generado")

        logger.success("[FIN] Biblioteca creada correctamente")
        return {
            "mensaje": f"Biblioteca '{nombre_biblioteca}' creada con éxito.",
            "id": biblioteca.id
        }

    except Exception as e:
        logger.exception("[ERROR] Ocurrió una excepción:")
        raise


def listar_bibliotecas(conexion: PostgresConexion) -> list[dict]:
    repo = BibliotecaRepo(conexion)
    bibliotecas: list[Biblioteca] = repo.get_all()
    return [
        {
            "id": b.id,
            "nombre": b.nombre,
            "descripcion": b.descripcion,
            "vector_dim": b.vector_dim
        }
        for b in bibliotecas
    ]


def agregar_nota_a_biblioteca(
    conexion: PostgresConexion,
    biblioteca_id: str,
    titulo: str,
    texto: str = "",
    tags: list[str] = None,
    conexiones: list[str] = None,
    resumen: str = ""
):
    repo_biblioteca = BibliotecaRepo(conexion)
    biblioteca = repo_biblioteca.get_by_id(biblioteca_id)
    if biblioteca is None:
        raise ValueError(f"No se encontró la biblioteca con ID {biblioteca_id}")

    nota = Nota(
        titulo=titulo,
        texto=texto,
        tags=tags or [],
        conexiones=conexiones or [],
        resumen=resumen or "",
    )
    logger.debug(
        f"[DEBUG] Nota creada: titulo='{nota.titulo}', "
        f"texto_len={len(nota.texto)}, "
        f"tags={len(nota.tags)}, "
        f"conexiones={len(nota.conexiones)}, "
        f"resumen_len={len(nota.resumen)}"
    )

    metadata = MetaData()
    tabla, ModeloNota = generar_tabla_nota_para_biblioteca(
        biblioteca.nombre,
        biblioteca.vector_dim,
        metadata
    )
    metadata.create_all(conexion.get_engine())

    repo_nota = NotaRepo(conexion.get_session(), ModeloNota)
    nota_id = repo_nota.add(nota)

    resultado = {
        "mensaje": f"Nota '{titulo}' agregada con éxito a la biblioteca '{biblioteca.nombre}'.",
        "nota_id": nota_id
    }

    logger.success(f"[SUCCESS] {resultado['mensaje']}")
    return resultado


def listar_notas_de_biblioteca(conexion: PostgresConexion, biblioteca_id: str) -> list[dict]:
    repo_biblioteca = BibliotecaRepo(conexion)
    biblioteca = repo_biblioteca.get_by_id(biblioteca_id)
    if not biblioteca:
        raise ValueError(f"No se encontró la biblioteca con ID: {biblioteca_id}")

    metadata = MetaData()
    tabla, ModeloNota = generar_tabla_nota_para_biblioteca(biblioteca.nombre, biblioteca.vector_dim, metadata)
    metadata.create_all(conexion.get_engine())

    repo_nota = NotaRepo(conexion.get_session(), ModeloNota)
    notas = repo_nota.get_all()
    return [
        {
            "id": n.id,
            "titulo": n.titulo,
            "tags": n.tags,
            "texto": n.texto,
            "resumen": n.resumen,
            "conexiones": n.conexiones
        }
        for n in notas
    ]


def eliminar_nota(conexion: PostgresConexion, biblioteca_id: str, nota_id: str) -> dict:
    repo_biblioteca = BibliotecaRepo(conexion)
    biblioteca = repo_biblioteca.get_by_id(biblioteca_id)
    if not biblioteca:
        raise ValueError(f"No se encontró la biblioteca con ID: {biblioteca_id}")

    metadata = MetaData()
    _, ModeloNota = generar_tabla_nota_para_biblioteca(biblioteca.nombre, biblioteca.vector_dim, metadata)
    metadata.create_all(conexion.get_engine())

    repo_nota = NotaRepo(conexion.get_session(), ModeloNota)
    fue_eliminada = repo_nota.delete_by_id(nota_id)

    if fue_eliminada:
        logger.success(f"Nota '{nota_id}' eliminada correctamente.")
        return {"mensaje": f"Nota '{nota_id}' eliminada correctamente."}
    else:
        raise ValueError(f"No se encontró la nota con ID: {nota_id}")


def actualizar_nota(conexion: PostgresConexion, biblioteca_id: str, nota_id: str, nota_input: NotaInput) -> dict:
    repo_biblioteca = BibliotecaRepo(conexion)
    biblioteca = repo_biblioteca.get_by_id(biblioteca_id)
    if not biblioteca:
        raise ValueError(f"No se encontró la biblioteca con ID: {biblioteca_id}")

    metadata = MetaData()
    _, ModeloNota = generar_tabla_nota_para_biblioteca(biblioteca.nombre, biblioteca.vector_dim, metadata)
    metadata.create_all(conexion.get_engine())

    repo_nota = NotaRepo(conexion.get_session(), ModeloNota)
    nota_actualizada = Nota(
        titulo=nota_input.titulo,
        texto=nota_input.texto,
        tags=nota_input.tags or [],
        conexiones=nota_input.conexiones or [],
        resumen=nota_input.resumen or ""
    )
    fue_actualizada = repo_nota.update(nota_id, nota_actualizada)

    if fue_actualizada:
        logger.success(f"Nota '{nota_id}' actualizada correctamente.")
        return {"mensaje": f"Nota '{nota_id}' actualizada correctamente."}
    else:
        raise ValueError(f"No se encontró la nota con ID: {nota_id}")