GeneralManager 0.1.1__tar.gz → 0.2.0__tar.gz

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

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

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

@@ -46,9 +46,13 @@ 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_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.1 → generalmanager-0.2.0}/PKG-INFO

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

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

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

generalmanager-0.2.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.2.0/src/general_manager/auxiliary/noneToZero.py

@@ -0,0 +1,21 @@
+from typing import Optional, TypeVar, Literal
+from general_manager.measurement import Measurement
+
+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.1.1 → generalmanager-0.2.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
@@ -654,7 +663,12 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             kwarg_filter[key].append(value)
         return kwarg_filter
 
-    def filter(self, **kwargs: Any) -> DatabaseBucket:
+    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),
@@ -663,7 +677,16 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             self.excludes,
         )
 
-    def exclude(self, **kwargs: Any) -> DatabaseBucket:
+    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.1 → generalmanager-0.2.0}/src/general_manager/manager/input.py

@@ -17,6 +17,14 @@ class Input(Generic[INPUT_TYPE]):
         possible_values: Optional[Callable | Iterable] = None,
         depends_on: Optional[List[str]] = None,
     ):
+        """
+        Initializes an Input instance with type information, possible values, and dependencies.
+        
+        Args:
+            type: The expected type for the input value.
+            possible_values: An optional iterable or callable that defines allowed values.
+            depends_on: An optional list of dependency names. If not provided and possible_values is callable, dependencies are inferred from its parameters.
+        """
         self.type = type
         self.possible_values = possible_values
         self.is_manager = issubclass(type, GeneralManager)
@@ -33,16 +41,33 @@ class Input(Generic[INPUT_TYPE]):
             self.depends_on = []
 
     def cast(self, value: Any) -> Any:
+        """
+        Casts the input value to the type specified by this Input instance.
+        
+        Handles special cases for date, datetime, GeneralManager subclasses, and Measurement types.
+        If the value is already of the target type, it is returned unchanged. Otherwise, attempts to
+        convert or construct the value as appropriate for the target type.
+        
+        Args:
+            value: The value to be cast or converted.
+        
+        Returns:
+            The value converted to the target type, or an instance of the target type.
+        """
+        if self.type == date:
+            if isinstance(value, datetime) and type(value) is not date:
+                return value.date()
+            return date.fromisoformat(value)
+        if self.type == datetime:
+            if isinstance(value, date):
+                return datetime.combine(value, datetime.min.time())
+            return datetime.fromisoformat(value)
         if isinstance(value, self.type):
             return value
         if issubclass(self.type, GeneralManager):
             if isinstance(value, dict):
                 return self.type(**value)  # type: ignore
             return self.type(id=value)  # type: ignore
-        if self.type == date:
-            return date.fromisoformat(value)
-        if self.type == datetime:
-            return datetime.fromisoformat(value)
         if self.type == Measurement and isinstance(value, str):
             return Measurement.from_string(value)
         return self.type(value)

generalmanager-0.2.0/src/general_manager/rule/handler.py

@@ -0,0 +1,234 @@
+# generalManager/src/rule/handlers.py
+
+from __future__ import annotations
+import ast
+from typing import Dict, Optional, TYPE_CHECKING
+from abc import ABC, abstractmethod
+
+if TYPE_CHECKING:
+    from general_manager.rule.rule import Rule
+
+
+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,
+        left: Optional[ast.expr],
+        right: Optional[ast.expr],
+        op: Optional[ast.cmpop],
+        var_values: Dict[str, Optional[object]],
+        rule: Rule,
+    ) -> Dict[str, str]:
+        """
+        Erstelle Fehlermeldungen für den Vergleichs- oder Funktionsaufruf.
+        """
+        pass
+
+
+class FunctionHandler(BaseRuleHandler, ABC):
+    """
+    Handler für Funktionsaufrufe wie len(), max(), min(), sum().
+    """
+
+    def handle(
+        self,
+        node: ast.AST,
+        left: Optional[ast.expr],
+        right: Optional[ast.expr],
+        op: Optional[ast.cmpop],
+        var_values: Dict[str, Optional[object]],
+        rule: Rule,
+    ) -> Dict[str, str]:
+        if not isinstance(node, ast.Compare):
+            return {}
+        compare_node = node
+
+        left_node = compare_node.left
+        right_node = compare_node.comparators[0]
+        op_symbol = rule._get_op_symbol(op)
+
+        if not (isinstance(left_node, ast.Call) and left_node.args):
+            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)
+
+        # --- Hier der Typ-Guard für right_value ---
+        raw = rule._eval_node(right_node)
+        if not isinstance(raw, (int, float)):
+            raise ValueError("Invalid arguments for len function")
+        right_value: int | float = raw
+
+        if op_symbol == ">":
+            threshold = right_value + 1
+        elif op_symbol == ">=":
+            threshold = right_value
+        elif op_symbol == "<":
+            threshold = right_value - 1
+        elif op_symbol == "<=":
+            threshold = right_value
+        else:
+            threshold = right_value
+
+        # Fehlermeldung formulieren
+        if op_symbol in (">", ">="):
+            msg = f"[{var_name}] ({var_value}) is too short (min length {threshold})!"
+        elif op_symbol in ("<", "<="):
+            msg = f"[{var_name}] ({var_value}) is too long (max length {threshold})!"
+        else:
+            msg = f"[{var_name}] ({var_value}) must have a length of {right_value}!"
+
+        return {var_name: msg}
+
+
+class SumHandler(FunctionHandler):
+    function_name = "sum"
+
+    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]:
+
+        # 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}

{generalmanager-0.1.1 → generalmanager-0.2.0}/src/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", []):