simple-module-core 0.0.39__tar.gz → 0.0.40__tar.gz

{simple_module_core-0.0.39 → simple_module_core-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_core
-Version: 0.0.39
+Version: 0.0.40
 Summary: Module-system primitives for the simple_module framework — ModuleBase, discovery, diagnostics, events
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -22,7 +22,7 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: babel<3,>=2.14
-Requires-Dist: fastapi<0.157,>=0.140
+Requires-Dist: fastapi<0.159,>=0.140
 Requires-Dist: packaging<27,>=23.0
 Requires-Dist: pydantic-settings<3,>=2.0
 Requires-Dist: pydantic<3,>=2.0

{simple_module_core-0.0.39 → simple_module_core-0.0.40}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_core"
-version = "0.0.39"
+version = "0.0.40"
 description = "Module-system primitives for the simple_module framework — ModuleBase, discovery, diagnostics, events"
 readme = "README.md"
 license = "MIT"
@@ -22,7 +22,7 @@ classifiers = [
 ]
 dependencies = [
     "babel>=2.14,<3",
-    "fastapi>=0.140,<0.157",
+    "fastapi>=0.140,<0.159",
     "packaging>=23.0,<27",
     "pydantic>=2.0,<3",
     "pydantic-settings>=2.0,<3",

simple_module_core-0.0.40/simple_module_core/datetimes.py

@@ -0,0 +1,12 @@
+"""UTC timestamps and normalization of legacy naive database values."""
+
+from datetime import UTC, datetime
+
+
+def utcnow() -> datetime:
+    return datetime.now(UTC)
+
+
+def aware(value: datetime) -> datetime:
+    """Interpret a naive value as UTC; preserve an existing timezone."""
+    return value if value.tzinfo is not None else value.replace(tzinfo=UTC)

{simple_module_core-0.0.39 → simple_module_core-0.0.40}/simple_module_core/feature_flags.py

@@ -71,6 +71,13 @@ class FeatureFlagRegistry:
         else:
             self._tenant_overrides.pop((name, tenant_id), None)
 
+    def replace_overrides(
+        self, system: dict[str, bool], tenants: dict[tuple[str, str], bool]
+    ) -> None:
+        """Replace a complete DB snapshot, removing overrides absent from it."""
+        self._system_overrides = dict(system)
+        self._tenant_overrides = dict(tenants)
+
     def tenant_override(self, name: str, tenant_id: str) -> bool | None:
         """Return the per-tenant override for ``(name, tenant_id)`` if set, else None."""
         return self._tenant_overrides.get((name, tenant_id))

{simple_module_core-0.0.39 → simple_module_core-0.0.40}/simple_module_core/invalidation.py

@@ -9,11 +9,9 @@ share one failure shape: the worker that performed the write drops its own entry
 immediately, and **every other worker keeps serving the stale value until its own
 entry expires**.
 
-``settings`` has the same shape without the TTL — ``apply_changes_and_reload``
-hot-swaps the settings object in the worker that handled the save and announces it
-on the in-process :class:`~simple_module_core.events.EventBus`, so the others serve
-the old configuration until restart. It needs a re-read rather than an eviction, so
-it is a consumer this bus makes *possible* rather than one it already serves.
+``settings``, role overlays and feature-flag overrides had it too (#621); they now
+re-read the committed DB state on invalidation (and every 30 s as a fallback, see
+:mod:`simple_module_core.invalidation_refresh`) rather than evicting an entry.
 
 The obvious fix — publish the write on Redis pub/sub so every worker drops its
 entry at once — was not reachable from any of those modules. Redis belongs to

simple_module_core-0.0.40/simple_module_core/invalidation_refresh.py

@@ -0,0 +1,51 @@
+"""Reload DB-backed process state on invalidation and periodically after missed messages."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Awaitable, Callable
+from contextlib import suppress
+
+from simple_module_core.invalidation import Invalidation, InvalidationBus
+
+logger = logging.getLogger(__name__)
+REFRESH_SECONDS = 30
+
+
+class InvalidationRefresh:
+    """Serialize reloads and own the bounded-staleness fallback's lifecycle."""
+
+    def __init__(
+        self, bus: InvalidationBus, channel: str, reload: Callable[[str | None], Awaitable[None]]
+    ) -> None:
+        self._reload = reload
+        self._lock = asyncio.Lock()
+        self._task: asyncio.Task | None = None
+        bus.subscribe(channel, self._receive)
+
+    async def _receive(self, message: Invalidation) -> None:
+        await self.refresh(message.key)
+
+    async def refresh(self, key: str | None = None) -> None:
+        async with self._lock:
+            await self._reload(key)
+
+    def start(self) -> None:
+        if self._task is None:
+            self._task = asyncio.create_task(self._periodic())
+
+    async def stop(self) -> None:
+        if self._task is not None:
+            self._task.cancel()
+            with suppress(asyncio.CancelledError):
+                await self._task
+            self._task = None
+
+    async def _periodic(self) -> None:
+        while True:
+            await asyncio.sleep(REFRESH_SECONDS)
+            try:
+                await self.refresh()
+            except Exception:
+                logger.exception("Periodic state reload failed; retrying on the next interval")

{simple_module_core-0.0.39 → simple_module_core-0.0.40}/simple_module_core/permissions.py

@@ -208,6 +208,14 @@ class PermissionRegistry:
         self._role_overlay[role] = set(permissions)
         self._invalidate()
 
+    def replace_role_overlays(self, overlays: dict[str, list[str]]) -> None:
+        """Replace the complete persisted snapshot, including removed grants."""
+        snapshot = {role: set(keys) for role, keys in overlays.items()}
+        if snapshot == self._role_overlay:  # periodic reloads: keep derived caches warm
+            return
+        self._role_overlay = snapshot
+        self._invalidate()
+
     @property
     def role_map(self) -> dict[str, list[str]]:
         """Merged role→permission mapping (``DEFAULT_ROLE_PERMISSIONS`` + module maps)."""

{simple_module_core-0.0.39 → simple_module_core-0.0.40}/simple_module_core/user_directory.py

@@ -45,6 +45,9 @@ class DirectoryUser:
     #: Role names, or ``None`` when the provider does not know them (Keycloak
     #: keeps roles in the IdP). Only filled when ``with_roles=True`` was asked.
     roles: tuple[str, ...] | None = None
+    #: Whether the account's email is proven, or ``None`` when the provider
+    #: does not track it (Keycloak: read the token's ``email_verified``).
+    email_verified: bool | None = None
 
     @property
     def label(self) -> str:

simple_module_core-0.0.40/simple_module_core/user_events.py

@@ -0,0 +1,16 @@
+"""User lifecycle contracts shared without a dependency on the users module."""
+
+import uuid
+from dataclasses import dataclass
+
+from simple_module_core.events import Event
+
+
+@dataclass
+class UserDeleted(Event):
+    """The account is gone; owners of per-user rows must durably remove them.
+
+    Delivery is at least once, so handlers must be idempotent.
+    """
+
+    user_id: uuid.UUID

simple_module_core-0.0.40/tests/test_core_datetimes.py

@@ -0,0 +1,19 @@
+"""Shared UTC helpers preserve aware values and interpret naive values as UTC."""
+
+from datetime import UTC, datetime, timedelta, timezone
+
+from simple_module_core.datetimes import aware, utcnow
+
+
+def test_naive_is_utc_and_aware_keeps_its_offset():
+    naive = datetime(2026, 1, 1)
+    assert aware(naive) == datetime(2026, 1, 1, tzinfo=UTC)
+    offset = naive.replace(tzinfo=timezone(timedelta(hours=2)))
+    assert aware(offset) is offset
+
+
+def test_utcnow_is_current_aware_utc():
+    before = datetime.now(UTC)
+    value = utcnow()
+    assert before <= value <= datetime.now(UTC)
+    assert value.tzinfo is UTC

simple_module_core-0.0.40/tests/test_core_invalidation_refresh.py

@@ -0,0 +1,54 @@
+"""Missed messages and transient reload failures must not leave state stale forever."""
+
+import asyncio
+
+from simple_module_core.invalidation import InvalidationBus
+from simple_module_core.invalidation_refresh import InvalidationRefresh
+
+
+async def test_periodic_refresh_retries_without_a_message_and_stops(monkeypatch):
+    monkeypatch.setattr("simple_module_core.invalidation_refresh.REFRESH_SECONDS", 0.001)
+    attempts = []
+    refreshed = asyncio.Event()
+
+    async def reload(key):
+        attempts.append(key)
+        if len(attempts) == 1:
+            raise RuntimeError("transient DB failure")
+        refreshed.set()
+
+    refresh = InvalidationRefresh(InvalidationBus(), "test.snapshot", reload)
+    refresh.start()
+    try:
+        await asyncio.wait_for(refreshed.wait(), timeout=1)
+    finally:
+        await refresh.stop()
+    assert attempts[:2] == [None, None]
+    count = len(attempts)
+    await asyncio.sleep(0.01)  # intentional-sleep: proves no reload runs after stop()
+    assert len(attempts) == count
+
+
+async def test_reload_messages_are_serialized():
+    bus = InvalidationBus()
+    entered = asyncio.Event()
+    release = asyncio.Event()
+    keys = []
+
+    async def reload(key):
+        keys.append(key)
+        if key == "first":
+            entered.set()
+            await release.wait()
+
+    InvalidationRefresh(bus, "test.snapshot", reload)
+    first = asyncio.create_task(bus.publish("test.snapshot", key="first"))
+    await asyncio.wait_for(entered.wait(), timeout=1)
+    second = asyncio.create_task(bus.publish("test.snapshot", key="second"))
+    try:
+        await asyncio.sleep(0)
+        assert keys == ["first"]
+    finally:
+        release.set()
+        await asyncio.wait_for(asyncio.gather(first, second), timeout=1)
+    assert keys == ["first", "second"]

{simple_module_core-0.0.39 → simple_module_core-0.0.40}/tests/test_feature_flags.py

@@ -194,3 +194,16 @@ class TestConsumerHelpers:
 
         request.state.tenant_id = "other"
         assert is_flag_enabled(request, "beta_ui") is False
+
+
+async def test_reloading_overrides_removes_deleted_values_in_both_scopes():
+    registry = FeatureFlagRegistry()
+    registry.add(FeatureFlagDefinition("switch", default_enabled=True))
+    registry.set_override("switch", False)
+    registry.set_override("switch", False, tenant_id="acme")
+    registry.replace_overrides({}, {("switch", "globex"): False})
+    assert registry.is_enabled("switch") is True
+    assert registry.is_enabled("switch", "acme") is True
+    assert registry.is_enabled("switch", "globex") is False
+    registry.replace_overrides({}, {})
+    assert registry.is_enabled("switch", "globex") is True

{simple_module_core-0.0.39 → simple_module_core-0.0.40}/tests/test_permissions.py

@@ -141,3 +141,13 @@ class TestGrants:
         """Callers hand it whatever they have — the middleware caches a set,
         a test hands a list."""
         assert grants(["users.manage"], "users.manage") is True
+
+
+async def test_reloading_role_overlays_removes_deleted_grants_but_keeps_code_grants():
+    registry = PermissionRegistry()
+    registry.map_role("editor", ["code.view"])
+    registry.set_role_overlay("editor", ["db.view"])
+    registry.replace_role_overlays({"reviewer": ["db.review"]})
+    assert registry.role_map["editor"] == ["code.view"]
+    assert registry.role_map["reviewer"] == ["db.review"]
+    assert registry.role_map["admin"] == ["*"]