smithy-http 0.0.1__tar.gz → 0.2.0__tar.gz

smithy_http-0.2.0/.changes/0.0.1.json

@@ -0,0 +1,12 @@
+{
+  "changes": [
+    {
+      "type": "feature",
+      "description": "Added support for aiohttp and AWSCRT http clients."
+    },
+    {
+      "type": "feature",
+      "description": "Added basic HTTP primitives and interfaces for Smithy clients."
+    }
+  ]
+}

smithy_http-0.2.0/.changes/0.1.0.json

@@ -0,0 +1,12 @@
+{
+  "changes": [
+    {
+      "type": "breaking",
+      "description": "Removed identity and auth interfaces in favor of the transport-agnostic interfaces introduced in `smithy-core`."
+    },
+    {
+      "type": "feature",
+      "description": "Introduced schema-based serializers and deserializers for HTTP binding protocols."
+    }
+  ]
+}

smithy_http-0.2.0/.changes/0.2.0.json

@@ -0,0 +1,8 @@
+{
+  "changes": [
+    {
+      "type": "breaking",
+      "description": "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`."
+    }
+  ]
+}

smithy_http-0.2.0/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## 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.2.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: smithy-http
+Version: 0.2.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/
+Project-URL: Issue tracker, https://github.com/smithy-lang/smithy-python/issues
+Author: Amazon Web Services
+License: Apache License 2.0
+License-File: NOTICE
+Keywords: http,sdk,smithy
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+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 :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.12
+Requires-Dist: smithy-core~=0.1.0
+Provides-Extra: aiohttp
+Requires-Dist: aiohttp<4.0,>=3.11.12; extra == 'aiohttp'
+Requires-Dist: yarl; extra == 'aiohttp'
+Provides-Extra: awscrt
+Requires-Dist: awscrt~=0.28.2; extra == 'awscrt'
+Description-Content-Type: text/markdown
+
+# smithy-http
+
+This package provides primitives and interfaces for http functionality in tooling generated by Smithy.

smithy_http-0.2.0/README.md

@@ -0,0 +1,3 @@
+# smithy-http
+
+This package provides primitives and interfaces for http functionality in tooling generated by Smithy.

smithy_http-0.2.0/pyproject.toml

@@ -0,0 +1,59 @@
+[project]
+name = "smithy-http"
+dynamic = ["version"]
+requires-python = ">=3.12"
+authors = [
+  {name = "Amazon Web Services"},
+]
+description = "HTTP components for Smithy tooling."
+readme = "README.md"
+license = {text = "Apache License 2.0"}
+keywords = ["smithy", "sdk", "http"]
+classifiers = [
+  "Development Status :: 2 - Pre-Alpha",
+  "Intended Audience :: Developers",
+  "Intended Audience :: System Administrators",
+  "Natural Language :: English",
+  "License :: OSI Approved :: Apache Software License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Topic :: Software Development :: Libraries"
+]
+dependencies = [
+    "smithy-core~=0.1.0",
+]
+
+[project.urls]
+"Changelog" = "https://github.com/smithy-lang/smithy-python/blob/develop/packages/smithy-http/CHANGELOG.md"
+"Code" = "https://github.com/smithy-lang/smithy-python/blob/develop/packages/smithy-http/"
+"Issue tracker" = "https://github.com/smithy-lang/smithy-python/issues"
+
+[project.optional-dependencies]
+awscrt = [
+    "awscrt~=0.28.2",
+]
+aiohttp = [
+    "aiohttp>=3.11.12, <4.0",
+    "yarl"
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/smithy_http/__init__.py"
+
+[tool.hatch.build]
+exclude = [
+  "tests",
+]
+
+[tool.ruff]
+src = ["src"]

{smithy_http-0.0.1 → smithy_http-0.2.0}/src/smithy_http/__init__.py

@@ -1,13 +1,12 @@
 # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 # SPDX-License-Identifier: Apache-2.0
-import importlib.metadata
 from collections import Counter, OrderedDict
 from collections.abc import Iterable, Iterator
 
 from . import interfaces
 from .interfaces import FieldPosition
 
-__version__: str = importlib.metadata.version("smithy-http")
+__version__ = "0.2.0"
 
 
 class Field(interfaces.Field):

{smithy_http-0.0.1 → smithy_http-0.2.0}/src/smithy_http/aio/aiohttp.py

@@ -23,7 +23,7 @@ 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 MissingDependencyException
+from smithy_core.exceptions import MissingDependencyError
 from smithy_core.interfaces import URI
 
 from .. import Field, Fields
@@ -39,7 +39,7 @@ from .interfaces import HTTPResponse as HTTPResponseInterface
 
 def _assert_aiohttp() -> None:
     if not HAS_AIOHTTP:
-        raise MissingDependencyException(
+        raise MissingDependencyError(
             "Attempted to use aiohttp component, but aiohttp is not installed."
         )
 

smithy_http-0.2.0/src/smithy_http/aio/auth/apikey.py

@@ -0,0 +1,122 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#  SPDX-License-Identifier: Apache-2.0
+from typing import Any, Protocol, Self
+
+from smithy_core import URI
+from smithy_core.aio.interfaces.auth import AuthScheme, Signer
+from smithy_core.aio.interfaces.identity import IdentityResolver
+from smithy_core.exceptions import SmithyIdentityError
+from smithy_core.interfaces import TypedProperties as _TypedProperties
+from smithy_core.traits import APIKeyLocation, HTTPAPIKeyAuthTrait
+from smithy_core.types import PropertyKey
+
+from ... import Field
+from ..identity.apikey import APIKeyIdentity, APIKeyIdentityProperties
+from ..interfaces import HTTPRequest
+
+
+class APIKeyResolverConfig(Protocol):
+    """A config bearing API key properties."""
+
+    api_key: str | None
+    """An explicit API key.
+
+    If not set, it MAY be retrieved from elsewhere by the resolver.
+    """
+
+    api_key_identity_resolver: (
+        IdentityResolver[APIKeyIdentity, APIKeyIdentityProperties] | None
+    )
+    """An API key identity resolver.
+
+    The default implementation only checks the explicitly configured key.
+    """
+
+
+API_KEY_RESOLVER_CONFIG = PropertyKey(key="config", value_type=APIKeyResolverConfig)
+"""A context property bearing an API key config."""
+
+
+class APIKeySigner(Signer[HTTPRequest, APIKeyIdentity, Any]):
+    """A signer that signs http requests with an api key."""
+
+    def __init__(
+        self, *, name: str, location: APIKeyLocation, scheme: str | None = None
+    ) -> None:
+        self._name = name
+        self._location = location
+        self._scheme = scheme
+
+    async def sign(
+        self,
+        *,
+        request: HTTPRequest,
+        identity: APIKeyIdentity,
+        properties: Any,
+    ) -> HTTPRequest:
+        match self._location:
+            case APIKeyLocation.QUERY:
+                query = request.destination.query or ""
+                if query:
+                    query += "&"
+                query += f"{self._name}={identity.api_key}"
+                request.destination = URI(
+                    scheme=request.destination.scheme,
+                    username=request.destination.username,
+                    password=request.destination.password,
+                    host=request.destination.host,
+                    port=request.destination.port,
+                    path=request.destination.password,
+                    query=query,
+                    fragment=request.destination.fragment,
+                )
+            case APIKeyLocation.HEADER:
+                value = identity.api_key
+                if self._scheme is not None:
+                    value = f"{self._scheme} {value}"
+                request.fields.set_field(Field(name=self._name, values=[value]))
+
+        return request
+
+
+class APIKeyAuthScheme(
+    AuthScheme[HTTPRequest, APIKeyIdentity, APIKeyIdentityProperties, Any]
+):
+    """An auth scheme containing necessary data and tools for api key auth."""
+
+    scheme_id = HTTPAPIKeyAuthTrait.id
+    _signer: APIKeySigner
+
+    def __init__(
+        self, *, name: str, location: APIKeyLocation, scheme: str | None = None
+    ) -> None:
+        self._signer = APIKeySigner(name=name, location=location, scheme=scheme)
+
+    def identity_properties(
+        self, *, context: _TypedProperties
+    ) -> APIKeyIdentityProperties:
+        config = context.get(API_KEY_RESOLVER_CONFIG)
+        if config is not None and config.api_key is not None:
+            return {"api_key": config.api_key}
+        return {}
+
+    def identity_resolver(
+        self, *, context: _TypedProperties
+    ) -> IdentityResolver[APIKeyIdentity, APIKeyIdentityProperties]:
+        config = context.get(API_KEY_RESOLVER_CONFIG)
+        if config is None or config.api_key_identity_resolver is None:
+            raise SmithyIdentityError(
+                "Attempted to use API key auth, but api_key_identity_resolver was not "
+                "set on the config."
+            )
+        return config.api_key_identity_resolver
+
+    def signer_properties(self, *, context: _TypedProperties) -> Any:
+        return {}
+
+    def signer(self) -> Signer[HTTPRequest, APIKeyIdentity, Any]:
+        return self._signer
+
+    @classmethod
+    def from_trait(cls, trait: HTTPAPIKeyAuthTrait, /) -> Self:
+        return cls(name=trait.name, location=trait.location, scheme=trait.scheme)

smithy_http-0.2.0/src/smithy_http/aio/crt.py

@@ -0,0 +1,343 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#  SPDX-License-Identifier: Apache-2.0
+#  pyright: reportMissingTypeStubs=false,reportUnknownMemberType=false
+#  flake8: noqa: F811
+from collections.abc import AsyncGenerator, AsyncIterable
+from copy import deepcopy
+from dataclasses import dataclass
+from inspect import iscoroutinefunction
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    # pyright doesn't like optional imports. This is reasonable because if we use these
+    # in type hints then they'd result in runtime errors.
+    # TODO: add integ tests that import these without the dependendency installed
+    from awscrt import http as crt_http
+    from awscrt import io as crt_io
+    from awscrt.aio.http import (
+        AIOHttpClientConnectionUnified,
+        AIOHttpClientStreamUnified,
+    )
+
+try:
+    from awscrt import http as crt_http
+    from awscrt import io as crt_io
+    from awscrt.aio.http import (
+        AIOHttpClientConnectionUnified,
+        AIOHttpClientStreamUnified,
+    )
+
+    HAS_CRT = True
+except ImportError:
+    HAS_CRT = False  # type: ignore
+
+from smithy_core import interfaces as core_interfaces
+from smithy_core.aio import interfaces as core_aio_interfaces
+from smithy_core.aio.types import AsyncBytesReader
+from smithy_core.exceptions import MissingDependencyError
+
+from .. import Field, Fields
+from .. import interfaces as http_interfaces
+from ..exceptions import SmithyHTTPError
+from ..interfaces import FieldPosition
+from . import interfaces as http_aio_interfaces
+
+# Default buffer size for reading from streams (8 KB)
+DEFAULT_READ_BUFFER_SIZE = 8192
+
+
+def _assert_crt() -> None:
+    if not HAS_CRT:
+        raise MissingDependencyError(
+            "Attempted to use awscrt component, but awscrt is not installed."
+        )
+
+
+class _AWSCRTEventLoop:
+    def __init__(self) -> None:
+        _assert_crt()
+        self.bootstrap = self._initialize_default_loop()
+
+    def _initialize_default_loop(self) -> "crt_io.ClientBootstrap":
+        event_loop_group = crt_io.EventLoopGroup(1)
+        host_resolver = crt_io.DefaultHostResolver(event_loop_group)
+        return crt_io.ClientBootstrap(event_loop_group, host_resolver)
+
+
+class AWSCRTHTTPResponse(http_aio_interfaces.HTTPResponse):
+    def __init__(
+        self,
+        *,
+        status: int,
+        fields: Fields,
+        stream: "AIOHttpClientStreamUnified",
+    ) -> None:
+        _assert_crt()
+        self._status = status
+        self._fields = fields
+        self._stream = stream
+
+    @property
+    def status(self) -> int:
+        return self._status
+
+    @property
+    def fields(self) -> Fields:
+        return self._fields
+
+    @property
+    def body(self) -> AsyncIterable[bytes]:
+        return self.chunks()
+
+    @property
+    def reason(self) -> str | None:
+        """Optional string provided by the server explaining the status."""
+        # TODO: See how CRT exposes reason.
+        return None
+
+    async def chunks(self) -> AsyncGenerator[bytes, None]:
+        while True:
+            chunk = await self._stream.get_next_response_chunk()
+            if chunk:
+                yield chunk
+            else:
+                break
+
+    def __repr__(self) -> str:
+        return (
+            f"AWSCRTHTTPResponse("
+            f"status={self.status}, "
+            f"fields={self.fields!r}, body=...)"
+        )
+
+
+ConnectionPoolKey = tuple[str, str, int | None]
+ConnectionPoolDict = dict[ConnectionPoolKey, "AIOHttpClientConnectionUnified"]
+
+
+@dataclass(kw_only=True)
+class AWSCRTHTTPClientConfig(http_interfaces.HTTPClientConfiguration):
+    """AWS CRT HTTP client configuration.
+
+    :param read_buffer_size: The buffer size in bytes to use when reading from streams.
+        Defaults to 8192 (8 KB).
+    """
+
+    read_buffer_size: int = DEFAULT_READ_BUFFER_SIZE
+
+    def __post_init__(self) -> None:
+        _assert_crt()
+
+
+class AWSCRTHTTPClient(http_aio_interfaces.HTTPClient):
+    _HTTP_PORT = 80
+    _HTTPS_PORT = 443
+
+    def __init__(
+        self,
+        eventloop: _AWSCRTEventLoop | None = None,
+        client_config: AWSCRTHTTPClientConfig | None = None,
+    ) -> None:
+        """
+        :param client_config: Configuration that applies to all requests made with this
+        client.
+        """
+        _assert_crt()
+        self._config = client_config or AWSCRTHTTPClientConfig()
+        if eventloop is None:
+            eventloop = _AWSCRTEventLoop()
+        self._eventloop = eventloop
+        self._client_bootstrap = self._eventloop.bootstrap
+        self._tls_ctx = crt_io.ClientTlsContext(crt_io.TlsContextOptions())
+        self._socket_options = crt_io.SocketOptions()
+        self._connections: ConnectionPoolDict = {}
+
+    async def send(
+        self,
+        request: http_aio_interfaces.HTTPRequest,
+        *,
+        request_config: http_aio_interfaces.HTTPRequestConfiguration | None = None,
+    ) -> AWSCRTHTTPResponse:
+        """Send HTTP request using awscrt client.
+
+        :param request: The request including destination URI, fields, payload.
+        :param request_config: Configuration specific to this request.
+        """
+        crt_request = self._marshal_request(request)
+        connection = await self._get_connection(request.destination)
+
+        # Convert body to async iterator for request_body_generator
+        body_generator = self._create_body_generator(request.body)
+
+        crt_stream = connection.request(
+            crt_request,
+            request_body_generator=body_generator,
+        )
+
+        return await self._await_response(crt_stream)
+
+    async def _await_response(
+        self, stream: "AIOHttpClientStreamUnified"
+    ) -> AWSCRTHTTPResponse:
+        status_code = await stream.get_response_status_code()
+        headers = await stream.get_response_headers()
+        fields = Fields()
+        for header_name, header_val in headers:
+            try:
+                fields[header_name].add(header_val)
+            except KeyError:
+                fields[header_name] = Field(
+                    name=header_name,
+                    values=[header_val],
+                    kind=FieldPosition.HEADER,
+                )
+        return AWSCRTHTTPResponse(
+            status=status_code,
+            fields=fields,
+            stream=stream,
+        )
+
+    async def _create_connection(
+        self, url: core_interfaces.URI
+    ) -> "AIOHttpClientConnectionUnified":
+        """Builds and validates connection to ``url``"""
+        connection = await self._build_new_connection(url)
+        await self._validate_connection(connection)
+        return connection
+
+    async def _get_connection(
+        self, url: core_interfaces.URI
+    ) -> "AIOHttpClientConnectionUnified":
+        # TODO: Use CRT connection pooling instead of this basic kind
+        connection_key = (url.scheme, url.host, url.port)
+        connection = self._connections.get(connection_key)
+
+        if connection and connection.is_open():
+            return connection
+
+        connection = await self._create_connection(url)
+        self._connections[connection_key] = connection
+        return connection
+
+    async def _build_new_connection(
+        self, url: core_interfaces.URI
+    ) -> "AIOHttpClientConnectionUnified":
+        if url.scheme == "http":
+            port = self._HTTP_PORT
+            tls_connection_options = None
+        elif url.scheme == "https":
+            port = self._HTTPS_PORT
+            tls_connection_options = self._tls_ctx.new_connection_options()
+            tls_connection_options.set_server_name(url.host)
+            # TODO: Support TLS configuration, including alpn
+            tls_connection_options.set_alpn_list(["h2", "http/1.1"])
+        else:
+            raise SmithyHTTPError(
+                f"AWSCRTHTTPClient does not support URL scheme {url.scheme}"
+            )
+        if url.port is not None:
+            port = url.port
+
+        return await AIOHttpClientConnectionUnified.new(
+            bootstrap=self._client_bootstrap,
+            host_name=url.host,
+            port=port,
+            socket_options=self._socket_options,
+            tls_connection_options=tls_connection_options,
+        )
+
+    async def _validate_connection(
+        self, connection: "AIOHttpClientConnectionUnified"
+    ) -> None:
+        """Validates an existing connection against the client config.
+
+        Checks performed:
+        * If ``force_http_2`` is enabled: Is the connection HTTP/2?
+        """
+        force_http_2 = self._config.force_http_2
+        if force_http_2 and connection.version is not crt_http.HttpVersion.Http2:
+            await connection.close()
+            negotiated = crt_http.HttpVersion(connection.version).name
+            raise SmithyHTTPError(f"HTTP/2 could not be negotiated: {negotiated}")
+
+    def _render_path(self, url: core_interfaces.URI) -> str:
+        path = url.path if url.path is not None else "/"
+        query = f"?{url.query}" if url.query is not None else ""
+        return f"{path}{query}"
+
+    def _marshal_request(
+        self, request: http_aio_interfaces.HTTPRequest
+    ) -> "crt_http.HttpRequest":
+        """Create :py:class:`awscrt.http.HttpRequest` from
+        :py:class:`smithy_http.aio.HTTPRequest`"""
+        headers_list: list[tuple[str, str]] = []
+        if "host" not in request.fields:
+            request.fields.set_field(
+                Field(name="host", values=[request.destination.host])
+            )
+
+        if "accept" not in request.fields:
+            request.fields.set_field(Field(name="accept", values=["*/*"]))
+
+        for fld in request.fields.entries.values():
+            # TODO: Use literal values for "header"/"trailer".
+            if fld.kind.value != FieldPosition.HEADER.value:
+                continue
+            for val in fld.values:
+                headers_list.append((fld.name, val))
+
+        path = self._render_path(request.destination)
+        headers = crt_http.HttpHeaders(headers_list)
+
+        crt_request = crt_http.HttpRequest(
+            method=request.method,
+            path=path,
+            headers=headers,
+        )
+        return crt_request
+
+    async def _create_body_generator(
+        self, body: core_aio_interfaces.StreamingBlob
+    ) -> AsyncGenerator[bytes, None]:
+        """Convert various body types to async generator for request_body_generator."""
+        if isinstance(body, bytes):
+            # Yield the entire body as a single chunk
+            yield body
+        elif isinstance(body, bytearray):
+            # Convert bytearray to bytes
+            yield bytes(body)
+        elif isinstance(body, AsyncIterable):
+            # Already async iterable, just yield from it.
+            # Check this before AsyncByteStream since AsyncBytesReader implements both.
+            async for chunk in body:
+                if isinstance(chunk, bytearray):
+                    yield bytes(chunk)
+                else:
+                    yield chunk
+        elif iscoroutinefunction(getattr(body, "read", None)) and isinstance(
+            body,  # type: ignore[reportGeneralTypeIssues]
+            core_aio_interfaces.AsyncByteStream,  # type: ignore[reportGeneralTypeIssues]
+        ):
+            # AsyncByteStream has async read method but is not iterable
+            while True:
+                chunk = await body.read(self._config.read_buffer_size)
+                if not chunk:
+                    break
+                if isinstance(chunk, bytearray):
+                    yield bytes(chunk)
+                else:
+                    yield chunk
+        else:
+            # Assume it's a sync BytesReader, wrap it in AsyncBytesReader
+            async_reader = AsyncBytesReader(body)
+            async for chunk in async_reader:
+                if isinstance(chunk, bytearray):
+                    yield bytes(chunk)
+                else:
+                    yield chunk
+
+    def __deepcopy__(self, memo: Any) -> "AWSCRTHTTPClient":
+        return AWSCRTHTTPClient(
+            eventloop=self._eventloop,
+            client_config=deepcopy(self._config),
+        )