tigrbl-atoms 0.1.0.dev5__tar.gz

tigrbl_atoms-0.1.0.dev5/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: tigrbl-atoms
+Version: 0.1.0.dev5
+Summary: Runtime atom utilities and execution helpers for Tigrbl.
+License-Expression: Apache-2.0
+Keywords: tigrbl,sdk,standards,framework
+Author: Jacob Stewart
+Author-email: jacob@swarmauri.com
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Development Status :: 1 - Planning
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Dist: jinja2 (>=3.1)
+Requires-Dist: sqlalchemy (>=2.0)
+Requires-Dist: tigrbl-core
+Requires-Dist: tigrbl-ops-oltp
+Requires-Dist: tigrbl-typing
+Requires-Dist: typing-extensions (>=4.0)
+Description-Content-Type: text/markdown
+
+![Tigrbl branding](https://github.com/swarmauri/swarmauri-sdk/blob/a170683ecda8ca1c4f912c966d4499649ffb8224/assets/tigrbl.brand.theme.svg)
+
+# tigrbl-atoms
+
+![PyPI - Downloads](https://img.shields.io/pypi/dm/tigrbl-atoms.svg) ![Hits](https://hits.sh/github.com/swarmauri/swarmauri-sdk.svg) ![Python Versions](https://img.shields.io/pypi/pyversions/tigrbl-atoms.svg) ![License](https://img.shields.io/pypi/l/tigrbl-atoms.svg) ![Version](https://img.shields.io/pypi/v/tigrbl-atoms.svg)
+
+## Features
+
+- Modular package in the Tigrbl namespace.
+- Supports Python 3.10 through 3.12.
+- Distributed as part of the swarmauri-sdk workspace.
+
+## Installation
+
+### uv
+
+```bash
+uv add tigrbl-atoms
+```
+
+### pip
+
+```bash
+pip install tigrbl-atoms
+```
+
+## Usage
+
+Import from the shared package-specific module namespaces after installation in your environment.
+

tigrbl_atoms-0.1.0.dev5/README.md

@@ -0,0 +1,29 @@
+![Tigrbl branding](https://github.com/swarmauri/swarmauri-sdk/blob/a170683ecda8ca1c4f912c966d4499649ffb8224/assets/tigrbl.brand.theme.svg)
+
+# tigrbl-atoms
+
+![PyPI - Downloads](https://img.shields.io/pypi/dm/tigrbl-atoms.svg) ![Hits](https://hits.sh/github.com/swarmauri/swarmauri-sdk.svg) ![Python Versions](https://img.shields.io/pypi/pyversions/tigrbl-atoms.svg) ![License](https://img.shields.io/pypi/l/tigrbl-atoms.svg) ![Version](https://img.shields.io/pypi/v/tigrbl-atoms.svg)
+
+## Features
+
+- Modular package in the Tigrbl namespace.
+- Supports Python 3.10 through 3.12.
+- Distributed as part of the swarmauri-sdk workspace.
+
+## Installation
+
+### uv
+
+```bash
+uv add tigrbl-atoms
+```
+
+### pip
+
+```bash
+pip install tigrbl-atoms
+```
+
+## Usage
+
+Import from the shared package-specific module namespaces after installation in your environment.

tigrbl_atoms-0.1.0.dev5/pyproject.toml

@@ -0,0 +1,51 @@
+[project]
+name = "tigrbl-atoms"
+version = "0.1.0.dev5"
+description = "Runtime atom utilities and execution helpers for Tigrbl."
+license = "Apache-2.0"
+readme = "README.md"
+repository = "http://github.com/swarmauri/swarmauri-sdk"
+requires-python = ">=3.10,<3.13"
+classifiers = [
+    "License :: OSI Approved :: Apache Software License",
+    "Development Status :: 1 - Planning",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+]
+authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
+dependencies = [
+    "tigrbl-ops-oltp",
+    "tigrbl-core",
+    "tigrbl-typing",
+    "jinja2>=3.1",
+    "sqlalchemy>=2.0",
+    "typing-extensions>=4.0",
+]
+keywords = ["tigrbl", "sdk", "standards", "framework"]
+
+[tool.uv.sources]
+"tigrbl-ops-oltp" = { workspace = true }
+"tigrbl-core" = { workspace = true }
+"tigrbl-typing" = { workspace = true }
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.poetry]
+packages = [
+    { include = "tigrbl_atoms" },
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24.0",
+    "pytest-timeout>=2.3.1",
+    "ruff>=0.9",
+]

tigrbl_atoms-0.1.0.dev5/tigrbl_atoms/__init__.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from .types import (
+    EGRESS_PHASES,
+    HANDLER_PHASES,
+    INGRESS_PHASES,
+    PHASE_SEQUENCE,
+    HookPhase,
+    HookPhases,
+    HookPredicate,
+    StepFn,
+    VALID_HOOK_PHASES,
+)
+
+__all__ = [
+    "PHASE_SEQUENCE",
+    "INGRESS_PHASES",
+    "HANDLER_PHASES",
+    "EGRESS_PHASES",
+    "HookPhase",
+    "HookPhases",
+    "VALID_HOOK_PHASES",
+    "StepFn",
+    "HookPredicate",
+]

tigrbl_atoms-0.1.0.dev5/tigrbl_atoms/_ctx.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+
+def _ctx_view(ctx: Any) -> Dict[str, Any]:
+    """Small read-only view for user callables."""
+    safe_view = getattr(ctx, "safe_view", None)
+    if callable(safe_view):
+        view = safe_view(include_temp=True)
+        return dict(view)
+
+    return {
+        "op": getattr(ctx, "op", None),
+        "persist": getattr(ctx, "persist", True),
+        "temp": getattr(ctx, "temp", None),
+        "tenant": getattr(ctx, "tenant", None),
+        "user": getattr(ctx, "user", None),
+        "now": getattr(ctx, "now", None),
+    }
+
+
+__all__ = ["_ctx_view"]

tigrbl_atoms-0.1.0.dev5/tigrbl_atoms/_opview_helpers.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+
+def _ensure_temp(ctx: Any) -> dict[str, Any]:
+    tmp = getattr(ctx, "temp", None)
+    if not isinstance(tmp, dict):
+        tmp = {}
+        setattr(ctx, "temp", tmp)
+    return tmp
+
+
+def _ensure_ov(ctx: Any):
+    ov = getattr(ctx, "opview", None)
+    if ov is None:
+        raise RuntimeError("ctx_missing:opview")
+    return ov
+
+
+def _normalize_schema_from_specs(ctx: Any) -> None:
+    specs = getattr(ctx, "specs", None)
+    op = getattr(ctx, "op", None)
+    if not isinstance(specs, Mapping) or not isinstance(op, str) or not op:
+        raise RuntimeError("ctx_missing:opview")
+
+    in_fields: list[str] = []
+    out_fields: list[str] = []
+    by_field_in: dict[str, dict[str, Any]] = {}
+    by_field_out: dict[str, dict[str, Any]] = {}
+
+    for field_name, spec in specs.items():
+        if not isinstance(field_name, str):
+            continue
+        io = getattr(spec, "io", None)
+        fs = getattr(spec, "field", None)
+        storage = getattr(spec, "storage", None)
+
+        in_verbs = set(getattr(io, "in_verbs", ()) or ())
+        out_verbs = set(getattr(io, "out_verbs", ()) or ())
+
+        if op in in_verbs:
+            in_fields.append(field_name)
+            in_meta: dict[str, Any] = {"in_enabled": True}
+            if storage is None:
+                in_meta["virtual"] = True
+
+            default_factory = getattr(spec, "default_factory", None)
+            if callable(default_factory):
+                in_meta["default_factory"] = default_factory
+
+            alias_in = getattr(io, "alias_in", None)
+            if alias_in:
+                in_meta["alias_in"] = alias_in
+
+            header_in = getattr(io, "header_in", None)
+            if header_in:
+                in_meta["header_in"] = header_in
+                in_meta["header_required_in"] = bool(
+                    getattr(io, "header_required_in", False)
+                )
+
+            in_meta["required"] = bool(fs and op in getattr(fs, "required_in", ()))
+            in_meta["nullable"] = (
+                True if storage is None else bool(getattr(storage, "nullable", True))
+            )
+            by_field_in[field_name] = in_meta
+
+        if op in out_verbs:
+            out_fields.append(field_name)
+            out_meta: dict[str, Any] = {}
+
+            alias_out = getattr(io, "alias_out", None)
+            if alias_out:
+                out_meta["alias_out"] = alias_out
+            if storage is None:
+                out_meta["virtual"] = True
+
+            py_type = getattr(getattr(fs, "py_type", None), "__name__", None)
+            if py_type:
+                out_meta["py_type"] = py_type
+            by_field_out[field_name] = out_meta
+
+    in_fields_sorted = tuple(sorted(in_fields))
+    out_fields_sorted = tuple(sorted(out_fields))
+
+    setattr(
+        ctx,
+        "schema_in",
+        {
+            "fields": in_fields_sorted,
+            "by_field": {f: by_field_in.get(f, {}) for f in in_fields_sorted},
+            "required": tuple(
+                f for f in in_fields_sorted if by_field_in.get(f, {}).get("required")
+            ),
+        },
+    )
+    setattr(
+        ctx,
+        "schema_out",
+        {
+            "fields": out_fields_sorted,
+            "by_field": {f: by_field_out.get(f, {}) for f in out_fields_sorted},
+            "expose": out_fields_sorted,
+        },
+    )
+
+
+def _ensure_schema_in(ctx: Any) -> Mapping[str, Any]:
+    temp = _ensure_temp(ctx)
+    cached = temp.get("schema_in")
+    if isinstance(cached, Mapping):
+        return cached
+
+    schema_in = getattr(ctx, "schema_in", None)
+    if isinstance(schema_in, Mapping):
+        temp["schema_in"] = schema_in
+        return schema_in
+
+    try:
+        ov = _ensure_ov(ctx)
+        bf = ov.schema_in.by_field
+        req = tuple(n for n, e in bf.items() if e.get("required"))
+        temp["schema_in"] = {
+            "fields": ov.schema_in.fields,
+            "by_field": bf,
+            "required": req,
+        }
+    except RuntimeError as exc:
+        if str(exc) != "ctx_missing:opview":
+            raise
+        _normalize_schema_from_specs(ctx)
+        temp["schema_in"] = getattr(ctx, "schema_in")
+    return temp["schema_in"]
+
+
+def _ensure_schema_out(ctx: Any) -> Mapping[str, Any]:
+    temp = _ensure_temp(ctx)
+    cached = temp.get("schema_out")
+    if isinstance(cached, Mapping):
+        return cached
+
+    schema_out = getattr(ctx, "schema_out", None)
+    if isinstance(schema_out, Mapping):
+        temp["schema_out"] = schema_out
+        return schema_out
+
+    try:
+        ov = _ensure_ov(ctx)
+        temp["schema_out"] = {
+            "fields": ov.schema_out.fields,
+            "by_field": ov.schema_out.by_field,
+            "expose": ov.schema_out.expose,
+        }
+    except RuntimeError as exc:
+        if str(exc) != "ctx_missing:opview":
+            raise
+        _normalize_schema_from_specs(ctx)
+        temp["schema_out"] = getattr(ctx, "schema_out")
+    return temp["schema_out"]

tigrbl_atoms-0.1.0.dev5/tigrbl_atoms/_request.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import json as json_module
+from dataclasses import dataclass, field
+from http.cookies import SimpleCookie
+from types import SimpleNamespace
+from typing import Any
+from collections.abc import Iterable, Mapping
+from urllib.parse import parse_qs
+
+from tigrbl_core._spec.request_spec import RequestSpec
+
+
+from tigrbl_typing.request import AwaitableValue, URL
+
+
+@dataclass(init=False)
+class Request(RequestSpec):
+    method: str
+    path: str
+    headers: Mapping[str, str] | Iterable[tuple[str, str]]
+    query: dict[str, list[str]]
+    path_params: dict[str, str]
+    body: bytes
+    script_name: str = ""
+    app: Any | None = None
+    state: SimpleNamespace = field(default_factory=SimpleNamespace)
+    scope: dict[str, Any] = field(default_factory=dict)
+    _json_cache: Any = field(default=None, init=False, repr=False)
+    _json_loaded: bool = field(default=False, init=False, repr=False)
+
+    def __init__(
+        self,
+        method: str | dict[str, Any],
+        path: str | None = None,
+        headers: Mapping[str, str] | Iterable[tuple[str, str]] | None = None,
+        query: dict[str, list[str]] | None = None,
+        path_params: dict[str, str] | None = None,
+        body: bytes = b"",
+        script_name: str = "",
+        app: Any | None = None,
+        state: SimpleNamespace | None = None,
+        scope: dict[str, Any] | None = None,
+        receive: Any | None = None,
+    ) -> None:
+        del receive
+
+        self._json_cache = None
+        self._json_loaded = False
+
+        if isinstance(method, dict):
+            if scope is not None:
+                raise TypeError("scope cannot be provided when first argument is scope")
+            self._init_from_scope(method, app=app, state=state)
+            return
+
+        if path is None:
+            raise TypeError("path is required when constructing Request from fields")
+
+        self.method = method
+        self.path = path
+        self.headers = headers or {}
+        self.query = query or {}
+        self.path_params = path_params or {}
+        self.body = body
+        self.script_name = script_name
+        self.app = app
+        self.state = state or SimpleNamespace()
+        self.scope = scope or {}
+
+    def _init_from_scope(
+        self,
+        scope: dict[str, Any],
+        *,
+        app: Any | None,
+        state: SimpleNamespace | None,
+    ) -> None:
+        self.method = (scope.get("method") or "GET").upper()
+        self.path = scope.get("path") or "/"
+        self.headers = {
+            key.decode("latin-1").lower(): value.decode("latin-1")
+            for key, value in scope.get("headers", [])
+        }
+        self.query = parse_qs(
+            scope.get("query_string", b"").decode("latin-1"), keep_blank_values=True
+        )
+        self.path_params = scope.get("path_params") or {}
+        self.body = b""
+        self.script_name = scope.get("root_path") or ""
+        self.app = app
+        self.state = state or SimpleNamespace()
+        self.scope = scope
+
+    @classmethod
+    def from_scope(
+        cls,
+        scope: dict[str, Any],
+        receive: Any | None = None,
+        *,
+        app: Any | None = None,
+        state: SimpleNamespace | None = None,
+    ) -> "Request":
+        return cls(scope, app=app, state=state, receive=receive)
+
+    def json(self) -> AwaitableValue:
+        return AwaitableValue(self.json_sync())
+
+    def json_sync(self) -> Any:
+        if self._json_loaded:
+            return self._json_cache
+        if not self.body:
+            self._json_loaded = True
+            self._json_cache = None
+            return None
+        self._json_cache = json_module.loads(self.body.decode("utf-8"))
+        self._json_loaded = True
+        return self._json_cache
+
+    @property
+    def url(self) -> URL:
+        return URL(path=self.path, query=self.query, script_name=self.script_name)
+
+    @property
+    def query_params(self) -> dict[str, str]:
+        return {name: vals[0] for name, vals in self.query.items() if vals}
+
+    @property
+    def cookies(self) -> dict[str, str]:
+        raw = self.headers.get("cookie", "") or ""
+        parsed = SimpleCookie()
+        parsed.load(raw)
+        return {name: morsel.value for name, morsel in parsed.items()}
+
+    @property
+    def bearer_token(self) -> str | None:
+        authorization = self.headers.get("authorization", "") or ""
+        scheme, _, token = authorization.partition(" ")
+        cleaned = token.strip()
+        return cleaned if scheme.lower() == "bearer" and cleaned else None
+
+    @property
+    def admin_key(self) -> str | None:
+        key = (self.headers.get("x-admin-key") or "").strip()
+        return key or None
+
+    @property
+    def session_token(self) -> str | None:
+        return self.bearer_token or (self.cookies.get("sid") or "").strip() or None
+
+    @property
+    def client(self) -> SimpleNamespace:
+        host = ""
+        client = self.scope.get("client") if isinstance(self.scope, dict) else None
+        if isinstance(client, tuple) and client:
+            host = str(client[0])
+        return SimpleNamespace(ip=host, host=host)
+
+
+__all__ = ["Request", "URL", "AwaitableValue"]