Add implementation of AWS StandardRegionalEndpoints

Author: alextwoods

codegen/aws/core/src/main/java/software/amazon/smithy/python/aws/codegen/AwsPythonDependency.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package software.amazon.smithy.python.aws.codegen;
+
+import software.amazon.smithy.python.codegen.PythonDependency;
+import software.amazon.smithy.utils.SmithyUnstableApi;
+
+/**
+ * AWS Dependencies used in the smithy python generator.
+ */
+@SmithyUnstableApi
+public class AwsPythonDependency {
+    /**
+     * The core aws smithy runtime python package.
+     *
+     * <p>While in development this will use the develop branch.
+     */
+    public static final PythonDependency SMITHY_AWS_CORE = new PythonDependency(
+            "smithy_aws_core",
+            // You'll need to locally install this before we publish
+            "==0.0.1",
+            PythonDependency.Type.DEPENDENCY,
+            false);
+}

codegen/aws/core/src/main/java/software/amazon/smithy/python/aws/codegen/AwsRegionalEndpointsGenerator.java

@@ -0,0 +1,100 @@
+package software.amazon.smithy.python.aws.codegen;
+
+import java.util.List;
+import software.amazon.smithy.aws.traits.ServiceTrait;
+import software.amazon.smithy.codegen.core.Symbol;
+import software.amazon.smithy.python.codegen.CodegenUtils;
+import software.amazon.smithy.python.codegen.ConfigProperty;
+import software.amazon.smithy.python.codegen.GenerationContext;
+import software.amazon.smithy.python.codegen.SmithyPythonDependency;
+import software.amazon.smithy.python.codegen.integrations.EndpointsGenerator;
+import software.amazon.smithy.python.codegen.writer.PythonWriter;
+
+/**
+ * Generates endpoint config and resolution logic for standard regional endpoints.
+ */
+public class AwsRegionalEndpointsGenerator implements EndpointsGenerator {
+    @Override
+    public List<ConfigProperty> endpointsConfig(GenerationContext context) {
+        return List.of(ConfigProperty.builder()
+                        .name("endpoint_resolver")
+                        .type(Symbol.builder()
+                                .name("EndpointResolver[RegionalEndpointParameters]")
+                                .addReference(Symbol.builder()
+                                        .name("RegionalEndpointParameters")
+                                        .namespace(AwsPythonDependency.SMITHY_AWS_CORE.packageName() + ".endpoints.standard_regional", ".")
+                                        .addDependency(AwsPythonDependency.SMITHY_AWS_CORE)
+                                        .build())
+                                .addReference(Symbol.builder()
+                                        .name("EndpointResolver")
+                                        .namespace("smithy_http.aio.interfaces", ".")
+                                        .addDependency(SmithyPythonDependency.SMITHY_HTTP)
+                                        .build())
+                                .build())
+                        .documentation("""
+                                The endpoint resolver used to resolve the final endpoint per-operation based on the \
+                                configuration.""")
+                        .nullable(false)
+                        .initialize(writer -> {
+                            writer.addImport("smithy_aws_core.endpoints.standard_regional", "StandardRegionalEndpointsResolver");
+                            String endpointPrefix = context.settings().service(context.model())
+                                    .getTrait(ServiceTrait.class)
+                                    .map(ServiceTrait::getEndpointPrefix)
+                                    .orElse(context.settings().service().getName());
+
+                            writer.write(
+                                    "self.endpoint_resolver = endpoint_resolver or StandardRegionalEndpointsResolver(endpoint_prefix='$L')",
+                                    endpointPrefix);
+                        })
+                        .build(),
+                ConfigProperty.builder()
+                        .name("endpoint_uri")
+                        .type(Symbol.builder()
+                                .name("str | URI")
+                                .addReference(Symbol.builder()
+                                        .name("URI")
+                                        .namespace("smithy_core.interfaces", ".")
+                                        .addDependency(SmithyPythonDependency.SMITHY_CORE)
+                                        .build())
+                                .build())
+                        .documentation("A static URI to route requests to.")
+                        .build(),
+                ConfigProperty.builder()
+                        .name("region")
+                        .type(Symbol.builder().name("str").build())
+                        .documentation(" The AWS region to connect to. The configured region is used to "
+                                + "determine the service endpoint.")
+                        .build());
+    }
+
+    @Override
+    public void generateEndpoints(GenerationContext context, PythonWriter writer) {
+        var errorSymbol = CodegenUtils.getServiceError(context.settings());
+
+        writer.addDependency(AwsPythonDependency.SMITHY_AWS_CORE);
+        writer.addImport("smithy_aws_core.endpoints.standard_regional", "RegionalEndpointParameters");
+        writer.addImport("smithy_core", "URI");
+        writer.write("""
+                        endpoint = await config.endpoint_resolver.resolve_endpoint(
+                            RegionalEndpointParameters(sdk_endpoint=config.endpoint_uri,region=config.region)
+                        )
+                        if not endpoint.uri.path:
+                            path = ""
+                        elif endpoint.uri.path.endswith("/"):
+                            path = endpoint.uri.path[:-1]
+                        else:
+                            path = endpoint.uri.path
+                        if context.transport_request.destination.path:
+                            path += context.transport_request.destination.path
+                        context._transport_request.destination = URI(
+                            scheme=endpoint.uri.scheme,
+                            host=context.transport_request.destination.host + endpoint.uri.host,
+                            path=path,
+                            port=endpoint.uri.port,
+                            query=context.transport_request.destination.query,
+                        )
+                        context._transport_request.fields.extend(endpoint.headers)
+                
+                """);
+    }
+}

codegen/aws/core/src/main/java/software/amazon/smithy/python/aws/codegen/AwsRegionalEndpointsIntegration.java

@@ -0,0 +1,14 @@
+package software.amazon.smithy.python.aws.codegen;
+
+import java.util.Optional;
+import software.amazon.smithy.model.Model;
+import software.amazon.smithy.model.shapes.ServiceShape;
+import software.amazon.smithy.python.codegen.integrations.EndpointsGenerator;
+import software.amazon.smithy.python.codegen.integrations.PythonIntegration;
+
+public class AwsRegionalEndpointsIntegration implements PythonIntegration {
+    @Override
+    public Optional<EndpointsGenerator> getEndpointsGenerator(Model model, ServiceShape service) {
+        return Optional.of(new AwsRegionalEndpointsGenerator());
+    }
+}

codegen/aws/core/src/main/resources/META-INF/services/software.amazon.smithy.python.codegen.integrations.PythonIntegration

@@ -5,3 +5,4 @@
 
 software.amazon.smithy.python.aws.codegen.AwsAuthIntegration
 software.amazon.smithy.python.aws.codegen.AwsProtocolsIntegration
+software.amazon.smithy.python.aws.codegen.AwsRegionalEndpointsIntegration

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

@@ -432,6 +432,7 @@ async def _handle_attempt(
 
         writer.pushState(new ResolveEndpointSection());
         if (context.applicationProtocol().isHttpProtocol()) {
+            writer.write("# Step 7f: Invoke endpoint_resolver.resolve_endpoint");
             context.endpointsGenerator().generateEndpoints(context, writer);
         }
         writer.popState();

codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/StaticEndpointsGenerator.java

@@ -60,7 +60,6 @@ public void generateEndpoints(GenerationContext context, PythonWriter writer) {
         writer.addImport("smithy_http.endpoints", "StaticEndpointParams");
         writer.addImport("smithy_core", "URI");
         writer.write("""
-                            # Step 7f: Invoke endpoint_resolver.resolve_endpoint
                             if config.endpoint_uri is None:
                                 raise $1T(
                                     "No endpoint_uri found on the operation config."

codegen/core/src/main/java/software/amazon/smithy/python/codegen/integrations/EndpointsGenerator.java

@@ -6,11 +6,32 @@
 import software.amazon.smithy.python.codegen.writer.PythonWriter;
 
 /**
- *
+ * Interface for Endpoints Generators.
+ * Endpoints Generators are responsible for defining the client configuration
+ * required for resolving endpoints, this includes an appropriately typed
+ * `endpoint_resolver` and any other configuration properties such as `endpoint_uri`.
+ * Endpoint generators are also responsible for rendering the logic in the client's
+ * request execution stack that sets the destination on the transport request.
+ * Endpoints Generators are only applied to services that use an HTTP transport.
  */
 public interface EndpointsGenerator {
 
+    /**
+     * Endpoints Generators are responsible for defining the client configuration
+     * required for resolving endpoints, this includes an appropriately typed
+     * `endpoint_resolver` and any other configuration properties such as `endpoint_uri`
+     *
+     * @param context generation context.
+     * @return list of client config required to resolve endpoints.
+     */
     List<ConfigProperty> endpointsConfig(GenerationContext context);
 
+    /**
+     * Render the logic in the client's request execution stack that sets the
+     * destination on the transport request using the provided writer.
+     *
+     * @param context generation context
+     * @param writer writer to generate endpoint resolution/setting logic with
+     */
     void generateEndpoints(GenerationContext context, PythonWriter writer);
 }

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

@@ -0,0 +1,2 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#  SPDX-License-Identifier: Apache-2.0

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

@@ -0,0 +1,61 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#  SPDX-License-Identifier: Apache-2.0
+from dataclasses import dataclass
+from urllib.parse import urlparse
+
+import smithy_core
+from smithy_core import URI
+from smithy_http.aio.interfaces import EndpointResolver
+from smithy_http.endpoints import Endpoint
+
+
+@dataclass(kw_only=True)
+class RegionalEndpointParameters:
+    """Endpoint parameters for services with standard regional endpoints."""
+
+    sdk_endpoint: str | smithy_core.interfaces.URI | None
+    region: str | None
+
+
+class StandardRegionalEndpointsResolver(EndpointResolver[RegionalEndpointParameters]):
+    """Resolves endpoints for services with standard regional endpoints."""
+
+    def __init__(self, endpoint_prefix: str):
+        self._endpoint_prefix = endpoint_prefix
+
+    async def resolve_endpoint(self, params: RegionalEndpointParameters) -> Endpoint:
+        if params.sdk_endpoint is not None:
+            # If it's not a string, it's already a parsed URI so just pass it along.
+            if not isinstance(params.sdk_endpoint, str):
+                return Endpoint(uri=params.sdk_endpoint)
+
+            # Does crt have implementations of these parsing methods? Using the standard
+            # library is probably fine.
+            parsed = urlparse(params.sdk_endpoint)
+
+            # This will end up getting wrapped in the client.
+            if parsed.hostname is None:
+                raise ValueError(
+                    f"Unable to parse hostname from provided URI: {params.sdk_endpoint}"
+                )
+
+            return Endpoint(
+                uri=URI(
+                    host=parsed.hostname,
+                    path=parsed.path,
+                    scheme=parsed.scheme,
+                    query=parsed.query,
+                    port=parsed.port,
+                )
+            )
+
+        if params.region is not None:
+            # TODO: use dns suffix determined from partition metadata
+            dns_suffix = "amazonaws.com"
+            hostname = f"{self._endpoint_prefix}.{params.region}.{dns_suffix}"
+
+            return Endpoint(uri=URI(host=hostname))
+
+        raise ValueError(
+            "Unable to resolve endpoint - either endpoint_url or region are required."
+        )