tigrbl_engine_numpy 0.1.1__py3-none-any.whl

tigrbl_engine_numpy/__init__.py

@@ -0,0 +1,26 @@
+from .engine import NumpyEngine, numpy_capabilities, numpy_engine
+from .session import NumpySession
+
+
+class _Registration:
+    def build(self, *, mapping, spec, dsn):
+        return numpy_engine(mapping=mapping, spec=spec, dsn=dsn)
+
+    def capabilities(self, *, spec, mapping=None):
+        return numpy_capabilities()
+
+
+def register() -> None:
+    """Entry-point hook invoked by tigrbl to register this engine."""
+    from tigrbl.engine.registry import register_engine
+
+    register_engine("numpy", _Registration())
+
+
+__all__ = [
+    "NumpyEngine",
+    "NumpySession",
+    "numpy_engine",
+    "numpy_capabilities",
+    "register",
+]

tigrbl_engine_numpy/engine.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import threading
+from typing import Any, Callable
+
+import numpy as np
+
+from .session import NumpySession
+
+
+@dataclass
+class NumpyCatalog:
+    rows: list[dict[str, Any]] = field(default_factory=list)
+    columns: list[str] = field(default_factory=list)
+    pk: str = "id"
+    table_ver: int = 0
+    path: str | None = None
+    file_format: str | None = None
+    npz_key: str | None = None
+    lock: threading.RLock = field(default_factory=threading.RLock)
+
+    def bump(self) -> None:
+        self.table_ver += 1
+
+
+@dataclass
+class NumpyEngine:
+    """Single-table NumPy engine: one ndarray/memmap behaves like one table DB."""
+
+    array: np.ndarray
+    table: str
+    pk: str
+    columns: list[str]
+    catalog: NumpyCatalog
+
+
+def _rows_from_array(array: np.ndarray, columns: list[str]) -> list[dict[str, Any]]:
+    if array.ndim == 0:
+        matrix = np.asarray([[array.item()]], dtype=object)
+    elif array.ndim == 1:
+        matrix = np.asarray(array, dtype=object).reshape(-1, 1)
+    else:
+        matrix = np.asarray(array, dtype=object)
+    return [dict(zip(columns, row, strict=False)) for row in matrix.tolist()]
+
+
+def _resolve_array(config: dict[str, Any]) -> np.ndarray:
+    if (raw_array := config.get("array")) is not None:
+        return raw_array if isinstance(raw_array, np.ndarray) else np.asarray(raw_array)
+
+    if (
+        path_value := config.get("path")
+        or config.get("load_path")
+        or config.get("file")
+    ):
+        path = Path(path_value)
+        loaded = np.load(
+            path,
+            mmap_mode=config.get("mmap_mode"),
+            allow_pickle=True,
+        )
+        if isinstance(loaded, np.lib.npyio.NpzFile):
+            with loaded as archive:
+                npz_key = config.get("npz_key")
+                if npz_key is None:
+                    if len(archive.files) != 1:
+                        raise ValueError(
+                            "mapping['npz_key'] is required for multi-array .npz files"
+                        )
+                    npz_key = archive.files[0]
+                return np.asarray(archive[npz_key])
+        return loaded
+
+    if (memmap_path := config.get("memmap_path")) is not None:
+        mode = config.get("memmap_mode", "r+")
+        valid_modes = {"r", "r+", "w+", "c"}
+        if mode not in valid_modes:
+            raise ValueError(
+                f"mapping['memmap_mode'] must be one of {sorted(valid_modes)}"
+            )
+        dtype = config.get("dtype", np.float64)
+        shape = config.get("shape")
+        if mode == "w+" and shape is None:
+            raise ValueError("mapping['shape'] is required when memmap_mode='w+'")
+        return np.memmap(memmap_path, dtype=dtype, mode=mode, shape=shape)
+
+    raise TypeError(
+        "Provide one of mapping['array'], mapping['path']/['load_path']/['file'], or mapping['memmap_path']"
+    )
+
+
+def numpy_engine(
+    *, mapping: dict[str, Any] | None = None, **_: Any
+) -> tuple[NumpyEngine, Callable[[], NumpySession]]:
+    """Build the ``numpy`` engine handle and session factory for tigrbl."""
+    config = dict(mapping or {})
+    table = config.get("table", "records")
+    pk = config.get("pk", "id")
+    if not isinstance(table, str) or not table:
+        raise TypeError("mapping['table'] must be a non-empty string")
+    if not isinstance(pk, str) or not pk:
+        raise TypeError("mapping['pk'] must be a non-empty string")
+
+    array = _resolve_array(config)
+    inferred_cols = 1 if array.ndim <= 1 else int(array.shape[1])
+    columns = list(
+        config.get("columns") or [f"col_{idx}" for idx in range(inferred_cols)]
+    )
+    if pk not in columns:
+        columns = [pk, *columns]
+
+    storage_path = config.get("path") or config.get("load_path") or config.get("file")
+    resolved_path = str(Path(storage_path)) if isinstance(storage_path, str) else None
+    npz_key = config.get("npz_key") if isinstance(config.get("npz_key"), str) else None
+    file_format: str | None = None
+    if resolved_path:
+        suffix = Path(resolved_path).suffix.lower()
+        if suffix == ".npy":
+            file_format = "npy"
+        elif suffix == ".npz":
+            file_format = "npz"
+
+    rows = _rows_from_array(array, columns)
+    catalog = NumpyCatalog(
+        rows=rows,
+        columns=columns,
+        pk=pk,
+        path=resolved_path,
+        file_format=file_format,
+        npz_key=npz_key,
+    )
+    engine = NumpyEngine(
+        array=array, table=table, pk=pk, columns=columns, catalog=catalog
+    )
+
+    def session_factory() -> NumpySession:
+        return NumpySession(engine)
+
+    return engine, session_factory
+
+
+def numpy_capabilities() -> dict[str, object]:
+    return {
+        "ndarray": True,
+        "single_table_database": True,
+        "file_formats": ["npy", "npz"],
+        "numpy_api": ["np.load", "np.memmap", "np.save"],
+        "memmap_modes": ["r", "r+", "w+", "c"],
+        "transactions": True,
+        "dialect": "numpy",
+    }

tigrbl_engine_numpy/session.py

@@ -0,0 +1,580 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import tempfile
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+)
+
+import numpy as np
+
+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
+except Exception:
+
+    class SessionSpec:  # pragma: no cover - fallback
+        def __init__(self, isolation=None, read_only=None):
+            self.isolation = isolation
+            self.read_only = read_only
+
+
+try:
+    from tigrbl.core.crud.helpers.model import _single_pk_name, _model_columns
+except Exception:
+
+    def _single_pk_name(model):  # pragma: no cover - fallback
+        return "id"
+
+    def _model_columns(model):  # pragma: no cover - fallback
+        return getattr(model, "__annotations__", {}) or {"id": int}
+
+
+if TYPE_CHECKING:
+    from .engine import NumpyEngine
+
+
+class _ScalarResult:
+    def __init__(self, items: Sequence[Any]) -> None:
+        self._items = list(items)
+
+    def scalars(self) -> "_ScalarResult":
+        return self
+
+    def all(self) -> List[Any]:
+        return list(self._items)
+
+
+class _ExecuteResult(_ScalarResult):
+    rowcount: int = 0
+
+
+class NumpySession(TigrblSessionBase):
+    """Tigrbl session for a single NumPy-backed table database."""
+
+    def __init__(self, engine: "NumpyEngine") -> None:
+        super().__init__(SessionSpec())
+        self._engine = engine
+        self._snap: Optional[list[dict[str, Any]]] = None
+        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]]:
+        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()
+        values = [[row.get(col) for col in self._engine.columns] for row in rows]
+        return np.asarray(values, dtype=object)
+
+    def load(
+        self, file: str, *, mmap_mode: str | None = None, npz_key: str | None = None
+    ) -> np.ndarray:
+        loaded = np.load(file, mmap_mode=mmap_mode, allow_pickle=True)
+        if isinstance(loaded, np.lib.npyio.NpzFile):
+            with loaded as archive:
+                key = npz_key or (archive.files[0] if len(archive.files) == 1 else None)
+                if key is None:
+                    raise ValueError(
+                        "npz_key is required when loading multi-array .npz files"
+                    )
+                return np.asarray(archive[key])
+        return loaded
+
+    def memmap(
+        self,
+        filename: str,
+        *,
+        dtype: Any = np.float64,
+        mode: str = "r+",
+        shape: Any = None,
+    ) -> np.memmap:
+        valid_modes = {"r", "r+", "w+", "c"}
+        if mode not in valid_modes:
+            raise ValueError(f"mode must be one of {sorted(valid_modes)}")
+        if mode == "w+" and shape is None:
+            raise ValueError("shape is required when mode='w+'")
+        return np.memmap(filename, dtype=dtype, mode=mode, shape=shape)
+
+    def save(
+        self,
+        file: str | None = None,
+        array: np.ndarray | None = None,
+        *,
+        npz_key: str | None = None,
+    ) -> None:
+        target = file or self._engine.catalog.path
+        if not target:
+            raise ValueError("A target file path is required")
+
+        payload = self.array() if array is None else np.asarray(array)
+        self._atomic_save_numpy(target, payload, npz_key=npz_key)
+
+    def _atomic_save_numpy(
+        self, file: str, array: np.ndarray, *, npz_key: str | None = None
+    ) -> None:
+        path = Path(file)
+        directory = str(path.parent if str(path.parent) else Path("."))
+        suffix = path.suffix.lower()
+        if suffix not in {".npy", ".npz"}:
+            raise ValueError("file must use .npy or .npz suffix")
+
+        fd, tmp = tempfile.mkstemp(
+            dir=directory,
+            prefix=".tmp_",
+            suffix=suffix,
+        )
+        os.close(fd)
+        try:
+            if suffix == ".npz":
+                key = npz_key or self._engine.catalog.npz_key or "data"
+                np.savez(tmp, **{key: array})
+            else:
+                np.save(tmp, array)
+            os.replace(tmp, str(path))
+        finally:
+            if os.path.exists(tmp):
+                os.remove(tmp)
+
+    async def run_sync(self, fn: Callable[[Any], Any]) -> Any:
+        out = fn(self)
+        return await out if hasattr(out, "__await__") else out
+
+    async def begin(self) -> None:
+        await self._tx_begin_impl()
+
+    async def commit(self) -> None:
+        await self._tx_commit_impl()
+
+    async def rollback(self) -> None:
+        await self._tx_rollback_impl()
+
+    async def flush(self) -> None:
+        await self._flush_impl()
+
+    async def refresh(self, obj: Any) -> None:
+        await self._refresh_impl(obj)
+
+    async def get(self, model: type, ident: Any) -> Any | None:
+        return await self._get_impl(model, ident)
+
+    async def execute(self, stmt: Any) -> Any:
+        return await self._execute_impl(stmt)
+
+    async def close(self) -> None:
+        await self._close_impl()
+
+    async def _tx_begin_impl(self) -> None:
+        self._snap = [dict(row) for row in self._engine.catalog.rows]
+        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"
+        if (
+            iso in ("repeatable_read", "snapshot", "serializable")
+            and self._snap_ver is not None
+        ):
+            if self._engine.catalog.table_ver != self._snap_ver:
+                raise RuntimeError("transaction conflict on table")
+
+        with self._engine.catalog.lock:
+            live = list(self._engine.catalog.rows)
+            for model, ident in self._dels:
+                pk = _single_pk_name(model)
+                live = [row for row in live if row.get(pk) != ident]
+            for (model, ident), row in self._puts.items():
+                pk = _single_pk_name(model)
+                live = [existing for existing in live if existing.get(pk) != ident]
+                live.append(dict(row))
+            self._engine.catalog.rows = live
+            self._engine.catalog.bump()
+            if self._engine.catalog.path:
+                self._atomic_save_numpy(
+                    self._engine.catalog.path,
+                    self.array(),
+                    npz_key=self._engine.catalog.npz_key,
+                )
+        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))
+        return None
+
+    async def _delete_impl(self, obj: Any) -> None:
+        model = obj.__class__
+        pk = _single_pk_name(model)
+        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:
+        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)
+        row = self._resolve_row(obj.__class__, ident)
+        if row is None:
+            return
+        for c in _model_columns(obj.__class__):
+            if c in row:
+                setattr(obj, c, row[c])
+
+    async def _get_impl(self, model: type, ident: Any) -> Any | None:
+        if (model, ident) in self._dels:
+            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()
+        if "select" in kind:
+            model, where, order, limit, offset = self._decompose_select(stmt)
+            items = self._scan_model(model)
+            items = [o for o in items if self._matches_obj(o, where)]
+            return _ExecuteResult(self._order_slice(items, order, limit, offset))
+        if "delete" in kind:
+            model, where = self._decompose_delete(stmt)
+            items = [o for o in self._scan_model(model) if self._matches_obj(o, where)]
+            for obj in items:
+                pk = _single_pk_name(model)
+                ident = getattr(obj, pk)
+                self._puts.pop((model, ident), None)
+                self._dels.add((model, ident))
+            res = _ExecuteResult([])
+            res.rowcount = len(items)
+            return res
+        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:
+        obj = model()
+        for c in _model_columns(model):
+            if c in data:
+                setattr(obj, c, data[c])
+        return obj
+
+    def _scan_model(self, model: type) -> List[Any]:
+        pk = _single_pk_name(model)
+        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._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[
+        type,
+        list[Tuple[str, str, Any]],
+        list[Tuple[str, str]],
+        Optional[int],
+        Optional[int],
+    ]:
+        return (
+            self._extract_model(stmt),
+            self._extract_predicates(stmt),
+            self._extract_order_by(stmt),
+            self._extract_int(stmt, ["_limit", "_limit_clause", "limit"]),
+            self._extract_int(stmt, ["_offset", "_offset_clause", "offset"]),
+        )
+
+    def _decompose_delete(self, stmt: Any) -> Tuple[type, list[Tuple[str, str, Any]]]:
+        return self._extract_model(stmt), self._extract_predicates(stmt)
+
+    def _extract_model(self, stmt: Any) -> type:
+        descs = getattr(stmt, "column_descriptions", None) or []
+        for desc in descs:
+            entity = desc.get("entity") if isinstance(desc, dict) else None
+            if isinstance(entity, type):
+                return entity
+
+        def _all_subclasses(base: type) -> list[type]:
+            out: list[type] = []
+            stack = [base]
+            seen: set[type] = set()
+            while stack:
+                cls = stack.pop()
+                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:
+            for cls in _all_subclasses(object):
+                if getattr(cls, "__tablename__", None) == name:
+                    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:
+                if isinstance(value, (list, tuple)) and not value:
+                    continue
+                table = value[0] if isinstance(value, (list, tuple)) else value
+                name = getattr(table, "name", None)
+                if isinstance(name, str):
+                    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]]:
+        where = getattr(stmt, "whereclause", None) or getattr(
+            stmt, "_whereclause", None
+        )
+        if where is None:
+            return []
+        nodes = list(getattr(where, "clauses", None) or [where])
+        out: list[Tuple[str, str, Any]] = []
+        for node in nodes:
+            left, right, op = (
+                getattr(node, "left", None),
+                getattr(node, "right", None),
+                getattr(node, "operator", None),
+            )
+            name = getattr(left, "key", None) or getattr(left, "name", None)
+            if left is None or right is None or name is None:
+                continue
+            opname = getattr(op, "__name__", str(op))
+            if "eq" in opname:
+                out.append((str(name), "eq", getattr(right, "value", None)))
+        return out
+
+    def _extract_order_by(self, stmt: Any) -> list[Tuple[str, str]]:
+        order = getattr(stmt, "_order_by_clause", None)
+        if order is None:
+            order = getattr(stmt, "_order_by_clauses", None)
+        if order is None:
+            return []
+        clauses = getattr(order, "clauses", None) or order
+        clauses = clauses if isinstance(clauses, (list, tuple)) else [clauses]
+        for clause in clauses:
+            col = getattr(clause, "element", None) or getattr(clause, "this", None)
+            name = getattr(col, "key", None) or getattr(col, "name", None)
+            if name:
+                direction = "desc" if "desc" in type(clause).__name__.lower() else "asc"
+                return [(str(name), direction)]
+        return []
+
+    def _extract_int(self, stmt: Any, names: Sequence[str]) -> Optional[int]:
+        for name in names:
+            value = getattr(stmt, name, None)
+            if value is None:
+                continue
+            try:
+                return int(value)
+            except Exception:
+                literal = getattr(value, "value", None)
+                if literal is not None:
+                    return int(literal)
+        return None
+
+    def _matches_obj(self, obj: Any, where: list[Tuple[str, str, Any]]) -> bool:
+        for name, op, value in where:
+            datum = getattr(obj, name, None)
+            if op == "eq" and datum != value:
+                return False
+        return True
+
+    def _order_slice(
+        self,
+        items: List[Any],
+        order: list[Tuple[str, str]],
+        limit: Optional[int],
+        offset: Optional[int],
+    ) -> List[Any]:
+        if order:
+            col, direction = order[0]
+            items.sort(
+                key=lambda obj: getattr(obj, col, None), reverse=(direction == "desc")
+            )
+        if isinstance(offset, int):
+            items = items[max(0, offset) :]
+        if isinstance(limit, int):
+            items = items[: max(0, limit)]
+        return items

tigrbl_engine_numpy-0.1.1.dist-info/METADATA

@@ -0,0 +1,279 @@
+Metadata-Version: 2.4
+Name: tigrbl_engine_numpy
+Version: 0.1.1
+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>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+        TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+        1. Definitions.
+        
+           "License" shall mean the terms and conditions for use, reproduction,
+           and distribution as defined by Sections 1 through 9 of this document.
+        
+           "Licensor" shall mean the copyright owner or entity authorized by
+           the copyright owner that is granting the License.
+        
+           "Legal Entity" shall mean the union of the acting entity and all
+           other entities that control, are controlled by, or are under common
+           control with that entity. For the purposes of this definition,
+           "control" means (i) the power, direct or indirect, to cause the
+           direction or management of such entity, whether by contract or
+           otherwise, or (ii) ownership of fifty percent (50%) or more of the
+           outstanding shares, or (iii) beneficial ownership of such entity.
+        
+           "You" (or "Your") shall mean an individual or Legal Entity
+           exercising permissions granted by this License.
+        
+           "Source" form shall mean the preferred form for making modifications,
+           including but not limited to software source code, documentation
+           source, and configuration files.
+        
+           "Object" form shall mean any form resulting from mechanical
+           transformation or translation of a Source form, including but
+           not limited to compiled object code, generated documentation,
+           and conversions to other media types.
+        
+           "Work" shall mean the work of authorship, whether in Source or
+           Object form, made available under the License, as indicated by a
+           copyright notice that is included in or attached to the work
+           (an example is provided in the Appendix below).
+        
+           "Derivative Works" shall mean any work, whether in Source or Object
+           form, that is based on (or derived from) the Work and for which the
+           editorial revisions, annotations, elaborations, or other modifications
+           represent, as a whole, an original work of authorship. For the purposes
+           of this License, Derivative Works shall not include works that remain
+           separable from, or merely link (or bind by name) to the interfaces of,
+           the Work and Derivative Works thereof.
+        
+           "Contribution" shall mean any work of authorship, including
+           the original version of the Work and any modifications or additions
+           to that Work or Derivative Works thereof, that is intentionally
+           submitted to Licensor for inclusion in the Work by the copyright owner
+           or by an individual or Legal Entity authorized to submit on behalf of
+           the copyright owner. For the purposes of this definition, "submitted"
+           means any form of electronic, verbal, or written communication sent
+           to the Licensor or its representatives, including but not limited to
+           communication on electronic mailing lists, source code control systems,
+           and issue tracking systems that are managed by, or on behalf of, the
+           Licensor for the purpose of discussing and improving the Work, but
+           excluding communication that is conspicuously marked or otherwise
+           designated in writing by the copyright owner as "Not a Contribution."
+        
+           "Contributor" shall mean Licensor and any individual or Legal Entity
+           on behalf of whom a Contribution has been received by Licensor and
+           subsequently incorporated within the Work.
+        
+        2. Grant of Copyright License. Subject to the terms and conditions of
+           this License, each Contributor hereby grants to You a perpetual,
+           worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+           copyright license to reproduce, prepare Derivative Works of,
+           publicly display, publicly perform, sublicense, and distribute the
+           Work and such Derivative Works in Source or Object form.
+        
+        3. Grant of Patent License. Subject to the terms and conditions of
+           this License, each Contributor hereby grants to You a perpetual,
+           worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+           (except as stated in this section) patent license to make, have made,
+           use, offer to sell, sell, import, and otherwise transfer the Work,
+           where such license applies only to those patent claims licensable
+           by such Contributor that are necessarily infringed by their
+           Contribution(s) alone or by combination of their Contribution(s)
+           with the Work to which such Contribution(s) was submitted. If You
+           institute patent litigation against any entity (including a
+           cross-claim or counterclaim in a lawsuit) alleging that the Work
+           or a Contribution incorporated within the Work constitutes direct
+           or contributory patent infringement, then any patent licenses
+           granted to You under this License for that Work shall terminate
+           as of the date such litigation is filed.
+        
+        4. Redistribution. You may reproduce and distribute copies of the
+           Work or Derivative Works thereof in any medium, with or without
+           modifications, and in Source or Object form, provided that You
+           meet the following conditions:
+        
+           (a) You must give any other recipients of the Work or
+               Derivative Works a copy of this License; and
+        
+           (b) You must cause any modified files to carry prominent notices
+               stating that You changed the files; and
+        
+           (c) You must retain, in the Source form of any Derivative Works
+               that You distribute, all copyright, patent, trademark, and
+               attribution notices from the Source form of the Work,
+               excluding those notices that do not pertain to any part of
+               the Derivative Works; and
+        
+           (d) If the Work includes a "NOTICE" text file as part of its
+               distribution, then any Derivative Works that You distribute must
+               include a readable copy of the attribution notices contained
+               within such NOTICE file, excluding those notices that do not
+               pertain to any part of the Derivative Works, in at least one
+               of the following places: within a NOTICE text file distributed
+               as part of the Derivative Works; within the Source form or
+               documentation, if provided along with the Derivative Works; or,
+               within a display generated by the Derivative Works, if and
+               wherever such third-party notices normally appear. The contents
+               of the NOTICE file are for informational purposes only and
+               do not modify the License. You may add Your own attribution
+               notices within Derivative Works that You distribute, alongside
+               or as an addendum to the NOTICE text from the Work, provided
+               that such additional attribution notices cannot be construed
+               as modifying the License.
+        
+           You may add Your own copyright statement to Your modifications and
+           may provide additional or different license terms and conditions
+           for use, reproduction, or distribution of Your modifications, or
+           for any such Derivative Works as a whole, provided Your use,
+           reproduction, and distribution of the Work otherwise complies with
+           the conditions stated in this License.
+        
+        5. Submission of Contributions. Unless You explicitly state otherwise,
+           any Contribution intentionally submitted for inclusion in the Work
+           by You to the Licensor shall be under the terms and conditions of
+           this License, without any additional terms or conditions.
+           Notwithstanding the above, nothing herein shall supersede or modify
+           the terms of any separate license agreement you may have executed
+           with Licensor regarding such Contributions.
+        
+        6. Trademarks. This License does not grant permission to use the trade
+           names, trademarks, service marks, or product names of the Licensor,
+           except as required for reasonable and customary use in describing the
+           origin of the Work and reproducing the content of the NOTICE file.
+        
+        7. Disclaimer of Warranty. Unless required by applicable law or
+           agreed to in writing, Licensor provides the Work (and each
+           Contributor provides its Contributions) on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+           implied, including, without limitation, any warranties or conditions
+           of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+           PARTICULAR PURPOSE. You are solely responsible for determining the
+           appropriateness of using or redistributing the Work and assume any
+           risks associated with Your exercise of permissions under this License.
+        
+        8. Limitation of Liability. In no event and under no legal theory,
+           whether in tort (including negligence), contract, or otherwise,
+           unless required by applicable law (such as deliberate and grossly
+           negligent acts) or agreed to in writing, shall any Contributor be
+           liable to You for damages, including any direct, indirect, special,
+           incidental, or consequential damages of any character arising as a
+           result of this License or out of the use or inability to use the
+           Work (including but not limited to damages for loss of goodwill,
+           work stoppage, computer failure or malfunction, or any and all
+           other commercial damages or losses), even if such Contributor
+           has been advised of the possibility of such damages.
+        
+        9. Accepting Warranty or Additional Liability. While redistributing
+           the Work or Derivative Works thereof, You may choose to offer,
+           and charge a fee for, acceptance of support, warranty, indemnity,
+           or other liability obligations and/or rights consistent with this
+           License. However, in accepting such obligations, You may act only
+           on Your own behalf and on Your sole responsibility, not on behalf
+           of any other Contributor, and only if You agree to indemnify,
+           defend, and hold each Contributor harmless for any liability
+           incurred by, or claims asserted against, such Contributor by reason
+           of your accepting any such warranty or additional liability.
+        
+        END OF TERMS AND CONDITIONS
+        
+        APPENDIX: How to apply the Apache License to your work.
+        
+           To apply the Apache License to your work, attach the following
+           boilerplate notice, with the fields enclosed by brackets "[]"
+           replaced with your own identifying information. (Don't include
+           the brackets!)  The text should be enclosed in the appropriate
+           comment syntax for the file format. We also recommend that a
+           file or class name and description of purpose be included on the
+           same "printed page" as the copyright notice for easier
+           identification within third-party archives.
+        
+           Copyright [2025] [Swarmauri Team]
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+License-File: LICENSE
+Keywords: array,engine,experimental,numpy,tigrbl
+Classifier: Development Status :: 1 - Planning
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <3.13,>=3.10
+Requires-Dist: numpy>=1.26
+Requires-Dist: tigrbl>=0.3.0.dev4
+Description-Content-Type: text/markdown
+
+![Tigrbl Logo](https://raw.githubusercontent.com/swarmauri/swarmauri-sdk/master/assets/tigrbl_full_logo.png)
+
+<p align="center">
+    <a href="https://pypi.org/project/tigrbl_engine_numpy/">
+        <img src="https://img.shields.io/pypi/v/tigrbl_engine_numpy?label=tigrbl_engine_numpy&color=green" alt="PyPI - tigrbl_engine_numpy"/>
+    </a>
+    <a href="https://pypi.org/project/tigrbl_engine_numpy/">
+        <img src="https://img.shields.io/pypi/dm/tigrbl_engine_numpy" alt="PyPI - Downloads"/>
+    </a>
+    <a href="https://pypi.org/project/tigrbl_engine_numpy/">
+        <img src="https://img.shields.io/pypi/pyversions/tigrbl_engine_numpy" alt="PyPI - Python Version"/>
+    </a>
+    <a href="https://pypi.org/project/tigrbl_engine_numpy/">
+        <img src="https://img.shields.io/pypi/l/tigrbl_engine_numpy" alt="PyPI - License"/>
+    </a>
+    <a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/experimental/tigrbl_engine_numpy/">
+        <img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/experimental/tigrbl_engine_numpy.svg"/>
+    </a>
+</p>
+
+# tigrbl_engine_numpy
+
+A tigrbl engine plugin that registers `kind="numpy"` where each array/matrix is a single-table database-like object.
+
+## Features
+
+- Registers a `numpy` engine through the `tigrbl.engine` entry-point group.
+- Treats one NumPy array/matrix as one table.
+- Provides a first-class `NumpySession` (subclass of `TigrblSessionBase`) without pandas dependencies.
+- Supports loading `.npy`/`.npz` via `np.load(...)`, memory-mapped arrays via `np.memmap(...)`, and persistence via `np.save(...)`.
+
+## Installation
+
+### uv
+
+```bash
+uv add tigrbl_engine_numpy
+```
+
+### pip
+
+```bash
+pip install tigrbl_engine_numpy
+```
+
+## Usage
+
+```python
+import numpy as np
+from tigrbl.engine import EngineSpec
+
+spec = EngineSpec(kind="numpy", mapping={"array": np.array([[1, 2], [3, 4]]), "columns": ["id", "value"], "table": "matrix", "pk": "id"})
+provider = spec.provider()
+engine, session_factory = provider.build()
+
+session = session_factory()
+print(session.array())
+print(session.to_records())
+session.close()
+```

tigrbl_engine_numpy-0.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+tigrbl_engine_numpy/__init__.py,sha256=AwC9E7-M6JejPcB-kOh247YvfpgfPkmRuogWJToIwSc,635
+tigrbl_engine_numpy/engine.py,sha256=UA1CzqX6DLo8Mto7rtUffUuIwPoxYs0e1nE9EQpl_SI,5038
+tigrbl_engine_numpy/session.py,sha256=-WcfVc87AtfIegCa9kw-0sWu9fAx5rUvJolO6VBpdyA,20080
+tigrbl_engine_numpy-0.1.1.dist-info/METADATA,sha256=P9RX43Ed_D1o8mP5CZxuRB_JbGtztiJZ_k8KIxjpS5g,15334
+tigrbl_engine_numpy-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+tigrbl_engine_numpy-0.1.1.dist-info/entry_points.txt,sha256=F2yEiEf3u5fb5rzg1epqAM_GBi80I5V5umgd8KiO6CA,53
+tigrbl_engine_numpy-0.1.1.dist-info/licenses/LICENSE,sha256=708mvS2G_dkXGD6DVfUDngIUW4HW-T14Ws-q7shsacA,10880
+tigrbl_engine_numpy-0.1.1.dist-info/RECORD,,

tigrbl_engine_numpy-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

tigrbl_engine_numpy-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[tigrbl.engine]
+numpy = tigrbl_engine_numpy:register

tigrbl_engine_numpy-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+   Copyright [2025] [Swarmauri Team]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.