tigrbl 0.0.1.dev1__py3-none-any.whl → 0.3.0.dev3__py3-none-any.whl

tigrbl/core/crud/helpers/model.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Mapping, Tuple
+
+import logging
+
+from ....column.mro_collect import mro_collect_columns
+
+logging.getLogger("uvicorn").setLevel(logging.DEBUG)
+logger = logging.getLogger("uvicorn")
+
+
+def _pk_columns(model: type) -> Tuple[Any, ...]:
+    logger.debug("_pk_columns called with model=%s", model)
+    table = getattr(model, "__table__", None)
+    if table is None:
+        raise ValueError(f"{model.__name__} has no __table__")
+    pks = tuple(table.primary_key.columns)  # type: ignore[attr-defined]
+    if not pks:
+        raise ValueError(f"{model.__name__} has no primary key")
+    logger.debug("_pk_columns returning %s", pks)
+    return pks
+
+
+def _single_pk_name(model: type) -> str:
+    logger.debug("_single_pk_name called with model=%s", model)
+    pks = _pk_columns(model)
+    if len(pks) != 1:
+        raise NotImplementedError(
+            f"{model.__name__} has composite PK; not supported by default core"
+        )
+    name = pks[0].name
+    logger.debug("_single_pk_name returning %s", name)
+    return name
+
+
+def _coerce_pk_value(model: type, value: Any) -> Any:
+    logger.debug("_coerce_pk_value called with model=%s value=%s", model, value)
+    if value is None:
+        return None
+    try:
+        col = _pk_columns(model)[0]
+        py_type = col.type.python_type  # type: ignore[attr-defined]
+    except Exception:  # pragma: no cover - best effort
+        logger.debug("_coerce_pk_value returning original value %s", value)
+        return value
+    if isinstance(value, py_type):
+        return value
+    try:
+        coerced = py_type(value)
+        logger.debug("_coerce_pk_value coerced %s to %s", value, coerced)
+        return coerced
+    except Exception:  # pragma: no cover - fallback to original
+        logger.debug("_coerce_pk_value failed to coerce %s", value)
+        return value
+
+
+def _model_columns(model: type) -> Tuple[str, ...]:
+    logger.debug("_model_columns called with model=%s", model)
+    table = getattr(model, "__table__", None)
+    if table is None:
+        return ()
+    cols = tuple(c.name for c in table.columns)
+    logger.debug("_model_columns returning %s", cols)
+    return cols
+
+
+def _colspecs(model: type) -> Mapping[str, Any]:
+    logger.info("_colspecs called with model=%s", model)
+    cache_bust = hash(
+        (
+            id(getattr(model, "__tigrbl_colspecs__", None)),
+            id(getattr(model, "__tigrbl_cols__", None)),
+        )
+    )
+    specs = mro_collect_columns(model, _cache_bust=cache_bust)
+    logger.info("_colspecs returning %s", specs)
+    return specs
+
+
+def _filter_in_values(
+    model: type, data: Mapping[str, Any], verb: str
+) -> Dict[str, Any]:
+    logger.info("_filter_in_values called with data=%s verb=%s", data, verb)
+    specs = _colspecs(model)
+    if not specs:
+        result = dict(data)
+        logger.debug("_filter_in_values returning %s", result)
+        return result
+    out: Dict[str, Any] = {}
+    for k, v in data.items():
+        sp = specs.get(k)
+        if sp is None:
+            out[k] = v
+            continue
+        io = getattr(sp, "io", None)
+        allowed = True
+        if io is not None:
+            in_verbs = getattr(io, "in_verbs", ())
+            mutable = getattr(io, "mutable_verbs", ())
+            if in_verbs and verb not in in_verbs:
+                allowed = False
+            if mutable and verb not in mutable:
+                allowed = False
+        if allowed:
+            out[k] = v
+    logger.info("_filter_in_values returning %s", out)
+    return out
+
+
+def _immutable_columns(model: type, verb: str) -> set[str]:
+    logger.info("_immutable_columns called with model=%s verb=%s", model, verb)
+    specs = _colspecs(model)
+    if not specs:
+        return set()
+    imm: set[str] = set()
+    for name, sp in specs.items():
+        io = getattr(sp, "io", None)
+        mutable = getattr(io, "mutable_verbs", ()) if io else ()
+        if mutable and verb not in mutable:
+            imm.add(name)
+    logger.info("_immutable_columns returning %s", imm)
+    return imm

tigrbl/core/crud/helpers/normalize.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Mapping, Optional, Union
+import builtins as _builtins
+import logging
+
+from . import AsyncSession, Session
+
+logging.getLogger("uvicorn").setLevel(logging.DEBUG)
+logger = logging.getLogger("uvicorn")
+
+
+def _pop_bound_self(args: list[Any]) -> None:
+    logger.debug("_pop_bound_self called with args=%s", args)
+    if args and not isinstance(args[0], type):
+        args.pop(0)
+    logger.debug("_pop_bound_self result args=%s", args)
+
+
+def _extract_db(
+    args: list[Any], kwargs: dict[str, Any]
+) -> Union[Session, AsyncSession]:
+    logger.debug("_extract_db called with args=%s kwargs=%s", args, kwargs)
+    db = kwargs.pop("db", None)
+    if db is not None:
+        logger.debug("_extract_db found db in kwargs=%s", db)
+        return db
+    for i, a in enumerate(args):
+        if isinstance(a, (Session, AsyncSession)) or hasattr(a, "execute"):
+            args.pop(i)
+            logger.debug("_extract_db using positional db=%s", a)
+            return a  # type: ignore[return-value]
+    logger.debug("_extract_db failed to find db")
+    raise TypeError("db session is required")
+
+
+def _as_pos_int(x: Any) -> Optional[int]:
+    logger.debug("_as_pos_int called with x=%s", x)
+    if x is None:
+        return None
+    try:
+        v = int(x)
+        result = v if v >= 0 else 0
+        logger.debug("_as_pos_int returning %s", result)
+        return result
+    except Exception:
+        logger.debug("_as_pos_int returning None for x=%s", x)
+        return None
+
+
+def _normalize_list_call(
+    _args: tuple[Any, ...], _kwargs: dict[str, Any]
+) -> tuple[type, Dict[str, Any]]:
+    logger.debug("_normalize_list_call called with _args=%s _kwargs=%s", _args, _kwargs)
+    args = _builtins.list(_args)
+    kwargs = dict(_kwargs)
+
+    _pop_bound_self(args)
+
+    if args and isinstance(args[0], type):
+        model = args.pop(0)
+    else:
+        model = kwargs.pop("model", None)
+        if not isinstance(model, type):
+            raise TypeError("list(model, ...) requires a model class")
+
+    filters = kwargs.pop("filters", None)
+    if filters is None and args:
+        maybe = args[0]
+        if isinstance(maybe, Mapping):
+            filters = args.pop(0)
+
+    skip = _as_pos_int(kwargs.pop("skip", None))
+    limit = _as_pos_int(kwargs.pop("limit", None))
+    sort = kwargs.pop("sort", None)
+
+    if skip is None and args:
+        skip = _as_pos_int(args[0])
+        if skip is not None:
+            args.pop(0)
+    if limit is None and args:
+        limit = _as_pos_int(args[0])
+        if limit is not None:
+            args.pop(0)
+
+    db = _extract_db(args, kwargs)
+
+    if filters is None:
+        filters = {}
+
+    result = {
+        "filters": filters,
+        "skip": skip,
+        "limit": limit,
+        "db": db,
+        "sort": sort,
+    }
+    logger.debug("_normalize_list_call returning model=%s params=%s", model, result)
+    return model, result

tigrbl/core/crud/ops.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Mapping, Optional, Union
+
+import builtins as _builtins
+import logging
+
+from .helpers import (
+    AsyncSession,
+    Session,
+    NoResultFound,
+    select,
+    sa_delete,
+    _apply_filters,
+    _apply_sort,
+    _coerce_filters,
+    _coerce_pk_value,
+    _filter_in_values,
+    _immutable_columns,
+    _maybe_delete,
+    _maybe_execute,
+    _maybe_flush,
+    _maybe_get,
+    _normalize_list_call,
+    _set_attrs,
+    _single_pk_name,
+    _validate_enum_values,
+)
+
+logging.getLogger("uvicorn").setLevel(logging.DEBUG)
+logger = logging.getLogger("uvicorn")
+
+
+async def create(
+    model: type, data: Mapping[str, Any], db: Union[Session, AsyncSession]
+) -> Any:
+    """
+    Insert a single row. Returns the persisted model instance.
+    Flush-only (commit happens later in END_TX).
+    """
+    logger.debug("create called with model=%s data=%s", model, data)
+    data = _filter_in_values(model, data or {}, "create")
+    _validate_enum_values(model, data)
+    obj = model(**data)
+    if hasattr(db, "add"):
+        db.add(obj)
+    await _maybe_flush(db)
+    logger.debug("create persisted obj=%s", obj)
+    return obj
+
+
+async def read(model: type, ident: Any, db: Union[Session, AsyncSession]) -> Any:
+    """
+    Load a single row by primary key. Raises NoResultFound if not found.
+    """
+    logger.debug("read called with model=%s ident=%s", model, ident)
+    obj = await _maybe_get(db, model, ident)
+    if obj is None:
+        logger.debug("read did not find model=%s ident=%s", model, ident)
+        raise NoResultFound(f"{model.__name__}({ident!r}) not found")
+    logger.debug("read returning obj=%s", obj)
+    return obj
+
+
+async def update(
+    model: type, ident: Any, data: Mapping[str, Any], db: Union[Session, AsyncSession]
+) -> Any:
+    """
+    Partial update by primary key. Missing keys are left unchanged.
+    Returns the updated model instance. Flush-only.
+    """
+    logger.debug("update called with model=%s ident=%s data=%s", model, ident, data)
+    data = _filter_in_values(model, data or {}, "update")
+    _validate_enum_values(model, data)
+    obj = await read(model, ident, db)
+    skip = _immutable_columns(model, "update")
+    _set_attrs(obj, data, allow_missing=True, skip=skip)
+    await _maybe_flush(db)
+    logger.debug("update returning obj=%s", obj)
+    return obj
+
+
+async def replace(
+    model: type, ident: Any, data: Mapping[str, Any], db: Union[Session, AsyncSession]
+) -> Any:
+    """
+    PUT semantics with upsert behaviour.
+
+    If the row exists it is replaced entirely (missing attributes are nulled).
+    If the row does not exist it is created with the provided identifier.
+    Flush-only.
+    """
+    logger.debug("replace called with model=%s ident=%s data=%s", model, ident, data)
+    data = _filter_in_values(model, data or {}, "replace")
+    _validate_enum_values(model, data)
+    pk = _single_pk_name(model)
+    obj = await _maybe_get(db, model, ident)
+    if obj is None:
+        payload = {pk: ident, **data}
+        result = await create(model, payload, db=db)
+        logger.debug("replace created obj=%s", result)
+        return result
+    skip = _immutable_columns(model, "replace")
+    _set_attrs(obj, data, allow_missing=False, skip=skip)
+    await _maybe_flush(db)
+    logger.debug("replace updated obj=%s", obj)
+    return obj
+
+
+async def merge(
+    model: type, ident: Any, data: Mapping[str, Any], db: Union[Session, AsyncSession]
+) -> Any:
+    """PATCH semantics with upsert behaviour."""
+    logger.debug("merge called with model=%s ident=%s data=%s", model, ident, data)
+    pk = _single_pk_name(model)
+    ident = _coerce_pk_value(model, ident)
+    obj = await _maybe_get(db, model, ident)
+
+    verb = "update" if obj is not None else "create"
+    data = _filter_in_values(model, data or {}, verb)
+    _validate_enum_values(model, data)
+    data_no_pk = {k: v for k, v in data.items() if k != pk}
+    if obj is None:
+        payload = {pk: ident, **data_no_pk}
+        result = await create(model, payload, db=db)
+        logger.debug("merge created obj=%s", result)
+        return result
+    skip = _immutable_columns(model, "update")
+    _set_attrs(obj, data_no_pk, allow_missing=True, skip=skip)
+    await _maybe_flush(db)
+    logger.debug("merge updated obj=%s", obj)
+    return obj
+
+
+async def delete(
+    model: type, ident: Any, db: Union[Session, AsyncSession]
+) -> Dict[str, int]:
+    """
+    Delete by primary key. Returns {"deleted": 1} if removed, else raises NoResultFound.
+    Flush-only.
+    """
+    logger.debug("delete called with model=%s ident=%s", model, ident)
+    obj = await read(model, ident, db)
+    await _maybe_delete(db, obj)
+    await _maybe_flush(db)
+    logger.debug("delete removed obj=%s", obj)
+    return {"deleted": 1}
+
+
+# NOTE: tolerant signature: accepts positional/keyword and ignores stray args
+async def list(*_args: Any, **_kwargs: Any) -> List[Any]:  # noqa: A001  (shadow built-in)
+    """
+    Simple list with equality filters + skip/limit (+ optional sort).
+    Tolerant to:
+      - missing filters (defaults to {})
+      - accidental bound-method 'self' (first positional arg)
+      - positional or keyword args
+      - stray extras (e.g., request) which are ignored
+    """
+    logger.debug("list called with args=%s kwargs=%s", _args, _kwargs)
+    model, params = _normalize_list_call(_args, _kwargs)
+
+    filters: Mapping[str, Any] = _coerce_filters(model, params["filters"])
+    skip: Optional[int] = params["skip"]
+    limit: Optional[int] = params["limit"]
+    db: Union[Session, AsyncSession] = params["db"]
+    sort = params["sort"]
+
+    if select is None:  # pragma: no cover
+        # Fallback: legacy query API
+        q = db.query(model)  # type: ignore[attr-defined]
+        if filters:
+            q = q.filter_by(**filters)  # type: ignore[attr-defined]
+        if isinstance(skip, int):
+            q = q.offset(max(skip, 0))  # type: ignore[attr-defined]
+        if isinstance(limit, int) and limit is not None:
+            q = q.limit(max(limit, 0))  # type: ignore[attr-defined]
+        return _builtins.list(q.all())  # type: ignore[attr-defined]
+
+    where = _apply_filters(model, filters)
+    stmt = select(model)
+    if where is not None:
+        stmt = stmt.where(where)
+
+    order_exprs = _apply_sort(model, sort)
+    if order_exprs:
+        for ob in order_exprs:
+            stmt = stmt.order_by(ob)
+
+    if isinstance(skip, int):
+        stmt = stmt.offset(max(skip, 0))
+    if isinstance(limit, int) and limit is not None:
+        stmt = stmt.limit(max(limit, 0))
+
+    result = await _maybe_execute(db, stmt)
+    items = _builtins.list(result.scalars().all())  # type: ignore[attr-defined]
+    logger.debug("list returning %d items", len(items))
+    return items
+
+
+async def clear(
+    *args: Any,
+    **kwargs: Any,
+) -> Dict[str, int]:
+    """
+    Delete many rows matching equality filters. Returns {"deleted": N}.
+    Flush-only. Tolerant to the same calling variations as `list`.
+    """
+    # Reuse normalizer to accept the same shapes
+    logger.debug("clear called with args=%s kwargs=%s", args, kwargs)
+    model, params = _normalize_list_call(args, kwargs)
+    raw_filters: Mapping[str, Any] = params["filters"]
+    db: Union[Session, AsyncSession] = params["db"]
+
+    if sa_delete is None:  # pragma: no cover
+        # Fallback path: manual iteration
+        items = await list(model, raw_filters, db=db)
+        n = 0
+        for obj in items:
+            await _maybe_delete(db, obj)
+            n += 1
+        await _maybe_flush(db)
+        return {"deleted": n}
+
+    filt = _coerce_filters(model, raw_filters)
+    where = _apply_filters(model, filt)
+    stmt = sa_delete(model)
+    if where is not None:
+        stmt = stmt.where(where)
+
+    res = await _maybe_execute(db, stmt)
+    await _maybe_flush(db)
+    n = int(getattr(res, "rowcount", 0) or 0)
+    logger.debug("clear removed %d rows", n)
+    return {"deleted": n}