GeneralManager 0.64.1__tar.gz → 0.64.2__tar.gz

{generalmanager-0.64.1/src/GeneralManager.egg-info → generalmanager-0.64.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.64.1
+Version: 0.64.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.64.1 → generalmanager-0.64.2}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.64.1
+Version: 0.64.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.64.2/src/general_manager/api/graphql_relations.py

@@ -0,0 +1,180 @@
+"""Resolve manager targets from GraphQL relation annotations."""
+
+from __future__ import annotations
+
+import ast
+from collections.abc import Mapping
+from types import UnionType
+from typing import ForwardRef, Union, get_args, get_origin
+
+from general_manager.bucket.base_bucket import Bucket
+from general_manager.manager.general_manager import GeneralManager
+from general_manager.utils.type_checks import safe_issubclass
+
+
+def get_graphql_manager_registry() -> dict[str, type[GeneralManager]]:
+    """Return the live GraphQL manager registry without an import-time cycle."""
+    from general_manager.api.graphql import GraphQL
+
+    return GraphQL.manager_registry
+
+
+def resolve_general_manager_type(
+    declared_type: object,
+    manager_registry: Mapping[str, type[GeneralManager]] | None = None,
+) -> type[GeneralManager] | None:
+    """Return the single manager target represented by ``declared_type``.
+
+    Concrete manager classes, interface model classes carrying a manager
+    back-reference, supported collection annotations, optional unions, and
+    postponed string forms of those annotations are recognized. Ambiguous
+    annotations containing multiple manager targets return ``None``.
+    """
+    registry = manager_registry or {}
+    resolved = _collect_general_manager_types(declared_type, registry, set())
+    if len(resolved) != 1:
+        return None
+    return next(iter(resolved))
+
+
+def _collect_general_manager_types(
+    declared_type: object,
+    manager_registry: Mapping[str, type[GeneralManager]],
+    seen: set[int],
+) -> set[type[GeneralManager]]:
+    value_id = id(declared_type)
+    if value_id in seen:
+        return set()
+    seen.add(value_id)
+
+    if safe_issubclass(declared_type, GeneralManager):
+        return {declared_type}
+
+    related_manager_type = getattr(declared_type, "_general_manager_class", None)
+    if safe_issubclass(related_manager_type, GeneralManager):
+        return {related_manager_type}
+
+    if isinstance(declared_type, ForwardRef):
+        declared_type = declared_type.__forward_arg__
+    if isinstance(declared_type, str):
+        manager_type = manager_registry.get(declared_type)
+        if manager_type is not None:
+            return {manager_type}
+        return _collect_string_general_manager_types(
+            declared_type,
+            manager_registry,
+            set(),
+        )
+
+    origin = get_origin(declared_type)
+    if origin is None:
+        return set()
+    if origin not in {list, tuple, set, Union, UnionType} and not safe_issubclass(
+        origin, Bucket
+    ):
+        return set()
+
+    manager_types: set[type[GeneralManager]] = set()
+    for argument in get_args(declared_type):
+        if argument is None or argument is type(None) or argument is Ellipsis:
+            continue
+        manager_types.update(
+            _collect_general_manager_types(argument, manager_registry, seen)
+        )
+    return manager_types
+
+
+_SUPPORTED_STRING_WRAPPERS = {
+    "Bucket",
+    "List",
+    "Optional",
+    "Set",
+    "Tuple",
+    "Union",
+    "list",
+    "set",
+    "tuple",
+}
+
+
+def _collect_string_general_manager_types(
+    annotation: str,
+    manager_registry: Mapping[str, type[GeneralManager]],
+    seen: set[str],
+) -> set[type[GeneralManager]]:
+    expression = annotation.strip()
+    if not expression or expression in seen:
+        return set()
+    seen.add(expression)
+
+    try:
+        node = ast.parse(expression, mode="eval").body
+    except (SyntaxError, ValueError):
+        return set()
+    return _collect_annotation_node_manager_types(node, manager_registry, seen)
+
+
+def _collect_annotation_node_manager_types(
+    node: ast.expr,
+    manager_registry: Mapping[str, type[GeneralManager]],
+    seen: set[str],
+) -> set[type[GeneralManager]]:
+    if isinstance(node, ast.Name):
+        manager_type = manager_registry.get(node.id)
+        return {manager_type} if manager_type is not None else set()
+
+    if isinstance(node, ast.Constant):
+        if isinstance(node.value, str):
+            return _collect_string_general_manager_types(
+                node.value,
+                manager_registry,
+                seen,
+            )
+        return set()
+
+    if isinstance(node, ast.Subscript):
+        wrapper_name = _annotation_node_name(node.value)
+        if wrapper_name is None or wrapper_name.rsplit(".", 1)[-1] not in (
+            _SUPPORTED_STRING_WRAPPERS
+        ):
+            return set()
+        return _collect_annotation_node_manager_types(
+            node.slice,
+            manager_registry,
+            seen,
+        )
+
+    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
+        return _collect_annotation_node_manager_types(
+            node.left,
+            manager_registry,
+            seen,
+        ) | _collect_annotation_node_manager_types(
+            node.right,
+            manager_registry,
+            seen,
+        )
+
+    if isinstance(node, ast.Tuple):
+        manager_types: set[type[GeneralManager]] = set()
+        for element in node.elts:
+            manager_types.update(
+                _collect_annotation_node_manager_types(
+                    element,
+                    manager_registry,
+                    seen,
+                )
+            )
+        return manager_types
+
+    return set()
+
+
+def _annotation_node_name(node: ast.expr) -> str | None:
+    if isinstance(node, ast.Name):
+        return node.id
+    if isinstance(node, ast.Attribute):
+        parent_name = _annotation_node_name(node.value)
+        if parent_name is not None:
+            return f"{parent_name}.{node.attr}"
+    return None

{generalmanager-0.64.1 → generalmanager-0.64.2}/src/general_manager/rule/rule.py

@@ -311,10 +311,15 @@ class Rule(Generic[GeneralManagerType]):
         Returns:
             dict[str, str] | None: Mapping keyed by referenced variables or
             Django's `NON_FIELD_ERRORS` fallback when no variables are available;
-            `None` if the predicate passed or was not evaluated.
+            `None` if the predicate passed, was skipped, or has not been evaluated.
 
         Raises:
-            ErrorMessageGenerationError: If called before any input has been evaluated.
+            MissingErrorTemplateVariableError: If a failed rule's custom message
+                omits a placeholder for a referenced variable.
+            ErrorMessageGenerationError: If internal evaluation state records a
+                failed result without retaining its evaluated input.
+            Exception: A matching rule handler's documented message-generation
+                exceptions propagate unchanged.
         """
         if self._last_result or self._last_result is None:
             return None

generalmanager-0.64.1/src/general_manager/api/graphql_relations.py

@@ -1,72 +0,0 @@
-"""Resolve manager targets from GraphQL relation annotations."""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-from types import UnionType
-from typing import ForwardRef, Union, get_args, get_origin
-
-from general_manager.bucket.base_bucket import Bucket
-from general_manager.manager.general_manager import GeneralManager
-from general_manager.utils.type_checks import safe_issubclass
-
-
-def get_graphql_manager_registry() -> dict[str, type[GeneralManager]]:
-    """Return the live GraphQL manager registry without an import-time cycle."""
-    from general_manager.api.graphql import GraphQL
-
-    return GraphQL.manager_registry
-
-
-def resolve_general_manager_type(
-    declared_type: object,
-    manager_registry: Mapping[str, type[GeneralManager]] | None = None,
-) -> type[GeneralManager] | None:
-    """Return the single manager target represented by ``declared_type``.
-
-    Concrete manager classes, supported collection annotations, optional
-    unions, and exact names in ``manager_registry`` are recognized. Ambiguous
-    annotations containing multiple manager targets return ``None``.
-    """
-    registry = manager_registry or {}
-    resolved = _collect_general_manager_types(declared_type, registry, set())
-    if len(resolved) != 1:
-        return None
-    return next(iter(resolved))
-
-
-def _collect_general_manager_types(
-    declared_type: object,
-    manager_registry: Mapping[str, type[GeneralManager]],
-    seen: set[int],
-) -> set[type[GeneralManager]]:
-    value_id = id(declared_type)
-    if value_id in seen:
-        return set()
-    seen.add(value_id)
-
-    if safe_issubclass(declared_type, GeneralManager):
-        return {declared_type}
-
-    if isinstance(declared_type, ForwardRef):
-        declared_type = declared_type.__forward_arg__
-    if isinstance(declared_type, str):
-        manager_type = manager_registry.get(declared_type)
-        return {manager_type} if manager_type is not None else set()
-
-    origin = get_origin(declared_type)
-    if origin is None:
-        return set()
-    if origin not in {list, tuple, set, Union, UnionType} and not safe_issubclass(
-        origin, Bucket
-    ):
-        return set()
-
-    manager_types: set[type[GeneralManager]] = set()
-    for argument in get_args(declared_type):
-        if argument is None or argument is type(None) or argument is Ellipsis:
-            continue
-        manager_types.update(
-            _collect_general_manager_types(argument, manager_registry, seen)
-        )
-    return manager_types