tigrcorn-http 0.3.16__py3-none-any.whl

tigrcorn_http/__init__.py

@@ -0,0 +1,54 @@
+from tigrcorn_http.conditional import ConditionalEvaluation, apply_conditional_request, parse_http_date
+from tigrcorn_http.entity import EntitySemanticsResult, apply_response_entity_semantics
+from tigrcorn_http.etag import EntityTag, EntityTagList, format_etag, generate_entity_tag, parse_entity_tag, parse_entity_tag_list, strong_compare, weak_compare
+from tigrcorn_http.range import ByteRange, RangeEvaluation, apply_byte_ranges, parse_range_header
+from tigrcorn_http.structured_fields import (
+    ByteSequence,
+    Date,
+    InnerList,
+    Item,
+    StructuredFieldError,
+    Token,
+    parse_dictionary,
+    parse_item,
+    parse_list,
+    parse_structured_field,
+    serialize_dictionary,
+    serialize_item,
+    serialize_list,
+    serialize_structured_value,
+)
+
+__all__ = [
+    'ByteRange',
+    'ConditionalEvaluation',
+    'EntitySemanticsResult',
+    'EntityTag',
+    'EntityTagList',
+    'RangeEvaluation',
+    'ByteSequence',
+    'Date',
+    'InnerList',
+    'Item',
+    'StructuredFieldError',
+    'Token',
+    'apply_byte_ranges',
+    'apply_conditional_request',
+    'apply_response_entity_semantics',
+    'format_etag',
+    'generate_entity_tag',
+    'parse_entity_tag',
+    'parse_entity_tag_list',
+    'parse_http_date',
+    'parse_dictionary',
+    'parse_range_header',
+    'parse_item',
+    'parse_list',
+    'parse_structured_field',
+    'serialize_dictionary',
+    'serialize_item',
+    'serialize_list',
+    'serialize_structured_value',
+    'strong_compare',
+    'weak_compare',
+]

tigrcorn_http/alt_svc.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+
+HeaderList = list[tuple[bytes, bytes]]
+
+
+def _to_bytes(value: bytes | str) -> bytes:
+    if isinstance(value, bytes):
+        return value
+    return str(value).encode('latin1')
+
+
+def _dedupe(values: Iterable[bytes]) -> list[bytes]:
+    seen: set[bytes] = set()
+    result: list[bytes] = []
+    for item in values:
+        token = bytes(item).strip()
+        if not token or token in seen:
+            continue
+        seen.add(token)
+        result.append(token)
+    return result
+
+
+def configured_alt_svc_values(config, *, request_http_version: str | None = None) -> list[bytes]:
+    explicit = _dedupe(_to_bytes(item) for item in getattr(config.http, 'alt_svc_headers', ()))
+    if explicit:
+        return explicit
+    if not getattr(config.http, 'alt_svc_auto', False):
+        return []
+    version = str(request_http_version or '').replace('HTTP/', '').strip().lower()
+    if version in {'3', '3.0', 'h3', 'http/3'}:
+        return []
+    values: list[bytes] = []
+    max_age = int(getattr(config.http, 'alt_svc_max_age', 86400))
+    persist = bool(getattr(config.http, 'alt_svc_persist', False))
+    for listener in getattr(config, 'listeners', ()):  # pragma: no branch - tiny loop
+        if getattr(listener, 'kind', None) != 'udp':
+            continue
+        enabled = set(getattr(listener, 'enabled_protocols', ()))
+        if 'http3' not in enabled:
+            continue
+        port = getattr(listener, 'port', 0)
+        if not isinstance(port, int) or port <= 0:
+            continue
+        fragments = [f'h3=":{port}"'.encode('ascii')]
+        if max_age >= 0:
+            fragments.append(f'ma={max_age}'.encode('ascii'))
+        if persist:
+            fragments.append(b'persist=1')
+        values.append(b'; '.join(fragments))
+    return _dedupe(values)
+
+
+def append_alt_svc_headers(
+    headers: Iterable[tuple[bytes, bytes]],
+    *,
+    config,
+    request_http_version: str | None = None,
+) -> HeaderList:
+    normalized = [(bytes(name).lower(), bytes(value)) for name, value in headers]
+    if any(name == b'alt-svc' for name, _value in normalized):
+        return normalized
+    for value in configured_alt_svc_values(config, request_http_version=request_http_version):
+        normalized.append((b'alt-svc', value))
+    return normalized
+
+
+__all__ = ['append_alt_svc_headers', 'configured_alt_svc_values']

tigrcorn_http/conditional.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+
+from tigrcorn_http.etag import EntityTag, EntityTagList, parse_entity_tag, parse_entity_tag_list, strong_compare, weak_compare
+from tigrcorn_core.utils.headers import get_header
+
+
+HeaderList = list[tuple[bytes, bytes]]
+_PRECONDITION_FAILED_BODY = b'precondition failed'
+
+
+@dataclass(frozen=True, slots=True)
+class ConditionalEvaluation:
+    status: int
+    headers: HeaderList
+    body: bytes
+    not_modified: bool = False
+    precondition_failed: bool = False
+
+
+def parse_http_date(value: bytes | str | None) -> datetime | None:
+    if value is None:
+        return None
+    try:
+        dt = parsedate_to_datetime(value.decode('latin1') if isinstance(value, bytes) else value)
+    except (TypeError, ValueError, IndexError):
+        return None
+    if dt is None:
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc).replace(microsecond=0)
+
+
+def _current_validators(headers: HeaderList) -> tuple[EntityTag | None, bytes | None, datetime | None, bytes | None]:
+    etag_raw = get_header(headers, b'etag')
+    last_modified_raw = get_header(headers, b'last-modified')
+    return parse_entity_tag(etag_raw), etag_raw, parse_http_date(last_modified_raw), last_modified_raw
+
+
+def _build_precondition_failed_headers(current_etag_raw: bytes | None, last_modified_raw: bytes | None) -> HeaderList:
+    headers: HeaderList = [(b'content-type', b'text/plain; charset=utf-8')]
+    if current_etag_raw is not None:
+        headers.append((b'etag', current_etag_raw))
+    if last_modified_raw is not None:
+        headers.append((b'last-modified', last_modified_raw))
+    return headers
+
+
+def _matches_if_match(condition: EntityTagList | None, current: EntityTag | None) -> bool:
+    if condition is None:
+        return True
+    if condition.any_value:
+        return current is not None
+    return any(strong_compare(candidate, current) for candidate in condition.items)
+
+
+def _matches_if_none_match(condition: EntityTagList | None, current: EntityTag | None) -> bool:
+    if condition is None:
+        return False
+    if condition.any_value:
+        return current is not None
+    return any(weak_compare(candidate, current) for candidate in condition.items)
+
+
+def apply_conditional_request(
+    *,
+    method: str,
+    request_headers: list[tuple[bytes, bytes]] | tuple[tuple[bytes, bytes], ...],
+    response_headers: HeaderList,
+    body: bytes,
+    status: int,
+) -> ConditionalEvaluation:
+    method_upper = method.upper()
+    headers = [(bytes(name).lower(), bytes(value)) for name, value in response_headers]
+    current_etag, current_etag_raw, last_modified, last_modified_raw = _current_validators(headers)
+
+    if_match_raw = get_header(request_headers, b'if-match')
+    if if_match_raw is not None:
+        condition = parse_entity_tag_list(if_match_raw)
+        if condition is not None and not _matches_if_match(condition, current_etag):
+            return ConditionalEvaluation(
+                status=412,
+                headers=_build_precondition_failed_headers(current_etag_raw, last_modified_raw),
+                body=_PRECONDITION_FAILED_BODY,
+                precondition_failed=True,
+            )
+
+    if_unmodified_since_raw = get_header(request_headers, b'if-unmodified-since')
+    if if_unmodified_since_raw is not None and last_modified is not None:
+        date_value = parse_http_date(if_unmodified_since_raw)
+        if date_value is not None and last_modified > date_value:
+            return ConditionalEvaluation(
+                status=412,
+                headers=_build_precondition_failed_headers(current_etag_raw, last_modified_raw),
+                body=_PRECONDITION_FAILED_BODY,
+                precondition_failed=True,
+            )
+
+    if_none_match_raw = get_header(request_headers, b'if-none-match')
+    if if_none_match_raw is not None:
+        condition = parse_entity_tag_list(if_none_match_raw)
+        if condition is not None and _matches_if_none_match(condition, current_etag):
+            if method_upper in {'GET', 'HEAD'}:
+                return ConditionalEvaluation(status=304, headers=headers, body=b'', not_modified=True)
+            return ConditionalEvaluation(
+                status=412,
+                headers=_build_precondition_failed_headers(current_etag_raw, last_modified_raw),
+                body=_PRECONDITION_FAILED_BODY,
+                precondition_failed=True,
+            )
+
+    if if_none_match_raw is None and method_upper in {'GET', 'HEAD'} and last_modified is not None:
+        if_modified_since_raw = get_header(request_headers, b'if-modified-since')
+        if if_modified_since_raw is not None:
+            date_value = parse_http_date(if_modified_since_raw)
+            if date_value is not None and last_modified <= date_value:
+                return ConditionalEvaluation(status=304, headers=headers, body=b'', not_modified=True)
+
+    return ConditionalEvaluation(status=status, headers=headers, body=body)
+
+
+__all__ = ['ConditionalEvaluation', 'apply_conditional_request', 'parse_http_date']

tigrcorn_http/early_hints.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from tigrcorn_core.utils.headers import strip_connection_specific_headers
+
+
+HeaderList = list[tuple[bytes, bytes]]
+
+# Keep the public support envelope intentionally narrow for checkpointability:
+# 103 responses are treated as preload-hint carriers and only preserve Link fields.
+_EARLY_HINTS_ALLOWED_HEADERS = {b'link'}
+
+
+def _normalize(headers: Iterable[tuple[bytes, bytes]]) -> HeaderList:
+    normalized = [(bytes(name).lower(), bytes(value)) for name, value in headers]
+    return strip_connection_specific_headers(normalized)
+
+
+def sanitize_informational_headers(status: int, headers: Iterable[tuple[bytes, bytes]]) -> HeaderList:
+    """Return a safe informational-header list.
+
+    For 103 Early Hints, restrict the surface to Link preload hints and drop
+    connection-specific framing metadata. Other informational responses keep
+    ordinary end-to-end fields except framing metadata.
+    """
+
+    normalized = _normalize(headers)
+    if status == 103:
+        result: HeaderList = []
+        seen: set[tuple[bytes, bytes]] = set()
+        for name, value in normalized:
+            if name not in _EARLY_HINTS_ALLOWED_HEADERS:
+                continue
+            if b'\r' in value or b'\n' in value:
+                continue
+            item = (name, value)
+            if item not in seen:
+                seen.add(item)
+                result.append(item)
+        return result
+    return [
+        (name, value)
+        for name, value in normalized
+        if name not in {b'content-length', b'transfer-encoding'}
+    ]
+
+
+__all__ = ['sanitize_informational_headers']

tigrcorn_http/entity.py

@@ -0,0 +1,338 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from tigrcorn_asgi.send import BodySegment
+from tigrcorn_http.conditional import apply_conditional_request
+from tigrcorn_http.etag import generate_entity_tag
+from tigrcorn_http.range import apply_byte_ranges, build_file_range_segments, plan_file_byte_ranges
+from tigrcorn_protocols.content_coding import ContentCodingSelection, apply_http_content_coding
+from tigrcorn_protocols.http1.serializer import response_allows_body
+from tigrcorn_core.utils.headers import append_if_missing, get_header, replace_header
+
+
+HeaderList = list[tuple[bytes, bytes]]
+
+
+@dataclass(frozen=True, slots=True)
+class EntitySemanticsResult:
+    status: int
+    headers: HeaderList
+    body: bytes
+    content_coding: ContentCodingSelection
+    range_applied: bool = False
+    not_modified: bool = False
+    precondition_failed: bool = False
+    head_response: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class FileBackedEntitySemanticsResult:
+    status: int
+    headers: HeaderList
+    body: bytes
+    body_segments: tuple[BodySegment, ...] = ()
+    use_body_segments: bool = False
+    range_applied: bool = False
+    not_modified: bool = False
+    precondition_failed: bool = False
+    head_response: bool = False
+    requires_materialization: bool = False
+
+
+def _normalize_headers(headers: list[tuple[bytes, bytes]]) -> HeaderList:
+    return [(bytes(name).lower(), bytes(value)) for name, value in headers]
+
+
+def finalize_response_content_length(*, method: str, status: int, headers: HeaderList, body_length: int, trailers_present: bool = False) -> HeaderList:
+    normalized = [(name.lower(), value) for name, value in headers if name.lower() != b'content-length']
+    method_upper = method.upper()
+    if status in {204} or 100 <= status < 200:
+        return normalized
+    if trailers_present:
+        return normalized
+    if status == 304:
+        return normalized
+    if not response_allows_body(status):
+        return normalized
+    normalized.append((b'content-length', str(max(int(body_length), 0)).encode('ascii')))
+    if method_upper == 'HEAD':
+        return normalized
+    return normalized
+
+
+def _maybe_generate_etag(headers: HeaderList, body: bytes, *, enabled: bool) -> HeaderList:
+    if not enabled:
+        return headers
+    if get_header(headers, b'etag') is not None:
+        return headers
+    headers = list(headers)
+    headers.append((b'etag', generate_entity_tag(body)))
+    return headers
+
+
+def _default_selection() -> ContentCodingSelection:
+    return ContentCodingSelection(coding=None, identity_acceptable=True)
+
+
+def should_materialize_response_body(
+    *,
+    method: str,
+    request_headers: list[tuple[bytes, bytes]] | tuple[tuple[bytes, bytes], ...],
+    response_headers: list[tuple[bytes, bytes]],
+    status: int,
+    apply_content_coding: bool = True,
+) -> bool:
+    method_upper = method.upper()
+    if method_upper == 'HEAD' or not response_allows_body(status) or status in {304} or 100 <= status < 200:
+        return False
+    if not apply_content_coding:
+        return False
+    if get_header(response_headers, b'content-encoding') is not None:
+        return False
+    return get_header(request_headers, b'accept-encoding') is not None
+
+
+def apply_header_only_response_semantics(
+    *,
+    method: str,
+    request_headers: list[tuple[bytes, bytes]] | tuple[tuple[bytes, bytes], ...],
+    response_headers: list[tuple[bytes, bytes]],
+    status: int,
+    body_length: int,
+    generated_etag: bytes | None = None,
+    trailers_present: bool = False,
+    advertise_accept_ranges: bool = False,
+) -> EntitySemanticsResult:
+    method_upper = method.upper()
+    headers = _normalize_headers(response_headers)
+    if generated_etag is not None and get_header(headers, b'etag') is None and status not in {412, 416} and not (100 <= status < 200):
+        headers = list(headers)
+        headers.append((b'etag', generated_etag))
+
+    conditional = apply_conditional_request(
+        method=method_upper,
+        request_headers=request_headers,
+        response_headers=headers,
+        body=b'',
+        status=status,
+    )
+    status = conditional.status
+    headers = conditional.headers
+    body = conditional.body
+
+    if advertise_accept_ranges and get_header(headers, b'accept-ranges') is None and status in {200, 206} and get_header(headers, b'content-encoding') is None:
+        append_if_missing(headers, b'accept-ranges', b'bytes')
+
+    content_length = len(body) if conditional.precondition_failed else int(body_length)
+    headers = finalize_response_content_length(
+        method=method_upper,
+        status=status,
+        headers=headers,
+        body_length=content_length,
+        trailers_present=trailers_present,
+    )
+
+    if method_upper == 'HEAD':
+        return EntitySemanticsResult(
+            status=status,
+            headers=headers,
+            body=b'',
+            content_coding=_default_selection(),
+            not_modified=conditional.not_modified,
+            precondition_failed=conditional.precondition_failed,
+            head_response=True,
+        )
+
+    return EntitySemanticsResult(
+        status=status,
+        headers=headers,
+        body=body,
+        content_coding=_default_selection(),
+        not_modified=conditional.not_modified,
+        precondition_failed=conditional.precondition_failed,
+    )
+
+
+def plan_file_backed_response_entity_semantics(
+    *,
+    method: str,
+    request_headers: list[tuple[bytes, bytes]] | tuple[tuple[bytes, bytes], ...],
+    response_headers: list[tuple[bytes, bytes]],
+    status: int,
+    body_path: str,
+    body_length: int,
+    generated_etag: bytes | None = None,
+    apply_content_coding: bool = True,
+    trailers_present: bool = False,
+) -> FileBackedEntitySemanticsResult:
+    method_upper = method.upper()
+    headers = _normalize_headers(response_headers)
+    if generated_etag is not None and get_header(headers, b'etag') is None and status not in {412, 416} and not (100 <= status < 200):
+        headers = list(headers)
+        headers.append((b'etag', generated_etag))
+
+    if should_materialize_response_body(
+        method=method_upper,
+        request_headers=request_headers,
+        response_headers=headers,
+        status=status,
+        apply_content_coding=apply_content_coding,
+    ):
+        return FileBackedEntitySemanticsResult(
+            status=status,
+            headers=headers,
+            body=b'',
+            requires_materialization=True,
+        )
+
+    conditional = apply_conditional_request(
+        method=method_upper,
+        request_headers=request_headers,
+        response_headers=headers,
+        body=b'',
+        status=status,
+    )
+    if conditional.not_modified or conditional.precondition_failed:
+        precondition_body = conditional.body if not (method_upper == 'HEAD') else b''
+        precondition_headers = finalize_response_content_length(
+            method=method_upper,
+            status=conditional.status,
+            headers=conditional.headers,
+            body_length=len(conditional.body),
+            trailers_present=False,
+        )
+        return FileBackedEntitySemanticsResult(
+            status=conditional.status,
+            headers=precondition_headers,
+            body=precondition_body,
+            not_modified=conditional.not_modified,
+            precondition_failed=conditional.precondition_failed,
+            head_response=method_upper == 'HEAD',
+        )
+
+    plan = plan_file_byte_ranges(
+        method=method_upper,
+        request_headers=request_headers,
+        response_headers=conditional.headers,
+        resource_length=body_length,
+        status=conditional.status,
+    )
+    headers = finalize_response_content_length(
+        method=method_upper,
+        status=plan.status,
+        headers=plan.headers,
+        body_length=plan.body_length,
+        trailers_present=trailers_present,
+    )
+
+    if method_upper == 'HEAD' or not response_allows_body(plan.status) or plan.unsatisfied:
+        return FileBackedEntitySemanticsResult(
+            status=plan.status,
+            headers=headers,
+            body=b'',
+            range_applied=plan.applied,
+            head_response=method_upper == 'HEAD',
+        )
+
+    body_segments = build_file_range_segments(
+        path=body_path,
+        plan=plan,
+        total_length=body_length,
+        source_content_type=get_header(conditional.headers, b'content-type'),
+    )
+    return FileBackedEntitySemanticsResult(
+        status=plan.status,
+        headers=headers,
+        body=b'',
+        body_segments=body_segments,
+        use_body_segments=True,
+        range_applied=plan.applied,
+    )
+
+
+def apply_response_entity_semantics(
+    *,
+    method: str,
+    request_headers: list[tuple[bytes, bytes]] | tuple[tuple[bytes, bytes], ...],
+    response_headers: list[tuple[bytes, bytes]],
+    body: bytes,
+    status: int,
+    content_coding_policy: str = 'allowlist',
+    supported_codings: tuple[str, ...] = ('br', 'gzip', 'deflate'),
+    apply_content_coding: bool = True,
+    generate_etag: bool = True,
+    trailers_present: bool = False,
+) -> EntitySemanticsResult:
+    method_upper = method.upper()
+    headers = _normalize_headers(response_headers)
+    range_present = get_header(request_headers, b'range') is not None and method_upper in {'GET', 'HEAD'}
+
+    if apply_content_coding and not range_present:
+        status, headers, body, selection = apply_http_content_coding(
+            request_headers=request_headers,
+            response_headers=headers,
+            body=body,
+            status=status,
+            policy=content_coding_policy,
+            supported=supported_codings,
+        )
+    else:
+        selection = _default_selection()
+
+    headers = _maybe_generate_etag(headers, body, enabled=generate_etag and status not in {412, 416} and not (100 <= status < 200))
+
+    conditional = apply_conditional_request(
+        method=method_upper,
+        request_headers=request_headers,
+        response_headers=headers,
+        body=body,
+        status=status,
+    )
+    status = conditional.status
+    headers = conditional.headers
+    body = conditional.body
+    range_applied = False
+
+    if not conditional.not_modified and not conditional.precondition_failed:
+        range_result = apply_byte_ranges(
+            method=method_upper,
+            request_headers=request_headers,
+            response_headers=headers,
+            body=body,
+            status=status,
+        )
+        status = range_result.status
+        headers = range_result.headers
+        body = range_result.body
+        range_applied = range_result.applied
+
+    if get_header(headers, b'accept-ranges') is None and status in {200, 206} and get_header(headers, b'content-encoding') is None:
+        append_if_missing(headers, b'accept-ranges', b'bytes')
+
+    headers = finalize_response_content_length(method=method_upper, status=status, headers=headers, body_length=len(body), trailers_present=trailers_present)
+
+    if method_upper == 'HEAD':
+        return EntitySemanticsResult(
+            status=status,
+            headers=headers,
+            body=b'',
+            content_coding=selection,
+            range_applied=range_applied,
+            not_modified=conditional.not_modified,
+            precondition_failed=conditional.precondition_failed,
+            head_response=True,
+        )
+
+    return EntitySemanticsResult(
+        status=status,
+        headers=headers,
+        body=body,
+        content_coding=selection,
+        range_applied=range_applied,
+        not_modified=conditional.not_modified,
+        precondition_failed=conditional.precondition_failed,
+    )
+
+
+__all__ = ['EntitySemanticsResult', 'FileBackedEntitySemanticsResult', 'apply_header_only_response_semantics', 'apply_response_entity_semantics', 'finalize_response_content_length', 'plan_file_backed_response_entity_semantics', 'should_materialize_response_body']