GeneralManager 0.64.0__tar.gz → 0.64.2__tar.gz

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

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

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

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

@@ -33,6 +33,7 @@ src/general_manager/api/graphql.py
 src/general_manager/api/graphql_errors.py
 src/general_manager/api/graphql_mutations.py
 src/general_manager/api/graphql_prefetch.py
+src/general_manager/api/graphql_relations.py
 src/general_manager/api/graphql_resolvers.py
 src/general_manager/api/graphql_search.py
 src/general_manager/api/graphql_subscription_consumer.py

{generalmanager-0.64.0 → generalmanager-0.64.2}/src/general_manager/api/graphql.py

@@ -101,6 +101,7 @@ from general_manager.api.graphql_resolvers import (
     create_list_resolver as _create_list_resolver_fn,
     create_resolver as _create_resolver_fn,
 )
+from general_manager.api.graphql_relations import resolve_general_manager_type
 from general_manager.api.graphql_search import (
     register_search_query as _register_search_query_fn,
     create_search_union as _create_search_union_fn,
@@ -546,8 +547,13 @@ class GraphQL:
         # Map Attribute Types to Graphene Fields
         for field_name, field_info in interface_cls.get_attribute_types().items():
             field_type = field_info["type"]
-            fields[field_name] = cls._map_field_to_graphene_read(
+            resolved_manager_type = resolve_general_manager_type(
                 field_type,
+                cls.manager_registry,
+            )
+            resolved_field_type = resolved_manager_type or field_type
+            fields[field_name] = cls._map_field_to_graphene_read(
+                resolved_field_type,
                 field_name,
                 field_info,
             )
@@ -576,7 +582,10 @@ class GraphQL:
 
                 fields[resolver_name] = resolve_stored_file
             else:
-                fields[resolver_name] = cls._create_resolver(field_name, field_type)
+                fields[resolver_name] = cls._create_resolver(
+                    field_name,
+                    resolved_field_type,
+                )
 
         # handle GraphQLProperty attributes
         for (
@@ -594,9 +603,13 @@ class GraphQL:
 
             if origin in (list, tuple, set):
                 element = type_args[0] if type_args else object
-                if isinstance(element, type) and issubclass(element, GeneralManager):
+                manager_type = resolve_general_manager_type(
+                    element,
+                    cls.manager_registry,
+                )
+                if manager_type is not None:
                     graphene_field = graphene.List(
-                        lambda elem=element: GraphQL.graphql_type_registry[
+                        lambda elem=manager_type: GraphQL.graphql_type_registry[
                             elem.__name__
                         ]
                     )
@@ -605,13 +618,22 @@ class GraphQL:
                         element if isinstance(element, type) else str
                     )
                     graphene_field = graphene.List(base_type)
-                resolved_type = element if isinstance(element, type) else str
+                resolved_type = manager_type or (
+                    element if isinstance(element, type) else str
+                )
             else:
                 resolved_type = (
                     cast(type[object], type_args[0])
                     if type_args
                     else cast(type[object], raw_hint)
                 )
+                resolved_type = (
+                    resolve_general_manager_type(
+                        resolved_type,
+                        cls.manager_registry,
+                    )
+                    or resolved_type
+                )
                 graphene_field = cls._map_field_to_graphene_read(
                     resolved_type, attr_name
                 )
@@ -821,7 +843,7 @@ class GraphQL:
             field_info,
         ) in generalManagerClass.Interface.get_attribute_types().items():
             field_type = field_info["type"]
-            if safe_issubclass(field_type, GeneralManager):
+            if resolve_general_manager_type(field_type, GraphQL.manager_registry):
                 continue
             else:
                 sort_options.append(field_name)
@@ -970,7 +992,7 @@ class GraphQL:
 
     @staticmethod
     def _map_field_to_graphene_read(
-        field_type: type,
+        field_type: object,
         field_name: str,
         field_info: Mapping[str, object] | None = None,
     ) -> object:
@@ -998,6 +1020,13 @@ class GraphQL:
         Returns:
             object: Graphene field or type configured for the attribute.
         """
+        manager_type = resolve_general_manager_type(
+            field_type,
+            GraphQL.manager_registry,
+        )
+        if manager_type is not None:
+            field_type = manager_type
+
         if safe_issubclass(field_type, Measurement):
             return graphene.Field(MeasurementType, target_unit=graphene.String())
         elif safe_issubclass(field_type, GeneralManager):
@@ -1032,8 +1061,9 @@ class GraphQL:
                 return graphene.Field(StoredFile)
             if orm_field_kind == "image":
                 return graphene.Field(StoredImage)
+            scalar_type = cast(type, field_type)
             return GraphQL._map_field_to_graphene_base_type(
-                field_type,
+                scalar_type,
                 field_info,
             )()
 
@@ -1191,7 +1221,10 @@ class GraphQL:
             input_field_name,
             input_field,
         ) in generalManagerClass.Interface.input_fields.items():
-            if safe_issubclass(input_field.type, GeneralManager):
+            if resolve_general_manager_type(
+                input_field.type,
+                cls.manager_registry,
+            ):
                 key = f"{input_field_name}_id"
                 identification_fields[key] = graphene.Argument(
                     graphene.ID, required=input_field.required

{generalmanager-0.64.0 → generalmanager-0.64.2}/src/general_manager/api/graphql_mutations.py

@@ -21,11 +21,14 @@ from django.db import models
 from django.core.exceptions import FieldDoesNotExist
 
 from general_manager.interface.base_interface import AttributeTypedDict, InterfaceBase
+from general_manager.api.graphql_relations import (
+    get_graphql_manager_registry,
+    resolve_general_manager_type,
+)
 from general_manager.manager.general_manager import GeneralManager
 from general_manager.uploads.errors import UploadError, stable_upload_error
 from general_manager.uploads.graphql_types import UploadToken
 from general_manager.uploads.types import UploadOperation
-from general_manager.utils.type_checks import safe_issubclass
 from general_manager.utils.format_string import snake_to_camel
 from general_manager.api.graphql_errors import (
     MissingManagerIdentifierError,
@@ -166,13 +169,20 @@ def _normalize_mutation_kwargs_for_manager(
 
     attribute_types = interface_cls.get_attribute_types()
     normalized = dict(kwargs)
+    manager_registry = get_graphql_manager_registry()
 
     for key in list(kwargs.keys()):
         if key.endswith("_list") and not key.endswith("_id_list"):
             base_key = key.removesuffix("_list")
             type_info = attribute_types.get(key)
             relation_type = type_info["type"] if type_info is not None else None
-            if safe_issubclass(relation_type, GeneralManager):
+            if (
+                resolve_general_manager_type(
+                    relation_type,
+                    manager_registry,
+                )
+                is not None
+            ):
                 normalized.setdefault(f"{base_key}_id_list", normalized[key])
                 normalized.pop(key, None)
                 continue
@@ -180,7 +190,13 @@ def _normalize_mutation_kwargs_for_manager(
         if not key.endswith("_id"):
             type_info = attribute_types.get(key)
             relation_type = type_info["type"] if type_info is not None else None
-            if safe_issubclass(relation_type, GeneralManager):
+            if (
+                resolve_general_manager_type(
+                    relation_type,
+                    manager_registry,
+                )
+                is not None
+            ):
                 normalized.setdefault(f"{key}_id", normalized[key])
                 normalized.pop(key, None)
 
@@ -196,20 +212,23 @@ def _graphql_mutation_field_name(
         return snake_to_camel(field_name)
 
     attribute_types = interface_cls.get_attribute_types()
+    manager_registry = get_graphql_manager_registry()
 
     if field_name.endswith("_id_list"):
         relation_name = f"{field_name.removesuffix('_id_list')}_list"
         relation_info = attribute_types.get(relation_name)
-        if relation_info is not None and safe_issubclass(
-            relation_info["type"], GeneralManager
+        if relation_info is not None and resolve_general_manager_type(
+            relation_info["type"],
+            manager_registry,
         ):
             return snake_to_camel(relation_name)
 
     if field_name.endswith("_id"):
         relation_name = field_name.removesuffix("_id")
         relation_info = attribute_types.get(relation_name)
-        if relation_info is not None and safe_issubclass(
-            relation_info["type"], GeneralManager
+        if relation_info is not None and resolve_general_manager_type(
+            relation_info["type"],
+            manager_registry,
         ):
             return snake_to_camel(relation_name)
 
@@ -224,6 +243,7 @@ def _graphql_mutation_field_name(
 def _is_direct_relation_raw_id_alias(
     name: str,
     attribute_types: dict[str, AttributeTypedDict],
+    manager_registry: dict[str, type[GeneralManager]],
 ) -> bool:
     """Return true when ``name`` is a raw relation id alias with a canonical field."""
     if name.endswith("_id_list"):
@@ -231,7 +251,13 @@ def _is_direct_relation_raw_id_alias(
         relation_info = attribute_types.get(relation_name)
         if relation_info is None:
             return False
-        return safe_issubclass(relation_info["type"], GeneralManager)
+        return (
+            resolve_general_manager_type(
+                relation_info["type"],
+                manager_registry,
+            )
+            is not None
+        )
 
     if not name.endswith("_id"):
         return False
@@ -292,12 +318,17 @@ def create_write_fields(
     """
     fields: GrapheneFieldMap = {}
     attribute_types = interface_cls.get_attribute_types()
+    manager_registry = get_graphql_manager_registry()
     for name, info in attribute_types.items():
         if name in ["changed_by", "created_at", "updated_at"]:
             continue
         if info["is_derived"]:
             continue
-        if _is_direct_relation_raw_id_alias(name, attribute_types):
+        if _is_direct_relation_raw_id_alias(
+            name,
+            attribute_types,
+            manager_registry,
+        ):
             continue
 
         typ = info["type"]
@@ -307,7 +338,13 @@ def create_write_fields(
         fld: object
         if info.get("orm_field_kind") in {"file", "image"}:
             fld = UploadToken(required=req, default_value=default)
-        elif safe_issubclass(typ, GeneralManager):
+        elif (
+            resolve_general_manager_type(
+                typ,
+                manager_registry,
+            )
+            is not None
+        ):
             if name.endswith("_list"):
                 fld = graphene.List(graphene.ID, required=req, default_value=default)
             else:

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.0 → generalmanager-0.64.2}/src/general_manager/api/graphql_resolvers.py

@@ -24,6 +24,10 @@ from general_manager.bucket.group_bucket import GroupBucket
 from general_manager.manager.general_manager import GeneralManager
 from general_manager.measurement.measurement import Measurement
 from general_manager.api.graphql_errors import get_read_permission_filter
+from general_manager.api.graphql_relations import (
+    get_graphql_manager_registry,
+    resolve_general_manager_type,
+)
 from general_manager.api.graphql_prefetch import (
     collect_selected_graphql_property_names,
     plan_dependency_cache_prefetches,
@@ -834,7 +838,7 @@ def _selection_set_includes_path(
 
 def create_resolver(
     field_name: str,
-    field_type: type[object],
+    field_type: object,
     filter_normalizer: ManagerFilterNormalizer | None = None,
 ) -> Resolver:
     """
@@ -845,8 +849,11 @@ def create_resolver(
     :class:`~general_manager.measurement.Measurement` fields, and
     :func:`create_normal_resolver` for everything else.
     """
-    if field_name.endswith("_list") and safe_issubclass(field_type, GeneralManager):
-        manager_field_type = cast(type[GeneralManager], field_type)
+    manager_field_type = resolve_general_manager_type(
+        field_type,
+        get_graphql_manager_registry(),
+    )
+    if field_name.endswith("_list") and manager_field_type is not None:
         return create_list_resolver(
             lambda self, _include_inactive: cast(
                 Bucket[GeneralManager],

{generalmanager-0.64.0 → generalmanager-0.64.2}/src/general_manager/api/graphql_search.py

@@ -41,6 +41,10 @@ from general_manager.api.graphql_errors import (
     map_field_to_graphene_base_type,
     get_read_permission_filter,
 )
+from general_manager.api.graphql_relations import (
+    get_graphql_manager_registry,
+    resolve_general_manager_type,
+)
 from general_manager.api.graphql_resolvers import (
     can_read_instance,
     get_backend_shape,
@@ -538,9 +542,15 @@ def get_filter_options(
         "endswith",
     ]
 
-    normalized_type = attribute_type if isinstance(attribute_type, type) else str
+    manager_type = resolve_general_manager_type(
+        attribute_type,
+        get_graphql_manager_registry(),
+    )
+    normalized_type = manager_type or (
+        attribute_type if isinstance(attribute_type, type) else str
+    )
 
-    if safe_issubclass(normalized_type, GeneralManager):
+    if manager_type is not None:
         yield attribute_name, None
     elif attribute_name == "id":
         yield attribute_name, graphene.ID()
@@ -591,7 +601,7 @@ def get_filter_options(
 
 
 def get_relation_filter_option(
-    attribute_type: type,
+    attribute_type: object,
     attribute_name: str,
     attr_info: Mapping[str, object],
     graphql_filter_type_registry: dict[str, type[graphene.InputObjectType]],
@@ -614,7 +624,11 @@ def get_relation_filter_option(
     """
     if remaining_depth <= 0:
         return None
-    if not safe_issubclass(attribute_type, GeneralManager):
+    manager_type = resolve_general_manager_type(
+        attribute_type,
+        get_graphql_manager_registry(),
+    )
+    if manager_type is None:
         return None
 
     relation_kind = attr_info.get("relation_kind")
@@ -622,7 +636,7 @@ def get_relation_filter_option(
         return None
 
     nested_type = create_filter_options(
-        attribute_type,
+        manager_type,
         graphql_filter_type_registry,
         map_field_to_graphene_read,
         relation_depth=remaining_depth - 1,
@@ -633,7 +647,7 @@ def get_relation_filter_option(
 
     if relation_kind == "collection":
         relation_type_name = (
-            f"{attribute_type.__name__}{attribute_name.title().replace('_', '')}"
+            f"{manager_type.__name__}{attribute_name.title().replace('_', '')}"
             f"RelationFilterTypeDepth{remaining_depth - 1}"
         )
         if relation_type_name not in graphql_filter_type_registry:
@@ -700,9 +714,13 @@ def create_filter_options(
     filter_fields: dict[str, GrapheneFieldType] = {}
     for attr_name, attr_info in field_type.Interface.get_attribute_types().items():
         attr_type = attr_info["type"]
-        if safe_issubclass(attr_type, GeneralManager):
+        manager_type = resolve_general_manager_type(
+            attr_type,
+            get_graphql_manager_registry(),
+        )
+        if manager_type is not None:
             relation_option = get_relation_filter_option(
-                attr_type,
+                manager_type,
                 attr_name,
                 attr_info,
                 graphql_filter_type_registry,
@@ -826,12 +844,16 @@ def normalize_filter_input(
         attr_type = attr_info.get("type")
         relation_kind = attr_info.get("relation_kind")
         lookup = attr_info.get("filter_lookup", key)
-        if not safe_issubclass(attr_type, GeneralManager) or relation_kind is None:
+        manager_type = resolve_general_manager_type(
+            attr_type,
+            get_graphql_manager_registry(),
+        )
+        if manager_type is None or relation_kind is None:
             filters[key] = value
             continue
 
         if relation_kind == "direct":
-            nested = normalize_filter_input(attr_type, value)
+            nested = normalize_filter_input(manager_type, value)
             for nested_key, nested_value in nested["filter"].items():
                 filters[f"{lookup}__{nested_key}"] = nested_value
             for nested_key, nested_value in nested["exclude"].items():
@@ -842,13 +864,13 @@ def normalize_filter_input(
             any_value = value.get("any")
             none_value = value.get("none")
             if isinstance(any_value, dict):
-                nested = normalize_filter_input(attr_type, any_value)
+                nested = normalize_filter_input(manager_type, any_value)
                 for nested_key, nested_value in nested["filter"].items():
                     filters[f"{lookup}__{nested_key}"] = nested_value
                 for nested_key, nested_value in nested["exclude"].items():
                     excludes[f"{lookup}__{nested_key}"] = nested_value
             if isinstance(none_value, dict):
-                nested = normalize_filter_input(attr_type, none_value)
+                nested = normalize_filter_input(manager_type, none_value)
                 for nested_key, nested_value in nested["filter"].items():
                     excludes[f"{lookup}__{nested_key}"] = nested_value
                 for nested_key, nested_value in nested["exclude"].items():

{generalmanager-0.64.0 → generalmanager-0.64.2}/src/general_manager/bootstrap.py

@@ -522,6 +522,13 @@ def handle_graph_ql(
         "creating graphql interfaces and mutations",
         context={"pending": len(pending_graphql_interfaces)},
     )
+    GraphQL.manager_registry.update(
+        {
+            general_manager_class.__name__: general_manager_class
+            for general_manager_class in pending_graphql_interfaces
+            if getattr(general_manager_class, "Interface", None) is not None
+        }
+    )
     for general_manager_class in pending_graphql_interfaces:
         GraphQL.create_graphql_interface(general_manager_class)
         GraphQL.create_graphql_mutation(general_manager_class)

{generalmanager-0.64.0 → 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