GeneralManager 0.82.5__tar.gz → 0.83.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.82.5
+Version: 0.83.1
 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.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.82.5"
+version = "0.83.1"
 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.1/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.82.5
+Version: 0.83.1
 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.1}/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.1}/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.1}/src/general_manager/interface/capabilities/orm_utils/field_descriptors.py

@@ -155,6 +155,20 @@ def _orm_file_field_kind(
     return None
 
 
+def _field_default(field: DjangoField) -> object:
+    """Normalize concrete measurement defaults without evaluating runtime defaults."""
+    default = field.default
+    if (
+        not isinstance(field, MeasurementField)
+        or default is None
+        or default is models.NOT_PROVIDED
+        or callable(default)
+    ):
+        return default
+    measurement, _ = field._normalize_value(default)
+    return measurement
+
+
 def _to_snake_case(name: str) -> str:
     """Convert a CamelCase class name into snake_case."""
     snake = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
@@ -257,7 +271,7 @@ class _FieldDescriptorBuilder:
                     else not field.null
                 ),
                 is_editable=field.editable,
-                default=field.default,
+                default=_field_default(field),
                 is_derived=False,
                 accessor=_instance_attribute_accessor(field_name),
                 orm_field_kind=orm_field_kind,
@@ -286,7 +300,7 @@ class _FieldDescriptorBuilder:
                     else not field.null and field.default is models.NOT_PROVIDED
                 ),
                 is_editable=field.editable,
-                default=field.default,
+                default=_field_default(field),
                 is_derived=False,
                 accessor=_instance_attribute_accessor(field.name),
                 orm_field_kind=orm_field_kind,

{generalmanager-0.82.5 → generalmanager-0.83.1}/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.1}/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.1/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.")
+        )

{generalmanager-0.82.5 → generalmanager-0.83.1}/src/general_manager/measurement/measurement_field.py

@@ -740,10 +740,24 @@ class MeasurementField(MeasurementFieldBase):
                 does not make exact non-wrapped Pint subclasses part of this
                 field's stable API.
         """
+        measurement, magnitude = self._normalize_value(value)
+        setattr(instance, self.value_attr, magnitude)
+        setattr(
+            instance,
+            self.unit_attr,
+            str(measurement.unit) if measurement is not None else None,
+        )
+
+    def _normalize_value(
+        self, value: object
+    ) -> tuple[Measurement | None, Decimal | None]:
+        """Validate a value for storage or metadata without creating a model instance.
+
+        Return the measurement in its declared unit and its quantized base-unit
+        magnitude. This does not evaluate defaults or run model validators.
+        """
         if value is None:
-            setattr(instance, self.value_attr, None)
-            setattr(instance, self.unit_attr, None)
-            return
+            return None, None
         if isinstance(value, str):
             try:
                 value = Measurement.from_string(value)
@@ -776,8 +790,7 @@ class MeasurementField(MeasurementFieldBase):
                 {self.name: [f"Unit must be compatible with '{self.base_unit}'."]}
             ) from e
 
-        setattr(instance, self.value_attr, self._normalize_base_magnitude(base_mag))
-        setattr(instance, self.unit_attr, str(value.unit))
+        return value, self._normalize_base_magnitude(base_mag)
 
     def validate(
         self,