edri 2025.12.3__tar.gz → 2025.12.3rc1__tar.gz

{edri-2025.12.3 → edri-2025.12.3rc1}/PKG-INFO

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

{edri-2025.12.3 → edri-2025.12.3rc1}/edri/abstract/manager/manager_base.py

@@ -634,7 +634,7 @@ class ManagerBase(ABC, Process, metaclass=ManagerBaseMeta):
                 if cache_key:
                     etag = self._cache.tag(cache_key)
                     method = self._cache_methods[event.__class__]
-                    if etag and hasattr(event, "etag") and event.etag and f"\"{etag}\"" in event.etag and method == HTTPMethod.GET:
+                    if etag and hasattr(event, "etag") and event.etag and etag in event.etag and method == HTTPMethod.GET:
                         event.response.add_directive(NotModifiedResponseDirective())
                         self.router_queue.put(event)
                         return
@@ -646,7 +646,7 @@ class ManagerBase(ABC, Process, metaclass=ManagerBaseMeta):
                         if event.response.get_status() == ResponseStatus.OK and method in (HTTPMethod.POST, HTTPMethod.PUT, HTTPMethod.PATCH, HTTPMethod.DELETE):
                             self._cache.renew(cache_key)
                         else:
-                            event.response.add_directive(HeaderResponseDirective(name="ETag", value=f"\"{etag}\""))
+                            event.response.add_directive(HeaderResponseDirective(name="ETag", value=etag))
                             event.response.add_directive(HeaderResponseDirective(name="Cache-Control", value=API_CACHE_CONTROL))
                             event.response.add_directive(HeaderResponseDirective(name="Vary", value=self._cache_vary))
                     self.router_queue.put(event)

{edri-2025.12.3 → edri-2025.12.3rc1}/edri/api/dataclass/__init__.py

@@ -1,6 +1,5 @@
 from .file import File
 from .client import Client
-from .range import RangeSpec, RangeValue
 
 class Cookie:
     def __init__(self, name: str):

{edri-2025.12.3 → edri-2025.12.3rc1}/edri/api/dataclass/file.py

@@ -9,4 +9,3 @@ class File:
     file_name: str | None
     mime_type: str
     path: Path | SharedMemoryPipe
-    fingerprint: str | None = None

{edri-2025.12.3 → edri-2025.12.3rc1}/edri/api/handlers/http_handler.py

@@ -9,7 +9,7 @@ from json import loads, JSONDecodeError
 from logging import warning
 from mimetypes import guess_type
 from pathlib import Path
-from re import compile, escape, sub, VERBOSE, split
+from re import compile, escape, sub
 from tempfile import NamedTemporaryFile, TemporaryFile
 from types import NoneType
 from typing import Callable, Type, Pattern, Any, Unpack, TypedDict, NotRequired, AnyStr, BinaryIO, Self, Literal, get_args, get_origin, \
@@ -20,7 +20,7 @@ from uuid import UUID
 from multipart import MultipartParser
 
 from edri.api import Headers
-from edri.api.dataclass import File, RangeSpec, RangeValue
+from edri.api.dataclass import File
 from edri.api.dataclass.api_event import api_events
 from edri.api.handlers import BaseHandler
 from edri.api.handlers.base_handler import BaseDirectiveHandlerDict
@@ -30,14 +30,15 @@ from edri.config.setting import MAX_BODY_SIZE, ASSETS_PATH, UPLOAD_FILES_PREFIX,
 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, NotModifiedResponseDirective, \
-    ServiceUnavailableResponseDirective, PartialContentResponseDirective, RangeNotSatisfiableResponseDirective
+    NotFoundResponseDirective, \
+    ConflictResponseDirective, HeaderResponseDirective, UnprocessableContentResponseDirective, \
+    BadRequestResponseDirective, NotModifiedResponseDirective, ServiceUnavailableResponseDirective
 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 StringValidator
 
 
 class EventTypesExtensionsDict(TypedDict):
@@ -235,23 +236,6 @@ class URLNode:
 
         return repr_str
 
-_RANGE_VALUE_RE = compile(
-    r"""
-    ^\s*
-    (?P<unit>[A-Za-z][A-Za-z0-9._-]*)     # range-unit
-    \s*=\s*
-    (?P<specs>.+?)                       # comma-separated specs (validated below)
-    \s*$
-    """,
-    VERBOSE,
-)
-
-# "bytes" token grammar: 1) first-last / first-   OR   2) -suffix
-_BYTES_SPEC_RE = compile(
-    r"^\s*(?:(?P<first>\d+)\s*-\s*(?P<last>\d*)|-\s*(?P<suffix>\d+))\s*$"
-)
-
-
 
 class HTTPHandler[T: HTTPResponseDirective](BaseHandler, ABC):
     _directive_handlers: dict[Type[T], HTTPDirectiveHandlerDict[T]] = {
@@ -292,12 +276,6 @@ class HTTPHandler[T: HTTPResponseDirective](BaseHandler, ABC):
         },
         ServiceUnavailableResponseDirective: {
             "status": HTTPStatus.SERVICE_UNAVAILABLE,
-        },
-        PartialContentResponseDirective: {
-            "status": HTTPStatus.PARTIAL_CONTENT,
-        },
-        RangeNotSatisfiableResponseDirective: {
-            "status": HTTPStatus.REQUESTED_RANGE_NOT_SATISFIABLE,
         }
     }
 
@@ -640,39 +618,16 @@ class HTTPHandler[T: HTTPResponseDirective](BaseHandler, ABC):
 
     async def response_file(self, event: Event, *args, **kwargs: Unpack[ResponseKW]):
         headers = kwargs["headers"]
-        request_headers = kwargs["request_headers"]
         file = event.response.file
 
         headers["Content-Type"].append(file.mime_type)
         headers["Content-Disposition"].append(f"attachment;filename*=UTF-8''{quote(file.file_name, encoding='utf-8')}")
 
         if isinstance(file.path, Path):
-            file_size = file.path.stat().st_size
-            headers["Accept-Ranges"].append("bytes")
-            if file.fingerprint:
-                headers["ETag"].append(f"\"{file.fingerprint}\"")
+            headers["Content-Length"].append(str(file.path.lstat().st_size))
             try:
                 with file.path.open("rb") as data:
-                    # Only honor Range if If-Range matches current ETag (and we actually got a Range header).
-                    if request_headers["If-Range"] == headers["ETag"] and "range" in request_headers and len(request_headers["range"]) == 1:
-                        try:
-                            bytes_ranges = await self.parse_range_values(request_headers["Range"][0])
-
-                            # Handle only the first range spec (multipart/byteranges is a separate response type).
-                            if bytes_ranges.specs:
-                                spec = bytes_ranges.specs[0]
-                                start, end = self.compute_range(spec, file_size)
-                                data.seek(start)
-                                headers["Content-Length"].append(str(bytes_ranges.content_length(start, end)))
-                                headers["Content-Range"].append(bytes_ranges.content_range(file_size, start, end))
-                                return await self.response_file_path(data, headers, max_bytes=(end - start) + 1, http_status=HTTPStatus.REQUESTED_RANGE_NOT_SATISFIABLE)
-
-                        except Exception as e:
-                            self.logger.warning("Wrong Range header", exc_info=e)
-
-                    headers["Content-Length"].append(str(file_size))
-                    return await self.response_file_path(data, headers)
-
+                    await self.response_file_path(data, headers)
             except FileNotFoundError as e:
                 await self.response_error(HTTPStatus.INTERNAL_SERVER_ERROR, {
                     "reasons": [{
@@ -725,60 +680,22 @@ class HTTPHandler[T: HTTPResponseDirective](BaseHandler, ABC):
                     }]
                 })
 
-    async def response_file_path(
-            self,
-            file: BinaryIO,
-            headers: "NormalizedDefaultDict[str, Headers]",
-            *,
-            max_bytes: int | None = None,
-            http_status: HTTPStatus = HTTPStatus.OK,
-    ):
+    async def response_file_path(self, file: BinaryIO, headers: NormalizedDefaultDict[str, Headers]):
         try:
             await self.send({
-                "type": "http.response.start",
-                "status": http_status,
-                "headers": self.get_headers_binary(headers),
+                'type': 'http.response.start',
+                'status': HTTPStatus.OK,
+                'headers': self.get_headers_binary(headers),
             })
-
             chunk_size = 1024 * 1024
-            remaining = max_bytes
-
-            def read_size() -> int:
-                if remaining is None:
-                    return chunk_size
-                return min(chunk_size, remaining)
-
-            sent_any = False
-
-            # Lookahead loop so we always send a final more_body=False
-            if remaining == 0:
-                await self.send({"type": "http.response.body", "body": b"", "more_body": False})
-                return
-
-            data = file.read(read_size())
-            while data:
-                sent_any = True
-
-                if remaining is not None:
-                    remaining -= len(data)
-                    if remaining <= 0:
-                        await self.send({"type": "http.response.body", "body": data, "more_body": False})
-                        return
-
-                next_data = file.read(read_size())
+            while data := file.read(chunk_size):
                 await self.send({
-                    "type": "http.response.body",
-                    "body": data,
-                    "more_body": bool(next_data),
+                    'type': 'http.response.body',
+                    'body': data,
+                    'more_body': len(data) == chunk_size
                 })
-                data = next_data
-
-            if not sent_any:
-                await self.send({"type": "http.response.body", "body": b"", "more_body": False})
-
         except Exception as e:
             self.logger.error(e, exc_info=e)
-            raise
 
     async def response_file_shared_memory_pipe(self, smp: SharedMemoryPipe, headers: NormalizedDefaultDict[str, Headers]):
         try:
@@ -904,98 +821,3 @@ class HTTPHandler[T: HTTPResponseDirective](BaseHandler, ABC):
                 return super().convert_type(value.value, annotation)
 
         return super().convert_type(value, annotation)
-
-    @staticmethod
-    async def parse_range_values(value: str, *, max_ranges: int = 100, max_digits: int = 50) -> RangeValue:
-        """
-        Parse + validate a Range header *value* (field-value only), e.g.:
-          "bytes=0-99,200-299"
-          "bytes=9500-"
-          "bytes=-500"
-          "items=1-10"  (prepared for other units -> currently throws)
-
-        Returns RangeValue(unit, specs). Raises ValueError on any validation failure.
-        """
-        if value is None:
-            raise ValueError("Range value is None")
-
-        m = _RANGE_VALUE_RE.match(value)
-        if not m:
-            raise ValueError("Invalid Range value (expected <unit>=<spec>[,<spec>...])")
-
-        unit = m.group("unit").lower()
-        specs_blob = m.group("specs").strip()
-        if not specs_blob:
-            raise ValueError("Range value missing specs after '='")
-
-        parts = split(r"\s*,\s*", specs_blob)
-        if any(p == "" for p in parts):
-            raise ValueError("Invalid Range value (empty range-spec)")
-        if len(parts) > max_ranges:
-            raise ValueError(f"Too many ranges: {len(parts)} > {max_ranges}")
-
-        def to_int(s: str) -> int:
-            s = s.strip()
-            if not s.isdigit():
-                raise ValueError(f"Invalid numeric value: {s!r}")
-            if len(s) > max_digits:
-                raise ValueError(f"Numeric value too large (>{max_digits} digits)")
-            return int(s)
-
-        if unit != "bytes":
-            # Prepared for other units: we parse the unit name, but we don't implement its grammar yet.
-            raise ValueError(f"Unsupported range unit: {unit!r}")
-
-        parsed: list[RangeSpec] = []
-        for p in parts:
-            sm = _BYTES_SPEC_RE.match(p)
-            if not sm:
-                raise ValueError(f"Invalid bytes range-spec: {p!r}")
-
-            suffix = sm.group("suffix")
-            if suffix is not None:
-                # "-0" is syntactically valid; satisfiable vs unsatisfiable needs representation length.
-                parsed.append(RangeSpec(suffix_length=to_int(suffix)))
-                continue
-
-            first = to_int(sm.group("first"))
-            last_s = (sm.group("last") or "").strip()
-            if last_s == "":
-                parsed.append(RangeSpec(first=first, last=None))
-            else:
-                last = to_int(last_s)
-                if last < first:
-                    raise ValueError(f"Invalid bytes range-spec (last < first): {p!r}")
-                parsed.append(RangeSpec(first=first, last=last))
-
-        return RangeValue(unit=unit, specs=tuple(parsed))
-
-    @staticmethod
-    def compute_range(spec: RangeSpec, file_size: int) -> tuple[int, int]:
-        """
-        Compute (start, end) inclusive for a single byte-range spec.
-        """
-
-        if spec.suffix_length:
-            if spec.suffix_length <= 0:
-                raise ValueError("Invalid suffix length")
-            start = max(file_size - spec.suffix_length, 0)
-            end = file_size - 1
-
-        # Open-ended range: bytes=START-
-        elif spec.first is not None and spec.last is None:
-            start = spec.first
-            end = file_size - 1
-
-        # Normal range: bytes=START-END
-        elif spec.first is not None and spec.last is not None:
-            start = spec.first
-            end = min(spec.last, file_size - 1)
-
-        else:
-            raise ValueError("Invalid range spec")
-
-        if start < 0 or start >= file_size or end < start:
-            raise ValueError("Range out of bounds")
-
-        return start, end

{edri-2025.12.3 → edri-2025.12.3rc1}/edri/api/listener.py

@@ -267,7 +267,7 @@ class Listener(Process):
             status, headers = handler.handle_directives(event_response.get_response().get_directives())
             if status.is_success:
                 if event_response.get_response().is_file_only:
-                    await handler.response_file(event_response, headers=headers, request_headers=handler.headers)
+                    await handler.response_file(event_response, headers=headers)
                 else:
                     await handler.response(status, event_response, headers=headers)
             elif status.is_redirection:

{edri-2025.12.3 → edri-2025.12.3rc1}/edri/dataclass/directive/http.py

@@ -80,8 +80,3 @@ class ServiceUnavailableResponseDirective(HTTPResponseDirective):
 @dataclass
 class PartialContentResponseDirective(HTTPResponseDirective):
     pass
-
-
-@dataclass
-class RangeNotSatisfiableResponseDirective(HTTPResponseDirective):
-    pass

{edri-2025.12.3 → edri-2025.12.3rc1}/edri.egg-info/PKG-INFO

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

{edri-2025.12.3 → edri-2025.12.3rc1}/edri.egg-info/SOURCES.txt

@@ -23,7 +23,6 @@ edri/api/dataclass/__init__.py
 edri/api/dataclass/api_event.py
 edri/api/dataclass/client.py
 edri/api/dataclass/file.py
-edri/api/dataclass/range.py
 edri/api/extensions/__init__.py
 edri/api/extensions/url_extension.py
 edri/api/extensions/url_prefix.py

{edri-2025.12.3 → edri-2025.12.3rc1}/setup.py

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

edri-2025.12.3/edri/api/dataclass/range.py

@@ -1,71 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass(slots=True)
-class RangeSpec:
-    first: int | None = None
-    last: int | None = None
-    suffix_length: int | None = None
-
-
-@dataclass(slots=True)
-class RangeValue:
-    unit: str
-    specs: tuple[RangeSpec, ...]
-
-    def content_range(
-        self,
-        full_length: int | None,
-        start: int,
-        end: int,
-    ) -> str:
-        """
-        Build Content-Range for a *single* range response (206).
-
-        Args:
-          full_length: total representation length, or None if unknown.
-          start, end: inclusive byte positions of the payload actually served.
-        Returns:
-          e.g. "bytes 0-99/1234" or "bytes 0-99/*"
-        """
-        if self.unit != "bytes":
-            raise ValueError(f"Content-Range generation not implemented for unit={self.unit!r}")
-
-        if start < 0 or end < start:
-            raise ValueError("Invalid start/end")
-
-        if full_length is not None:
-            if full_length < 0:
-                raise ValueError("full_length must be >= 0")
-            # When length known, served range must be within it (end inclusive)
-            if full_length == 0:
-                raise ValueError("Cannot serve a non-empty range for full_length=0")
-            if end >= full_length:
-                raise ValueError("end must be < full_length when full_length is known")
-
-            return f"bytes {start}-{end}/{full_length}"
-
-        return f"bytes {start}-{end}/*"
-
-    @staticmethod
-    def content_range_unsatisfied(*, unit: str = "bytes", full_length: int) -> str:
-        """
-        Build Content-Range for 416 Range Not Satisfiable.
-
-        Returns:
-          e.g. "bytes */1234"
-        """
-        if full_length < 0:
-            raise ValueError("full_length must be >= 0")
-        return f"{unit} */{full_length}"
-
-
-    def content_length(self, start: int, end: int) -> int:
-        """
-        Content-Length for a *single* resolved range body (206).
-        """
-        if self.unit != "bytes":
-            raise ValueError(f"Content-Length not implemented for unit={self.unit!r}")
-        if start < 0 or end < start:
-            raise ValueError("Invalid start/end")
-        return (end - start) + 1