GeneralManager 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

general_manager/interface/readOnlyInterface.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+import json
+
+from typing import Type, Any, Callable, TYPE_CHECKING
+from django.db import models, transaction
+from general_manager.interface.databaseBasedInterface import (
+    DBBasedInterface,
+    GeneralManagerModel,
+    classPreCreationMethod,
+    classPostCreationMethod,
+)
+
+if TYPE_CHECKING:
+    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.meta import GeneralManagerMeta
+
+
+class ReadOnlyInterface(DBBasedInterface):
+    _interface_type = "readonly"
+
+    @classmethod
+    def sync_data(cls) -> None:
+        """
+        Synchronizes the database model with JSON data, ensuring exact correspondence.
+
+        This method parses JSON data from the parent class and updates the associated Django model so that its records exactly match the JSON content. It creates or updates instances based on unique fields and deletes any database entries not present in the JSON data. Raises a ValueError if required attributes are missing or if the JSON data is invalid.
+        """
+        model: Type[models.Model] | None = getattr(cls, "_model", None)
+        parent_class = getattr(cls, "_parent_class", None)
+        if model is None or parent_class is None:
+            raise ValueError("Attribute '_model' and '_parent_class' must be set.")
+        json_data = getattr(parent_class, "_json_data", None)
+        if not json_data:
+            raise ValueError(
+                f"For ReadOnlyInterface '{parent_class.__name__}' must be set '_json_data'"
+            )
+
+        # JSON-Daten parsen
+        if isinstance(json_data, str):
+            data_list = json.loads(json_data)
+        elif isinstance(json_data, list):
+            data_list: list[Any] = json_data
+        else:
+            raise ValueError(
+                "_json_data must be a JSON string or a list of dictionaries"
+            )
+
+        unique_fields = getattr(parent_class, "_unique_fields", [])
+        if not unique_fields:
+            raise ValueError(
+                f"For ReadOnlyInterface '{parent_class.__name__}' must be defined '_unique_fields'"
+            )
+
+        with transaction.atomic():
+            json_unique_values: set[Any] = set()
+
+            # Daten synchronisieren
+            for data in data_list:
+                lookup = {field: data[field] for field in unique_fields}
+                unique_identifier = tuple(lookup[field] for field in unique_fields)
+                json_unique_values.add(unique_identifier)
+
+                instance, _ = model.objects.get_or_create(**lookup)
+                updated = False
+                for field_name, value in data.items():
+                    if getattr(instance, field_name, None) != value:
+                        setattr(instance, field_name, value)
+                        updated = True
+                if updated:
+                    instance.save()
+
+            # Existierende Einträge abrufen und löschen, wenn nicht im JSON vorhanden
+            existing_instances = model.objects.all()
+            for instance in existing_instances:
+                lookup = {field: getattr(instance, field) for field in unique_fields}
+                unique_identifier = tuple(lookup[field] for field in unique_fields)
+                if unique_identifier not in json_unique_values:
+                    instance.delete()
+
+    @staticmethod
+    def readOnlyPostCreate(func: Callable[..., Any]) -> Callable[..., Any]:
+        """
+        Decorator for post-creation hooks that registers the interface class as read-only.
+
+        Wraps a function to be called after a class creation event, then appends the interface
+        class to the meta-class's `read_only_classes` list.
+        """
+
+        def wrapper(
+            mcs: Type[GeneralManagerMeta],
+            new_class: Type[GeneralManager],
+            interface_cls: Type[ReadOnlyInterface],
+            model: Type[GeneralManagerModel],
+        ):
+            func(mcs, new_class, interface_cls, model)
+            mcs.read_only_classes.append(interface_cls)
+
+        return wrapper
+
+    @classmethod
+    def handleInterface(cls) -> tuple[classPreCreationMethod, classPostCreationMethod]:
+        """
+        Returns pre- and post-creation methods for integrating the interface with a GeneralManager.
+
+        The pre-creation method modifies keyword arguments before a GeneralManager instance is created. The post-creation method, wrapped with a decorator, modifies the instance after creation to add additional data. These methods are intended for use by the GeneralManagerMeta class during the manager's lifecycle.
+        """
+        return cls._preCreate, cls.readOnlyPostCreate(cls._postCreate)

general_manager/manager/generalManager.py

@@ -1,17 +1,18 @@
 from __future__ import annotations
-from typing import Generic, Type, Any, TYPE_CHECKING
+from typing import Generic, Type, Any, TYPE_CHECKING, TypeVar
 from general_manager.manager.meta import GeneralManagerMeta
-from general_manager.interface.baseInterface import (
-    InterfaceBase,
-    Bucket,
-    GeneralManagerType,
-)
+
 from general_manager.api.property import GraphQLProperty
 from general_manager.cache.cacheTracker import DependencyTracker
 from general_manager.cache.signals import dataChange
+from general_manager.bucket.baseBucket import Bucket
 
 if TYPE_CHECKING:
     from general_manager.permission.basePermission import BasePermission
+    from general_manager.interface.baseInterface import (
+        InterfaceBase,
+    )
+GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
 
 
 class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
@@ -129,15 +130,15 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
     @staticmethod
     def __parse_identification(kwargs: dict[str, Any]) -> dict[str, Any] | None:
         """
-        Converts a dictionary of keyword arguments by replacing any GeneralManager instances with their identifications.
+        Processes a dictionary by replacing GeneralManager instances with their identifications.
         
-        For each key-value pair, if the value is a GeneralManager, it is replaced with its identification. Lists and tuples are processed recursively, replacing contained GeneralManager instances with their identifications. Returns a new dictionary with the processed values, or None if the result is empty.
+        For each key-value pair, replaces any GeneralManager instance with its identification. Lists and tuples are processed recursively, substituting contained GeneralManager instances with their identifications. Returns None if the resulting dictionary is empty.
         
         Args:
-            kwargs: Dictionary of keyword arguments to process.
+            kwargs: Dictionary to process.
         
         Returns:
-            A new dictionary with GeneralManager instances replaced by their identifications, or None if the dictionary is empty.
+            A new dictionary with GeneralManager instances replaced by their identifications, or None if empty.
         """
         output = {}
         for key, value in kwargs.items():

general_manager/manager/groupManager.py

@@ -1,207 +1,21 @@
 from __future__ import annotations
 from typing import (
     Type,
-    Generator,
     Any,
     Generic,
     get_args,
     cast,
 )
-import json
 from datetime import datetime, date, time
 from general_manager.api.graphql import GraphQLProperty
 from general_manager.measurement import Measurement
 from general_manager.manager.generalManager import GeneralManager
-from general_manager.interface.baseInterface import (
+from general_manager.bucket.baseBucket import (
     Bucket,
     GeneralManagerType,
 )
 
 
-class GroupBucket(Bucket[GeneralManagerType]):
-
-    def __init__(
-        self,
-        manager_class: Type[GeneralManagerType],
-        group_by_keys: tuple[str, ...],
-        data: Bucket[GeneralManagerType],
-    ):
-        super().__init__(manager_class)
-        self.__checkGroupByArguments(group_by_keys)
-        self._group_by_keys = group_by_keys
-        self._data = self.__buildGroupedManager(data)
-        self._basis_data = data
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, self.__class__):
-            return False
-        return (
-            self._data == other._data
-            and self._manager_class == other._manager_class
-            and self._group_by_keys == other._group_by_keys
-        )
-
-    def __checkGroupByArguments(self, group_by_keys: tuple[str, ...]) -> None:
-        """
-        Validates that all group-by keys are strings and valid attributes of the manager class.
-
-        Raises:
-            TypeError: If any group-by key is not a string.
-            ValueError: If any group-by key is not a valid attribute of the manager class.
-        """
-        if not all(isinstance(arg, str) for arg in group_by_keys):
-            raise TypeError("groupBy() argument must be a string")
-        if not all(
-            arg in self._manager_class.Interface.getAttributes()
-            for arg in group_by_keys
-        ):
-            raise ValueError(
-                f"groupBy() argument must be a valid attribute of {self._manager_class.__name__}"
-            )
-
-    def __buildGroupedManager(
-        self,
-        data: Bucket[GeneralManagerType],
-    ) -> list[GroupManager[GeneralManagerType]]:
-        """
-        This method builds the grouped manager.
-        It returns a GroupBucket with the grouped data.
-        """
-        group_by_values = set()
-        for entry in data:
-            group_by_value = {}
-            for arg in self._group_by_keys:
-                group_by_value[arg] = getattr(entry, arg)
-            group_by_values.add(json.dumps(group_by_value))
-
-        groups = []
-        for group_by_value in sorted(group_by_values):
-            group_by_value = json.loads(group_by_value)
-            grouped_manager_objects = data.filter(**group_by_value)
-            groups.append(
-                GroupManager(
-                    self._manager_class, group_by_value, grouped_manager_objects
-                )
-            )
-        return groups
-
-    def __or__(self, other: object) -> GroupBucket[GeneralManagerType]:
-        if not isinstance(other, self.__class__):
-            raise ValueError("Cannot combine different bucket types")
-        if self._manager_class != other._manager_class:
-            raise ValueError("Cannot combine different manager classes")
-        return GroupBucket(
-            self._manager_class,
-            self._group_by_keys,
-            self._basis_data | other._basis_data,
-        )
-
-    def __iter__(self) -> Generator[GroupManager[GeneralManagerType]]:
-        for grouped_manager in self._data:
-            yield grouped_manager
-
-    def filter(self, **kwargs: Any) -> GroupBucket[GeneralManagerType]:
-        new_basis_data = self._basis_data.filter(**kwargs)
-        return GroupBucket(
-            self._manager_class,
-            self._group_by_keys,
-            new_basis_data,
-        )
-
-    def exclude(self, **kwargs: Any) -> GroupBucket[GeneralManagerType]:
-        new_basis_data = self._basis_data.exclude(**kwargs)
-        return GroupBucket(
-            self._manager_class,
-            self._group_by_keys,
-            new_basis_data,
-        )
-
-    def first(self) -> GroupManager[GeneralManagerType] | None:
-        try:
-            return next(iter(self))
-        except StopIteration:
-            return None
-
-    def last(self) -> GroupManager[GeneralManagerType] | None:
-        items = list(self)
-        if items:
-            return items[-1]
-        return None
-
-    def count(self) -> int:
-        return sum(1 for _ in self)
-
-    def all(self) -> Bucket[GeneralManagerType]:
-        return self
-
-    def get(self, **kwargs: Any) -> GroupManager[GeneralManagerType]:
-        first_value = self.filter(**kwargs).first()
-        if first_value is None:
-            raise ValueError(
-                f"Cannot find {self._manager_class.__name__} with {kwargs}"
-            )
-        return first_value
-
-    def __getitem__(
-        self, item: int | slice
-    ) -> GroupManager[GeneralManagerType] | GroupBucket[GeneralManagerType]:
-        if isinstance(item, int):
-            return self._data[item]
-        elif isinstance(item, slice):
-            new_data = self._data[item]
-            new_base_data = None
-            for manager in new_data:
-                if new_base_data is None:
-                    new_base_data = manager._data
-                else:
-                    new_base_data = new_base_data | manager._data
-            if new_base_data is None:
-                raise ValueError("Cannot slice an empty GroupBucket")
-            return GroupBucket(self._manager_class, self._group_by_keys, new_base_data)
-        raise TypeError(f"Invalid argument type: {type(item)}. Expected int or slice.")
-
-    def __len__(self) -> int:
-        return self.count()
-
-    def __contains__(self, item: GeneralManagerType) -> bool:
-        return item in self._basis_data
-
-    def sort(
-        self,
-        key: tuple[str] | str,
-        reverse: bool = False,
-    ) -> Bucket[GeneralManagerType]:
-        if isinstance(key, str):
-            key = (key,)
-        if reverse:
-            sorted_data = sorted(
-                self._data,
-                key=lambda x: tuple(getattr(x, k) for k in key),
-                reverse=True,
-            )
-        else:
-            sorted_data = sorted(
-                self._data, key=lambda x: tuple(getattr(x, k) for k in key)
-            )
-
-        new_bucket = GroupBucket(
-            self._manager_class, self._group_by_keys, self._basis_data
-        )
-        new_bucket._data = sorted_data
-        return new_bucket
-
-    def group_by(self, *group_by_keys: str) -> GroupBucket[GeneralManagerType]:
-        """
-        This method groups the data by the given arguments.
-        It returns a GroupBucket with the grouped data.
-        """
-        return GroupBucket(
-            self._manager_class,
-            tuple([*self._group_by_keys, *group_by_keys]),
-            self._basis_data,
-        )
-
-
 class GroupManager(Generic[GeneralManagerType]):
     """
     This class is used to group the data of a GeneralManager.
@@ -219,13 +33,21 @@ class GroupManager(Generic[GeneralManagerType]):
         self._data = data
         self._grouped_data: dict[str, Any] = {}
 
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self._manager_class,
+                tuple(self._group_by_value.items()),
+                frozenset(self._data),
+            )
+        )
+
     def __eq__(self, other: object) -> bool:
-        if not isinstance(other, self.__class__):
-            return False
         return (
-            self._data == other._data
+            isinstance(other, self.__class__)
             and self._manager_class == other._manager_class
             and self._group_by_value == other._group_by_value
+            and frozenset(self._data) == frozenset(other._data)
         )
 
     def __repr__(self) -> str:

general_manager/manager/meta.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
-from general_manager.interface.baseInterface import (
-    InterfaceBase,
-)
+
 from django.conf import settings
 from typing import Any, Type, TYPE_CHECKING, Generic, TypeVar, Iterable
+from general_manager.interface.baseInterface import InterfaceBase
 
 if TYPE_CHECKING:
-    from general_manager.interface.databaseInterface import ReadOnlyInterface
+    from general_manager.interface.readOnlyInterface import ReadOnlyInterface
     from general_manager.manager.generalManager import GeneralManager
 
+
 GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
 
 
@@ -24,6 +24,20 @@ class GeneralManagerMeta(type):
     Interface: type[InterfaceBase]
 
     def __new__(mcs, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> type:
+
+        """
+        Creates a new class, handling interface integration and registration for the general manager framework.
+        
+        If an 'Interface' attribute is present in the class definition, validates and processes it using the interface's pre- and post-creation hooks, then registers the resulting class for attribute initialization and tracking. If the 'AUTOCREATE_GRAPHQL' setting is enabled, also registers the class for pending GraphQL interface creation.
+        
+        Args:
+            name: The name of the class being created.
+            bases: Base classes for the new class.
+            attrs: Attribute dictionary for the new class.
+        
+        Returns:
+            The newly created class, possibly augmented with interface and registration logic.
+        """
         def createNewGeneralManagerClass(
             mcs, name: str, bases: tuple[type, ...], attrs: dict[str, Any]
         ) -> Type[GeneralManager]:
@@ -33,7 +47,7 @@ class GeneralManagerMeta(type):
             interface = attrs.pop("Interface")
             if not issubclass(interface, InterfaceBase):
                 raise TypeError(
-                    f"Interface must be a subclass of {InterfaceBase.__name__}"
+                    f"{interface.__name__} must be a subclass of InterfaceBase"
                 )
             preCreation, postCreation = interface.handleInterface()
             attrs, interface_cls, model = preCreation(name, attrs, interface)

general_manager/permission/basePermission.py

@@ -6,12 +6,10 @@ from general_manager.permission.permissionChecks import (
     permission_filter,
 )
 
+from django.contrib.auth.models import AnonymousUser, AbstractUser
+from general_manager.permission.permissionDataManager import PermissionDataManager
 
 if TYPE_CHECKING:
-    from django.contrib.auth.models import AbstractUser, AnonymousUser
-    from general_manager.permission.permissionDataManager import (
-        PermissionDataManager,
-    )
     from general_manager.manager.generalManager import GeneralManager
     from general_manager.manager.meta import GeneralManagerMeta
 
@@ -66,7 +64,7 @@ class BasePermission(ABC):
         request_user = cls.getUserWithId(request_user)
 
         errors = []
-        permission_data = PermissionDataManager[GeneralManager].forUpdate(
+        permission_data = PermissionDataManager.forUpdate(
             base_data=old_manager_instance, update_data=data
         )
         Permission = cls(permission_data, request_user)
@@ -90,7 +88,7 @@ class BasePermission(ABC):
         request_user = cls.getUserWithId(request_user)
 
         errors = []
-        permission_data = PermissionDataManager[GeneralManager](manager_instance)
+        permission_data = PermissionDataManager(manager_instance)
         Permission = cls(permission_data, request_user)
         for key in manager_instance.__dict__.keys():
             is_allowed = Permission.checkPermission("delete", key)

{generalmanager-0.5.2.dist-info → generalmanager-0.6.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.5.2
-Summary: Kurzbeschreibung deines Pakets
+Version: 0.6.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
 Requires-Python: >=3.12

{generalmanager-0.5.2.dist-info → generalmanager-0.6.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 general_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 general_manager/apps.py,sha256=0QwuIAnhHm5u0wTlCiDVsl8k0RU0BEgfFjmBMl9zvsw,3320
-general_manager/api/graphql.py,sha256=L-UUiDDOe1s5mhXs9nBNf0f7PXz9JLloUfyrXbjIfIs,27408
+general_manager/api/graphql.py,sha256=a_mH5dvM3yXC1WyQKFCYpzSE00DQFLNKhRsZrwvLrNM,27453
 general_manager/api/mutation.py,sha256=uu5RVxc9wbb-Zrbtt4azegvyKymMqEsxk_CkerKCd9Q,5178
 general_manager/api/property.py,sha256=oc93p1P8dcIvrNorRuqD1EJVsd6eYttYhZuAS0s28gs,696
 general_manager/auxiliary/__init__.py,sha256=4IwKJzsNxGduF-Ej0u1BNHVaMhkql8PjHbVtx9DOTSY,76
@@ -10,29 +10,35 @@ general_manager/auxiliary/jsonEncoder.py,sha256=TDsgFQvheITHZgdmn-m8tk1_QCzpT0Xw
 general_manager/auxiliary/makeCacheKey.py,sha256=lczutqxlofLSUnheKRi8nazhOyPa04TZOFNxNn5vDu4,1126
 general_manager/auxiliary/noneToZero.py,sha256=KfQtMQnrT6vsYST0K7lv6pVujkDcK3XL8czHYOhgqKQ,539
 general_manager/auxiliary/pathMapping.py,sha256=nrz5owQg2a69Yig1eCXorR9U0NSw7NmBAk5OkeoHTdA,6842
+general_manager/bucket/baseBucket.py,sha256=65oQbSE6C8TE0yVPP_Aoi_Fwq0Uo2TLVPWMG6l2qxyQ,7836
+general_manager/bucket/calculationBucket.py,sha256=M2z7H7mvs56BIlr0NKQYqxcbWO92cFsgXSeKgM4oAko,18056
+general_manager/bucket/databaseBucket.py,sha256=V_xiPa8ErnPHVh_-i-oaH8qCa818UJxm5CVl80SVc1U,9060
+general_manager/bucket/groupBucket.py,sha256=55QdUaH_qO1JFJ2Jc1f2WcxniiLE5LB3vNwbnksKk8A,10939
 general_manager/cache/cacheDecorator.py,sha256=DK2ANIJgPpMxazfMSiFrI9OuVE_7K9zlIZQRrgaC2Lw,3268
 general_manager/cache/cacheTracker.py,sha256=rRw3OhBDf86hTC2Xbt1ocRgZqwu8_kXk4lczamcADFg,2955
 general_manager/cache/dependencyIndex.py,sha256=kEbIAzzMzKlQgplKfcMYBPZ562zCBkOBKvJusxO_iC4,10537
-general_manager/cache/modelDependencyCollector.py,sha256=wS2edbZsQ1aTfRlHj02lhuasZHCc2ucRGob-E7ejuoY,2433
+general_manager/cache/modelDependencyCollector.py,sha256=lIqBvo0QygoxxZPJ32_vMs_-eJaVJDznGyrEmxPV41E,2436
 general_manager/cache/signals.py,sha256=ZHeXKFMN7tj9t0J-vSqf_05_NhGqEF2sZtbZO3vaRqI,1234
 general_manager/factory/__init__.py,sha256=wbPIGyBlWBHa7aGWUd-1IUMPWUS-M6YqtPUL1iKXW8U,93
 general_manager/factory/autoFactory.py,sha256=WBhSuMVsxkPAPLhlZhYXwHVIqiomUveS7vMxw1ON_8Q,9376
 general_manager/factory/factories.py,sha256=F6_nYFyJRYYc3LQApfoVFdctfLzsWUDHKafn6xjckB8,7224
 general_manager/factory/factoryMethods.py,sha256=9Bag891j0XHe3dUBAFi7gUKcKeUwcBZN3cDLBobyBiI,3225
-general_manager/interface/__init__.py,sha256=6x5adQLefTugvrJeyPcAxstyqgLAYeaJ1EPdAbac9pE,213
-general_manager/interface/baseInterface.py,sha256=V8AzZ9CwswZAqc2aODmE_7DtqokOkOxzpXFVQ6qznMo,11271
-general_manager/interface/calculationInterface.py,sha256=GzSNXjU6Z7bFz60gHyMKkI5xNUDIPuniV8wbyVtQT50,14250
-general_manager/interface/databaseInterface.py,sha256=khzqoOcKrBSaYnZAdPmm9cdseNx4YdPRqx5B-81KGf4,28431
+general_manager/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+general_manager/interface/baseInterface.py,sha256=b7MH-jVADcpGluvJMogPn2O3Yiy37uCnWOM9j0Ec0o0,8692
+general_manager/interface/calculationInterface.py,sha256=ZMYQcJZdfnEimsKOGFVfg-8r6Syjo_D9_HPVJkd59ak,4018
+general_manager/interface/databaseBasedInterface.py,sha256=K2PYxANuLQU8wzrajcl922tuWwko642KJAS3f3PnAmg,21566
+general_manager/interface/databaseInterface.py,sha256=rQWeL5u_WCvDtikXLracFkECVM9vZHjs7UXTJlDDCmY,4146
+general_manager/interface/readOnlyInterface.py,sha256=d2CM2gj5XZNEaVFZeNCgqZf46rwUAetVS3SyePCKNsY,4691
 general_manager/manager/__init__.py,sha256=l3RYp62aEhj3Y975_XUTIzo35LUnkTJHkb_hgChnXXI,111
-general_manager/manager/generalManager.py,sha256=L470Jevvh87doI5leUbTa9P6weIdekRZ6OTorqN-WpY,6091
-general_manager/manager/groupManager.py,sha256=gT7cLq3d6PhsLfVGaIG5-fC7xnwN-4nT46N2WpnSesY,10588
+general_manager/manager/generalManager.py,sha256=HX69KhrnSGVkuJwHY_jzff5gS0VD-6fRxKnd59A5Ct4,6100
+general_manager/manager/groupManager.py,sha256=8dpZUfm7aFL4lraUWv4qbbDRClQZaYxw4prclhBZYZs,4367
 general_manager/manager/input.py,sha256=iKawV3P1QICz-0AQUF00OvH7LZYxussg3svpvCUl8hE,2977
-general_manager/manager/meta.py,sha256=Km4axFpDKI_Wx000dOok5jUwjJVqq5QJG9XhrWRw5mo,3624
+general_manager/manager/meta.py,sha256=g94L92hDy5gdGhgaTu3pjgZtt_fLC8LruNj9T34ApdA,4414
 general_manager/measurement/__init__.py,sha256=X97meFujBldE5v0WMF7SmKeGpC5R0JTczfLo_Lq1Xek,84
 general_manager/measurement/measurement.py,sha256=e_FjHieeJbBtjXGCO9J7vRPw6KCkMrOxwWjaD0m8ee4,11777
 general_manager/measurement/measurementField.py,sha256=iq9Hqe6ZGX8CxXm4nIqTAWTRkQVptzpqE9ExX-jFyNs,5928
 general_manager/permission/__init__.py,sha256=5UlDERN60Vn8obGVkT-cOM8kHjzmoxgK5w5FgTCDhGE,59
-general_manager/permission/basePermission.py,sha256=PsJiX-UNeSh6xUlcUwuQNCLYvHZipWUJ0kAoMkdxXJc,6113
+general_manager/permission/basePermission.py,sha256=14iKo6qVmaUdg1sAz-gSZyNtpVKAAapIhutVAMDf93c,6056
 general_manager/permission/fileBasedPermission.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 general_manager/permission/managerBasedPermission.py,sha256=VgZJVgkXWdaLk6K7c0kYxTbELnTYK6UY9mMuKH5u64w,5728
 general_manager/permission/permissionChecks.py,sha256=T-9khBqiwM4ASBdey9p07sC_xgzceIU9EAE0reukguM,1655
@@ -40,8 +46,8 @@ general_manager/permission/permissionDataManager.py,sha256=Ji7fsnuaKTa6M8yzCGyzr
 general_manager/rule/__init__.py,sha256=4Har5cfPD1fmOsilTDod-ZUz3Com-tkl58jz7yY4fD0,23
 general_manager/rule/handler.py,sha256=z8SFHTIZ0LbLh3fV56Mud0V4_OvWkqJjlHvFqau7Qfk,7334
 general_manager/rule/rule.py,sha256=3FVCKGL7BTVoStdgOTdWQwuoVRIxAIAilV4VOzouDpc,10759
-generalmanager-0.5.2.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.5.2.dist-info/METADATA,sha256=7fumKNtzVKr86HwflW_Sesa93yWWHXTJAyumR-TWDEU,6101
-generalmanager-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-generalmanager-0.5.2.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.5.2.dist-info/RECORD,,
+generalmanager-0.6.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.6.0.dist-info/METADATA,sha256=Z3Eh9kL1htCX6HfL5DVmlU6FGIfvu_1k777eTxiNMjU,6205
+generalmanager-0.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+generalmanager-0.6.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.6.0.dist-info/RECORD,,