aws-sdk-lambda 0.4.0__py3-none-any.whl

aws_sdk_lambda/errors/__init__.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from ._base import (
+    DeserializationError as DeserializationError,
+)
+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 .callback_timeout_exception import (
+    CallbackTimeoutException as CallbackTimeoutException,
+)
+from .capacity_provider_limit_exceeded_exception import (
+    CapacityProviderLimitExceededException as CapacityProviderLimitExceededException,
+)
+from .code_signing_config_not_found_exception import (
+    CodeSigningConfigNotFoundException as CodeSigningConfigNotFoundException,
+)
+from .code_storage_exceeded_exception import (
+    CodeStorageExceededException as CodeStorageExceededException,
+)
+from .code_verification_failed_exception import (
+    CodeVerificationFailedException as CodeVerificationFailedException,
+)
+from .durable_execution_already_started_exception import (
+    DurableExecutionAlreadyStartedException as DurableExecutionAlreadyStartedException,
+)
+from .ec2_access_denied_exception import (
+    EC2AccessDeniedException as EC2AccessDeniedException,
+)
+from .ec2_throttled_exception import EC2ThrottledException as EC2ThrottledException
+from .ec2_unexpected_exception import EC2UnexpectedException as EC2UnexpectedException
+from .efs_mount_connectivity_exception import (
+    EFSMountConnectivityException as EFSMountConnectivityException,
+)
+from .efs_mount_failure_exception import (
+    EFSMountFailureException as EFSMountFailureException,
+)
+from .efs_mount_timeout_exception import (
+    EFSMountTimeoutException as EFSMountTimeoutException,
+)
+from .efsio_exception import EFSIOException as EFSIOException
+from .eni_limit_reached_exception import (
+    ENILimitReachedException as ENILimitReachedException,
+)
+from .function_versions_per_capacity_provider_limit_exceeded_exception import (
+    FunctionVersionsPerCapacityProviderLimitExceededException as FunctionVersionsPerCapacityProviderLimitExceededException,
+)
+from .invalid_code_signature_exception import (
+    InvalidCodeSignatureException as InvalidCodeSignatureException,
+)
+from .invalid_parameter_value_exception import (
+    InvalidParameterValueException as InvalidParameterValueException,
+)
+from .invalid_request_content_exception import (
+    InvalidRequestContentException as InvalidRequestContentException,
+)
+from .invalid_runtime_exception import (
+    InvalidRuntimeException as InvalidRuntimeException,
+)
+from .invalid_security_group_id_exception import (
+    InvalidSecurityGroupIDException as InvalidSecurityGroupIDException,
+)
+from .invalid_subnet_id_exception import (
+    InvalidSubnetIDException as InvalidSubnetIDException,
+)
+from .invalid_zip_file_exception import (
+    InvalidZipFileException as InvalidZipFileException,
+)
+from .kms_access_denied_exception import (
+    KMSAccessDeniedException as KMSAccessDeniedException,
+)
+from .kms_disabled_exception import KMSDisabledException as KMSDisabledException
+from .kms_invalid_state_exception import (
+    KMSInvalidStateException as KMSInvalidStateException,
+)
+from .kms_not_found_exception import KMSNotFoundException as KMSNotFoundException
+from .no_published_version_exception import (
+    NoPublishedVersionException as NoPublishedVersionException,
+)
+from .policy_length_exceeded_exception import (
+    PolicyLengthExceededException as PolicyLengthExceededException,
+)
+from .precondition_failed_exception import (
+    PreconditionFailedException as PreconditionFailedException,
+)
+from .provisioned_concurrency_config_not_found_exception import (
+    ProvisionedConcurrencyConfigNotFoundException as ProvisionedConcurrencyConfigNotFoundException,
+)
+from .recursive_invocation_exception import (
+    RecursiveInvocationException as RecursiveInvocationException,
+)
+from .request_too_large_exception import (
+    RequestTooLargeException as RequestTooLargeException,
+)
+from .resource_conflict_exception import (
+    ResourceConflictException as ResourceConflictException,
+)
+from .resource_in_use_exception import ResourceInUseException as ResourceInUseException
+from .resource_not_found_exception import (
+    ResourceNotFoundException as ResourceNotFoundException,
+)
+from .resource_not_ready_exception import (
+    ResourceNotReadyException as ResourceNotReadyException,
+)
+from .s3_files_mount_connectivity_exception import (
+    S3FilesMountConnectivityException as S3FilesMountConnectivityException,
+)
+from .s3_files_mount_failure_exception import (
+    S3FilesMountFailureException as S3FilesMountFailureException,
+)
+from .s3_files_mount_timeout_exception import (
+    S3FilesMountTimeoutException as S3FilesMountTimeoutException,
+)
+from .serialized_request_entity_too_large_exception import (
+    SerializedRequestEntityTooLargeException as SerializedRequestEntityTooLargeException,
+)
+from .service_exception import ServiceException as ServiceException
+from .snap_start_exception import SnapStartException as SnapStartException
+from .snap_start_not_ready_exception import (
+    SnapStartNotReadyException as SnapStartNotReadyException,
+)
+from .snap_start_timeout_exception import (
+    SnapStartTimeoutException as SnapStartTimeoutException,
+)
+from .subnet_ip_address_limit_reached_exception import (
+    SubnetIPAddressLimitReachedException as SubnetIPAddressLimitReachedException,
+)
+from .too_many_requests_exception import (
+    TooManyRequestsException as TooManyRequestsException,
+)
+from .unsupported_media_type_exception import (
+    UnsupportedMediaTypeException as UnsupportedMediaTypeException,
+)

aws_sdk_lambda/errors/_base.py

@@ -0,0 +1,94 @@
+from typing import Literal
+
+
+class LambdaError(Exception):
+    """Base class for all Lambda service errors."""
+
+
+class ServiceError(LambdaError):
+    """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(LambdaError):
+    """Raised when a value cannot be serialized."""
+
+
+class DeserializationError(LambdaError):
+    """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(LambdaError):
+    """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(LambdaError):
+    """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

aws_sdk_lambda/errors/callback_timeout_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CallbackTimeoutException``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import ServiceError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class CallbackTimeoutException_(TypedDict):
+    type: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>The exception type.</p>"""
+    message: NotRequired["aws_sdk_lambda.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CallbackTimeoutException_) -> 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) -> CallbackTimeoutException_:
+    out: CallbackTimeoutException_ = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        out["type"] = data["Type"]
+    if "Message" in data:
+        out["message"] = data["Message"]
+    return out
+
+
+class CallbackTimeoutException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambda#CallbackTimeoutException``."""
+
+    code: str | None = "CallbackTimeoutException"
+
+    def __init__(self, data: CallbackTimeoutException_):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="CallbackTimeoutException",
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict) -> "CallbackTimeoutException":
+        return cls(deserialize_json(data))

aws_sdk_lambda/errors/capacity_provider_limit_exceeded_exception.py

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

aws_sdk_lambda/errors/code_signing_config_not_found_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CodeSigningConfigNotFoundException``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import ServiceError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class CodeSigningConfigNotFoundException_(TypedDict):
+    type: NotRequired["aws_sdk_lambda.types.string.String"]
+    message: NotRequired["aws_sdk_lambda.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CodeSigningConfigNotFoundException_) -> 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) -> CodeSigningConfigNotFoundException_:
+    out: CodeSigningConfigNotFoundException_ = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        out["type"] = data["Type"]
+    if "Message" in data:
+        out["message"] = data["Message"]
+    return out
+
+
+class CodeSigningConfigNotFoundException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambda#CodeSigningConfigNotFoundException``."""
+
+    code: str | None = "CodeSigningConfigNotFoundException"
+
+    def __init__(self, data: CodeSigningConfigNotFoundException_):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="CodeSigningConfigNotFoundException",
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict) -> "CodeSigningConfigNotFoundException":
+        return cls(deserialize_json(data))

aws_sdk_lambda/errors/code_storage_exceeded_exception.py

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

aws_sdk_lambda/errors/code_verification_failed_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CodeVerificationFailedException``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import ServiceError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class CodeVerificationFailedException_(TypedDict):
+    type: NotRequired["aws_sdk_lambda.types.string.String"]
+    message: NotRequired["aws_sdk_lambda.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CodeVerificationFailedException_) -> 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) -> CodeVerificationFailedException_:
+    out: CodeVerificationFailedException_ = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        out["type"] = data["Type"]
+    if "Message" in data:
+        out["message"] = data["Message"]
+    return out
+
+
+class CodeVerificationFailedException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambda#CodeVerificationFailedException``."""
+
+    code: str | None = "CodeVerificationFailedException"
+
+    def __init__(self, data: CodeVerificationFailedException_):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="CodeVerificationFailedException",
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict) -> "CodeVerificationFailedException":
+        return cls(deserialize_json(data))

aws_sdk_lambda/errors/durable_execution_already_started_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#DurableExecutionAlreadyStartedException``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import ServiceError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class DurableExecutionAlreadyStartedException_(TypedDict):
+    type: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>The exception type.</p>"""
+    message: NotRequired["aws_sdk_lambda.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DurableExecutionAlreadyStartedException_) -> 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) -> DurableExecutionAlreadyStartedException_:
+    out: DurableExecutionAlreadyStartedException_ = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        out["type"] = data["Type"]
+    if "Message" in data:
+        out["message"] = data["Message"]
+    return out
+
+
+class DurableExecutionAlreadyStartedException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambda#DurableExecutionAlreadyStartedException``."""
+
+    code: str | None = "DurableExecutionAlreadyStartedException"
+
+    def __init__(self, data: DurableExecutionAlreadyStartedException_):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DurableExecutionAlreadyStartedException",
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict) -> "DurableExecutionAlreadyStartedException":
+        return cls(deserialize_json(data))

aws_sdk_lambda/errors/ec2_access_denied_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#EC2AccessDeniedException``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import ServiceError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class EC2AccessDeniedException_(TypedDict):
+    type: NotRequired["aws_sdk_lambda.types.string.String"]
+    message: NotRequired["aws_sdk_lambda.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EC2AccessDeniedException_) -> 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) -> EC2AccessDeniedException_:
+    out: EC2AccessDeniedException_ = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        out["type"] = data["Type"]
+    if "Message" in data:
+        out["message"] = data["Message"]
+    return out
+
+
+class EC2AccessDeniedException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambda#EC2AccessDeniedException``."""
+
+    code: str | None = "EC2AccessDeniedException"
+
+    def __init__(self, data: EC2AccessDeniedException_):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="EC2AccessDeniedException",
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict) -> "EC2AccessDeniedException":
+        return cls(deserialize_json(data))

aws_sdk_lambda/errors/ec2_throttled_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#EC2ThrottledException``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import ServiceError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class EC2ThrottledException_(TypedDict):
+    type: NotRequired["aws_sdk_lambda.types.string.String"]
+    message: NotRequired["aws_sdk_lambda.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EC2ThrottledException_) -> 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) -> EC2ThrottledException_:
+    out: EC2ThrottledException_ = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        out["type"] = data["Type"]
+    if "Message" in data:
+        out["message"] = data["Message"]
+    return out
+
+
+class EC2ThrottledException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambda#EC2ThrottledException``."""
+
+    code: str | None = "EC2ThrottledException"
+
+    def __init__(self, data: EC2ThrottledException_):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="EC2ThrottledException",
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict) -> "EC2ThrottledException":
+        return cls(deserialize_json(data))