tigr-asgi-contract 0.1.2.dev7__py3-none-any.whl

tigr_asgi_contract/__init__.py

@@ -0,0 +1,22 @@
+from .version import CONTRACT_VERSION, CONTRACT_SERDE_VERSION
+from .scope_types import ScopeType
+from .bindings import Binding
+from .exchanges import Exchange
+from .families import Family
+from .subevents import Subevent
+from .completion import EmitCompletionLevel
+from .capabilities import FamilyCapabilities
+from .compatibility import Compatibility
+from .ids import UnitIds
+from .models import TlsMetadata, TransportMetadata, WebSocketScopeExt, SseScopeExt, WebTransportScopeExt, ScopeExt, DerivedEvent
+from .scope import ContractScope
+from .events import TransportEventType, ContractEvent
+from .validators import binding_supports_family, family_supports_subevent, binding_supports_subevent, binding_family_legality, binding_subevent_legality
+
+__all__ = [
+    "CONTRACT_VERSION", "CONTRACT_SERDE_VERSION", "ScopeType", "Binding", "Exchange", "Family", "Subevent",
+    "EmitCompletionLevel", "FamilyCapabilities", "Compatibility", "UnitIds", "TlsMetadata", "TransportMetadata",
+    "WebSocketScopeExt", "SseScopeExt", "WebTransportScopeExt", "ScopeExt", "DerivedEvent", "ContractScope",
+    "TransportEventType", "ContractEvent", "binding_supports_family", "family_supports_subevent",
+    "binding_supports_subevent", "binding_family_legality", "binding_subevent_legality",
+]

tigr_asgi_contract/_enum_compat.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+from enum import Enum
+
+try:
+    from enum import StrEnum
+except ImportError:
+    class StrEnum(str, Enum):
+        pass

tigr_asgi_contract/bindings.py

@@ -0,0 +1,10 @@
+from ._enum_compat import StrEnum
+
+
+class Binding(StrEnum):
+    REST = 'rest'
+    JSONRPC = 'jsonrpc'
+    HTTP_STREAM = 'http.stream'
+    SSE = 'sse'
+    WEBSOCKET = 'websocket'
+    WEBTRANSPORT = 'webtransport'

tigr_asgi_contract/capabilities.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+
+class FamilyCapabilities(BaseModel):
+    request: bool = False
+    session: bool = False
+    message: bool = False
+    stream_in: bool = False
+    stream_out: bool = False
+    datagram: bool = False

tigr_asgi_contract/compatibility.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+
+class Compatibility(BaseModel):
+    contract_name: str
+    contract_version: str
+    serde_version: int
+    schema_draft: str
+    min_tigrcorn_version: str | None = None
+    min_tigrbl_version: str | None = None

tigr_asgi_contract/completion.py

@@ -0,0 +1,6 @@
+from ._enum_compat import StrEnum
+
+
+class EmitCompletionLevel(StrEnum):
+    ACCEPTED_BY_RUNTIME = 'accepted_by_runtime'
+    FLUSHED_TO_TRANSPORT = 'flushed_to_transport'

tigr_asgi_contract/events.py

@@ -0,0 +1,29 @@
+from ._enum_compat import StrEnum
+from pydantic import BaseModel, Field
+
+
+class TransportEventType(StrEnum):
+    HTTP_REQUEST = 'http.request'
+    HTTP_DISCONNECT = 'http.disconnect'
+    HTTP_RESPONSE_START = 'http.response.start'
+    HTTP_RESPONSE_BODY = 'http.response.body'
+    WEBSOCKET_CONNECT = 'websocket.connect'
+    WEBSOCKET_RECEIVE = 'websocket.receive'
+    WEBSOCKET_DISCONNECT = 'websocket.disconnect'
+    WEBSOCKET_ACCEPT = 'websocket.accept'
+    WEBSOCKET_SEND = 'websocket.send'
+    WEBSOCKET_CLOSE = 'websocket.close'
+    WEBTRANSPORT_CONNECT = 'webtransport.connect'
+    WEBTRANSPORT_ACCEPT = 'webtransport.accept'
+    WEBTRANSPORT_STREAM_RECEIVE = 'webtransport.stream.receive'
+    WEBTRANSPORT_STREAM_SEND = 'webtransport.stream.send'
+    WEBTRANSPORT_DATAGRAM_RECEIVE = 'webtransport.datagram.receive'
+    WEBTRANSPORT_DATAGRAM_SEND = 'webtransport.datagram.send'
+    WEBTRANSPORT_DISCONNECT = 'webtransport.disconnect'
+    WEBTRANSPORT_CLOSE = 'webtransport.close'
+    TRANSPORT_EMIT_COMPLETE = 'transport.emit.complete'
+
+
+class ContractEvent(BaseModel):
+    type: TransportEventType
+    payload: dict = Field(default_factory=dict)

tigr_asgi_contract/exchanges.py

@@ -0,0 +1,7 @@
+from ._enum_compat import StrEnum
+
+
+class Exchange(StrEnum):
+    UNARY = 'unary'
+    SERVER_STREAM = 'server_stream'
+    DUPLEX = 'duplex'

tigr_asgi_contract/families.py

@@ -0,0 +1,9 @@
+from ._enum_compat import StrEnum
+
+
+class Family(StrEnum):
+    REQUEST = 'request'
+    SESSION = 'session'
+    MESSAGE = 'message'
+    STREAM = 'stream'
+    DATAGRAM = 'datagram'

tigr_asgi_contract/ids.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+
+class UnitIds(BaseModel):
+    unit_id: str | None = None
+    parent_unit_id: str | None = None
+    session_id: str | None = None
+    stream_id: int | None = None
+    datagram_id: int | None = None
+    emit_id: str | None = None

tigr_asgi_contract/models.py

@@ -0,0 +1,50 @@
+from pydantic import BaseModel
+from .capabilities import FamilyCapabilities
+
+
+class TlsMetadata(BaseModel):
+    version: str | None = None
+    cipher: str | None = None
+    verified: bool = False
+    peer_identity: str | None = None
+    peer_cert: dict | None = None
+
+
+class TransportMetadata(BaseModel):
+    binding: str
+    network: str
+    secure: bool
+    alpn: str | None = None
+    tls: TlsMetadata | None = None
+    framing: str | None = None
+
+
+class WebSocketScopeExt(BaseModel):
+    subprotocol: str | None = None
+
+
+class SseScopeExt(BaseModel):
+    retry_ms: int | None = None
+    last_event_id: str | None = None
+
+
+class WebTransportScopeExt(BaseModel):
+    session_id: str | None = None
+    supports_datagrams: bool = False
+    supports_bidi_streams: bool = False
+    supports_uni_streams: bool = False
+    max_datagram_size: int | None = None
+
+
+class ScopeExt(BaseModel):
+    transport: TransportMetadata
+    family_capabilities: FamilyCapabilities
+    websocket: WebSocketScopeExt | None = None
+    sse: SseScopeExt | None = None
+    webtransport: WebTransportScopeExt | None = None
+
+
+class DerivedEvent(BaseModel):
+    family: str
+    subevent: str
+    repeated: bool = False

tigr_asgi_contract/registry.py

@@ -0,0 +1,366 @@
+BINDING_FAMILY_MATRIX = {
+  "rest": {
+    "request": "R",
+    "session": "F",
+    "message": "F",
+    "stream": "O",
+    "datagram": "F"
+  },
+  "jsonrpc": {
+    "request": "R",
+    "session": "F",
+    "message": "F",
+    "stream": "O",
+    "datagram": "F"
+  },
+  "http.stream": {
+    "request": "R",
+    "session": "F",
+    "message": "F",
+    "stream": "R",
+    "datagram": "F"
+  },
+  "sse": {
+    "request": "R",
+    "session": "R",
+    "message": "R",
+    "stream": "R",
+    "datagram": "F"
+  },
+  "websocket": {
+    "request": "F",
+    "session": "R",
+    "message": "R",
+    "stream": "F",
+    "datagram": "F"
+  },
+  "webtransport": {
+    "request": "F",
+    "session": "R",
+    "message": "O",
+    "stream": "R",
+    "datagram": "R"
+  }
+}
+
+FAMILY_SUBEVENT_MATRIX = {
+  "request": {
+    "request.open": "R",
+    "request.body_in": "R",
+    "request.chunk_in": "R",
+    "request.accept": "R",
+    "request.close": "R",
+    "request.disconnect": "R",
+    "response.open": "R",
+    "response.body_out": "R",
+    "response.chunk_out": "R",
+    "response.close": "R",
+    "response.emit_complete": "R"
+  },
+  "session": {
+    "session.open": "R",
+    "session.accept": "R",
+    "session.ready": "R",
+    "session.heartbeat": "R",
+    "session.sync": "R",
+    "session.close": "R",
+    "session.disconnect": "R",
+    "session.emit_complete": "R"
+  },
+  "message": {
+    "message.in": "R",
+    "message.decode": "R",
+    "message.handle": "R",
+    "message.out": "R",
+    "message.ack": "R",
+    "message.nack": "R",
+    "message.replay": "R",
+    "message.snapshot": "R",
+    "message.emit_complete": "R"
+  },
+  "stream": {
+    "stream.open": "R",
+    "stream.chunk_in": "R",
+    "stream.chunk_out": "R",
+    "stream.flush": "R",
+    "stream.finalize": "R",
+    "stream.abort": "R",
+    "stream.close": "R",
+    "stream.emit_complete": "R"
+  },
+  "datagram": {
+    "datagram.in": "R",
+    "datagram.handle": "R",
+    "datagram.out": "R",
+    "datagram.ack": "R",
+    "datagram.close": "R",
+    "datagram.emit_complete": "R"
+  }
+}
+
+BINDING_SUBEVENT_MATRIX = {
+  "rest": {
+    "request.open": "R",
+    "request.body_in": "R",
+    "request.chunk_in": "F",
+    "request.accept": "O",
+    "request.close": "R",
+    "request.disconnect": "O",
+    "response.open": "R",
+    "response.body_out": "R",
+    "response.chunk_out": "F",
+    "response.close": "O",
+    "response.emit_complete": "R",
+    "session.open": "F",
+    "session.accept": "F",
+    "session.ready": "F",
+    "session.heartbeat": "F",
+    "session.sync": "F",
+    "session.close": "F",
+    "session.disconnect": "F",
+    "session.emit_complete": "F",
+    "message.in": "F",
+    "message.decode": "F",
+    "message.handle": "F",
+    "message.out": "F",
+    "message.ack": "F",
+    "message.nack": "F",
+    "message.replay": "F",
+    "message.snapshot": "F",
+    "message.emit_complete": "F",
+    "stream.open": "O",
+    "stream.chunk_in": "O",
+    "stream.chunk_out": "O",
+    "stream.flush": "F",
+    "stream.finalize": "O",
+    "stream.abort": "F",
+    "stream.close": "O",
+    "stream.emit_complete": "O",
+    "datagram.in": "F",
+    "datagram.handle": "F",
+    "datagram.out": "F",
+    "datagram.ack": "F",
+    "datagram.close": "F",
+    "datagram.emit_complete": "F"
+  },
+  "jsonrpc": {
+    "request.open": "R",
+    "request.body_in": "R",
+    "request.chunk_in": "F",
+    "request.accept": "O",
+    "request.close": "R",
+    "request.disconnect": "O",
+    "response.open": "R",
+    "response.body_out": "R",
+    "response.chunk_out": "F",
+    "response.close": "O",
+    "response.emit_complete": "R",
+    "session.open": "F",
+    "session.accept": "F",
+    "session.ready": "F",
+    "session.heartbeat": "F",
+    "session.sync": "F",
+    "session.close": "F",
+    "session.disconnect": "F",
+    "session.emit_complete": "F",
+    "message.in": "F",
+    "message.decode": "D",
+    "message.handle": "F",
+    "message.out": "F",
+    "message.ack": "F",
+    "message.nack": "F",
+    "message.replay": "F",
+    "message.snapshot": "F",
+    "message.emit_complete": "F",
+    "stream.open": "O",
+    "stream.chunk_in": "O",
+    "stream.chunk_out": "O",
+    "stream.flush": "F",
+    "stream.finalize": "O",
+    "stream.abort": "F",
+    "stream.close": "O",
+    "stream.emit_complete": "O",
+    "datagram.in": "F",
+    "datagram.handle": "F",
+    "datagram.out": "F",
+    "datagram.ack": "F",
+    "datagram.close": "F",
+    "datagram.emit_complete": "F"
+  },
+  "http.stream": {
+    "request.open": "R",
+    "request.body_in": "O",
+    "request.chunk_in": "D",
+    "request.accept": "O",
+    "request.close": "R",
+    "request.disconnect": "O",
+    "response.open": "R",
+    "response.body_out": "O",
+    "response.chunk_out": "D",
+    "response.close": "O",
+    "response.emit_complete": "R",
+    "session.open": "F",
+    "session.accept": "F",
+    "session.ready": "F",
+    "session.heartbeat": "F",
+    "session.sync": "F",
+    "session.close": "F",
+    "session.disconnect": "F",
+    "session.emit_complete": "F",
+    "message.in": "F",
+    "message.decode": "F",
+    "message.handle": "F",
+    "message.out": "F",
+    "message.ack": "F",
+    "message.nack": "F",
+    "message.replay": "F",
+    "message.snapshot": "F",
+    "message.emit_complete": "F",
+    "stream.open": "R",
+    "stream.chunk_in": "R",
+    "stream.chunk_out": "R",
+    "stream.flush": "O",
+    "stream.finalize": "R",
+    "stream.abort": "O",
+    "stream.close": "R",
+    "stream.emit_complete": "R",
+    "datagram.in": "F",
+    "datagram.handle": "F",
+    "datagram.out": "F",
+    "datagram.ack": "F",
+    "datagram.close": "F",
+    "datagram.emit_complete": "F"
+  },
+  "sse": {
+    "request.open": "R",
+    "request.body_in": "O",
+    "request.chunk_in": "F",
+    "request.accept": "O",
+    "request.close": "R",
+    "request.disconnect": "O",
+    "response.open": "O",
+    "response.body_out": "F",
+    "response.chunk_out": "D",
+    "response.close": "O",
+    "response.emit_complete": "R",
+    "session.open": "R",
+    "session.accept": "R",
+    "session.ready": "R",
+    "session.heartbeat": "O",
+    "session.sync": "O",
+    "session.close": "R",
+    "session.disconnect": "O",
+    "session.emit_complete": "O",
+    "message.in": "F",
+    "message.decode": "F",
+    "message.handle": "F",
+    "message.out": "R",
+    "message.ack": "F",
+    "message.nack": "F",
+    "message.replay": "O",
+    "message.snapshot": "O",
+    "message.emit_complete": "R",
+    "stream.open": "R",
+    "stream.chunk_in": "F",
+    "stream.chunk_out": "R",
+    "stream.flush": "O",
+    "stream.finalize": "O",
+    "stream.abort": "O",
+    "stream.close": "R",
+    "stream.emit_complete": "R",
+    "datagram.in": "F",
+    "datagram.handle": "F",
+    "datagram.out": "F",
+    "datagram.ack": "F",
+    "datagram.close": "F",
+    "datagram.emit_complete": "F"
+  },
+  "websocket": {
+    "request.open": "F",
+    "request.body_in": "F",
+    "request.chunk_in": "F",
+    "request.accept": "F",
+    "request.close": "F",
+    "request.disconnect": "F",
+    "response.open": "F",
+    "response.body_out": "F",
+    "response.chunk_out": "F",
+    "response.close": "F",
+    "response.emit_complete": "F",
+    "session.open": "R",
+    "session.accept": "R",
+    "session.ready": "R",
+    "session.heartbeat": "O",
+    "session.sync": "O",
+    "session.close": "R",
+    "session.disconnect": "O",
+    "session.emit_complete": "O",
+    "message.in": "R",
+    "message.decode": "O",
+    "message.handle": "R",
+    "message.out": "R",
+    "message.ack": "O",
+    "message.nack": "O",
+    "message.replay": "O",
+    "message.snapshot": "O",
+    "message.emit_complete": "R",
+    "stream.open": "F",
+    "stream.chunk_in": "F",
+    "stream.chunk_out": "F",
+    "stream.flush": "F",
+    "stream.finalize": "F",
+    "stream.abort": "F",
+    "stream.close": "F",
+    "stream.emit_complete": "F",
+    "datagram.in": "F",
+    "datagram.handle": "F",
+    "datagram.out": "F",
+    "datagram.ack": "F",
+    "datagram.close": "F",
+    "datagram.emit_complete": "F"
+  },
+  "webtransport": {
+    "request.open": "F",
+    "request.body_in": "F",
+    "request.chunk_in": "F",
+    "request.accept": "F",
+    "request.close": "F",
+    "request.disconnect": "F",
+    "response.open": "F",
+    "response.body_out": "F",
+    "response.chunk_out": "F",
+    "response.close": "F",
+    "response.emit_complete": "F",
+    "session.open": "R",
+    "session.accept": "R",
+    "session.ready": "R",
+    "session.heartbeat": "O",
+    "session.sync": "O",
+    "session.close": "R",
+    "session.disconnect": "O",
+    "session.emit_complete": "O",
+    "message.in": "O",
+    "message.decode": "O",
+    "message.handle": "O",
+    "message.out": "O",
+    "message.ack": "O",
+    "message.nack": "O",
+    "message.replay": "O",
+    "message.snapshot": "O",
+    "message.emit_complete": "O",
+    "stream.open": "R",
+    "stream.chunk_in": "R",
+    "stream.chunk_out": "R",
+    "stream.flush": "O",
+    "stream.finalize": "R",
+    "stream.abort": "O",
+    "stream.close": "R",
+    "stream.emit_complete": "R",
+    "datagram.in": "R",
+    "datagram.handle": "R",
+    "datagram.out": "R",
+    "datagram.ack": "O",
+    "datagram.close": "R",
+    "datagram.emit_complete": "R"
+  }
+}

tigr_asgi_contract/scope.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from .models import ScopeExt
+
+
+class ContractScope(BaseModel):
+    type: str
+    asgi: dict
+    scheme: str
+    http_version: str | None = None
+    method: str | None = None
+    path: str
+    query_string: bytes = b""
+    headers: list[tuple[bytes, bytes]]
+    client: tuple[str, int] | None = None
+    server: tuple[str, int] | None = None
+    ext: ScopeExt

tigr_asgi_contract/scope_types.py

@@ -0,0 +1,8 @@
+from ._enum_compat import StrEnum
+
+
+class ScopeType(StrEnum):
+    HTTP = 'http'
+    WEBSOCKET = 'websocket'
+    LIFESPAN = 'lifespan'
+    WEBTRANSPORT = 'webtransport'

tigr_asgi_contract/subevents.py

@@ -0,0 +1,46 @@
+from ._enum_compat import StrEnum
+
+
+class Subevent(StrEnum):
+    REQUEST_OPEN = 'request.open'
+    REQUEST_BODY_IN = 'request.body_in'
+    REQUEST_CHUNK_IN = 'request.chunk_in'
+    REQUEST_ACCEPT = 'request.accept'
+    REQUEST_CLOSE = 'request.close'
+    REQUEST_DISCONNECT = 'request.disconnect'
+    RESPONSE_OPEN = 'response.open'
+    RESPONSE_BODY_OUT = 'response.body_out'
+    RESPONSE_CHUNK_OUT = 'response.chunk_out'
+    RESPONSE_CLOSE = 'response.close'
+    RESPONSE_EMIT_COMPLETE = 'response.emit_complete'
+    SESSION_OPEN = 'session.open'
+    SESSION_ACCEPT = 'session.accept'
+    SESSION_READY = 'session.ready'
+    SESSION_HEARTBEAT = 'session.heartbeat'
+    SESSION_SYNC = 'session.sync'
+    SESSION_CLOSE = 'session.close'
+    SESSION_DISCONNECT = 'session.disconnect'
+    SESSION_EMIT_COMPLETE = 'session.emit_complete'
+    MESSAGE_IN = 'message.in'
+    MESSAGE_DECODE = 'message.decode'
+    MESSAGE_HANDLE = 'message.handle'
+    MESSAGE_OUT = 'message.out'
+    MESSAGE_ACK = 'message.ack'
+    MESSAGE_NACK = 'message.nack'
+    MESSAGE_REPLAY = 'message.replay'
+    MESSAGE_SNAPSHOT = 'message.snapshot'
+    MESSAGE_EMIT_COMPLETE = 'message.emit_complete'
+    STREAM_OPEN = 'stream.open'
+    STREAM_CHUNK_IN = 'stream.chunk_in'
+    STREAM_CHUNK_OUT = 'stream.chunk_out'
+    STREAM_FLUSH = 'stream.flush'
+    STREAM_FINALIZE = 'stream.finalize'
+    STREAM_ABORT = 'stream.abort'
+    STREAM_CLOSE = 'stream.close'
+    STREAM_EMIT_COMPLETE = 'stream.emit_complete'
+    DATAGRAM_IN = 'datagram.in'
+    DATAGRAM_HANDLE = 'datagram.handle'
+    DATAGRAM_OUT = 'datagram.out'
+    DATAGRAM_ACK = 'datagram.ack'
+    DATAGRAM_CLOSE = 'datagram.close'
+    DATAGRAM_EMIT_COMPLETE = 'datagram.emit_complete'

tigr_asgi_contract/validators.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+from .registry import BINDING_FAMILY_MATRIX, FAMILY_SUBEVENT_MATRIX, BINDING_SUBEVENT_MATRIX
+
+
+def binding_supports_family(binding: str, family: str) -> bool:
+    return BINDING_FAMILY_MATRIX[binding][family] != "F"
+
+
+def family_supports_subevent(family: str, subevent: str) -> bool:
+    return FAMILY_SUBEVENT_MATRIX[family].get(subevent) != "F"
+
+
+def binding_supports_subevent(binding: str, subevent: str) -> bool:
+    return BINDING_SUBEVENT_MATRIX[binding].get(subevent) != "F"
+
+
+def binding_family_legality(binding: str, family: str) -> str:
+    return BINDING_FAMILY_MATRIX[binding][family]
+
+
+def binding_subevent_legality(binding: str, subevent: str) -> str:
+    return BINDING_SUBEVENT_MATRIX[binding][subevent]

tigr_asgi_contract/version.py

@@ -0,0 +1,2 @@
+CONTRACT_VERSION = "0.1.2-dev7"
+CONTRACT_SERDE_VERSION = 1