edri 2025.12.3rc1__py3-none-any.whl → 2025.12.3rc2__py3-none-any.whl

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 etag in event.etag and method == HTTPMethod.GET:
+                    if etag and hasattr(event, "etag") and event.etag and f"\"{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=etag))
+                            event.response.add_directive(HeaderResponseDirective(name="ETag", value=f"\"{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/api/dataclass/__init__.py

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

edri/api/dataclass/file.py

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

edri/api/dataclass/range.py

@@ -0,0 +1,71 @@
+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

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
+from re import compile, escape, sub, VERBOSE, split
 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
+from edri.api.dataclass import File, RangeSpec, RangeValue
 from edri.api.dataclass.api_event import api_events
 from edri.api.handlers import BaseHandler
 from edri.api.handlers.base_handler import BaseDirectiveHandlerDict
@@ -30,15 +30,14 @@ 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
+    NotFoundResponseDirective, ConflictResponseDirective, HeaderResponseDirective, \
+    UnprocessableContentResponseDirective, BadRequestResponseDirective, NotModifiedResponseDirective, \
+    ServiceUnavailableResponseDirective, PartialContentResponseDirective, RangeNotSatisfiableResponseDirective
 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):
@@ -236,6 +235,23 @@ 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]] = {
@@ -276,6 +292,12 @@ class HTTPHandler[T: HTTPResponseDirective](BaseHandler, ABC):
         },
         ServiceUnavailableResponseDirective: {
             "status": HTTPStatus.SERVICE_UNAVAILABLE,
+        },
+        PartialContentResponseDirective: {
+            "status": HTTPStatus.PARTIAL_CONTENT,
+        },
+        RangeNotSatisfiableResponseDirective: {
+            "status": HTTPStatus.REQUESTED_RANGE_NOT_SATISFIABLE,
         }
     }
 
@@ -618,16 +640,39 @@ 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):
-            headers["Content-Length"].append(str(file.path.lstat().st_size))
+            file_size = file.path.stat().st_size
+            headers["Accept-Ranges"].append("bytes")
+            if file.fingerprint:
+                headers["ETag"].append(f"\"{file.fingerprint}\"")
             try:
                 with file.path.open("rb") as data:
-                    await self.response_file_path(data, headers)
+                    # 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)
+
             except FileNotFoundError as e:
                 await self.response_error(HTTPStatus.INTERNAL_SERVER_ERROR, {
                     "reasons": [{
@@ -680,22 +725,60 @@ class HTTPHandler[T: HTTPResponseDirective](BaseHandler, ABC):
                     }]
                 })
 
-    async def response_file_path(self, file: BinaryIO, headers: NormalizedDefaultDict[str, Headers]):
+    async def response_file_path(
+            self,
+            file: BinaryIO,
+            headers: "NormalizedDefaultDict[str, Headers]",
+            *,
+            max_bytes: int | None = None,
+            http_status: HTTPStatus = HTTPStatus.OK,
+    ):
         try:
             await self.send({
-                'type': 'http.response.start',
-                'status': HTTPStatus.OK,
-                'headers': self.get_headers_binary(headers),
+                "type": "http.response.start",
+                "status": http_status,
+                "headers": self.get_headers_binary(headers),
             })
+
             chunk_size = 1024 * 1024
-            while data := file.read(chunk_size):
+            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())
                 await self.send({
-                    'type': 'http.response.body',
-                    'body': data,
-                    'more_body': len(data) == chunk_size
+                    "type": "http.response.body",
+                    "body": data,
+                    "more_body": bool(next_data),
                 })
+                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:
@@ -821,3 +904,98 @@ 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/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)
+                    await handler.response_file(event_response, headers=headers, request_headers=handler.headers)
                 else:
                     await handler.response(status, event_response, headers=headers)
             elif status.is_redirection:

edri/dataclass/directive/http.py

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

{edri-2025.12.3rc1.dist-info → edri-2025.12.3rc2.dist-info}/METADATA

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

{edri-2025.12.3rc1.dist-info → edri-2025.12.3rc2.dist-info}/RECORD

@@ -1,7 +1,7 @@
 edri/__init__.py,sha256=bBVs4ynkUzMRudKZyuRScpPmUZTIL1LDfIytZ_L7oKE,6257
 edri/abstract/__init__.py,sha256=C6ew041GNVcQlfkE77kHeZ9Ts1rIaWRqqh3bKz7Kb1E,488
 edri/abstract/manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-edri/abstract/manager/manager_base.py,sha256=mguHncpNnx-5RSAPdkzzl74NpOghpl2pI76H0biyZEo,42373
+edri/abstract/manager/manager_base.py,sha256=aEVzFzzl6XfLf3A7I8yAUyBpRbX3d3H6R2b0IRkNQNA,42391
 edri/abstract/manager/manager_priority_base.py,sha256=1bUGsIr6MUrCNsJsLNF_tYaiFDX5t8vK2794vdZumQo,8219
 edri/abstract/manager/worker.py,sha256=xMJMDQtcH-j8s37cUoMsF_ZrWS4elbU7vnjdKfAv0gM,403
 edri/abstract/worker/__init__.py,sha256=qcCF2MnReil9G9ojrr7I3hjMks-1tsap4yrYH5Vr07Q,164
@@ -10,19 +10,20 @@ edri/abstract/worker/worker_process.py,sha256=QiNxOuwkMds0sV2MBLyp7bjrovm5xColC7
 edri/abstract/worker/worker_thread.py,sha256=xoMPuDn-hAkWk6kFY3Xf8mxOVP__5t7-x7f-b396-8M,2176
 edri/api/__init__.py,sha256=ZDxCpHKFGajJ1RwDpV7CzxLDUaKpozJRfOCv1OPv5ZY,142
 edri/api/broker.py,sha256=I3z_bKbcTDnKXk82yteGEQmuxpqHgp5KrhQaJmk3US0,37258
-edri/api/listener.py,sha256=vXvLx2agQG43BIaLOnVpu9ATXhLvKon8BVRLCbVRs_Q,20409
+edri/api/listener.py,sha256=-29ROnrACEpGPtWuBaikzzxJZxrq2jU_twYiU__GgCA,20442
 edri/api/middleware.py,sha256=6_x55swthVDczT-fu_1ufY1cDsHTZ04jMx6J6xfjbsM,5483
-edri/api/dataclass/__init__.py,sha256=8Y-zcaJtzMdALnNG7M9jsCaB1qAJKM8Ld3h9MDajYjA,292
+edri/api/dataclass/__init__.py,sha256=u3520rEHLLetRI--OhTXwRmhv-ydMhuMhDPDx6_7KG0,333
 edri/api/dataclass/api_event.py,sha256=43pCg4Whm3Y1ANUomu8pXbXIRtWQkrDDqNsr_Qnt_-Y,6629
 edri/api/dataclass/client.py,sha256=ctc2G4mXJR2wUSujANudT3LqxW7qxk_YkpM_TEXD0tM,216
-edri/api/dataclass/file.py,sha256=OJfJlrCTjSnzCF8yFVnxr8rGeL0l08WVMsXJx00S4qc,225
+edri/api/dataclass/file.py,sha256=fKQDWBYOSMj0CHXjgkY50wjgvnUlVhaB3rqK9mgp0aE,260
+edri/api/dataclass/range.py,sha256=VaNZTZHtzzKimyg0mdW5auBF7q9ot1JHX5V2h2uw2NE,2222
 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=Lte9SEprQcIYv1nC4Zj2eMmHcvNcCGJQS4TWaP8XlrI,13156
 edri/api/handlers/html_handler.py,sha256=OprcTg1IQDI7eBK-_oHqA60P1H30LA9xIQpD7iV-Neg,7464
-edri/api/handlers/http_handler.py,sha256=jjOyx2Wu756K99x6zvJoybgM2Bj0eWXkjEElLYkCDZ0,36338
+edri/api/handlers/http_handler.py,sha256=nN6YVeiDzhOPsb7D0xqcIVR_FVWugOgjouFGZblOhdM,43256
 edri/api/handlers/rest_handler.py,sha256=GAG5lVTsRMCf9IUmYb_pokxyPcOfbnKZ2p3jxfy_-Dw,3300
 edri/api/handlers/websocket_handler.py,sha256=Dh2XannDuW0eFj5CEzf3owlGc1VTyQ8ehjpxYRrCYW8,8144
 edri/api/static_pages/documentation.j2,sha256=Fe7KLsbqp9P-pQYqG2z8rbhhGVDDFf3m6SQ2mc3PFG4,8934
@@ -41,7 +42,7 @@ edri/dataclass/response.py,sha256=VBMmVdna1IOKC5YGBXor6AayYOoiEYb9xx_RZ3bpKnw,38
 edri/dataclass/directive/__init__.py,sha256=nfvsh1BmxhACW7Q8gnwy7y3l3_cI1P0k2WP0jV5RJhI,608
 edri/dataclass/directive/base.py,sha256=2ghQpv1bGcNHYEMA0nyWGumIplXBzj9cPQ34aJ7uVr0,296
 edri/dataclass/directive/html.py,sha256=UCuwksxt_Q9b1wha1DjEygJWAyq2Hdnir5zG9lGi8as,946
-edri/dataclass/directive/http.py,sha256=FRiuU92TvkAOW0FKHgUIujcqD8zqfZcCs2Dj1kCgwqU,2811
+edri/dataclass/directive/http.py,sha256=iah8pVZll6ccf-gJKxwX0sAzzltFZ7WH3gY-yuv_Ex4,2900
 edri/events/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 edri/events/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 edri/events/api/client/__init__.py,sha256=6q7CJ4eLMAuz_EFIs7us-xDXudy0Z5DIHd0YCVtTeuo,170
@@ -157,7 +158,7 @@ tests/utility/test_validation.py,sha256=wZcXjLrj3JheVLKnYKkkYfyC8CCpHVAw9Jn_uDnu
 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.12.3rc1.dist-info/METADATA,sha256=OBAQ4p4GB6h8PesxFiCHbrlM1_JkrmsdOG-5oCk5QUQ,8374
-edri-2025.12.3rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-edri-2025.12.3rc1.dist-info/top_level.txt,sha256=himES6JgPlx4Zt8aDrQEj2fxAd7IDD6MBOsiNZkzKHQ,11
-edri-2025.12.3rc1.dist-info/RECORD,,
+edri-2025.12.3rc2.dist-info/METADATA,sha256=ApA6oZH9FenWEefx2CegCab_RVMUECQx-N9-DxF4gGA,8374
+edri-2025.12.3rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+edri-2025.12.3rc2.dist-info/top_level.txt,sha256=himES6JgPlx4Zt8aDrQEj2fxAd7IDD6MBOsiNZkzKHQ,11
+edri-2025.12.3rc2.dist-info/RECORD,,