GeneralManager 0.4.4__tar.gz → 0.4.6__tar.gz

{generalmanager-0.4.4 → generalmanager-0.4.6}/GeneralManager.egg-info/PKG-INFO

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

{generalmanager-0.4.4 → generalmanager-0.4.6}/GeneralManager.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ src/general_manager/cache/dependencyIndex.py
 src/general_manager/cache/modelDependencyCollector.py
 src/general_manager/cache/signals.py
 src/general_manager/factory/__init__.py
+src/general_manager/factory/autoFactory.py
 src/general_manager/factory/factories.py
 src/general_manager/factory/factoryMethods.py
 src/general_manager/interface/__init__.py
@@ -48,6 +49,7 @@ src/general_manager/rule/__init__.py
 src/general_manager/rule/handler.py
 src/general_manager/rule/rule.py
 tests/test_argsToKwargs.py
+tests/test_autoFactory.py
 tests/test_basePermission.py
 tests/test_cacheDecorator.py
 tests/test_cacheTracker.py
@@ -55,6 +57,7 @@ tests/test_dependencyIndex.py
 tests/test_factories.py
 tests/test_factoryMethods.py
 tests/test_filterParser.py
+tests/test_generalManager.py
 tests/test_graph_ql.py
 tests/test_input.py
 tests/test_jsonEncoder.py

{generalmanager-0.4.4 → generalmanager-0.4.6}/PKG-INFO

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

{generalmanager-0.4.4 → generalmanager-0.4.6}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.4.4"
+version = "0.4.6"
 description = "Kurzbeschreibung deines Pakets"
 readme = "README.md"
 authors = [

generalmanager-0.4.6/src/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

{generalmanager-0.4.4 → generalmanager-0.4.6}/src/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]):

{generalmanager-0.4.4 → generalmanager-0.4.6}/src/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__(

{generalmanager-0.4.4 → generalmanager-0.4.6}/src/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

{generalmanager-0.4.4 → generalmanager-0.4.6}/src/general_manager/measurement/measurement.py

@@ -56,7 +56,22 @@ class Measurement:
 
     @classmethod
     def from_string(cls, value: str) -> Measurement:
-        value, unit = value.split(" ")
+        """
+        Creates a Measurement instance from a string in the format 'value unit'.
+        
+        Args:
+            value: A string containing a numeric value and a unit separated by a space (e.g., '10.5 kg').
+        
+        Returns:
+            A Measurement instance representing the parsed value and unit.
+        
+        Raises:
+            ValueError: If the input string does not contain exactly two parts separated by a space.
+        """
+        splitted = value.split(" ")
+        if len(splitted) != 2:
+            raise ValueError("String must be in the format 'value unit'.")
+        value, unit = splitted
         return cls(value, unit)
 
     @staticmethod
@@ -202,12 +217,31 @@ class Measurement:
         return f"Measurement({self.quantity.magnitude}, '{self.quantity.units}')"
 
     def _compare(self, other: Any, operation: Callable[..., bool]) -> bool:
+        """
+        Compares this Measurement with another using the specified comparison operation.
+        
+        If `other` is a string, it is parsed into a Measurement. Raises a TypeError if
+        `other` is not a Measurement instance. Converts `other` to this instance's unit
+        before applying the comparison. Raises a ValueError if the measurements have
+        incompatible dimensions.
+        
+        Args:
+            other: The object to compare with, either a Measurement or a string in the format "value unit".
+            operation: A callable that takes two magnitudes and returns a boolean result.
+        
+        Returns:
+            The result of the comparison operation.
+        
+        Raises:
+            TypeError: If `other` is not a Measurement instance or a valid string representation.
+            ValueError: If the measurements have different dimensions and cannot be compared.
+        """
         if isinstance(other, str):
             other = Measurement.from_string(other)
 
         # Überprüfen, ob `other` ein Measurement-Objekt ist
         if not isinstance(other, Measurement):
-            return NotImplemented
+            raise TypeError("Comparison is only allowed between Measurement instances.")
         try:
             # Convert `other` to the same units as `self`
             other_converted: pint.Quantity = other.quantity.to(self.quantity.units)  # type: ignore
@@ -238,4 +272,17 @@ class Measurement:
         return self._compare(other, gt)
 
     def __ge__(self, other: Any) -> bool:
+        """
+        Returns True if this measurement is greater than or equal to another measurement.
+        
+        Comparison is performed after converting the other operand to the same unit. Raises a TypeError if the other object is not a Measurement instance or a compatible string, or a ValueError if the units are not compatible.
+        """
         return self._compare(other, ge)
+
+    def __hash__(self) -> int:
+        """
+        Returns a hash value based on the magnitude and unit of the measurement.
+        
+        This enables Measurement instances to be used in hash-based collections such as sets and dictionaries.
+        """
+        return hash((self.quantity.magnitude, str(self.quantity.units)))