GeneralManager 0.12.1__py3-none-any.whl → 0.13.0__py3-none-any.whl

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

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."
+        )

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

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

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()
+        )

general_manager/interface/databaseBasedInterface.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 from typing import Type, Any, Callable, TYPE_CHECKING, TypeVar, Generic, cast
 from django.db import models
+
 from datetime import datetime, timedelta
 from general_manager.measurement.measurement import Measurement
 from general_manager.measurement.measurementField import MeasurementField
@@ -66,6 +67,25 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
             instance = self.getHistoricalRecord(instance, search_date)
         return instance
 
+    @staticmethod
+    def __parseKwargs(**kwargs: Any) -> dict[str, Any]:
+        """
+        Parses keyword arguments to ensure they are compatible with the model's fields.
+
+        Converts GeneralManager instances to their primary key values and returns a dictionary of parsed arguments.
+        """
+        from general_manager.manager.generalManager import GeneralManager
+
+        parsed_kwargs: dict[str, Any] = {}
+        for key, value in kwargs.items():
+            if isinstance(value, GeneralManager):
+                parsed_kwargs[key] = getattr(
+                    value._interface, "_instance", value.identification["id"]
+                )
+            else:
+                parsed_kwargs[key] = value
+        return parsed_kwargs
+
     @classmethod
     def filter(cls, **kwargs: Any) -> DatabaseBucket:
         """
@@ -77,6 +97,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         Returns:
             A DatabaseBucket wrapping the filtered queryset and associated metadata.
         """
+
+        kwargs = cls.__parseKwargs(**kwargs)
+
         return DatabaseBucket(
             cls._model.objects.filter(**kwargs),
             cls._parent_class,
@@ -94,6 +117,8 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         Returns:
             A DatabaseBucket wrapping the queryset of excluded model instances.
         """
+        kwargs = cls.__parseKwargs(**kwargs)
+
         return DatabaseBucket(
             cls._model.objects.exclude(**kwargs),
             cls._parent_class,
@@ -135,9 +160,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
         """
-        Return a dictionary mapping each attribute name of the model to its type information and metadata.
+        Return a dictionary mapping each model attribute name to its type information and metadata.
 
-        The returned dictionary includes all standard model fields, custom fields, foreign keys, many-to-many, and reverse relation fields, excluding any GenericForeignKey fields. For each attribute, the metadata specifies its Python type (translated from Django field types when possible), whether it is required, editable, derived, and its default value. For related models with a general manager class, the type is set to that class.
+        Includes standard fields, custom fields, foreign keys, many-to-many, and reverse relation fields, excluding GenericForeignKey fields. For each attribute, provides its Python type (translated from Django field types when possible), required and editable status, whether it is derived, and its default value. For related models with a general manager class, the type is set to that class.
 
         Returns:
             dict[str, AttributeTypedDict]: Mapping of attribute names to their type information and metadata.
@@ -178,7 +203,8 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 fields[field_name] = {
                     "type": type(field),
                     "is_derived": False,
-                    "is_required": not field.null,
+                    "is_required": not field.null
+                    and field.default is models.NOT_PROVIDED,
                     "is_editable": field.editable,
                     "default": field.default,
                 }
@@ -196,7 +222,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
             ):
                 related_model = related_model._general_manager_class  # type: ignore
 
-            elif related_model is not None:
+            if related_model is not None:
                 default = None
                 if hasattr(field, "default"):
                     default = field.default  # type: ignore
@@ -247,12 +273,12 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getAttributes(cls) -> dict[str, Callable[[DBBasedInterface], Any]]:
         """
-        Return a dictionary mapping attribute names to callables that retrieve values from a DBBasedInterface instance.
+        Return a mapping of attribute names to callables that extract values from a DBBasedInterface instance.
 
-        The mapping includes accessors for custom fields, standard model fields, foreign keys, many-to-many relations, and reverse relations. For related models with a general manager class, the accessor returns an instance of that class; otherwise, it returns the related object or queryset. Raises a ValueError if a field name conflict is detected.
+        The returned dictionary includes accessors for custom fields, standard model fields, foreign keys, many-to-many relations, and reverse relations. For related models with a general manager class, the accessor returns an instance or queryset of that class; otherwise, it returns the related object or queryset directly. Raises a ValueError if a field name conflict is detected.
 
         Returns:
-            dict: A dictionary where keys are attribute names and values are callables that extract the corresponding value from a DBBasedInterface instance.
+            dict[str, Callable[[DBBasedInterface], Any]]: Mapping of attribute names to callables for retrieving values from a DBBasedInterface instance.
         """
         from general_manager.manager.generalManager import GeneralManager
 
@@ -306,12 +332,22 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 cls._model._meta.get_field(field_name).related_model,
                 "_general_manager_class",
             ):
+                related_model = cast(
+                    Type[models.Model],
+                    cls._model._meta.get_field(field_name).related_model,
+                )
+                related_fields = [
+                    f
+                    for f in related_model._meta.get_fields()
+                    if f.related_model == cls._model
+                ]
+
                 field_values[
                     f"{field_name}_list"
-                ] = lambda self, field_name=field_name: self._instance._meta.get_field(
+                ] = lambda self, field_name=field_name, related_fields=related_fields: self._instance._meta.get_field(
                     field_name
                 ).related_model._general_manager_class.filter(
-                    **{self._instance.__class__.__name__.lower(): self.pk}
+                    **{related_field.name: self.pk for related_field in related_fields}
                 )
             else:
                 field_values[f"{field_name}_list"] = (
@@ -319,6 +355,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                         self._instance, field_call
                     ).all()
                 )
+
         return field_values
 
     @staticmethod

general_manager/interface/databaseInterface.py

@@ -84,19 +84,26 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         instance: GeneralManagerModel, many_to_many_kwargs: dict[str, list[Any]]
     ) -> GeneralManagerModel:
         """
-        Sets many-to-many attributes for the given instance based on the provided kwargs.
-
-        Args:
-            instance: The model instance to update.
-            many_to_many_kwargs: A dictionary containing many-to-many field names and their corresponding values.
-
+        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:
-            The updated model instance.
+            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.split("_id_list")[0]
+            field_name = key.removesuffix("_id_list")
+            if isinstance(value, list) and all(
+                isinstance(v, GeneralManager) for v in value
+            ):
+                value = [
+                    v.identification["id"] if hasattr(v, "identification") else v
+                    for v in value
+                ]
             getattr(instance, field_name).set(value)
 
         return instance

general_manager/interface/models.py

@@ -39,7 +39,7 @@ def getFullCleanMethode(model: Type[models.Model]) -> Callable[..., None]:
         except ValidationError as e:
             errors.update(e.message_dict)
 
-        rules: list[Rule] = getattr(self._meta, "rules")
+        rules: list[Rule] = getattr(self._meta, "rules", [])
         for rule in rules:
             if rule.evaluate(self) is False:
                 error_message = rule.getErrorMessage()

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

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.1.dist-info → generalmanager-0.13.0.dist-info}/METADATA

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

{generalmanager-0.12.1.dist-info → generalmanager-0.13.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
 general_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 general_manager/apps.py,sha256=ii-48klC2kBRjxtdQU9-RtPq66lZ8fDa7BmqyH-mbzk,9904
-general_manager/api/graphql.py,sha256=FyukDVM3doDAcD_TTeGkrIIHtsMqTEDX5Opa-hUZcrk,39351
+general_manager/api/graphql.py,sha256=x-ky5UTQc-ZM_RB__swtwc95QXmv-q-OqgiMzY8EUM0,39652
 general_manager/api/mutation.py,sha256=9T892INzH4ip5sX3_BxB2WX145zt8S_0HGVPhGzyXZA,6736
 general_manager/api/property.py,sha256=oc93p1P8dcIvrNorRuqD1EJVsd6eYttYhZuAS0s28gs,696
-general_manager/bucket/baseBucket.py,sha256=UjEai7cVxgDJysoVY2-7s3YULW7bi-sx2mPqRKFWyTw,7728
-general_manager/bucket/calculationBucket.py,sha256=a41YVdfhxKf_gpWlRKjXYmS1YuO-6VC0hn60RyLKByU,18777
-general_manager/bucket/databaseBucket.py,sha256=Rfgh81BZoQk4Ng4DG34edf0CZP2SJrFy59sKpBR8VUM,9179
-general_manager/bucket/groupBucket.py,sha256=PGmYh7cg9oC-wcY33krHVhwjpUvSH3slCamwvdT87H8,10951
+general_manager/bucket/baseBucket.py,sha256=RdEaUhbCVPGI9l9B3l9lC9Ma2pGjQx6NL1rlCEIPXEc,8243
+general_manager/bucket/calculationBucket.py,sha256=AWXftX9X3N6lwRNwCnLfgxDDKOquwtSWpIan_OxYsOc,19359
+general_manager/bucket/databaseBucket.py,sha256=sA7EAwEQxCYqlwI1l1Z6n4mgG2pEwkzeRdOBzdlzmbo,9554
+general_manager/bucket/groupBucket.py,sha256=CoXQoHtXcNa_KLnvUOMG1j1TcCNeenlIMb-ORrK08LQ,11381
 general_manager/cache/cacheDecorator.py,sha256=XQvs322lDDafecS6osPKmf7DyuZgDq8kuQaYpMeXXYg,3264
 general_manager/cache/cacheTracker.py,sha256=rRw3OhBDf86hTC2Xbt1ocRgZqwu8_kXk4lczamcADFg,2955
 general_manager/cache/dependencyIndex.py,sha256=lxD7IfnWVsBNt9l0_yDfJlHDRHAFC7N7p-Typ2tJp88,11044
@@ -19,9 +19,9 @@ general_manager/factory/factoryMethods.py,sha256=9Bag891j0XHe3dUBAFi7gUKcKeUwcBZ
 general_manager/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 general_manager/interface/baseInterface.py,sha256=cFsDU-nhj_O6Gir3eO0ukGKNn9Pplhe6gEMccHNi4O0,8648
 general_manager/interface/calculationInterface.py,sha256=fTD3WQpsn3ImaxGW5S-JwVJyJJPoPp2mR6lAambdB8U,4755
-general_manager/interface/databaseBasedInterface.py,sha256=F-a6P9rvPUmlcoZw1rKSWEAzbYGccQRL6uokv6C46qo,21782
-general_manager/interface/databaseInterface.py,sha256=rhKVXhg0ztdIxKikTWtgjrkA7cwZTOYlEsRh0RWajDQ,6732
-general_manager/interface/models.py,sha256=P4bYb-Q7-moZR-hgIqwruMuftDgUW6FSqjPtWfHW04o,3311
+general_manager/interface/databaseBasedInterface.py,sha256=uB4_kJ1kNSK-QnUrFKR0zrDP-UulBKeeHIslXqEdU4Q,23058
+general_manager/interface/databaseInterface.py,sha256=NHXOJycY40pywzE1d_5Fi-pLVnmLR4OQwhAIHsgkM_g,7249
+general_manager/interface/models.py,sha256=iYuSTMWKGrH5cjmxTii8HRpSmUUMhtw6xvatRzB4zuA,3315
 general_manager/interface/readOnlyInterface.py,sha256=TkfbOeaa2wCq5kCv0a3IwJWcYOTVbtNsdNWmGAz0Mns,11217
 general_manager/manager/__init__.py,sha256=l3RYp62aEhj3Y975_XUTIzo35LUnkTJHkb_hgChnXXI,111
 general_manager/manager/generalManager.py,sha256=4Qn9TYpZpqh5qC95BEAQhpiZgDrRXrAJjO2BbbXUdNg,9129
@@ -34,9 +34,9 @@ general_manager/measurement/measurementField.py,sha256=hesh8YMQqBuX-thcMUcawHpQW
 general_manager/permission/__init__.py,sha256=5UlDERN60Vn8obGVkT-cOM8kHjzmoxgK5w5FgTCDhGE,59
 general_manager/permission/basePermission.py,sha256=DeiAX2sQQhtdquO13jys2MSkp0kPdg2oo7PSqB9q5Bw,5653
 general_manager/permission/fileBasedPermission.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general_manager/permission/managerBasedPermission.py,sha256=DmoSLZ5m9zOyqAotKFDUbr7dahhsvS3K63kI8ChURN0,5491
+general_manager/permission/managerBasedPermission.py,sha256=CANZu5sU-GhzoFdR87aJ0rX0_rC4a38nqV76IpzIPQQ,7893
 general_manager/permission/mutationPermission.py,sha256=tYeunZQOJiUkQIqW0lU0KafwJKaTkrHTYKi7zV0wqHI,2972
-general_manager/permission/permissionChecks.py,sha256=T-9khBqiwM4ASBdey9p07sC_xgzceIU9EAE0reukguM,1655
+general_manager/permission/permissionChecks.py,sha256=s4XBQtfWK_6_AByVRFbEE3_UD4rXU_9y58L5oeSPXLM,1876
 general_manager/permission/permissionDataManager.py,sha256=EzF-XKJZKvKdNpF77ATYJ_VXSF09L-HTFe8h8p-JdB4,1784
 general_manager/permission/utils.py,sha256=_cznQLk-wmK35pqs3dtgY6I94Ahyz_bTSmpkT0-MQnI,1277
 general_manager/rule/__init__.py,sha256=4Har5cfPD1fmOsilTDod-ZUz3Com-tkl58jz7yY4fD0,23
@@ -51,8 +51,8 @@ general_manager/utils/makeCacheKey.py,sha256=UlFsxHXgsYy69AAelkF6GDvY4h7AImT2bBn
 general_manager/utils/noneToZero.py,sha256=KfQtMQnrT6vsYST0K7lv6pVujkDcK3XL8czHYOhgqKQ,539
 general_manager/utils/pathMapping.py,sha256=nrz5owQg2a69Yig1eCXorR9U0NSw7NmBAk5OkeoHTdA,6842
 general_manager/utils/testing.py,sha256=ElZ8p4iZHxsHjDN8Lm5TmI6527CW747ltDOmtY6gAhk,11872
-generalmanager-0.12.1.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.12.1.dist-info/METADATA,sha256=SdQ9KGXGoKes7mp8Rw1HhyJKCJzh__AlOCyRZSBBwW4,6206
-generalmanager-0.12.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-generalmanager-0.12.1.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.12.1.dist-info/RECORD,,
+generalmanager-0.13.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.13.0.dist-info/METADATA,sha256=_0sQJIW1Rz4ZjoxXUgfKDHSDEqkiUszY5YIVR3cnO3c,6206
+generalmanager-0.13.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+generalmanager-0.13.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.13.0.dist-info/RECORD,,