GeneralManager 0.4.5__py3-none-any.whl → 0.5.0__py3-none-any.whl

general_manager/apps.py

@@ -41,7 +41,7 @@ class GeneralmanagerConfig(AppConfig):
             attributes = general_manager_class.Interface.getAttributes()
             setattr(general_manager_class, "_attributes", attributes)
             GeneralManagerMeta.createAtPropertiesForAttributes(
-                attributes, general_manager_class
+                attributes.keys(), general_manager_class
             )
 
         if getattr(settings, "AUTOCREATE_GRAPHQL", False):

general_manager/factory/autoFactory.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Type, Callable, Union, Any, TypeVar, Literal
+from django.db import models
+from factory.django import DjangoModelFactory
+from general_manager.factory.factories import getFieldValue, getManyToManyFieldValue
+
+
+if TYPE_CHECKING:
+    from general_manager.interface.databaseInterface import (
+        DBBasedInterface,
+    )
+
+modelsModel = TypeVar("modelsModel", bound=models.Model)
+
+
+class AutoFactory(DjangoModelFactory[modelsModel]):
+    """
+    A factory class that automatically generates values for model fields,
+    including handling of unique fields and constraints.
+    """
+
+    interface: Type[DBBasedInterface]
+    _adjustmentMethod: (
+        Callable[..., Union[dict[str, Any], list[dict[str, Any]]]] | None
+    ) = None
+
+    @classmethod
+    def _generate(
+        cls, strategy: Literal["build", "create"], params: dict[str, Any]
+    ) -> models.Model | list[models.Model]:
+        """
+        Generates and populates a Django model instance or list of instances with automatic field value assignment.
+        
+        Automatically assigns values to unset model fields, including handling custom and special fields, and processes many-to-many relationships after instance creation or building. Raises a ValueError if the model is not a subclass of Django's Model.
+        
+        Args:
+            strategy: Specifies whether to build (unsaved) or create (saved) the instance(s).
+            params: Field values to use for instance generation; missing fields are auto-filled.
+        
+        Returns:
+            A single model instance or a list of model instances, depending on the input parameters and strategy.
+        """
+        cls._original_params = params
+        model = cls._meta.model
+        if not issubclass(model, models.Model):
+            raise ValueError("Model must be a type")
+        field_name_list, to_ignore_list = cls.interface.handleCustomFields(model)
+
+        fields = [
+            field
+            for field in model._meta.get_fields()
+            if field.name not in to_ignore_list
+        ]
+        special_fields: list[models.Field[Any, Any]] = [
+            getattr(model, field_name) for field_name in field_name_list
+        ]
+        pre_declarations = getattr(cls._meta, "pre_declarations", [])
+        post_declarations = getattr(cls._meta, "post_declarations", [])
+        declared_fields: set[str] = set(pre_declarations) | set(post_declarations)
+
+        field_list: list[models.Field[Any, Any] | models.ForeignObjectRel] = [
+            *fields,
+            *special_fields,
+        ]
+
+        for field in field_list:
+            if field.name in [*params, *declared_fields]:
+                continue  # Skip fields that are already set
+            if isinstance(field, models.AutoField) or field.auto_created:
+                continue  # Skip auto fields
+            params[field.name] = getFieldValue(field)
+
+        obj: list[models.Model] | models.Model = super()._generate(strategy, params)
+        if isinstance(obj, list):
+            for item in obj:  # type: ignore
+                if not isinstance(item, models.Model):
+                    raise ValueError("Model must be a type")
+                cls._handleManyToManyFieldsAfterCreation(item, params)
+        else:
+            cls._handleManyToManyFieldsAfterCreation(obj, params)
+        return obj
+
+    @classmethod
+    def _handleManyToManyFieldsAfterCreation(
+        cls, obj: models.Model, attrs: dict[str, Any]
+    ) -> None:
+        """
+        Sets many-to-many field values on a Django model instance after creation.
+        
+        For each many-to-many field, assigns related objects from the provided attributes if available; otherwise, generates values using `getManyToManyFieldValue`. The related objects are set using the Django ORM's `set` method.
+        """
+        for field in obj._meta.many_to_many:
+            if field.name in attrs:
+                m2m_values = attrs[field.name]
+            else:
+                m2m_values = getManyToManyFieldValue(field)
+            if m2m_values:
+                getattr(obj, field.name).set(m2m_values)
+
+    @classmethod
+    def _adjust_kwargs(cls, **kwargs: dict[str, Any]) -> dict[str, Any]:
+        # Remove ManyToMany fields from kwargs before object creation
+        """
+        Removes many-to-many field entries from keyword arguments before model instance creation.
+        
+        Returns:
+            The keyword arguments dictionary with many-to-many fields removed.
+        """
+        model: Type[models.Model] = cls._meta.model
+        m2m_fields = {field.name for field in model._meta.many_to_many}
+        for field_name in m2m_fields:
+            kwargs.pop(field_name, None)
+        return kwargs
+
+    @classmethod
+    def _create(
+        cls, model_class: Type[models.Model], *args: list[Any], **kwargs: dict[str, Any]
+    ) -> models.Model | list[models.Model]:
+        """
+        Creates and saves a Django model instance or instances, applying optional adjustment logic.
+        
+        If an adjustment method is defined, it is used to generate or modify field values before creation. Otherwise, the model is instantiated and saved with the provided attributes.
+        
+        Args:
+            model_class: The Django model class to instantiate.
+        
+        Returns:
+            A saved model instance or a list of instances.
+        """
+        kwargs = cls._adjust_kwargs(**kwargs)
+        if cls._adjustmentMethod is not None:
+            return cls.__createWithGenerateFunc(use_creation_method=True, params=kwargs)
+        return cls._modelCreation(model_class, **kwargs)
+
+    @classmethod
+    def _build(
+        cls, model_class: Type[models.Model], *args: list[Any], **kwargs: dict[str, Any]
+    ) -> models.Model | list[models.Model]:
+        """
+        Constructs an unsaved instance or list of instances of the given Django model class.
+        
+        If an adjustment method is defined, it is used to generate or modify field values before building the instance(s). Many-to-many fields are removed from the keyword arguments prior to instantiation.
+        """
+        kwargs = cls._adjust_kwargs(**kwargs)
+        if cls._adjustmentMethod is not None:
+            return cls.__createWithGenerateFunc(
+                use_creation_method=False, params=kwargs
+            )
+        return cls._modelBuilding(model_class, **kwargs)
+
+    @classmethod
+    def _modelCreation(
+        cls, model_class: Type[models.Model], **kwargs: dict[str, Any]
+    ) -> models.Model:
+        """
+        Creates and saves a Django model instance with the provided field values.
+        
+        Initializes the model, assigns attributes from keyword arguments, validates the instance using `full_clean()`, and saves it to the database.
+        
+        Returns:
+            The saved Django model instance.
+        """
+        obj = model_class()
+        for field, value in kwargs.items():
+            setattr(obj, field, value)
+        obj.full_clean()
+        obj.save()
+        return obj
+
+    @classmethod
+    def _modelBuilding(
+        cls, model_class: Type[models.Model], **kwargs: dict[str, Any]
+    ) -> models.Model:
+        """
+        Constructs an unsaved instance of the specified Django model with provided field values.
+        
+        Args:
+            model_class: The Django model class to instantiate.
+            **kwargs: Field values to set on the model instance.
+        
+        Returns:
+            An unsaved Django model instance with attributes set from kwargs.
+        """
+        obj = model_class()
+        for field, value in kwargs.items():
+            setattr(obj, field, value)
+        return obj
+
+    @classmethod
+    def __createWithGenerateFunc(
+        cls, use_creation_method: bool, params: dict[str, Any]
+    ) -> models.Model | list[models.Model]:
+        """
+        Generates one or more model instances using the adjustment method for field values.
+        
+        If the adjustment method returns a single dictionary, creates or builds a single model instance.
+        If it returns a list of dictionaries, creates or builds multiple instances accordingly.
+        
+        Args:
+            use_creation_method: If True, saves instances to the database; otherwise, builds unsaved instances.
+            params: Parameters to pass to the adjustment method for generating field values.
+        
+        Returns:
+            A single model instance or a list of model instances, depending on the adjustment method's output.
+        
+        Raises:
+            ValueError: If the adjustment method is not defined.
+        """
+        model_cls = cls._meta.model
+        if cls._adjustmentMethod is None:
+            raise ValueError("generate_func is not defined")
+        records = cls._adjustmentMethod(**params)
+        if isinstance(records, dict):
+            if use_creation_method:
+                return cls._modelCreation(model_cls, **records)
+            return cls._modelBuilding(model_cls, **records)
+
+        created_objects: list[models.Model] = []
+        for record in records:
+            if use_creation_method:
+                created_objects.append(cls._modelCreation(model_cls, **record))
+            else:
+                created_objects.append(cls._modelBuilding(model_cls, **record))
+        return created_objects

general_manager/factory/factories.py

@@ -1,164 +1,22 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING, Type, Callable, Union, Any, TypeVar, Literal, cast
+from typing import Any, cast
 from factory.declarations import LazyFunction
 from factory.faker import Faker
 import exrex  # type: ignore
 from django.db import models
 from django.core.validators import RegexValidator
-from factory.django import DjangoModelFactory
 import random
 from decimal import Decimal
 from general_manager.measurement.measurement import Measurement
 from general_manager.measurement.measurementField import MeasurementField
 from datetime import date, datetime, time, timezone
 
-if TYPE_CHECKING:
-    from general_manager.interface.databaseInterface import (
-        DBBasedInterface,
-    )
-
-modelsModel = TypeVar("modelsModel", bound=models.Model)
-
-
-class AutoFactory(DjangoModelFactory[modelsModel]):
-    """
-    A factory class that automatically generates values for model fields,
-    including handling of unique fields and constraints.
-    """
-
-    interface: Type[DBBasedInterface]
-    _adjustmentMethod: (
-        Callable[..., Union[dict[str, Any], list[dict[str, Any]]]] | None
-    ) = None
-
-    @classmethod
-    def _generate(
-        cls, strategy: Literal["build", "create"], params: dict[str, Any]
-    ) -> models.Model | list[models.Model]:
-        cls._original_params = params
-        model = getattr(cls._meta, "model")
-        if not issubclass(model, models.Model):
-            raise ValueError("Model must be a type")
-        field_name_list, to_ignore_list = cls.interface.handleCustomFields(model)
-
-        fields = [
-            field
-            for field in model._meta.get_fields()
-            if field.name not in to_ignore_list
-        ]
-        special_fields: list[models.Field[Any, Any]] = [
-            getattr(model, field_name) for field_name in field_name_list
-        ]
-        pre_declations = getattr(cls._meta, "pre_declarations", [])
-        post_declarations = getattr(cls._meta, "post_declarations", [])
-        declared_fields: set[str] = set(pre_declations) | set(post_declarations)
-
-        field_list: list[models.Field[Any, Any] | models.ForeignObjectRel] = [
-            *fields,
-            *special_fields,
-        ]
-
-        for field in field_list:
-            if field.name in [*params, *declared_fields]:
-                continue  # Skip fields that are already set
-            if isinstance(field, models.AutoField) or field.auto_created:
-                continue  # Skip auto fields
-            params[field.name] = getFieldValue(field)
-
-        obj: list[models.Model] | models.Model = super()._generate(strategy, params)
-        if isinstance(obj, list):
-            for item in obj:  # type: ignore
-                if not isinstance(item, models.Model):
-                    raise ValueError("Model must be a type")
-                cls._handleManyToManyFieldsAfterCreation(item, params)
-        else:
-            cls._handleManyToManyFieldsAfterCreation(obj, params)
-        return obj
-
-    @classmethod
-    def _handleManyToManyFieldsAfterCreation(
-        cls, obj: models.Model, attrs: dict[str, Any]
-    ) -> None:
-        for field in obj._meta.many_to_many:
-            if field.name in attrs:
-                m2m_values = attrs[field.name]
-            else:
-                m2m_values = getManyToManyFieldValue(field)
-            if m2m_values:
-                getattr(obj, field.name).set(m2m_values)
-
-    @classmethod
-    def _adjust_kwargs(cls, **kwargs: dict[str, Any]) -> dict[str, Any]:
-        # Remove ManyToMany fields from kwargs before object creation
-        model: Type[models.Model] = getattr(cls._meta, "model")
-        m2m_fields = {field.name for field in model._meta.many_to_many}
-        for field_name in m2m_fields:
-            kwargs.pop(field_name, None)
-        return kwargs
-
-    @classmethod
-    def _create(
-        cls, model_class: Type[models.Model], *args: list[Any], **kwargs: dict[str, Any]
-    ) -> models.Model | list[models.Model]:
-        kwargs = cls._adjust_kwargs(**kwargs)
-        if cls._adjustmentMethod is not None:
-            return cls.__createWithGenerateFunc(strategy=True, params=kwargs)
-        return cls._modelCreation(model_class, **kwargs)
-
-    @classmethod
-    def _build(
-        cls, model_class: Type[models.Model], *args: list[Any], **kwargs: dict[str, Any]
-    ) -> models.Model | list[models.Model]:
-        kwargs = cls._adjust_kwargs(**kwargs)
-        if cls._adjustmentMethod is not None:
-            return cls.__createWithGenerateFunc(strategy=False, params=kwargs)
-        return cls._modelBuilding(model_class, **kwargs)
-
-    @classmethod
-    def _modelCreation(
-        cls, model_class: Type[models.Model], **kwargs: dict[str, Any]
-    ) -> models.Model:
-        obj = model_class()
-        for field, value in kwargs.items():
-            setattr(obj, field, value)
-        obj.full_clean()
-        obj.save()
-        return obj
-
-    @classmethod
-    def _modelBuilding(
-        cls, model_class: Type[models.Model], **kwargs: dict[str, Any]
-    ) -> models.Model:
-        obj = model_class()
-        for field, value in kwargs.items():
-            setattr(obj, field, value)
-        return obj
-
-    @classmethod
-    def __createWithGenerateFunc(
-        cls, strategy: bool, params: dict[str, Any]
-    ) -> models.Model | list[models.Model]:
-        model_cls = getattr(cls._meta, "model")
-        if cls._adjustmentMethod is None:
-            raise ValueError("generate_func is not defined")
-        records = cls._adjustmentMethod(**params)
-        if isinstance(records, dict):
-            if strategy:
-                return cls._modelCreation(model_cls, **records)
-            return cls._modelBuilding(model_cls, **records)
-
-        created_objects: list[models.Model] = []
-        for record in records:
-            if strategy:
-                created_objects.append(cls._modelCreation(model_cls, **record))
-            else:
-                created_objects.append(cls._modelBuilding(model_cls, **record))
-        return created_objects
-
 
 def getFieldValue(field: models.Field[Any, Any] | models.ForeignObjectRel) -> object:
     """
-    Returns a suitable value for a given Django model field.
+    Generates an appropriate value for a given Django model field for use in testing or data factories.
+    
+    If the field allows null values, there is a 10% chance of returning None. Handles a wide range of Django field types, including measurement, text, numeric, date/time, boolean, relational, and specialized fields, returning a suitable fake or factory-generated value for each. For relational fields (OneToOneField and ForeignKey), attempts to use a factory if available or selects a random existing instance; raises ValueError if neither is possible. Returns None for unsupported field types.
     """
     if field.null:
         if random.choice([True] + 9 * [False]):

general_manager/interface/databaseInterface.py

@@ -18,7 +18,7 @@ from simple_history.models import HistoricalRecords  # type: ignore
 from general_manager.measurement.measurement import Measurement
 from general_manager.measurement.measurementField import MeasurementField
 from decimal import Decimal
-from general_manager.factory.factories import AutoFactory
+from general_manager.factory.autoFactory import AutoFactory
 from django.core.exceptions import ValidationError
 from general_manager.interface.baseInterface import (
     InterfaceBase,
@@ -646,13 +646,13 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         self, basis: dict[str, list[Any]], **kwargs: Any
     ) -> dict[str, list[Any]]:
         """
-        Merges filter definitions by combining existing filter criteria with additional keyword arguments.
+        Combines existing filter definitions with additional keyword arguments.
         
         Args:
-            basis: A dictionary mapping filter keys to lists of values.
+            basis: Dictionary mapping filter keys to lists of values. Additional keyword arguments are merged into this dictionary.
         
         Returns:
-            A dictionary where each key maps to a list of all values from both the original basis and the new keyword arguments.
+            A dictionary where each key maps to a list containing all values from both the original basis and the new keyword arguments.
         """
         kwarg_filter: dict[str, list[Any]] = {}
         for key, value in basis.items():
@@ -665,9 +665,9 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
 
     def filter(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
         """
-        Returns a new bucket containing manager instances matching the given filter criteria.
+        Returns a new bucket with manager instances matching the specified filter criteria.
         
-        Additional filter keyword arguments are merged with existing filters to refine the queryset.
+        Additional filter keyword arguments are merged with any existing filters to further restrict the queryset.
         """
         merged_filter = self.__mergeFilterDefinitions(self.filters, **kwargs)
         return self.__class__(
@@ -679,13 +679,9 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
 
     def exclude(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
         """
-        Returns a new bucket excluding items matching the given filter criteria.
+        Returns a new DatabaseBucket excluding items that match the specified criteria.
         
-        Args:
-            **kwargs: Field lookups to exclude from the queryset.
-        
-        Returns:
-            A DatabaseBucket containing items not matching the specified filters.
+        Keyword arguments specify field lookups to exclude from the queryset. The resulting bucket contains only items that do not match these filters.
         """
         merged_exclude = self.__mergeFilterDefinitions(self.excludes, **kwargs)
         return self.__class__(

general_manager/manager/generalManager.py

@@ -128,15 +128,31 @@ 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.
+        
+        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.
+        
+        Args:
+            kwargs: Dictionary of keyword arguments to process.
+        
+        Returns:
+            A new dictionary with GeneralManager instances replaced by their identifications, or None if the dictionary is empty.
+        """
+        output = {}
         for key, value in kwargs.items():
             if isinstance(value, GeneralManager):
-                kwargs[key] = value.identification
+                output[key] = value.identification
             elif isinstance(value, list):
-                kwargs[key] = [
-                    v.identification for v in value if isinstance(v, GeneralManager)
+                output[key] = [
+                    v.identification if isinstance(v, GeneralManager) else v
+                    for v in value
                 ]
             elif isinstance(value, tuple):
-                kwargs[key] = tuple(
-                    v.identification for v in value if isinstance(v, GeneralManager)
+                output[key] = tuple(
+                    v.identification if isinstance(v, GeneralManager) else v
+                    for v in value
                 )
-        return kwargs if kwargs else None
+            else:
+                output[key] = value
+        return output if output else None

general_manager/manager/meta.py

@@ -3,7 +3,7 @@ from general_manager.interface.baseInterface import (
     InterfaceBase,
 )
 from django.conf import settings
-from typing import Any, Type, TYPE_CHECKING, Generic, TypeVar
+from typing import Any, Type, TYPE_CHECKING, Generic, TypeVar, Iterable
 
 if TYPE_CHECKING:
     from general_manager.interface.databaseInterface import ReadOnlyInterface
@@ -12,6 +12,10 @@ if TYPE_CHECKING:
 GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
 
 
+class _nonExistent:
+    pass
+
+
 class GeneralManagerMeta(type):
     all_classes: list[Type[GeneralManager]] = []
     read_only_classes: list[Type[ReadOnlyInterface]] = []
@@ -48,7 +52,7 @@ class GeneralManagerMeta(type):
 
     @staticmethod
     def createAtPropertiesForAttributes(
-        attributes: dict[str, Any], new_class: Type[GeneralManager]
+        attributes: Iterable[str], new_class: Type[GeneralManager]
     ):
 
         def desciptorMethod(attr_name: str, new_class: type):
@@ -64,12 +68,21 @@ class GeneralManagerMeta(type):
                 ):
                     if instance is None:
                         return self.new_class.Interface.getFieldType(self.attr_name)
-                    attribute = instance._attributes[attr_name]
+                    attribute = instance._attributes.get(attr_name, _nonExistent)
+                    if attribute is _nonExistent:
+                        raise AttributeError(
+                            f"{self.attr_name} not found in {instance.__class__.__name__}"
+                        )
                     if callable(attribute):
-                        return attribute(instance._interface)
+                        try:
+                            attribute = attribute(instance._interface)
+                        except Exception as e:
+                            raise AttributeError(
+                                f"Error calling attribute {self.attr_name}: {e}"
+                            ) from e
                     return attribute
 
             return Descriptor(attr_name, new_class)
 
-        for attr_name in attributes.keys():
+        for attr_name in attributes:
             setattr(new_class, attr_name, desciptorMethod(attr_name, new_class))

{generalmanager-0.4.5.dist-info → generalmanager-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.4.5
+Version: 0.5.0
 Summary: Kurzbeschreibung deines Pakets
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License-Expression: MIT

{generalmanager-0.4.5.dist-info → generalmanager-0.5.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 general_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general_manager/apps.py,sha256=-AX9imxqht55Xr8q5abnoeKc48ubj-tzDq7WhUrcNUg,3313
+general_manager/apps.py,sha256=0QwuIAnhHm5u0wTlCiDVsl8k0RU0BEgfFjmBMl9zvsw,3320
 general_manager/api/graphql.py,sha256=L-UUiDDOe1s5mhXs9nBNf0f7PXz9JLloUfyrXbjIfIs,27408
 general_manager/api/mutation.py,sha256=uu5RVxc9wbb-Zrbtt4azegvyKymMqEsxk_CkerKCd9Q,5178
 general_manager/api/property.py,sha256=oc93p1P8dcIvrNorRuqD1EJVsd6eYttYhZuAS0s28gs,696
@@ -16,17 +16,18 @@ general_manager/cache/dependencyIndex.py,sha256=kEbIAzzMzKlQgplKfcMYBPZ562zCBkOB
 general_manager/cache/modelDependencyCollector.py,sha256=wS2edbZsQ1aTfRlHj02lhuasZHCc2ucRGob-E7ejuoY,2433
 general_manager/cache/signals.py,sha256=ZHeXKFMN7tj9t0J-vSqf_05_NhGqEF2sZtbZO3vaRqI,1234
 general_manager/factory/__init__.py,sha256=wbPIGyBlWBHa7aGWUd-1IUMPWUS-M6YqtPUL1iKXW8U,93
-general_manager/factory/factories.py,sha256=R2_iAVRspfysDNT_cKyJuMT38RFkNbjnPR3yjAXZRkc,12188
+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=mvSKUlA-0fazNnaIXGBwkiZxmX8DM_sOn-SaAIpaW8I,10273
 general_manager/interface/calculationInterface.py,sha256=GzSNXjU6Z7bFz60gHyMKkI5xNUDIPuniV8wbyVtQT50,14250
-general_manager/interface/databaseInterface.py,sha256=i3Z-rkHnoGzV8cFZjBKBmIjlWjGJ2CzdlsiQfL2JUas,28288
+general_manager/interface/databaseInterface.py,sha256=1hQcgOQkEhniv7Mrx2CbqPaes_qqH9zTqSnlriZQfGo,28314
 general_manager/manager/__init__.py,sha256=l3RYp62aEhj3Y975_XUTIzo35LUnkTJHkb_hgChnXXI,111
-general_manager/manager/generalManager.py,sha256=md-3zVCOMa-vC8ToCOEMKXeDuV7JtHLlSStQXh4cgBE,5258
+general_manager/manager/generalManager.py,sha256=L470Jevvh87doI5leUbTa9P6weIdekRZ6OTorqN-WpY,6091
 general_manager/manager/groupManager.py,sha256=O4FABqbm7KlZw6t36Ot3HU1FsBYN0h6Zhmk7ktN8a-Y,10087
 general_manager/manager/input.py,sha256=iKawV3P1QICz-0AQUF00OvH7LZYxussg3svpvCUl8hE,2977
-general_manager/manager/meta.py,sha256=5wHrCVnua5c38vpVZSCesrNvgydQDH8h6pxW6_QgCDg,3107
+general_manager/manager/meta.py,sha256=Km4axFpDKI_Wx000dOok5jUwjJVqq5QJG9XhrWRw5mo,3624
 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
@@ -39,8 +40,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.4.5.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.4.5.dist-info/METADATA,sha256=XtO9PCJmtFWR-pPXbRZ_EaV4b0SwgbVSWsHhusr9FKQ,6528
-generalmanager-0.4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-generalmanager-0.4.5.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.4.5.dist-info/RECORD,,
+generalmanager-0.5.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.5.0.dist-info/METADATA,sha256=x_8Yw5IpORQc7MOjzTp-J_vmcuptPWmTFL7zkGUEI7c,6528
+generalmanager-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+generalmanager-0.5.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.5.0.dist-info/RECORD,,