edri 2025.11.1rc2__tar.gz → 2025.11.1rc4__tar.gz

{edri-2025.11.1rc2 → edri-2025.11.1rc4}/PKG-INFO

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

{edri-2025.11.1rc2 → edri-2025.11.1rc4}/edri/api/broker.py

@@ -21,8 +21,8 @@ from edri.dataclass.response import ResponseStatus, Response
 from edri.events.api import group, manage, client
 from edri.events.edri.router import HealthCheck, Subscribe
 from edri.utility import Storage
-from edri.utility.validation import StringValidation, IntegerValidation, FloatValidation, DateValidation, \
-    TimeValidation, DateTimeValidation
+from edri.utility.validation import StringValidator, IntegerValidator, FloatValidator, DateValidator, \
+    TimeValidator, DateTimeValidator
 
 
 class TrieNode:
@@ -391,12 +391,12 @@ class Broker(ManagerBase):
 
         def extract_parameters_response(event_cls: Type[Event]) -> tuple[dict[str, Any], dict[str, Any]]:
             VALIDATION_MAP: dict[type, tuple[str, type]] = {
-                StringValidation: ("string", StringValidation.__bases__[0]),
-                IntegerValidation: ("integer", IntegerValidation.__bases__[0]),
-                FloatValidation: ("float", FloatValidation.__bases__[0]),
-                DateValidation: ("date", DateValidation.__bases__[0]),
-                TimeValidation: ("time", TimeValidation.__bases__[0]),
-                DateTimeValidation: ("datetime", DateTimeValidation.__bases__[0]),
+                StringValidator: ("string", StringValidator.__bases__[0]),
+                IntegerValidator: ("integer", IntegerValidator.__bases__[0]),
+                FloatValidator: ("float", FloatValidator.__bases__[0]),
+                DateValidator: ("date", DateValidator.__bases__[0]),
+                TimeValidator: ("time", TimeValidator.__bases__[0]),
+                DateTimeValidator: ("datetime", DateTimeValidator.__bases__[0]),
             }
 
             def resolve_validation(field_type: Injection) -> tuple[str | None, dict[str, Any]]:

{edri-2025.11.1rc2 → edri-2025.11.1rc4}/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 ListValidator
 
 
 @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 == ListValidator:
+                        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-2025.11.1rc4/edri/api/handlers/base_handler.py

@@ -0,0 +1,327 @@
+from abc import ABC, abstractmethod
+from dataclasses import fields, MISSING
+from inspect import signature
+from logging import getLogger
+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
+from edri.dataclass.event import Event
+from edri.dataclass.injection import Injection
+from edri.utility.function import camel2snake
+
+
+class BaseDirectiveHandlerDict[T](TypedDict):
+    pass
+
+
+class BaseHandler[T: ResponseDirective](ABC):
+    _directive_handlers: dict[Type[T], BaseDirectiveHandlerDict[T]] = {}
+
+    def __init__(self,
+                 scope: dict,
+                 receive: Callable,
+                 send: Callable):
+        super().__init__()
+        self.send = send
+        self.scope = scope
+        self.receive = receive
+        self.scope = scope
+        self.logger = getLogger(__name__)
+
+        self.parameters: dict[str, Any] = self.parse_url_parameters()
+
+    @classmethod
+    def directive_handlers(cls) -> dict[Type[ResponseDirective], BaseDirectiveHandlerDict]:
+        handlers = {}
+        for class_obj in reversed(cls.mro()):
+            if hasattr(class_obj, "_directive_handlers"):
+                # noinspection PyProtectedMember
+                handlers.update(class_obj._directive_handlers)
+        return handlers
+
+    @abstractmethod
+    async def response(self, status: Any, data: Any, *args, **kwargs) -> None:
+        pass
+
+    @abstractmethod
+    async def response_error(self, status: Any, response: Any, *args, **kwargs) -> None:
+        pass
+
+    def check_parameters(self, event_constructor: Type[Event]) -> None:
+        check_parameters = {}
+        for name, annotation in ((f.name, f.type) for f in fields(event_constructor)):
+            if name.startswith("_") or name == "method" or name == "response":
+                continue
+            try:
+                value = self.parameters.pop(name)
+            except KeyError:
+                raise ValueError(f"Missing value for parameter {name}")
+            try:
+                value = self.convert_type(value, annotation)
+            except TypeError:
+                raise ValueError(f"Wrong type {type(value)} for {name}:{annotation}")
+            except Exception:
+                raise ValueError("Unknown error during type checking")
+            check_parameters[name] = value
+        if self.parameters:
+            raise ValueError(f"Unknown parameters: {self.parameters}")
+        self.parameters = check_parameters
+
+    def create_event(self, event_constructor: Type[Event]) -> Event:
+        self.insert_default_parameters(event_constructor)
+        self.check_parameters(event_constructor)
+        event = event_constructor(**self.parameters)
+        event._timing.stamp(self.__class__.__name__, "Created")
+        return event
+
+    def convert_type(self, value: Any, annotation: type) -> Any:
+        """
+        Validates and converts input values to the specified annotation type,
+        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)
+
+        # Any
+        if annotation is Any:
+            return value
+
+        # Injection (chain of validation classes)
+        if isinstance(annotation, Injection):
+            return self._convert_injection(value, annotation)
+
+        # 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):
+            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:
+                    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
+            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 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]) -> ...:
+        pass
+
+    def insert_default_parameters(self, event_constructor: Type[Event]) -> None:
+        for field in fields(event_constructor):
+            if field.name.startswith("_") or field.name in ("response", "method"):
+                continue
+            if field.name in self.parameters:
+                continue
+            if field.default is not MISSING:
+                self.parameters[field.name] = field.default
+                continue
+            if field.default_factory is not MISSING:
+                self.parameters[field.name] = field.default_factory()
+                continue
+
+    def parse_url_parameters(self) -> dict[str, Any]:
+        url_parameters = parse_qs(unquote(self.scope["query_string"].decode()), keep_blank_values=True)
+        return {
+            camel2snake(key.strip("[]")): value if key.endswith("[]") else value[-1] for key, value in
+            url_parameters.items()
+        }

{edri-2025.11.1rc2 → edri-2025.11.1rc4}/edri/api/handlers/http_handler.py

@@ -29,14 +29,16 @@ from edri.config.setting import MAX_BODY_SIZE, ASSETS_PATH, UPLOAD_FILES_PREFIX,
     CORS_MAX_AGE, UPLOAD_FILES_PATH
 from edri.dataclass.directive import HTTPResponseDirective, ResponseDirective
 from edri.dataclass.directive.base import InternalServerErrorResponseDirective, UnauthorizedResponseDirective
-from edri.dataclass.directive.http import CookieResponseDirective, AccessDeniedResponseDirective, NotFoundResponseDirective, \
-    ConflictResponseDirective, HeaderResponseDirective, UnprocessableContentResponseDirective, BadRequestResponseDirective
+from edri.dataclass.directive.http import CookieResponseDirective, AccessDeniedResponseDirective, \
+    NotFoundResponseDirective, \
+    ConflictResponseDirective, HeaderResponseDirective, UnprocessableContentResponseDirective, \
+    BadRequestResponseDirective, NotModifiedResponseDirective
 from edri.dataclass.event import Event
 from edri.dataclass.injection import Injection
 from edri.utility import NormalizedDefaultDict
 from edri.utility.function import camel2snake
 from edri.utility.shared_memory_pipe import SharedMemoryPipe
-from edri.utility.validation import StringValidation
+from edri.utility.validation import StringValidator
 
 
 class EventTypesExtensionsDict(TypedDict):
@@ -194,7 +196,7 @@ class URLNode:
                             raise TypeError("All classes in 'inject' must have the same base class when used as URL parameters.")
                         break  # Only check the first valid base class regex
 
-            if vot is StringValidation:
+            if vot is StringValidator:
                 regex = type_.parameters.get("regex", None)
                 if regex is not None:
                     regex_function = lambda name, _: rf"^(?P<{escape(name)}>{sub(r'^\^(.*)\$$', r'\1', regex.pattern)})$"
@@ -271,6 +273,9 @@ class HTTPHandler[T: HTTPResponseDirective](BaseHandler, ABC):
         },
         BadRequestResponseDirective: {
             "status": HTTPStatus.BAD_REQUEST,
+        },
+        NotModifiedResponseDirective: {
+            "status": HTTPStatus.NOT_MODIFIED,
         }
     }
 
@@ -716,6 +721,23 @@ class HTTPHandler[T: HTTPResponseDirective](BaseHandler, ABC):
                     })
         except Exception as e:
             self.logger.error(e, exc_info=e)
+
+    async def response_headers(self, status: HTTPStatus, *args, **kwargs: Unpack[ResponseKW]):
+        headers = kwargs["headers"]
+        if headers is None:
+            headers = NormalizedDefaultDict(list)
+        await self.send({
+            'type': 'http.response.start',
+            'status': status,
+            'headers': self.get_headers_binary(headers),
+        })
+
+        await self.send({
+            'type': 'http.response.body',
+            'body': b"",
+            'more_body': False
+        })
+
     def get_event_constructors(self) -> tuple[dict[HTTPMethod, Type[Event]], dict[str, Any]]:
         return self.url_root.find_methods(self.scope["path"].lower())
 

{edri-2025.11.1rc2 → edri-2025.11.1rc4}/edri/api/listener.py

@@ -270,6 +270,8 @@ class Listener(Process):
                     await handler.response_file(event_response, headers=headers)
                 else:
                     await handler.response(status, event_response, headers=headers)
+            elif status.is_redirection:
+                await handler.response_headers(status, headers=headers)
             else:
                 await handler.response_error(status, event_response, headers=headers)
             self.unregister(pipe, event._api)

{edri-2025.11.1rc2 → edri-2025.11.1rc4}/edri/dataclass/directive/http.py

@@ -65,3 +65,7 @@ class UnprocessableContentResponseDirective(HTTPResponseDirective):
 @dataclass
 class BadRequestResponseDirective(HTTPResponseDirective):
     message: str | None = None
+
+@dataclass
+class NotModifiedResponseDirective(HTTPResponseDirective):
+    pass

{edri-2025.11.1rc2 → edri-2025.11.1rc4}/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-2025.11.1rc2 → edri-2025.11.1rc4}/edri/utility/validation.py

@@ -1,9 +1,9 @@
 from datetime import date, datetime, time
 from re import Pattern
-from typing import Self
+from typing import Self, Iterable, Any
 
 
-class StringValidation(str):
+class StringValidator(str):
     """
     A string type that performs validation on initialization.
 
@@ -21,7 +21,7 @@ class StringValidation(str):
                     or its length is outside the allowed bounds.
 
     Example:
-        >>> StringValidation("hello", minimum_length=3, maximum_length=10)
+        >>> StringValidator("hello", minimum_length=3, maximum_length=10)
         'hello'
     """
 
@@ -49,7 +49,7 @@ class StringValidation(str):
         return (v[:max_len] + "…") if len(v) > max_len else v
 
 
-class IntegerValidation(int):
+class IntegerValidator(int):
     """
     An integer type that performs validation on initialization.
 
@@ -65,7 +65,7 @@ class IntegerValidation(int):
         ValueError: If the value is less than `minimum` or greater than `maximum`.
 
     Example:
-        >>> IntegerValidation(5, minimum=1, maximum=10)
+        >>> IntegerValidator(5, minimum=1, maximum=10)
         5
     """
 
@@ -78,7 +78,7 @@ class IntegerValidation(int):
         return value
 
 
-class FloatValidation(float):
+class FloatValidator(float):
     """
     A float type that performs validation on initialization.
 
@@ -94,7 +94,7 @@ class FloatValidation(float):
         ValueError: If the value is less than `minimum` or greater than `maximum`.
 
     Example:
-        >>> FloatValidation(3.14, minimum=1.0, maximum=5.0)
+        >>> FloatValidator(3.14, minimum=1.0, maximum=5.0)
         3.14
     """
 
@@ -107,7 +107,7 @@ class FloatValidation(float):
         return value
 
 
-class DateValidation(date):
+class DateValidator(date):
     """
     A date type that performs validation on initialization.
 
@@ -126,7 +126,7 @@ class DateValidation(date):
         ValueError: If the date is outside the allowed bounds.
 
     Example:
-        >>> DateValidation(2024, 3, 28, minimum_date=date(2024, 1, 1))
+        >>> DateValidator(2024, 3, 28, minimum_date=date(2024, 1, 1))
         datetime.date(2024, 3, 28)
     """
 
@@ -144,7 +144,7 @@ class DateValidation(date):
         return value
 
 
-class TimeValidation(time):
+class TimeValidator(time):
     """
     A time type that performs validation on initialization.
 
@@ -164,7 +164,7 @@ class TimeValidation(time):
         ValueError: If the time is outside the allowed bounds.
 
     Example:
-        >>> TimeValidation(12, 30, maximum_time=time(20, 0))
+        >>> TimeValidator(12, 30, maximum_time=time(20, 0))
         datetime.time(12, 30)
     """
 
@@ -182,7 +182,7 @@ class TimeValidation(time):
         return value
 
 
-class DateTimeValidation(datetime):
+class DateTimeValidator(datetime):
     """
     A datetime type that performs validation on initialization.
 
@@ -205,7 +205,7 @@ class DateTimeValidation(datetime):
         ValueError: If the datetime is outside the allowed bounds.
 
     Example:
-        >>> DateTimeValidation(2024, 3, 28, 15, 45,
+        >>> DateTimeValidator(2024, 3, 28, 15, 45,
         ...     minimum_datetime=datetime(2024, 3, 1))
         datetime.datetime(2024, 3, 28, 15, 45)
     """
@@ -222,3 +222,44 @@ class DateTimeValidation(datetime):
             raise ValueError(f"Datetime '{instance}' is later than maximum allowed '{maximum_datetime}'")
 
         return instance
+
+
+class ListValidator(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:
+        >>> ListValidator([1, 2, 3], minimum_length=2)
+        [1, 2, 3]
+        >>> ListValidator([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 → edri-2025.11.1rc4}/edri.egg-info/PKG-INFO

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

{edri-2025.11.1rc2 → edri-2025.11.1rc4}/setup.py

@@ -122,7 +122,7 @@ Whether you're building a real-time data processing system, a distributed servic
 
 setup(
     name='edri',
-    version='2025.11.01rc2',
+    version='2025.11.01rc4',
     packages=find_packages(),
     description='Event Driven Routing Infrastructure',
     long_description=long_description,