GeneralManager 0.14.1__py3-none-any.whl → 0.15.0__py3-none-any.whl

general_manager/permission/mutationPermission.py

@@ -1,3 +1,5 @@
+"""Permission helper for GraphQL mutations."""
+
 from __future__ import annotations
 from django.contrib.auth.models import AbstractUser, AnonymousUser
 from typing import Any
@@ -8,12 +10,21 @@ from general_manager.permission.utils import validatePermissionString
 
 
 class MutationPermission:
+    """Evaluate mutation permissions using class-level configuration."""
+
     __mutate__: list[str]
 
     def __init__(
         self, data: dict[str, Any], request_user: AbstractUser | AnonymousUser
     ) -> None:
-        self._data = PermissionDataManager(data)
+        """
+        Create a mutation permission context for the given data and user.
+
+        Parameters:
+            data (dict[str, Any]): Input payload for the mutation.
+            request_user (AbstractUser | AnonymousUser): User attempting the mutation.
+        """
+        self._data: PermissionDataManager = PermissionDataManager(data)
         self._request_user = request_user
         self.__attribute_permissions = self.__getAttributePermissions()
 
@@ -21,15 +32,18 @@ class MutationPermission:
 
     @property
     def data(self) -> PermissionDataManager:
+        """Return wrapped permission data."""
         return self._data
 
     @property
     def request_user(self) -> AbstractUser | AnonymousUser:
+        """Return the user whose permissions are being evaluated."""
         return self._request_user
 
     def __getAttributePermissions(
         self,
     ) -> dict[str, list[str]]:
+        """Collect attribute-specific permission expressions declared on the class."""
         attribute_permissions = {}
         for attribute in self.__class__.__dict__:
             if not attribute.startswith("__"):
@@ -43,9 +57,14 @@ class MutationPermission:
         request_user: AbstractUser | AnonymousUser | Any,
     ) -> None:
         """
-        Check if the user has permission to perform the mutation based on the provided data.
+        Validate that ``request_user`` may execute the mutation for the provided data.
+
+        Parameters:
+            data (dict[str, Any]): Mutation payload.
+            request_user (AbstractUser | AnonymousUser | Any): User or user ID.
+
         Raises:
-            PermissionError: If the user does not have permission.
+            PermissionError: If any field-level permission check fails.
         """
         errors = []
         if not isinstance(request_user, (AbstractUser, AnonymousUser)):
@@ -63,6 +82,15 @@ class MutationPermission:
         self,
         attribute: str,
     ) -> bool:
+        """
+        Evaluate permissions for a specific attribute within the mutation payload.
+
+        Parameters:
+            attribute (str): Attribute name being validated.
+
+        Returns:
+            bool: True when permitted, False otherwise.
+        """
 
         has_attribute_permissions = attribute in self.__attribute_permissions
 
@@ -84,6 +112,7 @@ class MutationPermission:
         self,
         permissions: list[str],
     ) -> bool:
+        """Return True when any permission expression evaluates to True."""
         for permission in permissions:
             if validatePermissionString(permission, self.data, self.request_user):
                 return True

general_manager/permission/permissionChecks.py

@@ -1,3 +1,5 @@
+"""Registry of reusable permission checks and their queryset filters."""
+
 from typing import Any, Callable, TYPE_CHECKING, TypedDict, Literal
 
 if TYPE_CHECKING:
@@ -25,6 +27,8 @@ type permission_method = Callable[
 
 
 class PermissionDict(TypedDict):
+    """Typed dictionary describing a registered permission function."""
+
     permission_method: permission_method
     permission_filter: permission_filter
 
@@ -47,10 +51,14 @@ permission_functions: dict[str, PermissionDict] = {
             "filter": {f"{config[0]}__endswith": config[1]}
         },
     },
-    "admin": {
+    "isAdmin": {
         "permission_method": lambda instance, user, config: user.is_staff,
         "permission_filter": lambda user, config: None,
     },
+    "isSelf": {
+        "permission_method": lambda instance, user, config: instance.creator == user,  # type: ignore
+        "permission_filter": lambda user, config: {"filter": {"creator_id": user.id}},  # type: ignore
+    },
     "isAuthenticated": {
         "permission_method": lambda instance, user, config: user.is_authenticated,
         "permission_filter": lambda user, config: None,

general_manager/permission/permissionDataManager.py

@@ -1,5 +1,7 @@
+"""Wrapper for accessing permission-relevant data across manager operations."""
+
 from __future__ import annotations
-from typing import Callable, Dict, Any, Optional, TypeVar, Generic
+from typing import Callable, Optional, TypeVar, Generic, cast
 from django.contrib.auth.models import AbstractUser
 
 from general_manager.manager.generalManager import GeneralManager
@@ -8,22 +10,41 @@ GeneralManagerData = TypeVar("GeneralManagerData", bound=GeneralManager)
 
 
 class PermissionDataManager(Generic[GeneralManagerData]):
+    """Adapter that exposes permission-related data as a unified interface."""
+
     def __init__(
         self,
-        permission_data: Dict[str, Any] | GeneralManagerData,
+        permission_data: dict[str, object] | GeneralManagerData,
         manager: Optional[type[GeneralManagerData]] = None,
-    ):
-        self.getData: Callable[[str], Any]
+    ) -> None:
+        """
+        Create a permission data manager wrapping either a dict or a manager instance.
+
+        Parameters:
+            permission_data (dict[str, Any] | GeneralManager): Raw data or manager instance supplying field values.
+            manager (type[GeneralManager] | None): Manager class when `permission_data` is a dict.
+
+        Raises:
+            TypeError: If `permission_data` is neither a dict nor a `GeneralManager`.
+        """
+        self.getData: Callable[[str], object]
         self._permission_data = permission_data
+        self._manager: type[GeneralManagerData] | None
         if isinstance(permission_data, GeneralManager):
-            self.getData = lambda name, permission_data=permission_data: getattr(
-                permission_data, name
-            )
-            self._manager = permission_data.__class__
+            gm_instance = permission_data
+
+            def manager_getter(name: str) -> object:
+                return getattr(gm_instance, name)
+
+            self.getData = manager_getter
+            self._manager = cast(type[GeneralManagerData], permission_data.__class__)
         elif isinstance(permission_data, dict):
-            self.getData = (
-                lambda name, permission_data=permission_data: permission_data.get(name)
-            )
+            data_mapping = permission_data
+
+            def dict_getter(name: str) -> object:
+                return data_mapping.get(name)
+
+            self.getData = dict_getter
             self._manager = manager
         else:
             raise TypeError(
@@ -34,18 +55,31 @@ class PermissionDataManager(Generic[GeneralManagerData]):
     def forUpdate(
         cls,
         base_data: GeneralManagerData,
-        update_data: Dict[str, Any],
+        update_data: dict[str, object],
     ) -> PermissionDataManager:
-        merged_data = {**dict(base_data), **update_data}
+        """
+        Create a data manager that reflects a pending update to an existing manager.
+
+        Parameters:
+            base_data (GeneralManager): Existing manager instance.
+            update_data (dict[str, Any]): Fields being updated.
+
+        Returns:
+            PermissionDataManager: Wrapper exposing merged data for permission checks.
+        """
+        merged_data: dict[str, object] = {**dict(base_data), **update_data}
         return cls(merged_data, base_data.__class__)
 
     @property
-    def permission_data(self) -> Dict[str, Any] | GeneralManagerData:
+    def permission_data(self) -> dict[str, object] | GeneralManagerData:
+        """Return the underlying permission payload."""
         return self._permission_data
 
     @property
     def manager(self) -> type[GeneralManagerData] | None:
+        """Return the manager class associated with the permission data."""
         return self._manager
 
-    def __getattr__(self, name: str) -> Any:
+    def __getattr__(self, name: str) -> object:
+        """Proxy attribute access to the wrapped permission data."""
         return self.getData(name)

general_manager/permission/utils.py

@@ -1,3 +1,5 @@
+"""Utility helpers for evaluating permission expressions."""
+
 from general_manager.permission.permissionChecks import (
     permission_functions,
 )
@@ -13,9 +15,18 @@ def validatePermissionString(
     data: PermissionDataManager | GeneralManager | GeneralManagerMeta,
     request_user: AbstractUser | AnonymousUser,
 ) -> bool:
-    # permission can be a combination of multiple permissions
-    # separated by "&" (e.g. "isAuthenticated&isMatchingKeyAccount")
-    # this means that all sub_permissions must be true
+    """
+    Evaluate a compound permission expression joined by ``&`` operators.
+
+    Parameters:
+        permission (str): Permission expression (for example, ``isAuthenticated&admin``).
+        data (PermissionDataManager | GeneralManager | GeneralManagerMeta): Object evaluated by the permission functions.
+        request_user (AbstractUser | AnonymousUser): User performing the action.
+
+    Returns:
+        bool: True if every sub-permission evaluates to True.
+    """
+
     def _validateSinglePermission(
         permission: str,
     ) -> bool:

general_manager/rule/__init__.py

@@ -1 +1,27 @@
-from .rule import Rule
+"""Helpers for defining rule-based validations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from general_manager.utils.public_api import build_module_dir, resolve_export
+
+__all__ = ["Rule", "BaseRuleHandler"]
+
+_MODULE_MAP = {
+    "Rule": ("general_manager.rule.rule", "Rule"),
+    "BaseRuleHandler": ("general_manager.rule.handler", "BaseRuleHandler"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    return resolve_export(
+        name,
+        module_all=__all__,
+        module_map=_MODULE_MAP,
+        module_globals=globals(),
+    )
+
+
+def __dir__() -> list[str]:
+    return build_module_dir(module_all=__all__, module_globals=globals())

general_manager/rule/handler.py

@@ -1,4 +1,4 @@
-# generalManager/src/rule/handlers.py
+"""Rule handler implementations that craft error messages from AST nodes."""
 
 from __future__ import annotations
 import ast
@@ -10,7 +10,7 @@ if TYPE_CHECKING:
 
 
 class BaseRuleHandler(ABC):
-    """Schnittstelle für Rule-Handler."""
+    """Define the protocol for generating rule-specific error messages."""
 
     function_name: str  # ClassVar, der Name, unter dem dieser Handler registriert wird
 
@@ -25,14 +25,25 @@ class BaseRuleHandler(ABC):
         rule: Rule,
     ) -> Dict[str, str]:
         """
-        Erstelle Fehlermeldungen für den Vergleichs- oder Funktionsaufruf.
+        Produce error messages for a comparison or function call node.
+
+        Parameters:
+            node (ast.AST): AST node representing the expression being evaluated.
+            left (ast.expr | None): Left operand when applicable.
+            right (ast.expr | None): Right operand when applicable.
+            op (ast.cmpop | None): Comparison operator node.
+            var_values (dict[str, object | None]): Resolved variable values used during evaluation.
+            rule (Rule): Rule invoking the handler.
+
+        Returns:
+            dict[str, str]: Mapping of variable names to error messages.
         """
         pass
 
 
 class FunctionHandler(BaseRuleHandler, ABC):
     """
-    Handler für Funktionsaufrufe wie len(), max(), min(), sum().
+    Base class for handlers that evaluate function-call expressions such as len(), max(), or sum().
     """
 
     def handle(
@@ -74,7 +85,17 @@ class FunctionHandler(BaseRuleHandler, ABC):
         rule: Rule,
     ) -> Dict[str, str]:
         """
-        Aggregiere die Werte und erstelle eine Fehlermeldung.
+        Analyse the call arguments and construct an error message payload.
+
+        Parameters:
+            arg_node (ast.expr): AST node representing the function argument.
+            right_node (ast.expr): Node representing the comparison threshold.
+            op_symbol (str): Symbolic representation of the comparison operator.
+            var_values (dict[str, object | None]): Resolved values used during evaluation.
+            rule (Rule): Rule requesting the aggregation.
+
+        Returns:
+            dict[str, str]: Mapping of variable names to error messages.
         """
         raise NotImplementedError("Subclasses should implement this method")
 
@@ -90,6 +111,22 @@ class LenHandler(FunctionHandler):
         var_values: Dict[str, Optional[object]],
         rule: Rule,
     ) -> Dict[str, str]:
+        """
+        Evaluate length-based limits and craft an error message when violated.
+
+        Parameters:
+            arg_node (ast.expr): AST node representing the iterable passed to `len`.
+            right_node (ast.expr): Comparison threshold node.
+            op_symbol (str): Operator symbol describing the comparison.
+            var_values (dict[str, object | None]): Evaluated variable values.
+            rule (Rule): Calling rule used for helper evaluations.
+
+        Returns:
+            dict[str, str]: Mapping containing a single error message keyed by variable name.
+
+        Raises:
+            ValueError: If the argument is invalid or the threshold is not numeric.
+        """
 
         var_name = rule._get_node_name(arg_node)
         var_value = var_values.get(var_name)
@@ -133,6 +170,22 @@ class SumHandler(FunctionHandler):
         var_values: Dict[str, Optional[object]],
         rule: Rule,
     ) -> Dict[str, str]:
+        """
+        Compute the sum of an iterable and compare it to the threshold.
+
+        Parameters:
+            arg_node (ast.expr): AST node representing the iterable passed to `sum`.
+            right_node (ast.expr): Node describing the threshold value.
+            op_symbol (str): Operator symbol describing the comparison.
+            var_values (dict[str, object | None]): Evaluated variable values.
+            rule (Rule): Calling rule used for helper evaluations.
+
+        Returns:
+            dict[str, str]: Mapping containing a single error message keyed by variable name.
+
+        Raises:
+            ValueError: If the argument is not a numeric iterable or the threshold is invalid.
+        """
 
         # Name und Wert holen
         var_name = rule._get_node_name(arg_node)
@@ -175,6 +228,22 @@ class MaxHandler(FunctionHandler):
         var_values: Dict[str, Optional[object]],
         rule: Rule,
     ) -> Dict[str, str]:
+        """
+        Compare the maximum element of an iterable against the provided threshold.
+
+        Parameters:
+            arg_node (ast.expr): AST node representing the iterable passed to `max`.
+            right_node (ast.expr): Node describing the threshold value.
+            op_symbol (str): Operator symbol describing the comparison.
+            var_values (dict[str, object | None]): Evaluated variable values.
+            rule (Rule): Calling rule used for helper evaluations.
+
+        Returns:
+            dict[str, str]: Mapping containing a single error message keyed by variable name.
+
+        Raises:
+            ValueError: If the iterable is empty, non-numeric, or the threshold is invalid.
+        """
 
         var_name = rule._get_node_name(arg_node)
         raw_iter = var_values.get(var_name)
@@ -210,6 +279,22 @@ class MinHandler(FunctionHandler):
         var_values: Dict[str, Optional[object]],
         rule: Rule,
     ) -> Dict[str, str]:
+        """
+        Compare the minimum element of an iterable against the provided threshold.
+
+        Parameters:
+            arg_node (ast.expr): AST node representing the iterable passed to `min`.
+            right_node (ast.expr): Node describing the threshold value.
+            op_symbol (str): Operator symbol describing the comparison.
+            var_values (dict[str, object | None]): Evaluated variable values.
+            rule (Rule): Calling rule used for helper evaluations.
+
+        Returns:
+            dict[str, str]: Mapping containing a single error message keyed by variable name.
+
+        Raises:
+            ValueError: If the iterable is empty, non-numeric, or the threshold is invalid.
+        """
 
         var_name = rule._get_node_name(arg_node)
         raw_iter = var_values.get(var_name)

general_manager/rule/rule.py

@@ -1,4 +1,4 @@
-# generalManager/src/rule/rule.py
+"""Infrastructure for expressing validation rules against GeneralManager instances."""
 
 from __future__ import annotations
 import ast
@@ -33,8 +33,10 @@ GeneralManagerType = TypeVar("GeneralManagerType", bound=GeneralManager)
 
 class Rule(Generic[GeneralManagerType]):
     """
-    Rule kapselt eine boolsche Bedingungsfunktion und erzeugt bei Fehlschlag
-    automatisierte oder benutzerdefinierte Fehlermeldungen auf Basis des AST.
+    Encapsulate a boolean predicate and derive contextual error messages from its AST.
+
+    When the predicate evaluates to False, the rule inspects the parsed abstract syntax tree
+    to determine which variables failed and crafts either autogenerated or custom error messages.
     """
 
     _func: Callable[[GeneralManagerType], bool]
@@ -58,27 +60,22 @@ class Rule(Generic[GeneralManagerType]):
         self._last_result = None
         self._last_input = None
 
-        # 1) Quelltext holen, Decorators abschneiden, Dedent
-        src = inspect.getsource(func)
-        lines = src.splitlines()
-        if lines and lines[0].strip().startswith("@"):
-            idx = next(i for i, L in enumerate(lines) if not L.strip().startswith("@"))
-            src = "\n".join(lines[idx:])
-        src = textwrap.dedent(src)
+        # 1) Extract source, strip decorators, and dedent
+        src = textwrap.dedent(inspect.getsource(func))
 
-        # 2) AST parsen & Elternverweise setzen
+        # 2) Parse AST and attach parent references
         self._tree = ast.parse(src)
         for parent in ast.walk(self._tree):
             for child in ast.iter_child_nodes(parent):
                 setattr(child, "parent", parent)
 
-        # 3) Variablen extrahieren
+        # 3) Extract referenced variables
         self._variables = self._extract_variables()
 
-        # 4) Handler registrieren
+        # 4) Register handlers
         self._handlers = {}  # type: Dict[str, BaseRuleHandler]
         for cls in (LenHandler, MaxHandler, MinHandler, SumHandler):
-            inst = cls()
+            inst: BaseRuleHandler = cls()
             self._handlers[inst.function_name] = inst
         for path in getattr(settings, "RULE_HANDLERS", []):
             handler_cls: type[BaseRuleHandler] = import_string(path)
@@ -111,8 +108,13 @@ class Rule(Generic[GeneralManagerType]):
 
     def evaluate(self, x: GeneralManagerType) -> Optional[bool]:
         """
-        Führt die Regel aus. Gibt False bei Fehlschlag, True bei Erfolg
-        und None, falls ignore_if_none aktiv ist und eine Variable None war.
+        Execute the predicate against a manager instance and record the result.
+
+        Parameters:
+            x (GeneralManagerType): Manager instance supplied to the predicate.
+
+        Returns:
+            bool | None: True or False when the predicate executes; None when `ignore_if_none` is set and any referenced value is None.
         """
         self._last_input = x
         vals = self._extract_variable_values(x)
@@ -125,8 +127,13 @@ class Rule(Generic[GeneralManagerType]):
 
     def validateCustomErrorMessage(self) -> None:
         """
-        Stellt sicher, dass in der custom_error_message alle Variablen
-        aus self._variables verwendet werden.
+        Ensure the user-defined template references every extracted variable.
+
+        Returns:
+            None
+
+        Raises:
+            ValueError: If the custom error message omits a required placeholder.
         """
         if not self._custom_error_message:
             return
@@ -140,14 +147,20 @@ class Rule(Generic[GeneralManagerType]):
 
     def getErrorMessage(self) -> Optional[Dict[str, str]]:
         """
-        Liefert ein Dict variable→message, oder None, wenn kein Fehler.
+        Build a mapping of variable names to error messages for the last evaluation.
+
+        Returns:
+            dict[str, str] | None: Mapping describing validation failures, or None when the predicate passed.
+
+        Raises:
+            ValueError: If called before any input has been evaluated.
         """
         if self._last_result or self._last_result is None:
             return None
         if self._last_input is None:
             raise ValueError("No input provided for error message generation")
 
-        # Validierung und Ersetzen der Template-Platzhalter
+        # Validate and substitute template placeholders
         self.validateCustomErrorMessage()
         vals = self._extract_variable_values(self._last_input)
 
@@ -229,7 +242,7 @@ class Rule(Generic[GeneralManagerType]):
             for cmp in comparisons:
                 left, rights, ops = cmp.left, cmp.comparators, cmp.ops
                 for right, op in zip(rights, ops):
-                    # Spezial-Handler?
+                    # Special handler?
                     if isinstance(left, ast.Call):
                         fn = self._get_node_name(left.func)
                         handler = self._handlers.get(fn)
@@ -239,7 +252,7 @@ class Rule(Generic[GeneralManagerType]):
                             )
                             continue
 
-                    # Standard-Fehler
+                    # Standard error message
                     lnm = self._get_node_name(left)
                     rnm = self._get_node_name(right)
                     lval = self._eval_node(left)
@@ -261,11 +274,13 @@ class Rule(Generic[GeneralManagerType]):
 
             return errors
 
-        # kein Vergleich → pauschale Meldung
+        # No comparisons present → fall back to a generic message
         combo = ", ".join(f"[{v}]" for v in self._variables)
         return {v: f"{combo} combination is not valid" for v in self._variables}
 
     def _get_op_symbol(self, op: Optional[ast.cmpop]) -> str:
+        if op is None:
+            return "?"
         return {
             ast.Lt: "<",
             ast.LtE: "<=",
@@ -296,15 +311,13 @@ class Rule(Generic[GeneralManagerType]):
             args = ", ".join(self._get_node_name(a) for a in node.args)
             return f"{fn}({args})"
         try:
-            # ast.unparse gibt einen str zurück
+            # ast.unparse returns a string representation
             return ast.unparse(node)
         except Exception:
             return ""
 
     def _eval_node(self, node: ast.expr) -> Optional[object]:
-        """
-        Evaluiert einen AST-Ausdruck im Kontext von `x`.
-        """
+        """Evaluate an AST expression in the context of the last input."""
         if not isinstance(node, ast.expr):
             return None
         try:

general_manager/utils/__init__.py

@@ -1,2 +1,44 @@
-from .noneToZero import noneToZero
-from .argsToKwargs import args_to_kwargs
+"""Convenience re-exports for common utility helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from general_manager.utils.public_api import build_module_dir, resolve_export
+
+__all__ = [
+    "noneToZero",
+    "args_to_kwargs",
+    "make_cache_key",
+    "parse_filters",
+    "create_filter_function",
+    "snake_to_pascal",
+    "snake_to_camel",
+    "pascal_to_snake",
+    "camel_to_snake",
+]
+
+_MODULE_MAP = {
+    "noneToZero": ("general_manager.utils.noneToZero", "noneToZero"),
+    "args_to_kwargs": ("general_manager.utils.argsToKwargs", "args_to_kwargs"),
+    "make_cache_key": ("general_manager.utils.makeCacheKey", "make_cache_key"),
+    "parse_filters": ("general_manager.utils.filterParser", "parse_filters"),
+    "create_filter_function": ("general_manager.utils.filterParser", "create_filter_function"),
+    "snake_to_pascal": ("general_manager.utils.formatString", "snake_to_pascal"),
+    "snake_to_camel": ("general_manager.utils.formatString", "snake_to_camel"),
+    "pascal_to_snake": ("general_manager.utils.formatString", "pascal_to_snake"),
+    "camel_to_snake": ("general_manager.utils.formatString", "camel_to_snake"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    return resolve_export(
+        name,
+        module_all=__all__,
+        module_map=_MODULE_MAP,
+        module_globals=globals(),
+    )
+
+
+def __dir__() -> list[str]:
+    return build_module_dir(module_all=__all__, module_globals=globals())

general_manager/utils/argsToKwargs.py

@@ -1,22 +1,30 @@
-from typing import Any, Iterable
+from typing import Iterable, Mapping
 
 
 def args_to_kwargs(
-    args: tuple[Any, ...], keys: Iterable[Any], existing_kwargs: dict | None = None
-):
+    args: tuple[object, ...],
+    keys: Iterable[str],
+    existing_kwargs: Mapping[str, object] | None = None,
+) -> dict[str, object]:
     """
-    Converts *args into **kwargs and combines them with existing **kwargs.
+    Convert positional arguments to keyword arguments and merge them into an existing mapping.
 
-    :param args: Tuple of positional arguments (e.g., *args).
-    :param keys: List of keys to associate with the arguments.
-    :param existing_kwargs: Optional dictionary of already existing key-value mappings.
-    :return: Dictionary of combined **kwargs.
+    Parameters:
+        args (tuple[Any, ...]): Positional arguments that should be mapped to keyword arguments.
+        keys (Iterable[Any]): Keys used to map each positional argument within `args`.
+        existing_kwargs (dict | None): Optional keyword argument mapping to merge with the generated values.
+
+    Returns:
+        dict[Any, Any]: A dictionary containing the merged keyword arguments.
+
+    Raises:
+        TypeError: If the number of positional arguments exceeds the number of provided keys, or if any generated keyword collides with `existing_kwargs`.
     """
     keys = list(keys)
     if len(args) > len(keys):
         raise TypeError("More positional arguments than keys provided.")
 
-    kwargs = {key: value for key, value in zip(keys, args)}
+    kwargs: dict[str, object] = {key: value for key, value in zip(keys, args)}
     if existing_kwargs and any(key in kwargs for key in existing_kwargs):
         raise TypeError("Conflicts in existing kwargs.")
     if existing_kwargs: