GeneralManager 0.17.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

general_manager/permission/permissionChecks.py

@@ -35,32 +35,34 @@ class PermissionDict(TypedDict):
 
 permission_functions: dict[str, PermissionDict] = {
     "public": {
-        "permission_method": lambda instance, user, config: True,
-        "permission_filter": lambda user, config: None,
+        "permission_method": lambda _instance, _user, _config: True,
+        "permission_filter": lambda _user, _config: None,
     },
     "matches": {
-        "permission_method": lambda instance, user, config: getattr(instance, config[0])
+        "permission_method": lambda instance, _user, config: getattr(
+            instance, config[0]
+        )
         == config[1],
-        "permission_filter": lambda user, config: {"filter": {config[0]: config[1]}},
+        "permission_filter": lambda _user, config: {"filter": {config[0]: config[1]}},
     },
     "ends_with": {
-        "permission_method": lambda instance, user, config: getattr(
+        "permission_method": lambda instance, _user, config: getattr(
             instance, config[0]
         ).endswith(config[1]),
-        "permission_filter": lambda user, config: {
+        "permission_filter": lambda _user, config: {
             "filter": {f"{config[0]}__endswith": config[1]}
         },
     },
     "isAdmin": {
-        "permission_method": lambda instance, user, config: user.is_staff,
-        "permission_filter": lambda user, config: None,
+        "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
+        "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,
+        "permission_method": lambda _instance, user, _config: user.is_authenticated,
+        "permission_filter": lambda _user, _config: None,
     },
 }

general_manager/permission/permissionDataManager.py

@@ -6,6 +6,21 @@ from django.contrib.auth.models import AbstractUser
 
 from general_manager.manager.generalManager import GeneralManager
 
+
+class InvalidPermissionDataError(TypeError):
+    """Raised when the permission data manager receives unsupported input."""
+
+    def __init__(self) -> None:
+        """
+        Exception raised when a permission data input is not a dict or a GeneralManager instance.
+
+        The exception carries the message: "permission_data must be either a dict or an instance of GeneralManager."
+        """
+        super().__init__(
+            "permission_data must be either a dict or an instance of GeneralManager."
+        )
+
+
 GeneralManagerData = TypeVar("GeneralManagerData", bound=GeneralManager)
 
 
@@ -18,14 +33,14 @@ class PermissionDataManager(Generic[GeneralManagerData]):
         manager: Optional[type[GeneralManagerData]] = None,
     ) -> None:
         """
-        Create a permission data manager wrapping either a dict or a manager instance.
+        Wrap a mapping or GeneralManager instance to expose permission-related fields via attribute access.
 
         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.
+            permission_data (dict[str, object] | GeneralManager): Either a dict mapping field names to values or a GeneralManager instance whose attributes provide field values.
+            manager (type[GeneralManager] | None): When `permission_data` is a dict, the manager class associated with that data; otherwise ignored.
 
         Raises:
-            TypeError: If `permission_data` is neither a dict nor a `GeneralManager`.
+            InvalidPermissionDataError: If `permission_data` is neither a dict nor an instance of GeneralManager.
         """
         self.getData: Callable[[str], object]
         self._permission_data = permission_data
@@ -47,9 +62,7 @@ class PermissionDataManager(Generic[GeneralManagerData]):
             self.getData = dict_getter
             self._manager = manager
         else:
-            raise TypeError(
-                "permission_data must be either a dict or an instance of GeneralManager"
-            )
+            raise InvalidPermissionDataError()
 
     @classmethod
     def forUpdate(
@@ -58,14 +71,14 @@ class PermissionDataManager(Generic[GeneralManagerData]):
         update_data: dict[str, object],
     ) -> PermissionDataManager:
         """
-        Create a data manager that reflects a pending update to an existing manager.
+        Create a PermissionDataManager representing `base_data` with `update_data` applied.
 
         Parameters:
-            base_data (GeneralManager): Existing manager instance.
-            update_data (dict[str, Any]): Fields being updated.
+            base_data (GeneralManagerData): Existing manager instance whose data will serve as the base.
+            update_data (dict[str, object]): Fields to add or override on the base data.
 
         Returns:
-            PermissionDataManager: Wrapper exposing merged data for permission checks.
+            PermissionDataManager: Wrapper exposing the merged data where keys in `update_data` override those from `base_data`.
         """
         merged_data: dict[str, object] = {**dict(base_data), **update_data}
         return cls(merged_data, base_data.__class__)

general_manager/permission/utils.py

@@ -10,29 +10,57 @@ from general_manager.manager.generalManager import GeneralManager
 from general_manager.manager.meta import GeneralManagerMeta
 
 
+class PermissionNotFoundError(ValueError):
+    """Raised when a referenced permission function is not registered."""
+
+    def __init__(self, permission: str) -> None:
+        """
+        Exception raised when a referenced permission function cannot be found.
+
+        Parameters:
+            permission (str): The permission identifier that was not found; used to format the exception message.
+        """
+        super().__init__(f"Permission {permission} not found.")
+
+
 def validatePermissionString(
     permission: str,
     data: PermissionDataManager | GeneralManager | GeneralManagerMeta,
     request_user: AbstractUser | AnonymousUser,
 ) -> bool:
     """
-    Evaluate a compound permission expression joined by ``&`` operators.
+    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.
+        permission (str): Permission expression where sub-permissions are joined with '&'. Individual sub-permissions may include ':'-separated configuration parts (for example, "isAuthenticated&admin:level").
+        data (PermissionDataManager | GeneralManager | GeneralManagerMeta): Object passed to each permission function.
+        request_user (AbstractUser | AnonymousUser): User for whom permissions are evaluated.
 
     Returns:
-        bool: True if every sub-permission evaluates to True.
+        `true` if every sub-permission evaluates to True, `false` otherwise.
+
+    Raises:
+        PermissionNotFoundError: If a referenced permission function is not registered.
     """
 
     def _validateSinglePermission(
         permission: str,
     ) -> bool:
+        """
+        Evaluate a single sub-permission expression against the registered permission functions.
+
+        Parameters:
+                permission (str): A single permission fragment in the form "permission_name[:config...]" where parts after the first colon are passed as configuration.
+
+        Returns:
+                bool: `true` if the referenced permission function grants the permission, `false` otherwise.
+
+        Raises:
+                PermissionNotFoundError: If no registered permission function matches the `permission_name`.
+        """
         permission_function, *config = permission.split(":")
         if permission_function not in permission_functions:
-            raise ValueError(f"Permission {permission} not found")
+            raise PermissionNotFoundError(permission)
 
         return permission_functions[permission_function]["permission_method"](
             data, request_user, config

general_manager/public_api_registry.py

@@ -18,9 +18,18 @@ GENERAL_MANAGER_EXPORTS: LazyExportMap = {
     "graphQlMutation": ("general_manager.api.mutation", "graphQlMutation"),
     "GeneralManager": ("general_manager.manager.generalManager", "GeneralManager"),
     "Input": ("general_manager.manager.input", "Input"),
-    "CalculationInterface": ("general_manager.interface.calculationInterface", "CalculationInterface"),
-    "DatabaseInterface": ("general_manager.interface.databaseInterface", "DatabaseInterface"),
-    "ReadOnlyInterface": ("general_manager.interface.readOnlyInterface", "ReadOnlyInterface"),
+    "CalculationInterface": (
+        "general_manager.interface.calculationInterface",
+        "CalculationInterface",
+    ),
+    "DatabaseInterface": (
+        "general_manager.interface.databaseInterface",
+        "DatabaseInterface",
+    ),
+    "ReadOnlyInterface": (
+        "general_manager.interface.readOnlyInterface",
+        "ReadOnlyInterface",
+    ),
     "ManagerBasedPermission": (
         "general_manager.permission.managerBasedPermission",
         "ManagerBasedPermission",
@@ -45,7 +54,10 @@ FACTORY_EXPORTS: LazyExportMap = {
     "LazyProjectName": ("general_manager.factory.factoryMethods", "LazyProjectName"),
     "LazyDateToday": ("general_manager.factory.factoryMethods", "LazyDateToday"),
     "LazyDateBetween": ("general_manager.factory.factoryMethods", "LazyDateBetween"),
-    "LazyDateTimeBetween": ("general_manager.factory.factoryMethods", "LazyDateTimeBetween"),
+    "LazyDateTimeBetween": (
+        "general_manager.factory.factoryMethods",
+        "LazyDateTimeBetween",
+    ),
     "LazyInteger": ("general_manager.factory.factoryMethods", "LazyInteger"),
     "LazyDecimal": ("general_manager.factory.factoryMethods", "LazyDecimal"),
     "LazyChoice": ("general_manager.factory.factoryMethods", "LazyChoice"),
@@ -54,7 +66,10 @@ FACTORY_EXPORTS: LazyExportMap = {
     "LazyUUID": ("general_manager.factory.factoryMethods", "LazyUUID"),
     "LazyFakerName": ("general_manager.factory.factoryMethods", "LazyFakerName"),
     "LazyFakerEmail": ("general_manager.factory.factoryMethods", "LazyFakerEmail"),
-    "LazyFakerSentence": ("general_manager.factory.factoryMethods", "LazyFakerSentence"),
+    "LazyFakerSentence": (
+        "general_manager.factory.factoryMethods",
+        "LazyFakerSentence",
+    ),
     "LazyFakerAddress": ("general_manager.factory.factoryMethods", "LazyFakerAddress"),
     "LazyFakerUrl": ("general_manager.factory.factoryMethods", "LazyFakerUrl"),
 }
@@ -64,7 +79,10 @@ MEASUREMENT_EXPORTS: LazyExportMap = {
     "Measurement": ("general_manager.measurement.measurement", "Measurement"),
     "ureg": ("general_manager.measurement.measurement", "ureg"),
     "currency_units": ("general_manager.measurement.measurement", "currency_units"),
-    "MeasurementField": ("general_manager.measurement.measurementField", "MeasurementField"),
+    "MeasurementField": (
+        "general_manager.measurement.measurementField",
+        "MeasurementField",
+    ),
 }
 
 
@@ -73,7 +91,10 @@ UTILS_EXPORTS: LazyExportMap = {
     "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"),
+    "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"),
@@ -89,7 +110,10 @@ PERMISSION_EXPORTS: LazyExportMap = {
         "general_manager.permission.managerBasedPermission",
         "ManagerBasedPermission",
     ),
-    "MutationPermission": ("general_manager.permission.mutationPermission", "MutationPermission"),
+    "MutationPermission": (
+        "general_manager.permission.mutationPermission",
+        "MutationPermission",
+    ),
 }
 
 
@@ -124,7 +148,10 @@ CACHE_EXPORTS: LazyExportMap = {
 BUCKET_EXPORTS: LazyExportMap = {
     "Bucket": ("general_manager.bucket.baseBucket", "Bucket"),
     "DatabaseBucket": ("general_manager.bucket.databaseBucket", "DatabaseBucket"),
-    "CalculationBucket": ("general_manager.bucket.calculationBucket", "CalculationBucket"),
+    "CalculationBucket": (
+        "general_manager.bucket.calculationBucket",
+        "CalculationBucket",
+    ),
     "GroupBucket": ("general_manager.bucket.groupBucket", "GroupBucket"),
 }
 
@@ -157,4 +184,3 @@ EXPORT_REGISTRY: Mapping[str, LazyExportMap] = {
     "general_manager.manager": MANAGER_EXPORTS,
     "general_manager.rule": RULE_EXPORTS,
 }
-

general_manager/rule/__init__.py

@@ -12,10 +12,19 @@ __all__ = list(RULE_EXPORTS)
 _MODULE_MAP = RULE_EXPORTS
 
 if TYPE_CHECKING:
-    from general_manager._types.rule import *  # noqa: F401,F403
+    from general_manager._types.rule import *  # noqa: F403
 
 
 def __getattr__(name: str) -> Any:
+    """
+    Dynamically resolve a missing module attribute using the module's export registry.
+
+    Parameters:
+        name (str): The attribute name being accessed on the module.
+
+    Returns:
+        The attribute value associated with `name` from the module's export registry, or a fallback value if the name cannot be resolved.
+    """
     return resolve_export(
         name,
         module_all=__all__,

general_manager/rule/handler.py

@@ -9,6 +9,71 @@ if TYPE_CHECKING:
     from general_manager.rule.rule import Rule
 
 
+class InvalidFunctionNodeError(ValueError):
+    """Raised when a rule handler receives an invalid AST node for its function."""
+
+    def __init__(self, function_name: str) -> None:
+        """
+        Initialize the exception for an invalid left-hand AST node used with a function call.
+
+        Parameters:
+            function_name (str): Name of the function with the invalid left node; stored on the exception and used to form the message "Invalid left node for {function_name}() function."
+        """
+        self.function_name = function_name
+        super().__init__(f"Invalid left node for {function_name}() function.")
+
+
+class InvalidLenThresholdError(TypeError):
+    """Raised when len() comparisons use a non-numeric threshold."""
+
+    def __init__(self) -> None:
+        """
+        Exception raised when a len() threshold is not a numeric value.
+
+        Initializes the exception with a default message indicating invalid arguments for the len function.
+        """
+        super().__init__("Invalid arguments for len function.")
+
+
+class InvalidNumericThresholdError(TypeError):
+    """Raised when aggregate handlers use a non-numeric threshold."""
+
+    def __init__(self, function_name: str) -> None:
+        """
+        Create an InvalidFunctionNodeError with a formatted message for the given function name.
+
+        Parameters:
+            function_name (str): Name of the aggregate function (e.g., "sum", "max", "min") included in the message.
+        """
+        super().__init__(f"Invalid arguments for {function_name} function.")
+
+
+class NonEmptyIterableError(ValueError):
+    """Raised when an aggregate function expects a non-empty iterable."""
+
+    def __init__(self, function_name: str) -> None:
+        """
+        Initialize the error indicating an aggregate function received an empty iterable.
+
+        Parameters:
+            function_name (str): Name of the aggregate function (e.g., 'sum', 'max', 'len') used to build the error message.
+        """
+        super().__init__(f"{function_name} expects a non-empty iterable.")
+
+
+class NumericIterableError(TypeError):
+    """Raised when an aggregate function expects numeric elements."""
+
+    def __init__(self, function_name: str) -> None:
+        """
+        Initialize the exception indicating that a function expected an iterable of numeric values.
+
+        Parameters:
+            function_name (str): Name of the function included in the exception message (message: "<function_name> expects an iterable of numbers.").
+        """
+        super().__init__(f"{function_name} expects an iterable of numbers.")
+
+
 class BaseRuleHandler(ABC):
     """Define the protocol for generating rule-specific error messages."""
 
@@ -55,6 +120,23 @@ class FunctionHandler(BaseRuleHandler, ABC):
         var_values: Dict[str, Optional[object]],
         rule: Rule,
     ) -> Dict[str, str]:
+        """
+        Handle a comparison AST node whose left side is a function call and delegate analysis to the subclass aggregate method.
+
+        Parameters:
+            node (ast.AST): The AST node to inspect; processing only occurs if it is an `ast.Compare`.
+            left (Optional[ast.expr]): Original left operand from the rule (may be unused by this handler).
+            right (Optional[ast.expr]): Original right operand from the rule (may be unused by this handler).
+            op (Optional[ast.cmpop]): Comparison operator from the rule; used to determine operator symbol.
+            var_values (Dict[str, Optional[object]]): Mapping of variable names to their resolved values for message construction.
+            rule (Rule): Rule instance used to obtain the textual operator symbol and any rule-specific context.
+
+        Returns:
+            Dict[str, str]: Mapping from variable name to generated error message; empty if `node` is not an `ast.Compare`.
+
+        Raises:
+            InvalidFunctionNodeError: If the compare left-hand side is not a function call with at least one argument.
+        """
         if not isinstance(node, ast.Compare):
             return {}
         compare_node = node
@@ -64,7 +146,7 @@ class FunctionHandler(BaseRuleHandler, ABC):
         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")
+            raise InvalidFunctionNodeError(self.function_name)
         arg_node = left_node.args[0]
 
         return self.aggregate(
@@ -112,20 +194,20 @@ class LenHandler(FunctionHandler):
         rule: Rule,
     ) -> Dict[str, str]:
         """
-        Evaluate length-based limits and craft an error message when violated.
+        Produce an error message for a len() comparison against a numeric threshold.
 
         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.
+            arg_node (ast.expr): AST node representing the value passed to `len`.
+            right_node (ast.expr): AST node representing the comparison threshold.
+            op_symbol (str): Comparison operator symbol (e.g., ">", ">=", "<", "<=").
+            var_values (Dict[str, Optional[object]]): Runtime values for variables keyed by name.
+            rule (Rule): Rule helper used to resolve node names and evaluate nodes.
 
         Returns:
-            dict[str, str]: Mapping containing a single error message keyed by variable name.
+            Dict[str, str]: A single-entry mapping from the variable name to a human-readable violation message.
 
         Raises:
-            ValueError: If the argument is invalid or the threshold is not numeric.
+            InvalidLenThresholdError: If the comparison threshold cannot be interpreted as a number.
         """
 
         var_name = rule._get_node_name(arg_node)
@@ -134,7 +216,7 @@ class LenHandler(FunctionHandler):
         # --- 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")
+            raise InvalidLenThresholdError()
         right_value: int | float = raw
 
         if op_symbol == ">":
@@ -171,35 +253,38 @@ class SumHandler(FunctionHandler):
         rule: Rule,
     ) -> Dict[str, str]:
         """
-        Compute the sum of an iterable and compare it to the threshold.
+        Evaluate the sum of the iterable referenced by `arg_node` and produce a descriptive error message when the sum does not satisfy the comparison against the provided 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.
+            arg_node (ast.expr): AST node identifying the iterable variable whose elements will be summed.
+            right_node (ast.expr): AST node representing the threshold value to compare against.
+            op_symbol (str): Comparison operator symbol (e.g., ">", "<=", "==") used to form the message.
+            var_values (Dict[str, Optional[object]]): Mapping of variable names to their evaluated runtime values.
+            rule (Rule): Rule helper used to resolve node names and evaluate AST nodes.
 
         Returns:
-            dict[str, str]: Mapping containing a single error message keyed by variable name.
+            Dict[str, str]: A mapping containing a single entry: the variable name mapped to a human-readable message
+            describing how the computed sum relates to the threshold (too small, too large, or must equal).
 
         Raises:
-            ValueError: If the argument is not a numeric iterable or the threshold is invalid.
+            NonEmptyIterableError: If the referenced iterable is missing or empty.
+            NumericIterableError: If the iterable contains non-numeric elements.
+            InvalidNumericThresholdError: If the threshold evaluated from `right_node` is not numeric.
         """
 
         # 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 isinstance(raw_iter, (list, tuple)) or len(raw_iter) == 0:
+            raise NonEmptyIterableError("sum")
         if not all(isinstance(x, (int, float)) for x in raw_iter):
-            raise ValueError("sum expects an iterable of numbers")
+            raise NumericIterableError("sum")
         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")
+            raise InvalidNumericThresholdError("sum")
         right_value = raw
 
         # Message formulieren
@@ -229,33 +314,35 @@ class MaxHandler(FunctionHandler):
         rule: Rule,
     ) -> Dict[str, str]:
         """
-        Compare the maximum element of an iterable against the provided threshold.
+        Compare the maximum element of an iterable variable against a numeric threshold and produce an error message when the comparison fails.
 
         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.
+            arg_node (ast.expr): AST node identifying the iterable variable passed to `max`.
+            right_node (ast.expr): AST node that evaluates to the numeric threshold to compare against.
+            op_symbol (str): Comparison operator symbol (e.g., ">", ">=", "<", "<=", "==") used to shape the message.
+            var_values (Dict[str, Optional[object]]): Mapping of variable names to their evaluated runtime values.
+            rule (Rule): Rule helper used to resolve node names and evaluate `right_node`.
 
         Returns:
-            dict[str, str]: Mapping containing a single error message keyed by variable name.
+            Dict[str, str]: Single-item mapping from the variable name to a human-readable message describing the max value and the threshold comparison.
 
         Raises:
-            ValueError: If the iterable is empty, non-numeric, or the threshold is invalid.
+            NonEmptyIterableError: If the resolved iterable is not a non-empty list or tuple.
+            NumericIterableError: If any element of the iterable is not an int or float.
+            InvalidNumericThresholdError: If the evaluated threshold is not an int or float.
         """
 
         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")
+            raise NonEmptyIterableError("max")
         if not all(isinstance(x, (int, float)) for x in raw_iter):
-            raise ValueError("max expects an iterable of numbers")
+            raise NumericIterableError("max")
         current = max(raw_iter)
 
         raw = rule._eval_node(right_node)
         if not isinstance(raw, (int, float)):
-            raise ValueError("Invalid arguments for max function")
+            raise InvalidNumericThresholdError("max")
         right_value = raw
 
         if op_symbol in (">", ">="):
@@ -280,33 +367,35 @@ class MinHandler(FunctionHandler):
         rule: Rule,
     ) -> Dict[str, str]:
         """
-        Compare the minimum element of an iterable against the provided threshold.
+        Compare the minimum element of an iterable against a numeric threshold and produce an error message describing the violation.
 
         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.
+            arg_node (ast.expr): AST node for the iterable argument passed to `min`.
+            right_node (ast.expr): AST node for the threshold value to compare against.
+            op_symbol (str): Comparison operator symbol (e.g., ">", ">=", "<", "<=", "==").
+            var_values (Dict[str, Optional[object]]): Mapping of variable names to their evaluated values.
+            rule (Rule): Rule instance used to evaluate AST nodes and obtain variable names.
 
         Returns:
-            dict[str, str]: Mapping containing a single error message keyed by variable name.
+            dict[str, str]: Mapping with the variable name as key and the generated error message as value.
 
         Raises:
-            ValueError: If the iterable is empty, non-numeric, or the threshold is invalid.
+            NonEmptyIterableError: If the iterable is not a non-empty list/tuple.
+            NumericIterableError: If the iterable contains non-numeric elements.
+            InvalidNumericThresholdError: If the evaluated threshold is not numeric.
         """
 
         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")
+            raise NonEmptyIterableError("min")
         if not all(isinstance(x, (int, float)) for x in raw_iter):
-            raise ValueError("min expects an iterable of numbers")
+            raise NumericIterableError("min")
         current = min(raw_iter)
 
         raw = rule._eval_node(right_node)
         if not isinstance(raw, (int, float)):
-            raise ValueError("Invalid arguments for min function")
+            raise InvalidNumericThresholdError("min")
         right_value = raw
 
         if op_symbol in (">", ">="):