tigrbl_engine_numpy 0.1.1.dev2__tar.gz → 0.1.1.dev4__tar.gz

{tigrbl_engine_numpy-0.1.1.dev2 → tigrbl_engine_numpy-0.1.1.dev4}/.gitignore

@@ -30,9 +30,13 @@ pkgs/standards/peagen/.pymon
 gateway.db
 kms.db
 *.asc
+*.kid
 *.so
 *.db
 target/
 !.gitkeep          # keep the empty dir in repo
 pkgs/experimental/swarmakit/libs/svelte/.vscode/extensions.json
 node_modules/
+*.zip
+.pymon
+/.tmp_pydeps

{tigrbl_engine_numpy-0.1.1.dev2 → tigrbl_engine_numpy-0.1.1.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl_engine_numpy
-Version: 0.1.1.dev2
+Version: 0.1.1.dev4
 Summary: NumPy engine plugin for tigrbl with array-to-table helpers.
 Project-URL: Homepage, https://github.com/swarmauri/swarmauri-sdk
 Author-email: Jacob Stewart <jacob@swarmauri.com>

{tigrbl_engine_numpy-0.1.1.dev2 → tigrbl_engine_numpy-0.1.1.dev4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tigrbl_engine_numpy"
-version = "0.1.1.dev2"
+version = "0.1.1.dev4"
 description = "NumPy engine plugin for tigrbl with array-to-table helpers."
 readme = "README.md"
 license = { file = "LICENSE" }

{tigrbl_engine_numpy-0.1.1.dev2 → tigrbl_engine_numpy-0.1.1.dev4}/src/tigrbl_engine_numpy/session.py

@@ -16,7 +16,49 @@ from typing import (
 )
 
 import numpy as np
-from tigrbl.session.base import TigrblSessionBase
+
+try:
+    from tigrbl.session.base import TigrblSessionBase
+except Exception:
+    from abc import ABC, abstractmethod
+
+    class TigrblSessionBase(ABC):
+        def __init__(self, spec=None):
+            self._spec = spec
+
+        def apply_spec(self, spec):
+            self._spec = spec
+
+        @abstractmethod
+        def _add_impl(self, obj): ...
+
+        @abstractmethod
+        async def _delete_impl(self, obj): ...
+
+        @abstractmethod
+        async def _flush_impl(self): ...
+
+        @abstractmethod
+        async def _refresh_impl(self, obj): ...
+
+        @abstractmethod
+        async def _get_impl(self, model, ident): ...
+
+        @abstractmethod
+        async def _execute_impl(self, stmt): ...
+
+        @abstractmethod
+        async def _tx_begin_impl(self): ...
+
+        @abstractmethod
+        async def _tx_commit_impl(self): ...
+
+        @abstractmethod
+        async def _tx_rollback_impl(self): ...
+
+        @abstractmethod
+        async def _close_impl(self): ...
+
 
 try:
     from tigrbl.session.spec import SessionSpec
@@ -68,9 +110,22 @@ class NumpySession(TigrblSessionBase):
         self._snap_ver: Optional[int] = None
         self._puts: dict[tuple[type, Any], dict[str, Any]] = {}
         self._dels: set[tuple[type, Any]] = set()
+        self._tracked: dict[tuple[type, Any], Any] = {}
+        self._tracked: dict[tuple[type, Any], Any] = {}
 
     def to_records(self) -> list[dict[str, Any]]:
-        return [dict(row) for row in self._engine.catalog.rows]
+        pk = self._engine.catalog.pk
+        by_id: dict[Any, dict[str, Any]] = {}
+        for row in self._engine.catalog.rows:
+            ident = row.get(pk)
+            if ident is None:
+                continue
+            by_id[ident] = dict(row)
+        for (_, ident), row in self._puts.items():
+            by_id[ident] = dict(row)
+        for _, ident in self._dels:
+            by_id.pop(ident, None)
+        return list(by_id.values())
 
     def array(self) -> np.ndarray:
         rows = self.to_records()
@@ -155,6 +210,8 @@ class NumpySession(TigrblSessionBase):
         self._snap_ver = self._engine.catalog.table_ver
         self._puts.clear()
         self._dels.clear()
+        self._tracked.clear()
+        self._tracked.clear()
 
     async def _tx_commit_impl(self) -> None:
         iso = (self._spec.isolation if self._spec else None) or "read_committed"
@@ -184,17 +241,34 @@ class NumpySession(TigrblSessionBase):
                 )
         self._puts.clear()
         self._dels.clear()
+        self._tracked.clear()
+        self._tracked.clear()
 
     async def _tx_rollback_impl(self) -> None:
         self._puts.clear()
         self._dels.clear()
+        self._tracked.clear()
 
     def _add_impl(self, obj: Any) -> Any:
         model = obj.__class__
         pk = _single_pk_name(model)
         ident = getattr(obj, pk)
+        if ident is None:
+            default = getattr(getattr(model, "__table__", None), "columns", {}).get(pk)
+            default = getattr(default, "default", None)
+            if default is not None:
+                arg = getattr(default, "arg", default)
+                if callable(arg):
+                    try:
+                        ident = arg()
+                    except TypeError:
+                        ident = arg(None)
+                else:
+                    ident = arg
+                setattr(obj, pk, ident)
         if ident is None:
             raise ValueError(f"primary key {pk!r} must be set")
+        self._tracked[(model, ident)] = obj
         row = {c: getattr(obj, c, None) for c in _model_columns(model)}
         self._puts[(model, ident)] = row
         self._dels.discard((model, ident))
@@ -206,30 +280,43 @@ class NumpySession(TigrblSessionBase):
         ident = getattr(obj, pk)
         self._puts.pop((model, ident), None)
         self._dels.add((model, ident))
+        self._tracked.pop((model, ident), None)
+        self._tracked.pop((model, ident), None)
 
     async def _flush_impl(self) -> None:
-        return
+        for (model, ident), obj in list(self._tracked.items()):
+            if (model, ident) in self._dels:
+                continue
+            row = {c: getattr(obj, c, None) for c in _model_columns(model)}
+            baseline = self._resolve_row(model, ident)
+            if baseline is None:
+                continue
+            if row == dict(baseline):
+                continue
+            if self._spec and self._spec.read_only:
+                raise RuntimeError("read-only session: writes detected during flush")
+            self._puts[(model, ident)] = row
 
     async def _refresh_impl(self, obj: Any) -> None:
         pk = _single_pk_name(obj.__class__)
         ident = getattr(obj, pk)
-        fresh = await self._get_impl(obj.__class__, ident)
-        if fresh is None:
+        row = self._resolve_row(obj.__class__, ident)
+        if row is None:
             return
         for c in _model_columns(obj.__class__):
-            setattr(obj, c, getattr(fresh, c, None))
+            if c in row:
+                setattr(obj, c, row[c])
 
     async def _get_impl(self, model: type, ident: Any) -> Any | None:
-        row = self._puts.get((model, ident))
-        if row is not None:
-            return self._inflate(model, row)
         if (model, ident) in self._dels:
             return None
-        pk = _single_pk_name(model)
-        for record in self._engine.catalog.rows:
-            if record.get(pk) == ident:
-                return self._inflate(model, record)
-        return None
+        tracked = self._tracked.get((model, ident))
+        if tracked is not None:
+            return tracked
+        row = self._resolve_row(model, ident)
+        if row is None:
+            return None
+        return self._hydrate_tracked(model, ident, row)
 
     async def _execute_impl(self, stmt: Any) -> Any:
         kind = type(stmt).__name__.lower()
@@ -252,6 +339,7 @@ class NumpySession(TigrblSessionBase):
         raise NotImplementedError(f"Unsupported statement: {type(stmt)}")
 
     async def _close_impl(self) -> None:
+        self._tracked.clear()
         return
 
     def _inflate(self, model: type, data: Mapping[str, Any]) -> Any:
@@ -262,17 +350,43 @@ class NumpySession(TigrblSessionBase):
         return obj
 
     def _scan_model(self, model: type) -> List[Any]:
-        out = [self._inflate(model, row) for row in self._engine.catalog.rows]
         pk = _single_pk_name(model)
-        by_id = {getattr(obj, pk): obj for obj in out}
+        by_id: dict[Any, Any] = {}
+        for row in self._engine.catalog.rows:
+            ident = row.get(pk)
+            if ident is None:
+                continue
+            by_id[ident] = self._hydrate_tracked(model, ident, row)
         for (m, ident), row in self._puts.items():
             if m is model:
-                by_id[ident] = self._inflate(model, row)
+                by_id[ident] = self._hydrate_tracked(model, ident, row)
         for m, ident in self._dels:
             if m is model:
                 by_id.pop(ident, None)
+                self._tracked.pop((model, ident), None)
         return list(by_id.values())
 
+    def _resolve_row(self, model: type, ident: Any) -> Mapping[str, Any] | None:
+        row = self._puts.get((model, ident))
+        if row is not None:
+            return row
+        pk = _single_pk_name(model)
+        for record in self._engine.catalog.rows:
+            if record.get(pk) == ident:
+                return record
+        return None
+
+    def _hydrate_tracked(self, model: type, ident: Any, data: Mapping[str, Any]) -> Any:
+        obj = self._tracked.get((model, ident))
+        if obj is None:
+            obj = self._inflate(model, data)
+            self._tracked[(model, ident)] = obj
+            return obj
+        for c in _model_columns(model):
+            if c in data:
+                setattr(obj, c, data[c])
+        return obj
+
     def _decompose_select(
         self, stmt: Any
     ) -> Tuple[
@@ -302,11 +416,20 @@ class NumpySession(TigrblSessionBase):
 
         def _all_subclasses(base: type) -> list[type]:
             out: list[type] = []
-            stack = list(base.__subclasses__())
+            stack = [base]
+            seen: set[type] = set()
             while stack:
                 cls = stack.pop()
-                out.append(cls)
-                stack.extend(cls.__subclasses__())
+                try:
+                    children = cls.__subclasses__()
+                except TypeError:
+                    continue
+                for child in children:
+                    if child in seen:
+                        continue
+                    seen.add(child)
+                    out.append(child)
+                    stack.append(child)
             return out
 
         def _find_by_table(name: str) -> type | None:
@@ -315,6 +438,13 @@ class NumpySession(TigrblSessionBase):
                     return cls
             return None
 
+        table = getattr(stmt, "table", None)
+        name = getattr(table, "name", None)
+        if isinstance(name, str):
+            found = _find_by_table(name)
+            if found is not None:
+                return found
+
         for attr_name in ("_from_objects", "_froms", "froms"):
             value = getattr(stmt, attr_name, None)
             if value is not None:
@@ -326,6 +456,27 @@ class NumpySession(TigrblSessionBase):
                     found = _find_by_table(name)
                     if found is not None:
                         return found
+
+        table = getattr(stmt, "table", None)
+        name = getattr(table, "name", None)
+        if isinstance(name, str):
+            found = _find_by_table(name)
+            if found is not None:
+                return found
+
+        raw_columns = getattr(stmt, "_raw_columns", None) or getattr(
+            stmt, "columns", None
+        )
+        if raw_columns is not None:
+            if isinstance(raw_columns, (list, tuple)) and not raw_columns:
+                raise RuntimeError("Cannot resolve model from statement")
+            entity = raw_columns[0]
+            table = getattr(entity, "table", None)
+            name = getattr(table, "name", None)
+            if isinstance(name, str):
+                found = _find_by_table(name)
+                if found is not None:
+                    return found
         raise RuntimeError("Cannot resolve model from statement")
 
     def _extract_predicates(self, stmt: Any) -> list[Tuple[str, str, Any]]:

{tigrbl_engine_numpy-0.1.1.dev2 → tigrbl_engine_numpy-0.1.1.dev4}/tests/test_numpy_io.py

@@ -4,10 +4,34 @@ from pathlib import Path
 
 import numpy as np
 import pytest
+from tigrbl.specs import F, IO, S
+from tigrbl.shortcuts import acol
+from tigrbl.table import Table
+from tigrbl.types import Mapped, String
 
 from tigrbl_engine_numpy import numpy_engine
 
 
+class _Widget(Table):
+    __tablename__ = "session_widgets"
+
+    id: Mapped[str] = acol(
+        storage=S(type_=String(64), primary_key=True, nullable=False),
+        field=F(py_type=str),
+        io=IO(out_verbs=("read", "list")),
+    )
+
+    name: Mapped[str] = acol(
+        storage=S(type_=String(50), nullable=False),
+        field=F(py_type=str),
+        io=IO(
+            in_verbs=("create", "update", "replace"),
+            out_verbs=("read", "list"),
+            mutable_verbs=("create", "update", "replace"),
+        ),
+    )
+
+
 def test_numpy_session_save_and_load_npy(tmp_path: Path) -> None:
     target = tmp_path / "records.npy"
     _, session_factory = numpy_engine(
@@ -134,3 +158,48 @@ def test_numpy_session_save_uses_atomic_replace(
     assert len(calls) == 1
     assert calls[0][1] == str(target)
     assert Path(calls[0][0]).name.startswith(".tmp_")
+
+
+@pytest.mark.asyncio
+async def test_numpy_session_get_reuses_tracked_instance() -> None:
+    ident = "fixed-id"
+    _, session_factory = numpy_engine(
+        mapping={
+            "array": np.array([[ident, "a"]], dtype=object),
+            "columns": ["id", "name"],
+            "pk": "id",
+        }
+    )
+    session = session_factory()
+
+    first = await session.get(_Widget, ident)
+    assert first is not None
+    first.name = "mutated"
+
+    second = await session.get(_Widget, ident)
+    assert second is first
+    assert second.name == "mutated"
+
+
+@pytest.mark.asyncio
+async def test_numpy_session_refresh_updates_tracked_instance() -> None:
+    ident = "fixed-id"
+    engine, session_factory = numpy_engine(
+        mapping={
+            "array": np.array([[ident, "a"]], dtype=object),
+            "columns": ["id", "name"],
+            "pk": "id",
+        }
+    )
+    session = session_factory()
+
+    item = await session.get(_Widget, ident)
+    assert item is not None
+    item.name = "mutated"
+
+    engine.catalog.rows[0]["name"] = "server"
+    await session.refresh(item)
+
+    again = await session.get(_Widget, ident)
+    assert again is item
+    assert again.name == "server"

{tigrbl_engine_numpy-0.1.1.dev2 → tigrbl_engine_numpy-0.1.1.dev4}/tests/test_tigrblapp_rpc_usage.py

@@ -4,10 +4,11 @@ import numpy as np
 import pytest
 
 from tigrbl import TigrblApp
-from tigrbl.bindings import rpc_call
+from tigrbl import rpc_call
 from tigrbl.engine import EngineSpec
 from tigrbl.orm.mixins import GUIDPk
-from tigrbl.specs import F, IO, S, acol
+from tigrbl.specs import F, IO, S
+from tigrbl.shortcuts import acol
 from tigrbl.table import Table
 from tigrbl.types import Mapped, String
 
@@ -44,7 +45,7 @@ def app_and_db() -> tuple[TigrblApp, object]:
     db = session_factory()
 
     api = TigrblApp(engine=spec)
-    api.include_model(NumpyWidget, mount_router=False)
+    api.include_table(NumpyWidget, mount_router=False)
     api.initialize()
     return api, db