GeneralManager 0.1.2__py3-none-any.whl → 0.2.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/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/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/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,7 +77,7 @@ 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", []):

{generalmanager-0.1.2.dist-info → generalmanager-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.1.2
+Version: 0.2.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.2.0.dist-info}/RECORD

@@ -5,8 +5,8 @@ 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/auxiliary/filterParser.py,sha256=wmR4YzsnYgjI2Co5eyvCFROldotAraHx_GiCDJo79IY,5410
+general_manager/auxiliary/noneToZero.py,sha256=KfQtMQnrT6vsYST0K7lv6pVujkDcK3XL8czHYOhgqKQ,539
 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
@@ -18,7 +18,7 @@ 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/groupManager.py,sha256=O4FABqbm7KlZw6t36Ot3HU1FsBYN0h6Zhmk7ktN8a-Y,10087
@@ -34,10 +34,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=jmZxMFxthMPcc85Xx_zb8l7hajJK2SFAIgBZpE8bk8g,10736
+generalmanager-0.2.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.2.0.dist-info/METADATA,sha256=RIR7LsPxNSSbPErDku5Vv-YdlFb2BYD9QjXowcEOais,8188
+generalmanager-0.2.0.dist-info/WHEEL,sha256=A8Eltl-h0W-qZDVezsLjjslosEH_pdYC2lQ0JcbgCzs,91
+generalmanager-0.2.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.2.0.dist-info/RECORD,,

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

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