GeneralManager 0.2.0__tar.gz → 0.3.0__tar.gz

{generalmanager-0.2.0 → generalmanager-0.3.0}/GeneralManager.egg-info/PKG-INFO

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

{generalmanager-0.2.0 → generalmanager-0.3.0}/GeneralManager.egg-info/SOURCES.txt

@@ -14,10 +14,13 @@ src/general_manager/api/property.py
 src/general_manager/auxiliary/__init__.py
 src/general_manager/auxiliary/argsToKwargs.py
 src/general_manager/auxiliary/filterParser.py
+src/general_manager/auxiliary/jsonEncoder.py
+src/general_manager/auxiliary/makeCacheKey.py
 src/general_manager/auxiliary/noneToZero.py
 src/general_manager/cache/cacheDecorator.py
 src/general_manager/cache/cacheTracker.py
 src/general_manager/cache/dependencyIndex.py
+src/general_manager/cache/modelDependencyCollector.py
 src/general_manager/cache/pathMapping.py
 src/general_manager/cache/signals.py
 src/general_manager/factory/__init__.py
@@ -49,6 +52,7 @@ tests/test_basePermission.py
 tests/test_filterParser.py
 tests/test_graph_ql.py
 tests/test_input.py
+tests/test_jsonEncoder.py
 tests/test_managerBasedPermission.py
 tests/test_measurement.py
 tests/test_measurement_field.py

{generalmanager-0.2.0 → generalmanager-0.3.0}/PKG-INFO

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

{generalmanager-0.2.0 → generalmanager-0.3.0}/pyproject.toml

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

generalmanager-0.3.0/src/general_manager/auxiliary/jsonEncoder.py

@@ -0,0 +1,19 @@
+from datetime import datetime, date, time
+import json
+from general_manager.manager.generalManager import GeneralManager
+
+
+class CustomJSONEncoder(json.JSONEncoder):
+    def default(self, o):
+
+        # Serialize datetime objects as ISO strings
+        if isinstance(o, (datetime, date, time)):
+            return o.isoformat()
+        # Handle GeneralManager instances
+        if isinstance(o, GeneralManager):
+            return f"{o.__class__.__name__}(**{o.identification})"
+        try:
+            return super().default(o)
+        except TypeError:
+            # Fallback: convert all other objects to str
+            return str(o)

generalmanager-0.3.0/src/general_manager/auxiliary/makeCacheKey.py

@@ -0,0 +1,30 @@
+import inspect
+import json
+from general_manager.auxiliary.jsonEncoder import CustomJSONEncoder
+from hashlib import sha256
+
+
+def make_cache_key(func, args, kwargs):
+    """
+    Generate a deterministic cache key for a function call.
+
+    Args:
+        func: The function being called
+        args: Positional arguments to the function
+        kwargs: Keyword arguments to the function
+
+    Returns:
+        str: A hexadecimal SHA-256 hash that uniquely identifies this function call
+    """
+    sig = inspect.signature(func)
+    bound = sig.bind_partial(*args, **kwargs)
+    bound.apply_defaults()
+    payload = {
+        "module": func.__module__,
+        "name": func.__name__,
+        "args": bound.arguments,
+    }
+    raw = json.dumps(
+        payload, sort_keys=True, default=str, cls=CustomJSONEncoder
+    ).encode()
+    return sha256(raw, usedforsecurity=False).hexdigest()

generalmanager-0.3.0/src/general_manager/cache/cacheDecorator.py

@@ -0,0 +1,45 @@
+from typing import Any, Callable, Optional, Protocol, Set
+from functools import wraps
+from django.core.cache import cache as django_cache
+from general_manager.cache.cacheTracker import DependencyTracker
+from general_manager.cache.dependencyIndex import record_dependencies, Dependency
+from general_manager.cache.modelDependencyCollector import ModelDependencyCollector
+from general_manager.auxiliary.makeCacheKey import make_cache_key
+
+
+class CacheBackend(Protocol):
+    def get(self, key: str) -> Any: ...
+    def set(self, key: str, value: Any, timeout: Optional[int] = None) -> None: ...
+
+
+RecordFn = Callable[[str, Set[Dependency]], None]
+
+
+def cached(
+    timeout: Optional[int] = None,
+    cache_backend: CacheBackend = django_cache,
+    record_fn: RecordFn = record_dependencies,
+) -> Callable:
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            key = make_cache_key(func, args, kwargs)
+
+            result = cache_backend.get(key)
+            if result is not None:
+                return result
+
+            with DependencyTracker() as dependencies:
+                result = func(*args, **kwargs)
+                ModelDependencyCollector.addArgs(dependencies, args, kwargs)
+
+            cache_backend.set(key, result, timeout)
+
+            if dependencies and timeout is None:
+                record_fn(key, dependencies)
+
+            return result
+
+        return wrapper
+
+    return decorator

generalmanager-0.3.0/src/general_manager/cache/cacheTracker.py

@@ -0,0 +1,34 @@
+import threading
+from general_manager.cache.dependencyIndex import (
+    general_manager_name,
+    Dependency,
+    filter_type,
+)
+
+# Thread-lokale Variable zur Speicherung der Abhängigkeiten
+_dependency_storage = threading.local()
+
+
+class DependencyTracker:
+    def __enter__(
+        self,
+    ) -> set[Dependency]:
+        _dependency_storage.dependencies = set()
+        return _dependency_storage.dependencies
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if hasattr(_dependency_storage, "dependencies"):
+            del _dependency_storage.dependencies
+
+    @staticmethod
+    def track(
+        class_name: general_manager_name,
+        operation: filter_type,
+        identifier: str,
+    ) -> None:
+        """
+        Adds a dependency to the dependency storage.
+        """
+        if hasattr(_dependency_storage, "dependencies"):
+            dependencies: set[Dependency] = _dependency_storage.dependencies
+            dependencies.add((class_name, operation, identifier))

{generalmanager-0.2.0 → generalmanager-0.3.0}/src/general_manager/cache/dependencyIndex.py

@@ -6,7 +6,7 @@ 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
+from typing import Literal, Any, Iterable, TYPE_CHECKING, Type, Tuple
 
 if TYPE_CHECKING:
     from general_manager.manager.generalManager import GeneralManager
@@ -24,6 +24,8 @@ type dependency_index = dict[
     ],
 ]
 
+type filter_type = Literal["filter", "exclude", "identification"]
+type Dependency = Tuple[general_manager_name, filter_type, str]
 
 # -----------------------------------------------------------------------------
 # CONFIG

generalmanager-0.3.0/src/general_manager/cache/modelDependencyCollector.py

@@ -0,0 +1,51 @@
+from typing import Generator
+from general_manager.manager.generalManager import GeneralManager, Bucket
+from general_manager.cache.dependencyIndex import (
+    general_manager_name,
+    Dependency,
+    filter_type,
+)
+
+
+class ModelDependencyCollector:
+
+    def __init__(self, dependencies: set[Dependency]):
+        """
+        Initialize the ModelDependencyCollector with a set of dependencies.
+        """
+        self.dependencies = dependencies
+
+    @staticmethod
+    def collect(obj) -> Generator[tuple[general_manager_name, filter_type, str]]:
+        """Recursively find Django model instances in the object."""
+        if isinstance(obj, GeneralManager):
+            yield (
+                obj.__class__.__name__,
+                "identification",
+                f"{obj.identification}",
+            )
+        elif isinstance(obj, Bucket):
+            yield (obj._manager_class.__name__, "filter", f"{obj.filters}")
+            yield (obj._manager_class.__name__, "exclude", f"{obj.excludes}")
+        elif isinstance(obj, dict):
+            for v in obj.values():
+                yield from ModelDependencyCollector.collect(v)
+        elif isinstance(obj, (list, tuple, set)):
+            for item in obj:
+                yield from ModelDependencyCollector.collect(item)
+
+    @staticmethod
+    def addArgs(dependencies: set[Dependency], args: tuple, kwargs: dict) -> None:
+        """
+        Add dependencies to the dependency set.
+        """
+        if args and isinstance(args[0], GeneralManager):
+            inner_self = args[0]
+            for attr_val in inner_self.__dict__.values():
+                for dependency_tuple in ModelDependencyCollector.collect(attr_val):
+                    dependencies.add(dependency_tuple)
+
+        for dependency_tuple in ModelDependencyCollector.collect(args):
+            dependencies.add(dependency_tuple)
+        for dependency_tuple in ModelDependencyCollector.collect(kwargs):
+            dependencies.add(dependency_tuple)

{generalmanager-0.2.0 → generalmanager-0.3.0}/src/general_manager/manager/generalManager.py

@@ -7,7 +7,7 @@ from general_manager.interface.baseInterface import (
     GeneralManagerType,
 )
 from general_manager.api.property import GraphQLProperty
-from general_manager.cache.cacheTracker import addDependency
+from general_manager.cache.cacheTracker import DependencyTracker
 from general_manager.cache.signals import dataChange
 
 if TYPE_CHECKING:
@@ -21,7 +21,9 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
     def __init__(self, *args: Any, **kwargs: Any):
         self._interface = self.Interface(*args, **kwargs)
         self.__id: dict[str, Any] = self._interface.identification
-        addDependency(self.__class__.__name__, "identification", f"{self.__id}")
+        DependencyTracker.track(
+            self.__class__.__name__, "identification", f"{self.__id}"
+        )
 
     def __str__(self):
         return f"{self.__class__.__name__}(**{self.__id})"
@@ -108,12 +110,16 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
 
     @classmethod
     def filter(cls, **kwargs: Any) -> Bucket[GeneralManagerType]:
-        addDependency(cls.__name__, "filter", f"{cls.__parse_identification(kwargs)}")
+        DependencyTracker.track(
+            cls.__name__, "filter", f"{cls.__parse_identification(kwargs)}"
+        )
         return cls.Interface.filter(**kwargs)
 
     @classmethod
     def exclude(cls, **kwargs: Any) -> Bucket[GeneralManagerType]:
-        addDependency(cls.__name__, "exclude", f"{cls.__parse_identification(kwargs)}")
+        DependencyTracker.track(
+            cls.__name__, "exclude", f"{cls.__parse_identification(kwargs)}"
+        )
         return cls.Interface.exclude(**kwargs)
 
     @classmethod

{generalmanager-0.2.0 → generalmanager-0.3.0}/src/general_manager/rule/rule.py

@@ -81,7 +81,7 @@ class Rule(Generic[GeneralManagerType]):
             inst = cls()
             self._handlers[inst.function_name] = inst
         for path in getattr(settings, "RULE_HANDLERS", []):
-            handler_cls = import_string(path)
+            handler_cls: type[BaseRuleHandler] = import_string(path)
             inst = handler_cls()
             self._handlers[inst.function_name] = inst
 

generalmanager-0.3.0/tests/test_jsonEncoder.py

@@ -0,0 +1,49 @@
+from django.test import SimpleTestCase
+from datetime import datetime, date, time
+import json
+from unittest.mock import patch
+
+# Ensure the custom encoder module path is correct
+from general_manager.auxiliary import jsonEncoder
+
+
+class FakeGeneralManager:
+    def __init__(self, identification):
+        self.identification = identification
+
+
+class CustomJSONEncoderTests(SimpleTestCase):
+    def setUp(self):
+        self.encoder_cls = jsonEncoder.CustomJSONEncoder
+        self.FakeGeneralManager = FakeGeneralManager
+
+    def test_serialize_datetime_date_time(self):
+        dt = datetime(2021, 12, 31, 23, 59, 59)
+        d = date(2020, 1, 1)
+        t = time(8, 30)
+
+        self.assertEqual(json.dumps(dt, cls=self.encoder_cls), f'"{dt.isoformat()}"')
+        self.assertEqual(json.dumps(d, cls=self.encoder_cls), f'"{d.isoformat()}"')
+        self.assertEqual(json.dumps(t, cls=self.encoder_cls), f'"{t.isoformat()}"')
+
+    def test_serialize_nested_datetime_in_dict(self):
+        dt = datetime(2022, 5, 10, 14, 0)
+        data = {"timestamp": dt}
+        result = json.dumps(data, cls=self.encoder_cls)
+        self.assertIn('"timestamp": "2022-05-10T14:00:00"', result)
+
+    def test_serialize_general_manager(self):
+        with patch.object(jsonEncoder, "GeneralManager", FakeGeneralManager):
+            gm = self.FakeGeneralManager({"id": 123, "name": "Test"})
+            dumped = json.dumps(gm, cls=self.encoder_cls)
+            expected = f'"{gm.__class__.__name__}(**{gm.identification})"'
+            self.assertEqual(dumped, expected)
+
+    def test_fallback_to_str_on_unserializable(self):
+        class Unserializable:
+            def __str__(self):
+                return "custom_str"
+
+        obj = Unserializable()
+        dumped = json.dumps(obj, cls=self.encoder_cls)
+        self.assertEqual(dumped, '"custom_str"')

{generalmanager-0.2.0 → generalmanager-0.3.0}/tests/test_rule_handler.py

@@ -79,7 +79,7 @@ def test_len_handler_success(expr, op_symbol, var_values, expected):
     # DummyRule mit vorgegebener Op-Symbol-Antwort
     rule = DummyRule(op_symbol)
     result = len_handler.handle(
-        node, node.left, node.comparators[0], node.ops[0], var_values, rule
+        node, node.left, node.comparators[0], node.ops[0], var_values, rule  # type: ignore
     )
     assert result == expected
 
@@ -88,7 +88,7 @@ def test_non_compare_node_returns_empty():
     # z. B. ein Call-Knoten statt Compare
     node = ast.parse("print('hallo')", mode="eval").body
     rule = DummyRule(">")
-    assert len_handler.handle(node, None, None, None, {}, rule) == {}
+    assert len_handler.handle(node, None, None, None, {}, rule) == {}  # type: ignore
 
 
 @pytest.mark.parametrize(
@@ -104,11 +104,11 @@ def test_len_handler_invalid_raises(bad_expr, op):
     with pytest.raises(ValueError):
         len_handler.handle(
             node,
-            node.left,
+            node.left,  # type: ignore
             getattr(node, "comparators", [None])[0],
-            node.ops[0] if hasattr(node, "ops") else None,
+            node.ops[0] if hasattr(node, "ops") else None,  # type: ignore
             {"x": "hi"},
-            rule,
+            rule,  # type: ignore
         )
 
 
@@ -151,7 +151,7 @@ def test_sum_handler_success(expr, op_symbol, var_values, expected):
     node = ast.parse(expr, mode="eval").body
     rule = DummyRule(op_symbol)
     result = sum_handler.handle(
-        node, node.left, node.comparators[0], node.ops[0], var_values, rule
+        node, node.left, node.comparators[0], node.ops[0], var_values, rule  # type: ignore
     )
     assert result == expected
 
@@ -160,7 +160,7 @@ def test_sum_handler_success(expr, op_symbol, var_values, expected):
 def test_sum_handler_non_compare_returns_empty():
     node = ast.parse("print(1)", mode="eval").body
     rule = DummyRule(">")
-    assert sum_handler.handle(node, None, None, None, {}, rule) == {}
+    assert sum_handler.handle(node, None, None, None, {}, rule) == {}  # type: ignore
 
 
 @pytest.mark.parametrize(
@@ -177,11 +177,11 @@ def test_sum_handler_invalid(expr, var_values, error_msg):
     with pytest.raises(ValueError) as excinfo:
         sum_handler.handle(
             node,
-            node.left,
+            node.left,  # type: ignore
             getattr(node, "comparators", [None])[0],
-            node.ops[0],
+            node.ops[0],  # type: ignore
             var_values,
-            rule,
+            rule,  # type: ignore
         )
     assert error_msg in str(excinfo.value)
 
@@ -225,7 +225,7 @@ def test_max_handler_success(expr, op_symbol, var_values, expected):
     node = ast.parse(expr, mode="eval").body
     rule = DummyRule(op_symbol)
     result = max_handler.handle(
-        node, node.left, node.comparators[0], node.ops[0], var_values, rule
+        node, node.left, node.comparators[0], node.ops[0], var_values, rule  # type: ignore
     )
     assert result == expected
 
@@ -233,7 +233,7 @@ def test_max_handler_success(expr, op_symbol, var_values, expected):
 def test_max_handler_non_compare_returns_empty():
     node = ast.parse("42", mode="eval").body
     rule = DummyRule("<")
-    assert max_handler.handle(node, None, None, None, {}, rule) == {}
+    assert max_handler.handle(node, None, None, None, {}, rule) == {}  # type: ignore
 
 
 @pytest.mark.parametrize(
@@ -250,11 +250,11 @@ def test_max_handler_invalid(expr, var_values, error_msg):
     with pytest.raises(ValueError) as excinfo:
         max_handler.handle(
             node,
-            node.left,
+            node.left,  # type: ignore
             getattr(node, "comparators", [None])[0],
-            node.ops[0],
+            node.ops[0],  # type: ignore
             var_values,
-            rule,
+            rule,  # type: ignore
         )
     assert error_msg in str(excinfo.value)
 
@@ -298,7 +298,7 @@ def test_min_handler_success(expr, op_symbol, var_values, expected):
     node = ast.parse(expr, mode="eval").body
     rule = DummyRule(op_symbol)
     result = min_handler.handle(
-        node, node.left, node.comparators[0], node.ops[0], var_values, rule
+        node, node.left, node.comparators[0], node.ops[0], var_values, rule  # type: ignore
     )
     assert result == expected
 
@@ -306,7 +306,7 @@ def test_min_handler_success(expr, op_symbol, var_values, expected):
 def test_min_handler_non_compare_returns_empty():
     node = ast.parse("'foo'", mode="eval").body
     rule = DummyRule(">=")
-    assert min_handler.handle(node, None, None, None, {}, rule) == {}
+    assert min_handler.handle(node, None, None, None, {}, rule) == {}  # type: ignore
 
 
 @pytest.mark.parametrize(
@@ -323,11 +323,11 @@ def test_min_handler_invalid(expr, var_values, error_msg):
     with pytest.raises(ValueError) as excinfo:
         min_handler.handle(
             node,
-            node.left,
+            node.left,  # type: ignore
             getattr(node, "comparators", [None])[0],
-            node.ops[0],
+            node.ops[0],  # type: ignore
             var_values,
-            rule,
+            rule,  # type: ignore
         )
     assert error_msg in str(excinfo.value)
 
@@ -361,15 +361,15 @@ def test_mixed_numeric_types(expr, op_symbol, var_values, expected):
     # dispatch auf den richtigen Handler
     if expr.startswith("sum"):
         result = sum_handler.handle(
-            node, node.left, node.comparators[0], node.ops[0], var_values, rule
+            node, node.left, node.comparators[0], node.ops[0], var_values, rule  # type: ignore
         )
     elif expr.startswith("max"):
         result = max_handler.handle(
-            node, node.left, node.comparators[0], node.ops[0], var_values, rule
+            node, node.left, node.comparators[0], node.ops[0], var_values, rule  # type: ignore
         )
     else:
         result = min_handler.handle(
-            node, node.left, node.comparators[0], node.ops[0], var_values, rule
+            node, node.left, node.comparators[0], node.ops[0], var_values, rule  # type: ignore
         )
     assert result == expected
 
@@ -382,7 +382,7 @@ def test_sum_handler_large_collection():
     node = ast.parse(expr, mode="eval").body
     rule = DummyRule(">=")
     result = sum_handler.handle(
-        node, node.left, node.comparators[0], node.ops[0], {"large": large}, rule
+        node, node.left, node.comparators[0], node.ops[0], {"large": large}, rule  # type: ignore
     )
     assert result == {"large": f"[large] (sum={n}) is too small (>= {n})!"}
 
@@ -394,7 +394,7 @@ def test_max_handler_large_collection():
     node = ast.parse(expr, mode="eval").body
     rule = DummyRule("==")
     result = max_handler.handle(
-        node, node.left, node.comparators[0], node.ops[0], {"large": large}, rule
+        node, node.left, node.comparators[0], node.ops[0], {"large": large}, rule  # type: ignore
     )
     assert result == {"large": f"[large] (max={n-1}) must be {n-1}!"}
 
@@ -406,7 +406,7 @@ def test_min_handler_large_collection():
     node = ast.parse(expr, mode="eval").body
     rule = DummyRule("==")
     result = min_handler.handle(
-        node, node.left, node.comparators[0], node.ops[0], {"large": large}, rule
+        node, node.left, node.comparators[0], node.ops[0], {"large": large}, rule  # type: ignore
     )
     assert result == {"large": "[large] (min=0) must be 0!"}
 
@@ -426,9 +426,9 @@ def test_handler_none_value_raises(handler, expr, error_msg):
     with pytest.raises(ValueError) as excinfo:
         handler.handle(
             node,
-            node.left,
-            node.comparators[0],
-            node.ops[0],
+            node.left,  # type: ignore
+            node.comparators[0],  # type: ignore
+            node.ops[0],  # type: ignore
             {"x": None},
             rule,
         )

generalmanager-0.2.0/src/general_manager/cache/cacheDecorator.py

@@ -1,72 +0,0 @@
-from typing import Callable, Optional
-from functools import wraps
-from django.core.cache import cache as django_cache
-from hashlib import sha256
-from general_manager.cache.cacheTracker import DependencyTracker
-from general_manager.cache.dependencyIndex import record_dependencies, get_full_index
-
-
-def cached(timeout: Optional[int] = None) -> Callable:
-    """
-    Decorator to cache the result of a function for a specified timeout.
-    If no timeout is provided, the cache will expire when a dependency is invalidated.
-    """
-
-    def decorator(func: Callable) -> Callable:
-
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            from general_manager.manager.generalManager import GeneralManager, Bucket
-
-            django_cache_key = sha256(
-                f"{func.__module__}.{func.__name__}:{args}:{kwargs}".encode(),
-                usedforsecurity=False,
-            ).hexdigest()
-            cached_result = django_cache.get(django_cache_key)
-            if cached_result is not None:
-                return cached_result
-            # Dependency Tracking aktivieren
-            with DependencyTracker() as dependencies:
-                result = func(*args, **kwargs)
-
-            def collect_model_dependencies(obj):
-                """Rekursiv Django-Model-Instanzen im Objekt finden."""
-                if isinstance(obj, GeneralManager):
-                    yield (
-                        obj.__class__.__name__,
-                        "identification",
-                        f"{obj.identification}",
-                    )
-                elif isinstance(obj, Bucket):
-                    yield (obj._manager_class.__name__, "filter", f"{obj.filters}")
-                    yield (obj._manager_class.__name__, "exclude", f"{obj.excludes}")
-                elif isinstance(obj, dict):
-                    for v in obj.values():
-                        yield from collect_model_dependencies(v)
-                elif isinstance(obj, (list, tuple, set)):
-                    for item in obj:
-                        yield from collect_model_dependencies(item)
-
-            if args and isinstance(args[0], GeneralManager):
-                self = args[0]
-                for attr_val in self.__dict__.values():
-                    for dependency_tuple in collect_model_dependencies(attr_val):
-                        dependencies.add(dependency_tuple)
-
-            for dependency_tuple in collect_model_dependencies(args):
-                dependencies.add(dependency_tuple)
-            for dependency_tuple in collect_model_dependencies(kwargs):
-                dependencies.add(dependency_tuple)
-
-            django_cache.set(django_cache_key, result, timeout)
-
-            if dependencies and not timeout:
-                record_dependencies(
-                    django_cache_key,
-                    dependencies,
-                )
-            return result
-
-        return wrapper
-
-    return decorator

generalmanager-0.2.0/src/general_manager/cache/cacheTracker.py

@@ -1,33 +0,0 @@
-import threading
-from general_manager.cache.dependencyIndex import general_manager_name
-from typing import Any, Literal
-
-
-# Thread-lokale Variable zur Speicherung der Abhängigkeiten
-_dependency_storage = threading.local()
-
-
-class DependencyTracker:
-    def __enter__(
-        self,
-    ) -> set[
-        tuple[general_manager_name, Literal["filter", "exclude", "identification"], str]
-    ]:
-        _dependency_storage.dependencies = set()
-        return _dependency_storage.dependencies
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        # Optional: Aufräumen oder weitere Verarbeitung
-        pass
-
-
-def addDependency(class_name: str, operation: str, identifier: str) -> None:
-    """
-    Adds a dependency to the dependency storage.
-    """
-    if hasattr(_dependency_storage, "dependencies"):
-        dependencies: set[
-            tuple[general_manager_name, Literal["filter", "exclude", "id"], str]
-        ] = _dependency_storage.dependencies
-
-        _dependency_storage.dependencies.add((class_name, operation, identifier))