Pull resolver params from config

Author: JordonPhillips

codegen/core/src/main/java/software/amazon/smithy/python/codegen/ClientGenerator.java

@@ -530,7 +530,6 @@ await sleep(retry_token.retry_delay)
         writer.addImport("smithy_core.endpoints", "EndpointResolverParams");
         writer.write("""
                         # Step 7f: Invoke endpoint_resolver.resolve_endpoint
-                        context.properties["endpoint_uri"] = config.endpoint_uri
                         endpoint_resolver_parameters = EndpointResolverParams(
                             operation=operation,
                             input=context.request,

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

@@ -4,10 +4,3 @@
 import importlib.metadata
 
 __version__: str = importlib.metadata.version("smithy-aws-core")
-
-
-from smithy_core.types import PropertyKey
-
-
-REGION = PropertyKey(key="region", value_type=str)
-"""An AWS region."""

packages/smithy-aws-core/src/smithy_aws_core/endpoints/__init__.py

@@ -1,2 +1,15 @@
 #  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #  SPDX-License-Identifier: Apache-2.0
+from smithy_core.endpoints import StaticEndpointConfig
+from smithy_core.types import PropertyKey
+
+
+class RegionalEndpointConfig(StaticEndpointConfig):
+    """Endpoint config for services with standard regional endpoints."""
+
+    region: str | None
+    """The AWS region to address the request to."""
+
+
+REGIONAL_ENDPOINT_CONFIG = PropertyKey(key="config", value_type=RegionalEndpointConfig)
+"""Endpoint config for services with standard regional endpoints."""

packages/smithy-aws-core/src/smithy_aws_core/endpoints/standard_regional.py

@@ -7,7 +7,7 @@
 from smithy_core.endpoints import Endpoint, EndpointResolverParams, resolve_static_uri
 from smithy_core.exceptions import EndpointResolutionError
 
-from .. import REGION
+from . import REGIONAL_ENDPOINT_CONFIG
 
 
 class StandardRegionalEndpointsResolver(EndpointResolver):
@@ -20,10 +20,11 @@ async def resolve_endpoint(self, params: EndpointResolverParams[Any]) -> Endpoin
         if (static_uri := resolve_static_uri(params)) is not None:
             return Endpoint(uri=static_uri)
 
-        if (region := params.context.get(REGION)) is not None:
+        region_config = params.context.get(REGIONAL_ENDPOINT_CONFIG)
+        if region_config is not None and region_config.region is not None:
             # TODO: use dns suffix determined from partition metadata
             dns_suffix = "amazonaws.com"
-            hostname = f"{self._endpoint_prefix}.{region}.{dns_suffix}"
+            hostname = f"{self._endpoint_prefix}.{region_config.region}.{dns_suffix}"
 
             return Endpoint(uri=URI(host=hostname))
 

packages/smithy-aws-core/tests/unit/endpoints/test_standard_regional.py

@@ -1,26 +1,46 @@
 #  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #  SPDX-License-Identifier: Apache-2.0
+from dataclasses import dataclass
+from typing import Any
 from unittest.mock import Mock
 
 import pytest
 
 from smithy_core import URI
-from smithy_core.endpoints import STATIC_URI, EndpointResolverParams
+from smithy_core.endpoints import EndpointResolverParams
 from smithy_core.types import TypedProperties
 from smithy_core.exceptions import EndpointResolutionError
 
-from smithy_aws_core import REGION
+from smithy_aws_core.endpoints import REGIONAL_ENDPOINT_CONFIG
 from smithy_aws_core.endpoints.standard_regional import (
     StandardRegionalEndpointsResolver,
 )
 
 
+@dataclass
+class EndpointConfig:
+    endpoint_uri: str | URI | None = None
+    region: str | None = None
+
+    @classmethod
+    def params(
+        cls, endpoint_uri: str | URI | None = None, region: str | None = None
+    ) -> EndpointResolverParams[Any]:
+        properties = TypedProperties(
+            {
+                REGIONAL_ENDPOINT_CONFIG.key: cls(
+                    endpoint_uri=endpoint_uri, region=region
+                )
+            }
+        )
+        params = Mock(spec=EndpointResolverParams)
+        params.context = properties
+        return params
+
+
 async def test_resolve_endpoint_with_valid_sdk_endpoint_string():
     resolver = StandardRegionalEndpointsResolver(endpoint_prefix="service")
-    params = Mock(spec=EndpointResolverParams)
-    params.context = TypedProperties(
-        {STATIC_URI.key: "https://example.com/path?query=123"}
-    )
+    params = EndpointConfig.params("https://example.com/path?query=123")
 
     endpoint = await resolver.resolve_endpoint(params)
 
@@ -35,8 +55,7 @@ async def test_resolve_endpoint_with_sdk_endpoint_uri():
     parsed_uri = URI(
         host="example.com", path="/path", scheme="https", query="query=123", port=443
     )
-    params = Mock(spec=EndpointResolverParams)
-    params.context = TypedProperties({STATIC_URI.key: parsed_uri})
+    params = EndpointConfig.params(parsed_uri)
 
     endpoint = await resolver.resolve_endpoint(params)
 
@@ -45,17 +64,15 @@ async def test_resolve_endpoint_with_sdk_endpoint_uri():
 
 async def test_resolve_endpoint_with_invalid_sdk_endpoint():
     resolver = StandardRegionalEndpointsResolver(endpoint_prefix="service")
-    params = Mock(spec=EndpointResolverParams)
-    params.context = TypedProperties({STATIC_URI.key: "invalid_uri"})
+    params = EndpointConfig.params("invalid_uri")
 
     with pytest.raises(EndpointResolutionError):
         await resolver.resolve_endpoint(params)
 
 
 async def test_resolve_endpoint_with_region():
     resolver = StandardRegionalEndpointsResolver(endpoint_prefix="service")
-    params = Mock(spec=EndpointResolverParams)
-    params.context = TypedProperties({REGION.key: "us-west-2"})
+    params = EndpointConfig.params(region="us-west-2")
 
     endpoint = await resolver.resolve_endpoint(params)
 
@@ -64,18 +81,16 @@ async def test_resolve_endpoint_with_region():
 
 async def test_resolve_endpoint_with_no_sdk_endpoint_or_region():
     resolver = StandardRegionalEndpointsResolver(endpoint_prefix="service")
-    params = Mock(spec=EndpointResolverParams)
-    params.context = TypedProperties()
+    params = EndpointConfig.params()
 
     with pytest.raises(EndpointResolutionError):
         await resolver.resolve_endpoint(params)
 
 
 async def test_resolve_endpoint_with_sdk_endpoint_and_region():
     resolver = StandardRegionalEndpointsResolver(endpoint_prefix="service")
-    params = Mock(spec=EndpointResolverParams)
-    params.context = TypedProperties(
-        {STATIC_URI.key: "https://example.com", REGION.key: "us-west-2"}
+    params = EndpointConfig.params(
+        endpoint_uri="https://example.com", region="us-west-2"
     )
 
     endpoint = await resolver.resolve_endpoint(params)

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

@@ -1,6 +1,6 @@
 # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 # SPDX-License-Identifier: Apache-2.0
-from typing import Any
+from typing import Any, Protocol
 from dataclasses import dataclass, field
 from urllib.parse import urlparse
 
@@ -14,17 +14,6 @@
 from .exceptions import EndpointResolutionError
 
 
-STATIC_URI: PropertyKey[str | _URI] = PropertyKey(
-    key="endpoint_uri",
-    # Python currently has problems expressing parametric types that can be
-    # unions, literals, or other special types in addition to a class. So
-    # we have to ignore the type below. PEP 747 should resolve the issue.
-    # TODO: update this when PEP 747 lands
-    value_type=str | _URI,  # type: ignore
-)
-"""The property key for a statically defined URI."""
-
-
 @dataclass(kw_only=True)
 class Endpoint(_Endpoint):
     """A resolved endpoint."""
@@ -54,6 +43,17 @@ class EndpointResolverParams[I: SerializeableShape]:
     """The context of the operation invocation."""
 
 
+class StaticEndpointConfig(Protocol):
+    """A config that has a static endpoint."""
+
+    endpoint_uri: str | URI | None
+    """A static endpoint to use for the request."""
+
+
+STATIC_ENDPOINT_CONFIG = PropertyKey(key="config", value_type=StaticEndpointConfig)
+"""Property containing a config that has a static endpoint."""
+
+
 def resolve_static_uri(
     properties: _TypedProperties | EndpointResolverParams[Any],
 ) -> _URI | None:
@@ -66,10 +66,12 @@ def resolve_static_uri(
         if isinstance(properties, EndpointResolverParams)
         else properties
     )
-    static_uri = properties.get(STATIC_URI)
-    if static_uri is None:
+    static_uri_config = properties.get(STATIC_ENDPOINT_CONFIG)
+    if static_uri_config is None or static_uri_config.endpoint_uri is None:
         return None
 
+    static_uri = static_uri_config.endpoint_uri
+
     # If it's not a string, it's already a parsed URI so just pass it along.
     if not isinstance(static_uri, str):
         return static_uri

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

@@ -136,7 +136,6 @@ class PropertyKey[T](Protocol):
     key: str
     """The string key used to access the value."""
 
-    # TODO: update this when PEP 747 lands to allow for unions and literals
     value_type: type[T]
     """The type of the associated value in the properties bag."""
 

packages/smithy-core/tests/unit/aio/test_endpoints.py

@@ -1,17 +1,31 @@
 # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 # SPDX-License-Identifier: Apache-2.0
+from dataclasses import dataclass
+from typing import Any
 from unittest.mock import Mock
 from smithy_core.types import TypedProperties
-from smithy_core.endpoints import EndpointResolverParams, STATIC_URI
+from smithy_core.endpoints import EndpointResolverParams, STATIC_ENDPOINT_CONFIG
 from smithy_core.aio.endpoints import StaticEndpointResolver
 from smithy_core import URI
 
 
+@dataclass
+class EndpointConfig:
+    endpoint_uri: str | URI | None = None
+
+    @classmethod
+    def params(
+        cls, endpoint_uri: str | URI | None = None
+    ) -> EndpointResolverParams[Any]:
+        params = Mock(spec=EndpointResolverParams)
+        params.context = TypedProperties(
+            {STATIC_ENDPOINT_CONFIG.key: cls(endpoint_uri)}
+        )
+        return params
+
+
 async def test_endpoint_provider_with_uri_string() -> None:
-    params = Mock(spec=EndpointResolverParams)
-    params.context = TypedProperties(
-        {STATIC_URI.key: "https://foo.example.com:8080/spam?foo=bar&foo=baz"}
-    )
+    params = EndpointConfig.params("https://foo.example.com:8080/spam?foo=bar&foo=baz")
     expected = URI(
         host="foo.example.com",
         path="/spam",
@@ -32,8 +46,7 @@ async def test_endpoint_provider_with_uri_object() -> None:
         query="foo=bar&foo=baz",
         port=8080,
     )
-    params = Mock(spec=EndpointResolverParams)
-    params.context = TypedProperties({STATIC_URI.key: expected})
+    params = EndpointConfig.params(expected)
     resolver = StaticEndpointResolver()
     result = await resolver.resolve_endpoint(params=params)
     assert result.uri == expected