GeneralManager 0.13.1__py3-none-any.whl → 0.14.1__py3-none-any.whl

general_manager/bucket/calculationBucket.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from types import UnionType
 from typing import (
     Any,
     Type,
@@ -8,7 +9,10 @@ from typing import (
     Optional,
     Generator,
     List,
+    TypedDict,
+    get_origin,
 )
+from operator import attrgetter
 from copy import deepcopy
 from general_manager.interface.baseInterface import (
     generalManagerClassName,
@@ -19,8 +23,14 @@ from general_manager.manager.input import Input
 from general_manager.utils.filterParser import parse_filters
 
 if TYPE_CHECKING:
-    from general_manager.manager.generalManager import GeneralManager
-    from general_manager.interface.calculationInterface import CalculationInterface
+    from general_manager.api.property import GraphQLProperty
+
+
+class SortedFilters(TypedDict):
+    prop_filters: dict[str, Any]
+    input_filters: dict[str, Any]
+    prop_excludes: dict[str, Any]
+    input_excludes: dict[str, Any]
 
 
 class CalculationBucket(Bucket[GeneralManagerType]):
@@ -57,12 +67,40 @@ class CalculationBucket(Bucket[GeneralManagerType]):
                 "CalculationBucket can only be used with CalculationInterface subclasses"
             )
         self.input_fields = interface_class.input_fields
-        self.filters = {} if filter_definitions is None else filter_definitions
-        self.excludes = {} if exclude_definitions is None else exclude_definitions
-        self._current_combinations = None
+        self.filter_definitions = (
+            {} if filter_definitions is None else filter_definitions
+        )
+        self.exclude_definitions = (
+            {} if exclude_definitions is None else exclude_definitions
+        )
+
+        properties = self._manager_class.Interface.getGraphQLProperties()
+        possible_values = self.transformPropertiesToInputFields(
+            properties, self.input_fields
+        )
+
+        self._filters = parse_filters(self.filter_definitions, possible_values)
+        self._excludes = parse_filters(self.exclude_definitions, possible_values)
+
+        self._data = None
         self.sort_key = sort_key
         self.reverse = reverse
 
+    def __eq__(self, other: object) -> bool:
+        """
+        Checks if this Bucket is equal to another by comparing class, data, and manager class.
+
+        Returns:
+            True if both objects are of the same class and have equal internal data and manager class; otherwise, False.
+        """
+        if not isinstance(other, self.__class__):
+            return False
+        return (
+            self.filter_definitions == other.filter_definitions
+            and self.exclude_definitions == other.exclude_definitions
+            and self._manager_class == other._manager_class
+        )
+
     def __reduce__(self) -> generalManagerClassName | tuple[Any, ...]:
         """
         Prepares the CalculationBucket instance for pickling by returning its reconstruction data.
@@ -74,12 +112,12 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             self.__class__,
             (
                 self._manager_class,
-                self.filters,
-                self.excludes,
+                self.filter_definitions,
+                self.exclude_definitions,
                 self.sort_key,
                 self.reverse,
             ),
-            {"current_combinations": self._current_combinations},
+            {"data": self._data},
         )
 
     def __setstate__(self, state: dict[str, Any]) -> None:
@@ -89,20 +127,20 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         Args:
             state: A dictionary containing the state of the instance, including current combinations.
         """
-        self._current_combinations = state.get("current_combinations")
+        self._data = state.get("data")
 
     def __or__(
         self,
         other: Bucket[GeneralManagerType] | GeneralManagerType,
     ) -> CalculationBucket[GeneralManagerType]:
         """
-        Combine this CalculationBucket with another bucket or a manager instance of the same manager class.
-        
-        If combined with a manager instance, returns a bucket filtered to that instance's identification. If combined with another CalculationBucket of the same manager class, returns a new bucket containing only the filters and excludes that are present and identical in both buckets.
-        
+        Combine this CalculationBucket with another bucket or manager instance of the same manager class.
+
+        If combined with a manager instance, returns a bucket filtered to that manager's identification. If combined with another CalculationBucket of the same manager class, returns a new bucket containing only the filters and excludes that are present and identical in both buckets.
+
         Raises:
             ValueError: If the other object is not a CalculationBucket or manager of the same class.
-        
+
         Returns:
             CalculationBucket[GeneralManagerType]: A new CalculationBucket representing the intersection of filters and excludes, or a filtered bucket for the given manager instance.
         """
@@ -117,14 +155,16 @@ class CalculationBucket(Bucket[GeneralManagerType]):
 
         combined_filters = {
             key: value
-            for key, value in self.filters.items()
-            if key in other.filters and value == other.filters[key]
+            for key, value in self.filter_definitions.items()
+            if key in other.filter_definitions
+            and value == other.filter_definitions[key]
         }
 
         combined_excludes = {
             key: value
-            for key, value in self.excludes.items()
-            if key in other.excludes and value == other.excludes[key]
+            for key, value in self.exclude_definitions.items()
+            if key in other.exclude_definitions
+            and value == other.exclude_definitions[key]
         }
 
         return CalculationBucket(
@@ -158,7 +198,41 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         """
         Returns a concise string representation of the CalculationBucket, including the manager class name, filters, excludes, sort key, and sort order.
         """
-        return f"{self.__class__.__name__}({self._manager_class.__name__}, {self.filters}, {self.excludes}, {self.sort_key}, {self.reverse})"
+        return f"{self.__class__.__name__}({self._manager_class.__name__}, {self.filter_definitions}, {self.exclude_definitions}, {self.sort_key}, {self.reverse})"
+
+    @staticmethod
+    def transformPropertiesToInputFields(
+        properties: dict[str, GraphQLProperty], input_fields: dict[str, Input]
+    ) -> dict[str, Input]:
+        """
+        Returns a dictionary of possible values for each input field based on the provided properties.
+
+        This method analyzes the properties and input fields to determine valid values for each input parameter.
+
+        Args:
+            properties (dict[str, Any]): The GraphQL properties of the manager class.
+            input_fields (dict[str, Any]): The input fields to analyze.
+
+        Returns:
+            dict[str, Any]: A dictionary mapping input field names to their possible values.
+        """
+        parsed_inputs = {**input_fields}
+        for prop_name, prop in properties.items():
+            type_hint = prop.graphql_type_hint
+            origin = get_origin(type_hint)
+            if origin in (Union, UnionType):
+                type_hint = type_hint.__args__[0] if type_hint.__args__ else str  # type: ignore
+
+            elif isinstance(type_hint, type) and issubclass(
+                type_hint, (list, tuple, set, dict)
+            ):
+                type_hint: type = (
+                    type_hint.__args__[0] if hasattr(type_hint, "__args__") else str  # type: ignore
+                )
+            prop_input = Input(type=type_hint, possible_values=None, depends_on=None)
+            parsed_inputs[prop_name] = prop_input
+
+        return parsed_inputs
 
     def filter(self, **kwargs: Any) -> CalculationBucket:
         """
@@ -166,10 +240,14 @@ class CalculationBucket(Bucket[GeneralManagerType]):
 
         Merges the provided filter criteria with existing filters to further restrict valid input combinations.
         """
-        filters = self.filters.copy()
-        excludes = self.excludes.copy()
-        filters.update(parse_filters(kwargs, self.input_fields))
-        return CalculationBucket(self._manager_class, filters, excludes)
+        return CalculationBucket(
+            manager_class=self._manager_class,
+            filter_definitions={
+                **self.filter_definitions.copy(),
+                **kwargs,
+            },
+            exclude_definitions=self.exclude_definitions.copy(),
+        )
 
     def exclude(self, **kwargs: Any) -> CalculationBucket:
         """
@@ -177,10 +255,14 @@ class CalculationBucket(Bucket[GeneralManagerType]):
 
         Keyword arguments specify input values to exclude from the generated combinations.
         """
-        filters = self.filters.copy()
-        excludes = self.excludes.copy()
-        excludes.update(parse_filters(kwargs, self.input_fields))
-        return CalculationBucket(self._manager_class, filters, excludes)
+        return CalculationBucket(
+            manager_class=self._manager_class,
+            filter_definitions=self.filter_definitions.copy(),
+            exclude_definitions={
+                **self.exclude_definitions.copy(),
+                **kwargs,
+            },
+        )
 
     def all(self) -> CalculationBucket:
         """
@@ -201,6 +283,30 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         for combo in combinations:
             yield self._manager_class(**combo)
 
+    def _sortFilters(self, sorted_inputs: List[str]) -> SortedFilters:
+        input_filters: dict[str, dict] = {}
+        prop_filters: dict[str, dict] = {}
+        input_excludes: dict[str, dict] = {}
+        prop_excludes: dict[str, dict] = {}
+
+        for filter_name, filter_def in self._filters.items():
+            if filter_name in sorted_inputs:
+                input_filters[filter_name] = filter_def
+            else:
+                prop_filters[filter_name] = filter_def
+        for exclude_name, exclude_def in self._excludes.items():
+            if exclude_name in sorted_inputs:
+                input_excludes[exclude_name] = exclude_def
+            else:
+                prop_excludes[exclude_name] = exclude_def
+
+        return {
+            "prop_filters": prop_filters,
+            "input_filters": input_filters,
+            "prop_excludes": prop_excludes,
+            "input_excludes": input_excludes,
+        }
+
     def generate_combinations(self) -> List[dict[str, Any]]:
         """
         Generates and caches all valid input combinations based on filters, exclusions, and sorting.
@@ -209,28 +315,37 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             A list of dictionaries, each representing a unique combination of input values that satisfy the current filters, exclusions, and sorting order.
         """
 
-        def key_func(item: dict[str, Any]) -> tuple:
-            return tuple(item[key] for key in sort_key)
+        def key_func(manager_obj: GeneralManagerType) -> tuple:
+            getters = [attrgetter(key) for key in sort_key]
+            return tuple(getter(manager_obj) for getter in getters)
 
-        if self._current_combinations is None:
-            # Implementierung ähnlich wie im InputManager
+        if self._data is None:
             sorted_inputs = self.topological_sort_inputs()
-            current_combinations = self._generate_combinations(
-                sorted_inputs, self.filters, self.excludes
+            sorted_filters = self._sortFilters(sorted_inputs)
+            current_combinations = self._generate_input_combinations(
+                sorted_inputs,
+                sorted_filters["input_filters"],
+                sorted_filters["input_excludes"],
             )
+            manager_combinations = self._generate_prop_combinations(
+                current_combinations,
+                sorted_filters["prop_filters"],
+                sorted_filters["prop_excludes"],
+            )
+
             if self.sort_key is not None:
                 sort_key = self.sort_key
                 if isinstance(sort_key, str):
                     sort_key = (sort_key,)
-                current_combinations = sorted(
-                    current_combinations,
+                manager_combinations = sorted(
+                    manager_combinations,
                     key=key_func,
                 )
             if self.reverse:
-                current_combinations.reverse()
-            self._current_combinations = current_combinations
+                manager_combinations.reverse()
+            self._data = [manager.identification for manager in manager_combinations]
 
-        return self._current_combinations
+        return self._data
 
     def topological_sort_inputs(self) -> List[str]:
         """
@@ -306,15 +421,15 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         """
         if callable(input_field.possible_values):
             depends_on = input_field.depends_on
-            dep_values = {dep_name: current_combo[dep_name] for dep_name in depends_on}
-            possible_values = input_field.possible_values(**dep_values)
+            dep_values = [current_combo[dep_name] for dep_name in depends_on]
+            possible_values = input_field.possible_values(*dep_values)
         elif isinstance(input_field.possible_values, (Iterable, Bucket)):
             possible_values = input_field.possible_values
         else:
             raise TypeError(f"Invalid possible_values for input '{key_name}'")
         return possible_values
 
-    def _generate_combinations(
+    def _generate_input_combinations(
         self,
         sorted_inputs: List[str],
         filters: dict[str, dict],
@@ -381,6 +496,45 @@ class CalculationBucket(Bucket[GeneralManagerType]):
 
         return list(helper(0, {}))
 
+    def _generate_prop_combinations(
+        self,
+        current_combos: list[dict[str, Any]],
+        prop_filters: dict[str, Any],
+        prop_excludes: dict[str, Any],
+    ) -> list[GeneralManagerType]:
+
+        prop_filter_needed = set(prop_filters.keys()) | set(prop_excludes.keys())
+        manager_combinations = [
+            self._manager_class(**combo) for combo in current_combos
+        ]
+        if not prop_filter_needed:
+            return manager_combinations
+
+        # Apply property filters and exclusions
+        filtered_combos = []
+        for manager in manager_combinations:
+            keep = True
+            # include filters
+            for prop_name, defs in prop_filters.items():
+                for func in defs.get("filter_funcs", []):
+                    if not func(getattr(manager, prop_name)):
+                        keep = False
+                        break
+                if not keep:
+                    break
+            # excludes
+            if keep:
+                for prop_name, defs in prop_excludes.items():
+                    for func in defs.get("filter_funcs", []):
+                        if func(getattr(manager, prop_name)):
+                            keep = False
+                            break
+                    if not keep:
+                        break
+            if keep:
+                filtered_combos.append(manager)
+        return filtered_combos
+
     def first(self) -> GeneralManagerType | None:
         """
         Returns the first generated manager instance, or None if no combinations exist.
@@ -425,12 +579,12 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         if isinstance(result, list):
             new_bucket = CalculationBucket(
                 self._manager_class,
-                self.filters.copy(),
-                self.excludes.copy(),
+                self.filter_definitions.copy(),
+                self.exclude_definitions.copy(),
                 self.sort_key,
                 self.reverse,
             )
-            new_bucket._current_combinations = result
+            new_bucket._data = result
             return new_bucket
         return self._manager_class(**result)
 
@@ -482,7 +636,11 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             CalculationBucket: A new bucket instance sorted according to the specified key and order.
         """
         return CalculationBucket(
-            self._manager_class, self.filters, self.excludes, key, reverse
+            self._manager_class,
+            self.filter_definitions,
+            self.exclude_definitions,
+            key,
+            reverse,
         )
 
     def none(self) -> CalculationBucket[GeneralManagerType]:

general_manager/bucket/databaseBucket.py

@@ -4,6 +4,7 @@ from django.db import models
 from general_manager.interface.baseInterface import (
     GeneralManagerType,
 )
+from general_manager.utils.filterParser import create_filter_function
 from general_manager.bucket.baseBucket import Bucket
 
 from general_manager.manager.generalManager import GeneralManager
@@ -94,19 +95,78 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             kwarg_filter[key].append(value)
         return kwarg_filter
 
+    def __parseFilterDeifintions(self, **kwargs: Any):
+        annotations: dict[str, Any] = {}
+        orm_kwargs: dict[str, list[Any]] = {}
+        python_filters: list[tuple[str, Any, str]] = []
+        properties = self._manager_class.Interface.getGraphQLProperties()
+
+        for k, v in kwargs.items():
+            root = k.split("__")[0]
+            if root in properties:
+                if not properties[root].filterable:
+                    raise ValueError(
+                        f"Property '{root}' is not filterable in {self._manager_class.__name__}"
+                    )
+                prop = properties[root]
+                if prop.query_annotation is not None:
+                    annotations[root] = prop.query_annotation
+                    orm_kwargs[k] = v
+                else:
+                    python_filters.append((k, v, root))
+            else:
+                orm_kwargs[k] = v
+
+        return annotations, orm_kwargs, python_filters
+
+    def __parsePythonFilters(
+        self, query_set: models.QuerySet, python_filters: list[tuple[str, Any, str]]
+    ) -> list[int]:
+        ids: list[int] = []
+        for obj in query_set:
+            inst = self._manager_class(obj.pk)
+            keep = True
+            for k, val, root in python_filters:
+                lookup = k.split("__", 1)[1] if "__" in k else ""
+                func = create_filter_function(lookup, val)
+                if not func(getattr(inst, root)):
+                    keep = False
+                    break
+            if keep:
+                ids.append(obj.pk)
+        return ids
+
     def filter(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
         """
         Returns a new bucket with manager instances matching the combined filter criteria.
 
         Additional filter arguments are merged with any existing filters to further restrict the queryset, producing a new DatabaseBucket instance.
         """
-        merged_filter = self.__mergeFilterDefinitions(self.filters, **kwargs)
-        return self.__class__(
-            self._data.filter(**kwargs),
-            self._manager_class,
-            merged_filter,
-            self.excludes,
+        annotations, orm_kwargs, python_filters = self.__parseFilterDeifintions(
+            **kwargs
         )
+        qs = self._data
+        if annotations:
+            other_annotations: dict[str, Any] = {}
+            for key, value in annotations.items():
+                if not callable(value):
+                    other_annotations[key] = value
+                    continue
+                qs = value(qs)
+            if not isinstance(qs, models.QuerySet):
+                raise TypeError("Query annotation must return a Django QuerySet")
+            qs = qs.annotate(**other_annotations)
+        try:
+            qs = qs.filter(**orm_kwargs)
+        except Exception as e:
+            raise ValueError(f"Error filtering queryset: {e}")
+
+        if python_filters:
+            ids = self.__parsePythonFilters(qs, python_filters)
+            qs = qs.filter(pk__in=ids)
+
+        merged_filter = self.__mergeFilterDefinitions(self.filters, **kwargs)
+        return self.__class__(qs, self._manager_class, merged_filter, self.excludes)
 
     def exclude(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
         """
@@ -114,13 +174,28 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
 
         Keyword arguments specify field lookups to exclude from the queryset. The resulting bucket contains only items that do not satisfy these exclusion filters.
         """
-        merged_exclude = self.__mergeFilterDefinitions(self.excludes, **kwargs)
-        return self.__class__(
-            self._data.exclude(**kwargs),
-            self._manager_class,
-            self.filters,
-            merged_exclude,
+        annotations, orm_kwargs, python_filters = self.__parseFilterDeifintions(
+            **kwargs
         )
+        qs = self._data
+        if annotations:
+            other_annotations: dict[str, Any] = {}
+            for key, value in annotations.items():
+                if not callable(value):
+                    other_annotations[key] = value
+                    continue
+                qs = value(qs)
+            if not isinstance(qs, models.QuerySet):
+                raise TypeError("Query annotation must return a Django QuerySet")
+            qs = qs.annotate(**other_annotations)
+        qs = qs.exclude(**orm_kwargs)
+
+        if python_filters:
+            ids = self.__parsePythonFilters(qs, python_filters)
+            qs = qs.exclude(pk__in=ids)
+
+        merged_exclude = self.__mergeFilterDefinitions(self.excludes, **kwargs)
+        return self.__class__(qs, self._manager_class, self.filters, merged_exclude)
 
     def first(self) -> GeneralManagerType | None:
         """
@@ -184,11 +259,17 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         """
         return self._data.count()
 
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the bucket, showing the manager class name and the underlying queryset.
+        """
+        return f"{self._manager_class.__name__}Bucket {self._data} ({len(self._data)} items)"
+
     def __repr__(self) -> str:
         """
         Returns a string representation of the bucket, showing the manager class name and the underlying queryset.
         """
-        return f"{self._manager_class.__name__}Bucket ({self._data})"
+        return f"DatabaseBucket ({self._data}, manager_class={self._manager_class.__name__}, filters={self.filters}, excludes={self.excludes})"
 
     def __contains__(self, item: GeneralManagerType | models.Model) -> bool:
         """
@@ -222,11 +303,61 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         """
         if isinstance(key, str):
             key = (key,)
-        if reverse:
-            sorted_data = self._data.order_by(*[f"-{k}" for k in key])
+        properties = self._manager_class.Interface.getGraphQLProperties()
+        annotations: dict[str, Any] = {}
+        python_keys: list[str] = []
+        qs = self._data
+        for k in key:
+            if k in properties:
+                prop = properties[k]
+                if not prop.sortable:
+                    raise ValueError(
+                        f"Property '{k}' is not sortable in {self._manager_class.__name__}"
+                    )
+                if prop.query_annotation is not None:
+                    if callable(prop.query_annotation):
+                        qs = prop.query_annotation(qs)
+                    else:
+                        annotations[k] = prop.query_annotation
+                else:
+                    python_keys.append(k)
+        if not isinstance(qs, models.QuerySet):
+            raise TypeError("Query annotation must return a Django QuerySet")
+        if annotations:
+            qs = qs.annotate(**annotations)
+
+        if python_keys:
+            objs = list(qs)
+
+            def key_func(obj):
+                inst = self._manager_class(obj.pk)
+                values = []
+                for k in key:
+                    if k in properties:
+                        if k in python_keys:
+                            values.append(getattr(inst, k))
+                        else:
+                            values.append(getattr(obj, k))
+                    else:
+                        values.append(getattr(obj, k))
+                return tuple(values)
+
+            objs.sort(key=key_func, reverse=reverse)
+            ordered_ids = [obj.pk for obj in objs]
+            case = models.Case(
+                *[models.When(pk=pk, then=pos) for pos, pk in enumerate(ordered_ids)],
+                output_field=models.IntegerField(),
+            )
+            qs = qs.filter(pk__in=ordered_ids).annotate(_order=case).order_by("_order")
         else:
-            sorted_data = self._data.order_by(*key)
-        return self.__class__(sorted_data, self._manager_class)
+            order_fields = [f"-{k}" if reverse else k for k in key]
+            try:
+                qs = qs.order_by(*order_fields)
+            except Exception as e:
+                raise ValueError(f"Error ordering queryset: {e}")
+
+        return self.__class__(qs, self._manager_class)
+
 
     def none(self) -> DatabaseBucket[GeneralManagerType]:
         """
@@ -237,3 +368,4 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         own = self.all()
         own._data = own._data.none()
         return own
+

general_manager/interface/baseInterface.py

@@ -13,7 +13,9 @@ from typing import (
 from datetime import datetime
 from django.conf import settings
 from django.db.models import Model
+
 from general_manager.utils import args_to_kwargs
+from general_manager.api.property import GraphQLProperty
 
 if TYPE_CHECKING:
     from general_manager.manager.input import Input
@@ -60,8 +62,8 @@ class InterfaceBase(ABC):
     input_fields: dict[str, Input]
 
     def __init__(self, *args: Any, **kwargs: Any):
-        self.identification = self.parseInputFieldsToIdentification(*args, **kwargs)
-        self.formatIdentification()
+        identification = self.parseInputFieldsToIdentification(*args, **kwargs)
+        self.identification = self.formatIdentification(identification)
 
     def parseInputFieldsToIdentification(
         self,
@@ -113,18 +115,27 @@ class InterfaceBase(ABC):
                 )
         return identification
 
-    def formatIdentification(self) -> dict[str, Any]:
+    @staticmethod
+    def formatIdentification(identification: dict[str, Any]) -> dict[str, Any]:
         from general_manager.manager.generalManager import GeneralManager
 
-        for key, value in self.identification.items():
+        for key, value in identification.items():
             if isinstance(value, GeneralManager):
-                self.identification[key] = value.identification
+                identification[key] = value.identification
             elif isinstance(value, (list, tuple)):
-                self.identification[key] = [
-                    v.identification if isinstance(v, GeneralManager) else v
-                    for v in value
-                ]
-        return self.identification
+                identification[key] = []
+                for v in value:
+                    if isinstance(v, GeneralManager):
+                        identification[key].append(v.identification)
+                    elif isinstance(v, dict):
+                        identification[key].append(
+                            InterfaceBase.formatIdentification(v)
+                        )
+                    else:
+                        identification[key].append(v)
+            elif isinstance(value, dict):
+                identification[key] = InterfaceBase.formatIdentification(value)
+        return identification
 
     def _process_input(
         self, name: str, value: Any, identification: dict[str, Any]
@@ -184,6 +195,17 @@ class InterfaceBase(ABC):
     def getAttributes(cls) -> dict[str, Any]:
         raise NotImplementedError
 
+    @classmethod
+    def getGraphQLProperties(cls) -> dict[str, GraphQLProperty]:
+        """Return GraphQL properties defined on the parent manager."""
+        if not hasattr(cls, "_parent_class"):
+            return {}
+        return {
+            name: prop
+            for name, prop in vars(cls._parent_class).items()
+            if isinstance(prop, GraphQLProperty)
+        }
+
     @classmethod
     @abstractmethod
     def filter(cls, **kwargs: Any) -> Bucket[Any]: