GeneralManager 0.1.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

general_manager/auxiliary/filterParser.py

@@ -1,9 +1,23 @@
-from typing import Any, Callable, List
+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, Any]
+    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 = {}
@@ -42,6 +56,18 @@ def parse_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",
@@ -71,26 +97,39 @@ def create_filter_function(lookup_str: str, value: Any) -> Callable[[Any], bool]
     return filter_func
 
 
-def apply_lookup(x: Any, lookup: str, value: Any) -> bool:
+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 x == value
+            return value_to_check == filter_value
         elif lookup == "lt":
-            return x < value
+            return value_to_check < filter_value
         elif lookup == "lte":
-            return x <= value
+            return value_to_check <= filter_value
         elif lookup == "gt":
-            return x > value
+            return value_to_check > filter_value
         elif lookup == "gte":
-            return x >= value
-        elif lookup == "contains" and isinstance(x, str):
-            return value in x
-        elif lookup == "startswith" and isinstance(x, str):
-            return x.startswith(value)
-        elif lookup == "endswith" and isinstance(x, str):
-            return x.endswith(value)
+            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 x in value
+            return value_to_check in filter_value
         else:
             return False
     except TypeError as e:

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)

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()

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

general_manager/cache/cacheDecorator.py

@@ -1,70 +1,43 @@
-from typing import Callable, Optional
+from typing import Any, Callable, Optional, Protocol, Set
 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
+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
 
 
-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.
-    """
+class CacheBackend(Protocol):
+    def get(self, key: str) -> Any: ...
+    def set(self, key: str, value: Any, timeout: Optional[int] = None) -> None: ...
 
-    def decorator(func: Callable) -> Callable:
 
+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):
-            from general_manager.manager.generalManager import GeneralManager, Bucket
+            key = make_cache_key(func, args, kwargs)
+
+            result = cache_backend.get(key)
+            if result is not None:
+                return result
 
-            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)
+                ModelDependencyCollector.addArgs(dependencies, 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)
+            cache_backend.set(key, result, timeout)
 
-            django_cache.set(django_cache_key, result, timeout)
+            if dependencies and timeout is None:
+                record_fn(key, dependencies)
 
-            if dependencies and not timeout:
-                record_dependencies(
-                    django_cache_key,
-                    dependencies,
-                )
             return result
 
         return wrapper

general_manager/cache/cacheTracker.py

@@ -1,7 +1,9 @@
 import threading
-from general_manager.cache.dependencyIndex import general_manager_name
-from typing import Any, Literal
-
+from general_manager.cache.dependencyIndex import (
+    general_manager_name,
+    Dependency,
+    filter_type,
+)
 
 # Thread-lokale Variable zur Speicherung der Abhängigkeiten
 _dependency_storage = threading.local()
@@ -10,24 +12,23 @@ _dependency_storage = threading.local()
 class DependencyTracker:
     def __enter__(
         self,
-    ) -> set[
-        tuple[general_manager_name, Literal["filter", "exclude", "identification"], str]
-    ]:
+    ) -> set[Dependency]:
         _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))
+        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))

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

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)

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),

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

general_manager/rule/handler.py

@@ -2,19 +2,19 @@
 
 from __future__ import annotations
 import ast
-from typing import Dict, Optional, TYPE_CHECKING, cast
+from typing import Dict, Optional, TYPE_CHECKING
+from abc import ABC, abstractmethod
 
 if TYPE_CHECKING:
-    # Forward-Reference auf Rule mit beliebigem Generic-Parameter
     from general_manager.rule.rule import Rule
-    from general_manager.manager import GeneralManager
 
 
-class BaseRuleHandler:
+class BaseRuleHandler(ABC):
     """Schnittstelle für Rule-Handler."""
 
     function_name: str  # ClassVar, der Name, unter dem dieser Handler registriert wird
 
+    @abstractmethod
     def handle(
         self,
         node: ast.AST,
@@ -27,11 +27,13 @@ class BaseRuleHandler:
         """
         Erstelle Fehlermeldungen für den Vergleichs- oder Funktionsaufruf.
         """
-        raise NotImplementedError
+        pass
 
 
-class LenHandler(BaseRuleHandler):
-    function_name = "len"
+class FunctionHandler(BaseRuleHandler, ABC):
+    """
+    Handler für Funktionsaufrufe wie len(), max(), min(), sum().
+    """
 
     def handle(
         self,
@@ -42,7 +44,6 @@ class LenHandler(BaseRuleHandler):
         var_values: Dict[str, Optional[object]],
         rule: Rule,
     ) -> Dict[str, str]:
-        # Wir erwarten hier einen Compare-Knoten
         if not isinstance(node, ast.Compare):
             return {}
         compare_node = node
@@ -51,11 +52,45 @@ class LenHandler(BaseRuleHandler):
         right_node = compare_node.comparators[0]
         op_symbol = rule._get_op_symbol(op)
 
-        # Argument von len(...)
         if not (isinstance(left_node, ast.Call) and left_node.args):
-            raise ValueError("Invalid left node for len function")
+            raise ValueError(f"Invalid left node for {self.function_name}() function")
         arg_node = left_node.args[0]
 
+        return self.aggregate(
+            arg_node,
+            right_node,
+            op_symbol,
+            var_values,
+            rule,
+        )
+
+    @abstractmethod
+    def aggregate(
+        self,
+        arg_node: ast.expr,
+        right_node: ast.expr,
+        op_symbol: str,
+        var_values: Dict[str, Optional[object]],
+        rule: Rule,
+    ) -> Dict[str, str]:
+        """
+        Aggregiere die Werte und erstelle eine Fehlermeldung.
+        """
+        raise NotImplementedError("Subclasses should implement this method")
+
+
+class LenHandler(FunctionHandler):
+    function_name = "len"
+
+    def aggregate(
+        self,
+        arg_node: ast.expr,
+        right_node: ast.expr,
+        op_symbol: str,
+        var_values: Dict[str, Optional[object]],
+        rule: Rule,
+    ) -> Dict[str, str]:
+
         var_name = rule._get_node_name(arg_node)
         var_value = var_values.get(var_name)
 
@@ -65,7 +100,6 @@ class LenHandler(BaseRuleHandler):
             raise ValueError("Invalid arguments for len function")
         right_value: int | float = raw
 
-        # Schwellenwert je nach Operator
         if op_symbol == ">":
             threshold = right_value + 1
         elif op_symbol == ">=":
@@ -83,40 +117,118 @@ class LenHandler(BaseRuleHandler):
         elif op_symbol in ("<", "<="):
             msg = f"[{var_name}] ({var_value}) is too long (max length {threshold})!"
         else:
-            msg = f"[{var_name}] ({var_value}) must be {op_symbol} {right_value}!"
+            msg = f"[{var_name}] ({var_value}) must have a length of {right_value}!"
 
         return {var_name: msg}
 
 
-class IntersectionCheckHandler(BaseRuleHandler):
-    function_name = "intersectionCheck"
+class SumHandler(FunctionHandler):
+    function_name = "sum"
 
-    def handle(
+    def aggregate(
         self,
-        node: ast.AST,
-        left: Optional[ast.expr],
-        right: Optional[ast.expr],
-        op: Optional[ast.cmpop],
+        arg_node: ast.expr,
+        right_node: ast.expr,
+        op_symbol: str,
         var_values: Dict[str, Optional[object]],
-        rule: Rule[GeneralManager],
+        rule: Rule,
     ) -> Dict[str, str]:
-        # Der Aufruf steht in `left`, nicht in `node`
-        call_node = cast(ast.Call, left)
-        if not isinstance(call_node, ast.Call):
-            return {"error": "Invalid arguments for intersectionCheck"}
-
-        args = call_node.args
-        if len(args) < 2:
-            return {"error": "Invalid arguments for intersectionCheck"}
-
-        start_node, end_node = args[0], args[1]
-        start_name = rule._get_node_name(start_node)
-        end_name = rule._get_node_name(end_node)
-        start_val = var_values.get(start_name)
-        end_val = var_values.get(end_name)
-
-        msg = (
-            f"[{start_name}] ({start_val}) and "
-            f"[{end_name}] ({end_val}) must not overlap with existing ranges."
-        )
-        return {start_name: msg, end_name: msg}
+
+        # Name und Wert holen
+        var_name = rule._get_node_name(arg_node)
+        raw_iter = var_values.get(var_name)
+        if not isinstance(raw_iter, (list, tuple)):
+            raise ValueError("sum expects an iterable of numbers")
+        if not all(isinstance(x, (int, float)) for x in raw_iter):
+            raise ValueError("sum expects an iterable of numbers")
+        total = sum(raw_iter)
+
+        # Schwellenwert aus dem rechten Knoten
+        raw = rule._eval_node(right_node)
+        if not isinstance(raw, (int, float)):
+            raise ValueError("Invalid arguments for sum function")
+        right_value = raw
+
+        # Message formulieren
+        if op_symbol in (">", ">="):
+            msg = (
+                f"[{var_name}] (sum={total}) is too small ({op_symbol} {right_value})!"
+            )
+        elif op_symbol in ("<", "<="):
+            msg = (
+                f"[{var_name}] (sum={total}) is too large ({op_symbol} {right_value})!"
+            )
+        else:
+            msg = f"[{var_name}] (sum={total}) must be {right_value}!"
+
+        return {var_name: msg}
+
+
+class MaxHandler(FunctionHandler):
+    function_name = "max"
+
+    def aggregate(
+        self,
+        arg_node: ast.expr,
+        right_node: ast.expr,
+        op_symbol: str,
+        var_values: Dict[str, Optional[object]],
+        rule: Rule,
+    ) -> Dict[str, str]:
+
+        var_name = rule._get_node_name(arg_node)
+        raw_iter = var_values.get(var_name)
+        if not isinstance(raw_iter, (list, tuple)) or len(raw_iter) == 0:
+            raise ValueError("max expects a non-empty iterable")
+        if not all(isinstance(x, (int, float)) for x in raw_iter):
+            raise ValueError("max expects an iterable of numbers")
+        current = max(raw_iter)
+
+        raw = rule._eval_node(right_node)
+        if not isinstance(raw, (int, float)):
+            raise ValueError("Invalid arguments for max function")
+        right_value = raw
+
+        if op_symbol in (">", ">="):
+            msg = f"[{var_name}] (max={current}) is too small ({op_symbol} {right_value})!"
+        elif op_symbol in ("<", "<="):
+            msg = f"[{var_name}] (max={current}) is too large ({op_symbol} {right_value})!"
+        else:
+            msg = f"[{var_name}] (max={current}) must be {right_value}!"
+
+        return {var_name: msg}
+
+
+class MinHandler(FunctionHandler):
+    function_name = "min"
+
+    def aggregate(
+        self,
+        arg_node: ast.expr,
+        right_node: ast.expr,
+        op_symbol: str,
+        var_values: Dict[str, Optional[object]],
+        rule: Rule,
+    ) -> Dict[str, str]:
+
+        var_name = rule._get_node_name(arg_node)
+        raw_iter = var_values.get(var_name)
+        if not isinstance(raw_iter, (list, tuple)) or len(raw_iter) == 0:
+            raise ValueError("min expects a non-empty iterable")
+        if not all(isinstance(x, (int, float)) for x in raw_iter):
+            raise ValueError("min expects an iterable of numbers")
+        current = min(raw_iter)
+
+        raw = rule._eval_node(right_node)
+        if not isinstance(raw, (int, float)):
+            raise ValueError("Invalid arguments for min function")
+        right_value = raw
+
+        if op_symbol in (">", ">="):
+            msg = f"[{var_name}] (min={current}) is too small ({op_symbol} {right_value})!"
+        elif op_symbol in ("<", "<="):
+            msg = f"[{var_name}] (min={current}) is too large ({op_symbol} {right_value})!"
+        else:
+            msg = f"[{var_name}] (min={current}) must be {right_value}!"
+
+        return {var_name: msg}

general_manager/rule/rule.py

@@ -22,7 +22,9 @@ from django.utils.module_loading import import_string
 from general_manager.rule.handler import (
     BaseRuleHandler,
     LenHandler,
-    IntersectionCheckHandler,
+    MaxHandler,
+    MinHandler,
+    SumHandler,
 )
 from general_manager.manager.generalManager import GeneralManager
 
@@ -75,11 +77,11 @@ class Rule(Generic[GeneralManagerType]):
 
         # 4) Handler registrieren
         self._handlers = {}  # type: Dict[str, BaseRuleHandler]
-        for cls in (LenHandler, IntersectionCheckHandler):
+        for cls in (LenHandler, MaxHandler, MinHandler, SumHandler):
             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.1.2.dist-info → generalmanager-0.3.0.dist-info}/METADATA

@@ -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.dist-info → generalmanager-0.3.0.dist-info}/RECORD

@@ -5,11 +5,14 @@ general_manager/api/mutation.py,sha256=uu5RVxc9wbb-Zrbtt4azegvyKymMqEsxk_CkerKCd
 general_manager/api/property.py,sha256=oc93p1P8dcIvrNorRuqD1EJVsd6eYttYhZuAS0s28gs,696
 general_manager/auxiliary/__init__.py,sha256=4IwKJzsNxGduF-Ej0u1BNHVaMhkql8PjHbVtx9DOTSY,76
 general_manager/auxiliary/argsToKwargs.py,sha256=kmp1xonpQp4X_y8ZJG6c5uOW7zQwo0HtPqsHWVzXRSM,921
-general_manager/auxiliary/filterParser.py,sha256=exmRGVwvdMPgN-65MLwAV2q6L23bI4gTWb6lWXO4ZuU,3108
-general_manager/auxiliary/noneToZero.py,sha256=ovopSddMlTw84GIFWRd5s91_CFahPyL-t974w78Jb7g,300
-general_manager/cache/cacheDecorator.py,sha256=RmUDyJfkouO2-R2KZZJF1n8RCB0FjVa2OoTeLQ0vUyg,2934
-general_manager/cache/cacheTracker.py,sha256=vUQCarqABIW_O02hbKeRo0thurmPD0TfrOlIUh7kneI,1045
-general_manager/cache/dependencyIndex.py,sha256=KUDroajKrWfJv0PO2EQVNTrYq7XxrpBT4MGKBgPwMwo,10676
+general_manager/auxiliary/filterParser.py,sha256=wmR4YzsnYgjI2Co5eyvCFROldotAraHx_GiCDJo79IY,5410
+general_manager/auxiliary/jsonEncoder.py,sha256=TDsgFQvheITHZgdmn-m8tk1_QCzpT0XwEHo7bY3Qe-M,638
+general_manager/auxiliary/makeCacheKey.py,sha256=o2ZPe5ZjiZhHxYgSESBSMnOmQutkTxw5DLeJM7tOw84,881
+general_manager/auxiliary/noneToZero.py,sha256=KfQtMQnrT6vsYST0K7lv6pVujkDcK3XL8czHYOhgqKQ,539
+general_manager/cache/cacheDecorator.py,sha256=7DbPMw-2Xm1-5eCMVWyjUl_jdVtTJUKNpLW2WNJEhI0,1471
+general_manager/cache/cacheTracker.py,sha256=RmUWwAXMS5LQT8-w7IiG67FTBSxF1V0w4IDH1WzgmuM,998
+general_manager/cache/dependencyIndex.py,sha256=iuOjthmH5ehHCkWiM9iLbgzGlo4Cf2wRKkm-QhIQ024,10813
+general_manager/cache/modelDependencyCollector.py,sha256=Lt8mNpnp-AJaPCYrTu_UB1m_Hj1prfEXaPrxRwk3Qqs,1983
 general_manager/cache/pathMapping.py,sha256=WtECIek9fI-2_nqIYI4Ux9Lan6g8P9TMO_AfthkznX8,5656
 general_manager/cache/signals.py,sha256=ZHeXKFMN7tj9t0J-vSqf_05_NhGqEF2sZtbZO3vaRqI,1234
 general_manager/factory/__init__.py,sha256=DLSQbpSBpujPtDSZcruPc43OLWzKCCtf20gbalCDYRU,91
@@ -18,9 +21,9 @@ general_manager/factory/lazy_methods.py,sha256=UJC50a4Gbe4T5IQPh7ucyQqpaS2x4zhQz
 general_manager/interface/__init__.py,sha256=6x5adQLefTugvrJeyPcAxstyqgLAYeaJ1EPdAbac9pE,213
 general_manager/interface/baseInterface.py,sha256=mvSKUlA-0fazNnaIXGBwkiZxmX8DM_sOn-SaAIpaW8I,10273
 general_manager/interface/calculationInterface.py,sha256=GzSNXjU6Z7bFz60gHyMKkI5xNUDIPuniV8wbyVtQT50,14250
-general_manager/interface/databaseInterface.py,sha256=VR3V8WTE6XEeM84bv09h2__XMnTWp92u8CA8WRlevWc,27377
+general_manager/interface/databaseInterface.py,sha256=i3Z-rkHnoGzV8cFZjBKBmIjlWjGJ2CzdlsiQfL2JUas,28288
 general_manager/manager/__init__.py,sha256=l3RYp62aEhj3Y975_XUTIzo35LUnkTJHkb_hgChnXXI,111
-general_manager/manager/generalManager.py,sha256=xt7tvwTaPGhh7Z8VhbdMJuScsl78B9QDVQoMWv4amuo,5158
+general_manager/manager/generalManager.py,sha256=md-3zVCOMa-vC8ToCOEMKXeDuV7JtHLlSStQXh4cgBE,5258
 general_manager/manager/groupManager.py,sha256=O4FABqbm7KlZw6t36Ot3HU1FsBYN0h6Zhmk7ktN8a-Y,10087
 general_manager/manager/input.py,sha256=iKawV3P1QICz-0AQUF00OvH7LZYxussg3svpvCUl8hE,2977
 general_manager/manager/meta.py,sha256=5wHrCVnua5c38vpVZSCesrNvgydQDH8h6pxW6_QgCDg,3107
@@ -34,10 +37,10 @@ general_manager/permission/managerBasedPermission.py,sha256=VgZJVgkXWdaLk6K7c0kY
 general_manager/permission/permissionChecks.py,sha256=T-9khBqiwM4ASBdey9p07sC_xgzceIU9EAE0reukguM,1655
 general_manager/permission/permissionDataManager.py,sha256=Ji7fsnuaKTa6M8yzCGyzrIHyGa_ZvqJM7sXR97-uTrA,1937
 general_manager/rule/__init__.py,sha256=4Har5cfPD1fmOsilTDod-ZUz3Com-tkl58jz7yY4fD0,23
-general_manager/rule/handler.py,sha256=O3BZbTnUE9o3LTSWpoq6hgm3tKy1sEBjRcDrRaA54Gw,3936
-general_manager/rule/rule.py,sha256=tu3pNe_avs6ayI16KYeaQX85o2lXcPip_LN9CJEhr8Y,10708
-generalmanager-0.1.2.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.1.2.dist-info/METADATA,sha256=gfnRxKVbWKkOoCdnaR4cTvT7kXEaW6c5_kFTTEkFqVU,8188
-generalmanager-0.1.2.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-generalmanager-0.1.2.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.1.2.dist-info/RECORD,,
+general_manager/rule/handler.py,sha256=z8SFHTIZ0LbLh3fV56Mud0V4_OvWkqJjlHvFqau7Qfk,7334
+general_manager/rule/rule.py,sha256=3FVCKGL7BTVoStdgOTdWQwuoVRIxAIAilV4VOzouDpc,10759
+generalmanager-0.3.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.3.0.dist-info/METADATA,sha256=sKfEf7wuzdUhszsnlCJ49iydcFKidlwV58863yosGlw,8188
+generalmanager-0.3.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+generalmanager-0.3.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.3.0.dist-info/RECORD,,

{generalmanager-0.1.2.dist-info → generalmanager-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any