edri 2025.11.1rc2__py3-none-any.whl → 2025.11.1rc3__py3-none-any.whl

edri/api/dataclass/api_event.py

@@ -3,7 +3,7 @@ from enum import Enum
 from http import HTTPMethod
 from inspect import isclass
 from logging import getLogger
-from types import NoneType, UnionType
+from types import NoneType, UnionType, GenericAlias
 from typing import Type, get_origin, get_args
 from uuid import UUID
 
@@ -14,7 +14,9 @@ from edri.api.dataclass.file import File
 from edri.api.extensions.url_prefix import PrefixBase
 from edri.config.constant import ApiType
 from edri.dataclass.event import EventHandlingType, _event, Event
+from edri.dataclass.injection import Injection
 from edri.utility.function import camel2snake
+from edri.utility.validation import ListValidation
 
 
 @dataclass
@@ -109,6 +111,13 @@ def api(cls=None, /, *, init=True, repr=True, eq=True, order=False,
                         raise TypeError(f"{item_args[0]} cannot be used as a type for API event")
                 elif item_type not in allowed_types and not hasattr(field.type, "fromisoformat"):
                     raise TypeError(f"{field.type} cannot be used as a type for API event")
+            elif isinstance(field.type, Injection):
+                for validator in field.type.classes:
+                    if validator == ListValidation:
+                        raise TypeError(
+                            "ListValidation must be used as ListValidation[T], "
+                            "e.g. ListValidation[Any] or ListValidation[inject(...)]."
+                        )
 
         http_method = method or dataclass.method
         if http_method is None:

edri/api/handlers/base_handler.py

@@ -1,8 +1,9 @@
 from abc import ABC, abstractmethod
 from dataclasses import fields, MISSING
+from inspect import signature
 from logging import getLogger
-from types import UnionType, NoneType
-from typing import Callable, Type, get_origin, Union, get_args, Any, TypedDict, Literal, TypeAliasType
+from types import UnionType, NoneType, GenericAlias
+from typing import Callable, Type, get_origin, Union, get_args, Any, TypedDict, Literal, TypeAliasType, Iterable
 from urllib.parse import parse_qs, unquote
 
 from edri.dataclass.directive import ResponseDirective
@@ -79,73 +80,228 @@ class BaseHandler[T: ResponseDirective](ABC):
     def convert_type(self, value: Any, annotation: type) -> Any:
         """
         Validates and converts input values to the specified annotation type,
-        supporting basic types, Optional, and lists with type annotations.
+        supporting:
+          - basic types
+          - Optional / Union / |
+          - list / tuple / dict with type args
+          - Literal
+          - list-like subclasses (e.g. ListValidation[int])
+          - Injection of validation classes (e.g. Injection((ListValidation[int],), {...}))
+        """
+        annotation = self._normalize_annotation(annotation)
 
-        Parameters:
-            value: The input value to be validated and converted.
-            annotation: The target type annotation for the conversion.
+        # Any
+        if annotation is Any:
+            return value
 
-        Returns:
-            The converted value if conversion is successful.
+        # Injection (chain of validation classes)
+        if isinstance(annotation, Injection):
+            return self._convert_injection(value, annotation)
 
-        Raises:
-            TypeError: If the value cannot be converted to the specified type.
-        """
+        # Unions / Optional
+        if self._is_union(annotation):
+            return self._convert_union(value, annotation)
+
+        origin = get_origin(annotation)
+
+        # Generics: list, tuple, dict, Literal, ListValidation[int], ...
+        if origin is not None:
+            return self._convert_generic(value, annotation, origin)
+
+        # Non-generic simple types (including bare ListValidation, bool, etc.)
+        return self._convert_simple(value, annotation)
+
+    def _normalize_annotation(self, annotation: type) -> type:
+        """Unwrap TypeAliasType and other simple normalizations."""
         if isinstance(annotation, TypeAliasType):
-            annotation = annotation.__value__
-        if get_origin(annotation) or isinstance(annotation, UnionType):
-            if isinstance(annotation, UnionType) or get_origin(annotation) == Union:
-                annotations = get_args(annotation)
-                if value is None:
-                    if NoneType in annotations:
-                        return None
-                    else:
-                        raise TypeError(f"Value '{value}' cannot be converted to type {annotation}")
-                for annotation in annotations:
-                    try:
-                        return self.convert_type(value, annotation)
-                    except TypeError:
-                        continue
+            return annotation.__value__
+        return annotation
+
+    def _is_union(self, annotation: type) -> bool:
+        """Check if annotation is a Union / Optional / | type."""
+        return isinstance(annotation, UnionType) or get_origin(annotation) is Union
+
+    def _convert_injection(self, value: Any, injection: Injection) -> Any:
+        """
+        Run all validation classes in an Injection.
+
+        Each `cls` in `injection.classes` is:
+          - either a plain validation class (e.g. ListValidation),
+          - or a GenericAlias like ListValidation[int].
+
+        For list-like generics (e.g. ListValidation[int]) we:
+          - convert each element of `value` using the inner type (int here),
+          - then instantiate the validation class with filtered params.
+        """
+        try:
+            for cls in injection.classes:
+                # Determine underlying class and optional inner type
+                item_type = None
+
+                if isinstance(cls, GenericAlias):
+                    origin = get_origin(cls)  # e.g. ListValidation
+                    args = get_args(cls)  # e.g. (int,)
+                    target_cls = origin
+
+                    # list-like validation class: ListValidation[int], MyListValidator[str], ...
+                    if issubclass(origin, list) and args:
+                        item_type = args[0]
                 else:
-                    raise TypeError(f"Value '{value}' cannot be converted to type {annotation}")
-            elif get_origin(annotation) == list and isinstance(value, list):
-                if len(get_args(annotation)) != 1:
-                    raise TypeError("Type of list item must be specified")
-                return [self.convert_type(value, get_args(annotation)[0]) for value in value]
-            elif get_origin(annotation) == tuple and isinstance(value, tuple):
-                return tuple(self.convert_type(v, a) for v, a in zip(value, get_args(annotation)))
-            elif get_origin(annotation) == Literal and isinstance(value, str) and value in get_args(annotation):
-                return value
-            elif get_origin(annotation) == dict and isinstance(value, dict):
-                a_args = get_args(annotation)
-                return {self.convert_type(k, a_args[0]): self.convert_type(v, a_args[1]) for k, v in value.items()}
-            else:
-                raise TypeError(f"Value '{value}' cannot be converted to type {annotation}")
-        else:
-            if annotation is Any:
-                return value
-            elif isinstance(annotation, Injection):
-                try:
-                    for validator in annotation:
-                        value = validator(value)
-                    return value
-                except ValueError:
-                    raise TypeError(f"Value '{value}' cannot be converted to type {annotation}")
-            elif isinstance(value, annotation):
+                    target_cls = cls
+
+                # Filter parameters to those that target_cls.__init__ actually accepts
+                sig = signature(target_cls)
+                param_names = [
+                    p.name for p in sig.parameters.values()
+                    if p.name != "self"
+                ]
+                filtered_params = {
+                    k: v for k, v in injection.parameters.items()
+                    if k in param_names
+                }
+
+                # If this is a list-like validator with an inner type -> convert elements first
+                if item_type is not None:
+                    if (not isinstance(value, Iterable)) or isinstance(value, (str, bytes)):
+                        raise TypeError(
+                            f"Value '{value}' is not a valid iterable for validator {cls}"
+                        )
+
+                    converted_items = [
+                        self.convert_type(item, item_type) for item in value
+                    ]
+                    value = target_cls(converted_items, **filtered_params)
+                else:
+                    # Any other validation class: just feed the (possibly already converted) value
+                    value = target_cls(value, **filtered_params)
+
+            return value
+
+        except ValueError:
+            # Your original contract: map validator ValueError -> TypeError
+            raise TypeError(f"Value '{value}' cannot be converted to type {injection}")
+
+    def _convert_union(self, value: Any, annotation: type) -> Any:
+        """Handle Union/Optional annotations."""
+        annotations = get_args(annotation)
+
+        # Handle Optional[...] where None is allowed
+        if value is None:
+            if NoneType in annotations:
+                return None
+            raise TypeError(f"Value '{value}' cannot be converted to type {annotation}")
+
+        # Try each type in the Union
+        last_error: Exception | None = None
+        for ann in annotations:
+            try:
+                return self.convert_type(value, ann)
+            except TypeError as e:
+                last_error = e
+                continue
+
+        raise TypeError(f"Value '{value}' cannot be converted to type {annotation}") from last_error
+
+    def _convert_generic(self, value: Any, annotation: type, origin: type) -> Any:
+        """
+        Handle generics like:
+          - list[T] and list-like subclasses (ListValidation[T])
+          - tuple[X, Y, ...]
+          - dict[K, V]
+          - Literal[...]
+        """
+        args = get_args(annotation)
+
+        # list[T] and list-like subclasses (e.g. ListValidation[int])
+        if isinstance(origin, type) and issubclass(origin, list):
+            if not isinstance(value, Iterable) or isinstance(value, (str, bytes)):
+                raise TypeError(f"Value '{value}' is not a valid iterable for type {annotation}")
+
+            item_type = args[0] if args else Any
+            converted_items = [self.convert_type(item, item_type) for item in value]
+
+            if origin is list:
+                return converted_items
+
+            # Subclass of list, e.g. ListValidation[int]
+            try:
+                return origin(converted_items)
+            except Exception as e:
+                raise TypeError(
+                    f"Value '{value}' cannot be converted to list-like type {annotation}"
+                ) from e
+
+        # ---- tuple[X, Y, ...] ----
+        if origin is tuple:
+            if not isinstance(value, tuple):
+                raise TypeError(f"Value '{value}' is not a tuple for type {annotation}")
+            return tuple(self.convert_type(v, a) for v, a in zip(value, args))
+
+        # ---- dict[K, V] ----
+        if origin is dict:
+            if not isinstance(value, dict):
+                raise TypeError(f"Value '{value}' is not a dict for type {annotation}")
+            if len(args) != 2:
+                raise TypeError("Key and value types for dict must be specified")
+            key_type, value_type = args
+            return {
+                self.convert_type(k, key_type): self.convert_type(v, value_type)
+                for k, v in value.items()
+            }
+
+        # ---- Literal["a", "b", ...] ----
+        if origin is Literal:
+            literal_values = args
+            if value in literal_values:
                 return value
-            elif isinstance(value, str) and value.lower() == "false" and annotation == bool:
-                return False
+            raise TypeError(
+                f"Value '{value}' is not one of the allowed Literal values {literal_values}"
+            )
+
+        # Unknown generic
+        raise TypeError(f"Value '{value}' cannot be converted to type {annotation}")
+
+    def _convert_simple(self, value: Any, annotation: type) -> Any:
+        """
+        Handle non-generic types: bool, dataclasses, custom classes,
+        and bare list subclasses like ListValidation.
+        """
+        # Already correct type
+        if isinstance(value, annotation):
+            return value
+
+        # Support bare list-like subclasses (e.g. annotation is ListValidation without [T])
+        try:
+            is_list_subclass = isinstance(annotation, type) and issubclass(annotation, list)
+        except TypeError:
+            is_list_subclass = False
+
+        if is_list_subclass and not isinstance(value, (str, bytes)) and isinstance(value, Iterable):
             try:
                 return annotation(value)
-            except Exception:
-                if hasattr(annotation, "fromisoformat"):
-                    try:
-                        return annotation.fromisoformat(value)
-                    except Exception:
-                        raise TypeError(
-                            "Value '%s' cannot be converted from isoformat to type %s" % (value, annotation))
-                else:
-                    raise TypeError(f"Value '{value}' cannot be converted to type {annotation}")
+            except Exception as e:
+                raise TypeError(
+                    f"Value '{value}' cannot be converted to list-like type {annotation}"
+                ) from e
+
+        # Special case: string "false" -> False for bool
+        if isinstance(value, str) and value.lower() == "false" and annotation is bool:
+            return False
+
+        # Normal constructor-based conversion
+        try:
+            return annotation(value)
+        except Exception:
+            # Try fromisoformat if available (e.g., datetime, date)
+            if hasattr(annotation, "fromisoformat"):
+                try:
+                    return annotation.fromisoformat(value)
+                except Exception:
+                    raise TypeError(
+                        "Value '%s' cannot be converted from isoformat to type %s"
+                        % (value, annotation)
+                    )
+            raise TypeError(f"Value '{value}' cannot be converted to type {annotation}")
 
     @abstractmethod
     def handle_directives(self, directives: list[ResponseDirective]) -> ...:

edri/dataclass/injection.py

@@ -1,5 +1,6 @@
 from inspect import signature
-from typing import Any, Type
+from types import GenericAlias
+from typing import Any, Type, get_origin
 
 
 class Injection:
@@ -32,7 +33,10 @@ class Injection:
         # Create the callable on demand when iterating
         for cls in self.classes:
             # Get the signature of the __init__ method of the class
-            sig = signature(cls)
+            if isinstance(cls, GenericAlias):
+                sig = signature(get_origin(cls))
+            else:
+                sig = signature(cls)
             # Extract parameter names from the signature
             param_names: list[str] = [param.name for param in sig.parameters.values() if param.name != 'self']
 

edri/utility/validation.py

@@ -1,6 +1,6 @@
 from datetime import date, datetime, time
 from re import Pattern
-from typing import Self
+from typing import Self, Iterable, Any
 
 
 class StringValidation(str):
@@ -222,3 +222,44 @@ class DateTimeValidation(datetime):
             raise ValueError(f"Datetime '{instance}' is later than maximum allowed '{maximum_datetime}'")
 
         return instance
+
+
+class ListValidation(list):
+    """
+    A list type that performs validation on initialization.
+
+    This class validates the list against optional constraints:
+    - Minimum allowed length.
+    - Maximum allowed length.
+
+    Args:
+        iterable (Iterable, optional): Values to initialize the list with.
+        minimum_length (int, optional): The smallest allowed list length.
+        maximum_length (int, optional): The largest allowed list length.
+
+    Raises:
+        ValueError: If the list length is outside the allowed bounds.
+
+    Example:
+        >>> ListValidation([1, 2, 3], minimum_length=2)
+        [1, 2, 3]
+        >>> ListValidation([1, 2, 3], maximum_length=2)
+        ValueError: List length '3' is greater than maximum allowed '2'
+    """
+
+    def __init__(self, iterable: Iterable[Any] = (), /, *, minimum_length: int | None = None,
+                maximum_length: int | None = None):
+
+        super().__init__(iterable)
+
+        length = len(self)
+
+        if minimum_length is not None and length < minimum_length:
+            raise ValueError(
+                f"List length '{length}' is smaller than minimum allowed '{minimum_length}'"
+            )
+
+        if maximum_length is not None and length > maximum_length:
+            raise ValueError(
+                f"List length '{length}' is greater than maximum allowed '{maximum_length}'"
+            )

{edri-2025.11.1rc2.dist-info → edri-2025.11.1rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edri
-Version: 2025.11.1rc2
+Version: 2025.11.1rc3
 Summary: Event Driven Routing Infrastructure
 Author: Marek Olšan
 Author-email: marek.olsan@gmail.com

{edri-2025.11.1rc2.dist-info → edri-2025.11.1rc3.dist-info}/RECORD

@@ -13,14 +13,14 @@ edri/api/broker.py,sha256=6O-B2Io7WF9KPXJCXsCzcyxpwjieIx5vqR06cSEi1oI,37276
 edri/api/listener.py,sha256=QaBlrlWH8j5OsD0mFMeTd95eP2nq7J-B6FCPL9OtFac,20289
 edri/api/middleware.py,sha256=6_x55swthVDczT-fu_1ufY1cDsHTZ04jMx6J6xfjbsM,5483
 edri/api/dataclass/__init__.py,sha256=8Y-zcaJtzMdALnNG7M9jsCaB1qAJKM8Ld3h9MDajYjA,292
-edri/api/dataclass/api_event.py,sha256=NzS-BCw9DYy3QGlLJVDmL7RyJ0yH8stKcV_3io6sa3w,6085
+edri/api/dataclass/api_event.py,sha256=vAP5JOqlrg3XBZtKd_a721dPSKa2N1NlMtebD_kpP2Q,6589
 edri/api/dataclass/client.py,sha256=ctc2G4mXJR2wUSujANudT3LqxW7qxk_YkpM_TEXD0tM,216
 edri/api/dataclass/file.py,sha256=OJfJlrCTjSnzCF8yFVnxr8rGeL0l08WVMsXJx00S4qc,225
 edri/api/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 edri/api/extensions/url_extension.py,sha256=rZKumjR7J6pDTiSLIZf8IzxGgDZP7p2g0Kgs0USug_U,1971
 edri/api/extensions/url_prefix.py,sha256=kNI6g5ZlW0w-J_IMacYLco1EQvmTtMJyEkN6-SK1wC0,491
 edri/api/handlers/__init__.py,sha256=MI6OGDf1rM8jf_uCKK_JYeOGMts62CNy10BwwNlG0Tk,200
-edri/api/handlers/base_handler.py,sha256=iuVXOmWeCB1ZgLIpq_1QCtAvB7QL1NhPdx064NC2b50,7529
+edri/api/handlers/base_handler.py,sha256=wENi5nfXaz2heyypzN8ikbN0ucPGxyRMcnxCpD9_o9Q,13151
 edri/api/handlers/html_handler.py,sha256=OprcTg1IQDI7eBK-_oHqA60P1H30LA9xIQpD7iV-Neg,7464
 edri/api/handlers/http_handler.py,sha256=Il16LpIMjSreUXohn4c2R79Bx9mKqz7a08LfTVvPwws,35567
 edri/api/handlers/rest_handler.py,sha256=GAG5lVTsRMCf9IUmYb_pokxyPcOfbnKZ2p3jxfy_-Dw,3300
@@ -36,7 +36,7 @@ edri/config/setting.py,sha256=-6_BDFM-RdxIenYhE1Ykm8uGL73YhYUYbdz5YmI08xo,1833
 edri/dataclass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 edri/dataclass/event.py,sha256=3XwbS_8Nst0V5D6vQ0FYhrX5rx6KfLGd3-9ba71xUMQ,9866
 edri/dataclass/health_checker.py,sha256=62H5wGUtOhql3acPwFtMhpGKPUTmFwWQ4hlqIn6tjfo,1784
-edri/dataclass/injection.py,sha256=3bZIGQLKzsO7zv2pD1Wq0Mc4NfwsZ--wHBcHZxfcIPU,3394
+edri/dataclass/injection.py,sha256=C-VzC64FNhMvnLxkGBhgc-Kma2vPIvnRUyPEpyIE-h8,3554
 edri/dataclass/response.py,sha256=VBMmVdna1IOKC5YGBXor6AayYOoiEYb9xx_RZ3bpKnw,3867
 edri/dataclass/directive/__init__.py,sha256=nfvsh1BmxhACW7Q8gnwy7y3l3_cI1P0k2WP0jV5RJhI,608
 edri/dataclass/directive/base.py,sha256=2ghQpv1bGcNHYEMA0nyWGumIplXBzj9cPQ34aJ7uVr0,296
@@ -112,7 +112,7 @@ edri/utility/queue.py,sha256=xBbeu1DT3Krdxni0YABk7gDZ5fLQL9eX-H3U-1jSqag,3628
 edri/utility/shared_memory_pipe.py,sha256=kmtd-1999s-cUVThxXVtw4N-rp_WgrHtl-h4hhEliXA,6396
 edri/utility/storage.py,sha256=AbZwtj8py0OBy3dM5C0fJ97uV88TERZO79heEmyE9Yk,3781
 edri/utility/transformation.py,sha256=4FeRNav-ifxuqgwq9ys3G5WtMzUAC3_2B3tnFhMENho,1450
-edri/utility/validation.py,sha256=bLFgfBLc_nu8tK3-imS2pLdd_IOh-uR7CHjV_r6QodY,8225
+edri/utility/validation.py,sha256=V4EYvuDRsuVgfQTUSF-109O7tDtnNA78tsT231oeST4,9624
 edri/utility/watcher.py,sha256=9nwU-h6B_QCd02-z-2-Hvf6huro8B9yVcZAepoFtXQ4,4623
 edri/utility/manager/__init__.py,sha256=bNyqET60wyq-QFmNwk52UKRweK5lYTDH_TF2UgS6enk,73
 edri/utility/manager/scheduler.py,sha256=3wRPph-FGNrVMN3TG7SvZ_PDW8mNK7UdM3PnjI_QTH8,11624
@@ -156,7 +156,7 @@ tests/utility/test_validation.py,sha256=OEM9hGzlFoSvZdwf5_pyH-Xg9ISxw0QJFbgMaDP8
 tests/utility/manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/utility/manager/test_scheduler.py,sha256=sROffYvSOaWsYQxQGTy6l9Mn_qeNPRmJoXLVPKU3XNY,9153
 tests/utility/manager/test_store.py,sha256=xlo1JUsPLIhPJyQn7AXldAgWDo_O8ba2ns25TEaaGdQ,2821
-edri-2025.11.1rc2.dist-info/METADATA,sha256=Znv_9pH-YVrYGlhn9lN31KKpT-fSrrOkMj2sg4La034,8346
-edri-2025.11.1rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-edri-2025.11.1rc2.dist-info/top_level.txt,sha256=himES6JgPlx4Zt8aDrQEj2fxAd7IDD6MBOsiNZkzKHQ,11
-edri-2025.11.1rc2.dist-info/RECORD,,
+edri-2025.11.1rc3.dist-info/METADATA,sha256=d0LFmSlm3cYRVlw79-cj59_Pa33mweHzTS7Ox063e4Y,8346
+edri-2025.11.1rc3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+edri-2025.11.1rc3.dist-info/top_level.txt,sha256=himES6JgPlx4Zt8aDrQEj2fxAd7IDD6MBOsiNZkzKHQ,11
+edri-2025.11.1rc3.dist-info/RECORD,,