capo-cloudcontrol 0.1.0__py3-none-any.whl

capo_cloudcontrol/errors/__init__.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from ._base import (
+    CloudControlError as CloudControlError,
+)
+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 .already_exists_exception import AlreadyExistsException as AlreadyExistsException
+from .client_token_conflict_exception import (
+    ClientTokenConflictException as ClientTokenConflictException,
+)
+from .concurrent_modification_exception import (
+    ConcurrentModificationException as ConcurrentModificationException,
+)
+from .concurrent_operation_exception import (
+    ConcurrentOperationException as ConcurrentOperationException,
+)
+from .general_service_exception import (
+    GeneralServiceException as GeneralServiceException,
+)
+from .handler_failure_exception import (
+    HandlerFailureException as HandlerFailureException,
+)
+from .handler_internal_failure_exception import (
+    HandlerInternalFailureException as HandlerInternalFailureException,
+)
+from .invalid_credentials_exception import (
+    InvalidCredentialsException as InvalidCredentialsException,
+)
+from .invalid_request_exception import (
+    InvalidRequestException as InvalidRequestException,
+)
+from .network_failure_exception import (
+    NetworkFailureException as NetworkFailureException,
+)
+from .not_stabilized_exception import NotStabilizedException as NotStabilizedException
+from .not_updatable_exception import NotUpdatableException as NotUpdatableException
+from .private_type_exception import PrivateTypeException as PrivateTypeException
+from .request_token_not_found_exception import (
+    RequestTokenNotFoundException as RequestTokenNotFoundException,
+)
+from .resource_conflict_exception import (
+    ResourceConflictException as ResourceConflictException,
+)
+from .resource_not_found_exception import (
+    ResourceNotFoundException as ResourceNotFoundException,
+)
+from .service_internal_error_exception import (
+    ServiceInternalErrorException as ServiceInternalErrorException,
+)
+from .service_limit_exceeded_exception import (
+    ServiceLimitExceededException as ServiceLimitExceededException,
+)
+from .throttling_exception import ThrottlingException as ThrottlingException
+from .type_not_found_exception import TypeNotFoundException as TypeNotFoundException
+from .unsupported_action_exception import (
+    UnsupportedActionException as UnsupportedActionException,
+)

capo_cloudcontrol/errors/_base.py

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

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#AlreadyExistsException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudcontrol.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.error_message
+
+
+class AlreadyExistsException_(TypedDict, closed=True):
+    message: NotRequired["capo_cloudcontrol.types.error_message.ErrorMessage"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: AlreadyExistsException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> AlreadyExistsException_:
+    out: AlreadyExistsException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class AlreadyExistsException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.cloudcontrol#AlreadyExistsException``."""
+
+    code: str | None = "AlreadyExistsException"
+
+    def __init__(self, data: AlreadyExistsException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="AlreadyExistsException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "AlreadyExistsException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_cloudcontrol/errors/client_token_conflict_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#ClientTokenConflictException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudcontrol.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.error_message
+
+
+class ClientTokenConflictException_(TypedDict, closed=True):
+    message: NotRequired["capo_cloudcontrol.types.error_message.ErrorMessage"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ClientTokenConflictException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ClientTokenConflictException_:
+    out: ClientTokenConflictException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class ClientTokenConflictException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.cloudcontrol#ClientTokenConflictException``."""
+
+    code: str | None = "ClientTokenConflictException"
+
+    def __init__(self, data: ClientTokenConflictException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ClientTokenConflictException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "ClientTokenConflictException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_cloudcontrol/errors/concurrent_modification_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#ConcurrentModificationException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudcontrol.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.error_message
+
+
+class ConcurrentModificationException_(TypedDict, closed=True):
+    message: NotRequired["capo_cloudcontrol.types.error_message.ErrorMessage"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ConcurrentModificationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ConcurrentModificationException_:
+    out: ConcurrentModificationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class ConcurrentModificationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.cloudcontrol#ConcurrentModificationException``."""
+
+    code: str | None = "ConcurrentModificationException"
+
+    def __init__(
+        self, data: ConcurrentModificationException_, message: str | None = None
+    ):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ConcurrentModificationException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "ConcurrentModificationException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_cloudcontrol/errors/concurrent_operation_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#ConcurrentOperationException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudcontrol.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.error_message
+
+
+class ConcurrentOperationException_(TypedDict, closed=True):
+    message: NotRequired["capo_cloudcontrol.types.error_message.ErrorMessage"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ConcurrentOperationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ConcurrentOperationException_:
+    out: ConcurrentOperationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class ConcurrentOperationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.cloudcontrol#ConcurrentOperationException``."""
+
+    code: str | None = "ConcurrentOperationException"
+
+    def __init__(self, data: ConcurrentOperationException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ConcurrentOperationException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "ConcurrentOperationException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_cloudcontrol/errors/general_service_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#GeneralServiceException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudcontrol.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.error_message
+
+
+class GeneralServiceException_(TypedDict, closed=True):
+    message: NotRequired["capo_cloudcontrol.types.error_message.ErrorMessage"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: GeneralServiceException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> GeneralServiceException_:
+    out: GeneralServiceException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class GeneralServiceException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.cloudcontrol#GeneralServiceException``."""
+
+    code: str | None = "GeneralServiceException"
+
+    def __init__(self, data: GeneralServiceException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="GeneralServiceException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "GeneralServiceException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_cloudcontrol/errors/handler_failure_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#HandlerFailureException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudcontrol.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.error_message
+
+
+class HandlerFailureException_(TypedDict, closed=True):
+    message: NotRequired["capo_cloudcontrol.types.error_message.ErrorMessage"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: HandlerFailureException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> HandlerFailureException_:
+    out: HandlerFailureException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class HandlerFailureException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.cloudcontrol#HandlerFailureException``."""
+
+    code: str | None = "HandlerFailureException"
+
+    def __init__(self, data: HandlerFailureException_, message: str | None = None):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="HandlerFailureException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "HandlerFailureException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_cloudcontrol/errors/handler_internal_failure_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#HandlerInternalFailureException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudcontrol.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.error_message
+
+
+class HandlerInternalFailureException_(TypedDict, closed=True):
+    message: NotRequired["capo_cloudcontrol.types.error_message.ErrorMessage"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: HandlerInternalFailureException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> HandlerInternalFailureException_:
+    out: HandlerInternalFailureException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class HandlerInternalFailureException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.cloudcontrol#HandlerInternalFailureException``."""
+
+    code: str | None = "HandlerInternalFailureException"
+
+    def __init__(
+        self, data: HandlerInternalFailureException_, message: str | None = None
+    ):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="HandlerInternalFailureException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "HandlerInternalFailureException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_cloudcontrol/errors/invalid_credentials_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#InvalidCredentialsException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudcontrol.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.error_message
+
+
+class InvalidCredentialsException_(TypedDict, closed=True):
+    message: NotRequired["capo_cloudcontrol.types.error_message.ErrorMessage"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: InvalidCredentialsException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> InvalidCredentialsException_:
+    out: InvalidCredentialsException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class InvalidCredentialsException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.cloudcontrol#InvalidCredentialsException``."""
+
+    code: str | None = "InvalidCredentialsException"
+
+    def __init__(self, data: InvalidCredentialsException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidCredentialsException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidCredentialsException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_cloudcontrol/errors/invalid_request_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#InvalidRequestException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudcontrol.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.error_message
+
+
+class InvalidRequestException_(TypedDict, closed=True):
+    message: NotRequired["capo_cloudcontrol.types.error_message.ErrorMessage"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: InvalidRequestException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> InvalidRequestException_:
+    out: InvalidRequestException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class InvalidRequestException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.cloudcontrol#InvalidRequestException``."""
+
+    code: str | None = "InvalidRequestException"
+
+    def __init__(self, data: InvalidRequestException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidRequestException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidRequestException":
+        return cls(deserialize_aws_json_1_0(data), message)

capo_cloudcontrol/errors/network_failure_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#NetworkFailureException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudcontrol.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.error_message
+
+
+class NetworkFailureException_(TypedDict, closed=True):
+    message: NotRequired["capo_cloudcontrol.types.error_message.ErrorMessage"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: NetworkFailureException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> NetworkFailureException_:
+    out: NetworkFailureException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class NetworkFailureException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.cloudcontrol#NetworkFailureException``."""
+
+    code: str | None = "NetworkFailureException"
+
+    def __init__(self, data: NetworkFailureException_, message: str | None = None):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="NetworkFailureException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_0(
+        cls, data: dict, message: str | None = None
+    ) -> "NetworkFailureException":
+        return cls(deserialize_aws_json_1_0(data), message)