GeneralManager 0.0.0__py3-none-any.whl

general_manager/cache/dependencyIndex.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+import time
+import ast
+import re
+
+from django.core.cache import cache
+from general_manager.cache.signals import post_data_change, pre_data_change
+from django.dispatch import receiver
+from typing import Literal, Any, Iterable, TYPE_CHECKING, Type
+
+if TYPE_CHECKING:
+    from general_manager.manager.generalManager import GeneralManager
+
+type general_manager_name = str  # e.g. "Project", "Derivative", "User"
+type attribute = str  # e.g. "field", "name", "id"
+type lookup = str  # e.g. "field__gt", "field__in", "field__contains", "field"
+type cache_keys = set[str]  # e.g. "cache_key_1", "cache_key_2"
+type identifier = str  # e.g. "{'id': 1}"", "{'project': Project(**{'id': 1})}", ...
+type dependency_index = dict[
+    Literal["filter", "exclude"],
+    dict[
+        general_manager_name,
+        dict[attribute, dict[lookup, cache_keys]],
+    ],
+]
+
+
+# -----------------------------------------------------------------------------
+# CONFIG
+# -----------------------------------------------------------------------------
+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
+
+
+# -----------------------------------------------------------------------------
+# LOCKING HELPERS
+# -----------------------------------------------------------------------------
+def acquire_lock(timeout: int = LOCK_TIMEOUT) -> bool:
+    """Atomar: legt den LOCK_KEY an, wenn noch frei."""
+    return cache.add(LOCK_KEY, "1", timeout)
+
+
+def release_lock() -> None:
+    """Gibt den Lock frei."""
+    cache.delete(LOCK_KEY)
+
+
+# -----------------------------------------------------------------------------
+# INDEX ACCESS
+# -----------------------------------------------------------------------------
+def get_full_index() -> dependency_index:
+    """Lädt oder initialisiert den kompletten Index."""
+    idx = cache.get(INDEX_KEY, None)
+    if idx is None:
+        idx: dependency_index = {"filter": {}, "exclude": {}}
+        cache.set(INDEX_KEY, idx, None)
+    return idx
+
+
+def set_full_index(idx: dependency_index) -> None:
+    """Schreibt den kompletten Index zurück in den Cache."""
+    cache.set(INDEX_KEY, idx, None)
+
+
+# -----------------------------------------------------------------------------
+# DEPENDENCY RECORDING
+# -----------------------------------------------------------------------------
+def record_dependencies(
+    cache_key: str,
+    dependencies: Iterable[
+        tuple[
+            general_manager_name,
+            Literal["filter", "exclude", "identification"],
+            identifier,
+        ]
+    ],
+) -> 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:
+            raise TimeoutError("Could not aquire lock for record_dependencies")
+        time.sleep(0.05)
+
+    try:
+        idx = get_full_index()
+        for model_name, action, identifier in dependencies:
+            if action in ("filter", "exclude"):
+                params = ast.literal_eval(identifier)
+                section = idx[action].setdefault(model_name, {})
+                for lookup, val in params.items():
+                    lookup_map = section.setdefault(lookup, {})
+                    val_key = repr(val)
+                    lookup_map.setdefault(val_key, set()).add(cache_key)
+
+            else:
+                # Direkter ID‑Lookup als simpler filter auf 'id'
+                section = idx["filter"].setdefault(model_name, {})
+                lookup_map = section.setdefault("identification", {})
+                val_key = identifier
+                lookup_map.setdefault(val_key, set()).add(cache_key)
+
+        set_full_index(idx)
+
+    finally:
+        release_lock()
+
+
+# -----------------------------------------------------------------------------
+# 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.
+    """
+    start = time.time()
+    while not acquire_lock():
+        if time.time() - start > LOCK_TIMEOUT:
+            return False
+        time.sleep(0.05)
+
+    try:
+        idx = get_full_index()
+        for action in ("filter", "exclude"):
+            action_section = idx.get(action, {})
+            for mname, model_section in list(action_section.items()):
+                for lookup, lookup_map in list(model_section.items()):
+                    for val_key, key_set in list(lookup_map.items()):
+                        if cache_key in key_set:
+                            key_set.remove(cache_key)
+                            if not key_set:
+                                del lookup_map[val_key]
+                    if not lookup_map:
+                        del model_section[lookup]
+                if not model_section:
+                    del action_section[mname]
+        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)
+
+
+@receiver(pre_data_change)
+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?
+    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
+        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:
+                    break
+            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],
+    instance: GeneralManager,
+    old_relevant_values: dict[str, Any],
+    **kwargs,
+):
+    manager_name = sender.__name__
+    idx = get_full_index()
+
+    def matches(op: str, value: Any, val_key: Any) -> bool:
+        if value is None:
+            return False
+
+        # eq
+        if op == "eq":
+            return repr(value) == val_key
+
+        # in
+        if op == "in":
+            try:
+                seq = ast.literal_eval(val_key)
+                return value in seq
+            except:
+                return False
+
+        # range
+        if op in ("gt", "gte", "lt", "lte"):
+            try:
+                thr = type(value)(ast.literal_eval(val_key))
+            except:
+                return False
+            if op == "gt":
+                return value > thr
+            if op == "gte":
+                return value >= thr
+            if op == "lt":
+                return value < thr
+            if op == "lte":
+                return value <= thr
+
+        # 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))
+
+        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
+            parts = lookup.split("__")
+            if parts[-1] in (
+                "gt",
+                "gte",
+                "lt",
+                "lte",
+                "in",
+                "contains",
+                "startswith",
+                "endswith",
+                "regex",
+            ):
+                op = parts[-1]
+                attr_path = parts[:-1]
+            else:
+                op = "eq"
+                attr_path = parts
+
+            # 2) Alten und neuen Wert holen
+            old_val = old_relevant_values.get(lookup)
+
+            obj = instance
+            for attr in attr_path:
+                obj = getattr(obj, attr, None)
+                if obj is None:
+                    break
+            new_val = obj
+
+            # 3) Für jedes val_key prüfen
+            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:
+                        print(
+                            f"Invalidate cache key {cache_keys} for filter {lookup} with value {val_key}"
+                        )
+                        for ck in list(cache_keys):
+                            invalidate_cache_key(ck)
+                            remove_cache_key_from_index(ck)
+
+                else:  # action == 'exclude'
+                    # Excludes: nur invalidieren, wenn sich der Match-Status ändert
+                    if old_match != new_match:
+                        print(
+                            f"Invalidate cache key {cache_keys} for exclude {lookup} with value {val_key}"
+                        )
+                        for ck in list(cache_keys):
+                            invalidate_cache_key(ck)
+                            remove_cache_key_from_index(ck)

general_manager/cache/pathMapping.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, cast, get_args
+from general_manager.manager.meta import GeneralManagerMeta
+from general_manager.api.property import GraphQLProperty
+
+if TYPE_CHECKING:
+    from general_manager.interface.baseInterface import Bucket
+    from general_manager.manager.generalManager import GeneralManager
+
+
+type PathStart = str
+type PathDestination = str
+
+
+class PathMap:
+
+    instance: PathMap
+    mapping: dict[tuple[PathStart, PathDestination], PathTracer] = {}
+
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, "instance"):
+            cls.instance = super().__new__(cls)
+            cls.createPathMapping()
+        return cls.instance
+
+    @classmethod
+    def createPathMapping(cls):
+        all_managed_classes = GeneralManagerMeta.all_classes
+        for start_class in all_managed_classes:
+            for destination_class in all_managed_classes:
+                if start_class != destination_class:
+                    cls.instance.mapping[
+                        (start_class.__name__, destination_class.__name__)
+                    ] = PathTracer(start_class, destination_class)
+
+    def __init__(self, path_start: PathStart | GeneralManager | type[GeneralManager]):
+        from general_manager.manager.generalManager import GeneralManager
+
+        if isinstance(path_start, GeneralManager):
+            self.start_instance = path_start
+            self.start_class = path_start.__class__
+            self.start_class_name = path_start.__class__.__name__
+        elif isinstance(path_start, type):
+            self.start_instance = None
+            self.start_class = path_start
+            self.start_class_name = path_start.__name__
+        else:
+            self.start_instance = None
+            self.start_class = None
+            self.start_class_name = path_start
+
+    def to(
+        self, path_destination: PathDestination | type[GeneralManager] | str
+    ) -> PathTracer | None:
+        if isinstance(path_destination, type):
+            path_destination = path_destination.__name__
+
+        tracer = self.mapping.get((self.start_class_name, path_destination), None)
+        if not tracer:
+            return None
+        return tracer
+
+    def goTo(
+        self, path_destination: PathDestination | type[GeneralManager] | str
+    ) -> GeneralManager | Bucket | None:
+        if isinstance(path_destination, type):
+            path_destination = path_destination.__name__
+
+        tracer = self.mapping.get((self.start_class_name, path_destination), None)
+        if not tracer:
+            return None
+        if not self.start_instance:
+            raise ValueError("Cannot call goTo on a PathMap without a start instance.")
+        return tracer.traversePath(self.start_instance)
+
+    def getAllConnected(self) -> set[str]:
+        """
+        Returns a list of all classes that are connected to the start class.
+        """
+        connected_classes: set[str] = set()
+        for path_tuple in self.mapping.keys():
+            if path_tuple[0] == self.start_class_name:
+                destination_class_name = path_tuple[1]
+                connected_classes.add(destination_class_name)
+        return connected_classes
+
+
+class PathTracer:
+    def __init__(
+        self, start_class: type[GeneralManager], destination_class: type[GeneralManager]
+    ):
+        self.start_class = start_class
+        self.destination_class = destination_class
+        if self.start_class == self.destination_class:
+            self.path = []
+        else:
+            self.path = self.createPath(start_class, [])
+
+    def createPath(
+        self, current_manager: type[GeneralManager], path: list[str]
+    ) -> list[str] | None:
+        from general_manager.manager.generalManager import GeneralManager
+
+        current_connections = {
+            attr_name: attr_value["type"]
+            for attr_name, attr_value in current_manager.Interface.getAttributeTypes().items()
+        }
+        for attr_name, attr_value in current_manager.__dict__.items():
+            if not isinstance(attr_value, GraphQLProperty):
+                continue
+            type_hints = get_args(attr_value.graphql_type_hint)
+            field_type = (
+                type_hints[0]
+                if type_hints
+                else cast(type, attr_value.graphql_type_hint)
+            )
+            current_connections[attr_name] = field_type
+        for attr, attr_type in current_connections.items():
+            if attr in path or attr_type == self.start_class:
+                continue
+            if not issubclass(attr_type, GeneralManager):
+                continue
+            if attr_type == self.destination_class:
+                return [*path, attr]
+            result = self.createPath(attr_type, [*path, attr])
+            if result:
+                return result
+
+        return None
+
+    def traversePath(
+        self, start_instance: GeneralManager | Bucket
+    ) -> GeneralManager | Bucket | None:
+        from general_manager.interface.baseInterface import Bucket
+
+        current_instance = start_instance
+        if not self.path:
+            return None
+        for attr in self.path:
+            if not isinstance(current_instance, Bucket):
+                current_instance = getattr(current_instance, attr)
+                continue
+            new_instance = None
+            for entry in current_instance:
+                if not new_instance:
+                    new_instance = getattr(entry, attr)
+                else:
+                    new_instance = new_instance | getattr(entry, attr)
+            current_instance = new_instance
+
+        return current_instance

general_manager/cache/signals.py

@@ -0,0 +1,48 @@
+from django.dispatch import Signal
+from typing import Callable, Any
+from functools import wraps
+
+post_data_change = Signal()
+
+pre_data_change = Signal()
+
+
+def dataChange(func: Callable[..., Any]) -> Callable:
+    """
+    Signal to indicate that data has changed.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        action = func.__name__
+        if func.__name__ == "create":
+            sender = args[0]
+            instance_before = None
+        else:
+            instance = args[0]
+            sender = instance.__class__
+            instance_before = instance
+        pre_data_change.send(
+            sender=sender,
+            instance=instance_before,
+            action=action,
+            **kwargs,
+        )
+        old_relevant_values = getattr(instance_before, "_old_values", {})
+        result = (
+            func.__func__(*args, **kwargs)
+            if isinstance(func, classmethod)
+            else func(*args, **kwargs)
+        )
+        instance = result
+
+        post_data_change.send(
+            sender=sender,
+            instance=instance,
+            action=action,
+            old_relevant_values=old_relevant_values,
+            **kwargs,
+        )
+        return result
+
+    return wrapper

general_manager/factory/__init__.py

@@ -0,0 +1,5 @@
+from .lazy_methods import (
+    LazyMeasurement,
+    LazyDeltaDate,
+    LazyProjectName,
+)