endpoint_biblioteca_funcionando

Apikeys_embedding.ipynb

@@ -121,7 +121,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "943d0deb",
    "metadata": {},
    "outputs": [

backend/api/v1/endpoints/ping.py

@@ -4,6 +4,6 @@ from fastapi import APIRouter
 
 router = APIRouter()
 
-@router.get("/ping")
+@router.get("/")
 async def ping():
     return {"message": "pong"}

backend/api/v1/endpoints/text_manager.py

@@ -1,26 +0,0 @@
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-from typing import Optional
-from backend.db.conexion import get_conexion
-from src.TextManager.biblioteca import Biblioteca
-
-router = APIRouter()
-
-class BibliotecaIn(BaseModel):
-    nombre: str
-    descripcion: Optional[str] = ""
-    vector_dim: Optional[int] = None
-
-@router.post("/")
-def crear_biblioteca(biblio: BibliotecaIn):
-    try:
-        biblioteca = Biblioteca(
-            nombre=biblio.nombre,
-            descripcion=biblio.descripcion,
-            vector_dim=biblio.vector_dim
-        )
-        conexion = get_conexion()
-        modelo = biblioteca.generar_modelo_notas(conexion)
-        return {"id": biblioteca.id, "modelo": str(modelo.__name__)}
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))

backend/api/v1/endpoints/text_manager_endpoint.py

@@ -0,0 +1,21 @@
+# backend/api/v1/biblioteca.py
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+from backend.db.conexion import get_conexion
+from backend.services.text_manager import crear_biblioteca
+from src.ConexionSql.Postgres_conexion import PostgresConexion
+
+router = APIRouter()
+
+class BibliotecaInput(BaseModel):
+    nombre_biblioteca: str
+    descripcion: str
+
+@router.post("/")
+def crear_biblioteca_endpoint(
+    data: BibliotecaInput,
+    conexion: PostgresConexion = Depends(get_conexion)
+):
+    return crear_biblioteca(nombre_biblioteca=data.nombre_biblioteca,
+                            descripcion=data.descripcion,
+                             conexion=conexion)

backend/api/v1/router.py

@@ -1,8 +1,8 @@
 # backend/api/router.py
 
 from fastapi import APIRouter
-from backend.api.v1.endpoints import ping, nota, text_manager
+from backend.api.v1.endpoints import ping, text_manager_endpoint
 
 router = APIRouter()
 router.include_router(ping.router, prefix="/api/v1/ping")
-router.include_router(text_manager.router, prefix="/api/v1/bibliotecas")
+router.include_router(text_manager_endpoint.router, prefix="/api/v1/text_manager")

backend/db/conexion.py

@@ -1,19 +1,10 @@
+# backend/db/conexion.py
+from entrypoint.init_db import db_credencial
 from src.ConexionSql.Postgres_conexion import PostgresConexion
-from src.Credenciales.postgres_credencial import PostgresCredencial
-from dotenv import load_dotenv
-import os
-from entrypoint import ENV_PATH
-
-# Cargar .env
-load_dotenv(ENV_PATH)
 
 def get_conexion():
-    db_credencial = PostgresCredencial(
+    conexion = PostgresConexion(db_credencial)
-        titulo=os.getenv("DB_TITLE"),
+    try:
-        user=os.getenv("DB_USER"),
+        yield conexion
-        password=os.getenv("DB_PASSWORD"),
+    finally:
-        host=os.getenv("DB_HOST"),
+        conexion.close()
-        port=os.getenv("DB_PORT"),
-        dbname=os.getenv("DB_NAME")
-    )
-    return PostgresConexion(db_credencial)

backend/services/text_manager.py

@@ -0,0 +1,30 @@
+from src.TextManager.biblioteca import Biblioteca
+from src.TextManager.biblioteca_mmr import BibliotecaRepo
+from src.Llms.Embedders.Openai_embedder import OpenAIEmbedder
+from src.ApiKeys.openai_apikey_mmr import OpenAICredencialRepo
+from src.ConexionSql.Postgres_conexion import PostgresConexion
+from backend.db.conexion import get_conexion
+
+
+def crear_biblioteca(nombre_biblioteca: str, conexion: PostgresConexion, descripcion: str):
+    cred_repo = OpenAICredencialRepo(conexion)
+    credencial = cred_repo.get_by_id("OPAK20250510-ac2cea8af3110632314")
+
+    embedder = OpenAIEmbedder(credencial, model="text-embedding-3-large")
+    biblioteca = Biblioteca(nombre=nombre_biblioteca,
+                             embedder=embedder,
+                             descripcion=descripcion)
+
+    repo = BibliotecaRepo(conexion)
+    repo.add(biblioteca=biblioteca)
+
+    biblioteca.generar_modelo_notas(conexion)
+
+    return {
+        "mensaje": f"Biblioteca '{nombre_biblioteca}' creada con éxito.",
+        "id": biblioteca.id
+    }
+
+
+if __name__ == "__main__":
+    crear_biblioteca("hola_intento5")

borrar_pycache.py

@@ -0,0 +1,17 @@
+import os
+import shutil
+
+def eliminar_pycache(directorio):
+    eliminados = 0
+    for root, dirs, files in os.walk(directorio):
+        for d in dirs:
+            if d == "__pycache__":
+                ruta = os.path.join(root, d)
+                print(f"🗑️ Eliminando: {ruta}")
+                shutil.rmtree(ruta)
+                eliminados += 1
+    print(f"\n✅ Eliminados {eliminados} directorios '__pycache__'.")
+
+if __name__ == "__main__":
+    ruta_raiz = os.path.dirname(os.path.abspath(__file__))  # Carpeta actual
+    eliminar_pycache(ruta_raiz)

entrypoint/init_db.py

@@ -43,7 +43,7 @@ def init_db():
     
     # Crear engine desde la clase de conexión PostgreSQL
     conexion = PostgresConexion(db_credencial)
-    engine = conexion.engine  # Recuperamos el engine directamente
+    engine = conexion.get_engine()  # Recuperamos el engine directamente
 
     print("Creando tablas...")
     Base.metadata.create_all(engine)

frontend/src/components/LlamadorAPI.tsx

@@ -13,7 +13,7 @@ import { MetodoSelect } from './MetodoSelect';
 import { useMantineTheme } from '@mantine/core';
 
 export function LlamadorAPI() {
-  const [direccion, setDireccion] = useState('http://localhost:8000/api/saludo');
+  const [direccion, setDireccion] = useState('http://localhost:8000/api/v1/ping/');
   const [metodo, setMetodo] = useState('GET');
   const [contenido, setContenido] = useState('');
   const [respuesta, setRespuesta] = useState('');

src/ConexionSql/Base_conexion.py

@@ -1,12 +1,39 @@
 from abc import ABC, abstractmethod
-from sqlalchemy.orm import Session
+from datetime import datetime, timezone
+from sqlalchemy.orm import Session, sessionmaker
 from sqlalchemy.engine import Engine
+from sqlalchemy import create_engine, text
+from sqlalchemy.exc import SQLAlchemyError
 
 class ConexionBase(ABC):
+    def __init__(self, uri: str):
+        self.estado = "pendiente"
+        self.timestamp = datetime.now(timezone.utc)
+        self._engine: Engine = create_engine(uri)
+        self._Session = sessionmaker(bind=self._engine)
+        self._session_instance: Session | None = None
+
     @abstractmethod
     def get_session(self) -> Session:
-        pass
+        if self._session_instance is None:
+            self._session_instance = self._Session()
+        return self._session_instance
 
     @abstractmethod
     def get_engine(self) -> Engine:
-        pass
+        return self._engine
+
+    def probar_conexion(self) -> bool:
+        try:
+            with self._engine.connect() as connection:
+                connection.execute(text("SELECT 1"))
+            self.estado = "exito"
+            return True
+        except SQLAlchemyError:
+            self.estado = "fallo"
+            return False
+
+    def close(self):
+        if self._session_instance is not None:
+            self._session_instance.close()
+            self._session_instance = None

src/ConexionSql/Postgres_conexion.py

@@ -4,7 +4,6 @@ from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import sessionmaker, Session
 from sqlalchemy.engine import Engine
 
-
 from src.ConexionSql.Base_conexion import ConexionBase
 from src.Credenciales.postgres_credencial import PostgresCredencial
 
@@ -32,9 +31,13 @@ class PostgresConexion(ConexionBase):
         self._engine: Engine = create_engine(uri)
         self._Session = sessionmaker(bind=self._engine)
 
+        # ✅ INICIALIZAR LA SESIÓN AQUÍ
+        self._session_instance: Session | None = None
 
     def get_session(self) -> Session:
-        return self._Session()
+        if self._session_instance is None:
+            self._session_instance = self._Session()
+        return self._session_instance
 
     def get_engine(self) -> Engine:
         return self._engine
@@ -48,3 +51,8 @@ class PostgresConexion(ConexionBase):
         except SQLAlchemyError:
             self.estado = "fallo"
             return False
+
+    def close(self):
+        if self._session_instance is not None:
+            self._session_instance.close()
+            self._session_instance = None