mtpk-postgres 0.1.0__py3-none-any.whl

mtpk_postgres/utils.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+#-*- coding: UTF-8 -*-
+# ----------------------------------------
+# jjandres 2025
+# ----------------------------------------
+
+
+import bcrypt
+import hashlib, hmac
+import secrets
+import json
+import logging
+from typing import Optional, List, Dict, Any, Union, Literal, Callable
+from .core_sync import Columna
+from pydantic import BaseModel
+from decimal import Decimal
+from functools import wraps
+
+
+def hash_password(plain_password: str) -> str:
+    """
+    Genera un hash seguro de una contraseña en texto plano.
+
+    Args:
+        plain_password (str): Contraseña original en texto plano.
+
+    Returns:
+        str: Hash seguro (en formato string) listo para almacenar en la base de datos.
+    """
+    salt = bcrypt.gensalt()
+    hashed = bcrypt.hashpw(plain_password.encode(), salt)
+    return hashed.decode()
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """
+    Verifica si una contraseña en texto plano coincide con su hash almacenado.
+
+    Args:
+        plain_password (str): Contraseña introducida por el usuario.
+        hashed_password (str): Hash previamente almacenado.
+
+    Returns:
+        bool: True si coinciden, False si no.
+    """
+    return bcrypt.checkpw(
+        plain_password.encode(),
+        hashed_password.encode()
+    )
+
+
+def generar_api_key() -> str:
+    """
+    Genera una api_key aleatoria de ~43 caracteres seguros.
+    - Returns:
+        - str: cadena api_key aleatoria
+    """
+    return secrets.token_urlsafe(32)
+
+
+def generar_api_secret() -> str:
+    """
+    Genera una api_key aleatoria de ~65 caracteres seguros
+    - Returns:
+        2-tuple:
+        - str: cadena api_secret aleatoria.
+        - str: cadena api_secret hasheada
+    """
+    secreto = secrets.token_urlsafe(48)  # ~65 caracteres
+    secreto_hash = hashlib.sha256(secreto.encode()).hexdigest()
+    return secreto, secreto_hash  # Retorna secreto plano y su hash
+
+def verificar_api_secret(api_secret: str, hashed_api_secret: str) -> bool:
+    """
+    Verifica si un API_SECRET en texto plano coincide con su hash SHA-256.
+
+    Args:
+        api_secret (str): API_SECRET en texto plano.
+        hashed_api_secret (str): Hash SHA-256 (hex) previamente almacenado.
+
+    Returns:
+        bool: True si coinciden, False en caso contrario.
+    """
+    # Calcula el hash del secreto proporcionado
+    calc_hash = hashlib.sha256(api_secret.encode()).hexdigest()
+    # Compara de forma segura para evitar ataques de tiempo
+    return hmac.compare_digest(calc_hash, hashed_api_secret)
+
+
+def generar_lista_campos(campos, alias=None, excluir=None, prefijo_alias=None):
+    """
+    Genera una lista de campos SQL a partir de un diccionario, lista de strings o lista de objetos Columna,
+    con alias opcional, campos a excluir y alias renombrado con prefijo.
+
+    :param `campos`:           (Requerido) Diccionario {nombre_campo: Column}, lista de strings o lista de objetos Columna
+    :param `alias`:            (Opcional) Alias para los campos (string), ej: 'u'
+    :param `excluir`:          (Opcional) Lista de campos a excluir (lista de strings)
+    :param `prefijo_alias`:    (Opcional) Prefijo para renombrar los campos con alias: <alias>.<campo> AS <prefijo><campo>
+    :return:                   String con lista de campos separados por coma
+    """
+    excluir = excluir or []
+    lista = []
+
+    if isinstance(campos, dict):
+        iterable = campos.items()
+    elif isinstance(campos, list):
+        if all(hasattr(col, 'nombre') for col in campos):
+            iterable = [(col.nombre, col) for col in campos]
+        else:
+            iterable = [(nombre, None) for nombre in campos]
+    else:
+        raise TypeError("El parámetro 'campos' debe ser un dict, una lista de strings o una lista de objetos Columna.")
+
+    for nombre, _ in iterable:
+        if nombre in excluir:
+            continue
+        if alias:
+            campo_sql = f"{alias}.{nombre}"
+        else:
+            campo_sql = nombre
+
+        if prefijo_alias:
+            alias_sql = f"{prefijo_alias}{nombre}"
+            lista.append(f"{campo_sql} AS {alias_sql}")
+        else:
+            lista.append(campo_sql)
+
+    return ", ".join(lista)
+
+
+class FiltroCampo(BaseModel):
+    """Crea modelo para definir un filtro de campo SQL."""
+    op: Literal["=", "!=", ">", "<", ">=", "<=", "like", "in", "between"]
+    valor: Any
+
+
+
+def construir_condiciones_sql(filtros: dict[str, dict[str, Union[str, Any]]], alias: Optional[dict[str, str]] = None) -> tuple[str, list[Any]]:
+    """
+    Construye una cláusula WHERE SQL a partir de un diccionario de filtros.
+
+    Cada entrada del diccionario debe tener la forma:
+        campo: {"op": operador_sql, "valor": valor_o_lista}
+
+    Operadores soportados (case-insensitive):
+        '=', '!=', '>', '<', '>=', '<=', 'like', 'in', 'between'
+
+    Parámetros:
+        - `filtros`:    Diccionario de filtros con campo, operador y valor.
+        - `alias`:      Diccionario opcional con alias por campo, p.ej. {'nombre_campo': 'a.nombre_alias'}
+
+    Returns:
+        (condiciones_sql, valores): la cláusula WHERE (sin "WHERE") y la lista de parámetros.
+    """
+    condiciones: List[str] = []
+    valores: List[Any] = []
+
+    def _col(campo: str) -> str:
+        return alias.get(campo, campo) if alias else campo
+
+    def _is_seq(x: Any) -> bool:
+        return isinstance(x, (list, tuple))
+
+    for campo, cond in (filtros or {}).items():
+        if not isinstance(cond, dict):
+            # Compatibilidad: ignorar entradas mal formadas
+            continue
+
+        op_raw = cond.get("op")
+        val = cond.get("valor")
+        if not isinstance(op_raw, str):
+            # Compatibilidad: ignorar operador inválido
+            continue
+
+        op = op_raw.strip().lower()
+        campo_sql = _col(campo)
+
+        # Operadores simples y nulos
+        if op in {"=", "!="}:
+            # None -> IS NULL / IS NOT NULL
+            if val is None:
+                condiciones.append(f"{campo_sql} IS {'NOT ' if op == '!=' else ''}NULL")
+                continue
+
+            # List/Tuple -> IN / NOT IN
+            if _is_seq(val):
+                seq = list(val)
+                if not seq:
+                    # Compatibilidad: ignorar si viene vacío
+                    continue
+                placeholders = ", ".join(["%s"] * len(seq))
+                condiciones.append(f"{campo_sql} {'NOT ' if op == '!=' else ''}IN ({placeholders})")
+                valores.extend(seq)
+                continue
+
+            # Escalar
+            condiciones.append(f"{campo_sql} {op} %s")
+            valores.append(val)
+            continue
+
+        if op in {">", "<", ">=", "<="}:
+            condiciones.append(f"{campo_sql} {op} %s")
+            valores.append(val)
+            continue
+
+        if op == "like":
+            if val is None:
+                # Compatibilidad: ignorar filtro inválido
+                continue
+            condiciones.append(f"{campo_sql} LIKE %s")
+            valores.append(val)
+            continue
+
+        if op == "in":
+            if not _is_seq(val):
+                # Compatibilidad: ignorar si no es lista/tupla
+                continue
+            seq = list(val)
+            if not seq:
+                # Compatibilidad: ignorar IN vacío
+                continue
+            placeholders = ", ".join(["%s"] * len(seq))
+            condiciones.append(f"{campo_sql} IN ({placeholders})")
+            valores.extend(seq)
+            continue
+
+        if op == "between":
+            # Acepta [desde, hasta] o {"desde": x, "hasta": y}
+            desde = hasta = None
+            if isinstance(val, dict):
+                desde = val.get("desde", None)
+                hasta = val.get("hasta", None)
+            elif _is_seq(val) and len(val) >= 2:
+                desde, hasta = val[0], val[1]
+            elif val is None:
+                # Compatibilidad: ignorar
+                continue
+            else:
+                # Compatibilidad/utility: si viene solo un valor, tratar como '='
+                condiciones.append(f"{campo_sql} = %s")
+                valores.append(val)
+                continue
+
+            if desde is not None and hasta is not None:
+                condiciones.append(f"{campo_sql} BETWEEN %s AND %s")
+                valores.extend([desde, hasta])
+            elif desde is not None:
+                condiciones.append(f"{campo_sql} >= %s")
+                valores.append(desde)
+            elif hasta is not None:
+                condiciones.append(f"{campo_sql} <= %s")
+                valores.append(hasta)
+            # si ambos None, no añadimos nada (compatibilidad)
+            continue
+
+        # Operador no soportado: compatibilidad -> ignorar
+        continue
+
+    condiciones_sql = " AND ".join(condiciones)
+    return condiciones_sql, valores
+
+
+def resolver_orden_sql(orden: str, alias: Optional[dict[str, str]] = None) -> str:
+    """
+    Convierte una cadena de orden (como 'nombre DESC') en una cláusula SQL segura,
+    aplicando alias si están definidos.
+
+    Ejemplo:
+        orden = "nombre DESC"
+        alias = {"nombre": "a.nombre"}
+        => "a.nombre DESC"
+
+    Si el campo no está en alias, se usa tal cual (bajo tu responsabilidad).
+
+    Args:
+        orden (str): Campo o campos por los que ordenar, separados por coma.
+        alias (dict[str, str], optional): Diccionario de alias.
+
+    Returns:
+        str: Expresión segura de ordenación SQL.
+    """
+    if not orden:
+        return ""
+
+    campos_orden = []
+    for parte in orden.split(","):
+        tokens = parte.strip().split()
+        campo = tokens[0]
+        direccion = tokens[1].upper() if len(tokens) > 1 and tokens[1].upper() in {"ASC", "DESC"} else "ASC"
+
+        campo_sql = alias.get(campo, campo) if alias else campo
+        campos_orden.append(f"{campo_sql} {direccion}")
+
+    return ", ".join(campos_orden)

mtpk_postgres-0.1.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: mtpk_postgres
+Version: 0.1.0
+Summary: Librería para sincronización estructural de bases de datos Postgres con modelos Python (adaptación de mtpk_mariadb)
+Author-email: José Jesús Andrés Zambrana <jjandres@multiplika.es>
+License: MIT
+Project-URL: Homepage, https://github.com/jjandres/mtpk_postgres
+Project-URL: Repository, https://github.com/jjandres/mtpk_postgres
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psycopg[binary,pool]
+Requires-Dist: pydantic
+Requires-Dist: bcrypt
+Dynamic: license-file
+
+# mtpk_postgres
+
+Adaptación a Postgres (vía [psycopg 3](https://www.psycopg.org/psycopg3/)) de `mtpk_mariadb`: define tus tablas con
+dataclasses (`Tabla`, `Columna`, `ForeignKey`, `Index`), sincroniza la estructura de la base de datos automáticamente
+(CREATE/ALTER TABLE, índices, claves foráneas) y usa `AsyncCrudBase` para CRUD asíncrono.
+
+No modifica ni depende de `mtpk_mariadb`; es un paquete independiente. Ver `docs/mtpk-postgres-adaptacion.md` en el
+repo para el detalle de las diferencias frente a la versión MariaDB.
+
+## Instalación
+
+```
+pip install -e .
+```
+
+## Notas de la adaptación
+
+- Identificadores citados con `"comillas dobles"` en vez de backticks.
+- `auto_increment=True` genera `GENERATED ALWAYS AS IDENTITY` en vez de `AUTO_INCREMENT`; como Postgres no tiene
+  `lastrowid`, las inserciones vía `AsyncCrudBase.insert()`/`insertar()` añaden `RETURNING id`.
+- `Tabla.to_sql()` ya no incluye índices ni comentarios inline (Postgres no lo permite dentro de `CREATE TABLE`):
+  usa `Tabla.to_sql_indices()` y `Tabla.to_sql_comentarios()` para las sentencias `CREATE INDEX` y `COMMENT ON`
+  correspondientes. `ManagerDB` ya las ejecuta automáticamente al crear tablas.
+- `ENUM`/`SET` se traducen a `TEXT` + `CHECK`; al reconstruir la estructura desde la base de datos ambos se
+  reportan como `ENUM` (Postgres no permite distinguirlos después del hecho).
+- A diferencia de MariaDB, el DDL en Postgres es transaccional: los métodos de `ManagerDB` confirman (`COMMIT`)
+  explícitamente tras crear tablas, triggers y procedimientos.

mtpk_postgres-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+mtpk_postgres/__init__.py,sha256=GOvt_tgF0FaeTLJ5UKYawMTkQcEAzB4CSMrVHO_HxwI,104
+mtpk_postgres/async_adapter.py,sha256=625g5_ObLuwdZ4Ck5sGW9ZgwLz34UIi8zlRNGsDESv8,13332
+mtpk_postgres/core_sync.py,sha256=bspjGTZi3eoUE3o2yXirSW6yBJuveflMeZHTa017PFQ,74153
+mtpk_postgres/crud.py,sha256=ks3Wewwp-1LAvfaDAcz665gI4I_-Nx_xTw3h3VC9cNE,14348
+mtpk_postgres/excepciones.py,sha256=e3QUo5yOCeIpAMl9T7d5vVLLRievEDy0KYk3NnsuKvY,1486
+mtpk_postgres/interface.py,sha256=ke9CJKuvVcwWKG1kEXrPuPl0Tb5A_jjMPJTctV6y7zs,2039
+mtpk_postgres/utils.py,sha256=pG_wU1JMpfUbSE_90X4TIu5Ind41o0h3j3gaYUFlhfI,9869
+mtpk_postgres-0.1.0.dist-info/licenses/LICENSE,sha256=9P-e1cTXCTuepzDnhWFnAyWg-SiAsVzPTZymN2nH4Pw,1086
+mtpk_postgres-0.1.0.dist-info/METADATA,sha256=81x8zseU_2Ogek5uvuSnKavNajwAe5rXx8THgkW6TKE,2325
+mtpk_postgres-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+mtpk_postgres-0.1.0.dist-info/top_level.txt,sha256=UqdjUccq2zmrlXW616wuwUrog-SRqL0JouIKg5-eMPw,14
+mtpk_postgres-0.1.0.dist-info/RECORD,,

mtpk_postgres-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mtpk_postgres-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 José Jesús Andrés Zambrana
+
+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.

mtpk_postgres-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mtpk_postgres