simple-module-core 0.0.35__tar.gz → 0.0.36__tar.gz

{simple_module_core-0.0.35 → simple_module_core-0.0.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_core
-Version: 0.0.35
+Version: 0.0.36
 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
@@ -33,7 +33,7 @@ Description-Content-Type: text/markdown
 
 Module-system primitives for the [simple_module](https://github.com/antosubash/simple_module_python) framework — a modular-monolith for Python/FastAPI where each feature is a plugin package discovered at boot.
 
-This package defines `ModuleBase`, the `ModuleMeta` descriptor, the `discover_modules()` entry-point loader, topological dependency sorting, event bus primitives, and the diagnostic codes (`SM001`–`SM021`) used by `make doctor`.
+This package defines `ModuleBase`, the `ModuleMeta` descriptor, the `discover_modules()` entry-point loader, topological dependency sorting, event bus primitives, and the diagnostic codes (`SM001`–`SM025`) used by `make doctor`.
 
 ## Install
 
@@ -48,7 +48,8 @@ You usually don't install this directly — it's pulled in by `simple_module_hos
 - `ModuleBase` — the subclass every module extends to opt into lifecycle hooks.
 - `ModuleMeta` — required `meta = ModuleMeta(name=..., depends_on=...)` attribute on each module.
 - `discover_modules()` — loads all `[project.entry-points.simple_module]` modules, topologically sorts by `depends_on`.
-- Diagnostic registry — `SM001` missing meta, `SM003` orphan page, `SM008` duplicate name, `SM009` framework→plugin coupling violation, and the rest of the `SM0xx` set through `SM021`.
+- Diagnostic registry — `SM001` missing meta, `SM003` orphan page, `SM008` duplicate name, `SM009` framework→plugin coupling violation, and the rest of the `SM0xx` set through `SM025`.
+- Tenant-role vocabulary (`simple_module_core.tenancy`) — `TenantRole`, `TENANT_ROLE_PREFIX`, `tenant_role()`, so any module can map `tenant:<role>` onto its permissions without depending on `tenants`.
 - Tiny event-bus (`pyee`) for decoupled module-to-module communication.
 
 ## Usage

{simple_module_core-0.0.35 → simple_module_core-0.0.36}/README.md

@@ -2,7 +2,7 @@
 
 Module-system primitives for the [simple_module](https://github.com/antosubash/simple_module_python) framework — a modular-monolith for Python/FastAPI where each feature is a plugin package discovered at boot.
 
-This package defines `ModuleBase`, the `ModuleMeta` descriptor, the `discover_modules()` entry-point loader, topological dependency sorting, event bus primitives, and the diagnostic codes (`SM001`–`SM021`) used by `make doctor`.
+This package defines `ModuleBase`, the `ModuleMeta` descriptor, the `discover_modules()` entry-point loader, topological dependency sorting, event bus primitives, and the diagnostic codes (`SM001`–`SM025`) used by `make doctor`.
 
 ## Install
 
@@ -17,7 +17,8 @@ You usually don't install this directly — it's pulled in by `simple_module_hos
 - `ModuleBase` — the subclass every module extends to opt into lifecycle hooks.
 - `ModuleMeta` — required `meta = ModuleMeta(name=..., depends_on=...)` attribute on each module.
 - `discover_modules()` — loads all `[project.entry-points.simple_module]` modules, topologically sorts by `depends_on`.
-- Diagnostic registry — `SM001` missing meta, `SM003` orphan page, `SM008` duplicate name, `SM009` framework→plugin coupling violation, and the rest of the `SM0xx` set through `SM021`.
+- Diagnostic registry — `SM001` missing meta, `SM003` orphan page, `SM008` duplicate name, `SM009` framework→plugin coupling violation, and the rest of the `SM0xx` set through `SM025`.
+- Tenant-role vocabulary (`simple_module_core.tenancy`) — `TenantRole`, `TENANT_ROLE_PREFIX`, `tenant_role()`, so any module can map `tenant:<role>` onto its permissions without depending on `tenants`.
 - Tiny event-bus (`pyee`) for decoupled module-to-module communication.
 
 ## Usage

{simple_module_core-0.0.35 → simple_module_core-0.0.36}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_core"
-version = "0.0.35"
+version = "0.0.36"
 description = "Module-system primitives for the simple_module framework — ModuleBase, discovery, diagnostics, events"
 readme = "README.md"
 license = "MIT"

{simple_module_core-0.0.35 → simple_module_core-0.0.36}/simple_module_core/__init__.py

@@ -1,6 +1,7 @@
 """SimpleModule Core - Module system, menu, permissions, events, and diagnostics."""
 
 from simple_module_core.audit_links import AuditLink, AuditLinkRegistry, LabelResolver
+from simple_module_core.body_limits import BodyLimitRegistry
 from simple_module_core.csp import CspSourceError, CspSourceRegistry
 from simple_module_core.design_packs import DesignPack, DesignPackRegistry
 from simple_module_core.diagnostics import (
@@ -46,14 +47,17 @@ from simple_module_core.module import ModuleBase, ModuleMeta
 from simple_module_core.permissions import PermissionRegistry
 from simple_module_core.public_routes import PublicRoute, PublicRouteRegistry
 from simple_module_core.services import Services
-from simple_module_core.setup_steps import SetupRegistry, SetupStep
+from simple_module_core.setup_steps import SetupAction, SetupField, SetupRegistry, SetupStep
+from simple_module_core.tenancy import TENANT_ROLE_PREFIX, TenantRole, is_tenant_role, tenant_role
 from simple_module_core.versioning import FRAMEWORK_API_VERSION, check_framework_compatibility
 
 __all__ = [
     "DEFAULT_AUTH_PROVIDER",
     "FRAMEWORK_API_VERSION",
+    "TENANT_ROLE_PREFIX",
     "AuditLink",
     "AuditLinkRegistry",
+    "BodyLimitRegistry",
     "CircularDependencyError",
     "CspSourceError",
     "CspSourceRegistry",
@@ -87,8 +91,11 @@ __all__ = [
     "PublicRoute",
     "PublicRouteRegistry",
     "Services",
+    "SetupAction",
+    "SetupField",
     "SetupRegistry",
     "SetupStep",
+    "TenantRole",
     "Translator",
     "ValidationError",
     "check_framework_compatibility",
@@ -97,10 +104,12 @@ __all__ = [
     "flag_enabled",
     "get_module_package_name",
     "is_flag_enabled",
+    "is_tenant_role",
     "print_diagnostics",
     "require_flag",
     "resolve_auth_provider",
     "run_diagnostics",
     "select_auth_provider",
+    "tenant_role",
     "topological_sort",
 ]

{simple_module_core-0.0.35 → simple_module_core-0.0.36}/simple_module_core/__main__.py

@@ -11,14 +11,14 @@ i18n checks always run. ``SM_I18N_SUPPORTED_LOCALES`` (env or ``.env``)
 declares the locale set this install promises, which also enables SM013 for a
 namespace that never shipped one; with it unset, each namespace is checked
 against the locale files it actually has, so key drift between two shipped
-translations is still caught. Host-level ``host/locales/`` and shared
-``packages/ui/locales/`` are picked up relative to the project root
-(``SM_PROJECT_ROOT``, else the directory of the discovered ``.env``, else the
-current working dir).
+translations is still caught. Host-level ``host/locales/`` is picked up
+relative to the project root (``SM_PROJECT_ROOT``, else the directory of the
+discovered ``.env``, else the current working dir).
 """
 
 from __future__ import annotations
 
+import importlib.util
 import json
 import os
 import sys
@@ -30,6 +30,7 @@ from simple_module_core.diagnostics import (
     print_diagnostics,
     run_diagnostics,
 )
+from simple_module_core.diagnostics._i18n import unknown_overrides_for
 from simple_module_core.discovery import (
     discover_modules,
     resolve_auth_provider,
@@ -73,20 +74,59 @@ def _load_i18n_settings_from_env() -> tuple[list[str] | None, str]:
     return supported, default
 
 
+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")
+    return url.split(":", 1)[0].split("+", 1)[0]
+
+
+def _hosting_locales() -> Path | None:
+    """The framework's own ``hosting`` catalog (setup wizard), found without importing it.
+
+    The running app's ``build_i18n_registry`` always adds it, so doctor must
+    too, or every ``hosting.*`` host override reads as unknown (SM027). Core
+    may not import ``simple_module_hosting``: locate the package on disk.
+    """
+    try:
+        spec = importlib.util.find_spec("simple_module_hosting")
+    except (ImportError, ValueError):
+        return None
+    if spec is None or not spec.origin:
+        return None
+    locales = Path(spec.origin).resolve().parent / "locales"
+    return locales if locales.is_dir() else None
+
+
+def _hosting_ui_locales() -> Path | None:
+    """The shared ``ui`` catalog, which ships inside ``simple_module_hosting`` (#426)."""
+    hosting = _hosting_locales()
+    if hosting is None:
+        return None
+    ui = hosting.parent / "ui_locales"
+    return ui if ui.is_dir() else None
+
+
 def _discover_extra_locale_sources() -> list[tuple[str, str, Path]]:
-    """Return ``[(reporter, namespace, path), ...]`` for host + ui locale dirs."""
+    """Return ``[(reporter, namespace, path), ...]`` for hosting + host + ui locale dirs."""
     # Anchor on the same project root the `.env` was loaded from
     # (`parse_dotenv` walks up from the cwd) — resolving against the bare cwd
     # here would look for `host/locales` in the wrong directory whenever
     # doctor runs from a subdirectory.
     root = find_env_file().parent
     out: list[tuple[str, str, Path]] = []
+    hosting_locales = _hosting_locales()
+    if hosting_locales is not None:
+        out.append(("simple_module_hosting", "hosting", hosting_locales))
     host_locales = root / "host" / "locales"
     if host_locales.is_dir():
         out.append(("host", "host", host_locales))
-    ui_locales = root / "packages" / "ui" / "locales"
-    if ui_locales.is_dir():
-        out.append(("packages/ui", "ui", ui_locales))
+    ui_locales = _hosting_ui_locales()
+    if ui_locales is not None:
+        out.append(("simple_module_hosting/ui", "ui", ui_locales))
     return out
 
 
@@ -130,12 +170,17 @@ def main() -> int:
     supported, default = _load_i18n_settings_from_env()
     extra = _discover_extra_locale_sources()
 
+    unknown_overrides, override_findings = unknown_overrides_for(modules, extra, supported, default)
+
     diagnostics = run_diagnostics(
         modules,
         i18n_supported_locales=supported,
         i18n_default_locale=default,
         i18n_extra_sources=extra,
+        i18n_unknown_overrides=unknown_overrides,
+        database_dialect=_database_dialect(),
     )
+    diagnostics.extend(override_findings)
     print_diagnostics(diagnostics)
 
     errors = [d for d in diagnostics if d.level == DiagnosticLevel.ERROR]

simple_module_core-0.0.36/simple_module_core/_i18n_flatten.py

@@ -0,0 +1,44 @@
+"""Read locale catalogs and flatten nested locale dicts to dotted keys."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def read_catalog(path: Path) -> dict[str, Any]:
+    """Parse a ``<locale>.json`` catalog; ValueError if it is not a JSON object."""
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"invalid JSON in {path}: {exc}") from exc
+    if not isinstance(raw, dict):
+        raise ValueError(f"{path} must contain a JSON object at the top level")
+    return raw
+
+
+def flatten_messages(
+    nested: dict[str, Any],
+    *,
+    prefix: str = "",
+) -> dict[str, str]:
+    """Flatten a nested dict of string leaves to dotted keys.
+
+    {"browse": {"title": "X"}} -> {"browse.title": "X"}
+
+    Raises ValueError if any leaf is not a string.
+    """
+    out: dict[str, str] = {}
+    for key, value in nested.items():
+        composed = f"{prefix}.{key}" if prefix else key
+        if isinstance(value, dict):
+            out.update(flatten_messages(value, prefix=composed))
+        elif isinstance(value, str):
+            out[composed] = value
+        else:
+            raise ValueError(
+                f"Locale value at '{composed}' must be string or nested dict, "
+                f"got {type(value).__name__}"
+            )
+    return out

simple_module_core-0.0.36/simple_module_core/body_limits.py

@@ -0,0 +1,71 @@
+"""Per-path request-body ceilings modules declare for the body-size guard.
+
+The host ships one global ceiling (``HostSettings.max_request_body_bytes``).
+A module whose endpoint legitimately takes more — a multipart upload — or
+should take far less raises or lowers it for that route through
+:meth:`~simple_module_core.module.ModuleBase.register_body_limits`::
+
+    def register_body_limits(self, registry):
+        registry.add_prefix("/api/file-storage/upload", 100 * 1024 * 1024)
+
+``max_bytes`` may be a callable ``(app) -> int`` for a limit that is itself a
+runtime setting; it is evaluated per request. The first matching rule in
+registration order wins, and its value *replaces* the global ceiling.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from typing import Any
+
+from simple_module_core.public_routes import PublicRoute
+
+__all__ = ["BodyLimitRegistry"]
+
+MaxBytes = int | Callable[[Any], int]
+
+
+class BodyLimitRegistry:
+    def __init__(self) -> None:
+        self._rules: list[tuple[PublicRoute, MaxBytes]] = []
+
+    def add(
+        self,
+        pattern: str,
+        max_bytes: MaxBytes,
+        *,
+        methods: Iterable[str] | None = None,
+        kind: str = "prefix",
+    ) -> None:
+        """Register a ceiling. ``kind`` is prefix / exact / suffix / regex."""
+        if isinstance(max_bytes, int) and max_bytes < 0:
+            raise ValueError("max_bytes must be >= 0 (0 means unlimited)")
+        self._rules.append((PublicRoute(pattern, methods=methods, kind=kind), max_bytes))
+
+    def add_prefix(
+        self, prefix: str, max_bytes: MaxBytes, *, methods: Iterable[str] | None = None
+    ) -> None:
+        self.add(prefix, max_bytes, methods=methods, kind="prefix")
+
+    def add_exact(
+        self, path: str, max_bytes: MaxBytes, *, methods: Iterable[str] | None = None
+    ) -> None:
+        self.add(path, max_bytes, methods=methods, kind="exact")
+
+    def add_regex(
+        self, pattern: str, max_bytes: MaxBytes, *, methods: Iterable[str] | None = None
+    ) -> None:
+        self.add(pattern, max_bytes, methods=methods, kind="regex")
+
+    def limit_for(self, method: str, path: str, app: Any = None) -> int | None:
+        """The override for this request, or ``None`` to use the global ceiling.
+
+        ``0`` means "unlimited for this route".
+        """
+        for route, max_bytes in self._rules:
+            if route.matches(method, path):
+                return max_bytes if isinstance(max_bytes, int) else int(max_bytes(app))
+        return None
+
+    def __len__(self) -> int:
+        return len(self._rules)

{simple_module_core-0.0.35 → simple_module_core-0.0.36}/simple_module_core/csp.py

@@ -10,8 +10,13 @@ origin fails loudly at boot instead of silently weakening the header.
 from __future__ import annotations
 
 import re
+from collections.abc import Callable, Iterable
+from typing import Any
 
-__all__ = ["CspSourceError", "CspSourceRegistry"]
+__all__ = ["CspProvider", "CspSourceError", "CspSourceRegistry", "is_valid_source"]
+
+CspProvider = Callable[[Any], Iterable[tuple[str, str]]]
+"""``fn(app) -> [(directive, source), ...]`` evaluated per response."""
 
 # Fetch directives a module may extend. Deliberately excludes the policy's
 # structural directives (default-src, base-uri, form-action, frame-ancestors,
@@ -37,8 +42,10 @@ _EXTENDABLE_DIRECTIVES = frozenset(
 # a data-ish scheme keyword. One token — anything that could smuggle a second
 # token or terminate/extend the clause (whitespace, ";", ",", quotes) is
 # rejected, and a wildcard prefix must be followed by a real host (`*.` alone
-# is not a source).
-_SOURCE_RE = re.compile(r"^(?:[A-Za-z][A-Za-z0-9+.-]*:(?://)?)?(?:(?:\*\.)?[^\s;,'\"*]+)?$")
+# is not a source). Only printable ASCII: the header is latin-1 encoded and
+# h11 rejects control bytes, so anything else would fail at send time — on
+# every response, for a provider reading an admin-edited setting.
+_SOURCE_RE = re.compile(r"(?:[A-Za-z][A-Za-z0-9+.-]*:(?://)?)?(?:(?:\*\.)?(?:(?![;,'\"*])[!-~])+)?")
 
 # CSP3 fallback chains: when a directive is absent from a policy, the browser
 # consults these directives in order (ending at ``default-src``). A clause we
@@ -59,33 +66,64 @@ class CspSourceError(ValueError):
     """Invalid CSP directive or source declared by a module."""
 
 
+def _checked(directive: str, source: str) -> str:
+    """Validate one pair and return the normalized source token, or raise."""
+    if directive not in _EXTENDABLE_DIRECTIVES:
+        raise CspSourceError(
+            f"CSP directive {directive!r} is not extendable; "
+            f"choose one of {sorted(_EXTENDABLE_DIRECTIVES)}"
+        )
+    token = source.strip()
+    if not token or not _SOURCE_RE.fullmatch(token):
+        raise CspSourceError(
+            f"invalid CSP source {source!r} for {directive}: must be a single "
+            "origin or scheme token (no spaces, quotes, wildcards-only, or ';')"
+        )
+    return token
+
+
+def is_valid_source(directive: str, source: str) -> bool:
+    """Whether ``add(directive, source)`` would accept the pair (never raises)."""
+    try:
+        _checked(directive, source)
+    except (CspSourceError, AttributeError, TypeError):
+        return False
+    return True
+
+
 class CspSourceRegistry:
     """Collects per-directive extra CSP sources from modules."""
 
     def __init__(self) -> None:
         self._sources: dict[str, list[str]] = {}
+        self._providers: list[CspProvider] = []
 
     def add(self, directive: str, source: str) -> None:
         """Allow ``source`` in ``directive``, e.g. ``add("style-src", "https://rsms.me")``."""
-        if directive not in _EXTENDABLE_DIRECTIVES:
-            raise CspSourceError(
-                f"CSP directive {directive!r} is not extendable; "
-                f"choose one of {sorted(_EXTENDABLE_DIRECTIVES)}"
-            )
-        token = source.strip()
-        if not token or not _SOURCE_RE.match(token):
-            raise CspSourceError(
-                f"invalid CSP source {source!r} for {directive}: must be a single "
-                "origin or scheme token (no spaces, quotes, wildcards-only, or ';')"
-            )
+        token = _checked(directive, source)
         bucket = self._sources.setdefault(directive, [])
         if token not in bucket:
             bucket.append(token)
 
+    def add_provider(self, provider: CspProvider) -> None:
+        """Contribute sources that depend on runtime state (e.g. DB settings).
+
+        ``provider(app)`` runs on every response and returns
+        ``(directive, source)`` pairs. It must be synchronous and read only
+        in-memory state (``app.state.<pkg>.settings``) — never the DB. Pairs
+        that fail ``add()``'s validation, and providers that raise, are
+        dropped and logged by the host: the static policy still applies.
+        """
+        self._providers.append(provider)
+
+    @property
+    def providers(self) -> tuple[CspProvider, ...]:
+        return tuple(self._providers)
+
     def __bool__(self) -> bool:
         return bool(self._sources)
 
-    def extend_policy(self, policy: str) -> str:
+    def extend_policy(self, policy: str, extra: Iterable[tuple[str, str]] = ()) -> str:
         """Fold the registered sources into an existing policy string.
 
         Existing clauses keep their order and gain only sources they don't
@@ -94,8 +132,16 @@ class CspSourceRegistry:
         back to (per ``_FALLBACK_CHAINS``, ending at ``default-src``) —
         without that seed the new clause would *narrow* the policy, since the
         browser stops consulting the fallback once the directive exists.
+
+        ``extra`` adds already-validated ``(directive, source)`` pairs (from
+        providers) for this call only — the registry itself is not mutated.
         """
-        if not self._sources:
+        sources = {d: list(v) for d, v in self._sources.items()}
+        for directive, source in extra:
+            bucket = sources.setdefault(directive, [])
+            if source not in bucket:
+                bucket.append(source)
+        if not sources:
             return policy
         directives: dict[str, list[str]] = {}
         order: list[str] = []
@@ -106,7 +152,7 @@ class CspSourceRegistry:
             directive, _, rest = clause.partition(" ")
             directives[directive] = rest.split()
             order.append(directive)
-        for directive, extras in self._sources.items():
+        for directive, extras in sources.items():
             if directive not in directives:
                 directives[directive] = list(self._seed_sources(directive, directives))
                 order.append(directive)
@@ -126,7 +172,7 @@ class CspSourceRegistry:
                 continue
             bucket = directives[shadowing]
             for base in chain:
-                extras = self._sources.get(base)
+                extras = sources.get(base)
                 if extras:
                     bucket.extend(e for e in extras if e not in bucket)
         return "; ".join(f"{d} {' '.join(directives[d])}".rstrip() for d in order)

{simple_module_core-0.0.35 → simple_module_core-0.0.36}/simple_module_core/diagnostics/__init__.py

@@ -12,6 +12,7 @@ from simple_module_core.diagnostics._migration import MigrationDiagnostics
 from simple_module_core.diagnostics._module import ModuleDiagnostics
 from simple_module_core.diagnostics._pages import collect_tsx_pages
 from simple_module_core.diagnostics._runner import print_diagnostics, run_diagnostics
+from simple_module_core.diagnostics._tenancy import check_tenant_resolver
 from simple_module_core.diagnostics._types import Diagnostic, DiagnosticLevel
 
 __all__ = [
@@ -20,6 +21,7 @@ __all__ = [
     "I18nDiagnostics",
     "MigrationDiagnostics",
     "ModuleDiagnostics",
+    "check_tenant_resolver",
     "collect_tsx_pages",
     "print_diagnostics",
     "run_diagnostics",

simple_module_core-0.0.36/simple_module_core/diagnostics/_expression_index.py

@@ -0,0 +1,106 @@
+"""Expression-index diagnostics (SM026).
+
+SQLAlchemy cannot reflect expression indexes (``lower(email)``) on SQLite, so
+autogenerate and ``alembic check`` silently skip them there and report a clean
+diff. That is "unverified", not "clean": on Postgres the same index is either
+missing from the history or drifted. SM026 says so whenever the configured
+database is SQLite and any module model declares such an index.
+
+Duck-typed on SQLAlchemy ``Table``/``Index`` objects (core does not depend on
+SQLAlchemy).
+"""
+
+from __future__ import annotations
+
+import importlib
+import logging
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any
+
+from simple_module_core.diagnostics._types import Diagnostic, DiagnosticLevel
+
+if TYPE_CHECKING:
+    from simple_module_core.module import ModuleBase
+
+logger = logging.getLogger(__name__)
+
+
+def index_is_expression_based(index: Any) -> bool:
+    """True when any element of ``index`` is an expression rather than a plain column.
+
+    A plain ``Column`` is attached to its table; a ``text()`` or function
+    element is not.
+    """
+    return any(getattr(expr, "table", None) is None for expr in index.expressions)
+
+
+def find_expression_indexes(tables: Iterable[Any]) -> list[tuple[str, str]]:
+    """Return sorted ``(table name, index name)`` pairs for expression indexes."""
+    found = {
+        (table.name, index.name or "<unnamed>")
+        for table in tables
+        for index in table.indexes
+        if index_is_expression_based(index)
+    }
+    return sorted(found)
+
+
+def module_all_tables(mod: ModuleBase) -> list[Any]:
+    """Every table declared in the module's ``models`` submodule."""
+    pkg = type(mod).__module__.rsplit(".", 1)[0]
+    try:
+        models = importlib.import_module(f"{pkg}.models")
+    except ModuleNotFoundError:
+        return []
+    except Exception:  # pragma: no cover - a broken models module fails elsewhere, loudly
+        logger.debug("Could not import %s.models for SM026", pkg, exc_info=True)
+        return []
+    seen: dict[str, Any] = {}
+    for value in vars(models).values():
+        table = getattr(value, "__table__", None)
+        if (
+            isinstance(value, type)
+            and table is not None
+            and hasattr(table, "indexes")
+            # Skip models re-imported from another module, or each importer would
+            # be told about an index it does not own.
+            and getattr(value, "__module__", "").startswith(pkg)
+        ):
+            seen.setdefault(table.name, table)
+    return list(seen.values())
+
+
+def check_expression_indexes_unverifiable(
+    tables: Iterable[Any], dialect: str | None, module_name: str
+) -> list[Diagnostic]:
+    """SM026: INFO on SQLite when the models declare indexes it cannot verify."""
+    if dialect != "sqlite":
+        return []
+    found = find_expression_indexes(tables)
+    if not found:
+        return []
+    names = ", ".join(f"{idx} ({tbl})" for tbl, idx in found)
+    return [
+        Diagnostic(
+            level=DiagnosticLevel.INFO,
+            code="SM026",
+            message=(
+                f"SQLite cannot reflect expression indexes, so autogenerate and "
+                f"`alembic check` cannot verify {names}; a clean diff here says nothing "
+                f"about them"
+            ),
+            module_name=module_name,
+            suggestion=(
+                "Add them to a revision by hand and verify on Postgres: "
+                "`make migrations-roundtrip-pg`"
+            ),
+        )
+    ]
+
+
+__all__ = [
+    "check_expression_indexes_unverifiable",
+    "find_expression_indexes",
+    "index_is_expression_based",
+    "module_all_tables",
+]