GeneralManager 0.2.0__tar.gz → 0.3.1__tar.gz

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

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

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

@@ -14,11 +14,14 @@ 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/auxiliary/pathMapping.py
 src/general_manager/cache/cacheDecorator.py
 src/general_manager/cache/cacheTracker.py
 src/general_manager/cache/dependencyIndex.py
-src/general_manager/cache/pathMapping.py
+src/general_manager/cache/modelDependencyCollector.py
 src/general_manager/cache/signals.py
 src/general_manager/factory/__init__.py
 src/general_manager/factory/factories.py
@@ -46,12 +49,17 @@ src/general_manager/rule/handler.py
 src/general_manager/rule/rule.py
 tests/test_argsToKwargs.py
 tests/test_basePermission.py
+tests/test_cacheDecorator.py
+tests/test_cacheTracker.py
 tests/test_filterParser.py
 tests/test_graph_ql.py
 tests/test_input.py
+tests/test_jsonEncoder.py
+tests/test_makeCacheKey.py
 tests/test_managerBasedPermission.py
 tests/test_measurement.py
 tests/test_measurement_field.py
+tests/test_modelDependencyCollector.py
 tests/test_noneToZero.py
 tests/test_rule_handler.py
 tests/test_rules.py

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

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

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

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

generalmanager-0.3.1/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.1/src/general_manager/auxiliary/makeCacheKey.py

@@ -0,0 +1,33 @@
+import inspect
+import json
+from general_manager.auxiliary.jsonEncoder import CustomJSONEncoder
+from hashlib import sha256
+
+
+def make_cache_key(func, args, kwargs):
+    """
+    Generates a unique, deterministic cache key for a specific function call.
+    
+    The key is derived from the function's module, qualified name, and bound arguments,
+    serialized to JSON and hashed with SHA-256 to ensure uniqueness for each call signature.
+    
+    Args:
+        func: The target function to be identified.
+        args: Positional arguments for the function call.
+        kwargs: Keyword arguments for the function call.
+    
+    Returns:
+        A hexadecimal SHA-256 hash string uniquely representing the function call.
+    """
+    sig = inspect.signature(func)
+    bound = sig.bind_partial(*args, **kwargs)
+    bound.apply_defaults()
+    payload = {
+        "module": func.__module__,
+        "qualname": func.__qualname__,
+        "args": bound.arguments,
+    }
+    raw = json.dumps(
+        payload, sort_keys=True, default=str, cls=CustomJSONEncoder
+    ).encode()
+    return sha256(raw, usedforsecurity=False).hexdigest()

{generalmanager-0.2.0/src/general_manager/cache → generalmanager-0.3.1/src/general_manager/auxiliary}/pathMapping.py

@@ -3,9 +3,8 @@ 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
+from general_manager.interface.baseInterface import Bucket
+from general_manager.manager.generalManager import GeneralManager
 
 
 type PathStart = str
@@ -25,6 +24,11 @@ class PathMap:
 
     @classmethod
     def createPathMapping(cls):
+        """
+        Builds the mapping of paths between all pairs of distinct managed classes.
+        
+        Iterates over all registered managed classes and creates a PathTracer for each unique start and destination class pair, storing them in the mapping dictionary.
+        """
         all_managed_classes = GeneralManagerMeta.all_classes
         for start_class in all_managed_classes:
             for destination_class in all_managed_classes:
@@ -34,8 +38,12 @@ class PathMap:
                     ] = PathTracer(start_class, destination_class)
 
     def __init__(self, path_start: PathStart | GeneralManager | type[GeneralManager]):
-        from general_manager.manager.generalManager import GeneralManager
 
+        """
+        Initializes a PathMap with a specified starting point.
+        
+        The starting point can be a class name (string), a GeneralManager instance, or a GeneralManager subclass. Sets internal attributes for the start instance, class, and class name based on the input.
+        """
         if isinstance(path_start, GeneralManager):
             self.start_instance = path_start
             self.start_class = path_start.__class__
@@ -99,8 +107,17 @@ class PathTracer:
     def createPath(
         self, current_manager: type[GeneralManager], path: list[str]
     ) -> list[str] | None:
-        from general_manager.manager.generalManager import GeneralManager
 
+        """
+        Recursively constructs a path of attribute names from the current manager class to the destination class.
+        
+        Args:
+            current_manager: The current GeneralManager subclass being inspected.
+            path: The list of attribute names traversed so far.
+        
+        Returns:
+            A list of attribute names representing the path to the destination class, or None if no path exists.
+        """
         current_connections = {
             attr_name: attr_value["type"]
             for attr_name, attr_value in current_manager.Interface.getAttributeTypes().items()
@@ -131,8 +148,16 @@ class PathTracer:
     def traversePath(
         self, start_instance: GeneralManager | Bucket
     ) -> GeneralManager | Bucket | None:
-        from general_manager.interface.baseInterface import Bucket
 
+        """
+        Traverses the stored path from a starting instance to reach the destination instance or bucket.
+        
+        Args:
+            start_instance: The initial GeneralManager or Bucket instance from which to begin traversal.
+        
+        Returns:
+            The resulting GeneralManager or Bucket instance at the end of the path, or None if the path is empty.
+        """
         current_instance = start_instance
         if not self.path:
             return None

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

@@ -0,0 +1,81 @@
+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, default: Optional[Any] = None) -> Any:
+        """
+        Retrieves a value from the cache by key, returning a default if the key is not found.
+
+        Args:
+            key: The cache key to look up.
+            default: Value to return if the key is not present in the cache.
+
+        Returns:
+            The cached value if found; otherwise, the provided default.
+        """
+        ...
+
+    def set(self, key: str, value: Any, timeout: Optional[int] = None) -> None:
+        """
+        Stores a value in the cache under the specified key with an optional expiration timeout.
+
+        Args:
+            key: The cache key to associate with the value.
+            value: The value to store in the cache.
+            timeout: Optional expiration time in seconds. If None, the value is cached indefinitely.
+        """
+        ...
+
+
+RecordFn = Callable[[str, Set[Dependency]], None]
+
+_SENTINEL = object()
+
+
+def cached(
+    timeout: Optional[int] = None,
+    cache_backend: CacheBackend = django_cache,
+    record_fn: RecordFn = record_dependencies,
+) -> Callable:
+    """
+    Decorator that caches function results and tracks their dependencies.
+
+    When applied to a function, this decorator caches the function's output using a generated cache key based on its arguments. It also tracks dependencies accessed during the function's execution and stores them alongside the cached result. On cache hits, previously stored dependencies are re-tracked to maintain dependency tracking continuity. If dependencies exist and no timeout is set, an external recording function is invoked to persist the dependency information.
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            key = make_cache_key(func, args, kwargs)
+            deps_key = f"{key}:deps"
+
+            cached_result = cache_backend.get(key, _SENTINEL)
+            if cached_result is not _SENTINEL:
+                # saved dependencies are added to the current tracker
+                cached_deps = cache_backend.get(deps_key)
+                if cached_deps:
+                    for class_name, operation, identifier in cached_deps:
+                        DependencyTracker.track(class_name, operation, identifier)
+                return cached_result
+
+            with DependencyTracker() as dependencies:
+                result = func(*args, **kwargs)
+                ModelDependencyCollector.addArgs(dependencies, args, kwargs)
+
+                cache_backend.set(key, result, timeout)
+                cache_backend.set(deps_key, dependencies, timeout)
+
+                if dependencies and timeout is None:
+                    record_fn(key, dependencies)
+
+            return result
+
+        return wrapper
+
+    return decorator

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

@@ -0,0 +1,74 @@
+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]:
+        """
+        Enters a new dependency tracking context and returns the set for collecting dependencies.
+
+        Initializes thread-local storage for dependency tracking if not already present, supports nested contexts, and provides a set to accumulate dependencies at the current nesting level.
+
+        Returns:
+            The set used to collect dependencies for the current context level.
+        """
+        if not hasattr(_dependency_storage, "dependencies"):
+            _dependency_storage._depth = 0
+            _dependency_storage.dependencies = list()
+        else:
+            _dependency_storage._depth += 1
+        _dependency_storage.dependencies.append(set())
+        return _dependency_storage.dependencies[_dependency_storage._depth]
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """
+        Exits the dependency tracking context, managing cleanup for nested scopes.
+
+        If exiting the outermost context, removes all dependency tracking data from thread-local storage. Otherwise, decrements the nesting depth and removes the most recent dependency set.
+        """
+        if hasattr(_dependency_storage, "dependencies"):
+            if _dependency_storage._depth == 0:
+                self.reset_thread_local_storage()
+
+            else:
+                # Ansonsten reduzieren wir nur die Tiefe
+                _dependency_storage._depth -= 1
+                _dependency_storage.dependencies.pop()
+
+    @staticmethod
+    def track(
+        class_name: general_manager_name,
+        operation: filter_type,
+        identifier: str,
+    ) -> None:
+        """
+        Records a dependency in all active dependency tracking contexts.
+
+        Adds the specified dependency tuple to each set in the current stack of dependency tracking scopes, ensuring it is tracked at all nested levels.
+        """
+        if hasattr(_dependency_storage, "dependencies"):
+            for dep_set in _dependency_storage.dependencies[
+                : _dependency_storage._depth + 1
+            ]:
+                dep_set: set[Dependency]
+                dep_set.add((class_name, operation, identifier))
+
+    @staticmethod
+    def reset_thread_local_storage() -> None:
+        """
+        Resets the thread-local storage for dependency tracking.
+
+        This method clears the thread-local storage, ensuring that all dependency tracking data is removed. It is useful for cleaning up after operations that may have modified the state of the tracker.
+        """
+        if hasattr(_dependency_storage, "dependencies"):
+            del _dependency_storage.dependencies
+            del _dependency_storage._depth

{generalmanager-0.2.0 → generalmanager-0.3.1}/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.1/src/general_manager/cache/modelDependencyCollector.py

@@ -0,0 +1,59 @@
+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:
+
+    @staticmethod
+    def collect(obj) -> Generator[tuple[general_manager_name, filter_type, str]]:
+        """
+        Recursively yields dependency information from objects related to Django models.
+        
+        Traverses the input object and its nested structures to identify instances of
+        GeneralManager and Bucket, yielding tuples that describe their dependencies.
+        Yields a tuple of (manager class name, dependency type, dependency value) for
+        each dependency found.
+        
+        Args:
+            obj: The object or collection to inspect for model dependencies.
+        
+        Yields:
+            Tuples containing the manager class name, dependency type ("identification",
+            "filter", or "exclude"), and the string representation of the dependency value.
+        """
+        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.1}/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.1}/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