GeneralManager 0.87.3__tar.gz → 0.87.5__tar.gz

{generalmanager-0.87.3/src/GeneralManager.egg-info → generalmanager-0.87.5}/PKG-INFO

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

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

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

@@ -952,6 +952,10 @@ class GraphQL:
                 raw_hint,
                 cls.manager_registry,
             )
+            is_generated_relation = (
+                getattr(attr_value, "_general_manager_generated_relation", False)
+                is True
+            )
             property_page_hint = raw_hint
             if get_origin(property_page_hint) in {Union, UnionType}:
                 non_none_hints = [
@@ -1068,13 +1072,27 @@ class GraphQL:
                     )
                     or resolved_type
                 )
-                graphene_field = cls._map_field_to_graphene_read(
-                    resolved_type, attr_name
-                )
+                if property_relation_manager is not None and not is_generated_relation:
+                    graphene_field = graphene.Field(
+                        lambda manager=property_relation_manager: cls.graphql_type_registry[
+                            manager.__name__
+                        ]
+                    )
+                else:
+                    graphene_field = cls._map_field_to_graphene_read(
+                        resolved_type, attr_name
+                    )
 
             fields[attr_name] = graphene_field
-            fields[f"resolve_{attr_name}"] = cls._create_resolver(
-                attr_name, resolved_type
+            # Native property values follow their annotations. Generated reverse
+            # relations retain their paginated resolver despite a manager hint.
+            fields[f"resolve_{attr_name}"] = (
+                _create_normal_resolver_fn(
+                    attr_name,
+                    authorize_manager_collection=origin in (list, tuple, set),
+                )
+                if property_relation_manager is not None and not is_generated_relation
+                else cls._create_resolver(attr_name, resolved_type)
             )
 
         capability_declarations = get_graphql_capabilities(generalManagerClass)

{generalmanager-0.87.3 → generalmanager-0.87.5}/src/general_manager/api/graphql_resolvers.py

@@ -1591,14 +1591,19 @@ def create_list_resolver(
     ``base_queryset._manager_class`` when that is a GeneralManager subclass,
     otherwise using ``fallback_manager_class``. That manager class drives
     permission checks, filter normalization, dependency prefetching, and
-    capability warmups. For non-calculation managers, the resolver applies
+    capability warmups. For non-calculation, non-request sources, the resolver applies
     permission prefilters and the permission row gate before all user-supplied
-    query predicates. For calculation managers, it applies input predicates
-    before authorization to limit generated candidates, fences that exact
-    candidate subset before permission prefilters, then applies deferred
-    computed-property predicates afterward. Permission constraints can only
-    narrow the user-selected input domain. Grouping, sorting, and pagination
-    remain after those predicate phases. Sorting therefore applies to records
+    query predicates. For calculation managers, it also applies authorization
+    first. When query operands are present, it fences the authorized rows as
+    an exact subset, then applies declared-input predicates followed by
+    computed-property predicates. User input filters cannot reintroduce rows
+    outside the authorized subset. Request-backed sources are different:
+    unless the permission plan denies all rows, user predicates are applied
+    to ``base_queryset`` before that filtered source is authorized. The earlier
+    query-field permission check uses a separate authorized subset and does
+    not constrain ``base_queryset``. Supported remote ordering and pagination
+    controls may be forwarded during request-source preparation. Grouping,
+    local sorting, and local pagination follow source preparation. Sorting applies to records
     when grouping is omitted and to grouped manager objects when grouping is
     active. It computes ``total_count`` after grouping and sorting and before
     pagination. Non-grouped page items are

{generalmanager-0.87.3 → generalmanager-0.87.5}/src/general_manager/rule/rule.py

@@ -6,10 +6,13 @@ import inspect
 import re
 import textwrap
 from collections.abc import Container, Iterable, Mapping, Sequence, Sized
+from contextvars import ContextVar
 from operator import eq, ge, gt, le, lt, ne
 from typing import Callable, Dict, Generic, List, Optional, Tuple, TypeVar, cast
 from decimal import Decimal
 from types import CodeType
+from threading import RLock
+from weakref import WeakKeyDictionary
 
 from django.core.exceptions import NON_FIELD_ERRORS
 from django.utils.module_loading import import_string
@@ -50,6 +53,17 @@ _REVERSED_COMPARISON_OPS: dict[type[ast.cmpop], type[ast.cmpop]] = {
 _ERROR_TEMPLATE_PLACEHOLDER = re.compile(r"{([^{}]*)}")
 
 
+class _EvaluationToken:
+    """Identify one immutable evaluation state within an execution context."""
+
+
+# Values contain no candidate or rule references, so a context cannot root a
+# dynamic rule/class graph. Sharding limits copy-on-write to one rule bucket.
+_rule_tokens: tuple[
+    ContextVar[WeakKeyDictionary[object, _EvaluationToken] | None], ...
+] = tuple(ContextVar(f"rule_tokens_{index}", default=None) for index in range(64))
+
+
 class NonexistentAttributeError(AttributeError):
     """Raised when a referenced attribute does not exist on the GeneralManager instance."""
 
@@ -135,9 +149,6 @@ class Rule(Generic[GeneralManagerType]):
     _func: Callable[[GeneralManagerType], bool]
     _custom_error_message: Optional[str]
     _ignore_if_none: bool
-    _last_result: Optional[bool]
-    _last_input: Optional[GeneralManagerType]
-    _last_args: Dict[str, object]
     _param_names: Tuple[str, ...]
     _primary_param: Optional[str]
     _tree: ast.AST
@@ -162,9 +173,10 @@ class Rule(Generic[GeneralManagerType]):
         self._func = func
         self._custom_error_message = custom_error_message
         self._ignore_if_none = ignore_if_none
-        self._last_result = None
-        self._last_input = None
-        self._last_args = {}
+        self._evaluation_states: WeakKeyDictionary[
+            _EvaluationToken, tuple[Optional[bool], object, Dict[str, object]]
+        ] = WeakKeyDictionary()
+        self._evaluation_lock = RLock()
 
         parameters = inspect.signature(func).parameters
         self._param_names = tuple(parameters.keys())
@@ -231,6 +243,49 @@ class Rule(Generic[GeneralManagerType]):
             },
         )
 
+    def _state(self) -> tuple[Optional[bool], object, Dict[str, object]]:
+        """Read the last state for this rule in the current context."""
+        token_context = _rule_tokens[hash(self) % len(_rule_tokens)]
+        tokens = token_context.get()
+        token = tokens.get(self) if tokens is not None else None
+        if token is None:
+            return (None, None, {})
+        with self._evaluation_lock:
+            return self._evaluation_states.get(token, (None, None, {}))
+
+    def _set_state(
+        self, state: tuple[Optional[bool], object, Dict[str, object]]
+    ) -> None:
+        """Publish a new state without modifying inherited task contexts."""
+        token_context = _rule_tokens[hash(self) % len(_rule_tokens)]
+        previous = token_context.get()
+        tokens = previous.copy() if previous is not None else WeakKeyDictionary()
+        token = _EvaluationToken()
+        with self._evaluation_lock:
+            self._evaluation_states[token] = state
+        tokens[self] = token
+        token_context.set(tokens)
+
+    @property
+    def _last_result(self) -> Optional[bool]:
+        """Return the result in the current execution context."""
+        return self._state()[0]
+
+    @_last_result.setter
+    def _last_result(self, value: Optional[bool]) -> None:
+        _, candidate, args = self._state()
+        self._set_state((value, candidate, args))
+
+    @property
+    def _last_input(self) -> Optional[GeneralManagerType]:
+        """Return the input in the current execution context."""
+        return cast(Optional[GeneralManagerType], self._state()[1])
+
+    @property
+    def _last_args(self) -> Dict[str, object]:
+        """Return the arguments in the current execution context."""
+        return self._state()[2]
+
     @property
     def func(self) -> Callable[[GeneralManagerType], bool]:
         return self._func
@@ -454,11 +509,9 @@ class Rule(Generic[GeneralManagerType]):
         Returns:
             `True` if the predicate evaluates to true, `False` if it evaluates to false, `None` if evaluation was skipped because a referenced value was `None` and `ignore_if_none` is enabled.
         """
-        self._last_result = None
-        self._last_input = x
-        self._last_args = {}
-        if self._primary_param is not None:
-            self._last_args[self._primary_param] = x
+        self._set_state(
+            (None, x, {self._primary_param: x} if self._primary_param else {})
+        )
 
         logger.debug(
             "evaluating rule",
@@ -483,8 +536,9 @@ class Rule(Generic[GeneralManagerType]):
             )
             return None
 
-        self._last_result = self._func(x)
-        if self._last_result:
+        result = self._func(x)
+        self._last_result = result
+        if result:
             logger.debug(
                 "rule evaluation passed",
                 context={
@@ -501,7 +555,7 @@ class Rule(Generic[GeneralManagerType]):
                     "variables": self._variables,
                 },
             )
-        return self._last_result
+        return result
 
     def _parse_custom_error_paths(self) -> dict[str, tuple[str, ...]]:
         """Parse and validate placeholder syntax in the custom error message."""