smithy-http 0.4.3__tar.gz → 0.5.0__tar.gz

smithy_http-0.5.0/.changes/0.4.4.json

@@ -0,0 +1,16 @@
+{
+  "changes": [
+    {
+      "type": "enhancement",
+      "description": "Added a protocol hook for extracting server-provided retry delays from error responses."
+    },
+    {
+      "type": "enhancement",
+      "description": "Declared `AWSCRTHTTPClient` as duplex (bidirectional) streaming capable via `SUPPORTS_DUPLEX_STREAMING`. `AIOHTTPClient` explicitly does not support duplex streaming."
+    },
+    {
+      "type": "enhancement",
+      "description": "Disabled automatic redirects in `AIOHTTPClient` so that redirect responses are returned to the caller instead of being followed transparently."
+    }
+  ]
+}

smithy_http-0.5.0/.changes/0.5.0.json

@@ -0,0 +1,20 @@
+{
+  "changes": [
+    {
+      "type": "feature",
+      "description": "Added deterministic connection-pool cleanup and async context manager support to HTTP clients."
+    },
+    {
+      "type": "bugfix",
+      "description": "Stream aiohttp response bodies incrementally to enable true output event streams."
+    },
+    {
+      "type": "bugfix",
+      "description": "Fixed `AIOHTTPClient` to stop dropping valueless query parameters and automatically adding a `Content-Type` to bodyless POST, PUT, and PATCH requests."
+    },
+    {
+      "type": "bugfix",
+      "description": "Fixed duplicate Content-Type headers when a member is bound to Content-Type."
+    }
+  ]
+}

{smithy_http-0.4.3 → smithy_http-0.5.0}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## v0.5.0
+
+### Features
+* Added deterministic connection-pool cleanup and async context manager support to HTTP clients.
+
+### Bug fixes
+* Stream aiohttp response bodies incrementally to enable true output event streams.
+* Fixed `AIOHTTPClient` to stop dropping valueless query parameters and automatically adding a `Content-Type` to bodyless POST, PUT, and PATCH requests.
+* Fixed duplicate Content-Type headers when a member is bound to Content-Type.
+
+## v0.4.4
+
+### Enhancements
+* Added a protocol hook for extracting server-provided retry delays from error responses.
+* Declared `AWSCRTHTTPClient` as duplex (bidirectional) streaming capable via `SUPPORTS_DUPLEX_STREAMING`. `AIOHTTPClient` explicitly does not support duplex streaming.
+* Disabled automatic redirects in `AIOHTTPClient` so that redirect responses are returned to the caller instead of being followed transparently.
+
 ## v0.4.3
 
 ### Enhancements

{smithy_http-0.4.3 → smithy_http-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: smithy-http
-Version: 0.4.3
+Version: 0.5.0
 Summary: HTTP components for Smithy tooling.
 Project-URL: Changelog, https://github.com/smithy-lang/smithy-python/blob/develop/packages/smithy-http/CHANGELOG.md
 Project-URL: Code, https://github.com/smithy-lang/smithy-python/blob/develop/packages/smithy-http/

{smithy_http-0.4.3 → smithy_http-0.5.0}/src/smithy_http/__init__.py

@@ -7,7 +7,7 @@ from typing import get_args
 from . import interfaces
 from .interfaces import FieldPosition
 
-__version__ = "0.4.3"
+__version__ = "0.5.0"
 
 _VALID_FIELD_POSITIONS = frozenset(get_args(FieldPosition))
 

{smithy_http-0.4.3 → smithy_http-0.5.0}/src/smithy_http/aio/aiohttp.py

@@ -1,9 +1,9 @@
 #  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #  SPDX-License-Identifier: Apache-2.0
+from collections.abc import AsyncIterable, AsyncIterator
 from copy import copy, deepcopy
 from itertools import chain
-from typing import TYPE_CHECKING, Any
-from urllib.parse import parse_qs
+from typing import TYPE_CHECKING, Any, Self
 
 import yarl
 
@@ -22,11 +22,11 @@ except ImportError:
 
 from smithy_core.aio.interfaces import StreamingBlob
 from smithy_core.aio.types import AsyncBytesReader
-from smithy_core.aio.utils import async_list
 from smithy_core.exceptions import MissingDependencyError
 from smithy_core.interfaces import URI
 
 from .. import Field, Fields
+from ..exceptions import SmithyHTTPError
 from ..interfaces import (
     HTTPClientConfiguration,
     HTTPRequestConfiguration,
@@ -48,11 +48,30 @@ class AIOHTTPClientConfig(HTTPClientConfiguration):
         _assert_aiohttp()
 
 
+class _AIOHTTPStreamingBody(AsyncIterable[bytes]):
+    """Streams a response body, releasing the response once it is done."""
+
+    def __init__(self, response: "aiohttp.ClientResponse") -> None:
+        self._response = response
+
+    def __aiter__(self) -> AsyncIterator[bytes]:
+        # The reader iterates by line, so use iter_any to get raw chunks.
+        return self._response.content.iter_any()
+
+    async def close(self) -> None:
+        # Pools the connection if the body was read to completion, closes it if not.
+        self._response.release()
+
+
 class AIOHTTPClient(HTTPClient):
     """Implementation of :py:class:`.interfaces.HTTPClient` using aiohttp."""
 
     TIMEOUT_EXCEPTIONS = (TimeoutError,)
 
+    # aiohttp has no HTTP/2 support, so it can never interleave request and
+    # response data.
+    SUPPORTS_DUPLEX_STREAMING = False
+
     def __init__(
         self,
         *,
@@ -65,6 +84,7 @@ class AIOHTTPClient(HTTPClient):
         """
         _assert_aiohttp()
         self._config = client_config or AIOHTTPClientConfig()
+        self._closed = False
         # Disable transparent response decompression and advertise
         # 'identity' to request uncompressed responses.
         # TODO: add a functional test once the test client framework exists
@@ -84,6 +104,11 @@ class AIOHTTPClient(HTTPClient):
         :param request: The request including destination URI, fields, payload.
         :param request_config: Configuration specific to this request.
         """
+        if self._closed:
+            raise SmithyHTTPError(
+                "Cannot send a request after the HTTP client has been closed."
+            )
+
         request_config = request_config or HTTPRequestConfiguration()
 
         headers_list = list(
@@ -99,17 +124,34 @@ class AIOHTTPClient(HTTPClient):
         elif not isinstance(body, AsyncBytesReader):
             body = AsyncBytesReader(body)
 
-        # The typing on `params` is incorrect, it'll happily accept a mapping whose
-        # values are lists (or tuples) and produce expected values.
-        # See: https://github.com/aio-libs/aiohttp/issues/8563
-        async with self._session.request(
+        resp = await self._session.request(
             method=request.method,
-            url=self._serialize_uri_without_query(request.destination),
-            params=parse_qs(request.destination.query),  # type: ignore
+            url=self._serialize_uri(request.destination),
             headers=headers_list,
             data=body,
-        ) as resp:
-            return await self._marshal_response(resp)
+            allow_redirects=False,
+            skip_auto_headers={"Content-Type"},
+        )
+        try:
+            return self._marshal_response(resp)
+        except BaseException:
+            resp.release()
+            raise
+
+    async def close(self) -> None:
+        """Close the underlying aiohttp session and its connection pool."""
+        if self._closed:
+            return
+        self._closed = True
+        await self._session.close()
+
+    async def __aenter__(self) -> Self:
+        if self._closed:
+            raise SmithyHTTPError("Cannot enter an HTTP client that has been closed.")
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        await self.close()
 
     async def _prepare_body(self, body: StreamingBlob) -> AsyncBytesReader | None:
         """Convert a body for aiohttp, omitting seekable bodies with no data."""
@@ -124,8 +166,8 @@ class AIOHTTPClient(HTTPClient):
         await body.seek(position)
         return None if position == end else body
 
-    def _serialize_uri_without_query(self, uri: URI) -> yarl.URL:
-        """Serialize all parts of the URI up to and including the path."""
+    def _serialize_uri(self, uri: URI) -> yarl.URL:
+        """Serialize the URI, preserving the already-encoded query string as-is."""
         return yarl.URL.build(
             scheme=uri.scheme or "",
             host=uri.host,
@@ -133,10 +175,11 @@ class AIOHTTPClient(HTTPClient):
             user=uri.username,
             password=uri.password,
             path=uri.path or "",
+            query_string=uri.query or "",
             encoded=True,
         )
 
-    async def _marshal_response(
+    def _marshal_response(
         self, aiohttp_resp: "aiohttp.ClientResponse"
     ) -> HTTPResponseInterface:
         """Convert a ``aiohttp.ClientResponse`` to a ``smithy_http.aio.HTTPResponse``"""
@@ -154,7 +197,7 @@ class AIOHTTPClient(HTTPClient):
         return HTTPResponse(
             status=aiohttp_resp.status,
             fields=headers,
-            body=async_list([await aiohttp_resp.read()]),
+            body=_AIOHTTPStreamingBody(aiohttp_resp),
             reason=aiohttp_resp.reason,
         )
 

{smithy_http-0.4.3 → smithy_http-0.5.0}/src/smithy_http/aio/crt.py

@@ -1,12 +1,13 @@
 #  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #  SPDX-License-Identifier: Apache-2.0
 #  pyright: reportMissingTypeStubs=false,reportUnknownMemberType=false
+from asyncio import gather
 from collections.abc import AsyncGenerator, AsyncIterable
 from copy import deepcopy
 from dataclasses import dataclass
 from inspect import iscoroutinefunction
 from io import BytesIO
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Self
 
 from awscrt.exceptions import AwsCrtError
 
@@ -142,6 +143,10 @@ class AWSCRTHTTPClient(http_aio_interfaces.HTTPClient):
 
     TIMEOUT_EXCEPTIONS = (_CRTTimeoutError,)
 
+    # CRT can stream request and response data concurrently when the connection
+    # negotiates HTTP/2.
+    SUPPORTS_DUPLEX_STREAMING = True
+
     def __init__(
         self,
         eventloop: _AWSCRTEventLoop | None = None,
@@ -160,6 +165,7 @@ class AWSCRTHTTPClient(http_aio_interfaces.HTTPClient):
         self._tls_ctx = crt_io.ClientTlsContext(crt_io.TlsContextOptions())
         self._socket_options = crt_io.SocketOptions()
         self._connections: ConnectionPoolDict = {}
+        self._closed = False
 
     async def send(
         self,
@@ -172,6 +178,11 @@ class AWSCRTHTTPClient(http_aio_interfaces.HTTPClient):
         :param request: The request including destination URI, fields, payload.
         :param request_config: Configuration specific to this request.
         """
+        if self._closed:
+            raise SmithyHTTPError(
+                "Cannot send a request after the HTTP client has been closed."
+            )
+
         try:
             crt_request = self._marshal_request(request)
             connection = await self._get_connection(request.destination)
@@ -195,6 +206,26 @@ class AWSCRTHTTPClient(http_aio_interfaces.HTTPClient):
                 raise _CRTTimeoutError(f"CRT {e.name}: {e.message}") from e
             raise
 
+    async def close(self) -> None:
+        """Close all pooled HTTP connections."""
+        if self._closed:
+            return
+        self._closed = True
+        connections = tuple(self._connections.values())
+        self._connections.clear()
+        await gather(
+            *(connection.close() for connection in connections),
+            return_exceptions=True,
+        )
+
+    async def __aenter__(self) -> Self:
+        if self._closed:
+            raise SmithyHTTPError("Cannot enter an HTTP client that has been closed.")
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        await self.close()
+
     async def _await_response(
         self, stream: "AIOHttpClientStreamUnified"
     ) -> AWSCRTHTTPResponse:

{smithy_http-0.4.3 → smithy_http-0.5.0}/src/smithy_http/aio/protocols.py

@@ -192,6 +192,8 @@ class HttpBindingClientProtocol(HttpClientProtocol):
                 error_id=error_id,
             )
 
+        retry_after = self._retry_after(response)
+
         if error_id is None and self._matches_content_type(response):
             if isinstance(response_body, bytearray):
                 response_body = bytes(response_body)
@@ -225,7 +227,10 @@ class HttpBindingClientProtocol(HttpClientProtocol):
                 response=response,
                 body=response_body,
             )
-            return error_shape.deserialize(deserializer)
+            modeled_error = error_shape.deserialize(deserializer)
+            if retry_after is not None:
+                modeled_error.retry_after = retry_after
+            return modeled_error
 
         message = (
             f"Unknown error for operation {operation.schema.id} "
@@ -246,8 +251,13 @@ class HttpBindingClientProtocol(HttpClientProtocol):
             is_throttling_error=is_throttle,
             is_timeout_error=is_timeout,
             is_retry_safe=is_throttle or is_timeout or None,
+            retry_after=retry_after,
         )
 
+    def _retry_after(self, response: HTTPResponse) -> float | None:
+        """The retry delay in seconds requested by the server, if the response carries one."""
+        return None
+
     def _resolve_error_id(
         self,
         *,

{smithy_http-0.4.3 → smithy_http-0.5.0}/src/smithy_http/serializers.py

@@ -170,7 +170,9 @@ class HTTPRequestSerializer(SpecificShapeSerializer):
             payload = AsyncBytesReader(sync_payload)
 
         headers = binding_serializer.header_serializer.headers
-        if content_type is not None:
+        if content_type is not None and not any(
+            name.lower() == "content-type" for name, _ in headers
+        ):
             headers.append(("content-type", content_type))
 
         if content_length is not None:
@@ -358,7 +360,9 @@ class HTTPResponseSerializer(SpecificShapeSerializer):
             payload = AsyncBytesReader(sync_payload)
 
         headers = binding_serializer.header_serializer.headers
-        if content_type is not None:
+        if content_type is not None and not any(
+            name.lower() == "content-type" for name, _ in headers
+        ):
             headers.append(("content-type", content_type))
 
         if content_length is not None:

{smithy_http-0.4.3 → smithy_http-0.5.0}/src/smithy_http/testing/mockhttp.py

@@ -22,6 +22,11 @@ class MockHTTPClient(HTTPClient):
 
     TIMEOUT_EXCEPTIONS = (TimeoutError,)
 
+    # Declared so duplex (bidirectional) stream operations can be unit tested
+    # against this client. Queued responses are returned without consuming the
+    # request body, which is compatible with duplex streaming.
+    SUPPORTS_DUPLEX_STREAMING = True
+
     def __init__(
         self,
         *,