address comments

Author: haydenbaker

packages/smithy-aws-core/src/smithy_aws_core/protocols/restjson.py

@@ -19,7 +19,7 @@ def id(self) -> ShapeID:
         return self._id
 
     @property
-    def codec(self) -> Codec:
+    def payload_codec(self) -> Codec:
         return self._codec
 
     @property

packages/smithy-aws-core/src/smithy_aws_core/traits.py

@@ -16,26 +16,29 @@
 
 @dataclass(init=False, frozen=True)
 class RestJson1Trait(Trait, id=ShapeID("aws.protocols#restJson1")):
-    http: set[str] = field(repr=False, hash=False, compare=False, default_factory=set)
-    eventStreamHttp: set[str] = field(
-        repr=False, hash=False, compare=False, default_factory=set
+    http: Sequence[str] = field(
+        repr=False, hash=False, compare=False, default_factory=tuple
+    )
+    event_stream_http: Sequence[str] = field(
+        repr=False, hash=False, compare=False, default_factory=tuple
     )
 
     def __init__(self, value: DocumentValue | DynamicTrait = None):
         super().__init__(value)
         assert isinstance(self.document_value, Mapping)
 
-        assert isinstance(self.document_value["http"], Sequence)
-        for val in self.document_value["http"]:
+        http_versions = self.document_value["http"]
+        assert isinstance(http_versions, Sequence)
+        for val in http_versions:
             assert isinstance(val, str)
-            self.http.add(val)
-
-        if vals := self.document_value.get("eventStreamHttp") is None:
-            object.__setattr__(self, "eventStreamHttp", self.http)
+        object.__setattr__(self, "http", tuple(http_versions))
+        event_stream_http_versions = self.document_value.get("eventStreamHttp")
+        if not event_stream_http_versions:
+            object.__setattr__(self, "event_stream_http", self.http)
         else:
-            # check that eventStreamHttp is a subset of http
-            assert isinstance(vals, Sequence)
-            for val in self.document_value["eventStreamHttp"]:
-                assert val in self.http
+            assert isinstance(event_stream_http_versions, Sequence)
+            for val in event_stream_http_versions:
                 assert isinstance(val, str)
-                self.eventStreamHttp.add(val)
+            object.__setattr__(
+                self, "event_stream_http", tuple(event_stream_http_versions)
+            )

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

@@ -6,6 +6,7 @@
 from smithy_core.codecs import Codec
 from smithy_core.deserializers import DeserializeableShape
 from smithy_core.documents import TypeRegistry
+from smithy_core.exceptions import ExpectationNotMetException
 from smithy_core.interfaces import Endpoint, TypedProperties, URI
 from smithy_core.schemas import APIOperation
 from smithy_core.serializers import SerializeableShape
@@ -43,8 +44,8 @@ class HttpBindingClientProtocol(HttpClientProtocol):
     """An HTTP-based protocol that uses HTTP binding traits."""
 
     @property
-    def codec(self) -> Codec:
-        """The codec used for the serde of input and output shapes."""
+    def payload_codec(self) -> Codec:
+        """The codec used for the serde of input and output payloads."""
         ...
 
     @property
@@ -63,20 +64,23 @@ def serialize_request[
         endpoint: URI,
         context: TypedProperties,
     ) -> HTTPRequest:
-        # TODO: request binding cache like done in SJ
+        # TODO(optimization): request binding cache like done in SJ
         serializer = HTTPRequestSerializer(
-            payload_codec=self.codec,
-            http_trait=operation.schema.expect_trait(HTTPTrait),  # TODO
+            payload_codec=self.payload_codec,
+            http_trait=operation.schema.expect_trait(HTTPTrait),
             endpoint_trait=operation.schema.get_trait(EndpointTrait),
         )
 
-        input.serialize(serializer=serializer)
+        input.serialize(
+            serializer=serializer
+        )  # TODO: ensure serializer adds content-type
         request = serializer.result
 
         if request is None:
-            raise ValueError("Request is None")  # TODO
+            raise ExpectationNotMetException(
+                "Expected request to be serialized, but was None"
+            )
 
-        request.fields["content-type"].add(self.content_type)
         return request
 
     async def deserialize_response[
@@ -96,15 +100,17 @@ async def deserialize_response[
             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
+        # if body is not streaming and is async, we have to buffer it
+        if not operation.output_stream_member:
+            if (
+                read := getattr(body, "read", None)
+            ) is not None and iscoroutinefunction(read):
+                body = BytesIO(await read())
+
+        # TODO(optimization): response binding cache like done in SJ
         deserializer = HTTPResponseDeserializer(
-            payload_codec=self.codec,
+            payload_codec=self.payload_codec,
             http_trait=operation.schema.expect_trait(HTTPTrait),
             response=response,
             body=body,  # type: ignore

packages/smithy-http/src/smithy_http/serializers.py

@@ -112,6 +112,10 @@ def begin_struct(self, schema: Schema) -> Iterator[ShapeSerializer]:
         ) is not None and not iscoroutinefunction(seek):
             seek(0)
 
+        # TODO: conditional on empty-ness and a param of the protocol?
+        headers = binding_serializer.header_serializer.headers
+        headers.append(("content-type", self._payload_codec.media_type))
+
         self.result = _HTTPRequest(
             method=self._http_trait.method,
             destination=URI(
@@ -122,7 +126,7 @@ def begin_struct(self, schema: Schema) -> Iterator[ShapeSerializer]:
                     prefix=self._http_trait.query or "",
                 ),
             ),
-            fields=tuples_to_fields(binding_serializer.header_serializer.headers),
+            fields=tuples_to_fields(headers),
             body=payload,
         )