GeneralManager 0.12.2__tar.gz → 0.13.1__tar.gz

{generalmanager-0.12.2 → generalmanager-0.13.1}/GeneralManager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.12.2
+Version: 0.13.1
 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.12.2 → generalmanager-0.13.1}/PKG-INFO

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

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

@@ -384,10 +384,16 @@ class GraphQL:
         info: GraphQLResolveInfo,
     ) -> Bucket:
         """
-        Wendet die vom Permission-Interface vorgegebenen Filter auf das Queryset an.
+        Applies permission-based filters to a queryset according to the permission interface of the given manager class.
+        
+        Returns:
+            A queryset containing only the items allowed by the user's read permissions. If no permission filters are defined, returns the original queryset unchanged.
         """
         permission_filters = getReadPermissionFilter(general_manager_class, info)
-        filtered_queryset = queryset
+        if not permission_filters:
+            return queryset
+
+        filtered_queryset = queryset.none()
         for perm_filter, perm_exclude in permission_filters:
             qs_perm = queryset.exclude(**perm_exclude).filter(**perm_filter)
             filtered_queryset = filtered_queryset | qs_perm

{generalmanager-0.12.2 → generalmanager-0.13.1}/src/general_manager/bucket/baseBucket.py

@@ -61,13 +61,13 @@ class Bucket(ABC, Generic[GeneralManagerType]):
         other: Bucket[GeneralManagerType] | GeneralManagerType,
     ) -> Bucket[GeneralManagerType]:
         """
-        Return a new bucket containing the union of this bucket and another bucket or manager instance.
+        Return a new bucket representing the union of this bucket and another bucket or a single manager instance.
         
         Parameters:
-            other: Another bucket or a single manager instance to combine with this bucket.
+            other: Another bucket or a single manager instance to include in the union.
         
         Returns:
-            A new bucket containing all unique items from both sources.
+            A new bucket containing all unique items from both this bucket and the provided argument.
         """
         raise NotImplementedError
 
@@ -229,14 +229,23 @@ 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.
-
+        Return a GroupBucket that groups the items in this bucket by the specified attribute keys.
+        
+        Parameters:
+            *group_by_keys (str): Attribute names to group the items by.
+        
         Returns:
-            A GroupBucket instance containing the grouped data.
+            GroupBucket[GeneralManagerType]: A bucket containing items grouped by the given keys.
         """
         from general_manager.bucket.groupBucket import GroupBucket
 
         return GroupBucket(self._manager_class, group_by_keys, self)
+
+    def none(self) -> Bucket[GeneralManagerType]:
+        """
+        Raise NotImplementedError to indicate that subclasses must implement a method returning an empty bucket.
+        """
+        raise NotImplementedError(
+            "The 'none' method is not implemented in the base Bucket class. "
+            "Subclasses should implement this method to return an empty bucket."
+        )

{generalmanager-0.12.2 → generalmanager-0.13.1}/src/general_manager/bucket/calculationBucket.py

@@ -9,6 +9,7 @@ from typing import (
     Generator,
     List,
 )
+from copy import deepcopy
 from general_manager.interface.baseInterface import (
     generalManagerClassName,
     GeneralManagerType,
@@ -95,13 +96,13 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         other: Bucket[GeneralManagerType] | GeneralManagerType,
     ) -> CalculationBucket[GeneralManagerType]:
         """
-        Combine this CalculationBucket with another bucket or manager instance of the same manager class.
+        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 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.
+        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.
         
         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.
         """
@@ -183,17 +184,18 @@ class CalculationBucket(Bucket[GeneralManagerType]):
 
     def all(self) -> CalculationBucket:
         """
-        Returns the current CalculationBucket instance.
-
-        This method allows for compatibility with interfaces expecting an `all()` method that returns the full set of items.
+        Return a deep copy of the current CalculationBucket instance.
+        
+        Use this method to obtain an independent copy of the bucket, ensuring that modifications to the returned instance do not affect the original.
         """
-        return self
+        return deepcopy(self)
 
     def __iter__(self) -> Generator[GeneralManagerType, None, None]:
         """
-        Yields manager instances for each valid combination of input parameters.
-
-        Iterates over all generated input combinations, instantiating the manager class with each set of parameters.
+        Iterate over all valid input combinations, yielding a manager instance for each.
+        
+        Yields:
+            Manager instances created with each valid set of input parameters.
         """
         combinations = self.generate_combinations()
         for combo in combinations:
@@ -470,15 +472,27 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         self, key: str | tuple[str], reverse: bool = False
     ) -> CalculationBucket[GeneralManagerType]:
         """
-        Returns a new CalculationBucket with updated sorting parameters.
-
-        Args:
-            key: The field name or tuple of field names to sort combinations by.
-            reverse: If True, sorts in descending order.
-
+        Return a new CalculationBucket instance with updated sorting criteria.
+        
+        Parameters:
+            key (str or tuple of str): Field name(s) to sort the combinations by.
+            reverse (bool): Whether to sort in descending order.
+        
         Returns:
-            A new CalculationBucket instance with the specified sorting applied.
+            CalculationBucket: A new bucket instance sorted according to the specified key and order.
         """
         return CalculationBucket(
             self._manager_class, self.filters, self.excludes, key, reverse
         )
+
+    def none(self) -> CalculationBucket[GeneralManagerType]:
+        """
+        Return a new CalculationBucket instance of the same type containing no items.
+        
+        The returned bucket has all filters, excludes, and cached combinations cleared, representing an empty set of combinations.
+        """
+        own = self.all()
+        own._current_combinations = None
+        own.filters = {}
+        own.excludes = {}
+        return own

{generalmanager-0.12.2 → generalmanager-0.13.1}/src/general_manager/bucket/databaseBucket.py

@@ -211,14 +211,14 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         reverse: bool = False,
     ) -> DatabaseBucket:
         """
-        Return a new DatabaseBucket sorted by the specified field or fields.
-
+        Return a new DatabaseBucket with items sorted by the specified field or fields.
+        
         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:
-            DatabaseBucket: A new bucket instance containing the sorted queryset.
+            DatabaseBucket: A new bucket containing the sorted items.
         """
         if isinstance(key, str):
             key = (key,)
@@ -227,3 +227,13 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         else:
             sorted_data = self._data.order_by(*key)
         return self.__class__(sorted_data, self._manager_class)
+
+    def none(self) -> DatabaseBucket[GeneralManagerType]:
+        """
+        Return a new DatabaseBucket instance of the same type containing no items.
+        
+        This method creates an empty bucket while preserving the current manager class and bucket type.
+        """
+        own = self.all()
+        own._data = own._data.none()
+        return own

{generalmanager-0.12.2 → generalmanager-0.13.1}/src/general_manager/bucket/groupBucket.py

@@ -285,8 +285,8 @@ class GroupBucket(Bucket[GeneralManagerType]):
 
     def group_by(self, *group_by_keys: str) -> GroupBucket[GeneralManagerType]:
         """
-        Returns a new GroupBucket grouped by the current and additional specified attribute keys.
-
+        Return a new GroupBucket grouped by the current and additional attribute keys.
+        
         Additional group-by keys are appended to the existing grouping, and the new GroupBucket is constructed from the same underlying data.
         """
         return GroupBucket(
@@ -294,3 +294,13 @@ class GroupBucket(Bucket[GeneralManagerType]):
             tuple([*self._group_by_keys, *group_by_keys]),
             self._basis_data,
         )
+
+    def none(self) -> GroupBucket[GeneralManagerType]:
+        """
+        Return a new empty GroupBucket with the same manager class and group-by keys as the current instance.
+        
+        This method creates a GroupBucket containing no items, preserving the grouping configuration of the original.
+        """
+        return GroupBucket(
+            self._manager_class, self._group_by_keys, self._basis_data.none()
+        )

{generalmanager-0.12.2 → generalmanager-0.13.1}/src/general_manager/interface/databaseInterface.py

@@ -84,14 +84,17 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         instance: GeneralManagerModel, many_to_many_kwargs: dict[str, list[Any]]
     ) -> GeneralManagerModel:
         """
-        Set many-to-many relationship fields on a model instance using provided values.
-
-        Converts lists of `GeneralManager` instances to their corresponding IDs before updating the relationships. Returns the updated instance.
+        Set many-to-many relationship fields on a model instance using the provided values.
+        
+        For each field, converts lists of `GeneralManager` instances to their IDs if necessary, and updates the corresponding many-to-many relationship on the instance. Fields with values of `None` or `NOT_PROVIDED` are ignored.
+        
+        Returns:
+            GeneralManagerModel: The updated model instance with many-to-many relationships set.
         """
         from general_manager.manager.generalManager import GeneralManager
 
         for key, value in many_to_many_kwargs.items():
-            if not value:
+            if value is None or value is NOT_PROVIDED:
                 continue
             field_name = key.removesuffix("_id_list")
             if isinstance(value, list) and all(

{generalmanager-0.12.2 → generalmanager-0.13.1}/src/general_manager/permission/managerBasedPermission.py

@@ -17,20 +17,30 @@ type permission_type = Literal[
 ]
 
 
+class notExistent:
+    pass
+
+
 class ManagerBasedPermission(BasePermission):
     __based_on__: Optional[str] = None
-    __read__: list[str] = ["public"]
-    __create__: list[str] = ["isAuthenticated"]
-    __update__: list[str] = ["isAuthenticated"]
-    __delete__: list[str] = ["isAuthenticated"]
+    __read__: list[str]
+    __create__: list[str]
+    __update__: list[str]
+    __delete__: list[str]
 
     def __init__(
         self,
         instance: PermissionDataManager | GeneralManager,
         request_user: AbstractUser,
     ) -> None:
-
+        """
+        Initializes the ManagerBasedPermission with a manager instance and the requesting user.
+        
+        Configures default CRUD permissions, collects attribute-specific permissions, and sets up any related "based on" permission for cascading checks.
+        """
         super().__init__(instance, request_user)
+        self.__setPermissions()
+
         self.__attribute_permissions = self.__getAttributePermissions()
         self.__based_on_permission = self.__getBasedOnPermission()
         self.__overall_results: Dict[permission_type, Optional[bool]] = {
@@ -40,20 +50,52 @@ class ManagerBasedPermission(BasePermission):
             "delete": None,
         }
 
+    def __setPermissions(self, skip_based_on: bool = False) -> None:
+
+        """
+        Assigns default permission lists for CRUD actions based on the presence of a related permission attribute.
+        
+        If the permission is based on another attribute and `skip_based_on` is False, all default permissions are set to empty lists. Otherwise, read permissions default to `["public"]` and write permissions to `["isAuthenticated"]`. Class-level overrides are respected if present.
+        """
+        default_read = ["public"]
+        default_write = ["isAuthenticated"]
+
+        if self.__based_on__ is not None and not skip_based_on:
+            default_read = []
+            default_write = []
+
+        self.__read__ = getattr(self.__class__, "__read__", default_read)
+        self.__create__ = getattr(self.__class__, "__create__", default_write)
+        self.__update__ = getattr(self.__class__, "__update__", default_write)
+        self.__delete__ = getattr(self.__class__, "__delete__", default_write)
+
     def __getBasedOnPermission(self) -> Optional[BasePermission]:
+        """
+        Retrieves the permission object associated with the `__based_on__` attribute, if present and valid.
+        
+        Returns:
+            An instance of the related `BasePermission` subclass if the `__based_on__` attribute exists on the instance and its `Permission` class is a subclass of `BasePermission`; otherwise, returns `None`.
+        
+        Raises:
+            ValueError: If the `__based_on__` attribute is missing from the instance.
+            TypeError: If the `__based_on__` attribute is not a `GeneralManager` or its subclass.
+        """
         from general_manager.manager.generalManager import GeneralManager
 
         __based_on__ = getattr(self, "__based_on__")
         if __based_on__ is None:
             return None
 
-        basis_object = getattr(self.instance, __based_on__, None)
-        if basis_object is None:
+        basis_object = getattr(self.instance, __based_on__, notExistent)
+        if basis_object is notExistent:
             raise ValueError(
-                f"Based on object {__based_on__} not found in instance {self.instance}"
+                f"Based on configuration '{__based_on__}' is not valid or does not exist."
             )
-        if not isinstance(basis_object, GeneralManager) and not issubclass(
-            basis_object, GeneralManager
+        if basis_object is None:
+            self.__setPermissions(skip_based_on=True)
+            return None
+        if not isinstance(basis_object, GeneralManager) and not (
+            isinstance(basis_object, type) and issubclass(basis_object, GeneralManager)
         ):
             raise TypeError(f"Based on object {__based_on__} is not a GeneralManager")
 
@@ -124,6 +166,13 @@ class ManagerBasedPermission(BasePermission):
         self,
         permissions: list[str],
     ) -> bool:
+        """
+        Return True if no permissions are required or if at least one permission string is valid for the user.
+        
+        If the permissions list is empty, access is granted. Otherwise, returns True if any permission string in the list is validated for the user; returns False if none are valid.
+        """
+        if not permissions:
+            return True
         for permission in permissions:
             if self.validatePermissionString(permission):
                 return True

{generalmanager-0.12.2 → generalmanager-0.13.1}/src/general_manager/permission/permissionChecks.py

@@ -34,6 +34,11 @@ permission_functions: dict[str, PermissionDict] = {
         "permission_method": lambda instance, user, config: True,
         "permission_filter": lambda user, config: None,
     },
+    "matches": {
+        "permission_method": lambda instance, user, config: getattr(instance, config[0])
+        == config[1],
+        "permission_filter": lambda user, config: {"filter": {config[0]: config[1]}},
+    },
     "ends_with": {
         "permission_method": lambda instance, user, config: getattr(
             instance, config[0]

{generalmanager-0.12.2 → generalmanager-0.13.1}/src/general_manager/utils/pathMapping.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, cast, get_args
 from general_manager.manager.meta import GeneralManagerMeta
 from general_manager.api.property import GraphQLProperty
 
-from general_manager.interface.baseInterface import Bucket
+from general_manager.bucket.baseBucket import Bucket
 from general_manager.manager.generalManager import GeneralManager
 
 
@@ -26,7 +26,7 @@ class PathMap:
     def createPathMapping(cls):
         """
         Builds the mapping of paths between all pairs of distinct managed classes.
-        
+
         Iterates over all registered managed classes and creates a PathTracer for each unique start and destination class pair, storing them in the mapping dictionary.
         """
         all_managed_classes = GeneralManagerMeta.all_classes
@@ -38,10 +38,9 @@ class PathMap:
                     ] = PathTracer(start_class, destination_class)
 
     def __init__(self, path_start: PathStart | GeneralManager | type[GeneralManager]):
-
         """
         Initializes a PathMap with a specified starting point.
-        
+
         The starting point can be a class name (string), a GeneralManager instance, or a GeneralManager subclass. Sets internal attributes for the start instance, class, and class name based on the input.
         """
         if isinstance(path_start, GeneralManager):
@@ -86,9 +85,11 @@ class PathMap:
         Returns a list of all classes that are connected to the start class.
         """
         connected_classes: set[str] = set()
-        for path_tuple in self.mapping.keys():
+        for path_tuple, path_obj in self.mapping.items():
             if path_tuple[0] == self.start_class_name:
                 destination_class_name = path_tuple[1]
+                if path_obj.path is None:
+                    continue
                 connected_classes.add(destination_class_name)
         return connected_classes
 
@@ -107,14 +108,13 @@ class PathTracer:
     def createPath(
         self, current_manager: type[GeneralManager], path: list[str]
     ) -> list[str] | None:
-
         """
         Recursively constructs a path of attribute names from the current manager class to the destination class.
-        
+
         Args:
             current_manager: The current GeneralManager subclass being inspected.
             path: The list of attribute names traversed so far.
-        
+
         Returns:
             A list of attribute names representing the path to the destination class, or None if no path exists.
         """
@@ -135,6 +135,8 @@ class PathTracer:
         for attr, attr_type in current_connections.items():
             if attr in path or attr_type == self.start_class:
                 continue
+            if attr_type is None:
+                continue
             if not issubclass(attr_type, GeneralManager):
                 continue
             if attr_type == self.destination_class:
@@ -148,13 +150,12 @@ class PathTracer:
     def traversePath(
         self, start_instance: GeneralManager | Bucket
     ) -> GeneralManager | Bucket | None:
-
         """
         Traverses the stored path from a starting instance to reach the destination instance or bucket.
-        
+
         Args:
             start_instance: The initial GeneralManager or Bucket instance from which to begin traversal.
-        
+
         Returns:
             The resulting GeneralManager or Bucket instance at the end of the path, or None if the path is empty.
         """