GeneralManager 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

general_manager/factory/__init__.py

@@ -1,4 +1,4 @@
-from .lazy_methods import (
+from .factoryMethods import (
     LazyMeasurement,
     LazyDeltaDate,
     LazyProjectName,

general_manager/factory/factories.py

@@ -1,17 +1,16 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING, Type, Callable, Union, Any, TypeVar, Literal, cast
-from factory.declarations import LazyFunction, LazyAttribute, LazyAttributeSequence
+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
-from django.utils import timezone
 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
+from datetime import date, datetime, time, timezone
 
 if TYPE_CHECKING:
     from general_manager.interface.databaseInterface import (
@@ -33,7 +32,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
     ) = None
 
     @classmethod
-    def _generate(  # type: ignore
+    def _generate(
         cls, strategy: Literal["build", "create"], params: dict[str, Any]
     ) -> models.Model | list[models.Model]:
         cls._original_params = params
@@ -64,7 +63,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
                 continue  # Skip fields that are already set
             if isinstance(field, models.AutoField) or field.auto_created:
                 continue  # Skip auto fields
-            params[field.name] = get_field_value(field)
+            params[field.name] = getFieldValue(field)
 
         obj: list[models.Model] | models.Model = super()._generate(strategy, params)
         if isinstance(obj, list):
@@ -84,7 +83,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
             if field.name in attrs:
                 m2m_values = attrs[field.name]
             else:
-                m2m_values = get_m2m_field_value(field)
+                m2m_values = getManyToManyFieldValue(field)
             if m2m_values:
                 getattr(obj, field.name).set(m2m_values)
 
@@ -98,7 +97,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         return kwargs
 
     @classmethod
-    def _create(  # type: ignore
+    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)
@@ -107,7 +106,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         return cls._modelCreation(model_class, **kwargs)
 
     @classmethod
-    def _build(  # type: ignore
+    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)
@@ -157,7 +156,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         return created_objects
 
 
-def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) -> object:
+def getFieldValue(field: models.Field[Any, Any] | models.ForeignObjectRel) -> object:
     """
     Returns a suitable value for a given Django model field.
     """
@@ -166,22 +165,12 @@ def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) ->
             return None
 
     if isinstance(field, MeasurementField):
-        base_unit = field.base_unit
-        value = Decimal(str(random.uniform(0, 10_000))[:10])
-        return LazyFunction(lambda: Measurement(value, base_unit))
-    elif isinstance(field, models.CharField):
-        max_length = field.max_length or 100
-        # Check for RegexValidator
-        regex = None
-        for validator in field.validators:
-            if isinstance(validator, RegexValidator):
-                regex = getattr(validator.regex, "pattern", None)
-                break
-        if regex:
-            # Use exrex to generate a string matching the regex
-            return LazyFunction(lambda: exrex.getone(regex))  # type: ignore
-        else:
-            return cast(str, Faker("text", max_nb_chars=max_length))
+
+        def _measurement():
+            value = Decimal(random.randrange(0, 10_000_000)) / Decimal("100")  # two dp
+            return Measurement(value, field.base_unit)
+
+        return LazyFunction(_measurement)
     elif isinstance(field, models.TextField):
         return cast(str, Faker("paragraph"))
     elif isinstance(field, models.IntegerField):
@@ -201,8 +190,6 @@ def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) ->
         )
     elif isinstance(field, models.FloatField):
         return cast(float, Faker("pyfloat", positive=True))
-    elif isinstance(field, models.DateField):
-        return cast(date, Faker("date_between", start_date="-1y", end_date="today"))
     elif isinstance(field, models.DateTimeField):
         return cast(
             datetime,
@@ -213,10 +200,11 @@ def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) ->
                 tzinfo=timezone.utc,
             ),
         )
+    elif isinstance(field, models.DateField):
+        return cast(date, Faker("date_between", start_date="-1y", end_date="today"))
     elif isinstance(field, models.BooleanField):
         return cast(bool, Faker("pybool"))
-    elif isinstance(field, models.ForeignKey):
-        # Create or get an instance of the related model
+    elif isinstance(field, models.OneToOneField):
         if hasattr(field.related_model, "_general_manager_class"):
             related_factory = field.related_model._general_manager_class.Factory
             return related_factory()
@@ -229,11 +217,19 @@ def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) ->
                 raise ValueError(
                     f"No factory found for {field.related_model.__name__} and no instances found"
                 )
-    elif isinstance(field, models.OneToOneField):
-        # Similar to ForeignKey
+    elif isinstance(field, models.ForeignKey):
+        # Create or get an instance of the related model
         if hasattr(field.related_model, "_general_manager_class"):
+            create_a_new_instance = random.choice([True, True, False])
+            if not create_a_new_instance:
+                existing_instances = list(field.related_model.objects.all())
+                if existing_instances:
+                    # Pick a random existing instance
+                    return LazyFunction(lambda: random.choice(existing_instances))
+
             related_factory = field.related_model._general_manager_class.Factory
             return related_factory()
+
         else:
             # If no factory exists, pick a random existing instance
             related_instances = list(field.related_model.objects.all())
@@ -253,35 +249,56 @@ def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) ->
         return cast(str, Faker("uuid4"))
     elif isinstance(field, models.DurationField):
         return cast(time, Faker("time_delta"))
+    elif isinstance(field, models.CharField):
+        max_length = field.max_length or 100
+        # Check for RegexValidator
+        regex = None
+        for validator in field.validators:
+            if isinstance(validator, RegexValidator):
+                regex = getattr(validator.regex, "pattern", None)
+                break
+        if regex:
+            # Use exrex to generate a string matching the regex
+            return LazyFunction(lambda: exrex.getone(regex))  # type: ignore
+        else:
+            return cast(str, Faker("text", max_nb_chars=max_length))
     else:
         return None  # For unsupported field types
 
 
-def get_m2m_field_value(field: models.ManyToManyField[Any, Any]) -> list[models.Model]:
+def getManyToManyFieldValue(
+    field: models.ManyToManyField,
+) -> list[models.Model]:
     """
     Returns a list of instances for a ManyToMany field.
     """
-    related_factory = globals().get(f"{field.related_model.__name__}Factory")
-    existing_instances = list(field.related_model.objects.all())
+    related_factory = None
+    related_instances = list(field.related_model.objects.all())
+    if hasattr(field.related_model, "_general_manager_class"):
+        related_factory = field.related_model._general_manager_class.Factory
 
-    if related_factory:
-        # Use existing instances if available, otherwise create new ones
-        if existing_instances:
-            max_instances = len(existing_instances)
-            num_instances = random.randint(0, min(max_instances, 15))
-            return random.sample(existing_instances, num_instances)
-        else:
-            # No existing instances, create a few
-            num_to_create = random.randint(1, 3)
-            new_instances = [related_factory() for _ in range(num_to_create)]
-            return new_instances
+    min_required = 0 if field.blank else 1
+    number_of_instances = random.randint(min_required, 10)
+    if related_factory and related_instances:
+        number_to_create = random.randint(min_required, number_of_instances)
+        number_to_pick = number_of_instances - number_to_create
+        if number_to_pick > len(related_instances):
+            number_to_pick = len(related_instances)
+        existing_instances = random.sample(related_instances, number_to_pick)
+        new_instances = [related_factory() for _ in range(number_to_create)]
+        return existing_instances + new_instances
+    elif related_factory:
+        number_to_create = number_of_instances
+        new_instances = [related_factory() for _ in range(number_to_create)]
+        return new_instances
+    elif related_instances:
+        number_to_create = 0
+        number_to_pick = number_of_instances
+        if number_to_pick > len(related_instances):
+            number_to_pick = len(related_instances)
+        existing_instances = random.sample(related_instances, number_to_pick)
+        return existing_instances
     else:
-        # No factory exists, use existing instances
-        if existing_instances:
-            max_instances = len(existing_instances)
-            num_instances = random.randint(0, max_instances)
-            return random.sample(existing_instances, num_instances)
-        else:
-            raise ValueError(
-                f"No factory found for {field.related_model.__name__} and no instances found"
-            )
+        raise ValueError(
+            f"No factory found for {field.related_model.__name__} and no instances found"
+        )

general_manager/factory/factoryMethods.py

@@ -0,0 +1,109 @@
+from typing import Any, Optional
+from factory.declarations import LazyFunction, LazyAttribute, LazyAttributeSequence
+import random
+from general_manager.measurement.measurement import Measurement
+from datetime import timedelta, date, datetime
+from faker import Faker
+import uuid
+from decimal import Decimal
+
+fake = Faker()
+
+
+def LazyMeasurement(
+    min_value: int | float, max_value: int | float, unit: str
+) -> LazyFunction:
+    return LazyFunction(
+        lambda: Measurement(str(random.uniform(min_value, max_value))[:10], unit)
+    )
+
+
+def LazyDeltaDate(avg_delta_days: int, base_attribute: str) -> LazyAttribute:
+    return LazyAttribute(
+        lambda obj: (getattr(obj, base_attribute) or date.today())
+        + timedelta(days=random.randint(avg_delta_days // 2, avg_delta_days * 3 // 2))
+    )
+
+
+def LazyProjectName() -> LazyFunction:
+    return LazyFunction(
+        lambda: (
+            f"{fake.word().capitalize()} "
+            f"{fake.word().capitalize()} "
+            f"{fake.random_element(elements=('X', 'Z', 'G'))}"
+            f"-{fake.random_int(min=1, max=1000)}"
+        )
+    )
+
+
+def LazyDateToday() -> LazyFunction:
+    return LazyFunction(lambda: date.today())
+
+
+def LazyDateBetween(start_date: date, end_date: date) -> LazyAttribute:
+    delta = (end_date - start_date).days
+    return LazyAttribute(
+        lambda obj: start_date + timedelta(days=random.randint(0, delta))
+    )
+
+
+def LazyDateTimeBetween(start: datetime, end: datetime) -> LazyAttribute:
+    span = (end - start).total_seconds()
+    return LazyAttribute(
+        lambda obj: start + timedelta(seconds=random.randint(0, int(span)))
+    )
+
+
+def LazyInteger(min_value: int, max_value: int) -> LazyFunction:
+    return LazyFunction(lambda: random.randint(min_value, max_value))
+
+
+def LazyDecimal(min_value: float, max_value: float, precision: int = 2) -> LazyFunction:
+    fmt = f"{{:.{precision}f}}"
+    return LazyFunction(
+        lambda: Decimal(fmt.format(random.uniform(min_value, max_value)))
+    )
+
+
+def LazyChoice(options: list[Any]) -> LazyFunction:
+    return LazyFunction(lambda: random.choice(options))
+
+
+def LazySequence(start: int = 0, step: int = 1) -> LazyAttributeSequence:
+    return LazyAttributeSequence(lambda obj, n: start + n * step)
+
+
+def LazyBoolean(trues_ratio: float = 0.5) -> LazyFunction:
+    return LazyFunction(lambda: random.random() < trues_ratio)
+
+
+def LazyUUID() -> LazyFunction:
+    return LazyFunction(lambda: str(uuid.uuid4()))
+
+
+def LazyFakerName() -> LazyFunction:
+    return LazyFunction(lambda: fake.name())
+
+
+def LazyFakerEmail(
+    name: Optional[str] = None, domain: Optional[str] = None
+) -> LazyFunction:
+    if not name and not domain:
+        return LazyFunction(lambda: fake.email(domain=domain))
+    if not name:
+        name = fake.name()
+    if not domain:
+        domain = fake.domain_name()
+    return LazyFunction(lambda: name.replace(" ", "_") + "@" + domain)
+
+
+def LazyFakerSentence(number_of_words: int = 6) -> LazyFunction:
+    return LazyFunction(lambda: fake.sentence(nb_words=number_of_words))
+
+
+def LazyFakerAddress() -> LazyFunction:
+    return LazyFunction(lambda: fake.address())
+
+
+def LazyFakerUrl() -> LazyFunction:
+    return LazyFunction(lambda: fake.url())

general_manager/measurement/measurement.py

@@ -46,6 +46,14 @@ class Measurement:
     def quantity(self) -> pint.Quantity:
         return self.__quantity
 
+    @property
+    def magnitude(self) -> Decimal:
+        return self.__quantity.magnitude
+
+    @property
+    def unit(self) -> str:
+        return str(self.__quantity.units)
+
     @classmethod
     def from_string(cls, value: str) -> Measurement:
         value, unit = value.split(" ")

{generalmanager-0.3.2.dist-info → generalmanager-0.4.0.dist-info}/METADATA

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

{generalmanager-0.3.2.dist-info → generalmanager-0.4.0.dist-info}/RECORD

@@ -15,9 +15,9 @@ general_manager/cache/cacheTracker.py,sha256=rRw3OhBDf86hTC2Xbt1ocRgZqwu8_kXk4lc
 general_manager/cache/dependencyIndex.py,sha256=kEbIAzzMzKlQgplKfcMYBPZ562zCBkOBKvJusxO_iC4,10537
 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=DLSQbpSBpujPtDSZcruPc43OLWzKCCtf20gbalCDYRU,91
-general_manager/factory/factories.py,sha256=31NyVw2Ju5ZDPJ6sax6_seyZesCU5UrviNbk-2PaKnA,11559
-general_manager/factory/lazy_methods.py,sha256=UJC50a4Gbe4T5IQPh7ucyQqpaS2x4zhQzznwpJvyVLo,1155
+general_manager/factory/__init__.py,sha256=wbPIGyBlWBHa7aGWUd-1IUMPWUS-M6YqtPUL1iKXW8U,93
+general_manager/factory/factories.py,sha256=R2_iAVRspfysDNT_cKyJuMT38RFkNbjnPR3yjAXZRkc,12188
+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
@@ -28,7 +28,7 @@ general_manager/manager/groupManager.py,sha256=O4FABqbm7KlZw6t36Ot3HU1FsBYN0h6Zh
 general_manager/manager/input.py,sha256=iKawV3P1QICz-0AQUF00OvH7LZYxussg3svpvCUl8hE,2977
 general_manager/manager/meta.py,sha256=5wHrCVnua5c38vpVZSCesrNvgydQDH8h6pxW6_QgCDg,3107
 general_manager/measurement/__init__.py,sha256=X97meFujBldE5v0WMF7SmKeGpC5R0JTczfLo_Lq1Xek,84
-general_manager/measurement/measurement.py,sha256=hTISANW7nAN2voakq9f-naJxa1MUcxWLDrcDW1Rdn3s,9340
+general_manager/measurement/measurement.py,sha256=IMUY8vmoEIrclMW9FWLgL2Wi61rH1J0NMSmjYdMkMHM,9516
 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
@@ -39,8 +39,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.3.2.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.3.2.dist-info/METADATA,sha256=xE5D8fR08XEmMO8Fn2GbO5cu9Y1ESY1vvjZE660JfUA,8188
-generalmanager-0.3.2.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-generalmanager-0.3.2.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.3.2.dist-info/RECORD,,
+generalmanager-0.4.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.4.0.dist-info/METADATA,sha256=hA9V_hws-DSJegQQBxWgjhOnrDxIdeEJq_f7gHeOzPo,8188
+generalmanager-0.4.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+generalmanager-0.4.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.4.0.dist-info/RECORD,,

{generalmanager-0.3.2.dist-info → generalmanager-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

general_manager/factory/lazy_methods.py

@@ -1,38 +0,0 @@
-from typing import Any
-from factory.declarations import LazyFunction, LazyAttribute, LazyAttributeSequence
-import random
-from general_manager.measurement.measurement import Measurement
-from datetime import timedelta, date
-from faker import Faker
-
-fake = Faker()
-
-
-def LazyMeasurement(
-    min_value: int | float, max_value: int | float, unit: str
-) -> LazyFunction:
-    return LazyFunction(
-        lambda: Measurement(str(random.uniform(min_value, max_value))[:10], unit)
-    )
-
-
-def LazyDeltaDate(avg_delta_days: int, base_attribute: str) -> LazyAttribute:
-    return LazyAttribute(
-        lambda obj: (getattr(obj, base_attribute) or date.today())
-        + timedelta(days=random.randint(avg_delta_days // 2, avg_delta_days * 3 // 2))
-    )
-
-
-def LazyProjectName() -> LazyFunction:
-    return LazyFunction(
-        lambda: (
-            f"{fake.word().capitalize()} "
-            f"{fake.word().capitalize()} "
-            f"{fake.random_element(elements=('X', 'Z', 'G'))}"
-            f"-{fake.random_int(min=1, max=1000)}"
-        )
-    )
-
-
-def LazySapNumber() -> LazyAttributeSequence:
-    return LazyAttributeSequence(lambda obj, n: f"60{n:04d}")