latch-asgi 0.2.0__tar.gz → 1.0.0__tar.gz

latch_asgi-1.0.0/COPYING

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

latch_asgi-1.0.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: latch-asgi
+Version: 1.0.0
+Summary: ASGI python server
+Author-Email: Max Smolin <max@latch.bio>
+License: CC0-1.0
+Requires-Python: <4.0,>=3.11
+Requires-Dist: hypercorn[uvloop]<1.0.0,>=0.14.3
+Requires-Dist: latch-data-validation<1.0.0,>=0.1.3
+Requires-Dist: latch-o11y<1.0.0,>=0.1.4
+Requires-Dist: latch-config<1.0.0,>=0.1.6
+Requires-Dist: PyJWT[crypto]<3.0.0,>=2.6.0
+Requires-Dist: orjson<4.0.0,>=3.8.5
+Requires-Dist: opentelemetry-sdk<2.0.0,>=1.15.0
+Requires-Dist: opentelemetry-api<2.0.0,>=1.15.0
+Description-Content-Type: text/markdown
+
+# python-asgi

latch_asgi-1.0.0/latch_asgi/asgi_iface.py

@@ -0,0 +1,72 @@
+from collections.abc import Awaitable, Callable
+from typing import TypeAlias
+
+from hypercorn.typing import (
+    HTTPDisconnectEvent,
+    HTTPRequestEvent,
+    HTTPResponseBodyEvent,
+    HTTPResponseStartEvent,
+    HTTPServerPushEvent,
+    LifespanShutdownCompleteEvent,
+    LifespanShutdownEvent,
+    LifespanShutdownFailedEvent,
+    LifespanStartupCompleteEvent,
+    LifespanStartupEvent,
+    LifespanStartupFailedEvent,
+    WebsocketAcceptEvent,
+    WebsocketCloseEvent,
+    WebsocketConnectEvent,
+    WebsocketDisconnectEvent,
+    WebsocketReceiveEvent,
+    WebsocketResponseBodyEvent,
+    WebsocketResponseStartEvent,
+    WebsocketSendEvent,
+)
+
+# >>> Lifespan
+LifespanReceiveEvent: TypeAlias = LifespanStartupEvent | LifespanShutdownEvent
+LifespanReceiveCallable: TypeAlias = Callable[[], Awaitable[LifespanReceiveEvent]]
+
+LifespanShutdownSendEvent: TypeAlias = (
+    LifespanShutdownCompleteEvent | LifespanShutdownFailedEvent
+)
+LifespanStartupSendEvent: TypeAlias = (
+    LifespanStartupCompleteEvent | LifespanStartupFailedEvent
+)
+
+LifespanSendEvent: TypeAlias = LifespanStartupSendEvent | LifespanShutdownSendEvent
+LifespanSendCallable: TypeAlias = Callable[[LifespanSendEvent], Awaitable[None]]
+
+# >>> HTTP
+
+HTTPReceiveEvent: TypeAlias = HTTPRequestEvent | HTTPDisconnectEvent
+HTTPReceiveCallable: TypeAlias = Callable[[], Awaitable[HTTPReceiveEvent]]
+
+HTTPSendEvent: TypeAlias = (
+    HTTPResponseStartEvent
+    | HTTPResponseBodyEvent
+    | HTTPServerPushEvent
+    | HTTPDisconnectEvent
+)
+HTTPSendCallable: TypeAlias = Callable[[HTTPSendEvent], Awaitable[None]]
+
+# >>> Websocket
+
+WebsocketReceiveEventT: TypeAlias = (
+    WebsocketConnectEvent | WebsocketReceiveEvent | WebsocketDisconnectEvent
+)
+WebsocketReceiveCallable: TypeAlias = Callable[[], Awaitable[WebsocketReceiveEventT]]
+
+WebsocketSendEventT: TypeAlias = (
+    WebsocketAcceptEvent
+    | WebsocketSendEvent
+    | WebsocketResponseBodyEvent
+    | WebsocketResponseStartEvent
+    | WebsocketCloseEvent
+)
+WebsocketSendCallable: TypeAlias = Callable[[WebsocketSendEventT], Awaitable[None]]
+
+# >>> WWW
+
+WWWReceiveCallable = HTTPReceiveCallable | WebsocketReceiveCallable
+WWWSendCallable = HTTPSendCallable | WebsocketSendCallable

{latch_asgi-0.2.0 → latch_asgi-1.0.0}/latch_asgi/auth.py

@@ -3,7 +3,7 @@
 import re
 from dataclasses import dataclass
 from http import HTTPStatus
-from typing import Literal
+from typing import Literal, Self
 
 import jwt
 from jwt import PyJWKClient
@@ -37,14 +37,10 @@ class _HTTPUnauthorized(HTTPErrorResponse):
     """WARNING: HTTPForbidden is the correct error to use in virtually all cases"""
 
     def __init__(
-        self,
+        self: Self,
         error_description: str,
-        error: (
-            Literal["invalid_request"]
-            | Literal["invalid_token"]
-            | Literal["insufficient_scope"]
-        ),
-    ):
+        error: (Literal["invalid_request", "invalid_token", "insufficient_scope"]),
+    ) -> None:
         escaped_description = error_description.replace('"', '\\"')
         super().__init__(
             HTTPStatus.UNAUTHORIZED,
@@ -63,7 +59,7 @@ class Authorization:
     execution_token: str | None = None
     sdk_token: str | None = None
 
-    def unauthorized_if_none(self):
+    def unauthorized_if_none(self: Self) -> None:
         if self.oauth_sub is not None:
             return
         if self.execution_token is not None:
@@ -71,10 +67,7 @@ class Authorization:
         if self.sdk_token is not None:
             return
 
-        raise _HTTPUnauthorized(
-            "Authenticaton required",
-            error="invalid_request",
-        )
+        raise _HTTPUnauthorized("Authenticaton required", error="invalid_request")
 
 
 @trace_app_function
@@ -121,8 +114,7 @@ def get_signer_sub(auth_header: str) -> Authorization:
             jwt_key = jwk_client.get_signing_key_from_jwt(oauth_token).key
         except jwt.exceptions.InvalidTokenError as e:
             raise _HTTPUnauthorized(
-                error_description="JWT decoding failed",
-                error="invalid_token",
+                error_description="JWT decoding failed", error="invalid_token"
             ) from e
         except jwt.exceptions.PyJWKClientError:
             # fixme(maximsmol): gut this abomination

{latch_asgi-0.2.0 → latch_asgi-1.0.0}/latch_asgi/config.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+
 from latch_config.config import read_config
 
 
@@ -8,4 +9,5 @@ class AuthConfig:
     self_signed_jwk: str
     allow_spoofing: bool = False
 
+
 config = read_config(AuthConfig, "auth_")

{latch_asgi-0.2.0 → latch_asgi-1.0.0}/latch_asgi/context/common.py

@@ -1,61 +1,72 @@
 from dataclasses import dataclass, field
-from typing import Generic, TypeVar
-
-from latch_o11y.o11y import AttributesDict, app_tracer, trace_app_function
-
-from ..asgi_iface import WWWReceiveCallable, WWWScope, WWWSendCallable
+from typing import Generic, Self, TypeVar
+
+from hypercorn.typing import WWWScope
+from latch_o11y.o11y import (
+    AttributesDict,
+    app_tracer,
+    dict_to_attrs,
+    trace_app_function,
+)
+from opentelemetry.util.types import AttributeValue
+
+from ..asgi_iface import WWWReceiveCallable, WWWSendCallable
 from ..auth import Authorization, get_signer_sub
+from ..framework.common import otel_header_whitelist
+from ..framework.http import current_http_request_span
 
-# todo(ayush): this sucks
 Scope = TypeVar("Scope", bound=WWWScope)
-Send = TypeVar("Send", bound=WWWSendCallable)
-Receive = TypeVar("Receive", bound=WWWReceiveCallable)
+SendCallable = TypeVar("SendCallable", bound=WWWSendCallable)
+ReceiveCallable = TypeVar("ReceiveCallable", bound=WWWReceiveCallable)
 
 
 @dataclass
-class Context(Generic[Scope, Receive, Send]):
+class Context(Generic[Scope, ReceiveCallable, SendCallable]):
     scope: Scope
-    receive: Receive
-    send: Send
+    receive: ReceiveCallable
+    send: SendCallable
 
     auth: Authorization = field(default_factory=Authorization, init=False)
 
     _header_cache: dict[bytes, bytes] = field(default_factory=dict, init=False)
     _db_response_idx: int = field(default=0, init=False)
 
-    def __post_init__(self):
+    def __post_init__(self: Self) -> None:
         with app_tracer.start_as_current_span("find Authentication header"):
             auth_header = self.header_str("authorization")
 
         if auth_header is not None:
             self.auth = get_signer_sub(auth_header)
 
-    def header(self, x: str | bytes):
+        if self.auth.oauth_sub is not None:
+            current_http_request_span().set_attribute("enduser.id", self.auth.oauth_sub)
+
+    def header(self: Self, x: str | bytes) -> bytes | None:
         if isinstance(x, str):
-            x = x.encode("utf-8")
+            x = x.encode("latin-1")
 
         if x in self._header_cache:
             return self._header_cache[x]
 
-        for k, v in self.scope.headers:
+        for k, v in self.scope["headers"]:
             self._header_cache[k] = v
             if k == x:
                 return v
 
         return None
 
-    def header_str(self, x: str | bytes):
+    def header_str(self: Self, x: str | bytes) -> str | None:
         res = self.header(x)
         if res is None:
             return None
 
         return res.decode("latin-1")
 
-    def add_request_span_attrs(self, data: AttributesDict, prefix: str):
-        raise NotImplementedError()
+    def add_request_span_attrs(self: Self, data: AttributesDict, prefix: str) -> None:
+        current_http_request_span().set_attributes(dict_to_attrs(data, prefix))
 
     @trace_app_function
-    def add_db_response(self, data: AttributesDict):
+    def add_db_response(self: Self, data: AttributesDict) -> None:
         # todo(maximsmol): datadog has shit support for events
         # current_http_request_span().add_event(
         #     f"database response {self._db_response_idx}", dict_to_attrs(data, "data")

latch_asgi-1.0.0/latch_asgi/context/http.py

@@ -0,0 +1,28 @@
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Any, Self, TypeAlias, TypeVar
+
+from hypercorn.typing import HTTPScope
+from latch_o11y.o11y import trace_app_function
+
+from ..asgi_iface import HTTPReceiveCallable, HTTPSendCallable
+from ..framework.http import HTTPMethod, receive_class_ext
+from . import common
+
+T = TypeVar("T")
+
+
+@dataclass
+class Context(common.Context[HTTPScope, HTTPReceiveCallable, HTTPSendCallable]):
+    @trace_app_function
+    async def receive_request_payload(self: Self, cls: type[T]) -> T:
+        json, res = await receive_class_ext(self.receive, cls)
+
+        self.add_request_span_attrs(json, "http.request.body.data")
+
+        return res
+
+
+HandlerResult: TypeAlias = Any | None
+Handler: TypeAlias = Callable[[Context], Awaitable[HandlerResult]]
+Route: TypeAlias = Handler | tuple[list[HTTPMethod], Handler]

latch_asgi-1.0.0/latch_asgi/context/websocket.py

@@ -0,0 +1,50 @@
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Any, Self, TypeAlias, TypeVar
+
+from hypercorn.typing import WebsocketScope
+from latch_o11y.o11y import AttributesDict, dict_to_attrs, trace_app_function
+from opentelemetry.trace import get_current_span
+
+from ..asgi_iface import WebsocketReceiveCallable, WebsocketSendCallable
+from ..framework.common import Headers
+from ..framework.websocket import (
+    accept_connection,
+    current_websocket_session_span,
+    receive_class_ext,
+    send_websocket_auto,
+)
+from . import common
+
+T = TypeVar("T")
+
+
+@dataclass
+class Context(
+    common.Context[WebsocketScope, WebsocketReceiveCallable, WebsocketSendCallable]
+):
+    def add_session_span_attrs(self: Self, data: AttributesDict, prefix: str) -> None:
+        current_websocket_session_span().set_attributes(dict_to_attrs(data, prefix))
+
+    @trace_app_function
+    async def accept_connection(
+        self: Self, *, subprotocol: str | None = None, headers: Headers | None = None
+    ) -> None:
+        await accept_connection(self.send, subprotocol=subprotocol, headers=headers)
+
+    @trace_app_function
+    async def receive_message(self: Self, cls: type[T]) -> T:
+        json, res = await receive_class_ext(self.receive, cls)
+
+        get_current_span().set_attributes(dict_to_attrs(json, "payload"))
+
+        return res
+
+    @trace_app_function
+    async def send_message(self: Self, data: Any) -> None:
+        await send_websocket_auto(self.send, data)
+
+
+HandlerResult = str
+Handler: TypeAlias = Callable[[Context], Awaitable[HandlerResult]]
+Route: TypeAlias = Handler

{latch_asgi-0.2.0 → latch_asgi-1.0.0}/latch_asgi/datadog_propagator.py

@@ -1,3 +1,5 @@
+from typing import Self
+
 from opentelemetry import trace
 from opentelemetry.context.context import Context
 from opentelemetry.propagators import textmap
@@ -6,7 +8,7 @@ from opentelemetry.propagators import textmap
 class DDTraceContextTextMapPropagator(textmap.TextMapPropagator):
     # https://github.com/open-telemetry/opentelemetry-python-contrib/blob/934af7ea4f9b1e0294ced6a014d6eefdda156b2b/exporter/opentelemetry-exporter-datadog/src/opentelemetry/exporter/datadog/propagator.py
     def extract(
-        self,
+        self: Self,
         carrier: textmap.CarrierT,
         context: Context | None = None,
         getter: textmap.Getter[textmap.CarrierT] = textmap.default_getter,
@@ -28,12 +30,16 @@ class DDTraceContextTextMapPropagator(textmap.TextMapPropagator):
         sampling_priority = getter.get(carrier, "x-datadog-sampling-priority")
 
         trace_flags = trace.TraceFlags()
-        if sampling_priority is not None and len(sampling_priority) > 0:
-            if int(sampling_priority[0]) in (
+        if (
+            sampling_priority is not None
+            and len(sampling_priority) > 0
+            and int(sampling_priority[0])
+            in (
                 1,  # auto keep
                 2,  # user keep
-            ):
-                trace_flags = trace.TraceFlags(trace.TraceFlags.SAMPLED)
+            )
+        ):
+            trace_flags = trace.TraceFlags(trace.TraceFlags.SAMPLED)
 
         dd_origin = getter.get(carrier, "x-datadog-origin")
 
@@ -51,7 +57,7 @@ class DDTraceContextTextMapPropagator(textmap.TextMapPropagator):
         return trace.set_span_in_context(trace.NonRecordingSpan(span_context), context)
 
     def inject(
-        self,
+        self: Self,
         carrier: textmap.CarrierT,
         context: Context | None = None,
         setter: textmap.Setter[textmap.CarrierT] = textmap.default_setter,
@@ -69,11 +75,7 @@ class DDTraceContextTextMapPropagator(textmap.TextMapPropagator):
             "x-datadog-trace-id",
             str(span_context.trace_id & 0xFFFF_FFFF_FFFF_FFFF),
         )
-        setter.set(
-            carrier,
-            "x-datadog-parent-id",
-            str(span_context.span_id),
-        )
+        setter.set(carrier, "x-datadog-parent-id", str(span_context.span_id))
         setter.set(
             carrier,
             "x-datadog-sampling-priority",
@@ -87,7 +89,7 @@ class DDTraceContextTextMapPropagator(textmap.TextMapPropagator):
             )
 
     @property
-    def fields(self) -> set[str]:
+    def fields(self: Self) -> set[str]:
         return {
             "x-datadog-trace-id",
             "x-datadog-parent-id",

latch_asgi-1.0.0/latch_asgi/framework/common.py

@@ -0,0 +1,40 @@
+from typing import TypeAlias
+
+from opentelemetry.trace import get_tracer
+
+Headers: TypeAlias = dict[str | bytes, str | bytes]
+
+tracer = get_tracer(__name__)
+
+otel_header_whitelist = {
+    "host",
+    "content-type",
+    "content-length",
+    "accept",
+    "accept-encoding",
+    "accept-language",
+    "user-agent",
+    "dnt",
+    "sec-fetch-dest",
+    "sec-fetch-mode",
+    "sec-fetch-site",
+    "sec-fetch-user",
+    "sec-gpc",
+    "te",
+    "upgrade-insecure-requests",
+    "device-memory",
+    "downlink",
+    "dpr",
+    "ect",
+    "rtt",
+    "sec-ch-prefers-color-scheme",
+    "sec-ch-prefers-reduced-motion",
+    "sec-ch-ua",
+    "sec-ch-ua-arch",
+    "sec-ch-ua-full-version",
+    "sec-ch-ua-mobile",
+    "sec-ch-ua-model",
+    "sec-ch-ua-platform",
+    "sec-ch-ua-platfrom-version",
+    "viewport-width",
+}