GeneralManager 0.3.1__tar.gz → 0.4.0__tar.gz

{generalmanager-0.3.1 → generalmanager-0.4.0}/GeneralManager.egg-info/PKG-INFO

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

{generalmanager-0.3.1 → generalmanager-0.4.0}/GeneralManager.egg-info/SOURCES.txt

@@ -25,7 +25,7 @@ src/general_manager/cache/modelDependencyCollector.py
 src/general_manager/cache/signals.py
 src/general_manager/factory/__init__.py
 src/general_manager/factory/factories.py
-src/general_manager/factory/lazy_methods.py
+src/general_manager/factory/factoryMethods.py
 src/general_manager/interface/__init__.py
 src/general_manager/interface/baseInterface.py
 src/general_manager/interface/calculationInterface.py
@@ -51,6 +51,9 @@ tests/test_argsToKwargs.py
 tests/test_basePermission.py
 tests/test_cacheDecorator.py
 tests/test_cacheTracker.py
+tests/test_dependencyIndex.py
+tests/test_factories.py
+tests/test_factoryMethods.py
 tests/test_filterParser.py
 tests/test_graph_ql.py
 tests/test_input.py
@@ -63,4 +66,5 @@ tests/test_modelDependencyCollector.py
 tests/test_noneToZero.py
 tests/test_rule_handler.py
 tests/test_rules.py
-tests/test_settings.py
+tests/test_settings.py
+tests/test_signals.py

{generalmanager-0.3.1 → generalmanager-0.4.0}/PKG-INFO

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

{generalmanager-0.3.1 → generalmanager-0.4.0}/pyproject.toml

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

{generalmanager-0.3.1 → generalmanager-0.4.0}/src/general_manager/cache/dependencyIndex.py

@@ -33,18 +33,19 @@ type Dependency = Tuple[general_manager_name, filter_type, str]
 INDEX_KEY = "dependency_index"  # Key unter dem der gesamte Index liegt
 LOCK_KEY = "dependency_index_lock"  # Key für das Sperr‑Mutex
 LOCK_TIMEOUT = 5  # Sekunden TTL für den Lock
+UNDEFINED = object()  # Dummy für nicht definierte Werte
 
 
 # -----------------------------------------------------------------------------
 # LOCKING HELPERS
 # -----------------------------------------------------------------------------
 def acquire_lock(timeout: int = LOCK_TIMEOUT) -> bool:
-    """Atomar: legt den LOCK_KEY an, wenn noch frei."""
+    """Atomar: create Lock key if it doesn't exist."""
     return cache.add(LOCK_KEY, "1", timeout)
 
 
 def release_lock() -> None:
-    """Gibt den Lock frei."""
+    """Release Lock key."""
     cache.delete(LOCK_KEY)
 
 
@@ -52,7 +53,7 @@ def release_lock() -> None:
 # INDEX ACCESS
 # -----------------------------------------------------------------------------
 def get_full_index() -> dependency_index:
-    """Lädt oder initialisiert den kompletten Index."""
+    """Load or initialize the full index."""
     idx = cache.get(INDEX_KEY, None)
     if idx is None:
         idx: dependency_index = {"filter": {}, "exclude": {}}
@@ -61,7 +62,7 @@ def get_full_index() -> dependency_index:
 
 
 def set_full_index(idx: dependency_index) -> None:
-    """Schreibt den kompletten Index zurück in den Cache."""
+    """Write the complete index back to the cache."""
     cache.set(INDEX_KEY, idx, None)
 
 
@@ -78,15 +79,6 @@ def record_dependencies(
         ]
     ],
 ) -> None:
-    """
-    Speichert die Abhängigkeiten eines Cache Eintrags.
-    :param cache_key:   der Key unter dem das Ergebnis im cache steht
-    :param dependencies: Iterable von Tuplen (model_name, action, identifier)
-                         action ∈ {'filter','exclude'} oder sonstige → 'id'
-                         identifier = für filter/exclude: Dict String,
-                                      sonst: Primärschlüssel als String
-    """
-    # 1) Lock holen (Spin‑Lock mit Timeout)
     start = time.time()
     while not acquire_lock():
         if time.time() - start > LOCK_TIMEOUT:
@@ -105,7 +97,7 @@ def record_dependencies(
                     lookup_map.setdefault(val_key, set()).add(cache_key)
 
             else:
-                # Direkter ID‑Lookup als simpler filter auf 'id'
+                # director ID Lookup as simple filter on 'id'
                 section = idx["filter"].setdefault(model_name, {})
                 lookup_map = section.setdefault("identification", {})
                 val_key = identifier
@@ -120,15 +112,12 @@ def record_dependencies(
 # -----------------------------------------------------------------------------
 # INDEX CLEANUP
 # -----------------------------------------------------------------------------
-def remove_cache_key_from_index(cache_key: str) -> bool:
-    """
-    Entfernt einen cache_key aus allen Einträgen in filter/​exclude.
-    Nützlich, sobald Du den Cache gelöscht hast.
-    """
+def remove_cache_key_from_index(cache_key: str) -> None:
+    """Remove a cache key from the index."""
     start = time.time()
     while not acquire_lock():
         if time.time() - start > LOCK_TIMEOUT:
-            return False
+            raise TimeoutError("Could not aquire lock for remove_cache_key_from_index")
         time.sleep(0.05)
 
     try:
@@ -149,14 +138,12 @@ def remove_cache_key_from_index(cache_key: str) -> bool:
         set_full_index(idx)
     finally:
         release_lock()
-    return True
 
 
 # -----------------------------------------------------------------------------
 # CACHE INVALIDATION
 # -----------------------------------------------------------------------------
 def invalidate_cache_key(cache_key: str) -> None:
-    """Löscht den CacheEintrag – hier nutzt du deinen CacheBackend."""
     cache.delete(cache_key)
 
 
@@ -165,33 +152,28 @@ def capture_old_values(
     sender: Type[GeneralManager], instance: GeneralManager | None, **kwargs
 ) -> None:
     if instance is None:
-        # Wenn es kein Modell ist, gibt es nichts zu tun
         return
     manager_name = sender.__name__
     idx = get_full_index()
-    # Welche Lookups interessieren uns für diesen Model?
+    # get all lookups for this model
     lookups = set()
     for action in ("filter", "exclude"):
         lookups |= set(idx.get(action, {}).get(manager_name, {}))
     if lookups and instance.identification:
-        # Speichere alle relevanten Attribute für später
+        # save old values for later comparison
         vals = {}
         for lookup in lookups:
             attr_path = lookup.split("__")
             obj = instance
-            for attr in attr_path:
-                obj = getattr(obj, attr, None)
-                if obj is None:
+            for i, attr in enumerate(attr_path):
+                if getattr(obj, attr, UNDEFINED) is UNDEFINED:
+                    lookup = "__".join(attr_path[:i])
                     break
+                obj = getattr(obj, attr, None)
             vals[lookup] = obj
         setattr(instance, "_old_values", vals)
 
 
-# -----------------------------------------------------------------------------
-# GENERIC CACHE INVALIDATION: vergleicht alt vs. neu und invalidiert nur bei Übergang
-# -----------------------------------------------------------------------------
-
-
 @receiver(post_data_change)
 def generic_cache_invalidation(
     sender: type[GeneralManager],
@@ -236,18 +218,32 @@ def generic_cache_invalidation(
         # wildcard / regex
         if op in ("contains", "startswith", "endswith", "regex"):
             try:
-                pattern = re.compile(val_key)
-            except:
-                return False
-            text = value or ""
-            return bool(pattern.search(text))
+                literal = ast.literal_eval(val_key)
+            except Exception:
+                literal = val_key
+
+            # ensure we always work with strings to avoid TypeErrors
+            text = "" if value is None else str(value)
+            if op == "contains":
+                return literal in text
+            if op == "startswith":
+                return text.startswith(literal)
+            if op == "endswith":
+                return text.endswith(literal)
+            # regex: val_key selbst als Pattern benutzen
+            if op == "regex":
+                try:
+                    pattern = re.compile(val_key)
+                except re.error:
+                    return False
+                return bool(pattern.search(text))
 
         return False
 
     for action in ("filter", "exclude"):
         model_section = idx.get(action, {}).get(manager_name, {})
         for lookup, lookup_map in model_section.items():
-            # 1) Operator und Attributpfad ermitteln
+            # 1) get operator and attribute path
             parts = lookup.split("__")
             if parts[-1] in (
                 "gt",
@@ -266,8 +262,8 @@ def generic_cache_invalidation(
                 op = "eq"
                 attr_path = parts
 
-            # 2) Alten und neuen Wert holen
-            old_val = old_relevant_values.get(lookup)
+            # 2) get old & new value
+            old_val = old_relevant_values.get("__".join(attr_path))
 
             obj = instance
             for attr in attr_path:
@@ -276,14 +272,14 @@ def generic_cache_invalidation(
                     break
             new_val = obj
 
-            # 3) Für jedes val_key prüfen
+            # 3) check against all cache_keys
             for val_key, cache_keys in list(lookup_map.items()):
                 old_match = matches(op, old_val, val_key)
                 new_match = matches(op, new_val, val_key)
 
                 if action == "filter":
-                    # Direkte & alle Filter-Abhängigkeiten: immer invalidieren, wenn neu matcht
-                    if new_match:
+                    # Filter: invalidate if new match or old match
+                    if new_match or old_match:
                         print(
                             f"Invalidate cache key {cache_keys} for filter {lookup} with value {val_key}"
                         )
@@ -292,7 +288,7 @@ def generic_cache_invalidation(
                             remove_cache_key_from_index(ck)
 
                 else:  # action == 'exclude'
-                    # Excludes: nur invalidieren, wenn sich der Match-Status ändert
+                    # Excludes: invalidate only if matches changed
                     if old_match != new_match:
                         print(
                             f"Invalidate cache key {cache_keys} for exclude {lookup} with value {val_key}"

{generalmanager-0.3.1 → generalmanager-0.4.0}/src/general_manager/factory/__init__.py

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

{generalmanager-0.3.1 → generalmanager-0.4.0}/src/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"
+        )

generalmanager-0.4.0/src/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())

{generalmanager-0.3.1 → generalmanager-0.4.0}/src/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(" ")