izana-core 0.0.1__tar.gz → 0.2.0__tar.gz

{izana_core-0.0.1 → izana_core-0.2.0}/.gitignore

@@ -26,7 +26,7 @@ examples/django-react-site/harness/test-results/
 .vscode/
 
 # Build artifacts
-protocol/mizan-generate/bin/mizan-generate-*
+protocol/izana-generate/bin/izana-generate-*
 
 # Env
 .env

izana_core-0.2.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.5
+Name: izana-core
+Version: 0.2.0
+Summary: Izana Python core — @client registry, dispatch executor, KDL IR, HMAC cache keys, MWT identity. Framework-agnostic primitives shared by every Python backend adapter.
+License-Expression: Elastic-2.0
+Requires-Python: >=3.10
+Requires-Dist: jinja2>=3.1
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyjwt>=2.0
+Provides-Extra: dev
+Requires-Dist: ckdl>=1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'

izana_core-0.2.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "izana-core"
+version = "0.2.0"
+license = "Elastic-2.0"
+description = "Izana Python core — @client registry, dispatch executor, KDL IR, HMAC cache keys, MWT identity. Framework-agnostic primitives shared by every Python backend adapter."
+requires-python = ">=3.10"
+dependencies = [
+    "PyJWT>=2.0",
+    "jinja2>=3.1",
+    "pydantic>=2.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "ckdl>=1.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/izana_core"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+python_classes = ["*Tests", "*Test", "Test*"]
+python_functions = ["test_*"]

izana_core-0.2.0/src/izana_core/cache/backend.py

@@ -0,0 +1,110 @@
+
+from __future__ import annotations
+
+import abc
+
+
+class CacheBackend(abc.ABC):
+
+    @abc.abstractmethod
+    def get(self, key: str) -> bytes | None:
+        ...
+
+    @abc.abstractmethod
+    def set(self, key: str, value: bytes) -> None:
+        ...
+
+    @abc.abstractmethod
+    def delete(self, key: str) -> bool:
+        ...
+
+    @abc.abstractmethod
+    def delete_by_prefix(self, prefix: str) -> int:
+        ...
+
+    @abc.abstractmethod
+    def clear(self) -> None:
+        ...
+
+
+class MemoryCache(CacheBackend):
+
+    def __init__(self) -> None:
+        self._store: dict[str, bytes] = {}
+
+    def get(self, key: str) -> bytes | None:
+        return self._store.get(key)
+
+    def set(self, key: str, value: bytes) -> None:
+        self._store[key] = value
+
+    def delete(self, key: str) -> bool:
+        if key in self._store:
+            del self._store[key]
+            return True
+        return False
+
+    def delete_by_prefix(self, prefix: str) -> int:
+        to_delete = [k for k in self._store if k.startswith(prefix)]
+        for k in to_delete:
+            del self._store[k]
+        return len(to_delete)
+
+    def clear(self) -> None:
+        self._store.clear()
+
+
+class RedisCache(CacheBackend):
+
+    DEFAULT_TTL = 86400  # 24h safety-net
+
+    def __init__(
+        self,
+        redis_url: str,
+        prefix: str = "izana:",
+        ttl: int | None = None,
+    ) -> None:
+        try:
+            import redis as redis_lib
+        except ImportError as exc:
+            raise ImportError(
+                "Redis is required for Izana's cache backend. "
+                "Install it with: pip install izana[cache]"
+            ) from exc
+        self._client = redis_lib.from_url(
+            redis_url,
+            socket_connect_timeout=5,
+            socket_timeout=5,
+            health_check_interval=30,
+            retry_on_timeout=True,
+            max_connections=50,
+        )
+        self._prefix = prefix
+        self._ttl = ttl if ttl is not None else self.DEFAULT_TTL
+
+    def _key(self, key: str) -> str:
+        return f"{self._prefix}{key}"
+
+    def get(self, key: str) -> bytes | None:
+        return self._client.get(self._key(key))
+
+    def set(self, key: str, value: bytes) -> None:
+        self._client.set(self._key(key), value, ex=self._ttl)
+
+    def delete(self, key: str) -> bool:
+        return self._client.unlink(self._key(key)) > 0
+
+    def delete_by_prefix(self, prefix: str) -> int:
+        pattern = f"{self._prefix}{prefix}*"
+        count = 0
+        cursor = 0
+        while True:
+            cursor, keys = self._client.scan(cursor, match=pattern, count=1000)
+            if keys:
+                count += self._client.unlink(*keys)
+            if cursor == 0:
+                break
+        return count
+
+    def clear(self) -> None:
+        self.delete_by_prefix("")

izana_core-0.2.0/src/izana_core/cache/keys.py

@@ -0,0 +1,41 @@
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+from typing import Any
+
+CONTEXT_KEY_PREFIX = "ctx:"
+
+
+def derive_cache_key(
+    secret: str,
+    context: str,
+    params: dict[str, Any],
+    user_id: str | None = None,
+    rev: int = 0,
+) -> str:
+    def _normalize(v: Any) -> str:
+        if v is True:
+            return "true"
+        if v is False:
+            return "false"
+        if v is None:
+            return "null"
+        return str(v)
+
+    sorted_params = {k: _normalize(v) for k, v in sorted(params.items())}
+
+    key_data: dict[str, Any] = {"c": context, "p": sorted_params, "r": rev}
+    if user_id is not None:
+        key_data["u"] = str(user_id)
+
+    message = json.dumps(key_data, sort_keys=True, separators=(",", ":"))
+    hmac_hex = hmac.new(
+        secret.encode("utf-8"),
+        message.encode("utf-8"),
+        hashlib.sha256,
+    ).hexdigest()
+
+    return f"{CONTEXT_KEY_PREFIX}{context}:{hmac_hex}"