GeneralManager 0.82.5__tar.gz → 0.83.0__tar.gz

{generalmanager-0.82.5/src/GeneralManager.egg-info → generalmanager-0.83.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.82.5
+Version: 0.83.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.82.5 → generalmanager-0.83.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.82.5"
+version = "0.83.0"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]

{generalmanager-0.82.5 → generalmanager-0.83.0/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.82.5
+Version: 0.83.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.82.5 → generalmanager-0.83.0}/src/GeneralManager.egg-info/SOURCES.txt

@@ -229,6 +229,7 @@ src/general_manager/management/commands/search_index.py
 src/general_manager/management/commands/search_reconcile.py
 src/general_manager/management/commands/seed_manager_landscape.py
 src/general_manager/management/commands/shell.py
+src/general_manager/management/commands/sync_read_only.py
 src/general_manager/management/commands/workflow_drain_outbox.py
 src/general_manager/management/commands/workflow_replay_dead_letters.py
 src/general_manager/manager/__init__.py

{generalmanager-0.82.5 → generalmanager-0.83.0}/src/general_manager/bootstrap.py

@@ -191,7 +191,7 @@ def install_startup_hook_runner() -> None:
     ) -> None:
         run_main = os.environ.get("RUN_MAIN") == "true"
         command = argv[1] if len(argv) > 1 else None
-        should_run_hooks = command != "runserver" or run_main
+        should_run_hooks = command != "runserver" or run_main or "--noreload" in argv
         hooks_registry = registered_startup_hook_entries() if should_run_hooks else {}
         if hooks_registry:
             resolver_groups: list[

{generalmanager-0.82.5 → generalmanager-0.83.0}/src/general_manager/interface/capabilities/read_only/management.py

@@ -3,12 +3,14 @@
 from __future__ import annotations
 
 import json
-from collections.abc import Callable, Sequence
-from contextlib import AbstractContextManager
+from collections.abc import Callable, Iterator, Sequence
+from contextlib import AbstractContextManager, contextmanager
+from contextvars import ContextVar
 from hashlib import sha256
 from typing import TYPE_CHECKING, ClassVar, Protocol, TypeVar, cast
 
 from django.core.checks import Warning
+from django.conf import settings
 from django.db import (
     IntegrityError,
     connection as django_connection,
@@ -44,6 +46,19 @@ from ._types import (
 )
 
 logger = get_logger("interface.read_only")
+_automatic_sync_suppressed: ContextVar[bool] = ContextVar(
+    "read_only_automatic_sync_suppressed", default=False
+)
+
+
+@contextmanager
+def _suppress_automatic_sync() -> Iterator[None]:
+    """Let explicit CLI maintenance own sync while other startup hooks still run."""
+    token = _automatic_sync_suppressed.set(True)
+    try:
+        yield
+    finally:
+        _automatic_sync_suppressed.reset(token)
 
 
 class _ColumnDescription(Protocol):
@@ -1156,9 +1171,9 @@ class ReadOnlyManagementCapability(BaseCapability):
         returned. The registered hook catches `MissingReadOnlyBindingError`
         only to tolerate binding metadata becoming unavailable between
         registration and startup execution; other sync errors propagate.
-        Automatic synchronization is skipped when `READ_ONLY_SYNC_ON_STARTUP`
-        is disabled in GeneralManager settings. Explicit `sync_data()` calls
-        remain available.
+        Automatic synchronization uses `READ_ONLY_SYNC_ON_STARTUP`, falling
+        back to Django `DEBUG` when unset. Explicit `sync_data()` calls remain
+        available regardless of that setting.
 
         Parameters:
             interface_cls: Interface class used to derive the bound manager and model.
@@ -1192,7 +1207,9 @@ class ReadOnlyManagementCapability(BaseCapability):
             binding is not available (raises MissingReadOnlyBindingError), logs a debug
             message and returns without raising.
             """
-            if not get_setting("READ_ONLY_SYNC_ON_STARTUP", True):
+            if _automatic_sync_suppressed.get() or not get_setting(
+                "READ_ONLY_SYNC_ON_STARTUP", settings.DEBUG
+            ):
                 return
             try:
                 self.sync_data(interface_cls)

{generalmanager-0.82.5 → generalmanager-0.83.0}/src/general_manager/management/commands/search_reconcile.py

@@ -92,13 +92,18 @@ class Command(BaseCommand):
 
         while True:
             result = reconcile_search_indexes(force=force, max_states=max_states)
-            self.stdout.write(
-                self.style.SUCCESS(
-                    "Reconciled "
-                    f"{result.reconciled} search index states "
-                    f"({result.documents} documents, {result.failed} failures)."
-                )
+            summary = (
+                "Reconciled "
+                f"{result.reconciled} search index states "
+                f"({result.documents} documents, {result.failed} failures)."
             )
+            if result.failed:
+                self.stderr.write(self.style.ERROR(summary))
+                if once:
+                    message = "Search reconciliation failed; inspect logs and SearchIndexState.last_error."
+                    raise CommandError(message)
+            else:
+                self.stdout.write(self.style.SUCCESS(summary))
             if once:
                 return
             force = False

generalmanager-0.83.0/src/general_manager/management/commands/sync_read_only.py

@@ -0,0 +1,169 @@
+"""Explicit deployment maintenance for registered read-only managers."""
+
+from __future__ import annotations
+
+from argparse import ArgumentParser
+from collections.abc import Iterable, Sequence
+from typing import cast
+
+from django.core.management.base import BaseCommand, CommandError
+from django.db import connections
+
+from general_manager.interface.capabilities.read_only.management import (
+    ReadOnlyManagementCapability,
+    _ReadOnlyInterface,
+    _SchemaConnection,
+    _suppress_automatic_sync,
+)
+from general_manager.interface.infrastructure.startup_hooks import (
+    order_interfaces_by_dependency,
+)
+from general_manager.manager.meta import GeneralManagerMeta
+
+
+def _manager_path(interface: _ReadOnlyInterface) -> str:
+    """Identify a bound manager without importing arbitrary selector input."""
+    manager = interface._parent_class
+    return f"{manager.__module__}.{manager.__qualname__}"
+
+
+def _capability(interface: _ReadOnlyInterface) -> ReadOnlyManagementCapability:
+    """Use the manager's configured management capability, including overrides."""
+    return cast(
+        ReadOnlyManagementCapability,
+        interface.require_capability(
+            "read_only_management", expected_type=ReadOnlyManagementCapability
+        ),
+    )
+
+
+def _select_interfaces(value: object) -> list[_ReadOnlyInterface]:
+    """Validate selectors and include transitive read-only relation dependencies."""
+    interfaces = list(
+        dict.fromkeys(
+            cast(_ReadOnlyInterface, manager.Interface)
+            for manager in GeneralManagerMeta.all_classes
+            if getattr(manager.Interface, "_interface_type", None) == "readonly"
+        )
+    )
+    if value is None:
+        selected = interfaces
+    else:
+        selectors: tuple[object, ...]
+        if isinstance(value, str):
+            selectors = (value,)
+        elif isinstance(value, Iterable):
+            selectors = tuple(value)
+        else:
+            selectors = ()
+        if not selectors or any(
+            not isinstance(selector, str) or not selector for selector in selectors
+        ):
+            message = "--manager must contain one or more nonempty manager names."
+            raise CommandError(message)
+        selected = []
+        for selector in selectors:
+            matches = [
+                interface
+                for interface in interfaces
+                if selector
+                in (interface._parent_class.__name__, _manager_path(interface))
+            ]
+            if not matches:
+                message = f"Unknown read-only manager: {selector}."
+                raise CommandError(message)
+            if len(matches) > 1:
+                paths = ", ".join(sorted(_manager_path(item) for item in matches))
+                message = (
+                    f"Ambiguous read-only manager {selector}; use one of: {paths}."
+                )
+                raise CommandError(message)
+            if matches[0] not in selected:
+                selected.append(matches[0])
+
+    dependencies: dict[_ReadOnlyInterface, set[_ReadOnlyInterface]] = {}
+    pending = list(selected)
+    while pending:
+        interface = pending.pop(0)
+        if interface in dependencies:
+            continue
+        dependencies[interface] = (
+            ReadOnlyManagementCapability._related_readonly_interfaces(interface)
+        )
+        pending.extend(sorted(dependencies[interface], key=_manager_path))
+
+    interface_list = sorted(dependencies, key=_manager_path)
+    ordered = cast(
+        list[_ReadOnlyInterface],
+        order_interfaces_by_dependency(
+            interface_list,
+            lambda interface: set(dependencies[cast(_ReadOnlyInterface, interface)]),
+        ),
+    )
+    positions = {interface: index for index, interface in enumerate(ordered)}
+    if any(
+        positions[dependency] >= positions[interface]
+        for interface in ordered
+        for dependency in dependencies[interface]
+    ):
+        message = "Read-only dependency cycle; cannot determine a safe sync order."
+        raise CommandError(message)
+    return ordered
+
+
+class Command(BaseCommand):
+    help = "Synchronize read-only managers and their dependencies after migrations."
+
+    def add_arguments(self, parser: ArgumentParser) -> None:
+        """Accept repeatable unique class names or module-qualified manager paths."""
+        parser.add_argument(
+            "--manager",
+            action="append",
+            dest="managers",
+            help="Read-only manager name or module-qualified class path. Repeatable; defaults to all.",
+        )
+
+    def run_from_argv(self, argv: Sequence[str]) -> None:
+        """Avoid duplicate automatic read-only sync before this explicit CLI step."""
+        with _suppress_automatic_sync():
+            super().run_from_argv(argv)
+
+    def handle(self, *_args: object, **options: object) -> None:
+        """Preflight all schemas, then sync in dependency order or fail loudly.
+
+        No global transaction is added: completed managers may remain synced if
+        a later manager fails. Re-running the command converges the payloads.
+        """
+        interfaces = _select_interfaces(options.get("managers"))
+        # The public sync API logs schema warnings and returns without writing.
+        # Deployment maintenance must instead fail before claiming success.
+        for interface in interfaces:
+            try:
+                capability = _capability(interface)
+                warnings = capability.ensure_schema_is_up_to_date(
+                    interface,
+                    interface._parent_class,
+                    interface._model,
+                    connection=cast(
+                        _SchemaConnection,
+                        connections[capability._database_alias(interface)],
+                    ),
+                )
+            except Exception as exc:
+                message = f"Read-only schema check failed for {_manager_path(interface)}: {exc}"
+                raise CommandError(message) from exc
+            if warnings:
+                detail = "; ".join(str(warning) for warning in warnings)
+                message = f"Read-only schema check failed for {_manager_path(interface)}: {detail}"
+                raise CommandError(message)
+
+        for interface in interfaces:
+            try:
+                _capability(interface).sync_data(interface, schema_validated=True)
+            except Exception as exc:
+                message = f"Read-only sync failed for {_manager_path(interface)}: {exc}"
+                raise CommandError(message) from exc
+            self.stdout.write(f"Synchronized {_manager_path(interface)}.")
+        self.stdout.write(
+            self.style.SUCCESS(f"Synchronized {len(interfaces)} read-only managers.")
+        )