tigrbl_engine_xlsx 0.1.1__py3-none-any.whl

tigrbl_engine_xlsx/__init__.py

@@ -0,0 +1,27 @@
+from .engine import WorkbookCatalog, XlsxEngine, xlsx_capabilities, xlsx_engine
+from .session import XlsxSession
+
+
+class _Registration:
+    def build(self, *, mapping, spec, dsn):
+        return xlsx_engine(mapping=mapping, spec=spec, dsn=dsn)
+
+    def capabilities(self, *, spec, mapping=None):
+        return xlsx_capabilities()
+
+
+def register() -> None:
+    """Entry-point hook invoked by tigrbl to register this engine."""
+    from tigrbl.engine.registry import register_engine
+
+    register_engine("xlsx", _Registration())
+
+
+__all__ = [
+    "WorkbookCatalog",
+    "XlsxEngine",
+    "XlsxSession",
+    "xlsx_engine",
+    "xlsx_capabilities",
+    "register",
+]

tigrbl_engine_xlsx/engine.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import threading
+from typing import Any, Callable
+
+from openpyxl import load_workbook
+from openpyxl.workbook import Workbook
+
+from .session import XlsxSession
+
+
+@dataclass
+class WorkbookCatalog:
+    workbook: Workbook
+    path: str
+    tables: dict[str, list[dict[str, Any]]] = field(default_factory=dict)
+    pks: dict[str, str] = field(default_factory=dict)
+    table_ver: dict[str, int] = field(default_factory=dict)
+    lock: threading.RLock = field(default_factory=threading.RLock)
+
+    def get_live(self, name: str) -> list[dict[str, Any]]:
+        if name not in self.tables:
+            self.tables[name] = []
+            self.table_ver[name] = 0
+            self.pks.setdefault(name, "id")
+        self.table_ver.setdefault(name, 0)
+        return self.tables[name]
+
+    def bump(self, name: str) -> None:
+        self.table_ver[name] = self.table_ver.get(name, 0) + 1
+
+
+def _sheet_to_rows(workbook: Workbook, sheet_name: str) -> list[dict[str, Any]]:
+    sheet = workbook[sheet_name]
+    values = list(sheet.iter_rows(values_only=True))
+    if not values:
+        return []
+    headers = [str(col) if col is not None else "" for col in values[0]]
+    rows: list[dict[str, Any]] = []
+    for row_values in values[1:]:
+        row = {
+            header: value
+            for header, value in zip(headers, row_values, strict=False)
+            if header
+        }
+        if any(value is not None for value in row.values()):
+            rows.append(row)
+    return rows
+
+
+@dataclass
+class XlsxEngine:
+    """Workbook-backed engine: workbook as DB, sheet names as tables."""
+
+    path: str
+    pk: str
+    workbook: Workbook
+    catalog: WorkbookCatalog
+
+
+def xlsx_engine(
+    *, mapping: dict[str, Any] | None = None, **_: Any
+) -> tuple[XlsxEngine, Callable[[], XlsxSession]]:
+    config = dict(mapping or {})
+    path_value = config.get("path") or config.get("file")
+    if not isinstance(path_value, str) or not path_value:
+        raise TypeError("mapping['path'] (or 'file') must be a non-empty string")
+    path = str(Path(path_value))
+
+    pk = config.get("pk", "id")
+    if not isinstance(pk, str) or not pk:
+        raise TypeError("mapping['pk'] must be a non-empty string")
+
+    workbook = load_workbook(path)
+    if not workbook.sheetnames:
+        raise ValueError("workbook must contain at least one sheet")
+
+    catalog = WorkbookCatalog(
+        workbook=workbook,
+        path=path,
+        tables={name: _sheet_to_rows(workbook, name) for name in workbook.sheetnames},
+        pks={name: pk for name in workbook.sheetnames},
+    )
+    engine = XlsxEngine(path=path, pk=pk, workbook=workbook, catalog=catalog)
+
+    def session_factory() -> XlsxSession:
+        return XlsxSession(catalog)
+
+    return engine, session_factory
+
+
+def xlsx_capabilities() -> dict[str, object]:
+    return {
+        "files": ["xlsx"],
+        "workbook_database": True,
+        "multi_table": True,
+        "workbook_api": ["load_workbook", "wb[...]", "wb.save(...)"],
+        "transactions": True,
+        "dialect": "xlsx",
+    }

tigrbl_engine_xlsx/session.py

@@ -0,0 +1,608 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import uuid
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+)
+
+from openpyxl.worksheet.worksheet import Worksheet
+
+try:
+    from tigrbl.session.base import TigrblSessionBase
+except Exception:
+    from abc import ABC, abstractmethod
+
+    class TigrblSessionBase(ABC):  # pragma: no cover - fallback
+        def __init__(self, spec=None):
+            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}
+
+
+try:
+    from tigrbl.core.crud.helpers import NoResultFound
+except Exception:
+
+    class NoResultFound(Exception):
+        pass
+
+
+if TYPE_CHECKING:
+    from .engine import WorkbookCatalog
+
+
+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)
+
+    def scalar_one(self) -> Any:
+        if len(self._items) != 1:
+            raise NoResultFound("expected exactly one row")
+        return self._items[0]
+
+
+class _ExecuteResult(_ScalarResult):
+    rowcount: int = 0
+
+
+class XlsxSession(TigrblSessionBase):
+    """Native transaction session over workbook sheets as tables."""
+
+    def __init__(
+        self, catalog: "WorkbookCatalog", spec: Optional[SessionSpec] = None
+    ) -> None:
+        super().__init__(spec)
+        self._cat = catalog
+        self._snap: Dict[str, list[dict[str, Any]]] = {}
+        self._snap_ver: Dict[str, int] = {}
+        self._puts: Dict[Tuple[type, Any], Dict[str, Any]] = {}
+        self._dels: set[Tuple[type, Any]] = set()
+        self._tracked: Dict[Tuple[type, Any], Any] = {}
+
+    def workbook(self):
+        return self._cat.workbook
+
+    def sheet(self, name: str) -> Worksheet:
+        return self._cat.workbook[name]
+
+    def table(self, name: str) -> list[dict[str, Any]]:
+        rows = [dict(row) for row in self._cat.get_live(name)]
+        pk = self._pk_of(name)
+        by_pk = {row.get(pk): row for row in rows}
+
+        for (model, ident), row in self._puts.items():
+            if self._table(model) == name:
+                by_pk[ident] = dict(row)
+
+        for model, ident in self._dels:
+            if self._table(model) == name:
+                by_pk.pop(ident, None)
+
+        return list(by_pk.values())
+
+    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.clear()
+        self._snap_ver.clear()
+        self._puts.clear()
+        self._dels.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"):
+            for table, version in self._snap_ver.items():
+                if self._cat.table_ver.get(table, 0) != version:
+                    raise RuntimeError(f"transaction conflict on table '{table}'")
+
+        with self._cat.lock:
+            dels_by_table: Dict[str, List[Any]] = {}
+            for model, ident in self._dels:
+                dels_by_table.setdefault(self._table(model), []).append(ident)
+            for table, idents in dels_by_table.items():
+                pk = self._pk_of(table)
+                live = self._cat.get_live(table)
+                self._cat.tables[table] = [
+                    row for row in live if row.get(pk) not in idents
+                ]
+                self._cat.bump(table)
+
+            puts_by_table: Dict[str, List[Dict[str, Any]]] = {}
+            for (model, _), row in self._puts.items():
+                puts_by_table.setdefault(self._table(model), []).append(dict(row))
+            for table, rows in puts_by_table.items():
+                pk = self._pk_of(table)
+                live = self._cat.get_live(table)
+                live_by_pk = {row.get(pk): dict(row) for row in live}
+                for row in rows:
+                    if pk not in row:
+                        raise RuntimeError(f"missing pk '{pk}' for table '{table}'")
+                    live_by_pk[row[pk]] = row
+                self._cat.tables[table] = list(live_by_pk.values())
+                self._cat.bump(table)
+
+            self._persist_workbook()
+
+        self._puts.clear()
+        self._dels.clear()
+        self._tracked.clear()
+
+    async def _tx_rollback_impl(self) -> None:
+        self._snap.clear()
+        self._snap_ver.clear()
+        self._puts.clear()
+        self._dels.clear()
+        self._tracked.clear()
+
+    @staticmethod
+    def _pk_default(model: type, pk: str) -> Any:
+        table = getattr(model, "__table__", None)
+        if table is None:
+            return None
+        try:
+            column = table.columns.get(pk)
+        except Exception:
+            return None
+        if column is None:
+            return None
+        default = getattr(column, "default", None)
+        if default is None:
+            return None
+        arg = getattr(default, "arg", None)
+        if callable(arg):
+            try:
+                return arg()
+            except TypeError:
+                return arg(None)
+        return arg
+
+    def _add_impl(self, obj: Any) -> Any:
+        model = obj.__class__
+        pk = _single_pk_name(model)
+        ident = getattr(obj, pk)
+        if ident is None:
+            ident = self._pk_default(model, pk)
+            if ident is not None:
+                setattr(obj, pk, ident)
+        if ident is None:
+            raise ValueError(f"primary key {pk!r} must be set")
+        row = {column: getattr(obj, column, None) for column in _model_columns(model)}
+        self._puts[(model, ident)] = row
+        self._dels.discard((model, ident))
+        self._tracked[(model, ident)] = obj
+        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)
+
+    async def _flush_impl(self) -> None:
+        for (model, ident), obj in list(self._tracked.items()):
+            if (model, ident) in self._dels:
+                continue
+            row = {
+                column: getattr(obj, column, None) for column in _model_columns(model)
+            }
+            self._puts[(model, ident)] = row
+        return
+
+    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:
+            return
+        for column in _model_columns(obj.__class__):
+            setattr(obj, column, getattr(fresh, column, None))
+
+    async def _get_impl(self, model: type, ident: Any) -> Any | None:
+        tracked = self._tracked.get((model, ident))
+        if tracked is not None:
+            return tracked
+        row = self._puts.get((model, ident))
+        if row is not None:
+            return self._inflate_tracked(model, ident, row)
+        if (model, ident) in self._dels:
+            return None
+        table_rows = self._rows_for(model)
+        pk = _single_pk_name(model)
+        for table_row in table_rows:
+            if table_row.get(pk) == ident:
+                return self._inflate_tracked(model, ident, table_row)
+        return None
+
+    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 = [obj for obj in items if self._matches_obj(obj, where)]
+            return _ExecuteResult(self._order_slice(items, order, limit, offset))
+        if "delete" in kind:
+            model, where = self._decompose_delete(stmt)
+            items = self._scan_model(model)
+            items = [obj for obj in items if self._matches_obj(obj, 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))
+                self._tracked.pop((model, ident), None)
+            result = _ExecuteResult([])
+            result.rowcount = len(items)
+            return result
+        raise NotImplementedError(f"Unsupported statement: {type(stmt)}")
+
+    async def _close_impl(self) -> None:
+        return
+
+    def _table(self, model: type) -> str:
+        return getattr(model, "__tablename__", None) or model.__name__
+
+    def _pk_of(self, table: str) -> str:
+        if table in self._cat.pks:
+            return self._cat.pks[table]
+        raise RuntimeError(f"primary key for table '{table}' is unknown")
+
+    def _rows_for(self, model: type) -> list[dict[str, Any]]:
+        table = self._table(model)
+        iso = (self._spec.isolation if self._spec else None) or "read_committed"
+        if (
+            iso in ("repeatable_read", "snapshot", "serializable")
+            and table not in self._snap
+        ):
+            live = self._cat.get_live(table)
+            self._snap[table] = [dict(row) for row in live]
+            self._snap_ver[table] = self._cat.table_ver.get(table, 0)
+        return self._snap.get(table, self._cat.get_live(table))
+
+    def _inflate(self, model: type, data: Mapping[str, Any]) -> Any:
+        obj = model()
+        for column in _model_columns(model):
+            if column in data:
+                setattr(obj, column, data[column])
+        return obj
+
+    def _inflate_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
+
+    def _scan_model(self, model: type) -> List[Any]:
+        pk = _single_pk_name(model)
+        by_id: Dict[Any, Any] = {}
+        for row in self._rows_for(model):
+            ident = row.get(pk)
+            if ident is None:
+                continue
+            tracked = self._tracked.get((model, ident))
+            if tracked is not None:
+                by_id[ident] = tracked
+            else:
+                by_id[ident] = self._inflate_tracked(model, ident, row)
+        for (known_model, ident), row in self._puts.items():
+            if known_model is model:
+                by_id[ident] = self._inflate_tracked(model, ident, row)
+        for known_model, ident in self._dels:
+            if known_model is model:
+                by_id.pop(ident, None)
+        return list(by_id.values())
+
+    def _persist_workbook(self) -> None:
+        workbook = self._cat.workbook
+        for table, rows in self._cat.tables.items():
+            if table in workbook.sheetnames:
+                sheet = workbook[table]
+                sheet.delete_rows(1, sheet.max_row)
+            else:
+                sheet = workbook.create_sheet(table)
+            columns: list[str] = []
+            for row in rows:
+                for key in row:
+                    if key not in columns:
+                        columns.append(key)
+            if not columns:
+                columns = [self._pk_of(table)]
+            sheet.append(columns)
+            for row in rows:
+                sheet.append([self._excel_value(row.get(col)) for col in columns])
+        self._atomic_save_workbook(workbook, self._cat.path)
+
+    @staticmethod
+    def _excel_value(value: Any) -> Any:
+        if isinstance(value, uuid.UUID):
+            return str(value)
+        return value
+
+    def _atomic_save_workbook(self, workbook: Any, path: str) -> None:
+        directory = os.path.dirname(path) or "."
+        fd, tmp = tempfile.mkstemp(dir=directory, prefix=".tmp_", suffix=".xlsx")
+        os.close(fd)
+        try:
+            workbook.save(tmp)
+            os.replace(tmp, path)
+        finally:
+            if os.path.exists(tmp):
+                os.remove(tmp)
+
+    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]:
+            def _safe_subclasses(cls: type) -> list[type]:
+                try:
+                    return list(cls.__subclasses__())
+                except TypeError:
+                    return []
+
+            out: list[type] = []
+            stack = _safe_subclasses(base)
+            while stack:
+                cls = stack.pop()
+                out.append(cls)
+                stack.extend(_safe_subclasses(cls))
+            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
+
+        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
+
+        rc = getattr(stmt, "_raw_columns", None) or getattr(stmt, "columns", None)
+        if rc is not None:
+            if isinstance(rc, (list, tuple)) and not rc:
+                raise RuntimeError("Cannot resolve model from statement")
+            entity = rc[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 []
+        parts = (
+            getattr(where, "clauses", None)
+            or getattr(where, "get_children", lambda: [])()
+        )
+        nodes = list(parts) if parts else [where]
+        out: list[Tuple[str, str, Any]] = []
+        for node in nodes:
+            left = getattr(node, "left", None)
+            right = getattr(node, "right", None)
+            op = getattr(node, "operator", None)
+            if left is None or right is None:
+                continue
+            name = getattr(left, "key", None) or getattr(left, "name", None)
+            if name is None:
+                continue
+            opname = getattr(op, "__name__", str(op))
+            if "eq" in opname:
+                value = (
+                    getattr(right, "value", None)
+                    if hasattr(right, "value")
+                    else getattr(right, "literal", None)
+                )
+                out.append((str(name), "eq", value))
+                continue
+            right_clauses = getattr(right, "clauses", None)
+            if right_clauses is not None and "in" in opname:
+                vals = [
+                    getattr(lit, "value", None)
+                    if hasattr(lit, "value")
+                    else getattr(lit, "literal", None)
+                    for lit in right_clauses
+                ]
+                out.append((str(name), "in", vals))
+        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 ob in clauses:
+            col = (
+                getattr(ob, "element", None)
+                or getattr(ob, "this", None)
+                or getattr(ob, "expr", None)
+            )
+            name = getattr(col, "key", None) or getattr(col, "name", None)
+            direction = "desc" if "desc" in type(ob).__name__.lower() else "asc"
+            if name:
+                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:
+                lit = getattr(value, "value", None)
+                if lit is not None:
+                    try:
+                        return int(lit)
+                    except Exception:
+                        pass
+        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
+            if op == "in" and datum not in set(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_xlsx-0.1.1.dist-info/METADATA

@@ -0,0 +1,277 @@
+Metadata-Version: 2.4
+Name: tigrbl_engine_xlsx
+Version: 0.1.1
+Summary: XLSX engine plugin for tigrbl where each workbook is a database and each sheet is a table.
+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: dataframe,engine,excel,experimental,tigrbl,xlsx
+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: openpyxl>=3.1
+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_xlsx/">
+        <img src="https://img.shields.io/pypi/v/tigrbl_engine_xlsx?label=tigrbl_engine_xlsx&color=green" alt="PyPI - tigrbl_engine_xlsx"/>
+    </a>
+    <a href="https://pypi.org/project/tigrbl_engine_xlsx/">
+        <img src="https://img.shields.io/pypi/dm/tigrbl_engine_xlsx" alt="PyPI - Downloads"/>
+    </a>
+    <a href="https://pypi.org/project/tigrbl_engine_xlsx/">
+        <img src="https://img.shields.io/pypi/pyversions/tigrbl_engine_xlsx" alt="PyPI - Python Version"/>
+    </a>
+    <a href="https://pypi.org/project/tigrbl_engine_xlsx/">
+        <img src="https://img.shields.io/pypi/l/tigrbl_engine_xlsx" alt="PyPI - License"/>
+    </a>
+    <a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/experimental/tigrbl_engine_xlsx/">
+        <img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/experimental/tigrbl_engine_xlsx.svg"/>
+    </a>
+</p>
+
+# tigrbl_engine_xlsx
+
+A tigrbl engine plugin where each workbook is a database-like object and each sheet is a table.
+
+## Features
+
+- Registers `kind="xlsx"` through the `tigrbl.engine` entry-point group.
+- Uses `load_workbook`, `wb[...]`, and `wb.save(...)` directly for workbook operations.
+- Treats each sheet as a table with transactional table semantics.
+
+## Installation
+
+### uv
+
+```bash
+uv add tigrbl_engine_xlsx
+```
+
+### pip
+
+```bash
+pip install tigrbl_engine_xlsx
+```
+
+## Usage
+
+```python
+from tigrbl.engine import EngineSpec
+
+spec = EngineSpec(kind="xlsx", mapping={"path": "./workbook.xlsx", "pk": "id"})
+provider = spec.provider()
+engine, session_factory = provider.build()
+
+session = session_factory()
+wb = session.workbook()
+print(wb["Sheet1"])
+print(session.table("Sheet1"))
+```

tigrbl_engine_xlsx-0.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+tigrbl_engine_xlsx/__init__.py,sha256=9yk65aLyE0KYRSJAuz_3Eqj93ayFJJifZDtiWoB5XD0,664
+tigrbl_engine_xlsx/engine.py,sha256=sHNfwMI_yXmBWIzMZ88AX-N8YLhPzjtbdyFWIrRTqNk,3138
+tigrbl_engine_xlsx/session.py,sha256=FHceAu8RHlqxjBvvwEj0tZEzov6L3k6n0JEHX45Gl9E,21016
+tigrbl_engine_xlsx-0.1.1.dist-info/METADATA,sha256=O0r7rGICGb44JV8WjkHrocdPPvuAw1bq_vEwX2XsabY,15141
+tigrbl_engine_xlsx-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+tigrbl_engine_xlsx-0.1.1.dist-info/entry_points.txt,sha256=rR7gnMBbkzbRbpClCTOcBzfPCRnxy2-CduR8LQZxaaE,51
+tigrbl_engine_xlsx-0.1.1.dist-info/licenses/LICENSE,sha256=708mvS2G_dkXGD6DVfUDngIUW4HW-T14Ws-q7shsacA,10880
+tigrbl_engine_xlsx-0.1.1.dist-info/RECORD,,

tigrbl_engine_xlsx-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_xlsx-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[tigrbl.engine]
+xlsx = tigrbl_engine_xlsx:register

tigrbl_engine_xlsx-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.