tigrcorn-http 0.3.16.dev5__py3-none-any.whl

tigrcorn_http/structured_fields.py

@@ -0,0 +1,358 @@
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Any
+
+from tigrcorn_config.governance_surface import STRUCTURED_FIELD_REGISTRY
+
+
+@dataclass(frozen=True, slots=True)
+class Token:
+    value: str
+
+
+@dataclass(frozen=True, slots=True)
+class ByteSequence:
+    value: bytes
+
+
+@dataclass(frozen=True, slots=True)
+class Date:
+    value: int
+
+
+BareItem = bool | int | Decimal | str | Token | ByteSequence | Date
+
+
+@dataclass(frozen=True, slots=True)
+class Item:
+    value: BareItem
+    params: dict[str, BareItem] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class InnerList:
+    items: list[Item]
+    params: dict[str, BareItem] = field(default_factory=dict)
+
+
+ListMember = Item | InnerList
+StructuredValue = Item | list[ListMember] | dict[str, ListMember]
+
+
+class StructuredFieldError(ValueError):
+    pass
+
+
+class _Parser:
+    def __init__(self, text: str):
+        self.text = text
+        self.length = len(text)
+        self.index = 0
+
+    def parse_dictionary(self) -> dict[str, ListMember]:
+        result: dict[str, ListMember] = {}
+        while True:
+            self._skip_ows()
+            if self.index >= self.length:
+                return result
+            key = self._parse_key()
+            self._skip_ows()
+            if self._peek('='):
+                self.index += 1
+                member = self.parse_list_member()
+            else:
+                params = self._parse_parameters()
+                member = Item(True, params)
+            result[key] = member
+            self._skip_ows()
+            if self.index >= self.length:
+                return result
+            self._expect(',')
+
+    def parse_list(self) -> list[ListMember]:
+        result: list[ListMember] = []
+        while True:
+            self._skip_ows()
+            if self.index >= self.length:
+                return result
+            result.append(self.parse_list_member())
+            self._skip_ows()
+            if self.index >= self.length:
+                return result
+            self._expect(',')
+
+    def parse_item_only(self) -> Item:
+        item = self._parse_item()
+        self._skip_ows()
+        if self.index != self.length:
+            raise StructuredFieldError('unexpected trailing data in structured item')
+        return item
+
+    def parse_list_member(self) -> ListMember:
+        self._skip_ows()
+        if self._peek('('):
+            self.index += 1
+            items: list[Item] = []
+            while True:
+                self._skip_sp()
+                if self._peek(')'):
+                    self.index += 1
+                    break
+                items.append(self._parse_item())
+                self._skip_sp()
+                if self._peek(')'):
+                    self.index += 1
+                    break
+            return InnerList(items, self._parse_parameters())
+        return self._parse_item()
+
+    def _parse_item(self) -> Item:
+        bare = self._parse_bare_item()
+        return Item(bare, self._parse_parameters())
+
+    def _parse_parameters(self) -> dict[str, BareItem]:
+        params: dict[str, BareItem] = {}
+        while self._peek(';'):
+            self.index += 1
+            key = self._parse_key()
+            value: BareItem = True
+            if self._peek('='):
+                self.index += 1
+                value = self._parse_bare_item()
+            params[key] = value
+        return params
+
+    def _parse_bare_item(self) -> BareItem:
+        if self.index >= self.length:
+            raise StructuredFieldError('unexpected end of structured field')
+        char = self.text[self.index]
+        if char == '"':
+            return self._parse_string()
+        if char == '?':
+            return self._parse_boolean()
+        if char == ':':
+            return self._parse_bytes()
+        if char == '@':
+            return self._parse_date()
+        if char == '-' or char.isdigit():
+            return self._parse_number()
+        return Token(self._parse_token())
+
+    def _parse_string(self) -> str:
+        self._expect('"')
+        chunks: list[str] = []
+        while self.index < self.length:
+            char = self.text[self.index]
+            self.index += 1
+            if char == '"':
+                return ''.join(chunks)
+            if char == '\\':
+                if self.index >= self.length:
+                    raise StructuredFieldError('unterminated escape in structured string')
+                chunks.append(self.text[self.index])
+                self.index += 1
+                continue
+            chunks.append(char)
+        raise StructuredFieldError('unterminated structured string')
+
+    def _parse_boolean(self) -> bool:
+        self._expect('?')
+        if self.index >= self.length or self.text[self.index] not in '01':
+            raise StructuredFieldError('invalid structured boolean')
+        value = self.text[self.index] == '1'
+        self.index += 1
+        return value
+
+    def _parse_bytes(self) -> ByteSequence:
+        self._expect(':')
+        start = self.index
+        while self.index < self.length and self.text[self.index] != ':':
+            self.index += 1
+        if self.index >= self.length:
+            raise StructuredFieldError('unterminated byte sequence')
+        encoded = self.text[start:self.index]
+        self.index += 1
+        try:
+            decoded = base64.b64decode(encoded.encode('ascii'), validate=True)
+        except Exception as exc:
+            raise StructuredFieldError('invalid byte sequence') from exc
+        return ByteSequence(decoded)
+
+    def _parse_date(self) -> Date:
+        self._expect('@')
+        digits = self._parse_digits(allow_sign=True)
+        return Date(int(digits))
+
+    def _parse_number(self) -> int | Decimal:
+        number = self._parse_digits(allow_sign=True)
+        if self._peek('.'):
+            self.index += 1
+            fraction = self._parse_digits(allow_sign=False)
+            return Decimal(f'{number}.{fraction}')
+        return int(number)
+
+    def _parse_token(self) -> str:
+        start = self.index
+        while self.index < self.length and self.text[self.index] not in '()<>@,;:\\"/[]?={} \t':
+            self.index += 1
+        token = self.text[start:self.index]
+        if not token:
+            raise StructuredFieldError('expected token')
+        return token
+
+    def _parse_key(self) -> str:
+        key = self._parse_token()
+        if not key[0].islower() and key[0] != '*':
+            raise StructuredFieldError(f'invalid structured key {key!r}')
+        return key
+
+    def _parse_digits(self, *, allow_sign: bool) -> str:
+        start = self.index
+        if allow_sign and self._peek('-'):
+            self.index += 1
+        while self.index < self.length and self.text[self.index].isdigit():
+            self.index += 1
+        digits = self.text[start:self.index]
+        if digits in {'', '-'}:
+            raise StructuredFieldError('expected digits')
+        return digits
+
+    def _skip_ows(self) -> None:
+        while self.index < self.length and self.text[self.index] in ' \t':
+            self.index += 1
+
+    def _skip_sp(self) -> None:
+        while self.index < self.length and self.text[self.index] == ' ':
+            self.index += 1
+
+    def _expect(self, char: str) -> None:
+        if not self._peek(char):
+            raise StructuredFieldError(f'expected {char!r}')
+        self.index += 1
+
+    def _peek(self, char: str) -> bool:
+        return self.index < self.length and self.text[self.index] == char
+
+
+def parse_item(value: str) -> Item:
+    return _Parser(value).parse_item_only()
+
+
+def parse_list(value: str) -> list[ListMember]:
+    return _Parser(value).parse_list()
+
+
+def parse_dictionary(value: str) -> dict[str, ListMember]:
+    return _Parser(value).parse_dictionary()
+
+
+def parse_structured_field(field_name: str, value: str) -> StructuredValue:
+    field_type = STRUCTURED_FIELD_REGISTRY.get(field_name.lower())
+    if field_type == 'dictionary':
+        return parse_dictionary(value)
+    if field_type == 'list':
+        return parse_list(value)
+    if field_type == 'item':
+        return parse_item(value)
+    raise StructuredFieldError(f'unknown structured field registry type for {field_name!r}')
+
+
+def serialize_bare_item(value: BareItem) -> str:
+    if isinstance(value, bool):
+        return '?1' if value else '?0'
+    if isinstance(value, Token):
+        return value.value
+    if isinstance(value, ByteSequence):
+        return ':' + base64.b64encode(value.value).decode('ascii') + ':'
+    if isinstance(value, Date):
+        return '@' + str(value.value)
+    if isinstance(value, Decimal):
+        text = format(value, 'f')
+        text = text.rstrip('0').rstrip('.') if '.' in text else text
+        return text
+    if isinstance(value, int):
+        return str(value)
+    escaped = str(value).replace('\\', '\\\\').replace('"', '\\"')
+    return f'"{escaped}"'
+
+
+def serialize_item(item: Item) -> str:
+    return serialize_bare_item(item.value) + _serialize_params(item.params)
+
+
+def serialize_list_member(member: ListMember) -> str:
+    if isinstance(member, InnerList):
+        inner = ' '.join(serialize_item(item) for item in member.items)
+        return f'({inner})' + _serialize_params(member.params)
+    return serialize_item(member)
+
+
+def serialize_dictionary(value: dict[str, ListMember]) -> str:
+    parts: list[str] = []
+    for key, member in value.items():
+        if isinstance(member, Item) and member.value is True:
+            parts.append(key + _serialize_params(member.params))
+        else:
+            parts.append(f'{key}={serialize_list_member(member)}')
+    return ', '.join(parts)
+
+
+def serialize_list(value: list[ListMember]) -> str:
+    return ', '.join(serialize_list_member(member) for member in value)
+
+
+def serialize_structured_value(value: StructuredValue) -> str:
+    if isinstance(value, dict):
+        return serialize_dictionary(value)
+    if isinstance(value, list):
+        return serialize_list(value)
+    return serialize_item(value)
+
+
+def _serialize_params(params: dict[str, BareItem]) -> str:
+    return ''.join(
+        f';{key}' if raw is True else f';{key}={serialize_bare_item(raw)}'
+        for key, raw in params.items()
+    )
+
+
+def normalize_for_json(value: Any) -> Any:
+    if isinstance(value, Token):
+        return {'type': 'token', 'value': value.value}
+    if isinstance(value, ByteSequence):
+        return {'type': 'bytes', 'value': base64.b64encode(value.value).decode('ascii')}
+    if isinstance(value, Date):
+        return {'type': 'date', 'value': value.value}
+    if isinstance(value, Decimal):
+        return {'type': 'decimal', 'value': str(value)}
+    if isinstance(value, Item):
+        return {'type': 'item', 'value': normalize_for_json(value.value), 'params': {k: normalize_for_json(v) for k, v in value.params.items()}}
+    if isinstance(value, InnerList):
+        return {'type': 'inner_list', 'items': [normalize_for_json(item) for item in value.items], 'params': {k: normalize_for_json(v) for k, v in value.params.items()}}
+    if isinstance(value, dict):
+        return {key: normalize_for_json(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [normalize_for_json(item) for item in value]
+    return value
+
+
+__all__ = [
+    'ByteSequence',
+    'Date',
+    'InnerList',
+    'Item',
+    'StructuredFieldError',
+    'Token',
+    'normalize_for_json',
+    'parse_dictionary',
+    'parse_item',
+    'parse_list',
+    'parse_structured_field',
+    'serialize_dictionary',
+    'serialize_item',
+    'serialize_list',
+    'serialize_structured_value',
+]

tigrcorn_http-0.3.16.dev5.dist-info/METADATA

@@ -0,0 +1,237 @@
+Metadata-Version: 2.4
+Name: tigrcorn-http
+Version: 0.3.16.dev5
+Summary: HTTP utilities for Tigrcorn headers, entity tags, content coding, range requests, and Python web server responses.
+Author-email: Jacob Stewart <jacob@swarmauri.com>
+License: Apache License
+        Version 2.0, January 2004
+        http://www.apache.org/licenses/
+        
+        TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+        1. Definitions.
+        
+           "License" shall mean the terms and conditions for use, reproduction, and
+           distribution as defined by Sections 1 through 9 of this document.
+        
+           "Licensor" shall mean the copyright owner or entity authorized by the
+           copyright owner that is granting the License.
+        
+           "Legal Entity" shall mean the union of the acting entity and all other
+           entities that control, are controlled by, or are under common control with
+           that entity. For the purposes of this definition, "control" means (i) the
+           power, direct or indirect, to cause the direction or management of such
+           entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+           (50%) or more of the outstanding shares, or (iii) beneficial ownership of
+           such entity.
+        
+           "You" (or "Your") shall mean an individual or Legal Entity exercising
+           permissions granted by this License.
+        
+           "Source" form shall mean the preferred form for making modifications,
+           including but not limited to software source code, documentation source, and
+           configuration files.
+        
+           "Object" form shall mean any form resulting from mechanical transformation
+           or translation of a Source form, including but not limited to compiled object
+           code, generated documentation, and conversions to other media types.
+        
+           "Work" shall mean the work of authorship, whether in Source or Object form,
+           made available under the License, as indicated by a copyright notice that is
+           included in or attached to the work (an example is provided in the Appendix
+           below).
+        
+           "Derivative Works" shall mean any work, whether in Source or Object form,
+           that is based on (or derived from) the Work and for which the editorial
+           revisions, annotations, elaborations, or other modifications represent, as a
+           whole, an original work of authorship. For the purposes of this License,
+           Derivative Works shall not include works that remain separable from, or
+           merely link (or bind by name) to the interfaces of, the Work and Derivative
+           Works thereof.
+        
+           "Contribution" shall mean any work of authorship, including the original
+           version of the Work and any modifications or additions to that Work or
+           Derivative Works thereof, that is intentionally submitted to Licensor for
+           inclusion in the Work by the copyright owner or by an individual or Legal
+           Entity authorized to submit on behalf of the copyright owner. For the
+           purposes of this definition, "submitted" means any form of electronic,
+           verbal, or written communication sent to the Licensor or its representatives,
+           including but not limited to communication on electronic mailing lists,
+           source code control systems, and issue tracking systems that are managed by,
+           or on behalf of, the Licensor for the purpose of discussing and improving the
+           Work, but excluding communication that is conspicuously marked or otherwise
+           designated in writing by the copyright owner as "Not a Contribution."
+        
+           "Contributor" shall mean Licensor and any individual or Legal Entity on
+           behalf of whom a Contribution has been received by Licensor and subsequently
+           incorporated within the Work.
+        
+        2. Grant of Copyright License. Subject to the terms and conditions of this
+           License, each Contributor hereby grants to You a perpetual, worldwide,
+           non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+           reproduce, prepare Derivative Works of, publicly display, publicly perform,
+           sublicense, and distribute the Work and such Derivative Works in Source or
+           Object form.
+        
+        3. Grant of Patent License. Subject to the terms and conditions of this
+           License, each Contributor hereby grants to You a perpetual, worldwide,
+           non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this
+           section) patent license to make, have made, use, offer to sell, sell, import,
+           and otherwise transfer the Work, where such license applies only to those
+           patent claims licensable by such Contributor that are necessarily infringed by
+           their Contribution(s) alone or by combination of their Contribution(s) with
+           the Work to which such Contribution(s) was submitted. If You institute patent
+           litigation against any entity (including a cross-claim or counterclaim in a
+           lawsuit) alleging that the Work or a Contribution incorporated within the Work
+           constitutes direct or contributory patent infringement, then any patent
+           licenses granted to You under this License for that Work shall terminate as of
+           the date such litigation is filed.
+        
+        4. Redistribution. You may reproduce and distribute copies of the Work or
+           Derivative Works thereof in any medium, with or without modifications, and in
+           Source or Object form, provided that You meet the following conditions:
+        
+           (a) You must give any other recipients of the Work or Derivative Works a copy
+               of this License; and
+        
+           (b) You must cause any modified files to carry prominent notices stating that
+               You changed the files; and
+        
+           (c) You must retain, in the Source form of any Derivative Works that You
+               distribute, all copyright, patent, trademark, and attribution notices
+               from the Source form of the Work, excluding those notices that do not
+               pertain to any part of the Derivative Works; and
+        
+           (d) If the Work includes a "NOTICE" text file as part of its distribution,
+               then any Derivative Works that You distribute must include a readable copy
+               of the attribution notices contained within such NOTICE file, excluding
+               those notices that do not pertain to any part of the Derivative Works, in
+               at least one of the following places: within a NOTICE text file distributed
+               as part of the Derivative Works; within the Source form or documentation,
+               if provided along with the Derivative Works; or, within a display generated
+               by the Derivative Works, if and wherever such third-party notices normally
+               appear. The contents of the NOTICE file are for informational purposes only
+               and do not modify the License. You may add Your own attribution notices
+               within Derivative Works that You distribute, alongside or as an addendum to
+               the NOTICE text from the Work, provided that such additional attribution
+               notices cannot be construed as modifying the License.
+        
+           You may add Your own copyright statement to Your modifications and may provide
+           additional or different license terms and conditions for use, reproduction, or
+           distribution of Your modifications, or for any such Derivative Works as a
+           whole, provided Your use, reproduction, and distribution of the Work otherwise
+           complies with the conditions stated in this License.
+        
+        5. Submission of Contributions. Unless You explicitly state otherwise, any
+           Contribution intentionally submitted for inclusion in the Work by You to the
+           Licensor shall be under the terms and conditions of this License, without any
+           additional terms or conditions. Notwithstanding the above, nothing herein
+           shall supersede or modify the terms of any separate license agreement you may
+           have executed with Licensor regarding such Contributions.
+        
+        6. Trademarks. This License does not grant permission to use the trade names,
+           trademarks, service marks, or product names of the Licensor, except as
+           required for reasonable and customary use in describing the origin of the Work
+           and reproducing the content of the NOTICE file.
+        
+        7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+           writing, Licensor provides the Work (and each Contributor provides its
+           Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+           KIND, either express or implied, including, without limitation, any warranties
+           or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+           PARTICULAR PURPOSE. You are solely responsible for determining the
+           appropriateness of using or redistributing the Work and assume any risks
+           associated with Your exercise of permissions under this License.
+        
+        8. Limitation of Liability. In no event and under no legal theory, whether in
+           tort (including negligence), contract, or otherwise, unless required by
+           applicable law (such as deliberate and grossly negligent acts) or agreed to in
+           writing, shall any Contributor be liable to You for damages, including any
+           direct, indirect, special, incidental, or consequential damages of any
+           character arising as a result of this License or out of the use or inability
+           to use the Work (including but not limited to damages for loss of goodwill,
+           work stoppage, computer failure or malfunction, or any and all other
+           commercial damages or losses), even if such Contributor has been advised of
+           the possibility of such damages.
+        
+        9. Accepting Warranty or Additional Liability. While redistributing the Work or
+           Derivative Works thereof, You may choose to offer, and charge a fee for,
+           acceptance of support, warranty, indemnity, or other liability obligations
+           and/or rights consistent with this License. However, in accepting such
+           obligations, You may act only on Your own behalf and on Your sole
+           responsibility, not on behalf of any other Contributor, and only if You agree
+           to indemnify, defend, and hold each Contributor harmless for any liability
+           incurred by, or claims asserted against, such Contributor by reason of your
+           accepting any such warranty or additional liability.
+        
+        END OF TERMS AND CONDITIONS
+        
+        
+Keywords: tigrcorn,http,headers,etag,content-coding,range-requests,http-utilities
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tigrcorn-core==0.3.16.dev5
+Provides-Extra: compression
+Requires-Dist: brotli>=1.1.0; extra == "compression"
+Dynamic: license-file
+
+<div align="center">
+<h1>tigrcorn-http</h1>
+
+<p><strong>HTTP utilities for Tigrcorn headers, entity tags, content coding, range requests, and Python web server responses.</strong></p>
+
+<a href="https://pypi.org/project/tigrcorn-http/"><img alt="PyPI version for tigrcorn-http" src="https://img.shields.io/pypi/v/tigrcorn-http?label=PyPI"></a>
+<a href="https://pypi.org/project/tigrcorn-http/"><img alt="tigrcorn-http package on PyPI" src="https://img.shields.io/badge/package-PyPI-blue"></a>
+<a href="LICENSE"><img alt="Apache 2.0 license" src="https://img.shields.io/badge/license-Apache%202.0-525252"></a>
+<a href="pyproject.toml"><img alt="Python 3.11 supported" src="https://img.shields.io/badge/python-3.11-3776ab"></a>
+<a href="pyproject.toml"><img alt="Python 3.12 supported" src="https://img.shields.io/badge/python-3.12-3776ab"></a>
+<a href="pyproject.toml"><img alt="Python 3.13 supported" src="https://img.shields.io/badge/python-3.13-3776ab"></a>
+<a href="src/tigrcorn_http/py.typed"><img alt="typed package" src="https://img.shields.io/badge/typed-py.typed-2f7ed8"></a>
+<a href="https://pypi.org/project/tigrcorn-http/"><img alt="http role package" src="https://img.shields.io/badge/role-http-0a7f5a"></a>
+</div>
+
+## Install
+
+~~~bash
+pip install tigrcorn-http
+~~~
+
+Use the aggregate [tigrcorn](https://pypi.org/project/tigrcorn/) distribution when you want the full ASGI3 Python web server stack. Install <code>tigrcorn-http</code> directly when you want only this package boundary and its declared dependencies.
+
+## What It Owns
+
+<code>tigrcorn-http</code> owns structured fields, range requests, entity validators, Alt-Svc, Early Hints, headers, and HTTP response utilities. Its import package is <code>tigrcorn_http</code>, and its declared package dependencies are: tigrcorn-core.
+
+This package page is written for developers searching for Tigrcorn ASGI3 server components, Python web server packages, HTTP/3 and QUIC support, WebSocket and WebTransport runtime surfaces, typed package boundaries, and Apache 2.0 licensed infrastructure.
+
+## Use It When
+
+Use <code>tigrcorn-http</code> when you need reusable HTTP utility logic for Tigrcorn packages without importing protocol handlers or the server runtime. It is part of Tigrcorn's split-package architecture, so it can be installed independently while remaining linked to the rest of the Tigrcorn package family on PyPI.
+
+## Import Surface
+
+~~~python
+import tigrcorn_http
+
+print(tigrcorn_http.__name__)
+~~~
+
+The package exposes its supported public surface through the <code>tigrcorn_http</code> namespace. The root [tigrcorn](https://pypi.org/project/tigrcorn/) package keeps compatibility shims for users who install the full server distribution.
+
+## Package Graph
+
+[tigrcorn](https://pypi.org/project/tigrcorn/) | [tigrcorn-core](https://pypi.org/project/tigrcorn-core/) | [tigrcorn-config](https://pypi.org/project/tigrcorn-config/) | [tigrcorn-asgi](https://pypi.org/project/tigrcorn-asgi/) | [tigrcorn-contract](https://pypi.org/project/tigrcorn-contract/) | [tigrcorn-transports](https://pypi.org/project/tigrcorn-transports/) | [tigrcorn-protocols](https://pypi.org/project/tigrcorn-protocols/) | [tigrcorn-http](https://pypi.org/project/tigrcorn-http/) | [tigrcorn-security](https://pypi.org/project/tigrcorn-security/) | [tigrcorn-runtime](https://pypi.org/project/tigrcorn-runtime/) | [tigrcorn-static](https://pypi.org/project/tigrcorn-static/) | [tigrcorn-observability](https://pypi.org/project/tigrcorn-observability/) | [tigrcorn-compat](https://pypi.org/project/tigrcorn-compat/) | [tigrcorn-certification](https://pypi.org/project/tigrcorn-certification/)

tigrcorn_http-0.3.16.dev5.dist-info/RECORD

@@ -0,0 +1,14 @@
+tigrcorn_http/__init__.py,sha256=47YHmQGk2dfL--fXnRHd9hQYriL3S2_xwAgGXT8ygQM,1505
+tigrcorn_http/alt_svc.py,sha256=0R_oHsfJ42j_5BV4qUtu32RtSZZX6ml4eplWfO8yxMA,2412
+tigrcorn_http/conditional.py,sha256=WzMiu1NQ1VfGfn9Q_pI646zf-WhcEZo7salb9gC0fP4,5191
+tigrcorn_http/early_hints.py,sha256=lrzHb_sfve498A5G4wcoaerxzOEBYc0o2UP4qIesZDw,1657
+tigrcorn_http/entity.py,sha256=vhfvdS-qXoU_6-ibOS904vNuI4kbYQataMckivBpe8E,11926
+tigrcorn_http/etag.py,sha256=RTNko6inxZRhuX5h5ybdQQgyEGEd5EmOVmhKwYPI6nw,3530
+tigrcorn_http/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+tigrcorn_http/range.py,sha256=6lqVAnmgX9KoQP2-nl8EvPy4Y_S9xKGrC5wMRrrReiA,12294
+tigrcorn_http/structured_fields.py,sha256=ijBRcJldsmlEbMexP9_Jn8aFjRXyYS23OP52TgFU-pg,11631
+tigrcorn_http-0.3.16.dev5.dist-info/licenses/LICENSE,sha256=xhBSirl227aDQNeQ8tk2v_yiU9nbQpJ4EZp6OtATX-s,9591
+tigrcorn_http-0.3.16.dev5.dist-info/METADATA,sha256=EDhJDlsSlXWHr7S-B28W_gJV9rR1w-ocQz8_Qh5V_J4,15731
+tigrcorn_http-0.3.16.dev5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+tigrcorn_http-0.3.16.dev5.dist-info/top_level.txt,sha256=3wazlC0vOiz-9nNNhlkj2s8epJ9m52CLbqqDf5Xhd6g,14
+tigrcorn_http-0.3.16.dev5.dist-info/RECORD,,

tigrcorn_http-0.3.16.dev5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+