chastack-bdd 0.1.1__tar.gz

chastack_bdd-0.1.1/LICENSE

@@ -0,0 +1,43 @@
+Licencia MIT
+
+Derechos de autor (c) 2023 Hernán A. Teszkiewicz Novick
+
+Se concede permiso, de forma gratuita, a cualquier persona que obtenga una copia
+de este software y los archivos de documentación asociados (el "Software"), para utilizar
+el Software sin restricción, incluyendo, sin limitación, los derechos
+para usar, copiar, modificar, fusionar, publicar, distribuir, sublicenciar y / o vender
+copias del Software, y para permitir a las personas a quienes se les proporcione el Software
+hacerlo, sujeto a las siguientes condiciones:
+
+El aviso de derechos de autor anterior y este aviso de permiso se incluirán en todos
+las copias o partes sustanciales del Software.
+
+EL SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O
+IMPLÍCITA, INCLUYENDO, PERO NO LIMITADO A, LAS GARANTÍAS DE COMERCIALIZACIÓN,
+ADECUACIÓN PARA UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN. EN NINGÚN CASO
+LOS TITULARES DE LOS DERECHOS DE AUTOR O LOS AUTORES SERÁN RESPONSABLES DE
+NINGUNA RECLAMACIÓN, DAÑOS U OTRAS RESPONSABILIDADES, YA SEA EN UNA ACCIÓN DE
+CONTRATO, AGRAVIO O DE CUALQUIER OTRA NATURALEZA, DERIVADAS DE, FUERA DE O EN CONEXIÓN CON EL
+SOFTWARE O EL USO U OTROS VERSIONES, DISTRIBUCIONES Y ACUERDOS CONCERNIENTES AL SOFTWARE.
+
+MIT License
+
+Copyright (c) 2023 Hernan A. Teszkiewicz Novick
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chastack_bdd-0.1.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.2
+Name: chastack-bdd
+Version: 0.1.1
+Summary: Abstracción de Bases de Datos en Python y constructor de modelos.
+Home-page: https://github.com/Hernanatn/bdd.py
+Author: Hernán A. Teszkiewicz Novick
+Author-email: "Hernán A.T.N." <herni@cajadeideas.ar>, Joaquín Correa <correajoaquin7@gmail.com>, "Camila M.T.N." <cmteszkiewicz@gmail.com>
+Project-URL: Homepage, https://github.com/Hernanatn/bdd.py
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sobrecargar
+Requires-Dist: solteron
+Requires-Dist: mysql-connector-python
+Dynamic: author
+Dynamic: home-page
+
+
+
+# BDD
+
+[![Hecho por Chaska](https://img.shields.io/badge/hecho_por-Ch'aska-303030.svg)](https://cajadeideas.ar)
+[![Versión: 0.1.0](https://img.shields.io/badge/version-v0.1.0-green.svg)](https://github.com/hernanatn/github.com/hernanatn/bdd.py/releases/latest)
+[![Verisón de Python: 3.12](https://img.shields.io/badge/Python-3.12-blue?logo=python)](https://www.python.org/downloads/release/python-3120/)
+[![Licencia: MIT](https://img.shields.io/badge/Licencia-MIT-lightgrey.svg)](LICENSE)
+
+
+## Descripción
+Módulo de Python 3.x con abstracciones útiles para gestión de Bases de Datos y construcción de modelos.
+
+## [Documentación](/docs)

chastack_bdd-0.1.1/README.md

@@ -0,0 +1,14 @@
+
+
+# BDD
+
+[![Hecho por Chaska](https://img.shields.io/badge/hecho_por-Ch'aska-303030.svg)](https://cajadeideas.ar)
+[![Versión: 0.1.0](https://img.shields.io/badge/version-v0.1.0-green.svg)](https://github.com/hernanatn/github.com/hernanatn/bdd.py/releases/latest)
+[![Verisón de Python: 3.12](https://img.shields.io/badge/Python-3.12-blue?logo=python)](https://www.python.org/downloads/release/python-3120/)
+[![Licencia: MIT](https://img.shields.io/badge/Licencia-MIT-lightgrey.svg)](LICENSE)
+
+
+## Descripción
+Módulo de Python 3.x con abstracciones útiles para gestión de Bases de Datos y construcción de modelos.
+
+## [Documentación](/docs)

chastack_bdd-0.1.1/chastack_bdd/__init__.py

@@ -0,0 +1,23 @@
+"""
+===============
+chastack-bdd
+===============
+Módulo de Python 3.x con abstracciones útiles para gestión de Bases de Datos y construcción de modelos.
+
+* Repositorio del proyecto: https://github.com/Hernanatn/bdd.py
+
+Derechos de autor (c) 2025 Ch'aska SRL. Distribuído bajo licencia MIT.
+Autores:
+ - Hernan ATN | herni@cajadeideas.ar 
+ - Joaquín C. | correajoaquin7@gmail.com
+"""
+
+from chastack_bdd.tipos import *
+from chastack_bdd.errores import *
+from chastack_bdd.utiles import *
+from chastack_bdd.bdd import *
+from chastack_bdd.tabla import *
+from chastack_bdd.registro import *
+
+if __name__ == '__main__':
+    print(__doc__)

chastack_bdd-0.1.1/chastack_bdd/bdd.py

@@ -0,0 +1,405 @@
+from chastack_bdd.tipos import *
+from chastack_bdd.errores import *
+from chastack_bdd.utiles import *
+from mysql.connector import connect
+
+@runtime_checkable
+class ProtocoloBaseDeDatos(Protocol):
+    def DESCRIBE(self: Self, tabla :str) -> Self: ...
+    def SELECT(self : Self, tabla : str, columnas : list[str], columnasSecundarias: Optional[dict[str, list[str]] ] = {}) -> Self:...
+    def DELETE(self : Self, tabla : str) -> Self: ...
+    def INSET(self : Self, tabla : str, **asignaciones : Unpack[dict[str, Any]]) -> Self: ...
+    def UPDATE(self : Self, tabla : str, **asignaciones : Unpack[dict[str, Any]]) -> Self: ...
+    def WHERE(self : Self, tipoCondicion : TipoCondicion = TipoCondicion.IGUAL , **columnaValor : Unpack[dict[str, Any]]) -> Self: ...
+    def JOIN(self : Self,   tablaSecundaria, columnaPrincipal, columnaSecundaria, tipoUnion : TipoUnion = TipoUnion.INNER) -> Self: ...
+    def LIMIT(self : Self, desplazamiento: int  , limite : int) -> Self: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, exc_type,excl_val,exc_tb) -> None: ...
+    def ejecutar(self: Self) -> Self :...
+    def devolverUnResultado(self: Self) -> Resultado :...
+    def devolverResultados(self: Self) -> tuple[Resultado] :...
+    def devolverIdUltimaInsercion(self:Self) -> int :...
+
+class InstruccionPrincipal():
+    ''' 
+        Clase que permite definir la clausula principal de una consulta SQL. 
+        Altamente acoplada con la clase Consulta y dependiente de la misma.    
+    '''
+
+    _slots__ = \
+    (
+        '__instruccion'
+    )
+    def __init__(self):
+        self.__instruccion = ''
+    
+    def chequearOcupado(self):
+        if self.__instruccion: raise ErrorMalaSintaxisSQL("La clausula principal ya ha sido definida.")
+    def esDescribe(self):
+        self.__instruccion = 'DESCRIBE'
+    def esInsert(self):
+        self.__instruccion = 'INSERT'
+    def esSelect(self):
+        self.__instruccion = 'SELECT'
+    def esDelete(self):
+        self.__instruccion = 'DELETE'
+    def esUpdate(self):
+        self.__instruccion = 'UPDATE'
+    def construirConsulta(self, parametrosPrincipales, condicion, union, limite):
+        if not self.__instruccion: raise ErrorMalaSintaxisSQL("No se ha definido una clausula principal.")
+        if self.__instruccion == 'INSERT':
+            if condicion or union or limite: raise ErrorMalaSintaxisSQL("Las instrucciones INSERT no pueden tener clausulas WHERE, JOIN o LIMIT.")
+        return self.__instruccion + '\n' + parametrosPrincipales + condicion + union + limite + ';'
+
+
+class Consulta():
+    '''
+    Clase que permite generar consultas SQL de forma programática. Las consultas se construyen concatenando
+    las clausulas principales (SELECT, DELETE, INSET, UPDATE) y las clausulas secundarias (WHERE, JOIN). Luego
+    se espera que el objeto sea convertido a string para obtener la consulta SQL.
+
+
+    METODOS PUBLICOS
+    - SELECT(tabla : str, columnas : list[str] columnasSecundarias: Optional[Dict[str, List[str]] ] = {}) -> Self
+    - DELETE(tabla : str) -> Self
+    - INSET(tabla : str, **asignaciones : Unpack[dict[str, Any]]) -> Self
+    - UPDATE(tabla : str, **asignaciones : Unpack[dict[str, Any]]) -> Self
+    - WHERE(tipoCondicion : TipoCondicion = TipoCondicion.IGUAL , **columnaValor : Unpack[dict[str, Any]]) -> Self
+    - JOIN(tablaSecundaria, columnaPrincipal, columnaSecundaria, tipoUnion : TipoUnion = TipoUnion.INNER) -> Self
+    - LIMIT(desplazamiento: int  , limite : int) -> Self
+    Aclaracion: Los metodos From, Set y LIMIT no son metodos publicos, ya que son llamados internamente por los metodos que invocan clausulas principales.
+
+    ATRIBUTOS PUBLICOS
+    - TipoCondicion: Enumeracion que contiene los tipos de condiciones posibles.
+    - TipoUnion: Enumeracion que contiene los tipos de joins posibles.
+
+    EJEMPLOS DE USO:
+
+
+    > consulta = Consulta().SELECT(tabla='Usuarios', columnas=['nombreUsuario', 'correo']).WHERE(id=1).LIMIT(10, 5)
+    > print(consulta)
+
+
+    SELECT 
+    Usuarios.nombreUsuario, Usuarios.correo
+    FROM Usuarios
+    WHERE Usuarios.id = 1
+    LIMIT 10, 5
+    ;
+
+    > consulta = Consulta().DELETE(tabla='Usuarios').WHERE(id=1)
+    > print(consulta)
+
+    DELETE 
+    FROM Usuarios
+    WHERE Usuarios.PRIMARY_KEY != 'NULL'
+    AND Usuarios.id = 1
+    ;
+
+    > consulta = Consulta().INSET(tabla='Usuarios', nombreUsuario='Juan')
+
+    > consulta = Consulta().SELECT(tabla='Usuarios', columnas=['nombreUsuario', 'correo'], columnasSecundarias={'Discos': 'autor'})
+    > consulta.JOIN(tablaSecundaria='Discos', columnaPrincipal='esPremium', columnaSecundaria ='esPremium', tipoUnion=TipoUnion.INNER)
+    > print(consulta)
+
+    SELECT Usuarios.nombreUsuario, Usuarios.correo, Discos.a, Discos.u, Discos.t, Discos.o, Discos.r
+    FROM Usuarios
+    INNER JOIN Discos ON Usuarios.esPremium = Discos.esPremium
+    ;
+
+    CASOS DE ERROR:
+
+    La clase levanta errores de tipo ErrorMalaSintaxisSQL en los siguientes casos:
+    - Se intenta invocar una clausula principal (SELECT, DELETE, INSET, UPDATE) más de una vez.
+    - Se intenta convertir a string sin clausula principal
+    - Se intenta pedir columnas secundarias de una tabla que no ha sido unida.
+
+    La clase levanta errores de tipo ErrorMalaSolicitud en los siguientes casos:
+
+    CASOS
+    
+    
+    '''
+
+    _slots__ = \
+    (   '__parametros_principales',
+        '__instruccionPrincipal',
+        '__tabla_principal',
+        '__tablas_secundarias',
+        '__condicion',
+        '__union',
+        '__limite')
+
+    
+
+    def __init__(self):
+        self.__instruccionPrincipal = InstruccionPrincipal()
+        self.__parametros_principales = ''
+        self.__condicion = ''
+        self.__union = ''
+        self.__limite = ''
+
+        self.__tabla_principal = ''
+        self.__tablas_secundarias = {}
+
+    def SELECT(self, tabla : str, columnas : list[str], columnasSecundarias: Optional[dict[str, list[str]] ] = {}) -> Self:
+        self.__tabla_principal = tabla
+        self.__instruccionPrincipal.esSelect()
+        self.__parametros_principales = self.etiquetar(tabla, columnas)
+        for t2, c2 in columnasSecundarias.items():
+            self.__tablas_secundarias[t2] = 0
+            self.__parametros_principales += ', ' + self.etiquetar(t2, c2) 
+        self.__parametros_principales += '\n'
+        self.__FROM(tabla)
+        return self
+    def DESCRIBE(self: Self, tabla :str) -> Self:
+        self.__tabla_principal = tabla
+        self.__instruccionPrincipal.esDescribe()
+        self.__parametros_principales += self.__tabla_principal
+        return self
+    def DELETE(self, tabla : str):
+        self.__tabla_principal = tabla
+        self.__instruccionPrincipal.esDelete()
+        self.__FROM(tabla)
+        self.WHERE(TipoCondicion.NO_ES, id = None)
+        return self
+    def INSET(self, tabla : str, **asignaciones : Unpack[dict[str, Any]]):
+        self.__tabla_principal = tabla
+        self.__instruccionPrincipal.esInsert()
+        self.__parametros_principales = 'INTO ' + tabla + '\n'
+        self.__SET(**asignaciones)
+        return self
+    def UPDATE(self, tabla : str, **asignaciones : Unpack[dict[str, Any]]):
+        self.__tabla_principal = tabla
+        self.__instruccionPrincipal.esUpdate()
+        self.__parametros_principales = tabla + '\n'
+        self.__SET(**asignaciones)
+        self.WHERE(TipoCondicion.NO_ES, id = None)
+
+        return self
+    def WHERE(self, tipoCondicion : TipoCondicion = TipoCondicion.IGUAL , **columnaValor : Unpack[dict[str, Any]]):
+        condiciones : str = '   AND '.join(f"{self.etiquetar(self.__tabla_principal, [columna]) } {tipoCondicion} {self.adaptar(valor)}" for columna, valor in columnaValor.items())
+        if not self.__condicion: self.__condicion = f'WHERE {condiciones}\n'
+        else: self.__condicion += f' AND {condiciones}\n'
+        return self
+
+    
+    def JOIN(self, tablaSecundaria, columnaPrincipal, columnaSecundaria, tipoUnion : TipoUnion = TipoUnion.INNER):
+        self.__tablas_secundarias[tablaSecundaria] = 1
+        nuevoJoin : str = tipoUnion +  ' JOIN ' + tablaSecundaria + ' ON ' + self.etiquetar(self.__tabla_principal, [columnaPrincipal]) + ' = ' + self.etiquetar(tablaSecundaria, [columnaSecundaria]) + '\n'
+        self.__union += nuevoJoin        
+        return self
+    
+    def LIMIT(self, desplazamiento: int  , limite : int):
+        if self.__limite : raise ErrorMalaSintaxisSQL("La clausula LIMIT ya ha sido definida.")
+        self.__limite  =  'LIMIT ' + str(desplazamiento) + ', ' + str(limite) + '\n'
+        return self
+    def __FROM(self, tabla : str):
+        self.__parametros_principales += 'FROM ' + tabla + '\n'
+        return self
+    def __SET(self, **columnaValor : Unpack[dict[str, Any]]):
+        asignaciones = ', '.join(f"{self.etiquetar(self.__tabla_principal, [columna]) } = {self.adaptar(valor)}" for columna, valor in columnaValor.items())
+        self.__parametros_principales += f'SET {asignaciones}\n'
+        return self
+
+    
+    
+    def etiquetar(self, tabla: str, columnas : list[str]):
+        # Recibe una tabla y columnas. devuelve cada columna en el namespace de la tabla 
+        return ', '.join([tabla + '.' + columna  for columna in columnas])
+
+    def adaptar(self, valor : Any) -> str:
+        #En caso de que el valor sea de un tipo estpecial debe convertirse a string fuera del llamado para que la consulta no falle
+        if not valor:
+            return "NULL"
+        if type(valor) == int:
+            return str(valor)
+        else:
+            return "'" + str(valor) + "'"
+
+    def reiniciar(self):
+        self.consulta = ''
+    
+    def __str__(self):
+        if not self.__parametros_principales: raise ErrorMalaSintaxisSQL("No se ha definido una clausula principal.") 
+        for tabla, valor in self.__tablas_secundarias.items():
+            if valor == 0:
+                raise ErrorMalaSintaxisSQL(f"La tabla {tabla} no ha sido unida.")
+        
+        return self.__instruccionPrincipal.construirConsulta(self.__parametros_principales, self.__condicion, self.__union, self.__limite)
+        
+
+
+class ConfigMySQL(metaclass=Solteron):
+
+    __slots__ = (
+        '__HOST',  
+        '__USUARIO',  
+        '__CONTRASENA',  
+        '__NOMBRE_BDD'
+    )
+
+    def __init__(self, host, usuario, contrasena, bdd):
+        self.__HOST = host
+        self.__USUARIO = usuario
+        self.__CONTRASENA = contrasena
+        self.__NOMBRE_BDD = bdd
+    @property
+    def PARAMETROS_CONEXION(self) -> dict: 
+        return \
+        {
+            "host" : self.__HOST,
+            "user" : self.__USUARIO,
+            "password" : self.__CONTRASENA,
+            "database" : self.__NOMBRE_BDD,
+            "use_pure" : False
+        }
+
+    @property
+    def OPCION_CURSOR(self) -> dict:
+        return \
+        {
+           "dictionary" : True,
+           "named_tuple" : False,   
+        }
+
+class BaseDeDatos_MySQL():
+    _slots__ = \
+    (
+        "__config",
+        "__conexion",
+        "__cursor",
+        "__consulta"
+    )
+    def __init__(self, configuracion : ConfigMySQL = None) -> None:
+        self.__conexion = None
+        self.__cursor = None
+        self.configurar(configuracion)
+        self.__consulta = Consulta()
+    
+    def configurar(self, configuracion : ConfigMySQL = None) -> None:
+        if configuracion:
+            self.__config = configuracion
+            return self
+        # Agregar comportamiento usando las variables de ambiente
+
+    def conectar(self) -> Self:
+        if self.__conexion: return self
+        self.__conexion = connect(**self.__config.PARAMETROS_CONEXION)
+        self.__cursor = self.__conexion.cursor(buffered=True, **self.__config.OPCION_CURSOR)
+        return self
+
+    def desconectar(self) -> None:
+        if self.__cursor: self.__cursor.close()
+        if self.__conexion: self.__conexion.close()
+        self.__cursor = None
+        self.__conexion = None
+    
+    def reconectar(self) -> Self:
+        self.desconectar()
+        self.conectar()
+        return self
+    
+    def DESCRIBE(self: Self, tabla :str) -> Self:
+        self.__consulta.DESCRIBE(tabla)
+        return self 
+    def SELECT(self, tabla : str, columnas : list[str], columnasSecundarias: Optional[dict[str, list[str]] ] = {}) -> Self:
+        self.__consulta.SELECT(tabla, columnas, columnasSecundarias)
+        return self
+    def DELETE(self, tabla : str) -> Self: 
+        self.__consulta.DELETE(tabla)
+        return self
+    def INSET(self, tabla : str, **asignaciones : Unpack[dict[str, Any]]) -> Self: 
+        self.__consulta.INSET(tabla, **asignaciones)
+        return self
+    def UPDATE(self, tabla : str, **asignaciones : Unpack[dict[str, Any]]) -> Self: 
+        self.__consulta.UPDATE( tabla, **asignaciones)
+        return self
+    def WHERE(self, tipoCondicion : TipoCondicion = TipoCondicion.IGUAL , **columnaValor : Unpack[dict[str, Any]]) -> Self: 
+        self.__consulta.WHERE(tipoCondicion, **columnaValor)
+        return self
+    def JOIN(self,   tablaSecundaria, columnaPrincipal, columnaSecundaria, tipoUnion : TipoUnion = TipoUnion.INNER) -> Self: 
+        self.__consulta.JOIN(tablaSecundaria, columnaPrincipal, columnaSecundaria, tipoUnion)
+        return self
+    def LIMIT(self, desplazamiento: int  , limite : int) -> Self: 
+        self.__consulta.LIMIT(desplazamiento, limite)
+        return self
+   
+    @sobrecargar
+    def ejecutar(self, consulta : Union[Consulta,str]) -> Optional[list[Resultado]] :
+        if isinstance(consulta,Consulta):
+            consulta = str(consulta)
+        try:
+            self.__cursor.execute(consulta)
+            self.__conexion.commit()
+        except ErrorBDD as e:
+            ###print(f"[ERROR] {e}")
+            self.reconectar()
+            self.__cursor.execute(consulta)
+            self.__conexion.commit()
+        except AttributeError as e:
+            ###print(f"[ERROR] {e}")
+            self = BaseDeDatos_MySQL()
+            self.conectar()
+            self.__cursor.execute(consulta)
+            self.__conexion.commit()
+        except Exception as f:
+            raise type(f)(f"No se pudo completar la consulta.\n Es probable que la consulta incluya carácteres prohibidos. \n {consulta.encode('utf-8').decode('unicode_escape')}\n") from f
+        return self
+
+    @sobrecargar
+    def ejecutar(self) :
+
+        try:
+            self.__cursor.execute(str(self.__consulta))
+            self.__conexion.commit()
+        except ErrorBDD as e:
+            ###print(f"[ERROR] {e}")
+            self.reconectar()
+            self.__cursor.execute(str(self.__consulta))
+            self.__conexion.commit()
+        except AttributeError as e:
+            ###print(f"[ERROR] {e}")
+            self = BaseDeDatos_MySQL()
+            self.conectar()
+            self.__cursor.execute(str(self.__consulta))
+            self.__conexion.commit()
+        except Exception as f:
+            raise type(f)(f"No se pudo completar la consulta.\n Es probable que la consulta incluya carácteres prohibidos. \n {str(self.__consulta).encode('utf-8').decode('unicode_escape')}\n") from f
+        
+        self.__consulta.reiniciar()
+        return self
+   
+    def devolverIdUltimaInsercion(self) -> Optional[int]:
+        return self.__cursor.lastrowid
+        
+    def devolverResultados(self, cantidad : Optional[int] = None) -> Optional[List[Dict[str, Any]]]:
+        resultados = self.__cursor.fetchall()
+        
+        if not resultados: return None
+        elif cantidad is None: return resultados
+        elif cantidad == 0: return []
+        elif cantidad > 0: return resultados[0:cantidad-1]
+        else: raise IndexError("Se solicitó una cantidad negativa de resultados, lo cual es un sinsentido.")
+    def devolverUnResultado(self) -> Optional[Dict[str, Any]]:
+        """
+        Devuelve el primer resultado de la última consulta.
+        """
+        return self.__cursor.fetchone()
+        
+    # Estados
+    def estaConectado (self):
+            return self.__conexion.is_connected() if self.__conexion else False
+
+
+
+  # with BaseDeDatos() as bdd
+    def __enter__(self) -> 'BaseDeDatos_MySQL':
+        if self.__conexion is None:
+            return self.conectar()
+        # ###print(f"[DEBUG] Entrando {self.__cursor=}{self.__conexion=}{self.__pool=}")
+        return self
+
+    def __exit__(self, exc_type,excl_val,exc_tb) -> None:
+        # ###print(f"[DEBUG] Saliendo {self.__cursor=}{self.__conexion=}{self.__pool=}")
+        self.desconectar()

chastack_bdd-0.1.1/chastack_bdd/errores/__init__.py

@@ -0,0 +1,15 @@
+#Errores
+class ErrorBDD(Exception):...
+
+class ErrorMalaSolicitud(ErrorBDD):
+        """Excepción para errores relacionados con solicitudes"""
+class SinResultado(ErrorMalaSolicitud): ...
+class ErrorTablaNoExiste(ErrorBDD): ...
+class ErrorBaseDeDatosNoExiste(ErrorBDD): ...
+
+class ErrorPoolLlena(ErrorBDD): ...
+class ErrorDemasiadasConexiones(ErrorBDD): ...
+
+class IdsNoCoinciden(ErrorBDD): ...
+
+class ErrorAPI(Exception): ...

chastack_bdd-0.1.1/chastack_bdd/pruebas.py

@@ -0,0 +1,24 @@
+from chastack_bdd.tipos import *
+from chastack_bdd.utiles import *
+from chastack_bdd.bdd import ConfigMySQL, BaseDeDatos_MySQL  
+from chastack_bdd.tabla import Tabla  
+from chastack_bdd.registro import Registro
+
+class Discos(metaclass=Tabla):
+    def devolverArtista(self):
+        return self.idAutor
+
+
+config = ConfigMySQL("localhost", "servidor_local", "Servidor!1234", "BaseDePrueba")
+bdd = BaseDeDatos_MySQL(config)
+disco = Discos(bdd=bdd,id=2)
+
+#print(disco.nombreUsuario)
+print(disco.tabla)
+print(disco.id)
+print(disco.tipo.haciaCadena())
+print(disco.soporte)
+print(disco.devolverArtista())
+
+print(f"{Discos.TipoSoporte.desdeCadena("DIGITAL").value=}")
+

chastack_bdd-0.1.1/chastack_bdd/registro.py

@@ -0,0 +1,121 @@
+from chastack_bdd.tipos import *
+from chastack_bdd.utiles import *
+from chastack_bdd.bdd import ProtocoloBaseDeDatos
+
+
+
+class Registro: ...
+class Registro:
+    __slots__ = (
+        '__bdd',
+        '__id',
+    )
+
+    __bdd : ProtocoloBaseDeDatos
+    __id : int
+
+    @property
+    def id(self):
+        return self.__id
+    
+    def __new__(cls, *posicionales,**nominales):
+        obj = super(Registro, cls).__new__(cls)
+        obj.__tabla = cls.__name__
+        return obj        
+
+    @sobrecargar
+    def __init__(self, bdd : ProtocoloBaseDeDatos, valores : dict):
+        for atributo in self.__slots__:
+            nombre = atributoPublico(atributo)
+            valor_SQL : Any = valores.get(nombre,None)
+            if valor_SQL is not None:
+                valor = valor_SQL
+                tipo_esperado : type = self.__class__.__annotations__[atributo]
+                if issubclass(tipo_esperado, Decimal):
+                    valor : Decimal = Decimal(valor_SQL)
+                elif issubclass(tipo_esperado, dict):
+                    valor : dict = loads(valor_SQL)
+                elif issubclass(tipo_esperado,bool):
+                    valor : bool = bool(valor_SQL)
+                elif issubclass(tipo_esperado,EnumSQL):
+                    valor : tipo_esperado = tipo_esperado.desdeCadena(valor_SQL)
+                else:
+                    valor = valor_SQL
+                setattr(self, atributoPrivado(self,atributo) if '__' in atributo else atributo, valor)
+
+    @sobrecargar
+    def __init__(self, bdd : ProtocoloBaseDeDatos, id : int):
+        resultado : Resultado
+        atributos : tuple[str] = (atributoPublico(atr) for atr in self.__slots__ if atr not in ('__bdd','__tabla'))
+        
+        with bdd as bdd:
+            resultado = bdd\
+                        .SELECT(self.tabla,atributos)\
+                        .WHERE(id=id)\
+                        .ejecutar()\
+                        .devolverUnResultado()
+
+        self.__init__(
+            bdd,
+            resultado
+        )
+        self.__id = id
+
+    def guardar(self) -> int:
+        """Guarda el registro en la tabla correspondiente.
+        Si tiene id, se edita un registro existente, 
+        de lo contrario se agrega uno nuevo.   
+
+        Devuelve:
+        :arg Id int:
+            El Id del registro.           
+
+        Levanta:  
+        :arg Exception: Propaga errores de la conexión con la BDD  
+        :arg Exception: Levanta error si al editar la base con coinciden los id
+        """
+        match self.__id:
+            case None:
+                self.__id : int = self.__crear()
+            case _: 
+                self.__editar()
+
+        return self.__id
+    
+
+    def __crear(self) -> int: 
+        """Crea un nuevo registro en la tabla correspondiente""" 
+
+        atributos : tuple[str] = (atr for atr in self.__slots__ if '__' not in atr)
+        ediciones : dict[str,Any] = {
+            atributo : getattr(self,atributo)
+            for atributo in atributos
+        }
+    
+        with self.__bdd as bdd:
+            id : int = bdd\
+                        .UPDATE(self.tabla,**ediciones)\
+                        .WHERE(id=self.__id)\
+                        .ejecutar()\
+                        .devolverIdUltimaInsercion()
+            self.__id = id
+        
+        return self.__id
+    
+    def __editar(self) -> None: 
+        """
+        Edita un registro ya existente, dado por el ID, en la tabla correspondiente.
+        """
+
+
+        atributos : tuple[str] = (atr for atr in self.__slots__ if '__' not in atr)
+        ediciones : dict[str,Any] = {
+            atributo : getattr(self,atributo)
+            for atributo in atributos
+        }
+
+        with self.__bdd as bdd:
+            bdd\
+                .UPDATE(self.tabla,**ediciones)\
+                .WHERE(id=self.__id)\
+                .ejecutar()

chastack_bdd-0.1.1/chastack_bdd/tabla.py

@@ -0,0 +1,133 @@
+from chastack_bdd.tipos import *
+from chastack_bdd.utiles import *
+from chastack_bdd.bdd import ProtocoloBaseDeDatos
+from chastack_bdd.registro import Registro
+
+class Tabla(type):
+    def __new__(mcs, nombre, bases, atributos):
+        if Registro not in bases and nombre != 'Registro':
+            bases = (Registro,) + bases
+        
+        cls = super().__new__(mcs, nombre, bases, atributos)
+        
+        cls.__tabla = nombre
+        setattr(cls, "tabla", property(lambda cls : cls.__tabla))
+
+        
+        if not hasattr(cls, '__annotations__'):
+            cls.__annotations__ = {}
+        
+        return cls
+
+    def __init__(cls, nombre, bases, atributos): ...
+        #print(cls.__slots__)
+
+    def __call__(cls, bdd: ProtocoloBaseDeDatos, *posicionales, **nominales):
+
+
+        slots :list[str] = []        
+        anotaciones : dict[str,type] = {}
+        with bdd as bdd:
+            resultados = bdd.DESCRIBE(cls.__tabla).ejecutar().devolverResultados()
+            
+            for columna in resultados:
+                nombre_campo = columna.get('Field')
+                es_clave = columna.get('Key') == "PRI"
+                #print(columna.get('Extra'))
+                es_auto = "auto_increment" in columna.get("Extra", "").lower() or "default_generated" in columna.get("Extra", "").lower() or "auto_generated" in columna.get("Extra", "").lower()
+                
+                nombre_attr = f"__{nombre_campo}" if es_clave or es_auto else nombre_campo
+                
+                tipo = cls.__resolverTipo(columna.get('Type'), nombre_campo)
+                
+                if nombre_attr not in cls.__slots__:
+                    slots.append(nombre_attr)
+                anotaciones.update({
+                    nombre_attr : tipo
+                })
+                
+                
+                if es_clave:
+                    setattr(cls, nombre_campo, property(lambda self, name=nombre_campo: getattr(self, atributoPrivado(self,name))))
+        
+        
+        cls.__slots__ = cls.__slots__ + tuple(slots)
+        cls.__annotations__.update(anotaciones)
+        print(cls.__slots__)
+        instancia = super().__call__(bdd, *posicionales, **nominales)
+        setattr(instancia, atributoPrivado(instancia,"__bdd"),bdd)
+        return instancia
+    
+    @classmethod
+    def __resolverTipo(cls, tipo_sql: str, nombre_columna: Optional[str]) -> type:
+        """
+        Deduce y devuelve un tipo de Python en base al tipo declarado en MySQL para la columna.
+        Si encuentra un ENUM, crea un enum de Python y lo guarda como una constante de la clase.
+        
+        Parámetros:
+            :arg tipo_sql str: El tipo definido en MySQL
+            :arg nombre_columna Optional[str]: El nombre de la columna (útil para enums)
+        
+        Devuelve:
+            :arg tipo `type`: el tipo python correspondiente (o `Any`)
+        """
+        tipo_declarado: Optional[Match[AnyStr]] = match(r'([a-z]+)(\(.*\))?', tipo_sql.lower())
+        if not tipo_declarado:
+            return Any
+
+        tipo_base: str = tipo_declarado.group(1)
+        parametros: str = tipo_declarado.group(2) if tipo_declarado.group(2) else ""
+        tipo_completo: str = tipo_base + parametros
+
+        tipos: dict[str, type] = {
+            'tinyint': int,
+            'smallint': int,
+            'mediumint': int,
+            'int': int,
+            'bigint': int,
+            'float': float,
+            'double': float,
+            'decimal': Decimal,
+            'datetime': datetime,
+            'timestamp': datetime,
+            'date': date,
+            'time': time,
+            'char': str,
+            'varchar': str,
+            'text': str,
+            'mediumtext': str,
+            'longtext': str,
+            'tinytext': str,
+            'boolean': bool,
+            'bool': bool,
+            'tinyint(1)': bool,
+            'blob': bytearray,
+            'mediumblob': bytearray,
+            'longblob': bytearray,
+            'tinyblob': bytearray,
+            'binary': bytearray,
+            'varbinary': bytearray,
+            'json': dict,
+        }
+
+        
+        if tipo_base == 'enum':
+            valores_enum: list[Any] = findall(r"'([^']*)'", tipo_sql)
+            dicc_enum: dict[str, int] = {'_invalido': 0}
+            for i, val in enumerate(valores_enum, 1):   
+                dicc_enum[val] = i
+            
+            nombre_enum: str = f"Tipo{nombre_columna.capitalize()}" if nombre_columna else f"__ENUM_{token_urlsafe(4)}"
+            clase_enum: type = type(
+                nombre_enum,
+                (EnumSQL, Enum),
+                dicc_enum
+            )
+            
+            setattr(cls,nombre_enum,clase_enum)
+            return clase_enum
+
+        
+        if tipo_completo in tipos:
+            return tipos[tipo_completo]
+        return tipos.get(tipo_base, Any)

chastack_bdd-0.1.1/chastack_bdd/tipos/__init__.py

@@ -0,0 +1,24 @@
+from typing import Protocol, runtime_checkable, Self, TypeAlias, Optional, Any, AnyStr, Unpack,Union,Dict,List, get_origin
+from decimal import Decimal
+from datetime import datetime,date,time,timedelta,timezone
+from re import Match
+
+from chastack_bdd.tipos.enum_sql import *
+from solteron import Solteron
+### BDD
+Resultado : TypeAlias = dict[str,Any]
+
+class TipoCondicion:
+    IGUAL = '='
+    DIFERENTE = '!='
+    MAYOR = '>'
+    MENOR = '<'
+    MAYOR_O_IGUAL = '>='
+    MENOR_O_IGUAL = '<='
+    NO_ES = 'IS NOT'
+
+class TipoUnion:
+    INNER = 'INNER'
+    LEFT  = 'LEFT'
+    RIGHT = 'RIGHT'
+    FULL  = 'FULL'

chastack_bdd-0.1.1/chastack_bdd/tipos/enum_sql.py

@@ -0,0 +1,56 @@
+from enum import Enum, EnumType as _EnumMeta, EnumDict as _EnumDict
+
+class EnumSQLMeta(_EnumMeta):
+    """
+    Metaclase para controlar las reglas personalizadas sobre las enumeraciones.
+    Asegura que `_invalido` siempre tenga el valor 0 y ningún otro miembro lo tenga.
+    """
+    @classmethod
+    def __prepare__(metacls, cls, bases, **kwds):
+        """Copiado de enum.EnumType con la modificación de que esta metaclase no inhibe la herencia"""
+        #metacls._check_for_existing_members_(cls, bases)
+        enum_dict = _EnumDict()
+        enum_dict._cls_name = cls
+        member_type, first_enum = metacls._get_mixins_(cls, bases)
+        if first_enum is not None:
+            enum_dict['_generate_next_value_'] = getattr(
+                    first_enum, '_generate_next_value_', None,
+                    )
+        return enum_dict
+    def __new__(cls, nombre, bases, diccionario):
+        diccionario_enum = EnumSQLMeta.__prepare__(nombre,bases,**diccionario)
+        diccionario_enum.update(diccionario)
+        nueva_clase = _EnumMeta.__new__(cls, nombre, bases, diccionario_enum)
+
+        # Verificar que la clase tiene '_invalido' con valor 0
+        if '_invalido' not in nueva_clase.__members__: ...
+            #raise ValueError(f"La enumeración {nombre} debe tener un miembro '_invalido' con valor 0.")
+        
+        # Verificar que ningún otro miembro tenga valor 0.
+        for miembro in nueva_clase.__members__.values():
+            if miembro.value == 0 and miembro.name != '_invalido':
+                raise ValueError(f"{nombre} no puede tener otro miembro con valor 0 (reservado para '_invalido').")
+        
+        return nueva_clase
+
+class EnumSQL(Enum,metaclass=EnumSQLMeta):
+    """
+    Clase base para enumeraciones que se lleva bien con SQL.
+    """
+    _invalido = 0  # Siempre debe ser 0 y no debe haber otro miembro con este valor.
+
+    def __init__(self, *args, **kwds):
+        pass
+
+    @classmethod
+    def desdeCadena(cls, cadena: str) -> 'EnumSQL':
+        return cls.__members__.get(cadena, cls._invalido)
+
+    def haciaCadena(self) -> str:
+        return self.name
+
+    def __str__(self) -> str:
+        return self.haciaCadena()
+
+    def __repr__(self) -> str:
+        return self.haciaCadena()

chastack_bdd-0.1.1/chastack_bdd/utiles.py

@@ -0,0 +1,39 @@
+from json import dumps,loads
+from chastack_bdd.tipos import *
+from solteron import Solteron
+from sobrecargar import sobrecargar
+from secrets import token_urlsafe
+from re import findall,match
+
+def formatearValorParaSQL(valor: Any, html : bool = False) -> str:
+    """
+    Formatea un valor de Python a una representación adecuada para SQL.
+    """
+    if valor is None:
+        return "NULL"
+    if isinstance(valor, bool):
+        return "1" if valor else "0"
+    if isinstance(valor, (int, float)):
+        return str(valor)
+    if isinstance(valor, (list, tuple)):
+        return f"'[{','.join(f"\"{str(v)}\"" for v in valor)}]'"
+    if isinstance(valor, Decimal):
+        return str(valor.to_eng_string())
+    if isinstance(valor, (date, datetime, time)):
+        return f"'{valor.isoformat()}'"
+    if isinstance(valor, dict):
+        return f"'{dumps(valor)}'"
+    if isinstance(valor, bytes):
+        return f"X'{valor.hex()}'"
+    if isinstance(valor, Enum):
+        return str(valor.value) if isinstance(valor.value, int) else f"'{valor.name}'"
+    if isinstance(valor, str):
+        return f"'{valor.replace("'", "''")}'"
+        
+    return f"'{str(valor).replace("'", "''")}'"
+
+def atributoPublico(nombreAtributo: str) -> str:
+    return nombreAtributo.replace('__','',1)
+
+def atributoPrivado(obj: Any, nombreAtributo: str) -> str:
+    return f"_{obj.__class__.__name__}__{atributoPublico(nombreAtributo)}"

chastack_bdd-0.1.1/chastack_bdd.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.2
+Name: chastack-bdd
+Version: 0.1.1
+Summary: Abstracción de Bases de Datos en Python y constructor de modelos.
+Home-page: https://github.com/Hernanatn/bdd.py
+Author: Hernán A. Teszkiewicz Novick
+Author-email: "Hernán A.T.N." <herni@cajadeideas.ar>, Joaquín Correa <correajoaquin7@gmail.com>, "Camila M.T.N." <cmteszkiewicz@gmail.com>
+Project-URL: Homepage, https://github.com/Hernanatn/bdd.py
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sobrecargar
+Requires-Dist: solteron
+Requires-Dist: mysql-connector-python
+Dynamic: author
+Dynamic: home-page
+
+
+
+# BDD
+
+[![Hecho por Chaska](https://img.shields.io/badge/hecho_por-Ch'aska-303030.svg)](https://cajadeideas.ar)
+[![Versión: 0.1.0](https://img.shields.io/badge/version-v0.1.0-green.svg)](https://github.com/hernanatn/github.com/hernanatn/bdd.py/releases/latest)
+[![Verisón de Python: 3.12](https://img.shields.io/badge/Python-3.12-blue?logo=python)](https://www.python.org/downloads/release/python-3120/)
+[![Licencia: MIT](https://img.shields.io/badge/Licencia-MIT-lightgrey.svg)](LICENSE)
+
+
+## Descripción
+Módulo de Python 3.x con abstracciones útiles para gestión de Bases de Datos y construcción de modelos.
+
+## [Documentación](/docs)

chastack_bdd-0.1.1/chastack_bdd.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+chastack_bdd/__init__.py
+chastack_bdd/bdd.py
+chastack_bdd/pruebas.py
+chastack_bdd/registro.py
+chastack_bdd/tabla.py
+chastack_bdd/utiles.py
+chastack_bdd.egg-info/PKG-INFO
+chastack_bdd.egg-info/SOURCES.txt
+chastack_bdd.egg-info/dependency_links.txt
+chastack_bdd.egg-info/requires.txt
+chastack_bdd.egg-info/top_level.txt
+chastack_bdd/errores/__init__.py
+chastack_bdd/tipos/__init__.py
+chastack_bdd/tipos/enum_sql.py

chastack_bdd-0.1.1/chastack_bdd.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chastack_bdd-0.1.1/chastack_bdd.egg-info/requires.txt

@@ -0,0 +1,3 @@
+sobrecargar
+solteron
+mysql-connector-python

chastack_bdd-0.1.1/chastack_bdd.egg-info/top_level.txt

@@ -0,0 +1 @@
+chastack_bdd

chastack_bdd-0.1.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chastack-bdd"
+version = "0.1.1"
+authors = [
+  { name="Hernán A.T.N.", email="herni@cajadeideas.ar" },
+  { name="Joaquín Correa", email="correajoaquin7@gmail.com" },
+  { name="Camila M.T.N.", email="cmteszkiewicz@gmail.com" },
+]
+description = "Abstracción de Bases de Datos en Python y constructor de modelos."
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+dependencies = [
+    'sobrecargar',
+    'solteron',
+    "mysql-connector-python",
+]
+
+[tool.setuptools]
+packages = [
+  "chastack_bdd",
+  "chastack_bdd.errores",
+  "chastack_bdd.tipos",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/Hernanatn/bdd.py"

chastack_bdd-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chastack_bdd-0.1.1/setup.py

@@ -0,0 +1,11 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='chastack-bdd',
+    description="setuptools.build_meta",
+    version='0.1.1',
+    author           = 'Hernán A. Teszkiewicz Novick',
+    author_email     = 'herni@cajadeideas.ar',
+    url= 'https://github.com/Hernanatn/bdd.py',
+    packages=['bdd', 'bdd.errores','bdd.tipos'],
+)