GeneralManager 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

general_manager/manager/generalManager.py

@@ -13,13 +13,21 @@ if TYPE_CHECKING:
         InterfaceBase,
     )
 GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
+InterfaceType = TypeVar("InterfaceType", bound="InterfaceBase", covariant=True)
 
 
-class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
-    Interface: Type[InterfaceBase]
+class GeneralManager(
+    Generic[GeneralManagerType, InterfaceType], metaclass=GeneralManagerMeta
+):
+    Interface: Type[InterfaceType]
     _attributes: dict[str, Any]
 
     def __init__(self, *args: Any, **kwargs: Any):
+        """
+        Initialize the manager by creating an interface instance with the provided arguments and storing its identification.
+        
+        The identification is registered with the dependency tracker for tracking purposes.
+        """
         self._interface = self.Interface(*args, **kwargs)
         self.__id: dict[str, Any] = self._interface.identification
         DependencyTracker.track(
@@ -33,11 +41,26 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
         return f"{self.__class__.__name__}(**{self.__id})"
 
     def __reduce__(self) -> str | tuple[Any, ...]:
+        """
+        Support object serialization by returning a tuple containing the class and identification values for pickling.
+        """
         return (self.__class__, tuple(self.__id.values()))
 
     def __or__(
-        self, other: GeneralManager[GeneralManagerType] | Bucket[GeneralManagerType]
+        self,
+        other: (
+            GeneralManager[GeneralManagerType, InterfaceType]
+            | Bucket[GeneralManagerType]
+        ),
     ) -> Bucket[GeneralManagerType]:
+        """
+        Combine this manager with another manager of the same class or a Bucket using the union operator.
+        
+        If combined with a Bucket, returns the union of the Bucket and this manager. If combined with another manager of the same class, returns a Bucket containing both instances. Raises a TypeError for unsupported types.
+        
+        Returns:
+            Bucket[GeneralManagerType]: A Bucket containing the union of the involved managers.
+        """
         if isinstance(other, Bucket):
             return other | self
         elif isinstance(other, GeneralManager) and other.__class__ == self.__class__:
@@ -63,11 +86,24 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
     @dataChange
     def create(
         cls,
-        creator_id: int,
+        creator_id: int | None = None,
         history_comment: str | None = None,
         ignore_permission: bool = False,
         **kwargs: dict[str, Any],
-    ) -> GeneralManager[GeneralManagerType]:
+    ) -> GeneralManager[GeneralManagerType, InterfaceType]:
+        """
+        Creates a new managed object using the underlying interface and returns a corresponding manager instance.
+        
+        Performs a permission check if a `Permission` class is defined and permission checks are not ignored. Passes all provided arguments to the interface's `create` method.
+        
+        Parameters:
+            creator_id (int | None): Optional identifier for the creator of the object.
+            history_comment (str | None): Optional comment for audit or history tracking.
+            ignore_permission (bool): If True, skips the permission check.
+        
+        Returns:
+            GeneralManager[GeneralManagerType, InterfaceType]: A new manager instance for the created object.
+        """
         Permission: Type[BasePermission] | None = getattr(cls, "Permission", None)
         if Permission is not None and not ignore_permission:
             Permission.checkCreatePermission(kwargs, cls, creator_id)
@@ -79,11 +115,23 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
     @dataChange
     def update(
         self,
-        creator_id: int,
+        creator_id: int | None = None,
         history_comment: str | None = None,
         ignore_permission: bool = False,
         **kwargs: dict[str, Any],
-    ) -> GeneralManager[GeneralManagerType]:
+    ) -> GeneralManager[GeneralManagerType, InterfaceType]:
+        """
+        Update the underlying interface object with new data and return a new manager instance.
+        
+        Parameters:
+            creator_id (int | None): Optional identifier for the user performing the update.
+            history_comment (str | None): Optional comment describing the update.
+            ignore_permission (bool): If True, skips permission checks.
+            **kwargs: Additional fields to update on the interface object.
+        
+        Returns:
+            GeneralManager[GeneralManagerType, InterfaceType]: A new manager instance reflecting the updated object.
+        """
         Permission: Type[BasePermission] | None = getattr(self, "Permission", None)
         if Permission is not None and not ignore_permission:
             Permission.checkUpdatePermission(kwargs, self, creator_id)
@@ -97,10 +145,21 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
     @dataChange
     def deactivate(
         self,
-        creator_id: int,
+        creator_id: int | None = None,
         history_comment: str | None = None,
         ignore_permission: bool = False,
-    ) -> GeneralManager[GeneralManagerType]:
+    ) -> GeneralManager[GeneralManagerType, InterfaceType]:
+        """
+        Deactivates the underlying interface object and returns a new manager instance.
+        
+        Parameters:
+            creator_id (int | None): Optional identifier for the user performing the deactivation.
+            history_comment (str | None): Optional comment describing the reason for deactivation.
+            ignore_permission (bool): If True, skips permission checks.
+        
+        Returns:
+            GeneralManager[GeneralManagerType, InterfaceType]: A new instance representing the deactivated object.
+        """
         Permission: Type[BasePermission] | None = getattr(self, "Permission", None)
         if Permission is not None and not ignore_permission:
             Permission.checkDeletePermission(self, creator_id)
@@ -130,15 +189,15 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
     @staticmethod
     def __parse_identification(kwargs: dict[str, Any]) -> dict[str, Any] | None:
         """
-        Processes a dictionary by replacing GeneralManager instances with their identifications.
+        Return a dictionary with all GeneralManager instances in the input replaced by their identification dictionaries.
         
-        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.
+        For each key-value pair in the input, any GeneralManager instance is replaced by 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 to process.
+        Parameters:
+            kwargs (dict[str, Any]): Dictionary to process.
         
         Returns:
-            A new dictionary with GeneralManager instances replaced by their identifications, or None if empty.
+            dict[str, Any] | None: Processed dictionary with identifications, or None if empty.
         """
         output = {}
         for key, value in kwargs.items():

general_manager/manager/input.py

@@ -18,12 +18,12 @@ class Input(Generic[INPUT_TYPE]):
         depends_on: Optional[List[str]] = None,
     ):
         """
-        Initializes an Input instance with type information, possible values, and dependencies.
+        Create an Input specification with type information, allowed values, and dependency metadata.
         
-        Args:
-            type: The expected type for the input value.
-            possible_values: An optional iterable or callable that defines allowed values.
-            depends_on: An optional list of dependency names. If not provided and possible_values is callable, dependencies are inferred from its parameters.
+        Parameters:
+            type: The expected Python type for the input value.
+            possible_values: Optional; an iterable of allowed values or a callable returning allowed values.
+            depends_on: Optional; a list of dependency names. If not provided and possible_values is callable, dependencies are inferred from the callable's parameter names.
         """
         self.type = type
         self.possible_values = possible_values
@@ -42,14 +42,9 @@ class Input(Generic[INPUT_TYPE]):
 
     def cast(self, value: Any) -> Any:
         """
-        Casts the input value to the type specified by this Input instance.
+        Converts the input value to the type specified by this Input instance, handling special cases for dates, datetimes, GeneralManager subclasses, and Measurement types.
         
-        Handles special cases for date, datetime, GeneralManager subclasses, and Measurement types.
-        If the value is already of the target type, it is returned unchanged. Otherwise, attempts to
-        convert or construct the value as appropriate for the target type.
-        
-        Args:
-            value: The value to be cast or converted.
+        If the value is already of the target type, it is returned unchanged. For date and datetime types, string and cross-type conversions are supported. For GeneralManager subclasses, instances are constructed from a dictionary or an ID. For Measurement, string values are parsed accordingly. Otherwise, the value is cast using the target type's constructor.
         
         Returns:
             The value converted to the target type, or an instance of the target type.
@@ -57,6 +52,8 @@ class Input(Generic[INPUT_TYPE]):
         if self.type == date:
             if isinstance(value, datetime) and type(value) is not date:
                 return value.date()
+            elif isinstance(value, date):
+                return value
             return date.fromisoformat(value)
         if self.type == datetime:
             if isinstance(value, date):

general_manager/manager/meta.py

@@ -18,29 +18,30 @@ class _nonExistent:
 
 class GeneralManagerMeta(type):
     all_classes: list[Type[GeneralManager]] = []
-    read_only_classes: list[Type[GeneralManager]] = []
+    read_only_classes: list[Type[GeneralManager[Any, ReadOnlyInterface]]] = []
     pending_graphql_interfaces: list[Type[GeneralManager]] = []
     pending_attribute_initialization: list[Type[GeneralManager]] = []
     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.
+        Creates a new class using the metaclass, integrating interface hooks and registering the class for attribute initialization and tracking.
         
-        Args:
-            name: The name of the class being created.
-            bases: Base classes for the new class.
-            attrs: Attribute dictionary for the new class.
+        If the class definition includes an `Interface` attribute, validates it as a subclass of `InterfaceBase`, applies pre- and post-creation hooks from the interface, and registers the resulting class for attribute initialization and management. Regardless of interface presence, the new class is tracked for pending GraphQL interface creation.
         
         Returns:
-            The newly created class, possibly augmented with interface and registration logic.
+            The newly created class, potentially augmented with interface integration and registration logic.
         """
+
         def createNewGeneralManagerClass(
             mcs, name: str, bases: tuple[type, ...], attrs: dict[str, Any]
         ) -> Type[GeneralManager]:
+            """
+            Create a new GeneralManager class using the standard metaclass instantiation process.
+            
+            Returns:
+                The newly created GeneralManager subclass.
+            """
             return super().__new__(mcs, name, bases, attrs)
 
         if "Interface" in attrs:
@@ -58,7 +59,6 @@ class GeneralManagerMeta(type):
 
         else:
             new_class = createNewGeneralManagerClass(mcs, name, bases, attrs)
-
         if getattr(settings, "AUTOCREATE_GRAPHQL", False):
             mcs.pending_graphql_interfaces.append(new_class)
 
@@ -68,8 +68,22 @@ class GeneralManagerMeta(type):
     def createAtPropertiesForAttributes(
         attributes: Iterable[str], new_class: Type[GeneralManager]
     ):
+        """
+        Dynamically assigns property descriptors to a class for each specified attribute name.
+        
+        For each attribute, creates a descriptor that:
+        - Returns the field type from the class's interface when accessed on the class.
+        - Retrieves the value from the instance's `_attributes` dictionary when accessed on an instance.
+        - Invokes the attribute with the instance's interface if it is callable.
+        - Raises `AttributeError` if the attribute is missing or if an error occurs during callable invocation.
+        """
 
         def desciptorMethod(attr_name: str, new_class: type):
+            """
+            Creates a property descriptor for an attribute, enabling dynamic access and callable resolution.
+            
+            When accessed on the class, returns the field type from the associated interface. When accessed on an instance, retrieves the attribute value from the instance's `_attributes` dictionary, invoking it with the instance's interface if the value is callable. Raises `AttributeError` if the attribute is missing or if a callable attribute raises an exception.
+            """
             class Descriptor(Generic[GeneralManagerType]):
                 def __init__(self, attr_name: str, new_class: Type[GeneralManager]):
                     self.attr_name = attr_name
@@ -77,7 +91,7 @@ class GeneralManagerMeta(type):
 
                 def __get__(
                     self,
-                    instance: GeneralManager[GeneralManagerType] | None,
+                    instance: GeneralManager[GeneralManagerType, InterfaceBase] | None,
                     owner: type | None = None,
                 ):
                     if instance is None:

general_manager/utils/testing.py

@@ -0,0 +1,124 @@
+from graphene_django.utils.testing import GraphQLTransactionTestCase
+from general_manager.apps import GeneralmanagerConfig
+from importlib import import_module
+from django.db import connection
+from django.conf import settings
+from typing import cast
+from django.db import models
+from general_manager.manager.generalManager import GeneralManager
+from general_manager.api.graphql import GraphQL
+from django.apps import apps as global_apps
+
+
+_original_get_app = global_apps.get_containing_app_config
+
+
+def createFallbackGetApp(fallback_app: str):
+    """
+    Creates a fallback function for getting the app config, which returns the specified fallback app if the original lookup fails.
+
+    Parameters:
+        fallback_app (str): The name of the app to return if the original lookup fails.
+
+    Returns:
+        function: A function that attempts to get the app config for a given object name, falling back to the specified app if not found.
+    """
+
+    def _fallback_get_app(object_name: str):
+        cfg = _original_get_app(object_name)
+        if cfg is not None:
+            return cfg
+        try:
+            return global_apps.get_app_config(fallback_app)
+        except LookupError:
+            return None
+
+    return _fallback_get_app
+
+
+def _default_graphql_url_clear():
+    """
+    Removes the first URL pattern for the GraphQL view from the project's root URL configuration.
+
+    This function searches the root URL patterns for a pattern whose callback is a `GraphQLView` and removes it, effectively clearing the default GraphQL endpoint from the URL configuration.
+    """
+    urlconf = import_module(settings.ROOT_URLCONF)
+    for pattern in urlconf.urlpatterns:
+        if (
+            hasattr(pattern, "callback")
+            and hasattr(pattern.callback, "view_class")
+            and pattern.callback.view_class.__name__ == "GraphQLView"
+        ):
+            urlconf.urlpatterns.remove(pattern)
+            break
+
+
+class GMTestCaseMeta(type):
+    """
+    Metaclass that wraps setUpClass: first calls user-defined setup,
+    then performs GM environment initialization, then super().setUpClass().
+    """
+
+    def __new__(mcs, name, bases, attrs):
+        """
+        Creates a new test case class with a customized setUpClass that prepares the database schema and GraphQL environment for GeneralManager integration tests.
+
+        The generated setUpClass method resets GraphQL class registries, invokes any user-defined setUpClass, clears default GraphQL URL patterns, creates missing database tables for specified GeneralManager classes and their history models, initializes GeneralManager and GraphQL configurations, and finally calls the original GraphQLTransactionTestCase setUpClass.
+        """
+        user_setup = attrs.get("setUpClass")
+        fallback_app = attrs.get("fallback_app", "general_manager")
+        # MERKE dir das echte GraphQLTransactionTestCase.setUpClass
+        base_setup = GraphQLTransactionTestCase.setUpClass
+
+        def wrapped_setUpClass(cls):
+            """
+            Performs comprehensive setup for a test case class, initializing GraphQL and GeneralManager environments and ensuring required database tables exist.
+
+            This method resets internal GraphQL registries, invokes any user-defined setup, removes default GraphQL URL patterns, creates missing database tables for models and their history associated with specified GeneralManager classes, initializes GeneralManager and GraphQL configurations, and finally calls the base test case setup.
+            """
+            GraphQL._query_class = None
+            GraphQL._mutation_class = None
+            GraphQL._mutations = {}
+            GraphQL._query_fields = {}
+            GraphQL.graphql_type_registry = {}
+            GraphQL.graphql_filter_type_registry = {}
+
+            if fallback_app is not None:
+                global_apps.get_containing_app_config = createFallbackGetApp(
+                    fallback_app
+                )
+
+            # 1) user-defined setUpClass (if any)
+            if user_setup:
+                user_setup.__func__(cls)
+            # 2) clear URL patterns
+            _default_graphql_url_clear()
+            # 3) register models & create tables
+            existing = connection.introspection.table_names()
+            with connection.schema_editor() as editor:
+                for manager_class in cls.general_manager_classes:
+                    model_class = cast(
+                        type[models.Model], manager_class.Interface._model  # type: ignore
+                    )
+                    if model_class._meta.db_table not in existing:
+                        editor.create_model(model_class)
+                        editor.create_model(model_class.history.model)  # type: ignore
+            # 4) GM & GraphQL initialization
+            GeneralmanagerConfig.initializeGeneralManagerClasses(
+                cls.general_manager_classes, cls.general_manager_classes
+            )
+            GeneralmanagerConfig.handleReadOnlyInterface(cls.read_only_classes)
+            GeneralmanagerConfig.handleGraphQL(cls.general_manager_classes)
+            # 5) GraphQLTransactionTestCase.setUpClass
+            base_setup.__func__(cls)
+
+        attrs["setUpClass"] = classmethod(wrapped_setUpClass)
+        return super().__new__(mcs, name, bases, attrs)
+
+
+class GeneralManagerTransactionTestCase(
+    GraphQLTransactionTestCase, metaclass=GMTestCaseMeta
+):
+    general_manager_classes: list[type[GeneralManager]] = []
+    read_only_classes: list[type[GeneralManager]] = []
+    fallback_app: str | None = "general_manager"

{generalmanager-0.7.0.dist-info → generalmanager-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.7.0
+Version: 0.9.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.7.0.dist-info → generalmanager-0.9.0.dist-info}/RECORD

@@ -1,11 +1,12 @@
 general_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general_manager/apps.py,sha256=sfH8a1iaAdTjTmmf7R9TZfZl_8yrce7zlsKGB1mFSQY,7935
-general_manager/api/graphql.py,sha256=a_mH5dvM3yXC1WyQKFCYpzSE00DQFLNKhRsZrwvLrNM,27453
-general_manager/api/mutation.py,sha256=uu5RVxc9wbb-Zrbtt4azegvyKymMqEsxk_CkerKCd9Q,5178
+general_manager/apps.py,sha256=Q6_by4VT4BtL6TxqyI0tG3XeiU3C3QZSiH4ok9a4XJY,8928
+general_manager/api/graphql.py,sha256=ZMzlpgmyn2X9Zwxo12r-b5UZ2R-u1pXys_nhNczxyX8,31622
+general_manager/api/mutation.py,sha256=RYCogAdUpUedyh2B9keMAzq9u-iIhEKAsoiw5xXmhrQ,5669
 general_manager/api/property.py,sha256=oc93p1P8dcIvrNorRuqD1EJVsd6eYttYhZuAS0s28gs,696
 general_manager/auxiliary/__init__.py,sha256=4IwKJzsNxGduF-Ej0u1BNHVaMhkql8PjHbVtx9DOTSY,76
 general_manager/auxiliary/argsToKwargs.py,sha256=kmp1xonpQp4X_y8ZJG6c5uOW7zQwo0HtPqsHWVzXRSM,921
 general_manager/auxiliary/filterParser.py,sha256=wmR4YzsnYgjI2Co5eyvCFROldotAraHx_GiCDJo79IY,5410
+general_manager/auxiliary/formatString.py,sha256=gZSbsKvpywBmf5bIx6YW43LmNJcqsCP7ZfrB7YPvaFo,1436
 general_manager/auxiliary/jsonEncoder.py,sha256=TDsgFQvheITHZgdmn-m8tk1_QCzpT0XwEHo7bY3Qe-M,638
 general_manager/auxiliary/makeCacheKey.py,sha256=lczutqxlofLSUnheKRi8nazhOyPa04TZOFNxNn5vDu4,1126
 general_manager/auxiliary/noneToZero.py,sha256=KfQtMQnrT6vsYST0K7lv6pVujkDcK3XL8czHYOhgqKQ,539
@@ -24,16 +25,17 @@ general_manager/factory/autoFactory.py,sha256=WBhSuMVsxkPAPLhlZhYXwHVIqiomUveS7v
 general_manager/factory/factories.py,sha256=F6_nYFyJRYYc3LQApfoVFdctfLzsWUDHKafn6xjckB8,7224
 general_manager/factory/factoryMethods.py,sha256=9Bag891j0XHe3dUBAFi7gUKcKeUwcBZN3cDLBobyBiI,3225
 general_manager/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general_manager/interface/baseInterface.py,sha256=WjavtLW_vzyv3PDIIGpw0cydFXjIBJfzxflMXDNF7ac,8583
+general_manager/interface/baseInterface.py,sha256=GCMo0MGlaRAElovfI34qfuWuVYOyTQLG0OA-ZJx8i3s,8604
 general_manager/interface/calculationInterface.py,sha256=Kg_OqLw67tcLwdzYNLq31eKVLzkM7taw-8Mzmk0CYi0,4232
-general_manager/interface/databaseBasedInterface.py,sha256=NoHJp1A9kWRa5R8aal3MS--4PRsHY4JMBzpcuNd69kY,22182
-general_manager/interface/databaseInterface.py,sha256=08dFgxoLQNa13RK2NQ4cDNbNPIG-X9ChLs3NvJcSp6Y,4923
-general_manager/interface/readOnlyInterface.py,sha256=USr4k6Jr1gz91Cdi8bbZY59cTy5MPGZ3oC40xCdWS88,10873
+general_manager/interface/databaseBasedInterface.py,sha256=S7xSEYnguihx5RD633hwXcDk830a9-NwOwOnCFmeJMo,20738
+general_manager/interface/databaseInterface.py,sha256=UBmsfS6gF-3G6slvrGsq3UbKhSkWBWqtSOzRmdsw3Cw,6627
+general_manager/interface/models.py,sha256=gGYW5f1AUBpBakV3O0qsZwqMiWxZGdKRYXWaCBjt1oI,3334
+general_manager/interface/readOnlyInterface.py,sha256=TkfbOeaa2wCq5kCv0a3IwJWcYOTVbtNsdNWmGAz0Mns,11217
 general_manager/manager/__init__.py,sha256=l3RYp62aEhj3Y975_XUTIzo35LUnkTJHkb_hgChnXXI,111
-general_manager/manager/generalManager.py,sha256=HX69KhrnSGVkuJwHY_jzff5gS0VD-6fRxKnd59A5Ct4,6100
+general_manager/manager/generalManager.py,sha256=AVFZICHzqiIyn7lgPU_WLH8X8WLP1edvWAE5CljZPrk,9178
 general_manager/manager/groupManager.py,sha256=8dpZUfm7aFL4lraUWv4qbbDRClQZaYxw4prclhBZYZs,4367
-general_manager/manager/input.py,sha256=iKawV3P1QICz-0AQUF00OvH7LZYxussg3svpvCUl8hE,2977
-general_manager/manager/meta.py,sha256=I4HO7Tp2P0-eRKicVzZRFrYzyMshjWY2ZGP8no9Su-Y,4411
+general_manager/manager/input.py,sha256=-pJXGJ-g2-OxZfl4Buj3mQkf05fN4p8MsR2Lh9BQcEo,3208
+general_manager/manager/meta.py,sha256=IN5Xzz4lcUBe2umqvBz84qoyjkzKubNaMwfuYFQjFGU,5631
 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
@@ -46,8 +48,9 @@ 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.7.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.7.0.dist-info/METADATA,sha256=S1_khOXyPT4HXYuMLADTSI3pAHiI0bV_WRPzWUFRTCc,6205
-generalmanager-0.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-generalmanager-0.7.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.7.0.dist-info/RECORD,,
+general_manager/utils/testing.py,sha256=R6l-9PVAgxeVywvynkzSR6xXcHCu4z2UzRqzHDVrBUY,5591
+generalmanager-0.9.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.9.0.dist-info/METADATA,sha256=jZGL1zcuGh2BUBCCpafvSZH2qIVWtcdk4FltvRj-06M,6205
+generalmanager-0.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+generalmanager-0.9.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.9.0.dist-info/RECORD,,