checkpoint

Author: haydenbaker

examples/weather/model/weather.smithy

@@ -26,6 +26,21 @@ resource City {
 resource Forecast {
     identifiers: { cityId: CityId }
     read: GetForecast,
+    update: PutForecast
+}
+
+@http(method: "PUT", uri: "/city/{cityId}/forecast", code: 200)
+@idempotent
+operation PutForecast {
+    input := for Forecast {
+        @required
+        @httpLabel
+        $cityId
+
+        chanceOfRain: Float
+    }
+
+    output := {}
 }
 
 // "pattern" is a trait.
@@ -154,3 +169,5 @@ structure GetForecastInput {
 structure GetForecastOutput {
     chanceOfRain: Float
 }
+
+

packages/smithy-core/src/smithy_core/aio/interfaces/__init__.py

@@ -1,11 +1,20 @@
 #  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #  SPDX-License-Identifier: Apache-2.0
+import os.path
+from asyncio import iscoroutinefunction
 from collections.abc import AsyncIterable
+from io import BytesIO
 from typing import Protocol, runtime_checkable, TYPE_CHECKING, Any
 
+from smithy_http.aio.interfaces import HTTPRequest, HTTPResponse
+from smithy_http.deserializers import HTTPResponseDeserializer
+from smithy_http.serializers import HTTPRequestSerializer
+from smithy_json import JSONCodec
+from ...codecs import Codec
 from ...interfaces import URI, Endpoint
 from ...interfaces import StreamingBlob as SyncStreamingBlob
-
+from ...traits import HTTPTrait, EndpointTrait, RestJson1Trait
+from ...type_registry import TypeRegistry
 
 if TYPE_CHECKING:
     from ...schemas import APIOperation
@@ -126,7 +135,7 @@ async def deserialize_response[
         operation: APIOperation[OperationInput, OperationOutput],
         request: I,
         response: O,
-        error_registry: Any,  # TODO: add error registry
+        error_registry: TypeRegistry,
         context: dict[str, Any],  # TODO: replace with a typed context bag
     ) -> OperationOutput:
         """Deserializes the output from the tranport response or throws an exception.
@@ -138,3 +147,121 @@ async def deserialize_response[
         :param context: A context bag for the request.
         """
         ...
+
+
+class HttpClientProtocol(ClientProtocol[HTTPRequest, HTTPResponse]):
+    def set_service_endpoint(
+        self,
+        *,
+        request: HTTPRequest,
+        endpoint: Endpoint,
+    ) -> HTTPRequest:
+        """Update the endpoint of a transport request.
+
+        :param request: The request whose endpoint should be updated.
+        :param endpoint: The endpoint to set on the request.
+        """
+        uri = endpoint.uri
+        uri_builder = request.destination
+
+        if uri.scheme:
+            uri_builder.scheme = uri.scheme
+        if uri.host:
+            uri_builder.host = uri.host
+        if uri.port and uri.port > -1:
+            uri_builder.port = uri.port
+        if uri.path:
+            # TODO: verify, uri helper?
+            uri_builder.path = os.path.join(uri.path, uri_builder.path or "")
+        # TODO: merge headers from the endpoint properties bag
+        return request
+
+
+class HttpBindingClientProtocol(HttpClientProtocol):
+    @property
+    def codec(self) -> Codec:
+        """The codec used for the serde of input and output shapes."""
+        ...
+
+    @property
+    def content_type(self) -> str:
+        """The media type of the http payload."""
+        ...
+
+    def serialize_request[
+        OperationInput: "SerializeableShape",
+        OperationOutput: "DeserializeableShape",
+    ](
+        self,
+        *,
+        operation: APIOperation[OperationInput, OperationOutput],
+        input: OperationInput,
+        endpoint: URI,
+        context: dict[str, Any],
+    ) -> HTTPRequest:
+        # TODO: request binding cache like done in SJ
+        serializer = HTTPRequestSerializer(
+            payload_codec=self.codec,
+            http_trait=operation.schema.expect_trait(HTTPTrait),  # TODO
+            endpoint_trait=operation.schema.get_trait(EndpointTrait),
+        )
+
+        input.serialize(serializer=serializer)
+        request = serializer.result
+
+        if request is None:
+            raise ValueError("Request is None")  # TODO
+
+        request.fields["content-type"].add(self.content_type)
+        return request
+
+    async def deserialize_response[
+        OperationInput: "SerializeableShape",
+        OperationOutput: "DeserializeableShape",
+    ](
+        self,
+        *,
+        operation: APIOperation[OperationInput, OperationOutput],
+        request: HTTPRequest,
+        response: HTTPResponse,
+        error_registry: TypeRegistry,
+        context: dict[str, Any],  # TODO: replace with a typed context bag
+    ) -> OperationOutput:
+        if not (200 <= response.status <= 299):  # TODO: extract to utility
+            # TODO: implement error serde from type registry
+            raise NotImplementedError
+
+        body = response.body
+        # TODO: extract to utility, seems common
+        if (read := getattr(body, "read", None)) is not None and iscoroutinefunction(
+            read
+        ):
+            body = BytesIO(await read())
+
+        # TODO: response binding cache like done in SJ
+        deserializer = HTTPResponseDeserializer(
+            payload_codec=self.codec,
+            http_trait=operation.schema.expect_trait(HTTPTrait),
+            response=response,
+            body=body,  # type: ignore
+        )
+
+        return operation.output.deserialize(deserializer)
+
+
+class RestJsonClientProtocol(HttpBindingClientProtocol):
+    _id: ShapeID = RestJson1Trait.id
+    _codec: JSONCodec = JSONCodec()
+    _contentType: str = "application/json"
+
+    @property
+    def id(self) -> ShapeID:
+        return self._id
+
+    @property
+    def codec(self) -> Codec:
+        return self._codec
+
+    @property
+    def content_type(self) -> str:
+        return self._contentType

packages/smithy-core/src/smithy_core/documents.py

@@ -143,6 +143,12 @@ def shape_type(self) -> ShapeType:
         """The Smithy data model type for the underlying contents of the document."""
         return self._type
 
+    @property
+    def discriminator(self) -> ShapeID:
+        """The shape ID that corresponds to the contents of the document."""
+        # TODO: custom exception?
+        raise NotImplementedError(f"{self} document has no discriminator.")
+
     def is_none(self) -> bool:
         """Indicates whether the document contains a null value."""
         return self._value is None and self._raw_value is None

packages/smithy-core/src/smithy_core/traits.py

@@ -313,3 +313,9 @@ def host_prefix(self) -> str:
 class HostLabelTrait(Trait, id=ShapeID("smithy.api#hostLabel")):
     def __post_init__(self):
         assert self.document_value is None
+
+
+@dataclass(init=False, frozen=True)
+class RestJson1Trait(Trait, id=ShapeID("aws.protocols#restJson1")):
+    def __post_init__(self):
+        assert self.document_value is None

packages/smithy-core/src/smithy_core/type_registry.py

@@ -0,0 +1,30 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#  SPDX-License-Identifier: Apache-2.0
+
+from smithy_core.deserializers import (
+    DeserializeableShape,
+)  # TODO: fix typo in deserializable
+from smithy_core.documents import Document
+from smithy_core.shapes import ShapeID
+
+
+# A registry for on-demand deserialization of types by using a mapping of shape IDs to their deserializers.
+# TODO: protocol
+class TypeRegistry:
+    def __init__(
+        self,
+        types: dict[ShapeID, DeserializeableShape],
+        sub_registry: "TypeRegistry | None" = None,
+    ):
+        self._types = types
+        self._sub_registry = sub_registry
+
+    def get(self, shape: ShapeID) -> type[DeserializeableShape]:
+        if shape in self._types:
+            return type(self._types[shape])
+        if self._sub_registry is not None:
+            return self._sub_registry.get(shape)
+        raise ValueError(f"Unknown shape: {shape}")  # TODO: real exception?
+
+    def deserialize(self, document: Document) -> DeserializeableShape:
+        return document.as_shape(self.get(document.discriminator))