tigrbl-ops-oltp 0.1.0.dev1__tar.gz → 0.1.0.dev7__tar.gz

{tigrbl_ops_oltp-0.1.0.dev1 → tigrbl_ops_oltp-0.1.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl-ops-oltp
-Version: 0.1.0.dev1
+Version: 0.1.0.dev7
 Summary: OLTP operation implementations for Tigrbl, including CRUD and bulk handlers.
 License-Expression: Apache-2.0
 Keywords: tigrbl,sdk,standards,framework,oltp,crud

{tigrbl_ops_oltp-0.1.0.dev1 → tigrbl_ops_oltp-0.1.0.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl-ops-oltp"
-version = "0.1.0.dev1"
+version = "0.1.0.dev7"
 description = "OLTP operation implementations for Tigrbl, including CRUD and bulk handlers."
 license = "Apache-2.0"
 readme = "README.md"

{tigrbl_ops_oltp-0.1.0.dev1 → tigrbl_ops_oltp-0.1.0.dev7}/tigrbl_ops_oltp/crud/helpers/__init__.py

@@ -30,6 +30,7 @@ from .db import (
     _maybe_get,
     _maybe_execute,
     _maybe_flush,
+    _maybe_rollback,
     _maybe_delete,
     _set_attrs,
 )
@@ -59,6 +60,7 @@ __all__ = [
     "_maybe_delete",
     "_maybe_execute",
     "_maybe_flush",
+    "_maybe_rollback",
     "_maybe_get",
     "_model_columns",
     "_normalize_list_call",

{tigrbl_ops_oltp-0.1.0.dev1 → tigrbl_ops_oltp-0.1.0.dev7}/tigrbl_ops_oltp/crud/helpers/db.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import inspect
+from functools import lru_cache
 from typing import Any, Mapping, Sequence, Union
 
 import logging
@@ -10,51 +12,63 @@ from .model import _model_columns, _single_pk_name
 logger = logging.getLogger("uvicorn")
 
 
+@lru_cache(maxsize=512)
+def _is_async_db_type(db_type: type[Any]) -> bool:
+    return db_type.__name__ == "AsyncSession" or hasattr(db_type, "run_sync")
+
+
 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")
+    result = _is_async_db_type(type(db))
     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]
+    result = db.get(model, pk_value)  # type: ignore[attr-defined]
+    if inspect.isawaitable(result):
+        result = await result
     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]
+    result = db.execute(stmt)  # type: ignore[attr-defined]
+    if inspect.isawaitable(result):
+        result = await result
     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]
+    result = db.flush()  # type: ignore[attr-defined]
+    if inspect.isawaitable(result):
+        await result
     logger.debug("_maybe_flush completed")
 
 
+async def _maybe_rollback(db: Union[Session, AsyncSession]) -> None:
+    logger.debug("_maybe_rollback called")
+    if not hasattr(db, "rollback"):
+        logger.debug("_maybe_rollback skipping rollback; no attribute")
+        return
+    result = db.rollback()  # type: ignore[attr-defined]
+    if inspect.isawaitable(result):
+        await result
+    logger.debug("_maybe_rollback 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]
+    result = db.delete(obj)  # type: ignore[attr-defined]
+    if inspect.isawaitable(result):
+        await result
     logger.debug("_maybe_delete completed for obj=%s", obj)
 
 

{tigrbl_ops_oltp-0.1.0.dev1 → tigrbl_ops_oltp-0.1.0.dev7}/tigrbl_ops_oltp/crud/helpers/enum.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import enum as _enum
 from typing import Any, Mapping
 import builtins as _builtins
 import logging
@@ -40,12 +41,7 @@ def _validate_enum_values(model: type, values: Mapping[str, Any]) -> None:
 
         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.Enum):
                 if isinstance(v, enum_cls):
                     continue
                 logger.debug(

tigrbl_ops_oltp-0.1.0.dev7/tigrbl_ops_oltp/crud/helpers/model.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import datetime as dt
+from functools import lru_cache
+from typing import Any, Dict, Mapping, Tuple
+
+try:
+    from tigrbl_core._spec.column_spec import mro_collect_columns
+except Exception:  # pragma: no cover
+
+    def mro_collect_columns(_model: type, _cache_bust: int | None = None):
+        return {}
+
+
+def _colspecs_cache_token(model: type) -> tuple[int, int, int, int]:
+    table = getattr(model, "__table__", None)
+    cols = getattr(table, "columns", None) if table is not None else None
+    try:
+        col_count = len(tuple(cols)) if cols is not None else 0
+    except Exception:
+        col_count = 0
+    return (
+        id(getattr(model, "__tigrbl_colspecs__", None)),
+        id(getattr(model, "__tigrbl_cols__", None)),
+        id(table),
+        col_count,
+    )
+
+
+@lru_cache(maxsize=256)
+def _colspecs_cached(
+    model: type, cache_token: tuple[int, int, int, int]
+) -> Mapping[str, Any]:
+    del cache_token
+    return mro_collect_columns(model, _cache_bust=hash(_colspecs_cache_token(model)))
+
+
+@lru_cache(maxsize=512)
+def _excluded_schema_fields(model: type, verb: str) -> frozenset[str]:
+    schema_cls = getattr(getattr(model, "schemas", None), verb, None)
+    schema_in = getattr(schema_cls, "in_", None) if schema_cls else None
+    model_fields = (
+        getattr(schema_in, "model_fields", None) if schema_in is not None else None
+    )
+    if not isinstance(model_fields, Mapping):
+        return frozenset()
+    return frozenset(
+        name
+        for name, field_info in model_fields.items()
+        if getattr(field_info, "exclude", False)
+    )
+
+
+def _filter_plan_cache_token(model: type, verb: str) -> tuple[int, int, int, int, int]:
+    return (
+        *_colspecs_cache_token(model),
+        id(getattr(getattr(model, "schemas", None), verb, None)),
+    )
+
+
+@lru_cache(maxsize=512)
+def _filter_plan_cached(
+    model: type, verb: str, cache_token: tuple[int, int, int, int, int]
+) -> tuple[Mapping[str, bool], frozenset[str], Mapping[str, Any]]:
+    del cache_token
+    specs = _colspecs(model)
+    if not specs:
+        return {}, frozenset(), _table_python_types(model)
+
+    allowed_by_field: dict[str, bool] = {}
+    for name, sp in specs.items():
+        io = getattr(sp, "io", None)
+        if io is None:
+            allowed_by_field[name] = True
+            continue
+        in_verbs = getattr(io, "in_verbs", ())
+        mutable = getattr(io, "mutable_verbs", ())
+        allowed = (not in_verbs or verb in in_verbs) and (
+            not mutable or verb in mutable
+        )
+        allowed_by_field[name] = allowed
+
+    return (
+        allowed_by_field,
+        _excluded_schema_fields(model, verb),
+        _table_python_types(model),
+    )
+
+
+@lru_cache(maxsize=256)
+def _table_python_types(model: type) -> Mapping[str, Any]:
+    table = getattr(model, "__table__", None)
+    columns = getattr(table, "columns", None)
+    if columns is None:
+        return {}
+    resolved: dict[str, Any] = {}
+    for col in columns:
+        try:
+            py_t = getattr(getattr(col, "type", None), "python_type", None)
+        except Exception:
+            py_t = None
+        if py_t is not None:
+            resolved[getattr(col, "name", "")] = py_t
+    return resolved
+
+
+def _pk_columns(model: type) -> Tuple[Any, ...]:
+    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")
+    return pks
+
+
+def _single_pk_name(model: type) -> str:
+    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
+    return name
+
+
+def _coerce_pk_value(model: type, value: Any) -> Any:
+    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
+        return value
+    if isinstance(value, py_type):
+        return value
+    try:
+        coerced = py_type(value)
+        return coerced
+    except Exception:  # pragma: no cover - fallback to original
+        return value
+
+
+def _model_columns(model: type) -> Tuple[str, ...]:
+    table = getattr(model, "__table__", None)
+    if table is None:
+        return ()
+    cols = tuple(c.name for c in table.columns)
+    return cols
+
+
+def _colspecs(model: type) -> Mapping[str, Any]:
+    return _colspecs_cached(model, _colspecs_cache_token(model))
+
+
+def _filter_in_values(
+    model: type, data: Mapping[str, Any], verb: str
+) -> Dict[str, Any]:
+    allowed_by_field, excluded_fields, column_types = _filter_plan_cached(
+        model, verb, _filter_plan_cache_token(model, verb)
+    )
+    if not allowed_by_field and not excluded_fields:
+        return dict(data)
+
+    out: Dict[str, Any] = {}
+    for k, v in data.items():
+        allowed = allowed_by_field.get(k)
+        if allowed is None:
+            if k in excluded_fields:
+                continue
+            out[k] = v
+            continue
+        if allowed:
+            try:
+                py_t = column_types.get(k)
+                if py_t is not None and v is not None and not isinstance(v, py_t):
+                    if py_t in (dt.datetime, dt.date) and isinstance(v, str):
+                        parsed = py_t.fromisoformat(v)
+                        out[k] = parsed
+                    else:
+                        out[k] = py_t(v)
+                else:
+                    out[k] = v
+            except Exception:
+                # Best effort coercion only; preserve original value on failure.
+                out[k] = v
+    return out
+
+
+def _immutable_columns(model: type, verb: str) -> set[str]:
+    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)
+    return imm

{tigrbl_ops_oltp-0.1.0.dev1 → tigrbl_ops_oltp-0.1.0.dev7}/tigrbl_ops_oltp/crud/ops.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+from functools import lru_cache
 from typing import Any, Dict, List, Mapping, Optional, Union
+import inspect
+from weakref import WeakSet
 
 import builtins as _builtins
 import logging
@@ -33,10 +36,57 @@ from .helpers import (
 
 logger = logging.getLogger("uvicorn")
 
+_MAPPED_MODELS: "WeakSet[type]" = WeakSet()
+
+
+@lru_cache(maxsize=512)
+def _create_flush_requirements(model: type) -> tuple[str | None, tuple[str, ...]]:
+    """Precompute model attributes that may need a create-time flush."""
+    table = getattr(model, "__table__", None)
+    pk_name: str | None = None
+    server_default_names: list[str] = []
+
+    if table is None:
+        return pk_name, ()
+
+    try:
+        pk_cols = tuple(getattr(table, "primary_key", ()).columns)
+    except Exception:
+        pk_cols = ()
+    if len(pk_cols) == 1:
+        name = getattr(pk_cols[0], "name", None)
+        if isinstance(name, str) and name:
+            pk_name = name
+
+    for col in getattr(table, "columns", ()):
+        name = getattr(col, "name", None)
+        if not isinstance(name, str) or not name:
+            continue
+        if getattr(col, "server_default", None) is not None:
+            server_default_names.append(name)
+
+    return pk_name, tuple(server_default_names)
+
+
+def _requires_create_flush(model: type, obj: Any) -> bool:
+    """Flush only when we need database-generated values immediately."""
+    pk_name, server_default_names = _create_flush_requirements(model)
+
+    if pk_name is not None and getattr(obj, pk_name, None) is None:
+        return True
+
+    for name in server_default_names:
+        if getattr(obj, name, None) is None:
+            return True
+    return False
+
 
 def _ensure_model_mapped(model: type) -> None:
+    if model in _MAPPED_MODELS:
+        return
     try:
         _sa_inspect(model)
+        _MAPPED_MODELS.add(model)
         return
     except NoInspectionAvailable:
         pass
@@ -46,6 +96,7 @@ def _ensure_model_mapped(model: type) -> None:
 
     _materialize_colspecs_to_sqla(model)
     TableBase.registry.map_declaratively(model)
+    _MAPPED_MODELS.add(model)
 
 
 def _ensure_model_table(model: type, db: Union[Session, AsyncSession]) -> None:
@@ -92,15 +143,23 @@ async def create(
             TableBase.registry.map_declaratively(model)
             obj = model(**data)
             db.add(obj)
+    needs_flush = _requires_create_flush(model, obj)
+
     try:
-        await _maybe_flush(db)
+        if needs_flush:
+            await _maybe_flush(db)
     except OperationalError as exc:
         if "no such table" not in str(exc).lower():
             raise
+        if hasattr(db, "rollback"):
+            rollback_result = db.rollback()
+            if inspect.isawaitable(rollback_result):
+                await rollback_result
         _ensure_model_table(model, db)
         obj = model(**data)
         db.add(obj)
-        await _maybe_flush(db)
+        if needs_flush:
+            await _maybe_flush(db)
     logger.debug("create persisted obj=%s", obj)
     return obj
 

tigrbl_ops_oltp-0.1.0.dev1/tigrbl_ops_oltp/crud/helpers/model.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-import datetime as dt
-from typing import Any, Dict, Mapping, Tuple
-
-import logging
-
-try:
-    from tigrbl_canon.mapping.column_mro_collect import mro_collect_columns
-except Exception:  # pragma: no cover
-
-    def mro_collect_columns(_model: type, _cache_bust: int | None = None):
-        return {}
-
-
-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:
-            try:
-                col = getattr(getattr(model, "__table__", None), "columns", {}).get(k)
-                py_t = getattr(getattr(col, "type", None), "python_type", None)
-                if py_t is not None and v is not None and not isinstance(v, py_t):
-                    if py_t in (dt.datetime, dt.date) and isinstance(v, str):
-                        parsed = py_t.fromisoformat(v)
-                        out[k] = parsed
-                    else:
-                        out[k] = py_t(v)
-                else:
-                    out[k] = v
-            except Exception:
-                # Best effort coercion only; preserve original value on failure.
-                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