feat: Implement main application shell with navigation and color scheme toggle
- Added Appshell component with responsive navbar and main content area - Integrated ColorSchemeToggle for light/dark mode switching - Created Welcome component with styled title and introductory text - Developed ChatPage for LLM interaction with WebSocket support - Implemented Biblioteca for managing notes with rich text editor - Added LoginPage for user authentication with error handling - Introduced MessageList and MessageBubble components for chat messages - Styled components with CSS modules for consistent design
This commit is contained in:
@@ -0,0 +1,59 @@
|
||||
from domains.Security.GenerarIDs import GeneradorIDUnico
|
||||
from domains.Llms.Embedders.Base_Embedder import EmbedderABC # Asegúrate de que esta ruta sea correcta
|
||||
from typing import List, Optional
|
||||
from domains.ConexionSql.Base_conexion import ConexionBase
|
||||
from sqlalchemy import MetaData # Asegúrate de importar esto
|
||||
from domains.TextManager.notas_mmr import generar_tabla_nota_para_biblioteca # Ajusta si es necesario
|
||||
from sqlalchemy import inspect
|
||||
from domains.base import Base
|
||||
|
||||
|
||||
class Biblioteca:
|
||||
def __init__(
|
||||
self,
|
||||
nombre: str,
|
||||
descripcion: str = "",
|
||||
id: Optional[str] = None,
|
||||
embedder: Optional[EmbedderABC] = None,
|
||||
vector_dim: Optional[int] = None
|
||||
):
|
||||
"""
|
||||
Clase que representa una biblioteca de notas de texto.
|
||||
|
||||
:param nombre: Nombre de la biblioteca.
|
||||
:param descripcion: Breve descripción de la biblioteca.
|
||||
:param id: ID único opcional. Si no se proporciona, se genera automáticamente.
|
||||
:param embedder: Objeto que implementa EmbedderABC para generar el vector del nombre.
|
||||
:param vector_dim: Dimensión del vector si no se proporciona un embedder.
|
||||
"""
|
||||
self.id = id if id is not None else GeneradorIDUnico("BBLI").generar()
|
||||
self.nombre = nombre if "biblio" in nombre else f"biblio_{nombre}"
|
||||
self.descripcion = descripcion
|
||||
self.embedder = embedder
|
||||
|
||||
if self.embedder is not None:
|
||||
self.vector_dim = self.embedder.dimension_number()
|
||||
elif vector_dim is not None:
|
||||
self.vector_dim = vector_dim
|
||||
else:
|
||||
raise ValueError("Debes proporcionar un 'embedder' o un 'vector_dim' explícito.")
|
||||
|
||||
def generar_modelo_notas(self, conexion: ConexionBase):
|
||||
nombre_tabla = f"{self.nombre}"
|
||||
print(f"[Notas] Generando tabla: {nombre_tabla}")
|
||||
|
||||
engine = conexion.get_engine()
|
||||
inspector = inspect(engine)
|
||||
|
||||
if inspector.has_table(nombre_tabla):
|
||||
print(f"[Notas] ❌ Ya existe la tabla {nombre_tabla}")
|
||||
raise ValueError(f"Ya existe una tabla con el nombre '{nombre_tabla}' en la base de datos.")
|
||||
|
||||
print("[Notas] Generando definición SQL...")
|
||||
tabla, NotaModel = generar_tabla_nota_para_biblioteca(nombre_tabla, self.vector_dim, Base.metadata)
|
||||
|
||||
print("[Notas] Creando tabla en base de datos...")
|
||||
Base.metadata.create_all(engine)
|
||||
print("[Notas] ✔️ Tabla creada")
|
||||
|
||||
return NotaModel
|
||||
@@ -0,0 +1,112 @@
|
||||
import os
|
||||
import base64
|
||||
from dotenv import load_dotenv
|
||||
from sqlalchemy import Column, String, Integer
|
||||
|
||||
from domains.ArquitectureLayer.Mapper import Mapper_base
|
||||
from domains.ArquitectureLayer.Model import Model_base
|
||||
from domains.ArquitectureLayer.Repo import Repo_base
|
||||
|
||||
from domains.ConexionSql.Base_conexion import ConexionBase
|
||||
from domains.base import Base
|
||||
from domains.Security.Encriptar import Encriptar_fernet
|
||||
from domains.Security.GenerarIDs import GeneradorIDUnico
|
||||
from domains.Llms.Embedders.Base_Embedder import EmbedderABC
|
||||
from domains.TextManager.biblioteca import Biblioteca # Suponiendo que defines la clase lógica Biblioteca aquí
|
||||
|
||||
# ----------------------
|
||||
# Cargar clave maestra
|
||||
# ----------------------
|
||||
from entrypoint import ENV_PATH
|
||||
load_dotenv(ENV_PATH)
|
||||
pssword = os.getenv('MASTER_PASSWORD')
|
||||
if pssword is None:
|
||||
raise ValueError("MASTER_PASSWORD no está definida en el archivo .env")
|
||||
|
||||
# ----------------------
|
||||
# MODELO (SQLAlchemy)
|
||||
# ----------------------
|
||||
|
||||
class BibliotecaModel(Base, Model_base):
|
||||
__tablename__ = "bibliotecas"
|
||||
|
||||
id = Column(String, primary_key=True, unique=True)
|
||||
nombre = Column(String, nullable=False, unique=True)
|
||||
|
||||
descripcion = Column(String, nullable=False, default="")
|
||||
|
||||
vector_dim = Column(Integer, nullable=False)
|
||||
|
||||
embedder_info = Column(String, nullable=True) # Nombre de clase, ID de configuración, o info encriptada del embedder
|
||||
|
||||
# ----------------------
|
||||
# MAPPER
|
||||
# ----------------------
|
||||
|
||||
class BibliotecaMapper(Mapper_base[Biblioteca, BibliotecaModel]):
|
||||
|
||||
@staticmethod
|
||||
def to_model(obj: Biblioteca) -> BibliotecaModel:
|
||||
return BibliotecaModel(
|
||||
id=obj.id,
|
||||
nombre=obj.nombre,
|
||||
descripcion=obj.descripcion,
|
||||
vector_dim=obj.vector_dim
|
||||
# embedder no se serializa en el modelo, se maneja por separado
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def from_model(model: BibliotecaModel) -> Biblioteca:
|
||||
return Biblioteca(
|
||||
id=model.id,
|
||||
nombre=model.nombre,
|
||||
descripcion=model.descripcion,
|
||||
vector_dim=model.vector_dim,
|
||||
embedder=None # se deja para inyección posterior si es necesario
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def to_dict(obj: Biblioteca) -> dict:
|
||||
embedder_info = type(obj.embedder).__name__ if obj.embedder else None
|
||||
return {
|
||||
"id": obj.id,
|
||||
"nombre": obj.nombre,
|
||||
"descripcion": obj.descripcion,
|
||||
"vector_dim": obj.vector_dim,
|
||||
"embedder_info": embedder_info
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def from_dict(data: dict) -> Biblioteca:
|
||||
return Biblioteca(
|
||||
id=data["id"],
|
||||
nombre=data["nombre"],
|
||||
descripcion=data["descripcion"],
|
||||
vector_dim=data["vector_dim"],
|
||||
embedder=None # inyección manual si se desea
|
||||
)
|
||||
|
||||
|
||||
# ----------------------
|
||||
# REPO
|
||||
# ----------------------
|
||||
|
||||
class BibliotecaRepo(Repo_base[BibliotecaModel, Biblioteca]):
|
||||
def __init__(self, conexion: ConexionBase):
|
||||
super().__init__(
|
||||
session=conexion.get_session(),
|
||||
modelo=BibliotecaModel,
|
||||
mapper=BibliotecaMapper
|
||||
)
|
||||
|
||||
def add(self, biblioteca: Biblioteca, created_by: str = None, notes: str = None) -> str:
|
||||
# Lógica personalizada: prevenir duplicados por nombre
|
||||
existente = self.session.query(self.Modelo).filter_by(nombre=biblioteca.nombre).first()
|
||||
if existente:
|
||||
raise ValueError(f"Ya existe una biblioteca con el nombre '{biblioteca.nombre}'")
|
||||
|
||||
return super().add(biblioteca, created_by=created_by, notes=notes)
|
||||
|
||||
def get_by_nombre(self, nombre: str) -> Biblioteca | None:
|
||||
model = self.session.query(self.Modelo).filter_by(nombre=nombre, sys_deleted_at=None).first()
|
||||
return self.Mapper.from_model(model) if model else None
|
||||
@@ -0,0 +1,41 @@
|
||||
from domains.Security.GenerarIDs import GeneradorIDUnico
|
||||
from typing import List
|
||||
|
||||
class Nota:
|
||||
def __init__(
|
||||
self,
|
||||
titulo: str,
|
||||
tags: List[str] = None,
|
||||
conexiones: List[str] = None,
|
||||
texto: str = "",
|
||||
vector: List[float] = None,
|
||||
resumen: str = "",
|
||||
vector_resumen: List[float] = None,
|
||||
id: str = None
|
||||
):
|
||||
"""
|
||||
Clase que representa una nota de texto con estructura semántica.
|
||||
|
||||
:param titulo: Título de la nota.
|
||||
:param tags: Lista de etiquetas asociadas.
|
||||
:param conexiones: Lista de identificadores relacionados.
|
||||
:param vector: Embedding vectorial de la nota.
|
||||
:param resumen: Texto resumen de la nota.
|
||||
:param vector_resumen: Embedding del resumen.
|
||||
:param id: Identificador único (si no se proporciona, se genera automáticamente).
|
||||
"""
|
||||
self.id = id if id is not None else GeneradorIDUnico("NOTA").generar()
|
||||
self.titulo = titulo
|
||||
self.tags = tags if tags is not None else []
|
||||
self.conexiones = conexiones if conexiones is not None else []
|
||||
self.texto = texto
|
||||
self.vector = vector
|
||||
self.resumen = resumen
|
||||
self.vector_resumen = vector_resumen
|
||||
|
||||
def __repr__(self):
|
||||
return (
|
||||
f"<Nota id={self.id}, titulo='{self.titulo}', tags={len(self.tags)}, "
|
||||
f"conexiones={len(self.conexiones)}, vector_dim={len(self.vector)}, "
|
||||
f"resumen_len={len(self.resumen)}, vector_resumen_dim={len(self.vector_resumen)}>"
|
||||
)
|
||||
@@ -0,0 +1,196 @@
|
||||
import os
|
||||
from dotenv import load_dotenv
|
||||
from sqlalchemy import Table, Column, String, Text, MetaData
|
||||
from pgvector.sqlalchemy import Vector
|
||||
from sqlalchemy.orm import registry, Session
|
||||
from domains.TextManager.nota import Nota
|
||||
from domains.ConexionSql.Base_conexion import ConexionBase
|
||||
from typing import Tuple
|
||||
import re
|
||||
|
||||
|
||||
from domains.ArquitectureLayer.Mapper import Mapper_base
|
||||
from domains.ArquitectureLayer.Model import Model_base
|
||||
from domains.ArquitectureLayer.Repo import Repo_base
|
||||
|
||||
from domains.Credenciales.postgres_credencial import PostgresCredencial # Asegúrate de tener esta clase implementada correctamente
|
||||
|
||||
|
||||
titulo = os.getenv('DB_TITLE')
|
||||
usuario = os.getenv('DB_USER')
|
||||
passwrd = os.getenv('DB_PASSWORD')
|
||||
host = os.getenv('DB_HOST')
|
||||
port = os.getenv('DB_PORT')
|
||||
db_name = os.getenv('DB_NAME')
|
||||
|
||||
|
||||
db_credencial = PostgresCredencial(
|
||||
titulo=titulo,
|
||||
user=usuario,
|
||||
password=passwrd,
|
||||
host=host,
|
||||
port=port,
|
||||
dbname=db_name
|
||||
)
|
||||
|
||||
# from entrypoint.init_db import db_credencial
|
||||
from domains.Logger.logger_db import LoggerDB, logger
|
||||
LoggerDB(db_credencial, "logger_textos", created_by="sistema")
|
||||
|
||||
|
||||
from domains.base import Base # Este es tu declarative_base()
|
||||
|
||||
# ----------------------
|
||||
# Cargar .env
|
||||
# ----------------------
|
||||
from entrypoint import ENV_PATH
|
||||
load_dotenv(ENV_PATH)
|
||||
|
||||
# ----------------------
|
||||
# REGISTRO DINÁMICO PARA TABLAS
|
||||
# ----------------------
|
||||
mapper_registry = registry()
|
||||
|
||||
# ----------------------
|
||||
# FUNCIONES AUXILIARES
|
||||
# ----------------------
|
||||
|
||||
|
||||
def generar_tabla_nota_para_biblioteca(biblioteca_nombre: str, vector_dim: int, metadata: MetaData) -> Tuple[Table, type]:
|
||||
"""
|
||||
Genera una tabla dinámica y modelo ORM para una biblioteca dada, con campos vectoriales y campos del sistema.
|
||||
"""
|
||||
try:
|
||||
logger.info(f"Generando tabla para biblioteca: '{biblioteca_nombre}' con dimensión de vector: {vector_dim}")
|
||||
|
||||
# Nombre SQL-safe
|
||||
nombre_tabla = re.sub(r"[^a-zA-Z0-9_]", "_", biblioteca_nombre.strip().lower())
|
||||
logger.debug(f"Nombre de tabla SQL-safe: '{nombre_tabla}'")
|
||||
|
||||
# Modelo ORM dinámico
|
||||
class NotaModel(Base, Model_base):
|
||||
__tablename__ = nombre_tabla
|
||||
__table_args__ = {"extend_existing": True}
|
||||
|
||||
id = Column(String, primary_key=True)
|
||||
titulo = Column(String, nullable=False)
|
||||
tags = Column(String)
|
||||
conexiones = Column(String)
|
||||
texto = Column(Text)
|
||||
resumen = Column(Text)
|
||||
vector = Column(Vector(vector_dim), nullable=True)
|
||||
vector_resumen = Column(Vector(vector_dim), nullable=True)
|
||||
|
||||
logger.info(f"Modelo ORM 'NotaModel' creado para la tabla '{nombre_tabla}'")
|
||||
logger.debug(f"Columnas del modelo: {[c.name for c in NotaModel.__table__.columns]}")
|
||||
logger.debug(f"Tipos de columnas: {[str(c.type) for c in NotaModel.__table__.columns]}")
|
||||
logger.debug(f"Claves primarias: {[c.name for c in NotaModel.__table__.primary_key]}")
|
||||
|
||||
return NotaModel.__table__, NotaModel
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error al generar la tabla y modelo ORM para '{biblioteca_nombre}': {e}")
|
||||
raise
|
||||
|
||||
# ----------------------
|
||||
# MAPPER
|
||||
# ----------------------
|
||||
|
||||
class NotaMapper(Mapper_base[Nota, object]): # Usa `object` si el modelo es dinámico
|
||||
@staticmethod
|
||||
def to_model(nota: Nota):
|
||||
return {
|
||||
"id": nota.id,
|
||||
"titulo": nota.titulo,
|
||||
"tags": ",".join(nota.tags),
|
||||
"conexiones": ",".join(nota.conexiones),
|
||||
"texto": nota.texto,
|
||||
"resumen": nota.resumen,
|
||||
"vector": nota.vector,
|
||||
"vector_resumen": nota.vector_resumen
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def from_model(model) -> Nota:
|
||||
return Nota(
|
||||
id=model.id,
|
||||
titulo=model.titulo,
|
||||
tags=model.tags.split(",") if model.tags else [],
|
||||
conexiones=model.conexiones.split(",") if model.conexiones else [],
|
||||
texto=model.texto,
|
||||
resumen=model.resumen,
|
||||
vector=list(model.vector) if model.vector is not None else None,
|
||||
vector_resumen=list(model.vector_resumen) if model.vector_resumen is not None else None
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def to_dict(nota: Nota) -> dict:
|
||||
return {
|
||||
"id": nota.id,
|
||||
"titulo": nota.titulo,
|
||||
"tags": ",".join(nota.tags),
|
||||
"conexiones": ",".join(nota.conexiones),
|
||||
"texto": nota.texto,
|
||||
"resumen": nota.resumen,
|
||||
"vector": nota.vector,
|
||||
"vector_resumen": nota.vector_resumen
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def from_dict(data: dict) -> Nota:
|
||||
return Nota(
|
||||
id=data["id"],
|
||||
titulo=data["titulo"],
|
||||
tags=data["tags"].split(",") if data.get("tags") else [],
|
||||
conexiones=data["conexiones"].split(",") if data.get("conexiones") else [],
|
||||
texto=data["texto"],
|
||||
resumen=data["resumen"],
|
||||
vector=data.get("vector"),
|
||||
vector_resumen=data.get("vector_resumen")
|
||||
)
|
||||
|
||||
# ----------------------
|
||||
# REPO
|
||||
# ----------------------
|
||||
|
||||
class NotaRepo(Repo_base):
|
||||
def __init__(self, session: Session, modelo_nota: type):
|
||||
if modelo_nota is None:
|
||||
raise ValueError("No se puede instanciar NotaRepo sin un modelo válido de nota.")
|
||||
super().__init__(session=session, modelo=modelo_nota, mapper=NotaMapper)
|
||||
|
||||
# ------------------------
|
||||
# Métodos personalizados
|
||||
# ------------------------
|
||||
|
||||
def get_by_tag(self, tag: str) -> list[Nota]:
|
||||
query = self.session.query(self.Modelo).filter(self.Modelo.tags.contains([tag]))
|
||||
models = query.all()
|
||||
return self.Mapper.from_model_list(models)
|
||||
|
||||
def search_by_text(self, texto: str) -> list[Nota]:
|
||||
query = self.session.query(self.Modelo).filter(self.Modelo.texto.ilike(f'%{texto}%'))
|
||||
models = query.all()
|
||||
return self.Mapper.from_model_list(models)
|
||||
|
||||
def get_paginated(self, offset: int = 0, limit: int = 10) -> list[Nota]:
|
||||
models = self.session.query(self.Modelo).offset(offset).limit(limit).all()
|
||||
return self.Mapper.from_model_list(models)
|
||||
|
||||
def update(self, id_: str, nota_actualizada: Nota) -> bool:
|
||||
model = self.session.get(self.Modelo, id_)
|
||||
if not model:
|
||||
return False
|
||||
|
||||
# Campos de dominio
|
||||
model.titulo = nota_actualizada.titulo
|
||||
model.texto = nota_actualizada.texto
|
||||
model.tags = nota_actualizada.tags
|
||||
model.conexiones = nota_actualizada.conexiones
|
||||
model.resumen = nota_actualizada.resumen
|
||||
|
||||
# Actualización de campos de sistema
|
||||
model.sys_version = (model.sys_version or 1) + 1
|
||||
|
||||
self.session.commit()
|
||||
return True
|
||||
Reference in New Issue
Block a user