GeneralManager 0.86.0__tar.gz → 0.86.2__tar.gz

{generalmanager-0.86.0/src/GeneralManager.egg-info → generalmanager-0.86.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.86.0
+Version: 0.86.2
 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.86.0 → generalmanager-0.86.2}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.86.0
+Version: 0.86.2
 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.86.0 → generalmanager-0.86.2}/src/general_manager/api/graphql.py

@@ -47,6 +47,7 @@ from general_manager.bucket._materialized_bucket import MaterializedBucket
 from general_manager.bucket.group_bucket import GroupBucket
 from general_manager.bucket.request_bucket import RequestBucket
 from general_manager.bucket.indexing import freeze_bucket_index_value
+from general_manager.cache.cache_tracker import DependencyTracker
 from general_manager.cache.dependency_index import (
     Dependency,
 )
@@ -116,6 +117,7 @@ from general_manager.api.graphql_resolvers import (
     apply_pagination as _apply_pagination_fn,
     apply_grouping as _apply_grouping_fn,
     check_read_permission as _check_read_permission_fn,
+    check_read_permission_for_user as _check_read_permission_for_user_fn,
     can_read_instance_for_user as _can_read_instance_for_user_fn,
     create_measurement_resolver as _create_measurement_resolver_fn,
     create_normal_resolver as _create_normal_resolver_fn,
@@ -2391,6 +2393,36 @@ class GraphQL:
             raise
         return item if readable else None
 
+    @classmethod
+    def _prepare_detail_subscription(
+        cls,
+        manager_class: type[GeneralManager],
+        identification: GraphQLIdentification,
+        user: object,
+        *,
+        property_names: Iterable[str] = (),
+    ) -> tuple[GeneralManager, set[Dependency]] | None:
+        """Hydrate and authorize before priming selected readable properties.
+
+        Call in a worker thread: construction, native permissions and property
+        reads may all access the ORM. Only hydration errors are suppressed;
+        permission-backend and property failures must fail the stream closed.
+        """
+        with DependencyTracker() as dependencies:
+            try:
+                instance, _ = cls._instantiate_manager(manager_class, identification)
+            except SUBSCRIPTION_HYDRATION_ERRORS:
+                return None
+            if not _can_read_instance_for_user_fn(instance, user):
+                return None
+            readable_properties = [
+                name
+                for name in property_names
+                if _check_read_permission_for_user_fn(instance, user, name)
+            ]
+            cls._prime_graphql_properties(instance, readable_properties)
+        return instance, dependencies
+
     @classmethod
     def _add_subscription_field(
         cls,
@@ -2411,7 +2443,7 @@ class GraphQL:
 
         Notes:
         - The subscribe function requires an available channel layer and subscribes the caller to channel groups derived from the instance identification and its resolved dependencies.
-        - The subscribe coroutine yields SubscriptionEvent objects with fields `item` (the current instance or None if it cannot be instantiated) and `action` (a string such as `"snapshot"` or other change actions).
+        - Detail events contain an authorized current instance and an action; unavailable or unreadable targets terminate the detail stream.
         - On termination the subscription cleans up listener tasks and unsubscribes from channel groups.
         """
         manager_field_name = pascal_to_snake(generalManagerClass.__name__)
@@ -2451,27 +2483,30 @@ class GraphQL:
             """
             Stream subscription events for a specific manager instance identified by the provided arguments.
 
-            Yields an initial `SubscriptionEvent` with `action` set to `"snapshot"` containing the current manager instance, then yields `SubscriptionEvent`s for each subsequent action. For subsequent events, `item` will be the re-instantiated manager instance or `None` if instantiation fails. The subscriber is registered on the manager's channel groups (including dependent managers' groups) and the channel subscriptions and background listener are cleaned up when the iterator is closed or cancelled.
-
-            Parameters:
-                identification: Identification fields required to locate the manager instance (maps to the manager's identification signature).
-
-            Returns:
-                AsyncIterator[SubscriptionEvent]: An asynchronous iterator that first yields a snapshot event and then yields update events; each event's `item` is the manager instance or `None` if it could not be instantiated.
+            Authorize the request user before property priming and registration.
+            Recheck access before each event; unavailable or unreadable targets
+            end the iterator without forwarding the queued action. Closing the
+            iterator removes its listeners and channel memberships.
             """
             identification_copy = deepcopy(identification)
             property_names = cls._subscription_property_names(info, generalManagerClass)
+            subscription_user = info.context.user
             try:
-                instance, dependency_records = await asyncio.to_thread(
-                    cls._instantiate_manager,
+                prepared = await asyncio.to_thread(
+                    cls._prepare_detail_subscription,
                     generalManagerClass,
                     identification_copy,
-                    collect_dependencies=True,
+                    subscription_user,
                     property_names=property_names,
                 )
             except Exception as exc:  # pragma: no cover - bubbled to GraphQL
                 raise GraphQLError(str(exc)) from exc
 
+            if prepared is None:
+                message = "Subscription target is unavailable or not readable."
+                raise GraphQLError(message)
+            instance, dependency_records = prepared
+
             try:
                 channel_layer = cast(
                     BaseChannelLayer, cls._get_channel_layer(strict=True)
@@ -2498,15 +2533,16 @@ class GraphQL:
                 group_names.add(cls._refresh_group_name(dependency_class))
 
             async def event_stream() -> AsyncIterator[SubscriptionEvent]:
-                """
-                Yield subscription events for a manager instance, starting with an initial snapshot followed by subsequent updates.
-
-                Returns:
-                    AsyncIterator[SubscriptionEvent]: An asynchronous iterator that first yields a `SubscriptionEvent` with `action` set to `"snapshot"` and `item` containing the current manager instance (or `None` if instantiation failed). Subsequent yields provide `SubscriptionEvent` values for each received action, where `action` is the action string and `item` is the (re-)instantiated manager or `None` if instantiation failed.
-
-                Notes:
-                    When the iterator is closed or exits, the background listener task is cancelled and the subscription's channel group memberships are discarded.
-                """
+                """Deliver authorized events and clean up on every exit path."""
+                # The iterator may be consumed long after subscribe() returns.
+                prepared = await asyncio.to_thread(
+                    cls._prepare_detail_subscription,
+                    generalManagerClass,
+                    identification_copy,
+                    subscription_user,
+                )
+                if prepared is None:
+                    return
                 channel_name = cast(str, await channel_layer.new_channel())
                 queue: asyncio.Queue[str] = asyncio.Queue[str]()
                 joined_groups = await _join_subscription_groups(
@@ -2523,19 +2559,29 @@ class GraphQL:
                     joined_groups,
                     listener_task,
                 ):
+                    # Group registration awaits I/O; access can change meanwhile.
+                    prepared = await asyncio.to_thread(
+                        cls._prepare_detail_subscription,
+                        generalManagerClass,
+                        identification_copy,
+                        subscription_user,
+                    )
+                    if prepared is None:
+                        return
+                    item, _ = prepared
                     clear_capability_context(info)
-                    yield SubscriptionEvent(item=instance, action="snapshot")
+                    yield SubscriptionEvent(item=item, action="snapshot")
                     while True:
                         action = await queue.get()
-                        try:
-                            item, _ = await asyncio.to_thread(
-                                cls._instantiate_manager,
-                                generalManagerClass,
-                                identification_copy,
-                                property_names=property_names,
-                            )
-                        except SUBSCRIPTION_HYDRATION_ERRORS:
-                            item = None
+                        prepared = await asyncio.to_thread(
+                            cls._prepare_detail_subscription,
+                            generalManagerClass,
+                            identification_copy,
+                            subscription_user,
+                        )
+                        if prepared is None:
+                            return
+                        item, _ = prepared
                         clear_capability_context(info)
                         yield SubscriptionEvent(item=item, action=action)
 

{generalmanager-0.86.0 → generalmanager-0.86.2}/src/general_manager/cache/data_change_context.py

@@ -162,3 +162,44 @@ def may_reuse_data_change_transaction(database_alias: str) -> bool:
         and not owner.caller_in_atomic_block
         and is_data_change_operation_authorized(database_alias)
     )
+
+
+@dataclass
+class DataChangeOutcome:
+    """Private per-call outcome; unknown/custom mutations remain changes."""
+
+    interface: object
+    unchanged: bool = False
+
+
+_operation_outcome: ContextVar[DataChangeOutcome | None] = ContextVar(
+    "data_change_operation_outcome", default=None
+)
+
+
+@contextmanager
+def suspend_data_change_outcome() -> Iterator[None]:
+    """Keep nested signal/lifecycle receivers outside their parent's outcome."""
+    token = _operation_outcome.set(None)
+    try:
+        yield
+    finally:
+        _operation_outcome.reset(token)
+
+
+@contextmanager
+def capture_data_change_outcome(interface: object) -> Iterator[DataChangeOutcome]:
+    """Isolate the wrapped operation from pre-signals and nested mutations."""
+    outcome = DataChangeOutcome(interface)
+    token = _operation_outcome.set(outcome)
+    try:
+        yield outcome
+    finally:
+        _operation_outcome.reset(token)
+
+
+def mark_data_change_unchanged(interface: object) -> None:
+    """Accept a proven no-op only for the interface owned by this call."""
+    outcome = _operation_outcome.get()
+    if outcome is not None and outcome.interface is interface:
+        outcome.unchanged = True

{generalmanager-0.86.0 → generalmanager-0.86.2}/src/general_manager/cache/signals.py

@@ -15,8 +15,10 @@ from django.utils.connection import ConnectionDoesNotExist
 from general_manager.cache.data_change_context import (
     DataChangeTransactionScope,
     authorize_data_change_operation,
+    capture_data_change_outcome,
     own_data_change_transaction,
     record_data_change_phase,
+    suspend_data_change_outcome,
 )
 from general_manager.as_of import reject_historical_mutation
 from general_manager.logging import get_logger
@@ -66,7 +68,9 @@ def data_change(
     clears run-scoped ORM bucket/index caches, emits `pre_data_change`, invokes
     the wrapped callable, then emits `post_data_change` with the changed
     instance, previous instance, action name, identification, and copied
-    `_old_values` payload. Both signals receive a per-call `change_context` and
+    `_old_values` payload. Proven unchanged built-in ORM updates skip only the
+    post-change signal; pre-change preparation and transaction cleanup still run.
+    Both signals receive a per-call `change_context` and
     the manager interface's database alias. ORM-backed signal dispatch and the
     mutation share one transaction. GraphQL warm-up requeue keys collected
     during signal handling are drained only after the outermost active
@@ -101,6 +105,7 @@ def data_change(
     )
 
     @wraps(decorator_source)
+    @suspend_data_change_outcome()
     def perform_change(*args: P.args, **kwargs: P.kwargs) -> R:
         """
         Emit pre_data_change and post_data_change signals around the wrapped function call.
@@ -252,7 +257,12 @@ def data_change(
                     if is_orm_backed
                     else nullcontext()
                 )
-                with operation_context:
+                with (
+                    operation_context,
+                    capture_data_change_outcome(
+                        getattr(instance_before, "_interface", None)
+                    ) as outcome,
+                ):
                     mutation_started = (
                         perf_counter() if transaction_scope is not None else None
                     )
@@ -282,15 +292,16 @@ def data_change(
                 if identification is None:
                     identification = pre_identification
 
-                post_data_change.send(
-                    sender=sender,
-                    instance=instance,
-                    previous_instance=instance_before,
-                    identification=identification,
-                    action=action,
-                    old_relevant_values=old_relevant_values,
-                    **signal_kwargs,
-                )
+                if not outcome.unchanged:
+                    post_data_change.send(
+                        sender=sender,
+                        instance=instance,
+                        previous_instance=instance_before,
+                        identification=identification,
+                        action=action,
+                        old_relevant_values=old_relevant_values,
+                        **signal_kwargs,
+                    )
                 if instance_before is not None:
                     try:
                         delattr(instance_before, "_old_values")

{generalmanager-0.86.0 → generalmanager-0.86.2}/src/general_manager/interface/capabilities/orm/mutations.py

@@ -11,7 +11,10 @@ from django.contrib.auth import get_user_model
 from django.db import DEFAULT_DB_ALIAS, models, router, transaction
 from django.db.models import NOT_PROVIDED
 
-from general_manager.cache.data_change_context import owns_data_change_transaction
+from general_manager.cache.data_change_context import (
+    mark_data_change_unchanged,
+    owns_data_change_transaction,
+)
 from general_manager.interface.capabilities.base import CapabilityName
 from general_manager.interface.capabilities.builtin import BaseCapability
 from general_manager.interface.capabilities.orm_utils.payload_normalizer import (
@@ -20,6 +23,7 @@ from general_manager.interface.capabilities.orm_utils.payload_normalizer import
 from general_manager.interface.capabilities.orm_utils.update_state import (
     changed_many_to_many,
     is_unchanged_update,
+    record_skipped_update_save,
     track_update,
 )
 from general_manager.interface.utils.database_interface_protocols import (
@@ -225,6 +229,7 @@ class OrmMutationCapability(BaseCapability):
                     object.__setattr__(instance, "changed_by_id", creator_id)
                 instance.full_clean()
                 if is_unchanged_update(instance):
+                    record_skipped_update_save(instance)
                     return instance.pk
                 if batch is not None and database_alias is None:
                     if (
@@ -606,7 +611,7 @@ class OrmUpdateCapability(BaseCapability):
                     changed_many,
                     history_comment,
                     database_alias=database_alias,
-                ):
+                ) as update_state:
                     instance = mutation.assign_simple_attributes(
                         interface_instance.__class__, instance, normalized_simple
                     )
@@ -624,6 +629,32 @@ class OrmUpdateCapability(BaseCapability):
                     history_comment=history_comment,
                 )
             discard_orm_instance_cache(interface_instance.__class__, pk)
+            if update_state is not None and update_state.save_skipped:
+                # A custom wrapper may write after delegating to a built-in
+                # method. Only the complete standard path can prove a no-op.
+                from general_manager.interface.base_interface import InterfaceBase
+
+                standard_methods = (
+                    (interface_instance.update, InterfaceBase.update),
+                    (self.update, OrmUpdateCapability.update),
+                    (
+                        mutation.assign_simple_attributes,
+                        OrmMutationCapability.assign_simple_attributes,
+                    ),
+                    (
+                        mutation.save_with_history,
+                        OrmMutationCapability.save_with_history,
+                    ),
+                    (
+                        mutation.apply_many_to_many,
+                        OrmMutationCapability.apply_many_to_many,
+                    ),
+                )
+                if all(
+                    getattr(method, "__func__", None) is standard
+                    for method, standard in standard_methods
+                ):
+                    mark_data_change_unchanged(interface_instance)
             return {"id": pk}
 
         return call_with_observability(

{generalmanager-0.86.0 → generalmanager-0.86.2}/src/general_manager/interface/capabilities/orm_utils/update_state.py

@@ -16,10 +16,11 @@ from django.db.models.fields.files import FieldFile
 from general_manager.measurement.measurement_field import MeasurementField
 
 
-@dataclass(frozen=True)
+@dataclass
 class _UpdateState:
     instance: models.Model
     values: dict[str, object]
+    save_skipped: bool = False
 
 
 _update_state: ContextVar[_UpdateState | None] = ContextVar(
@@ -47,7 +48,7 @@ def track_update(
     history_comment: str | None,
     *,
     database_alias: str | None = None,
-) -> Iterator[None]:
+) -> Iterator[_UpdateState | None]:
     """Scope the original row to its save, including nested mutation calls.
 
     The save compares after full_clean(), so validation and changes made by
@@ -85,7 +86,7 @@ def track_update(
             state = _UpdateState(instance, values)
     token = _update_state.set(state)
     try:
-        yield
+        yield state
     finally:
         _update_state.reset(token)
 
@@ -107,6 +108,13 @@ def is_unchanged_update(instance: models.Model) -> bool:
     return True
 
 
+def record_skipped_update_save(instance: models.Model) -> None:
+    """Record the built-in save decision without classifying custom wrappers."""
+    state = _update_state.get()
+    if state is not None and state.instance is instance:
+        state.save_skipped = True
+
+
 def changed_many_to_many(
     instance: models.Model,
     values: dict[str, list[object]],

{generalmanager-0.86.0 → generalmanager-0.86.2}/src/general_manager/workflow/signal_bridge.py

@@ -29,6 +29,8 @@ _WORKFLOW_SIGNAL_BRIDGE_KEY = "WORKFLOW_SIGNAL_BRIDGE"
 _DISPATCH_UID = "general_manager_workflow_signal_bridge"
 
 _RESERVED_KEYS = {
+    "change_context",
+    "database_alias",
     "creator_id",
     "history_comment",
     "identification",
@@ -88,8 +90,8 @@ def _manager_change_to_event(
         for key, value in kwargs.items()
         if key not in _RESERVED_KEYS and not key.startswith("_")
     }
-    if action in {"create", "update"} and not relevant_fields:
-        return None
+    # The mutation outcome controls no-op suppression. Empty input can still
+    # create defaults, change values in clean(), or request an audit touch.
 
     identification = kwargs.get("identification")
     if identification is None: