capo-lambda-core 0.1.0__py3-none-any.whl

capo_lambda_core/_services/lambda_core.py

@@ -0,0 +1,463 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdacore#LambdaCoreApiService``."""
+
+import uuid
+import warnings
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, Any, Iterable, Optional
+
+from typing_extensions import Self, TypedDict
+from zapros import BaseHandler, Client
+
+import capo_lambda_core._auth._signers
+import capo_lambda_core._auth._sigv4
+from capo_lambda_core._auth._identity import Credentials
+from capo_lambda_core._auth._providers import (
+    CredentialsProvider,
+    IdentityProvider,
+    StaticAwsCredentialsProvider,
+    default_aws_credentials_chain,
+)
+from capo_lambda_core._auth._zapros_handler import AuthMiddleware
+from capo_lambda_core._pagination import resolve_path as _resolve_path
+from capo_lambda_core._resources.lambda_core_api_service.network_connector import (
+    NetworkConnector,
+)
+from capo_lambda_core._services._aws_config import aws_config
+from capo_lambda_core._services._pipeline import (
+    Interceptor,
+    OperationOptions,
+    OperationRequest,
+    OperationResponse,
+    execute_pipeline,
+    retry,
+)
+
+if TYPE_CHECKING:
+    import capo_lambda_core.types.client_token_string
+    import capo_lambda_core.types.create_network_connector_request
+    import capo_lambda_core.types.create_network_connector_response
+    import capo_lambda_core.types.delete_network_connector_request
+    import capo_lambda_core.types.delete_network_connector_response
+    import capo_lambda_core.types.get_network_connector_request
+    import capo_lambda_core.types.get_network_connector_response
+    import capo_lambda_core.types.list_network_connectors_request
+    import capo_lambda_core.types.list_network_connectors_response
+    import capo_lambda_core.types.max_hundred_list_items
+    import capo_lambda_core.types.network_connector_configuration
+    import capo_lambda_core.types.network_connector_identifier
+    import capo_lambda_core.types.network_connector_name
+    import capo_lambda_core.types.network_connector_role_arn
+    import capo_lambda_core.types.network_connector_state
+    import capo_lambda_core.types.network_connector_summary
+    import capo_lambda_core.types.network_connector_tags
+    import capo_lambda_core.types.string
+    import capo_lambda_core.types.update_network_connector_request
+    import capo_lambda_core.types.update_network_connector_response
+
+
+class LambdaCoreClientConfig(TypedDict, total=False, closed=True):
+    operation_interceptors: Iterable[Interceptor[Any, Any]]
+    retry_max_attempts: int | None
+    region: str | None
+    use_dual_stack: bool | None
+    use_fips: bool | None
+    endpoint: str | None
+    credentials_provider: IdentityProvider[Credentials] | None
+
+
+class LambdaCoreClient:
+    """A client for the ``LambdaCore`` service.
+
+    Args:
+        http_handler: HTTP handler for sending requests. If not provided, creates a default handler.
+        operation_interceptors: Interceptors that wrap every operation call. If not provided, defaults to an empty list.
+        retry_max_attempts: Maximum number of times to retry a failed operation. Defaults to 3.
+        region: The value of the ``AWS::Region`` endpoint parameter.
+        use_dual_stack: The value of the ``AWS::UseDualStack`` endpoint parameter.
+        use_fips: The value of the ``AWS::UseFIPS`` endpoint parameter.
+        endpoint: The value of the ``SDK::Endpoint`` endpoint parameter.
+        credentials: AWS credentials for request signing.
+        credentials_provider: Provider that resolves AWS credentials. Takes precedence over ``credentials``.
+    """
+
+    def __init__(
+        self,
+        http_handler: BaseHandler | None = None,
+        operation_interceptors: Iterable[Interceptor[Any, Any]] | None = None,
+        retry_max_attempts: int | None = None,
+        region: str | None = None,
+        use_dual_stack: bool | None = None,
+        use_fips: bool | None = None,
+        endpoint: str | None = None,
+        credentials: Credentials | None = None,
+        credentials_provider: CredentialsProvider | None = None,
+    ):
+        self._client = Client(http_handler).wrap_with_middleware(
+            lambda next: AuthMiddleware(next)
+        )
+        if credentials is not None and credentials_provider is not None:
+            warnings.warn(
+                "Both credentials and credentials_provider given; provider takes precedence"
+            )
+        resolved_credentials_provider: IdentityProvider[Credentials] | None = (
+            credentials_provider
+        )
+        if resolved_credentials_provider is None and credentials is not None:
+            resolved_credentials_provider = StaticAwsCredentialsProvider(credentials)
+        if resolved_credentials_provider is None and credentials is None:
+            resolved_credentials_provider = default_aws_credentials_chain(
+                Client(http_handler)
+            )
+        self._config = LambdaCoreClientConfig(
+            {
+                "operation_interceptors": operation_interceptors or [],
+                "retry_max_attempts": retry_max_attempts,
+                "region": region,
+                "use_dual_stack": use_dual_stack,
+                "use_fips": use_fips,
+                "endpoint": endpoint,
+                "credentials_provider": resolved_credentials_provider,
+            }
+        )
+
+        # resources
+        self.network_connector = NetworkConnector(self)
+
+    def operation_options(
+        self, config_overrides: Optional[LambdaCoreClientConfig] = None
+    ) -> tuple[Iterable[Interceptor[Any, Any]], OperationOptions]:
+        overrides: LambdaCoreClientConfig = config_overrides or {}
+        interceptors_: list[Interceptor[Any, Any]] = [
+            *overrides.get(
+                "operation_interceptors", self._config.get("operation_interceptors", [])
+            ),
+            aws_config(),
+            retry(),
+        ]
+        options_: OperationOptions = OperationOptions(
+            client=self._client,
+            retry_max_attempts=overrides.get(
+                "retry_max_attempts", self._config.get("retry_max_attempts")
+            ),
+            region=overrides.get("region", self._config.get("region")),
+            use_dual_stack=overrides.get(
+                "use_dual_stack", self._config.get("use_dual_stack")
+            ),
+            use_fips=overrides.get("use_fips", self._config.get("use_fips")),
+            endpoint=overrides.get("endpoint", self._config.get("endpoint")),
+            credentials_provider=overrides.get(
+                "credentials_provider", self._config.get("credentials_provider")
+            ),
+        )
+        return interceptors_, options_
+
+    def create_network_connector(
+        self,
+        name: "capo_lambda_core.types.network_connector_name.NetworkConnectorName",
+        configuration: "capo_lambda_core.types.network_connector_configuration.NetworkConnectorConfiguration",
+        *,
+        config_overrides: Optional[LambdaCoreClientConfig] = None,
+        operator_role: Optional[
+            "capo_lambda_core.types.network_connector_role_arn.NetworkConnectorRoleArn"
+        ] = None,
+        client_token: Optional[
+            "capo_lambda_core.types.client_token_string.ClientTokenString"
+        ] = None,
+        tags: Optional[
+            "capo_lambda_core.types.network_connector_tags.NetworkConnectorTags"
+        ] = None,
+    ) -> "capo_lambda_core.types.create_network_connector_response.CreateNetworkConnectorResponse":
+        """<p>Creates a network connector that enables Lambda compute resources to route outbound traffic through your Amazon VPC. The network connector provisions elastic network interfaces (ENIs) in the subnets you specify, providing a managed network path to private resources such as databases, caches, and internal APIs.</p> <p>This operation is asynchronous. The network connector starts in <code>PENDING</code> state while ENIs are provisioned in your VPC (provisioning typically takes up to 10 minutes). Use <code>GetNetworkConnector</code> to poll the connector state until it reaches <code>ACTIVE</code>. Once active, you can attach the connector to Lambda MicroVMs at run time using the <code>egressNetworkConnectors</code> parameter on <code>RunMicroVm</code>.</p> <p>This operation is idempotent when you provide a <code>ClientToken</code> — if you retry a request that completed successfully using the same client token, the operation returns the existing connector without creating a duplicate.</p>
+
+        Args:
+            name: <p>A unique name for the network connector within your account and Region. You can use the name to identify the connector in subsequent API calls.</p>
+            configuration: <p>The network configuration for the connector. Specify a <code>VpcEgressConfiguration</code> to enable outbound traffic routing through your VPC.</p>
+            operator_role: <p>The ARN of the IAM role that Lambda assumes to manage elastic network interfaces in your VPC. This role must have permissions for <code>ec2:CreateNetworkInterface</code>, <code>ec2:DeleteNetworkInterface</code>, and related describe operations.</p>
+            client_token: <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request with the same client token, the API returns the existing connector without creating a duplicate.</p>
+            tags: <p>A map of key-value pairs to associate with the network connector for organization, cost allocation, or access control.</p>
+
+        Raises:
+            capo_lambda_core.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>One of the parameters in the request is not valid. Check the error message for details about which parameter failed validation.</p>
+            capo_lambda_core.errors.network_connector_limit_exceeded_exception.NetworkConnectorLimitExceededException: <p>The account has reached the maximum number of network connectors allowed. Delete unused connectors or request a limit increase through Service Quotas.</p>
+            capo_lambda_core.errors.resource_conflict_exception.ResourceConflictException: <p>The request could not be completed due to a conflict with the current state of the resource. For example, attempting to update a connector that is not in <code>ACTIVE</code> state.</p>
+            capo_lambda_core.errors.service_exception.ServiceException: <p>An internal service error occurred. Retry the request with exponential backoff.</p>
+            capo_lambda_core.errors.too_many_requests_exception.TooManyRequestsException: <p>The request was throttled due to exceeding the allowed request rate. Retry the request after a brief wait using exponential backoff.</p>
+            capo_lambda_core.errors.UnknownServiceError: The service returned an error code this client does not model.
+        """
+
+        def _handler(
+            req: "OperationRequest[capo_lambda_core.types.create_network_connector_request.CreateNetworkConnectorRequest]",
+        ) -> OperationResponse[
+            "capo_lambda_core.types.create_network_connector_response.CreateNetworkConnectorResponse"
+        ]:
+            import capo_lambda_core._operations.lambda_core_api_service.create_network_connector
+
+            output, http_response = (
+                capo_lambda_core._operations.lambda_core_api_service.create_network_connector.create_network_connector(
+                    req.options, req.input
+                )
+            )
+            return OperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self.operation_options(config_overrides)
+        input_: capo_lambda_core.types.create_network_connector_request.CreateNetworkConnectorRequest = {
+            "name": name,
+            "configuration": configuration,
+        }
+        if operator_role is not None:
+            input_["operator_role"] = operator_role
+        if client_token is None:
+            client_token = str(uuid.uuid4())
+        input_["client_token"] = client_token
+        if tags is not None:
+            input_["tags"] = tags
+
+        response = execute_pipeline(
+            OperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        response.response.close()
+        return response.output
+
+    def get_network_connector(
+        self,
+        identifier: "capo_lambda_core.types.network_connector_identifier.NetworkConnectorIdentifier",
+        *,
+        config_overrides: Optional[LambdaCoreClientConfig] = None,
+    ) -> "capo_lambda_core.types.get_network_connector_response.GetNetworkConnectorResponse":
+        """<p>Retrieves the current configuration, state, and metadata of a network connector. The <code>Identifier</code> parameter accepts the connector ID, name, or full ARN. Use this operation to poll connector state after creation or update, or to inspect the current VPC configuration and any failure reasons.</p> <p>The response includes the full connector configuration, current state, and — if the connector has been updated — the <code>LastUpdateStatus</code> and <code>LastUpdateStatusReasonCode</code> fields that indicate whether the most recent update succeeded or failed.</p>
+
+        Raises:
+            capo_lambda_core.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>One of the parameters in the request is not valid. Check the error message for details about which parameter failed validation.</p>
+            capo_lambda_core.errors.resource_not_found_exception.ResourceNotFoundException: <p>The specified network connector does not exist. Verify the identifier (ID, name, or ARN) and Region.</p>
+            capo_lambda_core.errors.service_exception.ServiceException: <p>An internal service error occurred. Retry the request with exponential backoff.</p>
+            capo_lambda_core.errors.too_many_requests_exception.TooManyRequestsException: <p>The request was throttled due to exceeding the allowed request rate. Retry the request after a brief wait using exponential backoff.</p>
+            capo_lambda_core.errors.UnknownServiceError: The service returned an error code this client does not model.
+        """
+
+        def _handler(
+            req: "OperationRequest[capo_lambda_core.types.get_network_connector_request.GetNetworkConnectorRequest]",
+        ) -> OperationResponse[
+            "capo_lambda_core.types.get_network_connector_response.GetNetworkConnectorResponse"
+        ]:
+            import capo_lambda_core._operations.lambda_core_api_service.get_network_connector
+
+            output, http_response = (
+                capo_lambda_core._operations.lambda_core_api_service.get_network_connector.get_network_connector(
+                    req.options, req.input
+                )
+            )
+            return OperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self.operation_options(config_overrides)
+        input_: capo_lambda_core.types.get_network_connector_request.GetNetworkConnectorRequest = {
+            "identifier": identifier
+        }
+
+        response = execute_pipeline(
+            OperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        response.response.close()
+        return response.output
+
+    def update_network_connector(
+        self,
+        identifier: "capo_lambda_core.types.network_connector_identifier.NetworkConnectorIdentifier",
+        *,
+        config_overrides: Optional[LambdaCoreClientConfig] = None,
+        configuration: Optional[
+            "capo_lambda_core.types.network_connector_configuration.NetworkConnectorConfiguration"
+        ] = None,
+        operator_role: Optional[
+            "capo_lambda_core.types.network_connector_role_arn.NetworkConnectorRoleArn"
+        ] = None,
+        client_token: Optional[
+            "capo_lambda_core.types.client_token_string.ClientTokenString"
+        ] = None,
+    ) -> "capo_lambda_core.types.update_network_connector_response.UpdateNetworkConnectorResponse":
+        """<p>Updates the VPC configuration or operator role of an existing network connector. You can modify the subnet IDs, security group IDs, network protocol, or operator role. The connector must be in <code>ACTIVE</code> state to accept updates.</p> <p>This operation is asynchronous. The connector remains in <code>ACTIVE</code> state during the update — existing workloads that reference this connector are not disrupted. Use <code>GetNetworkConnector</code> to monitor the <code>LastUpdateStatus</code> field, which transitions through <code>InProgress</code> to <code>Successful</code> or <code>Failed</code>. If the update fails, the <code>LastUpdateStatusReasonCode</code> field provides a specific error code for troubleshooting. This operation is idempotent when you provide a <code>ClientToken</code>.</p>
+
+        Args:
+            configuration: <p>The updated network configuration for the connector. Provide the full <code>VpcEgressConfiguration</code> including all subnet IDs and security group IDs — this replaces the existing configuration.</p>
+            operator_role: <p>The updated ARN of the IAM role that Lambda assumes to manage ENIs. Use this to change the operator role without recreating the connector.</p>
+            client_token: <p>A unique, case-sensitive identifier to ensure idempotency of the update request.</p>
+
+        Raises:
+            capo_lambda_core.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>One of the parameters in the request is not valid. Check the error message for details about which parameter failed validation.</p>
+            capo_lambda_core.errors.resource_conflict_exception.ResourceConflictException: <p>The request could not be completed due to a conflict with the current state of the resource. For example, attempting to update a connector that is not in <code>ACTIVE</code> state.</p>
+            capo_lambda_core.errors.resource_not_found_exception.ResourceNotFoundException: <p>The specified network connector does not exist. Verify the identifier (ID, name, or ARN) and Region.</p>
+            capo_lambda_core.errors.service_exception.ServiceException: <p>An internal service error occurred. Retry the request with exponential backoff.</p>
+            capo_lambda_core.errors.too_many_requests_exception.TooManyRequestsException: <p>The request was throttled due to exceeding the allowed request rate. Retry the request after a brief wait using exponential backoff.</p>
+            capo_lambda_core.errors.UnknownServiceError: The service returned an error code this client does not model.
+        """
+
+        def _handler(
+            req: "OperationRequest[capo_lambda_core.types.update_network_connector_request.UpdateNetworkConnectorRequest]",
+        ) -> OperationResponse[
+            "capo_lambda_core.types.update_network_connector_response.UpdateNetworkConnectorResponse"
+        ]:
+            import capo_lambda_core._operations.lambda_core_api_service.update_network_connector
+
+            output, http_response = (
+                capo_lambda_core._operations.lambda_core_api_service.update_network_connector.update_network_connector(
+                    req.options, req.input
+                )
+            )
+            return OperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self.operation_options(config_overrides)
+        input_: capo_lambda_core.types.update_network_connector_request.UpdateNetworkConnectorRequest = {
+            "identifier": identifier
+        }
+        if configuration is not None:
+            input_["configuration"] = configuration
+        if operator_role is not None:
+            input_["operator_role"] = operator_role
+        if client_token is None:
+            client_token = str(uuid.uuid4())
+        input_["client_token"] = client_token
+
+        response = execute_pipeline(
+            OperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        response.response.close()
+        return response.output
+
+    def delete_network_connector(
+        self,
+        identifier: "capo_lambda_core.types.network_connector_identifier.NetworkConnectorIdentifier",
+        *,
+        config_overrides: Optional[LambdaCoreClientConfig] = None,
+    ) -> "capo_lambda_core.types.delete_network_connector_response.DeleteNetworkConnectorResponse":
+        """<p>Initiates deletion of a network connector. The connector transitions to <code>DELETING</code> state while elastic network interfaces are cleaned up asynchronously. After deletion completes, subsequent calls to <code>GetNetworkConnector</code> return <code>ResourceNotFoundException</code>.</p> <p>This operation is idempotent — calling delete on a connector that is already deleting or has been deleted succeeds without error. You can delete connectors in <code>ACTIVE</code> or <code>FAILED</code> states. Before deleting a connector, ensure that no Lambda MicroVMs are using it, as they will lose VPC egress connectivity immediately.</p>
+
+        Raises:
+            capo_lambda_core.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>One of the parameters in the request is not valid. Check the error message for details about which parameter failed validation.</p>
+            capo_lambda_core.errors.resource_conflict_exception.ResourceConflictException: <p>The request could not be completed due to a conflict with the current state of the resource. For example, attempting to update a connector that is not in <code>ACTIVE</code> state.</p>
+            capo_lambda_core.errors.resource_not_found_exception.ResourceNotFoundException: <p>The specified network connector does not exist. Verify the identifier (ID, name, or ARN) and Region.</p>
+            capo_lambda_core.errors.service_exception.ServiceException: <p>An internal service error occurred. Retry the request with exponential backoff.</p>
+            capo_lambda_core.errors.too_many_requests_exception.TooManyRequestsException: <p>The request was throttled due to exceeding the allowed request rate. Retry the request after a brief wait using exponential backoff.</p>
+            capo_lambda_core.errors.UnknownServiceError: The service returned an error code this client does not model.
+        """
+
+        def _handler(
+            req: "OperationRequest[capo_lambda_core.types.delete_network_connector_request.DeleteNetworkConnectorRequest]",
+        ) -> OperationResponse[
+            "capo_lambda_core.types.delete_network_connector_response.DeleteNetworkConnectorResponse"
+        ]:
+            import capo_lambda_core._operations.lambda_core_api_service.delete_network_connector
+
+            output, http_response = (
+                capo_lambda_core._operations.lambda_core_api_service.delete_network_connector.delete_network_connector(
+                    req.options, req.input
+                )
+            )
+            return OperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self.operation_options(config_overrides)
+        input_: capo_lambda_core.types.delete_network_connector_request.DeleteNetworkConnectorRequest = {
+            "identifier": identifier
+        }
+
+        response = execute_pipeline(
+            OperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        response.response.close()
+        return response.output
+
+    def list_network_connectors(
+        self,
+        *,
+        config_overrides: Optional[LambdaCoreClientConfig] = None,
+        state: Optional[
+            "capo_lambda_core.types.network_connector_state.NetworkConnectorState"
+        ] = None,
+        marker: Optional["capo_lambda_core.types.string.String"] = None,
+        max_items: Optional[
+            "capo_lambda_core.types.max_hundred_list_items.MaxHundredListItems"
+        ] = None,
+    ) -> "capo_lambda_core.types.list_network_connectors_response.ListNetworkConnectorsResponse":
+        """<p>Returns a paginated list of network connectors in your account for the current Region. You can optionally filter results by connector state. Use the <code>Marker</code> parameter from a previous response to retrieve the next page of results.</p> <p>Each item in the response includes the connector ARN, name, ID, type, current state, and last modified timestamp. To retrieve full configuration details for a specific connector, use <code>GetNetworkConnector</code>.</p>
+
+        Args:
+            state: <p>Optional filter to return only connectors in the specified state (for example, <code>ACTIVE</code> or <code>FAILED</code>).</p>
+            marker: <p>The pagination token from a previous <code>ListNetworkConnectors</code> response. Use this value to retrieve the next page of results.</p>
+            max_items: <p>The maximum number of connectors to return per page. Valid range: 1 to 100.</p>
+
+        Raises:
+            capo_lambda_core.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>One of the parameters in the request is not valid. Check the error message for details about which parameter failed validation.</p>
+            capo_lambda_core.errors.service_exception.ServiceException: <p>An internal service error occurred. Retry the request with exponential backoff.</p>
+            capo_lambda_core.errors.too_many_requests_exception.TooManyRequestsException: <p>The request was throttled due to exceeding the allowed request rate. Retry the request after a brief wait using exponential backoff.</p>
+            capo_lambda_core.errors.UnknownServiceError: The service returned an error code this client does not model.
+        """
+
+        def _handler(
+            req: "OperationRequest[capo_lambda_core.types.list_network_connectors_request.ListNetworkConnectorsRequest]",
+        ) -> OperationResponse[
+            "capo_lambda_core.types.list_network_connectors_response.ListNetworkConnectorsResponse"
+        ]:
+            import capo_lambda_core._operations.lambda_core_api_service.list_network_connectors
+
+            output, http_response = (
+                capo_lambda_core._operations.lambda_core_api_service.list_network_connectors.list_network_connectors(
+                    req.options, req.input
+                )
+            )
+            return OperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self.operation_options(config_overrides)
+        input_: capo_lambda_core.types.list_network_connectors_request.ListNetworkConnectorsRequest = {}
+        if state is not None:
+            input_["state"] = state
+        if marker is not None:
+            input_["marker"] = marker
+        if max_items is not None:
+            input_["max_items"] = max_items
+
+        response = execute_pipeline(
+            OperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        response.response.close()
+        return response.output
+
+    def iter_list_network_connectors(
+        self,
+        *,
+        config_overrides: Optional[LambdaCoreClientConfig] = None,
+        state: Optional[
+            "capo_lambda_core.types.network_connector_state.NetworkConnectorState"
+        ] = None,
+        marker: Optional["capo_lambda_core.types.string.String"] = None,
+        max_items: Optional[
+            "capo_lambda_core.types.max_hundred_list_items.MaxHundredListItems"
+        ] = None,
+    ) -> "Iterator[capo_lambda_core.types.network_connector_summary.NetworkConnectorSummary]":
+        _token = marker
+        while True:
+            _response = self.list_network_connectors(
+                config_overrides=config_overrides,
+                state=state,
+                marker=_token,
+                max_items=max_items,
+            )
+            _page = _resolve_path(_response, ("network_connectors",))
+            for _item in _page or []:
+                yield _item
+            _token = _resolve_path(_response, ("next_marker",))
+            if not _token:
+                break
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: Any, exc: Any, tb: Any):
+        self._client.close()

capo_lambda_core/errors/__init__.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from ._base import (
+    DeserializationError as DeserializationError,
+)
+from ._base import (
+    LambdaCoreError as LambdaCoreError,
+)
+from ._base import (
+    SerializationError as SerializationError,
+)
+from ._base import (
+    ServiceError as ServiceError,
+)
+from ._base import (
+    UnknownServiceError as UnknownServiceError,
+)
+from ._base import (
+    WaiterFailedError as WaiterFailedError,
+)
+from ._base import (
+    WaiterTimeoutError as WaiterTimeoutError,
+)
+from .invalid_parameter_value_exception import (
+    InvalidParameterValueException as InvalidParameterValueException,
+)
+from .network_connector_limit_exceeded_exception import (
+    NetworkConnectorLimitExceededException as NetworkConnectorLimitExceededException,
+)
+from .resource_conflict_exception import (
+    ResourceConflictException as ResourceConflictException,
+)
+from .resource_not_found_exception import (
+    ResourceNotFoundException as ResourceNotFoundException,
+)
+from .service_exception import ServiceException as ServiceException
+from .too_many_requests_exception import (
+    TooManyRequestsException as TooManyRequestsException,
+)

capo_lambda_core/errors/_base.py

@@ -0,0 +1,94 @@
+from typing import Literal
+
+
+class LambdaCoreError(Exception):
+    """Base class for all LambdaCore service errors."""
+
+
+class ServiceError(LambdaCoreError):
+    """Base class for all modeled service errors.
+
+    Args:
+        fault: ``"client"`` or ``"server"``.
+        is_throttling_error: Whether this error is a throttling error.
+        is_retryable: Whether this error is retryable.
+        code: The wire error code, or ``None``.
+        message: The error message, or ``None``.
+    """
+
+    code: str | None = None
+
+    def __init__(
+        self,
+        fault: Literal["client", "server"],
+        *,
+        is_throttling_error: bool,
+        is_retryable: bool,
+        code: str | None = None,
+        message: str | None = None,
+    ) -> None:
+        super().__init__(f"{code or '<no code>'}: {message or '<no message>'}")
+        self.fault = fault
+        self.is_throttling_error = is_throttling_error
+        self.is_retryable = is_retryable
+        self.code = code
+        self.message = message
+
+
+class SerializationError(LambdaCoreError):
+    """Raised when a value cannot be serialized."""
+
+
+class DeserializationError(LambdaCoreError):
+    """Raised when a value cannot be deserialized or a required member is missing."""
+
+
+class UnknownServiceError(ServiceError):
+    """Raised when the server returns an error code the client does not model.
+
+    Args:
+        code: ``<Code>`` text from the response body, or ``None`` if absent.
+        message: ``<Message>`` text from the response body, or ``None``.
+        response: The original HTTP response object, for arbitrary inspection.
+    """
+
+    def __init__(
+        self, *, code: str | None, message: str | None, response: object
+    ) -> None:
+        _status = getattr(response, "status", 500)
+        _fault: Literal["client", "server"] = "client" if _status < 500 else "server"
+        _throttling = _status == 429
+        _retryable = _throttling or _status >= 500
+        super().__init__(
+            _fault,
+            is_throttling_error=_throttling,
+            is_retryable=_retryable,
+            code=code,
+            message=message,
+        )
+        self.response = response
+
+
+class WaiterFailedError(LambdaCoreError):
+    """Raised when a waiter hits an acceptor with ``state="failure"``.
+
+    Args:
+        waiter_name: snake_case waiter name (e.g. ``bucket_exists``).
+        reason: Short description of which acceptor fired.
+    """
+
+    def __init__(self, waiter_name: str, reason: str) -> None:
+        super().__init__(f"waiter {waiter_name} failed: {reason}")
+        self.waiter_name = waiter_name
+        self.reason = reason
+
+
+class WaiterTimeoutError(LambdaCoreError):
+    """Raised when a waiter exhausts ``max_wait_time`` without a terminal acceptor."""
+
+    def __init__(self, waiter_name: str, max_wait_time: float) -> None:
+        super().__init__(
+            f"waiter {waiter_name} timed out after {max_wait_time} seconds"
+        )
+        self.waiter_name = waiter_name
+        self.max_wait_time = max_wait_time

capo_lambda_core/errors/invalid_parameter_value_exception.py

@@ -0,0 +1,59 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdacore#InvalidParameterValueException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_core.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_lambda_core.types.string
+
+
+class InvalidParameterValueException_(TypedDict, closed=True):
+    type: NotRequired["capo_lambda_core.types.string.String"]
+    """<p>The exception type.</p>"""
+    message: NotRequired["capo_lambda_core.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvalidParameterValueException_) -> dict:
+    out: dict = {}
+    if "type" in value:
+        out["Type"] = value["type"]
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> InvalidParameterValueException_:
+    out: InvalidParameterValueException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Type") is not None:
+        out["type"] = data["Type"]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidParameterValueException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambdacore#InvalidParameterValueException``."""
+
+    code: str | None = "InvalidParameterValueException"
+
+    def __init__(
+        self, data: InvalidParameterValueException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidParameterValueException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidParameterValueException":
+        return cls(deserialize_json(data), message)