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

tigrbl/core/crud/bulk.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, List, Mapping, Union
+
+import builtins as _builtins
+import logging
+
+from .helpers import (
+    AsyncSession,
+    Session,
+    sa_delete,
+    _coerce_pk_value,
+    _immutable_columns,
+    _maybe_delete,
+    _maybe_execute,
+    _maybe_flush,
+    _maybe_get,
+    _set_attrs,
+    _single_pk_name,
+    _validate_enum_values,
+)
+from .ops import merge, read
+
+logging.getLogger("uvicorn").setLevel(logging.DEBUG)
+logger = logging.getLogger("uvicorn")
+
+
+async def bulk_create(
+    model: type, rows: Iterable[Mapping[str, Any]], db: Union[Session, AsyncSession]
+) -> List[Any]:
+    """
+    Insert many rows. Returns the list of persisted instances.
+    Flush-only.
+    """
+    logger.debug("bulk_create called with model=%s rows=%s", model, rows)
+    items_data = [dict(r) for r in (rows or ())]
+    for r in items_data:
+        _validate_enum_values(model, r)
+    items = [model(**r) for r in items_data]
+    if not items:
+        logger.debug("bulk_create no items to create")
+        return []
+    if hasattr(db, "add_all"):
+        db.add_all(items)  # type: ignore[attr-defined]
+    else:
+        for it in items:
+            db.add(it)  # type: ignore[attr-defined]
+    await _maybe_flush(db)
+    logger.debug("bulk_create persisted %d items", len(items))
+    return items
+
+
+async def bulk_update(
+    model: type, rows: Iterable[Mapping[str, Any]], db: Union[Session, AsyncSession]
+) -> List[Any]:
+    """
+    Update many rows by PK. Each row must include the PK field.
+    Returns the list of updated instances. Flush-only.
+    """
+    logger.debug("bulk_update called with model=%s rows=%s", model, rows)
+    pk = _single_pk_name(model)
+    skip = _immutable_columns(model, "update")
+    updated: List[Any] = []
+    for r in rows or ():
+        r = dict(r)
+        _validate_enum_values(model, r)
+        ident = r.get(pk)
+        if ident is None:
+            raise ValueError(f"bulk_update requires '{pk}' in each row")
+        obj = await read(model, ident, db)
+        data = {k: v for k, v in r.items() if k != pk}
+        _set_attrs(obj, data, allow_missing=True, skip=skip)
+        updated.append(obj)
+    if updated:
+        await _maybe_flush(db)
+    logger.debug("bulk_update updated %d items", len(updated))
+    return updated
+
+
+async def bulk_replace(
+    model: type, rows: Iterable[Mapping[str, Any]], db: Union[Session, AsyncSession]
+) -> List[Any]:
+    """
+    Replace many rows by PK. Each row must include the PK field.
+    Missing attributes are nulled (except PK). Flush-only.
+    """
+    logger.debug("bulk_replace called with model=%s rows=%s", model, rows)
+    pk = _single_pk_name(model)
+    skip = _immutable_columns(model, "replace")
+    replaced: List[Any] = []
+    for r in rows or ():
+        r = dict(r)
+        _validate_enum_values(model, r)
+        ident = r.get(pk)
+        if ident is None:
+            raise ValueError(f"bulk_replace requires '{pk}' in each row")
+        obj = await read(model, ident, db)
+        data = {k: v for k, v in r.items() if k != pk}
+        _set_attrs(obj, data, allow_missing=False, skip=skip)
+        replaced.append(obj)
+    if replaced:
+        await _maybe_flush(db)
+    logger.debug("bulk_replace replaced %d items", len(replaced))
+    return replaced
+
+
+async def bulk_merge(
+    model: type, rows: Iterable[Mapping[str, Any]], db: Union[Session, AsyncSession]
+) -> List[Any]:
+    """Merge many rows by primary key with upsert semantics."""
+    logger.debug("bulk_merge called with model=%s rows=%s", model, rows)
+    pk = _single_pk_name(model)
+    results: List[Any] = []
+    to_create: List[Mapping[str, Any]] = []
+    for r in rows or ():
+        r = dict(r)
+        ident = _coerce_pk_value(model, r.get(pk))
+        if ident is not None:
+            existing = await _maybe_get(db, model, ident)
+            if existing is not None:
+                data = {k: v for k, v in r.items() if k != pk}
+                merged = await merge(model, ident, data, db=db)
+                results.append(merged)
+                continue
+            r[pk] = ident
+        to_create.append(r)
+    if to_create:
+        created = await bulk_create(model, to_create, db)
+        results.extend(created)
+    logger.debug(
+        "bulk_merge returning %d results (%d created)",
+        len(results),
+        len(to_create),
+    )
+    return results
+
+
+async def bulk_delete(
+    model: type, idents: Iterable[Any], db: Union[Session, AsyncSession]
+) -> Dict[str, int]:
+    """
+    Delete many rows by a sequence of PK values. Returns {"deleted": N}.
+    Flush-only.
+    """
+    logger.debug("bulk_delete called with model=%s idents=%s", model, idents)
+    pk_name = _single_pk_name(model)
+    id_seq = _builtins.list(idents or ())
+    if not id_seq:
+        logger.debug("bulk_delete no ids supplied")
+        return {"deleted": 0}
+
+    if sa_delete is not None:
+        col = getattr(model, pk_name)
+        stmt = sa_delete(model).where(col.in_(id_seq))  # type: ignore[attr-defined]
+        res = await _maybe_execute(db, stmt)
+        await _maybe_flush(db)
+        n = int(getattr(res, "rowcount", 0) or 0)
+        logger.debug("bulk_delete removed %d rows via stmt", n)
+        return {"deleted": n}
+
+    n = 0
+    for ident in id_seq:
+        obj = await read(model, ident, db)
+        await _maybe_delete(db, obj)
+        n += 1
+    await _maybe_flush(db)
+    logger.debug("bulk_delete removed %d rows individually", n)
+    return {"deleted": n}

tigrbl/core/crud/helpers/__init__.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+try:
+    from sqlalchemy import select, delete as sa_delete, and_, asc, desc, Enum as SAEnum
+    from sqlalchemy.orm import Session
+    from sqlalchemy.ext.asyncio import AsyncSession
+    from sqlalchemy.orm.exc import NoResultFound  # type: ignore
+except Exception:  # pragma: no cover
+    select = sa_delete = and_ = asc = desc = None  # type: ignore
+    SAEnum = None  # type: ignore
+    Session = object  # type: ignore
+    AsyncSession = object  # type: ignore
+
+    class NoResultFound(LookupError):  # type: ignore
+        pass
+
+
+from .model import (
+    _pk_columns,
+    _single_pk_name,
+    _coerce_pk_value,
+    _model_columns,
+    _colspecs,
+    _filter_in_values,
+    _immutable_columns,
+)
+from .filters import _CANON_OPS, _coerce_filters, _apply_filters, _apply_sort
+from .db import (
+    _is_async_db,
+    _maybe_get,
+    _maybe_execute,
+    _maybe_flush,
+    _maybe_delete,
+    _set_attrs,
+)
+from .enum import _validate_enum_values
+from .normalize import (
+    _normalize_list_call,
+    _pop_bound_self,
+    _extract_db,
+    _as_pos_int,
+)
+
+__all__ = [
+    "AsyncSession",
+    "Session",
+    "NoResultFound",
+    "select",
+    "sa_delete",
+    "_apply_filters",
+    "_apply_sort",
+    "_CANON_OPS",
+    "_coerce_filters",
+    "_coerce_pk_value",
+    "_colspecs",
+    "_filter_in_values",
+    "_immutable_columns",
+    "_is_async_db",
+    "_maybe_delete",
+    "_maybe_execute",
+    "_maybe_flush",
+    "_maybe_get",
+    "_model_columns",
+    "_normalize_list_call",
+    "_pop_bound_self",
+    "_extract_db",
+    "_as_pos_int",
+    "_pk_columns",
+    "_set_attrs",
+    "_single_pk_name",
+    "_validate_enum_values",
+    "SAEnum",
+    "asc",
+    "desc",
+    "and_",
+]

tigrbl/core/crud/helpers/db.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Sequence, Union
+
+import logging
+
+from . import AsyncSession, Session
+from .model import _model_columns, _single_pk_name
+
+logging.getLogger("uvicorn").setLevel(logging.DEBUG)
+logger = logging.getLogger("uvicorn")
+
+
+def _is_async_db(db: Any) -> bool:
+    logger.debug("_is_async_db called with db=%s", db)
+    result = isinstance(db, AsyncSession) or hasattr(db, "run_sync")
+    logger.debug("_is_async_db returning %s", result)
+    return result
+
+
+async def _maybe_get(db: Union[Session, AsyncSession], model: type, pk_value: Any):
+    logger.debug("_maybe_get model=%s pk_value=%s", model, pk_value)
+    if _is_async_db(db):
+        result = await db.get(model, pk_value)  # type: ignore[attr-defined]
+    else:
+        result = db.get(model, pk_value)  # type: ignore[attr-defined]
+    logger.debug("_maybe_get returning %s", result)
+    return result
+
+
+async def _maybe_execute(db: Union[Session, AsyncSession], stmt: Any):
+    logger.debug("_maybe_execute stmt=%s", stmt)
+    if _is_async_db(db):
+        result = await db.execute(stmt)  # type: ignore[attr-defined]
+    else:
+        result = db.execute(stmt)  # type: ignore[attr-defined]
+    logger.debug("_maybe_execute returning %s", result)
+    return result
+
+
+async def _maybe_flush(db: Union[Session, AsyncSession]) -> None:
+    logger.debug("_maybe_flush called")
+    if _is_async_db(db):
+        await db.flush()  # type: ignore[attr-defined]
+    else:
+        db.flush()  # type: ignore[attr-defined]
+    logger.debug("_maybe_flush completed")
+
+
+async def _maybe_delete(db: Union[Session, AsyncSession], obj: Any) -> None:
+    logger.debug("_maybe_delete called with obj=%s", obj)
+    if not hasattr(db, "delete"):
+        logger.debug("_maybe_delete skipping delete; no attribute")
+        return
+    if _is_async_db(db):
+        await db.delete(obj)  # type: ignore[attr-defined]
+    else:
+        db.delete(obj)  # type: ignore[attr-defined]
+    logger.debug("_maybe_delete completed for obj=%s", obj)
+
+
+def _set_attrs(
+    obj: Any,
+    values: Mapping[str, Any],
+    *,
+    allow_missing: bool = True,
+    skip: Sequence[str] = (),
+) -> None:
+    logger.debug(
+        "_set_attrs called on obj=%s values=%s allow_missing=%s skip=%s",
+        obj,
+        values,
+        allow_missing,
+        skip,
+    )
+    cols = set(_model_columns(type(obj)))
+    pk = _single_pk_name(type(obj))
+    skip_set = set(skip) | {pk}
+
+    if allow_missing:
+        for k, v in values.items():
+            if k in cols and k not in skip_set:
+                setattr(obj, k, v)
+    else:
+        for c in cols:
+            if c in skip_set:
+                continue
+            if c in values:
+                setattr(obj, c, values[c])
+            else:
+                setattr(obj, c, None)
+    logger.debug("_set_attrs completed for obj=%s", obj)

tigrbl/core/crud/helpers/enum.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+import builtins as _builtins
+import logging
+
+from . import SAEnum
+
+logging.getLogger("uvicorn").setLevel(logging.DEBUG)
+logger = logging.getLogger("uvicorn")
+
+
+def _validate_enum_values(model: type, values: Mapping[str, Any]) -> None:
+    logger.debug("_validate_enum_values called with model=%s values=%s", model, values)
+    if not values or SAEnum is None:
+        logger.debug("_validate_enum_values no validation needed")
+        return
+
+    table = getattr(model, "__table__", None)
+    if table is None:
+        return
+
+    get = getattr(table.c, "get", None)
+
+    for key, v in values.items():
+        col = get(key) if get else None
+        if col is None:
+            try:
+                col = table.c[key]  # type: ignore[index]
+            except Exception:
+                col = None
+        if col is None:
+            continue
+
+        col_type = getattr(col, "type", None)
+        if col_type is None or not isinstance(col_type, SAEnum):
+            continue
+
+        if v is None:
+            continue
+
+        enum_cls = getattr(col_type, "enum_class", None)
+        if enum_cls is not None:
+            try:
+                import enum as _enum
+            except Exception:  # pragma: no cover
+                _enum = None
+
+            if _enum is not None and isinstance(v, _enum.Enum):
+                if isinstance(v, enum_cls):
+                    continue
+                logger.debug(
+                    "_validate_enum_values invalid value %s for enum %s", v, enum_cls
+                )
+                raise LookupError(
+                    f"{v!r} is not among the defined enum values. "
+                    f"Enum name: {enum_cls.__name__}. "
+                    f"Possible values: {', '.join([e.value for e in enum_cls])}"
+                )
+
+            allowed_values = [e.value for e in enum_cls]
+            allowed_names = [e.name for e in enum_cls]
+            if isinstance(v, str) and (v in allowed_values or v in allowed_names):
+                continue
+
+            logger.debug(
+                "_validate_enum_values invalid value %s for enum %s", v, enum_cls
+            )
+            raise LookupError(
+                f"{v!r} is not among the defined enum values. "
+                f"Enum name: {enum_cls.__name__}. "
+                f"Possible values: {', '.join(allowed_values)}"
+            )
+        else:
+            allowed = _builtins.list(getattr(col_type, "enums", []) or [])
+            if isinstance(v, str) and v in allowed:
+                continue
+            logger.debug(
+                "_validate_enum_values invalid value %s for enum %s", v, col_type
+            )
+            raise LookupError(
+                f"{v!r} is not among the defined enum values. "
+                f"Enum name: {getattr(col_type, 'name', 'Enum')}. "
+                f"Possible values: {', '.join(allowed) if allowed else '(none)'}"
+            )
+    logger.debug("_validate_enum_values completed")

tigrbl/core/crud/helpers/filters.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, Mapping, Optional, Sequence
+
+import logging
+
+from . import select, and_, asc, desc
+from .model import _model_columns, _colspecs
+
+logging.getLogger("uvicorn").setLevel(logging.DEBUG)
+logger = logging.getLogger("uvicorn")
+
+_CANON_OPS = {
+    "eq": "eq",
+    "=": "eq",
+    "==": "eq",
+    "ne": "ne",
+    "!=": "ne",
+    "<>": "ne",
+    "lt": "lt",
+    "<": "lt",
+    "gt": "gt",
+    ">": "gt",
+    "lte": "lte",
+    "le": "lte",
+    "<=": "lte",
+    "gte": "gte",
+    "ge": "gte",
+    ">=": "gte",
+    "like": "like",
+    "not_like": "not_like",
+    "ilike": "ilike",
+    "not_ilike": "not_ilike",
+    "in": "in",
+    "not_in": "not_in",
+    "nin": "not_in",
+}
+
+
+def _coerce_filters(
+    model: type, filters: Optional[Mapping[str, Any]]
+) -> Dict[str, Any]:
+    logger.debug("_coerce_filters called with filters=%s", filters)
+    cols = set(_model_columns(model))
+    specs = _colspecs(model)
+    raw = dict(filters or {})
+    out: Dict[str, Any] = {}
+    for k, v in raw.items():
+        name, op = k.split("__", 1) if "__" in k else (k, "eq")
+        if name not in cols:
+            continue
+        canon = _CANON_OPS.get(op, op)
+        sp = specs.get(name)
+        if sp is not None:
+            io = getattr(sp, "io", None)
+            ops = set(getattr(io, "filter_ops", ()) or [])
+            ops = {_CANON_OPS.get(o, o) for o in ops}
+            if not ops or canon not in ops:
+                continue
+        key = name if canon == "eq" else f"{name}__{canon}"
+        out[key] = v
+    logger.debug("_coerce_filters returning %s", out)
+    return out
+
+
+def _apply_filters(model: type, filters: Mapping[str, Any]) -> Any:
+    logger.debug("_apply_filters called with filters=%s", filters)
+    if select is None:  # pragma: no cover
+        return None
+    clauses = []
+    for k, v in filters.items():
+        name, op = k.split("__", 1) if "__" in k else (k, "eq")
+        canon = _CANON_OPS.get(op, op)
+        col = getattr(model, name, None)
+        if col is None:
+            continue
+        if canon == "eq":
+            clauses.append(col == v)
+        elif canon == "ne":
+            clauses.append(col != v)
+        elif canon == "lt":
+            clauses.append(col < v)
+        elif canon == "gt":
+            clauses.append(col > v)
+        elif canon == "lte":
+            clauses.append(col <= v)
+        elif canon == "gte":
+            clauses.append(col >= v)
+        elif canon == "like":
+            clauses.append(col.like(v))
+        elif canon == "not_like":
+            clauses.append(~col.like(v))
+        elif canon == "ilike":
+            clauses.append(col.ilike(v))
+        elif canon == "not_ilike":
+            clauses.append(~col.ilike(v))
+        elif canon == "in":
+            seq = list(v) if isinstance(v, (list, tuple, set)) else [v]
+            clauses.append(col.in_(seq))
+        elif canon == "not_in":
+            seq = list(v) if isinstance(v, (list, tuple, set)) else [v]
+            clauses.append(~col.in_(seq))
+    if not clauses:
+        logger.debug("_apply_filters produced no clauses")
+        return None
+    result = clauses[0] if len(clauses) == 1 else and_(*clauses)
+    logger.debug("_apply_filters returning %s", result)
+    return result
+
+
+def _apply_sort(model: type, sort: Any) -> Sequence[Any] | None:
+    logger.debug("_apply_sort called with sort=%s", sort)
+    if select is None or sort is None:  # pragma: no cover
+        return None
+
+    def _tokenize(s: str) -> list[str]:
+        return [t.strip() for t in s.split(",") if t.strip()]
+
+    tokens: list[str] = []
+    if isinstance(sort, str):
+        tokens = _tokenize(sort)
+    elif isinstance(sort, Iterable):
+        for t in sort:
+            if isinstance(t, str):
+                tokens.extend(_tokenize(t))
+
+    if not tokens:
+        logger.debug("_apply_sort no tokens derived")
+        return None
+
+    specs = _colspecs(model)
+    order_by_exprs: list[Any] = []
+    for tok in tokens:
+        direction = "asc"
+        name = tok
+
+        if ":" in tok:
+            name, dirpart = tok.split(":", 1)
+            name = name.strip()
+            dirpart = dirpart.strip().lower()
+            if dirpart in ("desc", "descending"):
+                direction = "desc"
+        elif tok.startswith("-"):
+            name = tok[1:]
+            direction = "desc"
+
+        col = getattr(model, name, None)
+        if col is None:
+            continue
+        sp = specs.get(name)
+        if sp is not None:
+            io = getattr(sp, "io", None)
+            if io is not None and not getattr(io, "sortable", False):
+                continue
+        if direction == "desc":
+            order_by_exprs.append(desc(col))
+        else:
+            order_by_exprs.append(asc(col))
+
+    result = order_by_exprs or None
+    logger.debug("_apply_sort returning %s", result)
+    return result