GeneralManager 0.10.2__tar.gz → 0.10.4__tar.gz

{generalmanager-0.10.2 → generalmanager-0.10.4}/GeneralManager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.10.2
+Version: 0.10.4
 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-Expression: MIT

{generalmanager-0.10.2 → generalmanager-0.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.10.2
+Version: 0.10.4
 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-Expression: MIT

{generalmanager-0.10.2 → generalmanager-0.10.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.10.2"
+version = "0.10.4"
 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.10.2 → generalmanager-0.10.4}/src/general_manager/api/graphql.py

@@ -102,9 +102,9 @@ class GraphQL:
     @classmethod
     def createGraphqlInterface(cls, generalManagerClass: GeneralManagerMeta) -> None:
         """
-        Generates and registers a GraphQL ObjectType for the specified GeneralManager class.
+        Generates and registers a GraphQL ObjectType for a given GeneralManager class.
         
-        This method maps interface attributes and GraphQLProperty attributes to Graphene fields, creates corresponding resolvers, registers the resulting type in the internal registry, and attaches relevant query fields to the schema.
+        This method maps interface and GraphQLProperty attributes to Graphene fields, creates resolvers for each field, registers the resulting type in the internal registry, and adds corresponding query fields to the schema.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -348,14 +348,7 @@ class GraphQL:
         base_getter: Callable[[Any], Any], fallback_manager_class: type[GeneralManager]
     ) -> Callable[..., Any]:
         """
-        Creates a resolver function for list fields that applies permission filters, query filters, sorting, pagination, and optional grouping to a queryset.
-        
-        Parameters:
-            base_getter (Callable): Function to obtain the base queryset from the parent instance.
-            fallback_manager_class (type[GeneralManager]): Manager class to use if the queryset does not specify one.
-        
-        Returns:
-            Callable: A resolver function for use in GraphQL list fields.
+        Returns a resolver function for GraphQL list fields that retrieves a queryset, applies permission-based filtering, query filters, sorting, pagination, and optional grouping, and returns the resulting data.
         """
 
         def resolver(
@@ -370,19 +363,19 @@ class GraphQL:
             group_by: list[str] | None = None,
         ) -> Any:
             """
-            Resolves a list field by applying permission filters, query parameters, sorting, pagination, and optional grouping to a queryset.
+            Resolves a list field by returning a queryset filtered by permissions, query parameters, sorting, pagination, and optional grouping.
             
             Parameters:
-                filter: Optional filter criteria as a dictionary or JSON string.
-                exclude: Optional exclusion criteria as a dictionary or JSON string.
-                sort_by: Optional sorting field as a Graphene Enum.
-                reverse: If True, reverses the sort order.
-                page: Optional page number for pagination.
-                page_size: Optional number of items per page.
-                group_by: Optional list of field names to group results by.
+                filter: Filter criteria as a dictionary or JSON string.
+                exclude: Exclusion criteria as a dictionary or JSON string.
+                sort_by: Field to sort by, as a Graphene Enum.
+                reverse: Whether to reverse the sort order.
+                page: Page number for pagination.
+                page_size: Number of items per page.
+                group_by: List of field names to group results by.
             
             Returns:
-                The filtered, sorted, paginated, and optionally grouped queryset.
+                A queryset with applied permission filters, filtering, sorting, pagination, and grouping.
             """
             base_queryset = base_getter(self)
             # use _manager_class from the attribute if available, otherwise fallback
@@ -460,7 +453,7 @@ class GraphQL:
         """
         Adds list and single-item query fields for a GeneralManager-derived class to the GraphQL schema.
         
-        This method registers both a list query (with filtering, sorting, pagination, and grouping) and a single-item query (using identification fields) for the specified manager class. The corresponding resolvers are also attached to the schema.
+        Registers a list query supporting filtering, sorting, pagination, and grouping, as well as a single-item query using identification fields for the specified manager class. The corresponding resolvers are attached to the schema.
         """
         if not issubclass(generalManagerClass, GeneralManager):
             raise TypeError(
@@ -526,10 +519,10 @@ class GraphQL:
         """
         Generate a dictionary of Graphene input fields for mutations based on the attributes of the provided interface class.
         
-        Skips fields that are system-managed (`changed_by`, `created_at`, `updated_at`) or marked as derived. For attributes referencing `GeneralManager` subclasses, uses ID fields; for list references, uses a list of IDs. All other types are mapped to their corresponding Graphene scalar types. Each field is annotated with an `editable` attribute indicating if it can be modified. Adds an optional `history_comment` field marked as editable.
+        Skips system-managed fields and derived attributes. For attributes referencing `GeneralManager` subclasses, uses ID or list of IDs as appropriate. Other types are mapped to their corresponding Graphene scalar types. Each field is annotated with an `editable` attribute. Adds an optional `history_comment` field marked as editable.
         
         Returns:
-            dict[str, Any]: A dictionary mapping attribute names to Graphene input fields for use in mutation arguments.
+            dict[str, Any]: Mapping of attribute names to Graphene input fields for mutation arguments.
         """
         fields: dict[str, Any] = {}
 
@@ -579,12 +572,12 @@ class GraphQL:
         default_return_values: dict[str, Any],
     ) -> type[graphene.Mutation] | None:
         """
-        Generates a Graphene mutation class for creating an instance of the specified GeneralManager subclass.
+        Dynamically generates a Graphene mutation class for creating an instance of the specified GeneralManager subclass.
         
-        The generated mutation class defines a `mutate` method that filters out fields with `NOT_PROVIDED` values, invokes the `create` method on the manager class with the provided arguments and the current user's ID, and returns a dictionary indicating success or failure along with any errors and the created instance.
+        The generated mutation class includes a `mutate` method that filters out fields with `NOT_PROVIDED` values, invokes the manager's `create` method with the provided arguments and the current user's ID, and returns a dictionary indicating success, any errors, and the created instance. Returns None if the manager class does not define an interface.
         
         Returns:
-            The generated Graphene mutation class, or None if the manager class does not define an interface.
+            The generated Graphene mutation class, or None if no interface is defined for the manager class.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -595,12 +588,12 @@ class GraphQL:
         def create_mutation(
             self,
             info: GraphQLResolveInfo,
-            **kwargs: dict[str, Any],
+            **kwargs: Any,
         ) -> dict:
             """
-            Creates a new instance of the specified manager class using provided input arguments.
+            Creates a new instance of the manager class with the provided arguments.
             
-            Filters out fields with default "not provided" values before creation. Returns a dictionary indicating success status, any errors encountered, and the created instance under a key named after the manager class.
+            Filters out fields with values marked as `NOT_PROVIDED` before creation. Returns a dictionary containing a success flag, a list of errors (if any), and the created instance under a key named after the manager class.
             """
             try:
                 kwargs = {
@@ -651,9 +644,9 @@ class GraphQL:
         default_return_values: dict[str, Any],
     ) -> type[graphene.Mutation] | None:
         """
-        Generates a GraphQL mutation class for updating an instance of a GeneralManager subclass.
+        Generates a GraphQL mutation class for updating instances of a GeneralManager subclass.
         
-        The generated mutation accepts editable fields as arguments, calls the `update` method on the manager instance, and returns a dictionary indicating success, errors, and the updated instance. If the manager class does not define an `Interface`, returns None.
+        The generated mutation accepts editable fields as arguments, invokes the manager's `update` method with the provided values, and returns a dictionary indicating success, any errors, and the updated instance. Returns None if the manager class does not define an `Interface`.
         
         Returns:
             The generated Graphene mutation class, or None if no interface is defined.
@@ -667,17 +660,17 @@ class GraphQL:
         def update_mutation(
             self,
             info: GraphQLResolveInfo,
-            **kwargs: dict[str, Any],
+            **kwargs: Any,
         ) -> dict:
             """
-            Handles the update mutation for a GeneralManager instance, applying provided field updates and returning the operation result.
+            Performs an update mutation on a GeneralManager instance with the specified fields.
             
             Parameters:
-                info (GraphQLResolveInfo): GraphQL resolver context containing user and request information.
+                info (GraphQLResolveInfo): The GraphQL resolver context, typically containing user and request information.
                 **kwargs: Fields to update, including the required 'id' of the instance.
             
             Returns:
-                dict: A dictionary containing the success status, any error messages, and the updated instance keyed by its class name.
+                dict: Contains the operation's success status, a list of error messages if any, and the updated instance keyed by its class name.
             """
             try:
                 manager_id = kwargs.pop("id", None)
@@ -725,7 +718,7 @@ class GraphQL:
         """
         Generates a GraphQL mutation class for deleting (deactivating) an instance of a GeneralManager subclass.
         
-        The generated mutation accepts input fields defined in the manager's interface, deactivates the specified instance, and returns a dictionary indicating success or failure, along with any errors and the deleted instance.
+        The generated mutation accepts input fields defined in the manager's interface, deactivates the specified instance using its ID, and returns a dictionary with the operation's success status, any error messages, and the deactivated instance.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -736,13 +729,13 @@ class GraphQL:
         def delete_mutation(
             self,
             info: GraphQLResolveInfo,
-            **kwargs: dict[str, Any],
+            **kwargs: Any,
         ) -> dict:
             """
-            Deletes (deactivates) an instance of the specified GeneralManager class and returns the operation result.
+            Deactivates an instance of the specified GeneralManager class and returns the result.
             
             Returns:
-                dict: A dictionary containing the success status, any error messages, and the deactivated instance under the class name key.
+                dict: Contains the operation's success status, a list of error messages if any, and the deactivated instance keyed by the class name.
             """
             try:
                 manager_id = kwargs.pop("id", None)

{generalmanager-0.10.2 → generalmanager-0.10.4}/src/general_manager/apps.py

@@ -43,12 +43,12 @@ class GeneralmanagerConfig(AppConfig):
 
     @staticmethod
     def handleReadOnlyInterface(
-        read_only_classes: list[Type[GeneralManager[Any, ReadOnlyInterface]]],
+        read_only_classes: list[Type[GeneralManager]],
     ):
         """
-        Configures synchronization and schema validation for the provided read-only interface classes.
-
-        Ensures that each read-only interface is synchronized before Django management commands run, and registers system checks to validate that their schemas are up to date.
+        Configures synchronization and schema validation for the given read-only GeneralManager classes.
+        
+        For each provided class, ensures that its data is synchronized before any Django management command executes, and registers a system check to verify that the associated schema remains up to date.
         """
         GeneralmanagerConfig.patchReadOnlyInterfaceSync(read_only_classes)
         from general_manager.interface.readOnlyInterface import ReadOnlyInterface
@@ -68,11 +68,11 @@ class GeneralmanagerConfig(AppConfig):
 
     @staticmethod
     def patchReadOnlyInterfaceSync(
-        general_manager_classes: list[Type[GeneralManager[Any, ReadOnlyInterface]]],
+        general_manager_classes: list[Type[GeneralManager]],
     ):
         """
         Monkey-patches Django's management command runner to synchronize all provided read-only interfaces before executing any management command, except during autoreload subprocesses of 'runserver'.
-
+        
         For each class in `general_manager_classes`, the associated read-only interface's `syncData` method is called prior to command execution, ensuring data consistency before management operations.
         """
         from general_manager.interface.readOnlyInterface import ReadOnlyInterface

{generalmanager-0.10.2 → generalmanager-0.10.4}/src/general_manager/bucket/baseBucket.py

@@ -15,6 +15,7 @@ if TYPE_CHECKING:
     from general_manager.manager.generalManager import GeneralManager
     from general_manager.manager.groupManager import GroupManager
     from general_manager.bucket.groupBucket import GroupBucket
+    from general_manager.interface.baseInterface import InterfaceBase
 
 
 class Bucket(ABC, Generic[GeneralManagerType]):
@@ -22,7 +23,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     def __init__(self, manager_class: Type[GeneralManagerType]):
         """
         Initializes the Bucket with a specified manager class.
-        
+
         Args:
             manager_class: The class of manager objects this bucket will manage.
         """
@@ -34,7 +35,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     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.
         """
@@ -45,7 +46,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     def __reduce__(self) -> str | tuple[Any, ...]:
         """
         Prepares the object for pickling by returning the class and initialization arguments.
-        
+
         Returns:
             A tuple containing the class and a tuple of arguments needed to reconstruct the object during unpickling.
         """
@@ -56,12 +57,13 @@ class Bucket(ABC, Generic[GeneralManagerType]):
 
     @abstractmethod
     def __or__(
-        self, other: Bucket[GeneralManagerType] | GeneralManager[GeneralManagerType]
+        self,
+        other: Bucket[GeneralManagerType] | GeneralManagerType,
     ) -> Bucket[GeneralManagerType]:
         """
-        Returns a new bucket representing the union of this bucket and another bucket or manager instance.
+        Return a new bucket containing the union of this bucket and another bucket or manager instance.
         
-        Args:
+        Parameters:
             other: Another bucket or a single manager instance to combine with this bucket.
         
         Returns:
@@ -72,10 +74,10 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     @abstractmethod
     def __iter__(
         self,
-    ) -> Generator[GeneralManagerType | GroupManager[GeneralManagerType]]:
+    ) -> Generator[GeneralManagerType | GroupManager[GeneralManagerType], None, None]:
         """
         Returns an iterator over the items in the bucket.
-        
+
         Yields:
             Instances of the managed type or group manager contained in the bucket.
         """
@@ -85,10 +87,10 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     def filter(self, **kwargs: Any) -> Bucket[GeneralManagerType]:
         """
         Returns a new bucket containing only items that match the specified filter criteria.
-        
+
         Args:
             **kwargs: Field-value pairs used to filter items in the bucket.
-        
+
         Returns:
             A new Bucket instance with items matching the given criteria.
         """
@@ -98,10 +100,10 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     def exclude(self, **kwargs: Any) -> Bucket[GeneralManagerType]:
         """
         Returns a new Bucket excluding items that match the specified criteria.
-        
+
         Args:
             **kwargs: Field-value pairs specifying the exclusion criteria.
-        
+
         Returns:
             A new Bucket instance with items matching the criteria excluded.
         """
@@ -111,7 +113,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     def first(self) -> GeneralManagerType | GroupManager[GeneralManagerType] | None:
         """
         Returns the first item in the bucket, or None if the bucket is empty.
-        
+
         Returns:
             The first GeneralManager or GroupManager instance, or None if no items exist.
         """
@@ -121,7 +123,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     def last(self) -> GeneralManagerType | GroupManager[GeneralManagerType] | None:
         """
         Returns the last item in the bucket, or None if the bucket is empty.
-        
+
         Returns:
             The last GeneralManager or GroupManager instance, or None if no items exist.
         """
@@ -131,7 +133,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     def count(self) -> int:
         """
         Returns the number of items in the bucket.
-        
+
         Subclasses must implement this method to provide the count of contained elements.
         """
         raise NotImplementedError
@@ -140,7 +142,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     def all(self) -> Bucket[GeneralManagerType]:
         """
         Returns a bucket containing all items managed by this instance.
-        
+
         Subclasses must implement this method to provide access to the complete collection without filters or exclusions applied.
         """
         raise NotImplementedError
@@ -151,13 +153,13 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     ) -> GeneralManagerType | GroupManager[GeneralManagerType]:
         """
         Retrieves a single item matching the specified criteria.
-        
+
         Args:
             **kwargs: Field-value pairs used to identify the item.
-        
+
         Returns:
             The matching GeneralManager or GroupManager instance.
-        
+
         Raises:
             NotImplementedError: If the method is not implemented by a subclass.
         """
@@ -173,13 +175,13 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     ):
         """
         Retrieves an item or a slice from the bucket.
-        
+
         Args:
             item: An integer index to retrieve a single element, or a slice to retrieve a subset.
-        
+
         Returns:
             A single manager instance if an integer is provided, or a new Bucket containing the sliced elements if a slice is provided.
-        
+
         Raises:
             NotImplementedError: This method must be implemented by subclasses.
         """
@@ -189,7 +191,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     def __len__(self) -> int:
         """
         Returns the number of items in the bucket.
-        
+
         Subclasses must implement this method to provide the count of contained elements.
         """
         raise NotImplementedError
@@ -198,12 +200,12 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     def __contains__(self, item: GeneralManagerType) -> bool:
         """
         Checks whether the specified item is present in the bucket.
-        
+
         Args:
-        	item: The manager instance to check for membership.
-        
+                item: The manager instance to check for membership.
+
         Returns:
-        	True if the item is contained in the bucket, otherwise False.
+                True if the item is contained in the bucket, otherwise False.
         """
         raise NotImplementedError
 
@@ -215,11 +217,11 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     ) -> Bucket[GeneralManagerType]:
         """
         Returns a new Bucket with items sorted by the specified key or keys.
-        
+
         Args:
             key: A string or tuple of strings specifying the attribute(s) to sort by.
             reverse: If True, sorts in descending order. Defaults to False.
-        
+
         Returns:
             A new Bucket instance with items sorted according to the given key(s).
         """
@@ -228,10 +230,10 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     def group_by(self, *group_by_keys: str) -> GroupBucket[GeneralManagerType]:
         """
         Groups the bucket's data by one or more specified keys.
-        
+
         Args:
             *group_by_keys: One or more attribute names to group the data by.
-        
+
         Returns:
             A GroupBucket instance containing the grouped data.
         """

{generalmanager-0.10.2 → generalmanager-0.10.4}/src/general_manager/bucket/calculationBucket.py

@@ -92,19 +92,18 @@ class CalculationBucket(Bucket[GeneralManagerType]):
 
     def __or__(
         self,
-        other: (
-            Bucket[GeneralManagerType]
-            | GeneralManager[GeneralManagerType, CalculationInterface]
-        ),
+        other: Bucket[GeneralManagerType] | GeneralManagerType,
     ) -> CalculationBucket[GeneralManagerType]:
         """
-        Combines this CalculationBucket with another bucket or manager of the same type.
-
-        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 with filters and excludes that are present and identical in both.
-
+        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.
         """
         from general_manager.manager.generalManager import GeneralManager
 
@@ -190,7 +189,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         """
         return self
 
-    def __iter__(self) -> Generator[GeneralManagerType]:
+    def __iter__(self) -> Generator[GeneralManagerType, None, None]:
         """
         Yields manager instances for each valid combination of input parameters.
 

{generalmanager-0.10.2 → generalmanager-0.10.4}/src/general_manager/bucket/databaseBucket.py

@@ -1,10 +1,5 @@
 from __future__ import annotations
-from typing import (
-    Type,
-    Any,
-    Generator,
-    TypeVar,
-)
+from typing import Type, Any, Generator, TypeVar, TYPE_CHECKING
 from django.db import models
 from general_manager.interface.baseInterface import (
     GeneralManagerType,
@@ -15,6 +10,9 @@ from general_manager.manager.generalManager import GeneralManager
 
 modelsModel = TypeVar("modelsModel", bound=models.Model)
 
+if TYPE_CHECKING:
+    from general_manager.interface.databaseInterface import DatabaseInterface
+
 
 class DatabaseBucket(Bucket[GeneralManagerType]):
 
@@ -26,21 +24,20 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         exclude_definitions: dict[str, list[Any]] | None = None,
     ):
         """
-        Initializes a DatabaseBucket with a queryset, manager class, and optional filter and exclude definitions.
+        Initialize a DatabaseBucket with a Django queryset, a manager class, and optional filter and exclude definitions.
 
-        If no queryset is provided, constructs one using the manager class and the given filters and excludes. Stores the queryset, manager class, and copies of the filter and exclude definitions for further operations.
+        Parameters:
+            data (QuerySet): The Django queryset containing model instances to be managed.
+            manager_class (Type[GeneralManagerType]): The manager class used to wrap model instances.
+            filter_definitions (dict[str, list[Any]], optional): Initial filter criteria for the queryset.
+            exclude_definitions (dict[str, list[Any]], optional): Initial exclude criteria for the queryset.
         """
-        if data is None:
-            data = manager_class.Interface._model.objects.filter(
-                **filter_definitions
-            ).exclude(**exclude_definitions)
         self._data = data
-
         self._manager_class = manager_class
         self.filters = {**(filter_definitions or {})}
         self.excludes = {**(exclude_definitions or {})}
 
-    def __iter__(self) -> Generator[GeneralManagerType]:
+    def __iter__(self) -> Generator[GeneralManagerType, None, None]:
         """
         Yields manager instances for each item in the underlying queryset.
 
@@ -51,15 +48,15 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
 
     def __or__(
         self,
-        other: Bucket[GeneralManagerType] | GeneralManager[GeneralManagerType],
+        other: Bucket[GeneralManagerType] | GeneralManagerType,
     ) -> DatabaseBucket[GeneralManagerType]:
         """
-        Combines this bucket with another bucket or manager instance using the union operator.
+        Return a new bucket containing the union of this bucket and another bucket or manager instance.
 
-        If `other` is a manager instance of the same class, creates a bucket containing only that instance and combines it. If `other` is a compatible bucket, returns a new bucket containing the union of both buckets' querysets. Raises a `ValueError` if the types or manager classes are incompatible.
+        If `other` is a manager instance of the same class, it is converted to a bucket before combining. If `other` is a compatible bucket, the resulting bucket contains all unique items from both. Raises a `ValueError` if the types or manager classes are incompatible.
 
         Returns:
-            A new `DatabaseBucket` containing the combined items.
+            DatabaseBucket[GeneralManagerType]: A new bucket with the combined items.
         """
         if isinstance(other, GeneralManager) and other.__class__ == self._manager_class:
             return self.__or__(
@@ -195,10 +192,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
 
     def __contains__(self, item: GeneralManagerType | models.Model) -> bool:
         """
-        Checks if a manager instance or model instance is present in the bucket.
-
-        Args:
-            item: A manager instance or Django model instance to check for membership.
+        Determine whether a manager instance or Django model instance is present in the bucket.
 
         Returns:
             True if the item's primary key exists in the underlying queryset; otherwise, False.
@@ -209,7 +203,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             return item.identification.get("id", None) in self._data.values_list(
                 "pk", flat=True
             )
-        return item in self._data
+        return item.pk in self._data.values_list("pk", flat=True)
 
     def sort(
         self,
@@ -217,14 +211,14 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         reverse: bool = False,
     ) -> DatabaseBucket:
         """
-        Returns a new DatabaseBucket sorted by the specified field or fields.
+        Return a new DatabaseBucket sorted by the specified field or fields.
 
-        Args:
-            key: A field name or tuple of field names to sort by.
-            reverse: If True, sorts in descending order.
+        Parameters:
+            key (str or tuple of str): Field name or tuple of field names to sort by.
+            reverse (bool): If True, sort in descending order.
 
         Returns:
-            A new DatabaseBucket instance with the sorted queryset.
+            DatabaseBucket: A new bucket instance containing the sorted queryset.
         """
         if isinstance(key, str):
             key = (key,)

{generalmanager-0.10.2 → generalmanager-0.10.4}/src/general_manager/bucket/groupBucket.py

@@ -117,7 +117,7 @@ class GroupBucket(Bucket[GeneralManagerType]):
             self._basis_data | other._basis_data,
         )
 
-    def __iter__(self) -> Generator[GroupManager[GeneralManagerType]]:
+    def __iter__(self) -> Generator[GroupManager[GeneralManagerType], None, None]:
         """
         Yields each grouped manager in the current GroupBucket.
 

{generalmanager-0.10.2 → generalmanager-0.10.4}/src/general_manager/cache/modelDependencyCollector.py

@@ -11,15 +11,17 @@ from general_manager.cache.dependencyIndex import (
 class ModelDependencyCollector:
 
     @staticmethod
-    def collect(obj) -> Generator[tuple[general_manager_name, filter_type, str]]:
+    def collect(
+        obj,
+    ) -> Generator[tuple[general_manager_name, filter_type, str], None, None]:
         """
         Recursively extracts dependency information from Django model-related objects.
-        
+
         Inspects the input object and its nested structures to identify instances of GeneralManager and Bucket, yielding a tuple for each dependency found. Each tuple contains the manager class name, the dependency type ("identification", "filter", or "exclude"), and the string representation of the dependency value.
-        
+
         Args:
             obj: The object or collection to inspect for model dependencies.
-        
+
         Yields:
             Tuples of (manager class name, dependency type, dependency value) for each dependency discovered.
         """