simple-module-core 0.0.41__tar.gz → 0.0.42__tar.gz

{simple_module_core-0.0.41 → simple_module_core-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_core
-Version: 0.0.41
+Version: 0.0.42
 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.159,>=0.140
+Requires-Dist: fastapi<0.160,>=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.41 → simple_module_core-0.0.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_core"
-version = "0.0.41"
+version = "0.0.42"
 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.159",
+    "fastapi>=0.140,<0.160",
     "packaging>=23.0,<27",
     "pydantic>=2.0,<3",
     "pydantic-settings>=2.0,<3",

{simple_module_core-0.0.41 → simple_module_core-0.0.42}/simple_module_core/__init__.py

@@ -4,6 +4,7 @@ from simple_module_core.audit_links import AuditLink, AuditLinkRegistry, LabelRe
 from simple_module_core.body_limits import BodyLimitRegistry
 from simple_module_core.cors import CorsPolicy, CorsPolicyRegistry
 from simple_module_core.csp import CspSourceError, CspSourceRegistry
+from simple_module_core.data_compatibility import DataCompatibilityIssue
 from simple_module_core.design_packs import DesignPack, DesignPackRegistry
 from simple_module_core.diagnostics import (
     DiagnosticLevel,
@@ -78,6 +79,7 @@ __all__ = [
     "CorsPolicyRegistry",
     "CspSourceError",
     "CspSourceRegistry",
+    "DataCompatibilityIssue",
     "DesignPack",
     "DesignPackRegistry",
     "DiagnosticLevel",

{simple_module_core-0.0.41 → simple_module_core-0.0.42}/simple_module_core/__main__.py

@@ -24,6 +24,7 @@ import os
 import sys
 from pathlib import Path
 
+from simple_module_core._data_doctor import data_compatibility_diagnostics
 from simple_module_core.diagnostics import (
     Diagnostic,
     DiagnosticLevel,
@@ -75,13 +76,18 @@ def _load_i18n_settings_from_env() -> tuple[list[str] | None, str]:
     return supported, default
 
 
+def _database_url() -> str:
+    """``SM_DATABASE_URL``, defaulting like ``Settings.database_url``."""
+    return os.environ.get("SM_DATABASE_URL", "sqlite+aiosqlite:///./app.db")
+
+
 def _database_dialect() -> str:
     """Dialect name of ``SM_DATABASE_URL`` (``.env`` merged by the i18n loader first).
 
     Defaults to ``sqlite`` like ``Settings.database_url``. Reads the env var
     directly for the same reason the i18n settings do: no hosting import.
     """
-    url = os.environ.get("SM_DATABASE_URL", "sqlite+aiosqlite:///./app.db")
+    url = _database_url()
     return url.split(":", 1)[0].split("+", 1)[0]
 
 
@@ -182,6 +188,7 @@ def main() -> int:
         database_dialect=_database_dialect(),
     )
     diagnostics.extend(override_findings)
+    diagnostics.extend(data_compatibility_diagnostics(modules, _database_url()))
     # A missing dependency only warns at a dev boot, but production refuses
     # to start with it (GH #501), so doctor reports it as what it will be.
     for finding in diagnostics:

simple_module_core-0.0.42/simple_module_core/_data_doctor.py

@@ -0,0 +1,22 @@
+"""Optional database diagnostics for Doctor without requiring a host app import."""
+
+import asyncio
+import importlib.util
+from collections.abc import Sequence
+
+from simple_module_core.data_compatibility import checking_modules
+from simple_module_core.diagnostics import Diagnostic
+from simple_module_core.module import ModuleBase
+
+
+def data_compatibility_diagnostics(
+    modules: Sequence[ModuleBase], database_url: str
+) -> list[Diagnostic]:
+    # Core-only installations have no database runtime to inspect.
+    if importlib.util.find_spec("simple_module_db") is None:
+        return []
+    if not checking_modules(modules):
+        return []
+    from simple_module_db.data_compatibility import database_compatibility_diagnostics
+
+    return asyncio.run(database_compatibility_diagnostics(modules, database_url))

simple_module_core-0.0.42/simple_module_core/data_compatibility.py

@@ -0,0 +1,43 @@
+"""Semantic, read-only checks for upgrades in host-owned migration histories."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal
+
+if TYPE_CHECKING:
+    from simple_module_core.module import ModuleBase
+
+
+@dataclass(frozen=True, kw_only=True)
+class DataCompatibilityIssue:
+    """An outstanding module upgrade, independent of Alembic revision ids."""
+
+    upgrade_id: str
+    message: str
+    severity: Literal["warning", "error"]
+
+    def remediation(self) -> str:
+        return f"smpy migrations prepare {self.upgrade_id} --head <host-head-or-label@head>"
+
+
+async def collect_data_compatibility(
+    modules: Sequence[ModuleBase], db: Any
+) -> list[DataCompatibilityIssue]:
+    """Read module state without applying migrations or changing credentials."""
+    issues = []
+    for module in checking_modules(modules):
+        issues.extend(await module.check_data_compatibility(db))
+    return issues
+
+
+def checking_modules(modules: Sequence[ModuleBase]) -> list[ModuleBase]:
+    """Modules that override the hook; the rest need no database session."""
+    from simple_module_core.module import ModuleBase
+
+    return [
+        module
+        for module in modules
+        if type(module).check_data_compatibility is not ModuleBase.check_data_compatibility
+    ]

{simple_module_core-0.0.41 → simple_module_core-0.0.42}/simple_module_core/durable_events.py

@@ -21,6 +21,7 @@ from __future__ import annotations
 
 import logging
 from collections.abc import Awaitable, Callable, Sequence
+from contextvars import ContextVar
 from dataclasses import dataclass
 from functools import cache
 from typing import Any, Protocol, runtime_checkable
@@ -33,6 +34,14 @@ logger = logging.getLogger(__name__)
 # subscribe time so an over-long name fails at boot, not on a publisher's flush.
 MAX_NAME_LENGTH = 255
 
+# Set by delivery transports only while invoking a durable handler.
+IN_DELIVERY: ContextVar[bool] = ContextVar("durable_event_in_delivery", default=False)
+
+
+def in_delivery() -> bool:
+    """Whether this context runs in a durable handler (including child tasks)."""
+    return IN_DELIVERY.get()
+
 
 class DurableDeliveryUnavailable(RuntimeError):  # noqa: N818 - name fixed by the design
     """``publish_durable`` was called but no durable transport is installed.
@@ -177,6 +186,7 @@ class DurableRegistry:
 
 
 __all__ = [
+    "IN_DELIVERY",
     "DurableContext",
     "DurableDeliveryUnavailable",
     "DurableHandler",
@@ -186,5 +196,6 @@ __all__ = [
     "deserialize_event",
     "event_key",
     "handler_name",
+    "in_delivery",
     "serialize_event",
 ]

{simple_module_core-0.0.41 → simple_module_core-0.0.42}/simple_module_core/events.py

@@ -11,6 +11,7 @@ from typing import Any
 from pyee.asyncio import AsyncIOEventEmitter
 
 from simple_module_core.durable_events import (
+    IN_DELIVERY,
     DurableContext,
     DurableDeliveryUnavailable,
     DurableHandler,
@@ -160,4 +161,9 @@ class EventBus:
             subscription = self.durable.lookup(key, name)
             if subscription is None:
                 continue
-            await subscription.handler(event, ctx)
+            # Inline delivery is still a durable delivery for ``in_delivery()`` (#682).
+            token = IN_DELIVERY.set(True)
+            try:
+                await subscription.handler(event, ctx)
+            finally:
+                IN_DELIVERY.reset(token)

{simple_module_core-0.0.41 → simple_module_core-0.0.42}/simple_module_core/feature_flags.py

@@ -71,6 +71,12 @@ class FeatureFlagRegistry:
         else:
             self._tenant_overrides.pop((name, tenant_id), None)
 
+    def clear_tenant_overrides(self, tenant_id: str) -> None:
+        """Forget every override for a deleted tenant, including unknown flags."""
+        self._tenant_overrides = {
+            key: value for key, value in self._tenant_overrides.items() if key[1] != tenant_id
+        }
+
     def replace_overrides(
         self, system: dict[str, bool], tenants: dict[tuple[str, str], bool]
     ) -> None:

{simple_module_core-0.0.41 → simple_module_core-0.0.42}/simple_module_core/module.py

@@ -3,10 +3,12 @@
 from __future__ import annotations
 
 from abc import ABC
+from collections.abc import Sequence
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from simple_module_core._request_hooks import RequestHooksMixin
+from simple_module_core.data_compatibility import DataCompatibilityIssue
 from simple_module_core.module_meta import ModuleMeta
 
 if TYPE_CHECKING:
@@ -226,6 +228,14 @@ class ModuleBase(RequestHooksMixin, ABC):
 
     # ── Lifecycle ─────────────────────────────────────────────
 
+    async def check_data_compatibility(self, db: Any) -> Sequence[DataCompatibilityIssue]:
+        """Read-only upgrade checks before settings hydration and module startup.
+
+        Report semantic state, never demand an upstream Alembic revision id:
+        scaffolded hosts own their histories and may port an equivalent step.
+        """
+        return ()
+
     async def on_startup(self, app: FastAPI) -> None:
         """Called after all modules are registered, during app startup."""
 

{simple_module_core-0.0.41 → simple_module_core-0.0.42}/simple_module_core/resources.py

@@ -25,10 +25,11 @@ typed ``Any``; the stock policy lives in ``simple_module_db.resource_policy``.
 from __future__ import annotations
 
 import re
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
 from typing import Any, Protocol, runtime_checkable
 
+from simple_module_core.deprecation import deprecate
 from simple_module_core.permissions import grants
 
 ACTION_VIEW = "view"
@@ -39,7 +40,13 @@ ACTION_DELETE = "delete"
 ACTION_SHARE = "share"
 """Granting someone else access; the ``sharing`` module checks it on the granter."""
 
+_SHAREABLE_ACTIONS = deprecate(
+    "ResourceType.shareable_actions", remove_in="0.1.0", use="ResourceType.share_roles"
+)
+
 _TYPE_NAME = re.compile(r"^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$")
+# A share role id is stored in a 32-character column (``sharing`` ``ROLE_MAX``).
+_ROLE_ID = re.compile(r"^[a-z][a-z0-9_]{0,31}$")
 
 
 @dataclass(frozen=True)
@@ -87,13 +94,36 @@ class ResourceType:
     ``name`` is dotted and owned by the module (``"notes.note"``). ``select_by_id``
     builds the unfiltered ``SELECT`` for one row from its string id; callers
     always pass it through ``policy.filter`` before executing it.
+
+    ``share_roles`` maps each share role id this type allows to the actions it
+    implies (each must include ``view``; checked at registration). ``None``
+    means the ``sharing`` module's default view/edit roles. Pass the same
+    mapping to ``sharing``'s ``share_exists_for(..., roles=...)``.
+    ``shareable_actions`` is deprecated in favour of ``share_roles``.
     """
 
     name: str
     policy: ResourcePolicy
     select_by_id: StatementForId
-    #: Actions a share may grant on this type, beyond :data:`ACTION_VIEW`.
-    shareable_actions: tuple[str, ...] = field(default=(ACTION_VIEW, ACTION_EDIT))
+    #: Deprecated role allowlist; retained for view/edit subsets until 0.1.0.
+    shareable_actions: tuple[str, ...] | None = None
+    #: Role ids mapped to their implied actions; None uses sharing's view/edit default.
+    share_roles: Mapping[str, tuple[str, ...]] | None = field(
+        default=None, kw_only=True, hash=False
+    )
+
+    def __post_init__(self) -> None:
+        if self.shareable_actions is not None:
+            _SHAREABLE_ACTIONS.warn(stacklevel=3)
+            if self.share_roles is None:
+                object.__setattr__(
+                    self,
+                    "share_roles",
+                    {
+                        role: (ACTION_VIEW,) if role == ACTION_VIEW else (ACTION_VIEW, role)
+                        for role in self.shareable_actions
+                    },
+                )
 
 
 class ResourceTypeError(ValueError):
@@ -115,6 +145,17 @@ class ResourceTypeRegistry:
             raise ResourceTypeError(f"Resource type name {name!r} must look like 'module.thing'")
         if name in self._types:
             raise ResourceTypeError(f"Resource type {name!r} is registered twice")
+        if resource_type.share_roles is not None:
+            for role, actions in resource_type.share_roles.items():
+                if not isinstance(role, str) or not _ROLE_ID.fullmatch(role):
+                    raise ResourceTypeError(
+                        f"Resource type {name!r} share role {role!r} must be a lowercase "
+                        "identifier of at most 32 characters"
+                    )
+                if isinstance(actions, str) or ACTION_VIEW not in actions:
+                    raise ResourceTypeError(
+                        f"Resource type {name!r} share role {role!r} must include {ACTION_VIEW!r}"
+                    )
         self._types[name] = resource_type
 
     def get(self, name: str) -> ResourceType | None:

simple_module_core-0.0.42/tests/test_core_data_compatibility_doctor.py

@@ -0,0 +1,45 @@
+"""Both Doctor entry points report upgrade ids and return a failing status (#711)."""
+
+import pytest
+import sqlalchemy as sa
+from simple_module_core import ModuleBase, ModuleMeta
+from simple_module_core import __main__ as doctor
+from simple_module_core.data_compatibility import DataCompatibilityIssue
+
+
+@pytest.mark.parametrize("entrypoint", ["make", "smpy"])
+def test_core_doctor_reports_semantic_data_errors(tmp_path, monkeypatch, capsys, entrypoint):
+    path = tmp_path / "doctor.db"
+    engine = sa.create_engine(f"sqlite:///{path}")
+    with engine.begin() as conn:
+        conn.execute(sa.text("CREATE TABLE alembic_version (version_num VARCHAR(32))"))
+        conn.execute(sa.text("INSERT INTO alembic_version VALUES ('local')"))
+    engine.dispose()
+
+    class Module(ModuleBase):
+        meta = ModuleMeta(name="Example")
+
+        async def check_data_compatibility(self, db):
+            assert await db.scalar(sa.text("SELECT version_num FROM alembic_version")) == "local"
+            return [
+                DataCompatibilityIssue(
+                    upgrade_id="example.v1", message="Upgrade required", severity="error"
+                )
+            ]
+
+    monkeypatch.setenv("SM_DATABASE_URL", f"sqlite+aiosqlite:///{path}")
+    monkeypatch.setattr(doctor, "discover_modules", lambda strict: [Module()])
+    monkeypatch.setattr(doctor, "parse_dotenv", dict)
+    monkeypatch.setattr(doctor, "run_diagnostics", lambda *a, **kw: [])
+    if entrypoint == "make":
+        assert doctor.main() == 1
+        output = capsys.readouterr().err
+    else:
+        from simple_module_cli.cli import app
+        from typer.testing import CliRunner
+
+        result = CliRunner().invoke(app, ["doctor"])
+        assert result.exit_code == 1
+        output = result.output
+    assert "example.v1" in output
+    assert "smpy migrations prepare example.v1" in output

simple_module_core-0.0.42/tests/test_core_inline_delivery_context.py

@@ -0,0 +1,19 @@
+"""Inline durable dispatch marks its handlers as in-delivery (#682)."""
+
+from simple_module_core.durable_events import in_delivery
+from simple_module_core.events import EventBus
+from simple_module_core.tenant_events import TenantDeleted
+
+
+async def test_inline_durable_handler_sees_in_delivery():
+    bus = EventBus()
+    seen: list[bool] = []
+
+    async def handler(event, ctx):
+        seen.append(in_delivery())
+
+    bus.subscribe_durable(TenantDeleted, handler, name="probe")
+    assert in_delivery() is False
+    await bus.publish_durable_or_inline(TenantDeleted("id", "slug", "Name"), object())
+    assert seen == [True]
+    assert in_delivery() is False