GeneralManager 0.1.2__tar.gz → 0.3.0__tar.gz

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

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

{generalmanager-0.1.2 → 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
@@ -46,11 +49,14 @@ src/general_manager/rule/handler.py
 src/general_manager/rule/rule.py
 tests/test_argsToKwargs.py
 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
 tests/test_noneToZero.py
+tests/test_rule_handler.py
 tests/test_rules.py
 tests/test_settings.py

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

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

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

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

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

@@ -0,0 +1,136 @@
+from __future__ import annotations
+from typing import Any, Callable
+from general_manager.manager.input import Input
+
+
+def parse_filters(
+    filter_kwargs: dict[str, Any], possible_values: dict[str, Input]
+) -> dict[str, dict]:
+    """
+    Parses filter keyword arguments and constructs filter criteria for input fields.
+    
+    For each filter key-value pair, determines the target field and lookup type, validates the field, and generates either filter keyword arguments or filter functions depending on the field's type. Returns a dictionary mapping field names to filter criteria, supporting both direct lookups and dynamic filter functions.
+    
+    Args:
+        filter_kwargs: Dictionary of filter keys and their corresponding values.
+        possible_values: Mapping of field names to Input definitions used for validation and casting.
+    
+    Returns:
+        A dictionary where each key is a field name and each value is a dictionary containing either 'filter_kwargs' for direct lookups or 'filter_funcs' for dynamic filtering.
+    """
+    from general_manager.manager.generalManager import GeneralManager
+
+    filters = {}
+    for kwarg, value in filter_kwargs.items():
+        parts = kwarg.split("__")
+        field_name = parts[0]
+        if field_name not in possible_values:
+            raise ValueError(f"Unknown input field '{field_name}' in filter")
+        input_field = possible_values[field_name]
+
+        lookup = "__".join(parts[1:]) if len(parts) > 1 else ""
+
+        if issubclass(input_field.type, GeneralManager):
+            # Sammle die Filter-Keyword-Argumente für das InputField
+            if lookup == "":
+                lookup = "id"
+                if not isinstance(value, GeneralManager):
+                    value = input_field.cast(value)
+                value = getattr(value, "id", value)
+            filters.setdefault(field_name, {}).setdefault("filter_kwargs", {})[
+                lookup
+            ] = value
+        else:
+            # Erstelle Filterfunktionen für Nicht-Bucket-Typen
+            if isinstance(value, (list, tuple)) and not isinstance(
+                value, input_field.type
+            ):
+                casted_value = [input_field.cast(v) for v in value]
+            else:
+                casted_value = input_field.cast(value)
+            filter_func = create_filter_function(lookup, casted_value)
+            filters.setdefault(field_name, {}).setdefault("filter_funcs", []).append(
+                filter_func
+            )
+    return filters
+
+
+def create_filter_function(lookup_str: str, value: Any) -> Callable[[Any], bool]:
+    """
+    Creates a filter function based on an attribute path and lookup operation.
+    
+    The returned function checks whether an object's nested attribute(s) satisfy a specified comparison or matching operation against a given value.
+    
+    Args:
+        lookup_str: Attribute path and lookup operation, separated by double underscores (e.g., "age__gte", "name__contains").
+        value: The value to compare against.
+    
+    Returns:
+        A function that takes an object and returns True if the object's attribute(s) match the filter condition, otherwise False.
+    """
+    parts = lookup_str.split("__") if lookup_str else []
+    if parts and parts[-1] in [
+        "exact",
+        "lt",
+        "lte",
+        "gt",
+        "gte",
+        "contains",
+        "startswith",
+        "endswith",
+        "in",
+    ]:
+        lookup = parts[-1]
+        attr_path = parts[:-1]
+    else:
+        lookup = "exact"
+        attr_path = parts
+
+    def filter_func(x):
+        for attr in attr_path:
+            if hasattr(x, attr):
+                x = getattr(x, attr)
+            else:
+                return False
+        return apply_lookup(x, lookup, value)
+
+    return filter_func
+
+
+def apply_lookup(value_to_check: Any, lookup: str, filter_value: Any) -> bool:
+    """
+    Evaluates whether a value satisfies a specified lookup condition against a filter value.
+    
+    Supports comparison and string operations such as "exact", "lt", "lte", "gt", "gte", "contains", "startswith", "endswith", and "in". Returns False for unsupported lookups or if a TypeError occurs.
+    
+    Args:
+        value_to_check: The value to be compared or checked.
+        lookup: The lookup operation to perform.
+        filter_value: The value to compare against.
+    
+    Returns:
+        True if the lookup condition is satisfied; otherwise, False.
+    """
+    try:
+        if lookup == "exact":
+            return value_to_check == filter_value
+        elif lookup == "lt":
+            return value_to_check < filter_value
+        elif lookup == "lte":
+            return value_to_check <= filter_value
+        elif lookup == "gt":
+            return value_to_check > filter_value
+        elif lookup == "gte":
+            return value_to_check >= filter_value
+        elif lookup == "contains" and isinstance(value_to_check, str):
+            return filter_value in value_to_check
+        elif lookup == "startswith" and isinstance(value_to_check, str):
+            return value_to_check.startswith(filter_value)
+        elif lookup == "endswith" and isinstance(value_to_check, str):
+            return value_to_check.endswith(filter_value)
+        elif lookup == "in":
+            return value_to_check in filter_value
+        else:
+            return False
+    except TypeError as e:
+        return False

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.1.2 → generalmanager-0.3.0}/src/general_manager/auxiliary/noneToZero.py

@@ -7,6 +7,15 @@ NUMBERVALUE = TypeVar("NUMBERVALUE", int, float, Measurement)
 def noneToZero(
     value: Optional[NUMBERVALUE],
 ) -> NUMBERVALUE | Literal[0]:
+    """
+    Returns zero if the input is None; otherwise, returns the original value.
+    
+    Args:
+        value: An integer, float, or Measurement, or None.
+    
+    Returns:
+        The original value if not None, otherwise 0.
+    """
     if value is None:
         return 0
     return value

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.1.2 → 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.1.2 → generalmanager-0.3.0}/src/general_manager/interface/databaseInterface.py

@@ -645,6 +645,15 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
     def __mergeFilterDefinitions(
         self, basis: dict[str, list[Any]], **kwargs: Any
     ) -> dict[str, list[Any]]:
+        """
+        Merges filter definitions by combining existing filter criteria with additional keyword arguments.
+        
+        Args:
+            basis: A dictionary mapping filter keys to lists of values.
+        
+        Returns:
+            A dictionary where each key maps to a list of all values from both the original basis and the new keyword arguments.
+        """
         kwarg_filter: dict[str, list[Any]] = {}
         for key, value in basis.items():
             kwarg_filter[key] = value
@@ -655,6 +664,11 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         return kwarg_filter
 
     def filter(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
+        """
+        Returns a new bucket containing manager instances matching the given filter criteria.
+        
+        Additional filter keyword arguments are merged with existing filters to refine the queryset.
+        """
         merged_filter = self.__mergeFilterDefinitions(self.filters, **kwargs)
         return self.__class__(
             self._data.filter(**kwargs),
@@ -664,6 +678,15 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         )
 
     def exclude(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
+        """
+        Returns a new bucket excluding items matching the given filter criteria.
+        
+        Args:
+            **kwargs: Field lookups to exclude from the queryset.
+        
+        Returns:
+            A DatabaseBucket containing items not matching the specified filters.
+        """
         merged_exclude = self.__mergeFilterDefinitions(self.excludes, **kwargs)
         return self.__class__(
             self._data.exclude(**kwargs),

{generalmanager-0.1.2 → 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