capo-cloudcontrol 0.1.0__py3-none-any.whl

capo_cloudcontrol/errors/not_stabilized_exception.py

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

capo_cloudcontrol/errors/not_updatable_exception.py

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

capo_cloudcontrol/errors/private_type_exception.py

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

capo_cloudcontrol/errors/request_token_not_found_exception.py

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

capo_cloudcontrol/errors/resource_conflict_exception.py

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

capo_cloudcontrol/errors/resource_not_found_exception.py

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

capo_cloudcontrol/errors/service_internal_error_exception.py

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

capo_cloudcontrol/errors/service_limit_exceeded_exception.py

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

capo_cloudcontrol/errors/throttling_exception.py

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

capo_cloudcontrol/errors/type_not_found_exception.py

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

capo_cloudcontrol/errors/unsupported_action_exception.py

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

capo_cloudcontrol/types/_prelude/blob.py

@@ -0,0 +1,12 @@
+"""Generated from Smithy prelude shape ``smithy.api#Blob``."""
+
+import base64
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: bytes) -> str:
+    return base64.b64encode(value).decode("ascii")
+
+
+def deserialize_aws_json_1_0(data: str) -> bytes:
+    return base64.b64decode(data)

capo_cloudcontrol/types/_prelude/timestamp.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy prelude shape ``smithy.api#Timestamp``."""
+
+import datetime
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: datetime.datetime) -> float:
+    value = (
+        value.astimezone(datetime.timezone.utc)
+        if value.tzinfo
+        else value.replace(tzinfo=datetime.timezone.utc)
+    )
+    return value.timestamp()
+
+
+def deserialize_aws_json_1_0(data: float) -> datetime.datetime:
+    return datetime.datetime.fromtimestamp(float(data), tz=datetime.timezone.utc)

capo_cloudcontrol/types/cancel_resource_request_input.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#CancelResourceRequestInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_cloudcontrol.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.request_token
+
+
+class CancelResourceRequestInput(TypedDict, closed=True):
+    request_token: "capo_cloudcontrol.types.request_token.RequestToken"
+    """<p>The <code>RequestToken</code> of the <code>ProgressEvent</code> object returned by the resource operation request.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: CancelResourceRequestInput) -> dict:
+    out: dict = {}
+    out["RequestToken"] = value["request_token"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> CancelResourceRequestInput:
+    out: CancelResourceRequestInput = {}  # type: ignore[typeddict-item]
+    if data.get("RequestToken") is not None:
+        out["request_token"] = data["RequestToken"]
+    else:
+        raise DeserializationError("CancelResourceRequestInput.request_token required")
+    return out

capo_cloudcontrol/types/cancel_resource_request_output.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudcontrol#CancelResourceRequestOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_cloudcontrol.types.progress_event
+
+
+class CancelResourceRequestOutput(TypedDict, closed=True):
+    progress_event: NotRequired["capo_cloudcontrol.types.progress_event.ProgressEvent"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: CancelResourceRequestOutput) -> dict:
+    out: dict = {}
+    if "progress_event" in value:
+        import capo_cloudcontrol.types.progress_event
+
+        out["ProgressEvent"] = (
+            capo_cloudcontrol.types.progress_event.serialize_aws_json_1_0(
+                value["progress_event"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> CancelResourceRequestOutput:
+    out: CancelResourceRequestOutput = {}  # type: ignore[typeddict-item]
+    if data.get("ProgressEvent") is not None:
+        import capo_cloudcontrol.types.progress_event
+
+        out["progress_event"] = (
+            capo_cloudcontrol.types.progress_event.deserialize_aws_json_1_0(
+                data["ProgressEvent"]
+            )
+        )
+    return out