GeneralManager 0.40.6__tar.gz → 0.41.0__tar.gz

{generalmanager-0.40.6/src/GeneralManager.egg-info → generalmanager-0.41.0}/PKG-INFO

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

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

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

@@ -102,6 +102,7 @@ from general_manager.api.graphql_search import (
     passes_permission_filters as _passes_permission_filters_fn,
     get_filter_options as _get_filter_options_fn,
     create_filter_options as _create_filter_options_fn,
+    normalize_filter_input as _normalize_filter_input_fn,
 )
 from general_manager.api.graphql_subscriptions import (
     get_channel_layer_safe as _get_channel_layer_fn,
@@ -704,10 +705,12 @@ class GraphQL:
         field_type: Type[GeneralManager],
     ) -> type[graphene.InputObjectType] | None:
         """Build filter InputObjectType for *field_type*. See ``graphql_search.create_filter_options``."""
+        relation_depth = int(get_setting("GRAPHQL_FILTER_RELATION_DEPTH", 1) or 0)
         return _create_filter_options_fn(
             field_type,
             GraphQL.graphql_filter_type_registry,
             GraphQL._map_field_to_graphene_read,
+            relation_depth=relation_depth,
         )
 
     @staticmethod
@@ -779,6 +782,14 @@ class GraphQL:
         """Normalise a filter/exclude input into a plain dict. See ``graphql_resolvers.parse_input``."""
         return _parse_input_fn(input_val)
 
+    @staticmethod
+    def _normalize_filter_input(
+        field_type: Type[GeneralManager],
+        filter_input: dict[str, Any],
+    ) -> dict[str, dict[str, Any]]:
+        """Flatten nested relation filters. See ``graphql_search.normalize_filter_input``."""
+        return _normalize_filter_input_fn(field_type, filter_input)
+
     @staticmethod
     def _apply_query_parameters(
         queryset: Bucket[GeneralManager],
@@ -786,10 +797,17 @@ class GraphQL:
         exclude_input: dict[str, Any] | str | None,
         sort_by: graphene.Enum | None,
         reverse: bool,
+        filter_normalizer: Callable[[dict[str, Any]], dict[str, dict[str, Any]]]
+        | None = None,
     ) -> Bucket[GeneralManager]:
         """Apply filter/exclude/sort to *queryset*. See ``graphql_resolvers.apply_query_parameters``."""
         return _apply_query_parameters_fn(
-            queryset, filter_input, exclude_input, sort_by, reverse
+            queryset,
+            filter_input,
+            exclude_input,
+            sort_by,
+            reverse,
+            filter_normalizer=filter_normalizer,
         )
 
     @staticmethod
@@ -814,7 +832,11 @@ class GraphQL:
         fallback_manager_class: type[GeneralManager],
     ) -> Callable[..., Any]:
         """Build a list-field resolver. See ``graphql_resolvers.create_list_resolver``."""
-        return _create_list_resolver_fn(base_getter, fallback_manager_class)
+        return _create_list_resolver_fn(
+            base_getter,
+            fallback_manager_class,
+            _normalize_filter_input_fn,
+        )
 
     @staticmethod
     def _apply_pagination(
@@ -845,7 +867,7 @@ class GraphQL:
     @classmethod
     def _create_resolver(cls, field_name: str, field_type: type) -> Callable[..., Any]:
         """Dispatch to the appropriate resolver factory. See ``graphql_resolvers.create_resolver``."""
-        return _create_resolver_fn(field_name, field_type)
+        return _create_resolver_fn(field_name, field_type, _normalize_filter_input_fn)
 
     @classmethod
     def _get_or_create_page_type(

{generalmanager-0.40.6 → generalmanager-0.41.0}/src/general_manager/api/graphql_resolvers.py

@@ -39,6 +39,15 @@ GeneralManagerT = TypeVar("GeneralManagerT", bound=GeneralManager)
 logger = get_logger("api.graphql")
 
 
+class UnsupportedExcludeNoneRelationFilterError(ValueError):
+    """Raised when `none` relation filters are used in GraphQL exclude input."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            "`none` relation filters are not supported inside `exclude` inputs."
+        )
+
+
 @dataclass(slots=True)
 class ReadAuthorizationResult(Generic[GeneralManagerT]):
     queryset: Bucket[GeneralManagerT]
@@ -72,6 +81,17 @@ def parse_input(input_val: dict[str, Any] | str | None) -> dict[str, Any]:
     return input_val
 
 
+def contains_none_relation_filter(input_val: Any) -> bool:
+    """Return True when a nested relation filter contains a ``none`` operator."""
+    if isinstance(input_val, dict):
+        if "none" in input_val:
+            return True
+        return any(contains_none_relation_filter(value) for value in input_val.values())
+    if isinstance(input_val, list):
+        return any(contains_none_relation_filter(value) for value in input_val)
+    return False
+
+
 # ---------------------------------------------------------------------------
 # Queryset modifiers
 # ---------------------------------------------------------------------------
@@ -83,6 +103,9 @@ def apply_query_parameters(
     exclude_input: dict[str, Any] | str | None,
     sort_by: graphene.Enum | None,
     reverse: bool,
+    *,
+    filter_normalizer: Callable[[dict[str, Any]], dict[str, dict[str, Any]]]
+    | None = None,
 ) -> Bucket[GeneralManager]:
     """
     Apply filtering, exclusion, and sorting to *queryset*.
@@ -96,13 +119,27 @@ def apply_query_parameters(
     Returns:
         The queryset after filters, exclusions, and sorting are applied.
     """
+    normalized_excludes: dict[str, Any] = {}
+
     filters = parse_input(filter_input)
+    if filters and filter_normalizer is not None:
+        normalized = filter_normalizer(filters)
+        filters = normalized["filter"]
+        normalized_excludes = normalized["exclude"]
     if filters:
         queryset = queryset.filter(**filters)
 
     excludes = parse_input(exclude_input)
+    if excludes and filter_normalizer is not None:
+        if contains_none_relation_filter(excludes):
+            raise UnsupportedExcludeNoneRelationFilterError
+        normalized = filter_normalizer(excludes)
+        excludes = normalized["filter"]
+        normalized_excludes = {**normalized_excludes, **normalized["exclude"]}
     if excludes:
         queryset = queryset.exclude(**excludes)
+    if normalized_excludes:
+        queryset = queryset.exclude(**normalized_excludes)
 
     if sort_by:
         sort_by_str = cast(str, getattr(sort_by, "value", sort_by))
@@ -440,6 +477,10 @@ def create_normal_resolver(field_name: str) -> Callable[..., Any]:
 def create_list_resolver(
     base_getter: Callable[[Any, bool], Any],
     fallback_manager_class: type[GeneralManager],
+    filter_normalizer: Callable[
+        [type[GeneralManager], dict[str, Any]], dict[str, dict[str, Any]]
+    ]
+    | None = None,
 ) -> Callable[..., Any]:
     """
     Build a resolver for list fields that applies filters, permissions, and pagination.
@@ -479,7 +520,22 @@ def create_list_resolver(
         ):
             manager_class = fallback_manager_class
         qs = apply_permission_filters(base_queryset, manager_class, info)
-        qs = apply_query_parameters(qs, filter, exclude, sort_by, reverse)
+        bound_filter_normalizer = None
+        if filter_normalizer is not None:
+
+            def bound_filter_normalizer(
+                filters: dict[str, Any],
+            ) -> dict[str, dict[str, Any]]:
+                return filter_normalizer(manager_class, filters)
+
+        qs = apply_query_parameters(
+            qs,
+            filter,
+            exclude,
+            sort_by,
+            reverse,
+            filter_normalizer=bound_filter_normalizer,
+        )
         qs_grouped = apply_grouping(qs, group_by)
 
         total_count = len(qs_grouped)
@@ -575,7 +631,14 @@ def _selection_set_includes_path(
     return False
 
 
-def create_resolver(field_name: str, field_type: type) -> Callable[..., Any]:
+def create_resolver(
+    field_name: str,
+    field_type: type,
+    filter_normalizer: Callable[
+        [type[GeneralManager], dict[str, Any]], dict[str, dict[str, Any]]
+    ]
+    | None = None,
+) -> Callable[..., Any]:
     """
     Return the appropriate resolver for *field_name* based on *field_type*.
 
@@ -586,7 +649,9 @@ def create_resolver(field_name: str, field_type: type) -> Callable[..., Any]:
     """
     if field_name.endswith("_list") and safe_issubclass(field_type, GeneralManager):
         return create_list_resolver(
-            lambda self, _include_inactive: getattr(self, field_name), field_type
+            lambda self, _include_inactive: getattr(self, field_name),
+            field_type,
+            filter_normalizer,
         )
     if safe_issubclass(field_type, Measurement):
         return create_measurement_resolver(field_name)

{generalmanager-0.40.6 → generalmanager-0.41.0}/src/general_manager/api/graphql_search.py

@@ -357,10 +357,66 @@ def get_filter_options(
                     )
 
 
+def get_relation_filter_option(
+    attribute_type: type,
+    attribute_name: str,
+    attr_info: Mapping[str, Any],
+    graphql_filter_type_registry: dict[str, type[graphene.InputObjectType]],
+    map_field_to_graphene_read: Callable[[type, str, Mapping[str, Any] | None], Any],
+    remaining_depth: int,
+) -> tuple[str, Any] | None:
+    """Build a nested relation filter field for direct and collection relations."""
+    if remaining_depth <= 0:
+        return None
+    if not safe_issubclass(attribute_type, GeneralManager):
+        return None
+
+    relation_kind = attr_info.get("relation_kind")
+    if relation_kind not in {"collection", "direct"}:
+        return None
+
+    nested_type = create_filter_options(
+        attribute_type,
+        graphql_filter_type_registry,
+        map_field_to_graphene_read,
+        relation_depth=remaining_depth - 1,
+        _remaining_depth=remaining_depth - 1,
+    )
+    if nested_type is None:
+        return None
+
+    if relation_kind == "collection":
+        relation_type_name = (
+            f"{attribute_type.__name__}{attribute_name.title().replace('_', '')}"
+            f"RelationFilterTypeDepth{remaining_depth - 1}"
+        )
+        if relation_type_name not in graphql_filter_type_registry:
+            graphql_filter_type_registry[relation_type_name] = type(
+                relation_type_name,
+                (graphene.InputObjectType,),
+                {
+                    "any": graphene.InputField(nested_type),
+                    "none": graphene.InputField(nested_type),
+                },
+            )
+        return (
+            attribute_name,
+            graphene.InputField(graphql_filter_type_registry[relation_type_name]),
+        )
+
+    if relation_kind == "direct":
+        return attribute_name, graphene.InputField(nested_type)
+
+    return None
+
+
 def create_filter_options(
     field_type: Type[GeneralManager],
     graphql_filter_type_registry: dict[str, type[graphene.InputObjectType]],
     map_field_to_graphene_read: Callable[[type, str, Mapping[str, Any] | None], Any],
+    *,
+    relation_depth: int = 1,
+    _remaining_depth: int | None = None,
 ) -> type[graphene.InputObjectType] | None:
     """
     Create (or retrieve from cache) a Graphene InputObjectType exposing all
@@ -378,13 +434,27 @@ def create_filter_options(
         A Graphene ``InputObjectType`` for *field_type*, or ``None`` if no
         filterable fields exist.
     """
-    graphene_filter_type_name = f"{field_type.__name__}FilterType"
+    remaining_depth = relation_depth if _remaining_depth is None else _remaining_depth
+    graphene_filter_type_name = f"{field_type.__name__}FilterTypeDepth{remaining_depth}"
     if graphene_filter_type_name in graphql_filter_type_registry:
         return graphql_filter_type_registry[graphene_filter_type_name]
 
     filter_fields: dict[str, Any] = {}
     for attr_name, attr_info in field_type.Interface.get_attribute_types().items():
         attr_type = attr_info["type"]
+        if safe_issubclass(attr_type, GeneralManager):
+            relation_option = get_relation_filter_option(
+                attr_type,
+                attr_name,
+                attr_info,
+                graphql_filter_type_registry,
+                map_field_to_graphene_read,
+                remaining_depth,
+            )
+            if relation_option is not None:
+                key, value = relation_option
+                filter_fields[key] = value
+            continue
         filter_fields = {
             **filter_fields,
             **{
@@ -423,6 +493,63 @@ def create_filter_options(
     return filter_class
 
 
+def normalize_filter_input(
+    field_type: Type[GeneralManager],
+    filter_input: dict[str, Any],
+) -> dict[str, dict[str, Any]]:
+    """Flatten nested GraphQL relation filters into filter and exclude kwargs."""
+    interface = getattr(field_type, "Interface", None)
+    get_attribute_types = getattr(interface, "get_attribute_types", None)
+    if not callable(get_attribute_types):
+        return {"filter": dict(filter_input), "exclude": {}}
+
+    filters: dict[str, Any] = {}
+    excludes: dict[str, Any] = {}
+    attr_types = get_attribute_types()
+
+    for key, value in filter_input.items():
+        attr_info = attr_types.get(key)
+        if not attr_info or not isinstance(value, dict):
+            filters[key] = value
+            continue
+
+        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:
+            filters[key] = value
+            continue
+
+        if relation_kind == "direct":
+            nested = normalize_filter_input(attr_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():
+                excludes[f"{lookup}__{nested_key}"] = nested_value
+            continue
+
+        if relation_kind == "collection":
+            any_value = value.get("any")
+            none_value = value.get("none")
+            if isinstance(any_value, dict):
+                nested = normalize_filter_input(attr_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)
+                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():
+                    filters[f"{lookup}__{nested_key}"] = nested_value
+            continue
+
+        filters[key] = value
+
+    return {"filter": filters, "exclude": excludes}
+
+
 # ---------------------------------------------------------------------------
 # Top-level search query registration
 # ---------------------------------------------------------------------------
@@ -634,7 +761,7 @@ def register_search_query(
 
             hits.sort(key=_sort_key, reverse=sort_desc)
         else:
-            hits.sort(key=lambda item: (item[0] or 0), reverse=True)
+            hits.sort(key=lambda item: item[0] or 0, reverse=True)
 
         items: list[GeneralManager] = []
         for _, _hit, instance in hits[offset : offset + limit]:

{generalmanager-0.40.6 → generalmanager-0.41.0}/src/general_manager/interface/base_interface.py

@@ -72,6 +72,8 @@ class AttributeTypedDict(TypedDict):
 
     type: type
     graphql_scalar: NotRequired[str]
+    relation_kind: NotRequired[str]
+    filter_lookup: NotRequired[str]
     default: Any
     is_required: bool
     is_editable: bool

{generalmanager-0.40.6 → generalmanager-0.41.0}/src/general_manager/interface/capabilities/orm_utils/field_descriptors.py

@@ -205,6 +205,8 @@ class _FieldDescriptorBuilder:
                 default=default,
                 is_derived=False,
                 accessor=accessor,
+                relation_kind="direct",
+                filter_lookup=field.name,
             )
 
     def _add_collection_relations(self) -> None:
@@ -303,6 +305,8 @@ class _FieldDescriptorBuilder:
             default=None,
             is_derived=is_derived,
             accessor=accessor,
+            relation_kind="collection",
+            filter_lookup=getattr(field, "name", accessor_name),
         )
 
     def _resolve_collection_base_name(
@@ -347,6 +351,8 @@ class _FieldDescriptorBuilder:
         default: Any,
         is_derived: bool,
         accessor: DescriptorAccessor,
+        relation_kind: str | None = None,
+        filter_lookup: str | None = None,
     ) -> None:
         """
         Register a FieldDescriptor for a named interface attribute.
@@ -375,6 +381,10 @@ class _FieldDescriptorBuilder:
         graphql_scalar = _graphql_scalar_hint(raw_type)
         if graphql_scalar is not None:
             metadata["graphql_scalar"] = graphql_scalar
+        if relation_kind is not None:
+            metadata["relation_kind"] = relation_kind
+        if filter_lookup is not None:
+            metadata["filter_lookup"] = filter_lookup
         self._descriptors[attribute_name] = FieldDescriptor(
             name=attribute_name,
             metadata=metadata,