smithy-http 0.6.0__tar.gz → 0.7.0__tar.gz

smithy_http-0.7.0/.changes/0.7.0.json

@@ -0,0 +1,80 @@
+{
+  "changes": [
+    {
+      "type": "breaking",
+      "description": "Replaced the async protocols with event stream mixins composed onto the sync protocols. `AsyncHttpClientProtocol`, `AsyncHttpBindingClientProtocol` and `AsyncRpcClientProtocol` are removed; use `AsyncHttpEventStreamMixin` or `AsyncRpcEventStreamMixin` with a protocol from `smithy_http.protocols`. `AsyncRpcV2CborClientProtocol` is kept as such a composition."
+    },
+    {
+      "type": "breaking",
+      "description": "Moved `HTTPRequest` and `HTTPResponse` to `smithy_http`, and their protocols and `HTTPErrorIdentifier` to `smithy_http.interfaces`. Removed `consume_body_async`."
+    },
+    {
+      "type": "breaking",
+      "description": "Removed `AsyncAPIKeySigner`; `AsyncAPIKeyAuthScheme` returns the sync `APIKeySigner`. Renamed `smithy_http.aio.restjson.parse_rest_json_error_info` to `parse_rest_json_error_info_async`."
+    },
+    {
+      "type": "breaking",
+      "description": "Serialized request bodies are now synchronous for both sync and async clients. `HTTPBindingSerializer`'s `async_body` parameter is replaced by `event_stream_body`, and `RawPayloadDeserializer` returns streaming payloads as the transport provides them."
+    },
+    {
+      "type": "breaking",
+      "description": "Moved async implementations to `smithy_http.aio` and added the `Async` prefix to their names, for example `AsyncHTTPClient`, `AsyncHttpClientProtocol`, `AsyncHttpBindingClientProtocol`, `AsyncRpcV2CborClientProtocol` and `AsyncAPIKeyAuthScheme`. The unprefixed names are reserved for sync implementations. Update imports to the `aio` paths."
+    },
+    {
+      "type": "breaking",
+      "description": "Declared explicit `__all__` exports on all public modules. Names that were previously importable only incidentally (via `from module import *` or as un-annotated module attributes) are no longer part of the public API; import public symbols by name from their documented module."
+    },
+    {
+      "type": "breaking",
+      "description": "`smithy_http.testing.MockHTTPClient` is now synchronous. Async clients use `smithy_http.aio.testing.AsyncMockHTTPClient`."
+    },
+    {
+      "type": "breaking",
+      "description": "Renamed `AWSCRTHTTPResponse` to `AsyncAWSCRTHTTPResponse`, and `smithy_http.aio.auth.apikey.APIKeyResolverConfig` to `AsyncAPIKeyResolverConfig`."
+    },
+    {
+      "type": "feature",
+      "description": "Added synchronous HTTP support: `smithy_http.urllib3.Urllib3HTTPClient`, the sync protocols in `smithy_http.protocols`, `smithy_http.restjson.parse_rest_json_error_info` and `smithy_http.identity.apikey.APIKeyIdentityResolver`."
+    },
+    {
+      "type": "feature",
+      "description": "Added `connect_timeout` and `read_timeout` to `Urllib3HTTPClientConfig`, both defaulting to 60 seconds, so sync requests no longer wait indefinitely. A request's `HTTPRequestConfiguration.read_timeout` takes precedence."
+    },
+    {
+      "type": "feature",
+      "description": "Added `max_pool_connections` to `Urllib3HTTPClientConfig`, the connections kept for reuse per host, defaulting to 10 instead of urllib3's 1."
+    },
+    {
+      "type": "feature",
+      "description": "Added a RpcClientProtocol base class and client-side event stream support for the rpcv2Cbor protocol."
+    },
+    {
+      "type": "enhancement",
+      "description": "AWSCRTHTTPClient now negotiates HTTP/2 per request for operations that require it (event streams), advertising only HTTP/2 in ALPN and pooling those connections separately from HTTP/1.1 ones, so a single client serves both HTTP/1.1 operations and HTTP/2 event streams without configuration. The client-wide force_http_2 config remains as an override."
+    },
+    {
+      "type": "enhancement",
+      "description": "Added a trust_store_path option to AWSCRTHTTPClientConfig for overriding the TLS trust store with a custom CA bundle."
+    },
+    {
+      "type": "enhancement",
+      "description": "Added support for Python 3.15."
+    },
+    {
+      "type": "bugfix",
+      "description": "Fixed HTTP serializers sending seekable streaming payloads, such as files, without a Content-Length and sending a modeled Content-Length twice."
+    },
+    {
+      "type": "bugfix",
+      "description": "Fixed API key auth setting the request path to the URI password."
+    },
+    {
+      "type": "bugfix",
+      "description": "`APIKeyIdentity` no longer includes `api_key` in its repr, which keeps it out of debug logs."
+    },
+    {
+      "type": "dependency",
+      "description": "Bump `smithy-cbor` from `~=0.1.0` to `~=0.2.0`."
+    }
+  ]
+}

{smithy_http-0.6.0 → smithy_http-0.7.0}/.gitignore

@@ -34,3 +34,6 @@ htmlcov
 *.egg-info
 dist
 .venv
+
+# make gen
+/workspace/

smithy_http-0.7.0/CHANGELOG.md

@@ -0,0 +1,128 @@
+# Changelog
+
+## v0.7.0
+
+### Breaking Changes
+* Replaced the async protocols with event stream mixins composed onto the sync protocols. `AsyncHttpClientProtocol`, `AsyncHttpBindingClientProtocol` and `AsyncRpcClientProtocol` are removed; use `AsyncHttpEventStreamMixin` or `AsyncRpcEventStreamMixin` with a protocol from `smithy_http.protocols`. `AsyncRpcV2CborClientProtocol` is kept as such a composition.
+* Moved `HTTPRequest` and `HTTPResponse` to `smithy_http`, and their protocols and `HTTPErrorIdentifier` to `smithy_http.interfaces`. Removed `consume_body_async`.
+* Removed `AsyncAPIKeySigner`; `AsyncAPIKeyAuthScheme` returns the sync `APIKeySigner`. Renamed `smithy_http.aio.restjson.parse_rest_json_error_info` to `parse_rest_json_error_info_async`.
+* Serialized request bodies are now synchronous for both sync and async clients. `HTTPBindingSerializer`'s `async_body` parameter is replaced by `event_stream_body`, and `RawPayloadDeserializer` returns streaming payloads as the transport provides them.
+* Moved async implementations to `smithy_http.aio` and added the `Async` prefix to their names, for example `AsyncHTTPClient`, `AsyncHttpClientProtocol`, `AsyncHttpBindingClientProtocol`, `AsyncRpcV2CborClientProtocol` and `AsyncAPIKeyAuthScheme`. The unprefixed names are reserved for sync implementations. Update imports to the `aio` paths.
+* Declared explicit `__all__` exports on all public modules. Names that were previously importable only incidentally (via `from module import *` or as un-annotated module attributes) are no longer part of the public API; import public symbols by name from their documented module.
+* `smithy_http.testing.MockHTTPClient` is now synchronous. Async clients use `smithy_http.aio.testing.AsyncMockHTTPClient`.
+* Renamed `AWSCRTHTTPResponse` to `AsyncAWSCRTHTTPResponse`, and `smithy_http.aio.auth.apikey.APIKeyResolverConfig` to `AsyncAPIKeyResolverConfig`.
+
+### Features
+* Added synchronous HTTP support: `smithy_http.urllib3.Urllib3HTTPClient`, the sync protocols in `smithy_http.protocols`, `smithy_http.restjson.parse_rest_json_error_info` and `smithy_http.identity.apikey.APIKeyIdentityResolver`.
+* Added `connect_timeout` and `read_timeout` to `Urllib3HTTPClientConfig`, both defaulting to 60 seconds, so sync requests no longer wait indefinitely. A request's `HTTPRequestConfiguration.read_timeout` takes precedence.
+* Added `max_pool_connections` to `Urllib3HTTPClientConfig`, the connections kept for reuse per host, defaulting to 10 instead of urllib3's 1.
+* Added a RpcClientProtocol base class and client-side event stream support for the rpcv2Cbor protocol.
+
+### Enhancements
+* AWSCRTHTTPClient now negotiates HTTP/2 per request for operations that require it (event streams), advertising only HTTP/2 in ALPN and pooling those connections separately from HTTP/1.1 ones, so a single client serves both HTTP/1.1 operations and HTTP/2 event streams without configuration. The client-wide force_http_2 config remains as an override.
+* Added a trust_store_path option to AWSCRTHTTPClientConfig for overriding the TLS trust store with a custom CA bundle.
+* Added support for Python 3.15.
+
+### Bug fixes
+* Fixed HTTP serializers sending seekable streaming payloads, such as files, without a Content-Length and sending a modeled Content-Length twice.
+* Fixed API key auth setting the request path to the URI password.
+* `APIKeyIdentity` no longer includes `api_key` in its repr, which keeps it out of debug logs.
+
+### Dependencies
+* Bump `smithy-cbor` from `~=0.1.0` to `~=0.2.0`.
+
+## v0.6.0
+
+### Features
+* `HttpClientProtocol` implements `extract_response_metadata()`, reporting the HTTP status code.
+* Added a naive `RpcV2CborClientProtocol` for the `smithy.protocols#rpcv2Cbor` protocol (optional `cbor` extra).
+* Added schema-cached HTTP binding plans for members, operations, payloads, and request and response dispatch.
+
+### Dependencies
+* Bump `smithy-cbor` from `~=0.0.0` to `~=0.1.0`.
+
+## 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
+* Enabled HTTP binding protocols to resolve modeled response errors when wire identifiers do not exactly match registered shape IDs. ([#742](https://github.com/smithy-lang/smithy-python/pull/742))
+
+### Bug fixes
+* Fixed `AIOHTTPClient` sending omitted request payloads with chunked transfer encoding.
+
+## v0.4.2
+
+### Bug fixes
+* Disabled automatic response decompression in `AIOHTTPClient`.
+
+## v0.4.1
+
+### Bug fixes
+* Fixed `AWSCRTHTTPClient` to send HTTP/1.1 request bodies via `body_stream` instead of the HTTP/2-only `request_body_generator`.
+
+## v0.4.0
+
+### Breaking Changes
+* Replace `FieldPosition` enum values with string literals for `Field.kind`. Use "header" and "trailer" instead of `FieldPosition.HEADER` and `FieldPosition.TRAILER`.
+
+### Dependencies
+* Upgrade CRT to 0.32.0 to fix bug where HTTP2 exceptions could hang indefinitely
+
+## v0.3.1
+
+### Bug fixes
+* Fixed empty error messaging for CRT-based timeout errors.
+
+### Dependencies
+* Removed strict pinning on `smithy-core` in favor of client managed versions.
+
+## v0.3.0
+
+### Features
+* Added `MockHTTPClient` for testing SDK clients without making real HTTP requests.
+
+### Enhancements
+* Added timeout error detection for HTTP clients
+
+### Dependencies
+* Bump `smithy-core` from `~=0.1.0` to `~=0.2.0`.
+
+## v0.2.1
+
+### Bug fixes
+* Add port to CRT HTTP client's host header.
+
+## v0.2.0
+
+### Breaking Changes
+* Update `AWSCRTHTTPClient` to integrate with the new AWS CRT async interfaces. ([#573](https://github.com/smithy-lang/smithy-python/pull/573)). The `AWSCRTHTTPResponse` constructor now accepts a `stream` argument of type `awscrt.aio.http.AIOHttpClientStreamUnified`. Additionally, the following classes were removed: `CRTResponseBody`, `CRTResponseFactory`, and `BufferableByteStream`.
+
+## v0.1.0
+
+### Breaking Changes
+* Removed identity and auth interfaces in favor of the transport-agnostic interfaces introduced in `smithy-core`.
+
+### Features
+* Introduced schema-based serializers and deserializers for HTTP binding protocols.
+
+## v0.0.1
+
+### Features
+* Added support for aiohttp and AWSCRT http clients.
+* Added basic HTTP primitives and interfaces for Smithy clients.

{smithy_http-0.6.0 → smithy_http-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: smithy-http
-Version: 0.6.0
+Version: 0.7.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/
@@ -21,6 +21,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries
@@ -32,7 +33,9 @@ Requires-Dist: yarl; extra == 'aiohttp'
 Provides-Extra: awscrt
 Requires-Dist: awscrt~=0.32.0; extra == 'awscrt'
 Provides-Extra: cbor
-Requires-Dist: smithy-cbor~=0.1.0; extra == 'cbor'
+Requires-Dist: smithy-cbor~=0.2.0; extra == 'cbor'
+Provides-Extra: urllib3
+Requires-Dist: urllib3<3.0,>=2.0; extra == 'urllib3'
 Description-Content-Type: text/markdown
 
 # smithy-http
@@ -47,11 +50,14 @@ The `smithy_http.testing` module provides shared utilities for testing HTTP func
 
 ### MockHTTPClient
 
-The `MockHTTPClient` allows you to test smithy-python clients without making actual network calls. It implements the `HTTPClient` interface and provides configurable responses for functional testing.
+`MockHTTPClient` lets you test smithy-python clients without making actual network
+calls. It implements the `HTTPClient` interface and returns queued responses. For async
+clients, use `smithy_http.aio.testing.AsyncMockHTTPClient`, which implements
+`AsyncHTTPClient` the same way.
 
-#### Basic Usage                                                                                                                                                                                      
+#### Basic Usage
 
-```python                                                                                                                                                                                               
+```python
 from smithy_http.testing import MockHTTPClient
 
 # Create mock client and configure responses
@@ -67,7 +73,7 @@ config = Config(transport=mock_client)
 client = TestSmithyServiceClient(config=config)
 
 # Test your client logic
-result = await client.some_operation({"input": "data"})
+result = client.some_operation({"input": "data"})
 
 # Inspect what requests were made
 assert mock_client.call_count == 1

{smithy_http-0.6.0 → smithy_http-0.7.0}/README.md

@@ -10,11 +10,14 @@ The `smithy_http.testing` module provides shared utilities for testing HTTP func
 
 ### MockHTTPClient
 
-The `MockHTTPClient` allows you to test smithy-python clients without making actual network calls. It implements the `HTTPClient` interface and provides configurable responses for functional testing.
+`MockHTTPClient` lets you test smithy-python clients without making actual network
+calls. It implements the `HTTPClient` interface and returns queued responses. For async
+clients, use `smithy_http.aio.testing.AsyncMockHTTPClient`, which implements
+`AsyncHTTPClient` the same way.
 
-#### Basic Usage                                                                                                                                                                                      
+#### Basic Usage
 
-```python                                                                                                                                                                                               
+```python
 from smithy_http.testing import MockHTTPClient
 
 # Create mock client and configure responses
@@ -30,7 +33,7 @@ config = Config(transport=mock_client)
 client = TestSmithyServiceClient(config=config)
 
 # Test your client logic
-result = await client.some_operation({"input": "data"})
+result = client.some_operation({"input": "data"})
 
 # Inspect what requests were made
 assert mock_client.call_count == 1

{smithy_http-0.6.0 → smithy_http-0.7.0}/pyproject.toml

@@ -22,6 +22,7 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Free Threading :: 2 - Beta",
   "Topic :: Software Development :: Libraries"
@@ -40,12 +41,15 @@ awscrt = [
     "awscrt~=0.32.0",
 ]
 cbor = [
-    "smithy-cbor~=0.1.0",
+    "smithy-cbor~=0.2.0",
 ]
 aiohttp = [
     "aiohttp>=3.11.12, <4.0",
     "yarl"
 ]
+urllib3 = [
+    "urllib3>=2.0, <3.0",
+]
 
 [build-system]
 requires = ["hatchling"]

{smithy_http-0.6.0 → smithy_http-0.7.0}/src/smithy_http/__init__.py

@@ -2,12 +2,27 @@
 # SPDX-License-Identifier: Apache-2.0
 from collections import Counter, OrderedDict
 from collections.abc import Iterable, Iterator
+from dataclasses import dataclass, field
 from typing import get_args
 
+from smithy_core.interfaces import AnyStreamingBlob, URI
+from smithy_core.utils import read_streaming_blob
+
 from . import interfaces
 from .interfaces import FieldPosition
 
-__version__ = "0.6.0"
+__all__ = [
+    "Field",
+    "FieldPosition",
+    "Fields",
+    "HTTPRequest",
+    "HTTPResponse",
+    "interfaces",
+    "quote_and_escape_field_value",
+    "tuples_to_fields",
+]
+
+__version__ = "0.7.0"
 
 _VALID_FIELD_POSITIONS = frozenset(get_args(FieldPosition))
 
@@ -35,6 +50,22 @@ class Field(interfaces.Field):
             raise ValueError(f"Unknown field kind: {kind!r}")
         self.kind = kind
 
+    def __eq__(self, other: object) -> bool:
+        """Name, values, and kind must match.
+
+        Values order must match.
+        """
+        if not isinstance(other, Field):
+            return False
+        return (
+            self.name == other.name
+            and self.kind == other.kind
+            and self.values == other.values
+        )
+
+    def __repr__(self) -> str:
+        return f"Field(name={self.name!r}, value={self.values!r}, kind={self.kind!r})"
+
     def add(self, value: str) -> None:
         """Append a value to a field."""
         self.values.append(value)
@@ -75,22 +106,6 @@ class Field(interfaces.Field):
         value."""
         return [(self.name, val) for val in self.values]
 
-    def __eq__(self, other: object) -> bool:
-        """Name, values, and kind must match.
-
-        Values order must match.
-        """
-        if not isinstance(other, Field):
-            return False
-        return (
-            self.name == other.name
-            and self.kind == other.kind
-            and self.values == other.values
-        )
-
-    def __repr__(self) -> str:
-        return f"Field(name={self.name!r}, value={self.values!r}, kind={self.kind!r})"
-
 
 class Fields(interfaces.Fields):
     def __init__(
@@ -123,10 +138,6 @@ class Fields(interfaces.Fields):
         self.entries: dict[str, interfaces.Field] = OrderedDict(init_tuples)
         self.encoding: str = encoding
 
-    def set_field(self, field: interfaces.Field) -> None:
-        """Alias for __setitem__ to utilize the field.name for the entry key."""
-        self.__setitem__(field.name, field)
-
     def __setitem__(self, name: str, field: interfaces.Field) -> None:
         """Set or override entry for a Field name."""
         normalized_name = self._normalize_field_name(name)
@@ -138,11 +149,6 @@ class Fields(interfaces.Fields):
             )
         self.entries[normalized_name] = field
 
-    def get(
-        self, key: str, default: interfaces.Field | None = None
-    ) -> interfaces.Field | None:
-        return self[key] if key in self else default
-
     def __getitem__(self, name: str) -> interfaces.Field:
         """Retrieve Field entry."""
         normalized_name = self._normalize_field_name(name)
@@ -153,6 +159,36 @@ class Fields(interfaces.Fields):
         normalized_name = self._normalize_field_name(name)
         del self.entries[normalized_name]
 
+    def __eq__(self, other: object) -> bool:
+        """Encoding must match.
+
+        Entries must match in values and order.
+        """
+        if not isinstance(other, Fields):
+            return False
+        return self.encoding == other.encoding and self.entries == other.entries
+
+    def __iter__(self) -> Iterator[interfaces.Field]:
+        yield from self.entries.values()
+
+    def __len__(self) -> int:
+        return len(self.entries)
+
+    def __repr__(self) -> str:
+        return f"Fields({self.entries})"
+
+    def __contains__(self, key: str) -> bool:
+        return self._normalize_field_name(key) in self.entries
+
+    def set_field(self, field: interfaces.Field) -> None:
+        """Alias for __setitem__ to utilize the field.name for the entry key."""
+        self.__setitem__(field.name, field)
+
+    def get(
+        self, key: str, default: interfaces.Field | None = None
+    ) -> interfaces.Field | None:
+        return self[key] if key in self else default
+
     def get_by_type(self, kind: FieldPosition) -> list[interfaces.Field]:
         """Helper function for retrieving specific types of fields.
 
@@ -182,26 +218,43 @@ class Fields(interfaces.Fields):
         """
         return name.lower()
 
-    def __eq__(self, other: object) -> bool:
-        """Encoding must match.
 
-        Entries must match in values and order.
-        """
-        if not isinstance(other, Fields):
-            return False
-        return self.encoding == other.encoding and self.entries == other.entries
+@dataclass(kw_only=True)
+class HTTPRequest(interfaces.HTTPRequest):
+    """HTTP primitives for an Exchange to construct a version agnostic HTTP message."""
 
-    def __iter__(self) -> Iterator[interfaces.Field]:
-        yield from self.entries.values()
+    destination: URI
+    body: AnyStreamingBlob = field(repr=False, default=b"")
+    method: str
+    fields: interfaces.Fields
+    http2_required: bool = False
+    """Transport hint: negotiate HTTP/2 for this request and don't reuse a non-h2
+    connection for it. Set for event-stream operations whose protocol permits h2;
+    not sent on the wire."""
 
-    def __len__(self) -> int:
-        return len(self.entries)
 
-    def __repr__(self) -> str:
-        return f"Fields({self.entries})"
+# CAUTION: implements interfaces.HTTPResponse structurally; subclassing the protocol
+# makes its read-only properties collide with the dataclass fields (AttributeError).
+# See https://github.com/python/typing/discussions/903#discussioncomment-4866851.
+@dataclass(kw_only=True)
+class HTTPResponse:
+    """Basic implementation of :py:class:`.interfaces.HTTPResponse`."""
 
-    def __contains__(self, key: str) -> bool:
-        return self._normalize_field_name(key) in self.entries
+    body: AnyStreamingBlob = field(repr=False, default=b"")
+    """The response payload."""
+
+    status: int
+    """The 3 digit response status code (1xx, 2xx, 3xx, 4xx, 5xx)."""
+
+    fields: interfaces.Fields
+    """HTTP header and trailer fields."""
+
+    reason: str | None = None
+    """Optional string provided by the server explaining the status."""
+
+    def consume_body(self) -> bytes:
+        """Read the response body into bytes."""
+        return read_streaming_blob(self.body)
 
 
 def quote_and_escape_field_value(value: str) -> str:

smithy_http-0.7.0/src/smithy_http/aio/__init__.py

@@ -0,0 +1,5 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+from .. import HTTPRequest, HTTPResponse
+
+__all__ = ["HTTPRequest", "HTTPResponse"]

{smithy_http-0.6.0 → smithy_http-0.7.0}/src/smithy_http/aio/aiohttp.py

@@ -25,22 +25,19 @@ from smithy_core.aio.types import AsyncBytesReader
 from smithy_core.exceptions import MissingDependencyError
 from smithy_core.interfaces import URI
 
-from .. import Field, Fields
+from smithy_http import HTTPResponse
+from smithy_http.interfaces import HTTPRequest
+from smithy_http.interfaces import HTTPResponse as HTTPResponseInterface
+
+from .. import tuples_to_fields
 from ..exceptions import SmithyHTTPError
 from ..interfaces import (
     HTTPClientConfiguration,
     HTTPRequestConfiguration,
 )
-from . import HTTPResponse
-from .interfaces import HTTPClient, HTTPRequest
-from .interfaces import HTTPResponse as HTTPResponseInterface
+from .interfaces import AsyncHTTPClient
 
-
-def _assert_aiohttp() -> None:
-    if not HAS_AIOHTTP:
-        raise MissingDependencyError(
-            "Attempted to use aiohttp component, but aiohttp is not installed."
-        )
+__all__ = ["AIOHTTPClient", "AIOHTTPClientConfig"]
 
 
 class AIOHTTPClientConfig(HTTPClientConfiguration):
@@ -48,23 +45,8 @@ 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."""
+class AIOHTTPClient(AsyncHTTPClient):
+    """Implementation of :py:class:`.interfaces.AsyncHTTPClient` using aiohttp."""
 
     TIMEOUT_EXCEPTIONS = (TimeoutError,)
 
@@ -93,6 +75,20 @@ class AIOHTTPClient(HTTPClient):
             headers={"Accept-Encoding": "identity"},
         )
 
+    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()
+
+    def __deepcopy__(self, memo: Any) -> "AIOHTTPClient":
+        return AIOHTTPClient(
+            client_config=deepcopy(self._config),
+            _session=copy(self._session),
+        )
+
     async def send(
         self,
         request: HTTPRequest,
@@ -145,14 +141,6 @@ class AIOHTTPClient(HTTPClient):
         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."""
         if not isinstance(body, AsyncBytesReader):
@@ -183,26 +171,37 @@ class AIOHTTPClient(HTTPClient):
         self, aiohttp_resp: "aiohttp.ClientResponse"
     ) -> HTTPResponseInterface:
         """Convert a ``aiohttp.ClientResponse`` to a ``smithy_http.aio.HTTPResponse``"""
-        headers = Fields()
-        for header_name, header_val in aiohttp_resp.headers.items():
-            try:
-                headers[header_name].add(header_val)
-            except KeyError:
-                headers[header_name] = Field(
-                    name=header_name,
-                    values=[header_val],
-                    kind="header",
-                )
-
         return HTTPResponse(
             status=aiohttp_resp.status,
-            fields=headers,
+            fields=tuples_to_fields(aiohttp_resp.headers.items()),
             body=_AIOHTTPStreamingBody(aiohttp_resp),
             reason=aiohttp_resp.reason,
         )
 
-    def __deepcopy__(self, memo: Any) -> "AIOHTTPClient":
-        return AIOHTTPClient(
-            client_config=deepcopy(self._config),
-            _session=copy(self._session),
+
+def _assert_aiohttp() -> None:
+    if not HAS_AIOHTTP:
+        raise MissingDependencyError(
+            "Attempted to use aiohttp component, but aiohttp is not installed."
         )
+
+
+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
+        self._reader: AsyncBytesReader | None = None
+
+    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 read(self, size: int = -1) -> bytes:
+        if self._reader is None:
+            self._reader = AsyncBytesReader(self._response.content.iter_any())
+        return await self._reader.read(size)
+
+    async def close(self) -> None:
+        # Pools the connection if the body was read to completion, closes it if not.
+        self._response.release()

{smithy_http-0.6.0/src/smithy_http/interceptors → smithy_http-0.7.0/src/smithy_http/aio/auth}/__init__.py

@@ -1,2 +1,3 @@
 #  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #  SPDX-License-Identifier: Apache-2.0
+__all__: list[str] = []