GeneralManager 0.82.0__tar.gz → 0.82.2__tar.gz

{generalmanager-0.82.0/src/GeneralManager.egg-info → generalmanager-0.82.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.82.0
+Version: 0.82.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.82.0 → generalmanager-0.82.2}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.82.0
+Version: 0.82.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.82.0 → generalmanager-0.82.2}/src/GeneralManager.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ src/general_manager/cache/model_dependency_collector.py
 src/general_manager/cache/run_context.py
 src/general_manager/cache/run_context_lru.py
 src/general_manager/cache/signals.py
+src/general_manager/cache/transaction_barrier.py
 src/general_manager/chat/__init__.py
 src/general_manager/chat/audit.py
 src/general_manager/chat/bootstrap.py

{generalmanager-0.82.0 → generalmanager-0.82.2}/src/general_manager/api/graphql.py

@@ -38,7 +38,10 @@ from django.core.exceptions import ObjectDoesNotExist
 from django.db import DEFAULT_DB_ALIAS, models, transaction
 from django.utils.module_loading import import_string
 
-from general_manager.api.graphql_identifiers import build_identification_arguments
+from general_manager.api.graphql_identifiers import (
+    build_identification_arguments,
+    property_identifier_type,
+)
 from general_manager.bucket.base_bucket import Bucket
 from general_manager.bucket.group_bucket import GroupBucket
 from general_manager.cache.dependency_index import (
@@ -929,6 +932,20 @@ class GraphQL:
         ) in generalManagerClass.Interface.get_graph_ql_properties().items():
             raw_hint = attr_value.graphql_type_hint
 
+            if attr_value.is_identifier:
+                native_type, is_collection = property_identifier_type(
+                    raw_hint,
+                    owner_name=generalManagerClass.__name__,
+                    field_name=attr_name,
+                )
+                fields[attr_name] = (
+                    graphene.List(graphene.ID) if is_collection else graphene.ID()
+                )
+                fields[f"resolve_{attr_name}"] = cls._create_resolver(
+                    attr_name, native_type
+                )
+                continue
+
             if _contains_measurement(raw_hint):
                 mapped = map_graphql_output_annotation(
                     raw_hint,

{generalmanager-0.82.0 → generalmanager-0.82.2}/src/general_manager/api/graphql_identifiers.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from typing import cast
+from types import UnionType
+from typing import Annotated, Union, cast, get_args, get_origin
+from uuid import UUID
 
 import graphene
 from django.db import models
@@ -16,9 +18,49 @@ from general_manager.api.graphql_relations import (
     get_graphql_manager_registry,
     resolve_general_manager_type,
 )
+from general_manager.api.graphql_output import GraphQLOutputAnnotationError
 from general_manager.manager.general_manager import GeneralManager
 
 
+def property_identifier_type(
+    annotation: object, *, owner_name: str, field_name: str
+) -> tuple[type, bool]:
+    """Validate an explicit native identity hint and return its type and shape.
+
+    This shared interpretation lets output and filter builders consume the
+    descriptor's public ``is_identifier`` flag without changing its annotation
+    or the native resolver value. Optional wrappers do not add non-null output
+    constraints to legacy manager properties.
+    """
+    original_annotation = annotation
+
+    def unwrap(hint: object) -> object:
+        while get_origin(hint) is Annotated:
+            hint = get_args(hint)[0]
+        if get_origin(hint) in (Union, UnionType):
+            members = get_args(hint)
+            if len(members) == 2 and type(None) in members:
+                return unwrap(next(t for t in members if t is not type(None)))
+        return hint
+
+    annotation = unwrap(annotation)
+    origin = get_origin(annotation)
+    is_collection = origin in (list, tuple, set)
+    if is_collection:
+        elements = get_args(annotation)
+        if origin is tuple and len(elements) == 2 and elements[1] is Ellipsis:
+            elements = elements[:1]
+        if elements and (origin is tuple or len(elements) == 1):
+            native_type = unwrap(elements[0])
+            if native_type in (int, str, UUID) and all(
+                unwrap(element) is native_type for element in elements
+            ):
+                return cast(type, native_type), True
+    elif annotation in (int, str, UUID):
+        return cast(type, annotation), False
+    raise GraphQLOutputAnnotationError(owner_name, field_name, original_annotation)
+
+
 def is_orm_identifier_input(manager_class: type[GeneralManager], name: str) -> bool:
     """Identify the ORM constructor alias addressing the actual model PK."""
     model = getattr(manager_class.Interface, "_model", None)

{generalmanager-0.82.0 → generalmanager-0.82.2}/src/general_manager/api/graphql_search.py

@@ -25,6 +25,7 @@ from django.core.exceptions import FieldDoesNotExist
 from django.db import models
 
 from general_manager.conf import get_setting
+from general_manager.api.graphql_identifiers import property_identifier_type
 from general_manager.api.graphql_ordering import (
     GraphQLOrderingInputError,
     create_ordering_types,
@@ -842,12 +843,20 @@ def create_filter_options(
             continue
         hints = [t for t in get_args(prop.graphql_type_hint) if t is not type(None)]
         prop_type = hints[0] if hints else cast(type, prop.graphql_type_hint)
+        prop_info: dict[str, object] = {}
+        if prop.is_identifier:
+            prop_type, _ = property_identifier_type(
+                prop.graphql_type_hint,
+                owner_name=field_type.__name__,
+                field_name=prop_name,
+            )
+            prop_info["is_identifier"] = True
         filter_fields = {
             **filter_fields,
             **{
                 k: v
                 for k, v in get_filter_options(
-                    prop_type, prop_name, map_field_to_graphene_read
+                    prop_type, prop_name, map_field_to_graphene_read, prop_info
                 )
                 if v is not None
             },

{generalmanager-0.82.0 → generalmanager-0.82.2}/src/general_manager/api/property.py

@@ -55,7 +55,7 @@ class GraphQLPropertyTimeoutConfigurationError(ValueError):
 class GraphQLProperty(property):
     """Descriptor that exposes a resolver with GraphQL metadata and caching.
 
-    Stable inspection attributes are `sortable`, `filterable`,
+    Stable inspection attributes are `sortable`, `filterable`, `is_identifier`,
     `query_annotation`, `cache`, `timeout`, `warm_up`, and `graphql_type_hint`.
     The descriptor preserves normal `property` behavior such as `fget` and
     `__doc__`, but those values follow Python's property/wraps mechanics rather
@@ -66,6 +66,7 @@ class GraphQLProperty(property):
 
     sortable: bool
     filterable: bool
+    is_identifier: bool
     warm_up: bool
     query_annotation: object | None
     timeout: int | None
@@ -77,6 +78,7 @@ class GraphQLProperty(property):
         *,
         sortable: bool = False,
         filterable: bool = False,
+        is_identifier: bool = False,
         query_annotation: object | None = None,
         cache: GraphQLPropertyCache = "none",
         timeout: int | None = None,
@@ -101,6 +103,10 @@ class GraphQLProperty(property):
             filterable: Whether generated GraphQL fields may expose filtering
                 for this property. Stored as supplied; runtime truthiness is not
                 coerced or validated.
+            is_identifier: Declare native integer, string, or UUID identities,
+                either scalar or a homogeneous list, tuple, or set. Generates
+                GraphQL ID output without changing Python values. Unsupported
+                annotations raise TypeError during schema generation.
             query_annotation: Opaque ORM annotation object or callable consumed
                 by database bucket query construction.
             cache: Resolver cache scope. `"none"` evaluates every access,
@@ -160,6 +166,7 @@ class GraphQLProperty(property):
 
         self.sortable = sortable
         self.filterable = filterable
+        self.is_identifier = is_identifier
         self.query_annotation = query_annotation
         self.cache = cache
         self.timeout = timeout
@@ -276,6 +283,7 @@ def graph_ql_property(
     *,
     sortable: bool = False,
     filterable: bool = False,
+    is_identifier: bool = False,
     query_annotation: object | None = None,
     cache: GraphQLPropertyCache = "run",
     timeout: int | None = None,
@@ -290,6 +298,7 @@ def graph_ql_property(
     *,
     sortable: bool = False,
     filterable: bool = False,
+    is_identifier: bool = False,
     query_annotation: object | None = None,
     cache: GraphQLPropertyCache = "run",
     timeout: int | None = None,
@@ -307,6 +316,13 @@ def graph_ql_property(
             property.
         filterable: Whether generated GraphQL fields may expose filtering for
             this property.
+        is_identifier: Explicitly declare native integer, string, or UUID
+            identities. Scalars map to ID and homogeneous list, tuple, or set
+            collections to [ID], preserving nullable property output and native
+            Python values. Optional annotations and optional elements are
+            supported. Manager objects, nested collections, ambiguous unions,
+            and other scalar types raise TypeError during schema generation.
+            Names and query_annotation never infer this flag. Defaults to False.
         query_annotation: Opaque ORM annotation object or callable consumed by
             database bucket query construction.
         cache: Cache scope. `"run"` is the default and memoizes only within the
@@ -354,6 +370,7 @@ def graph_ql_property(
             sortable=sortable,
             query_annotation=query_annotation,
             filterable=filterable,
+            is_identifier=is_identifier,
             cache=cache,
             timeout=timeout,
             warm_up=warm_up,

{generalmanager-0.82.0 → generalmanager-0.82.2}/src/general_manager/cache/dependency_index.py

@@ -7,7 +7,8 @@ import random
 from threading import Event, Thread
 import time
 import uuid
-from collections.abc import Mapping
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
 from contextvars import ContextVar
 from datetime import date, datetime
 from time import perf_counter
@@ -73,6 +74,9 @@ _pending_graphql_rewarm_cache_keys: ContextVar[frozenset[str]] = ContextVar(
     "general_manager_pending_graphql_rewarm_cache_keys",
     default=frozenset(),
 )
+_dependency_rewarm_scope_depth: ContextVar[int] = ContextVar(
+    "general_manager_dependency_rewarm_scope_depth", default=0
+)
 
 
 class DependencyLockTimeoutError(TimeoutError):
@@ -118,6 +122,8 @@ DEPENDENCY_GENERATION_KEY = "dependency_index_generation"
 DATA_CHANGE_LOCK_KEY = "dependency_index_data_change_lock"
 DATA_CHANGE_COUNT_KEY = "dependency_index_data_change_count"
 DATA_CHANGE_RECOVERY_KEY = "dependency_index_data_change_recovery"
+DATA_CHANGE_OWNERS_KEY = "dependency_index_data_change_owners"
+COMMITTED_GRAPHQL_REWARM_KEY = "dependency_index_committed_graphql_rewarm"
 LOCK_TIMEOUT = 5  # Lock TTL in seconds
 UNDEFINED = object()  # Sentinel for undefined values
 ACTIONS: tuple[Literal["filter"], Literal["exclude"]] = ("filter", "exclude")
@@ -241,6 +247,15 @@ def _set_dependency_data_change_count(count: int) -> int:
     return count
 
 
+def _get_dependency_data_change_owners() -> frozenset[str]:
+    owners = cache.get(DATA_CHANGE_OWNERS_KEY, frozenset())
+    if not isinstance(owners, frozenset) or not all(
+        isinstance(owner, str) for owner in owners
+    ):
+        raise DependencyBarrierStateError("journal")
+    return owners
+
+
 def _discard_active_context_dependency_cache_state() -> None:
     from general_manager.cache.run_context import current_calculation_run_context
 
@@ -304,10 +319,21 @@ def _clear_data_change_recovery(
 
 
 def _prepare_data_change_recovery(
-    token: DependencyLockToken, count: int, flag: object
+    token: DependencyLockToken,
+    count: int,
+    flag: object,
+    owners: frozenset[str],
+    generation: int | None = None,
 ) -> dict[str, object]:
     _require_data_change_lock_owner(token)
-    recovery: dict[str, object] = {"owner": token, "count": count, "flag": flag}
+    recovery: dict[str, object] = {
+        "owner": token,
+        "count": count,
+        "flag": flag,
+        "owners": owners,
+    }
+    if generation is not None:
+        recovery["generation"] = generation
     cache.set(DATA_CHANGE_RECOVERY_KEY, recovery, None)
     _verify_data_change_cache_value(DATA_CHANGE_RECOVERY_KEY, recovery)
     return recovery
@@ -321,6 +347,24 @@ def _recover_data_change_barrier(token: DependencyLockToken) -> None:
     # previous snapshot never overwrites a later operation's active barrier.
     if not isinstance(recovery, dict) or not isinstance(recovery.get("count"), int):
         raise DependencyBarrierStateError("journal")
+    generation = recovery.get("generation")
+    if generation is not None:
+        if not isinstance(generation, int):
+            raise DependencyBarrierStateError("journal")
+        _require_data_change_lock_owner(token)
+        generation = max(get_dependency_generation(), generation)
+        _set_dependency_generation(generation)
+        _verify_data_change_cache_value(DEPENDENCY_GENERATION_KEY, generation)
+    # Older journals have no owner set. Retain compatibility with #519 recovery.
+    if "owners" in recovery:
+        owners = recovery["owners"]
+        if not isinstance(owners, frozenset) or not all(
+            isinstance(owner, str) for owner in owners
+        ):
+            raise DependencyBarrierStateError("journal")
+        _require_data_change_lock_owner(token)
+        cache.set(DATA_CHANGE_OWNERS_KEY, owners, None)
+        _verify_data_change_cache_value(DATA_CHANGE_OWNERS_KEY, owners)
     _require_data_change_lock_owner(token)
     count = recovery["count"]
     _set_dependency_data_change_count(count)
@@ -359,7 +403,7 @@ def _release_data_change_lock(token: DependencyLockToken) -> None:
         logger.exception("dependency data-change mutex release failed")
 
 
-def begin_dependency_data_change() -> int:
+def begin_dependency_data_change(*, owner: str | None = None) -> int:
     """Open a publish barrier, preserving a recoverable pre-begin snapshot.
 
     Failed starts restore only their own count/flag under the mutex. If cleanup
@@ -375,8 +419,11 @@ def begin_dependency_data_change() -> int:
         _recover_data_change_barrier(lock_token)
         count = _get_dependency_data_change_count()
         flag = cache.get(DATA_CHANGE_LOCK_KEY)
-        recovery = {"owner": lock_token, "count": count, "flag": flag}
-        _prepare_data_change_recovery(lock_token, count, flag)
+        owners = _get_dependency_data_change_owners()
+        if owner is not None and owner in owners:
+            return get_dependency_generation()
+        recovery = {"owner": lock_token, "count": count, "flag": flag, "owners": owners}
+        _prepare_data_change_recovery(lock_token, count, flag, owners)
         _require_data_change_lock_owner(lock_token)
         generation = _set_dependency_generation(get_dependency_generation() + 1)
         _verify_data_change_cache_value(DEPENDENCY_GENERATION_KEY, generation)
@@ -386,6 +433,10 @@ def begin_dependency_data_change() -> int:
         _require_data_change_lock_owner(lock_token)
         cache.set(DATA_CHANGE_LOCK_KEY, "1", None)
         _verify_data_change_cache_value(DATA_CHANGE_LOCK_KEY, "1")
+        if owner is not None:
+            _require_data_change_lock_owner(lock_token)
+            cache.set(DATA_CHANGE_OWNERS_KEY, owners | {owner}, None)
+            _verify_data_change_cache_value(DATA_CHANGE_OWNERS_KEY, owners | {owner})
         _discard_active_context_dependency_cache_state()
         _clear_data_change_recovery(lock_token, recovery)
     except Exception:
@@ -400,18 +451,35 @@ def begin_dependency_data_change() -> int:
     return generation
 
 
-def end_dependency_data_change() -> None:
-    """Close one barrier, journaling its completed operation for forward recovery."""
+def end_dependency_data_change(*, owner: str | None = None) -> None:
+    """Fence in-flight calculations and close one barrier with forward recovery.
+
+    Owned ends are idempotent, including when cache writes applied then raised.
+    A retry completes the journal before checking ownership, so it cannot
+    decrement another transaction's barrier.
+    """
     if isinstance(caches["default"], DummyCache):
         return
     lock_token = acquire_lock_with_retry("end_dependency_data_change")
     recovery: dict[str, object] | None = None
     try:
         _recover_data_change_barrier(lock_token)
+        owners = _get_dependency_data_change_owners()
+        if owner is not None and owner not in owners:
+            return
+        if owner is not None:
+            owners = owners - {owner}
         count = max(_get_dependency_data_change_count() - 1, 0)
         flag = "1" if count else None
-        recovery = {"owner": lock_token, "count": count, "flag": flag}
-        _prepare_data_change_recovery(lock_token, count, flag)
+        generation = get_dependency_generation() + 1
+        recovery = {
+            "owner": lock_token,
+            "count": count,
+            "flag": flag,
+            "owners": owners,
+            "generation": generation,
+        }
+        _prepare_data_change_recovery(lock_token, count, flag, owners, generation)
         _recover_data_change_barrier(lock_token)
     except Exception:
         if recovery is not None:
@@ -449,6 +517,50 @@ def drain_invalidated_cache_keys_for_graphql_rewarm() -> tuple[str, ...]:
     return cache_keys
 
 
+def record_committed_graphql_rewarm_keys(cache_keys: Iterable[str]) -> None:
+    """Share committed work with the process that closes the final barrier."""
+    keys = frozenset(cache_keys)
+    if not keys:
+        return
+    token = acquire_lock_with_retry("record_committed_graphql_rewarm_keys")
+    try:
+        existing = cache.get(COMMITTED_GRAPHQL_REWARM_KEY, frozenset())
+        cache.set(COMMITTED_GRAPHQL_REWARM_KEY, existing | keys, None)
+    finally:
+        release_lock(token)
+
+
+def drain_committed_graphql_rewarm_keys() -> tuple[str, ...]:
+    """Claim committed keys only when no writer is pausing publication."""
+    if not cache.get(COMMITTED_GRAPHQL_REWARM_KEY):
+        return ()
+    token = acquire_lock_with_retry("drain_committed_graphql_rewarm_keys")
+    try:
+        if is_dependency_data_change_active():
+            return ()
+        keys = tuple(sorted(cache.get(COMMITTED_GRAPHQL_REWARM_KEY, frozenset())))
+        cache.delete(COMMITTED_GRAPHQL_REWARM_KEY)
+        return keys
+    finally:
+        release_lock(token)
+
+
+@contextmanager
+def dependency_rewarm_scope() -> Iterator[None]:
+    """Isolate a mutation's keys from enclosing writes on other connections."""
+    depth = _dependency_rewarm_scope_depth.get()
+    scope_token = _dependency_rewarm_scope_depth.set(depth + 1)
+    token = _pending_graphql_rewarm_cache_keys.set(frozenset()) if depth else None
+    try:
+        yield
+    finally:
+        if token is not None:
+            remaining = _pending_graphql_rewarm_cache_keys.get()
+            _pending_graphql_rewarm_cache_keys.reset(token)
+            record_invalidated_cache_keys_for_graphql_rewarm(remaining)
+        _dependency_rewarm_scope_depth.reset(scope_token)
+
+
 def acquire_lock_with_retry(operation: str) -> DependencyLockToken:
     """
     Acquire the dependency index lock, retrying with exponential backoff.

{generalmanager-0.82.0 → generalmanager-0.82.2}/src/general_manager/cache/signals.py

@@ -123,6 +123,11 @@ def data_change(
             is_dependency_data_change_active,
         )
         from general_manager.cache.run_context import current_calculation_run_context
+        from general_manager.cache.transaction_barrier import (
+            collect_transaction_rewarm_keys,
+            flush_transaction_rewarm_keys,
+            hold_dependency_transaction_barrier,
+        )
         from general_manager.interface.orm_interface import OrmInterfaceBase
         from general_manager.manager.bulk_create import (
             CreateManyUnsupportedError,
@@ -179,6 +184,8 @@ def data_change(
         transaction_outcome = "rolled_back"
         begin_dependency_data_change()
         try:
+            if is_orm_backed:
+                hold_dependency_transaction_barrier(database_alias)
             context = current_calculation_run_context()
             if context is not None:
                 context.clear_orm_bucket_results()
@@ -294,6 +301,8 @@ def data_change(
                         sender=sender,
                         **lifecycle_kwargs,
                     )
+                if is_orm_backed:
+                    collect_transaction_rewarm_keys(database_alias, completed=True)
             if transaction_scope is not None and transaction_scope.is_outermost:
                 transaction_outcome = "committed"
             completed = True
@@ -333,8 +342,15 @@ def data_change(
                     raise
             finally:
                 try:
+                    collected = is_orm_backed and collect_transaction_rewarm_keys(
+                        database_alias, completed=completed
+                    )
                     if not is_dependency_data_change_active():
-                        cache_keys = drain_invalidated_cache_keys_for_graphql_rewarm()
+                        if not collected:
+                            cache_keys = (
+                                drain_invalidated_cache_keys_for_graphql_rewarm()
+                            )
+                        flush_transaction_rewarm_keys()
                 except Exception:
                     if primary_exc is not None:
                         logger.exception(
@@ -355,9 +371,10 @@ def data_change(
 
     @wraps(decorator_source)
     def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        from general_manager.cache.dependency_index import dependency_rewarm_scope
         from general_manager.manager.bulk_create import create_many_signal_scope
 
-        with create_many_signal_scope():
+        with create_many_signal_scope(), dependency_rewarm_scope():
             return perform_change(*args, **kwargs)
 
     return wrapper