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

tigrcorn_asgi/__init__.py

@@ -0,0 +1 @@
+__all__ = []

tigrcorn_asgi/connection.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from tigrcorn_core.types import Receive, Scope, Send
+
+
+@dataclass(slots=True)
+class ASGIConnection:
+    scope: Scope
+    receive: Receive
+    send: Send

tigrcorn_asgi/errors.py

@@ -0,0 +1,2 @@
+class ASGIProtocolError(Exception):
+    """Raised when the application sends an invalid ASGI message sequence."""

tigrcorn_asgi/events/__init__.py

@@ -0,0 +1 @@
+__all__ = []

tigrcorn_asgi/events/custom.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+
+def custom_event(event_type: str, **payload) -> dict:
+    return {"type": event_type, **payload}
+
+
+def stream_receive(data: bytes, *, more_data: bool = False) -> dict:
+    return custom_event("tigrcorn.stream.receive", data=data, more_data=more_data)
+
+
+def stream_send(data: bytes, *, more_data: bool = False) -> dict:
+    return custom_event("tigrcorn.stream.send", data=data, more_data=more_data)

tigrcorn_asgi/events/http.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+
+def http_request(body: bytes = b"", more_body: bool = False) -> dict:
+    return {"type": "http.request", "body": body, "more_body": more_body}
+
+
+def http_request_trailers(trailers: list[tuple[bytes, bytes]]) -> dict:
+    return {"type": "http.request.trailers", "trailers": trailers}
+
+
+def http_disconnect() -> dict:
+    return {"type": "http.disconnect"}

tigrcorn_asgi/events/lifespan.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+
+def lifespan_startup() -> dict:
+    return {"type": "lifespan.startup"}
+
+
+def lifespan_shutdown() -> dict:
+    return {"type": "lifespan.shutdown"}

tigrcorn_asgi/events/websocket.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+
+def websocket_connect() -> dict:
+    return {"type": "websocket.connect"}
+
+
+def websocket_receive_text(text: str) -> dict:
+    return {"type": "websocket.receive", "text": text, "bytes": None}
+
+
+def websocket_receive_bytes(data: bytes) -> dict:
+    return {"type": "websocket.receive", "text": None, "bytes": data}
+
+
+def websocket_disconnect(code: int = 1005, reason: str = "") -> dict:
+    return {"type": "websocket.disconnect", "code": code, "reason": reason}

tigrcorn_asgi/extensions/__init__.py

@@ -0,0 +1 @@
+__all__ = []

tigrcorn_asgi/extensions/tls.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+
+def tls_extension(selected_alpn_protocol: str | None = None, peer_cert: dict | None = None) -> dict:
+    ext = {}
+    if selected_alpn_protocol is not None:
+        ext['selected_alpn_protocol'] = selected_alpn_protocol
+    if peer_cert is not None:
+        ext['peer_cert'] = peer_cert
+    return ext

tigrcorn_asgi/extensions/websocket_denial.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+
+def websocket_denial_extension() -> dict:
+    return {'websocket.http.response': {}}

tigrcorn_asgi/py.typed

@@ -0,0 +1 @@
+

tigrcorn_asgi/receive.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+
+from tigrcorn_asgi.events.http import http_disconnect, http_request, http_request_trailers
+from tigrcorn_asgi.events.lifespan import lifespan_shutdown, lifespan_startup
+from tigrcorn_core.errors import ProtocolError
+from tigrcorn_protocols.http1.parser import _validate_header_name, _validate_header_value
+from tigrcorn_core.types import Message, StreamReaderLike
+
+
+
+FORBIDDEN_REQUEST_TRAILER_NAMES = {
+    b'content-length',
+    b'transfer-encoding',
+    b'host',
+    b'trailer',
+    b'content-encoding',
+    b'content-type',
+}
+
+
+def apply_request_trailer_policy(
+    trailers: list[tuple[bytes, bytes]] | tuple[tuple[bytes, bytes], ...],
+    policy: str,
+) -> list[tuple[bytes, bytes]]:
+    normalized = [(bytes(name).lower(), bytes(value)) for name, value in trailers]
+    if policy == 'drop':
+        return []
+    if policy == 'strict':
+        forbidden = [name for name, _value in normalized if name in FORBIDDEN_REQUEST_TRAILER_NAMES]
+        if forbidden:
+            raise ProtocolError(f'forbidden request trailer fields: {forbidden!r}')
+    return normalized
+
+
+class HTTPRequestReceive:
+    """Buffered HTTP request body exposed as ASGI receive events."""
+
+    def __init__(self, body: bytes, *, trailers: list[tuple[bytes, bytes]] | None = None, trailer_policy: str = 'pass') -> None:
+        self._body = body
+        self._trailers = apply_request_trailer_policy(list(trailers or ()), trailer_policy)
+        self._sent_body = False
+        self._sent_trailers = False
+
+    async def __call__(self) -> Message:
+        if not self._sent_body:
+            self._sent_body = True
+            return http_request(self._body, False)
+        if self._trailers and not self._sent_trailers:
+            self._sent_trailers = True
+            return http_request_trailers(self._trailers)
+        return http_disconnect()
+
+
+class HTTPStreamingRequestReceive:
+    """Reader-backed HTTP/1.1 request body exposed incrementally as ASGI events."""
+
+    def __init__(
+        self,
+        *,
+        reader: StreamReaderLike,
+        content_length: int | None,
+        chunked: bool,
+        max_body_size: int,
+        expect_continue: bool = False,
+        on_expect_continue: Callable[[], Awaitable[None]] | None = None,
+        max_chunk_size: int = 65_536,
+        trailer_policy: str = 'pass',
+    ) -> None:
+        if content_length is not None and content_length < 0:
+            raise ValueError('content_length must be non-negative')
+        self._reader = reader
+        self._remaining = content_length
+        self._chunked = chunked
+        self._max_body_size = max_body_size
+        self._max_chunk_size = max_chunk_size
+        self._expect_continue = expect_continue
+        self._on_expect_continue = on_expect_continue
+        self._continue_sent = False
+        self._sent_final = False
+        self._disconnected = False
+        self._total_read = 0
+        self.body_complete = not chunked and (content_length is None or content_length == 0)
+        self._trailers_sent = False
+        self.trailer_policy = trailer_policy
+        self.trailers: list[tuple[bytes, bytes]] = []
+
+    async def __call__(self) -> Message:
+        if self._disconnected:
+            return http_disconnect()
+        if self._sent_final:
+            if self.trailers and not self._trailers_sent:
+                self._trailers_sent = True
+                return http_request_trailers(self.trailers)
+            self._disconnected = True
+            return http_disconnect()
+        await self._maybe_send_continue()
+        if self._chunked:
+            return await self._next_chunked_event()
+        if self._remaining is None or self._remaining == 0:
+            self.body_complete = True
+            self._sent_final = True
+            return http_request(b'', False)
+        amount = min(self._remaining, self._max_chunk_size)
+        data = await self._readexactly(amount)
+        self._remaining -= len(data)
+        self._total_read += len(data)
+        if self._total_read > self._max_body_size:
+            raise ProtocolError('request body exceeds configured max_body_size')
+        more_body = self._remaining > 0
+        if not more_body:
+            self.body_complete = True
+            self._sent_final = True
+        return http_request(data, more_body)
+
+    async def _maybe_send_continue(self) -> None:
+        if (
+            self._expect_continue
+            and not self._continue_sent
+            and not self.body_complete
+            and self._on_expect_continue is not None
+        ):
+            self._continue_sent = True
+            await self._on_expect_continue()
+
+    async def _read_line(self) -> bytes:
+        try:
+            return await self._reader.readuntil(b'\r\n')
+        except asyncio.IncompleteReadError as exc:
+            raise ProtocolError('unexpected EOF while reading HTTP/1.1 body') from exc
+
+    async def _readexactly(self, amount: int) -> bytes:
+        try:
+            return await self._reader.readexactly(amount)
+        except asyncio.IncompleteReadError as exc:
+            raise ProtocolError('unexpected EOF while reading HTTP/1.1 body') from exc
+
+    async def _consume_trailers(self) -> None:
+        trailers: list[tuple[bytes, bytes]] = []
+        while True:
+            trailer = await self._read_line()
+            if trailer == b'\r\n':
+                self.trailers = apply_request_trailer_policy(trailers, self.trailer_policy)
+                return
+            if trailer[:1] in {b' ', b'\t'}:
+                raise ProtocolError('obsolete line folding is not supported')
+            if b':' not in trailer[:-2]:
+                raise ProtocolError('malformed chunk trailer line')
+            name, value = trailer[:-2].split(b':', 1)
+            normalized_name = name.strip().lower()
+            normalized_value = value.strip()
+            _validate_header_name(normalized_name)
+            _validate_header_value(normalized_value)
+            trailers.append((normalized_name, normalized_value))
+
+    async def _next_chunked_event(self) -> Message:
+        line = await self._read_line()
+        size_token = line[:-2].split(b';', 1)[0].strip()
+        try:
+            size = int(size_token, 16)
+        except ValueError as exc:
+            raise ProtocolError('invalid chunk size') from exc
+        if size < 0:
+            raise ProtocolError('invalid chunk size')
+        if size == 0:
+            await self._consume_trailers()
+            self.body_complete = True
+            self._sent_final = True
+            return http_request(b'', False)
+        data = await self._readexactly(size)
+        terminator = await self._readexactly(2)
+        if terminator != b'\r\n':
+            raise ProtocolError('invalid chunk terminator')
+        self._total_read += size
+        if self._total_read > self._max_body_size:
+            raise ProtocolError('request body exceeds configured max_body_size')
+        return http_request(data, True)
+
+
+class QueueReceive:
+    def __init__(self, max_size: int | None = None) -> None:
+        self.max_size = max_size
+        self._queue: asyncio.Queue[Message] = asyncio.Queue(maxsize=0 if not max_size else max_size)
+
+    async def put(self, message: Message) -> None:
+        await self._queue.put(message)
+
+    async def __call__(self) -> Message:
+        return await self._queue.get()
+
+
+
+class LifespanReceive(QueueReceive):
+    async def startup(self) -> None:
+        await self.put(lifespan_startup())
+
+    async def shutdown(self) -> None:
+        await self.put(lifespan_shutdown())

tigrcorn_asgi/scopes/__init__.py

@@ -0,0 +1 @@
+__all__ = []

tigrcorn_asgi/scopes/custom.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from tigrcorn_core.constants import ASGI_SPEC_VERSION, ASGI_VERSION
+
+
+def build_custom_scope(scope_type: str, **fields) -> dict:
+    scope = {
+        "type": scope_type,
+        "asgi": {"version": ASGI_VERSION, "spec_version": ASGI_SPEC_VERSION},
+    }
+    scope.update(fields)
+    return scope

tigrcorn_asgi/scopes/http.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import Any
+
+from tigrcorn_core.constants import ASGI_SPEC_VERSION, ASGI_VERSION
+from tigrcorn_protocols.http1.parser import ParsedRequest, ParsedRequestHead
+from tigrcorn_core.types import Scope
+from tigrcorn_core.utils.proxy import resolve_proxy_view, strip_root_path
+
+
+def build_http_scope(
+    request: ParsedRequest | ParsedRequestHead,
+    *,
+    client: tuple[str, int] | None,
+    server: tuple[str, int] | tuple[str, None] | None,
+    scheme: str = "http",
+    extensions: dict | None = None,
+    root_path: str = "",
+    proxy: Any | None = None,
+) -> Scope:
+    if proxy is not None:
+        proxy_view = resolve_proxy_view(
+            request.headers,
+            client=client,
+            server=server,
+            scheme=scheme,
+            root_path=root_path,
+            enabled=bool(getattr(proxy, 'proxy_headers', False)),
+            forwarded_allow_ips=tuple(getattr(proxy, 'forwarded_allow_ips', []) or ()),
+        )
+        client = proxy_view.client
+        server = proxy_view.server
+        scheme = proxy_view.scheme
+        root_path = proxy_view.root_path
+    path, raw_path = strip_root_path(request.path, request.raw_path, root_path)
+    scope: Scope = {
+        "type": "http",
+        "asgi": {"version": ASGI_VERSION, "spec_version": ASGI_SPEC_VERSION},
+        "http_version": request.http_version,
+        "method": request.method,
+        "scheme": scheme,
+        "path": path,
+        "raw_path": raw_path,
+        "query_string": request.query_string,
+        "root_path": root_path,
+        "headers": request.headers,
+        "client": client,
+        "server": server,
+        "extensions": extensions or {},
+    }
+    return scope

tigrcorn_asgi/scopes/lifespan.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from tigrcorn_core.constants import ASGI_SPEC_VERSION, ASGI_VERSION
+from tigrcorn_core.types import Scope
+
+
+def build_lifespan_scope() -> Scope:
+    return {
+        "type": "lifespan",
+        "asgi": {"version": ASGI_VERSION, "spec_version": ASGI_SPEC_VERSION},
+        "state": {},
+    }

tigrcorn_asgi/scopes/websocket.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import Any
+
+from tigrcorn_core.constants import ASGI_VERSION, WEBSOCKET_SPEC_VERSION
+from tigrcorn_protocols.http1.parser import ParsedRequest
+from tigrcorn_core.types import Scope
+from tigrcorn_core.utils.headers import get_header
+from tigrcorn_core.utils.proxy import resolve_proxy_view, strip_root_path
+
+
+def build_websocket_scope(
+    request: ParsedRequest,
+    *,
+    client: tuple[str, int] | None,
+    server: tuple[str, int] | tuple[str, None] | None,
+    scheme: str = "ws",
+    extensions: dict | None = None,
+    root_path: str = "",
+    proxy: Any | None = None,
+) -> Scope:
+    if proxy is not None:
+        proxy_view = resolve_proxy_view(
+            request.headers,
+            client=client,
+            server=server,
+            scheme=scheme,
+            root_path=root_path,
+            enabled=bool(getattr(proxy, 'proxy_headers', False)),
+            forwarded_allow_ips=tuple(getattr(proxy, 'forwarded_allow_ips', []) or ()),
+        )
+        client = proxy_view.client
+        server = proxy_view.server
+        scheme = proxy_view.scheme
+        root_path = proxy_view.root_path
+    path, raw_path = strip_root_path(request.path, request.raw_path, root_path)
+    subprotocol_header = get_header(request.headers, b"sec-websocket-protocol")
+    subprotocols = []
+    if subprotocol_header:
+        subprotocols = [part.strip().decode("ascii", "ignore") for part in subprotocol_header.split(b",") if part.strip()]
+    scope_extensions = {"websocket.http.response": {}}
+    if extensions:
+        scope_extensions.update(extensions)
+    scope: Scope = {
+        "type": "websocket",
+        "asgi": {"version": ASGI_VERSION, "spec_version": WEBSOCKET_SPEC_VERSION},
+        "http_version": request.http_version,
+        "scheme": scheme,
+        "path": path,
+        "raw_path": raw_path,
+        "query_string": request.query_string,
+        "root_path": root_path,
+        "headers": request.headers,
+        "client": client,
+        "server": server,
+        "subprotocols": subprotocols,
+        "extensions": scope_extensions,
+    }
+    return scope