capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/_resources/aws_gir_api_service/provisioned_concurrency_config.py

@@ -0,0 +1,376 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+import capo_lambda._auth._signers
+import capo_lambda._auth._sigv4
+from capo_lambda._services._pipeline import (
+    AsyncOperationRequest,
+    AsyncOperationResponse,
+    OperationRequest,
+    OperationResponse,
+    aexecute_pipeline,
+    execute_pipeline,
+)
+
+if TYPE_CHECKING:
+    import capo_lambda.types.delete_provisioned_concurrency_config_request
+    import capo_lambda.types.function_name
+    import capo_lambda.types.get_provisioned_concurrency_config_request
+    import capo_lambda.types.get_provisioned_concurrency_config_response
+    import capo_lambda.types.positive_integer
+    import capo_lambda.types.put_provisioned_concurrency_config_request
+    import capo_lambda.types.put_provisioned_concurrency_config_response
+    import capo_lambda.types.qualifier
+    from capo_lambda._services._lambda import LambdaClient, LambdaClientConfig
+    from capo_lambda._services.async__lambda import (
+        AsyncLambdaClient,
+        AsyncLambdaClientConfig,
+    )
+
+
+class ProvisionedConcurrencyConfig:
+    def __init__(self, service: LambdaClient) -> None:
+        self._service = service
+
+    def put(
+        self,
+        function_name: "capo_lambda.types.function_name.FunctionName",
+        qualifier: "capo_lambda.types.qualifier.Qualifier",
+        provisioned_concurrent_executions: "capo_lambda.types.positive_integer.PositiveInteger",
+        *,
+        config_overrides: Optional[LambdaClientConfig] = None,
+    ) -> "capo_lambda.types.put_provisioned_concurrency_config_response.PutProvisionedConcurrencyConfigResponse":
+        r"""<p>Adds a provisioned concurrency configuration to a function's alias or version.</p>
+
+        Args:
+            function_name: <p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code>.</p> </li> <li> <p> <b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p> </li> <li> <p> <b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>
+            qualifier: <p>The version number or alias name.</p>
+            provisioned_concurrent_executions: <p>The amount of provisioned concurrency to allocate for the version or alias.</p>
+
+        Raises:
+            capo_lambda.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>One of the parameters in the request is not valid.</p>
+            capo_lambda.errors.resource_conflict_exception.ResourceConflictException: <p>The resource already exists, or another operation is in progress.</p>
+            capo_lambda.errors.resource_not_found_exception.ResourceNotFoundException: <p>The resource specified in the request does not exist.</p>
+            capo_lambda.errors.service_exception.ServiceException: <p>The Lambda service encountered an internal error.</p>
+            capo_lambda.errors.too_many_requests_exception.TooManyRequestsException: <p>The request throughput limit was exceeded. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#api-requests\">Lambda quotas</a>.</p>
+            capo_lambda.errors.UnknownServiceError: The service returned an error code this client does not model.
+
+        Examples:
+            To allocate provisioned concurrency
+            The following example allocates 100 provisioned concurrency for the BLUE alias of the specified function.
+
+            >>> client.put(function_name='my-function', qualifier='BLUE', provisioned_concurrent_executions=100)
+        """
+
+        def _handler(
+            req: "OperationRequest[capo_lambda.types.put_provisioned_concurrency_config_request.PutProvisionedConcurrencyConfigRequest]",
+        ) -> OperationResponse[
+            "capo_lambda.types.put_provisioned_concurrency_config_response.PutProvisionedConcurrencyConfigResponse"
+        ]:
+            import capo_lambda._operations.aws_gir_api_service.put_provisioned_concurrency_config
+
+            output, http_response = (
+                capo_lambda._operations.aws_gir_api_service.put_provisioned_concurrency_config.put_provisioned_concurrency_config(
+                    req.options, req.input
+                )
+            )
+            return OperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self._service.operation_options(config_overrides)
+        input_: capo_lambda.types.put_provisioned_concurrency_config_request.PutProvisionedConcurrencyConfigRequest = {}  # type: ignore[typeddict-item]
+        input_["function_name"] = function_name
+        input_["qualifier"] = qualifier
+        input_["provisioned_concurrent_executions"] = provisioned_concurrent_executions
+
+        response = execute_pipeline(
+            OperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        return response.output
+
+    def read(
+        self,
+        function_name: "capo_lambda.types.function_name.FunctionName",
+        qualifier: "capo_lambda.types.qualifier.Qualifier",
+        *,
+        config_overrides: Optional[LambdaClientConfig] = None,
+    ) -> "capo_lambda.types.get_provisioned_concurrency_config_response.GetProvisionedConcurrencyConfigResponse":
+        r"""<p>Retrieves the provisioned concurrency configuration for a function's alias or version.</p>
+
+        Args:
+            function_name: <p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code>.</p> </li> <li> <p> <b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p> </li> <li> <p> <b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>
+            qualifier: <p>The version number or alias name.</p>
+
+        Raises:
+            capo_lambda.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>One of the parameters in the request is not valid.</p>
+            capo_lambda.errors.provisioned_concurrency_config_not_found_exception.ProvisionedConcurrencyConfigNotFoundException: <p>The specified configuration does not exist.</p>
+            capo_lambda.errors.resource_not_found_exception.ResourceNotFoundException: <p>The resource specified in the request does not exist.</p>
+            capo_lambda.errors.service_exception.ServiceException: <p>The Lambda service encountered an internal error.</p>
+            capo_lambda.errors.too_many_requests_exception.TooManyRequestsException: <p>The request throughput limit was exceeded. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#api-requests\">Lambda quotas</a>.</p>
+            capo_lambda.errors.UnknownServiceError: The service returned an error code this client does not model.
+
+        Examples:
+            To get a provisioned concurrency configuration
+            The following example returns details for the provisioned concurrency configuration for the BLUE alias of the specified function.
+
+            >>> client.read(function_name='my-function', qualifier='BLUE')
+            To view a provisioned concurrency configuration
+            The following example displays details for the provisioned concurrency configuration for the BLUE alias of the specified function.
+
+            >>> client.read(function_name='my-function', qualifier='BLUE')
+        """
+
+        def _handler(
+            req: "OperationRequest[capo_lambda.types.get_provisioned_concurrency_config_request.GetProvisionedConcurrencyConfigRequest]",
+        ) -> OperationResponse[
+            "capo_lambda.types.get_provisioned_concurrency_config_response.GetProvisionedConcurrencyConfigResponse"
+        ]:
+            import capo_lambda._operations.aws_gir_api_service.get_provisioned_concurrency_config
+
+            output, http_response = (
+                capo_lambda._operations.aws_gir_api_service.get_provisioned_concurrency_config.get_provisioned_concurrency_config(
+                    req.options, req.input
+                )
+            )
+            return OperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self._service.operation_options(config_overrides)
+        input_: capo_lambda.types.get_provisioned_concurrency_config_request.GetProvisionedConcurrencyConfigRequest = {}  # type: ignore[typeddict-item]
+        input_["function_name"] = function_name
+        input_["qualifier"] = qualifier
+
+        response = execute_pipeline(
+            OperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        return response.output
+
+    def delete(
+        self,
+        function_name: "capo_lambda.types.function_name.FunctionName",
+        qualifier: "capo_lambda.types.qualifier.Qualifier",
+        *,
+        config_overrides: Optional[LambdaClientConfig] = None,
+    ) -> None:
+        r"""<p>Deletes the provisioned concurrency configuration for a function.</p>
+
+        Args:
+            function_name: <p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code>.</p> </li> <li> <p> <b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p> </li> <li> <p> <b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>
+            qualifier: <p>The version number or alias name.</p>
+
+        Raises:
+            capo_lambda.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>One of the parameters in the request is not valid.</p>
+            capo_lambda.errors.resource_conflict_exception.ResourceConflictException: <p>The resource already exists, or another operation is in progress.</p>
+            capo_lambda.errors.resource_not_found_exception.ResourceNotFoundException: <p>The resource specified in the request does not exist.</p>
+            capo_lambda.errors.service_exception.ServiceException: <p>The Lambda service encountered an internal error.</p>
+            capo_lambda.errors.too_many_requests_exception.TooManyRequestsException: <p>The request throughput limit was exceeded. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#api-requests\">Lambda quotas</a>.</p>
+            capo_lambda.errors.UnknownServiceError: The service returned an error code this client does not model.
+
+        Examples:
+            To delete a provisioned concurrency configuration
+            The following example deletes the provisioned concurrency configuration for the GREEN alias of a function named my-function.
+
+            >>> client.delete(function_name='my-function', qualifier='GREEN')
+        """
+
+        def _handler(
+            req: "OperationRequest[capo_lambda.types.delete_provisioned_concurrency_config_request.DeleteProvisionedConcurrencyConfigRequest]",
+        ) -> OperationResponse[None]:
+            import capo_lambda._operations.aws_gir_api_service.delete_provisioned_concurrency_config
+
+            output, http_response = (
+                capo_lambda._operations.aws_gir_api_service.delete_provisioned_concurrency_config.delete_provisioned_concurrency_config(
+                    req.options, req.input
+                )
+            )
+            return OperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self._service.operation_options(config_overrides)
+        input_: capo_lambda.types.delete_provisioned_concurrency_config_request.DeleteProvisionedConcurrencyConfigRequest = {}  # type: ignore[typeddict-item]
+        input_["function_name"] = function_name
+        input_["qualifier"] = qualifier
+
+        response = execute_pipeline(
+            OperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        return response.output
+
+
+class AsyncProvisionedConcurrencyConfig:
+    def __init__(self, service: AsyncLambdaClient) -> None:
+        self._service = service
+
+    async def put(
+        self,
+        function_name: "capo_lambda.types.function_name.FunctionName",
+        qualifier: "capo_lambda.types.qualifier.Qualifier",
+        provisioned_concurrent_executions: "capo_lambda.types.positive_integer.PositiveInteger",
+        *,
+        config_overrides: Optional[AsyncLambdaClientConfig] = None,
+    ) -> "capo_lambda.types.put_provisioned_concurrency_config_response.PutProvisionedConcurrencyConfigResponse":
+        r"""<p>Adds a provisioned concurrency configuration to a function's alias or version.</p>
+
+        Args:
+            function_name: <p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code>.</p> </li> <li> <p> <b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p> </li> <li> <p> <b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>
+            qualifier: <p>The version number or alias name.</p>
+            provisioned_concurrent_executions: <p>The amount of provisioned concurrency to allocate for the version or alias.</p>
+
+        Raises:
+            capo_lambda.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>One of the parameters in the request is not valid.</p>
+            capo_lambda.errors.resource_conflict_exception.ResourceConflictException: <p>The resource already exists, or another operation is in progress.</p>
+            capo_lambda.errors.resource_not_found_exception.ResourceNotFoundException: <p>The resource specified in the request does not exist.</p>
+            capo_lambda.errors.service_exception.ServiceException: <p>The Lambda service encountered an internal error.</p>
+            capo_lambda.errors.too_many_requests_exception.TooManyRequestsException: <p>The request throughput limit was exceeded. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#api-requests\">Lambda quotas</a>.</p>
+            capo_lambda.errors.UnknownServiceError: The service returned an error code this client does not model.
+
+        Examples:
+            To allocate provisioned concurrency
+            The following example allocates 100 provisioned concurrency for the BLUE alias of the specified function.
+
+            >>> await client.put(function_name='my-function', qualifier='BLUE', provisioned_concurrent_executions=100)
+        """
+
+        async def _handler(
+            req: "AsyncOperationRequest[capo_lambda.types.put_provisioned_concurrency_config_request.PutProvisionedConcurrencyConfigRequest]",
+        ) -> AsyncOperationResponse[
+            "capo_lambda.types.put_provisioned_concurrency_config_response.PutProvisionedConcurrencyConfigResponse"
+        ]:
+            import capo_lambda._operations.aws_gir_api_service.put_provisioned_concurrency_config
+
+            (
+                output,
+                http_response,
+            ) = await capo_lambda._operations.aws_gir_api_service.put_provisioned_concurrency_config.async_put_provisioned_concurrency_config(
+                req.options, req.input
+            )
+            return AsyncOperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self._service.operation_options(config_overrides)
+        input_: capo_lambda.types.put_provisioned_concurrency_config_request.PutProvisionedConcurrencyConfigRequest = {}  # type: ignore[typeddict-item]
+        input_["function_name"] = function_name
+        input_["qualifier"] = qualifier
+        input_["provisioned_concurrent_executions"] = provisioned_concurrent_executions
+
+        response = await aexecute_pipeline(
+            AsyncOperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        return response.output
+
+    async def read(
+        self,
+        function_name: "capo_lambda.types.function_name.FunctionName",
+        qualifier: "capo_lambda.types.qualifier.Qualifier",
+        *,
+        config_overrides: Optional[AsyncLambdaClientConfig] = None,
+    ) -> "capo_lambda.types.get_provisioned_concurrency_config_response.GetProvisionedConcurrencyConfigResponse":
+        r"""<p>Retrieves the provisioned concurrency configuration for a function's alias or version.</p>
+
+        Args:
+            function_name: <p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code>.</p> </li> <li> <p> <b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p> </li> <li> <p> <b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>
+            qualifier: <p>The version number or alias name.</p>
+
+        Raises:
+            capo_lambda.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>One of the parameters in the request is not valid.</p>
+            capo_lambda.errors.provisioned_concurrency_config_not_found_exception.ProvisionedConcurrencyConfigNotFoundException: <p>The specified configuration does not exist.</p>
+            capo_lambda.errors.resource_not_found_exception.ResourceNotFoundException: <p>The resource specified in the request does not exist.</p>
+            capo_lambda.errors.service_exception.ServiceException: <p>The Lambda service encountered an internal error.</p>
+            capo_lambda.errors.too_many_requests_exception.TooManyRequestsException: <p>The request throughput limit was exceeded. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#api-requests\">Lambda quotas</a>.</p>
+            capo_lambda.errors.UnknownServiceError: The service returned an error code this client does not model.
+
+        Examples:
+            To get a provisioned concurrency configuration
+            The following example returns details for the provisioned concurrency configuration for the BLUE alias of the specified function.
+
+            >>> await client.read(function_name='my-function', qualifier='BLUE')
+            To view a provisioned concurrency configuration
+            The following example displays details for the provisioned concurrency configuration for the BLUE alias of the specified function.
+
+            >>> await client.read(function_name='my-function', qualifier='BLUE')
+        """
+
+        async def _handler(
+            req: "AsyncOperationRequest[capo_lambda.types.get_provisioned_concurrency_config_request.GetProvisionedConcurrencyConfigRequest]",
+        ) -> AsyncOperationResponse[
+            "capo_lambda.types.get_provisioned_concurrency_config_response.GetProvisionedConcurrencyConfigResponse"
+        ]:
+            import capo_lambda._operations.aws_gir_api_service.get_provisioned_concurrency_config
+
+            (
+                output,
+                http_response,
+            ) = await capo_lambda._operations.aws_gir_api_service.get_provisioned_concurrency_config.async_get_provisioned_concurrency_config(
+                req.options, req.input
+            )
+            return AsyncOperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self._service.operation_options(config_overrides)
+        input_: capo_lambda.types.get_provisioned_concurrency_config_request.GetProvisionedConcurrencyConfigRequest = {}  # type: ignore[typeddict-item]
+        input_["function_name"] = function_name
+        input_["qualifier"] = qualifier
+
+        response = await aexecute_pipeline(
+            AsyncOperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        return response.output
+
+    async def delete(
+        self,
+        function_name: "capo_lambda.types.function_name.FunctionName",
+        qualifier: "capo_lambda.types.qualifier.Qualifier",
+        *,
+        config_overrides: Optional[AsyncLambdaClientConfig] = None,
+    ) -> None:
+        r"""<p>Deletes the provisioned concurrency configuration for a function.</p>
+
+        Args:
+            function_name: <p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code>.</p> </li> <li> <p> <b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p> </li> <li> <p> <b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>
+            qualifier: <p>The version number or alias name.</p>
+
+        Raises:
+            capo_lambda.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>One of the parameters in the request is not valid.</p>
+            capo_lambda.errors.resource_conflict_exception.ResourceConflictException: <p>The resource already exists, or another operation is in progress.</p>
+            capo_lambda.errors.resource_not_found_exception.ResourceNotFoundException: <p>The resource specified in the request does not exist.</p>
+            capo_lambda.errors.service_exception.ServiceException: <p>The Lambda service encountered an internal error.</p>
+            capo_lambda.errors.too_many_requests_exception.TooManyRequestsException: <p>The request throughput limit was exceeded. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#api-requests\">Lambda quotas</a>.</p>
+            capo_lambda.errors.UnknownServiceError: The service returned an error code this client does not model.
+
+        Examples:
+            To delete a provisioned concurrency configuration
+            The following example deletes the provisioned concurrency configuration for the GREEN alias of a function named my-function.
+
+            >>> await client.delete(function_name='my-function', qualifier='GREEN')
+        """
+
+        async def _handler(
+            req: "AsyncOperationRequest[capo_lambda.types.delete_provisioned_concurrency_config_request.DeleteProvisionedConcurrencyConfigRequest]",
+        ) -> AsyncOperationResponse[None]:
+            import capo_lambda._operations.aws_gir_api_service.delete_provisioned_concurrency_config
+
+            (
+                output,
+                http_response,
+            ) = await capo_lambda._operations.aws_gir_api_service.delete_provisioned_concurrency_config.async_delete_provisioned_concurrency_config(
+                req.options, req.input
+            )
+            return AsyncOperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self._service.operation_options(config_overrides)
+        input_: capo_lambda.types.delete_provisioned_concurrency_config_request.DeleteProvisionedConcurrencyConfigRequest = {}  # type: ignore[typeddict-item]
+        input_["function_name"] = function_name
+        input_["qualifier"] = qualifier
+
+        response = await aexecute_pipeline(
+            AsyncOperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        return response.output

capo_lambda/_resources/aws_gir_api_service/resource_policy.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from capo_lambda._services._lambda import LambdaClient
+    from capo_lambda._services.async__lambda import (
+        AsyncLambdaClient,
+    )
+
+
+class ResourcePolicy:
+    def __init__(self, service: LambdaClient) -> None:
+        self._service = service
+
+
+class AsyncResourcePolicy:
+    def __init__(self, service: AsyncLambdaClient) -> None:
+        self._service = service

capo_lambda/_rule_engine/_aws_partition.py

@@ -0,0 +1,160 @@
+"""AWS partitions table and ``aws.partition`` rules-engine function.
+
+Data sourced from AWS SDK ``partitions.json``. All dispatch tables are
+materialised at codegen time:
+
+* ``_REGION_LOOKUP`` — O(1) dict of explicit region name -> partition outputs.
+* ``_REGEX_LOOKUP`` — compiled-regex / outputs pairs for unknown regions.
+* ``_DEFAULT_OUTPUTS`` — fallback partition (``aws``)."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+_PARTITION_AWS: dict[str, Any] = {
+    "dnsSuffix": "amazonaws.com",
+    "dualStackDnsSuffix": "api.aws",
+    "implicitGlobalRegion": "us-east-1",
+    "name": "aws",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_CN: dict[str, Any] = {
+    "dnsSuffix": "amazonaws.com.cn",
+    "dualStackDnsSuffix": "api.amazonwebservices.com.cn",
+    "implicitGlobalRegion": "cn-northwest-1",
+    "name": "aws-cn",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_EUSC: dict[str, Any] = {
+    "dnsSuffix": "amazonaws.eu",
+    "dualStackDnsSuffix": "api.amazonwebservices.eu",
+    "implicitGlobalRegion": "eusc-de-east-1",
+    "name": "aws-eusc",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_ISO: dict[str, Any] = {
+    "dnsSuffix": "c2s.ic.gov",
+    "dualStackDnsSuffix": "api.aws.ic.gov",
+    "implicitGlobalRegion": "us-iso-east-1",
+    "name": "aws-iso",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_ISO_B: dict[str, Any] = {
+    "dnsSuffix": "sc2s.sgov.gov",
+    "dualStackDnsSuffix": "api.aws.scloud",
+    "implicitGlobalRegion": "us-isob-east-1",
+    "name": "aws-iso-b",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_ISO_E: dict[str, Any] = {
+    "dnsSuffix": "cloud.adc-e.uk",
+    "dualStackDnsSuffix": "api.cloud-aws.adc-e.uk",
+    "implicitGlobalRegion": "eu-isoe-west-1",
+    "name": "aws-iso-e",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_ISO_F: dict[str, Any] = {
+    "dnsSuffix": "csp.hci.ic.gov",
+    "dualStackDnsSuffix": "api.aws.hci.ic.gov",
+    "implicitGlobalRegion": "us-isof-south-1",
+    "name": "aws-iso-f",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_US_GOV: dict[str, Any] = {
+    "dnsSuffix": "amazonaws.com",
+    "dualStackDnsSuffix": "api.aws",
+    "implicitGlobalRegion": "us-gov-west-1",
+    "name": "aws-us-gov",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+
+_REGION_LOOKUP: dict[str, dict[str, Any]] = {
+    "af-south-1": _PARTITION_AWS,
+    "ap-east-1": _PARTITION_AWS,
+    "ap-east-2": _PARTITION_AWS,
+    "ap-northeast-1": _PARTITION_AWS,
+    "ap-northeast-2": _PARTITION_AWS,
+    "ap-northeast-3": _PARTITION_AWS,
+    "ap-south-1": _PARTITION_AWS,
+    "ap-south-2": _PARTITION_AWS,
+    "ap-southeast-1": _PARTITION_AWS,
+    "ap-southeast-2": _PARTITION_AWS,
+    "ap-southeast-3": _PARTITION_AWS,
+    "ap-southeast-4": _PARTITION_AWS,
+    "ap-southeast-5": _PARTITION_AWS,
+    "ap-southeast-6": _PARTITION_AWS,
+    "ap-southeast-7": _PARTITION_AWS,
+    "aws-global": _PARTITION_AWS,
+    "ca-central-1": _PARTITION_AWS,
+    "ca-west-1": _PARTITION_AWS,
+    "eu-central-1": _PARTITION_AWS,
+    "eu-central-2": _PARTITION_AWS,
+    "eu-north-1": _PARTITION_AWS,
+    "eu-south-1": _PARTITION_AWS,
+    "eu-south-2": _PARTITION_AWS,
+    "eu-west-1": _PARTITION_AWS,
+    "eu-west-2": _PARTITION_AWS,
+    "eu-west-3": _PARTITION_AWS,
+    "il-central-1": _PARTITION_AWS,
+    "me-central-1": _PARTITION_AWS,
+    "me-south-1": _PARTITION_AWS,
+    "mx-central-1": _PARTITION_AWS,
+    "sa-east-1": _PARTITION_AWS,
+    "us-east-1": _PARTITION_AWS,
+    "us-east-2": _PARTITION_AWS,
+    "us-west-1": _PARTITION_AWS,
+    "us-west-2": _PARTITION_AWS,
+    "aws-cn-global": _PARTITION_AWS_CN,
+    "cn-north-1": _PARTITION_AWS_CN,
+    "cn-northwest-1": _PARTITION_AWS_CN,
+    "eusc-de-east-1": _PARTITION_AWS_EUSC,
+    "aws-iso-global": _PARTITION_AWS_ISO,
+    "us-iso-east-1": _PARTITION_AWS_ISO,
+    "us-iso-west-1": _PARTITION_AWS_ISO,
+    "aws-iso-b-global": _PARTITION_AWS_ISO_B,
+    "us-isob-east-1": _PARTITION_AWS_ISO_B,
+    "us-isob-west-1": _PARTITION_AWS_ISO_B,
+    "aws-iso-e-global": _PARTITION_AWS_ISO_E,
+    "eu-isoe-west-1": _PARTITION_AWS_ISO_E,
+    "aws-iso-f-global": _PARTITION_AWS_ISO_F,
+    "us-isof-east-1": _PARTITION_AWS_ISO_F,
+    "us-isof-south-1": _PARTITION_AWS_ISO_F,
+    "aws-us-gov-global": _PARTITION_AWS_US_GOV,
+    "us-gov-east-1": _PARTITION_AWS_US_GOV,
+    "us-gov-west-1": _PARTITION_AWS_US_GOV,
+}
+
+_REGEX_LOOKUP: tuple[tuple[re.Pattern[str], dict[str, Any]], ...] = (
+    (re.compile(r"^(us|eu|ap|sa|ca|me|af|il|mx)\-\w+\-\d+$"), _PARTITION_AWS),
+    (re.compile(r"^cn\-\w+\-\d+$"), _PARTITION_AWS_CN),
+    (re.compile(r"^eusc\-(de)\-\w+\-\d+$"), _PARTITION_AWS_EUSC),
+    (re.compile(r"^us\-iso\-\w+\-\d+$"), _PARTITION_AWS_ISO),
+    (re.compile(r"^us\-isob\-\w+\-\d+$"), _PARTITION_AWS_ISO_B),
+    (re.compile(r"^eu\-isoe\-\w+\-\d+$"), _PARTITION_AWS_ISO_E),
+    (re.compile(r"^us\-isof\-\w+\-\d+$"), _PARTITION_AWS_ISO_F),
+    (re.compile(r"^us\-gov\-\w+\-\d+$"), _PARTITION_AWS_US_GOV),
+)
+
+_DEFAULT_OUTPUTS: dict[str, Any] = _PARTITION_AWS
+
+
+def aws_partition(region: Any) -> dict[str, Any] | None:
+    """Resolve ``region`` to a partition outputs dict."""
+    if not isinstance(region, str):
+        return None
+    outputs = _REGION_LOOKUP.get(region)
+    if outputs is not None:
+        return outputs
+    for pattern, outputs in _REGEX_LOOKUP:
+        if pattern.fullmatch(region):
+            return outputs
+    return _DEFAULT_OUTPUTS