capo-codedeploy 0.1.0__py3-none-any.whl

capo_codedeploy/errors/deployment_group_does_not_exist_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#DeploymentGroupDoesNotExistException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class DeploymentGroupDoesNotExistException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeploymentGroupDoesNotExistException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeploymentGroupDoesNotExistException_:
+    out: DeploymentGroupDoesNotExistException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class DeploymentGroupDoesNotExistException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#DeploymentGroupDoesNotExistException``."""
+
+    code: str | None = "DeploymentGroupDoesNotExistException"
+
+    def __init__(
+        self, data: DeploymentGroupDoesNotExistException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DeploymentGroupDoesNotExistException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "DeploymentGroupDoesNotExistException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/deployment_group_limit_exceeded_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#DeploymentGroupLimitExceededException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class DeploymentGroupLimitExceededException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeploymentGroupLimitExceededException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeploymentGroupLimitExceededException_:
+    out: DeploymentGroupLimitExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class DeploymentGroupLimitExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#DeploymentGroupLimitExceededException``."""
+
+    code: str | None = "DeploymentGroupLimitExceededException"
+
+    def __init__(
+        self, data: DeploymentGroupLimitExceededException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DeploymentGroupLimitExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "DeploymentGroupLimitExceededException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/deployment_group_name_required_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#DeploymentGroupNameRequiredException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class DeploymentGroupNameRequiredException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeploymentGroupNameRequiredException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeploymentGroupNameRequiredException_:
+    out: DeploymentGroupNameRequiredException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class DeploymentGroupNameRequiredException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#DeploymentGroupNameRequiredException``."""
+
+    code: str | None = "DeploymentGroupNameRequiredException"
+
+    def __init__(
+        self, data: DeploymentGroupNameRequiredException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DeploymentGroupNameRequiredException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "DeploymentGroupNameRequiredException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/deployment_id_required_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#DeploymentIdRequiredException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class DeploymentIdRequiredException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeploymentIdRequiredException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeploymentIdRequiredException_:
+    out: DeploymentIdRequiredException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class DeploymentIdRequiredException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#DeploymentIdRequiredException``."""
+
+    code: str | None = "DeploymentIdRequiredException"
+
+    def __init__(
+        self, data: DeploymentIdRequiredException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DeploymentIdRequiredException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "DeploymentIdRequiredException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/deployment_is_not_in_ready_state_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#DeploymentIsNotInReadyStateException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class DeploymentIsNotInReadyStateException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeploymentIsNotInReadyStateException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeploymentIsNotInReadyStateException_:
+    out: DeploymentIsNotInReadyStateException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class DeploymentIsNotInReadyStateException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#DeploymentIsNotInReadyStateException``."""
+
+    code: str | None = "DeploymentIsNotInReadyStateException"
+
+    def __init__(
+        self, data: DeploymentIsNotInReadyStateException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DeploymentIsNotInReadyStateException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "DeploymentIsNotInReadyStateException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/deployment_limit_exceeded_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#DeploymentLimitExceededException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class DeploymentLimitExceededException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeploymentLimitExceededException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeploymentLimitExceededException_:
+    out: DeploymentLimitExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class DeploymentLimitExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#DeploymentLimitExceededException``."""
+
+    code: str | None = "DeploymentLimitExceededException"
+
+    def __init__(
+        self, data: DeploymentLimitExceededException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DeploymentLimitExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "DeploymentLimitExceededException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/deployment_not_started_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#DeploymentNotStartedException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class DeploymentNotStartedException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeploymentNotStartedException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeploymentNotStartedException_:
+    out: DeploymentNotStartedException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class DeploymentNotStartedException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#DeploymentNotStartedException``."""
+
+    code: str | None = "DeploymentNotStartedException"
+
+    def __init__(
+        self, data: DeploymentNotStartedException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DeploymentNotStartedException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "DeploymentNotStartedException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/deployment_target_does_not_exist_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#DeploymentTargetDoesNotExistException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class DeploymentTargetDoesNotExistException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeploymentTargetDoesNotExistException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeploymentTargetDoesNotExistException_:
+    out: DeploymentTargetDoesNotExistException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class DeploymentTargetDoesNotExistException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#DeploymentTargetDoesNotExistException``."""
+
+    code: str | None = "DeploymentTargetDoesNotExistException"
+
+    def __init__(
+        self, data: DeploymentTargetDoesNotExistException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DeploymentTargetDoesNotExistException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "DeploymentTargetDoesNotExistException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/deployment_target_id_required_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#DeploymentTargetIdRequiredException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class DeploymentTargetIdRequiredException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeploymentTargetIdRequiredException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeploymentTargetIdRequiredException_:
+    out: DeploymentTargetIdRequiredException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class DeploymentTargetIdRequiredException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#DeploymentTargetIdRequiredException``."""
+
+    code: str | None = "DeploymentTargetIdRequiredException"
+
+    def __init__(
+        self, data: DeploymentTargetIdRequiredException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DeploymentTargetIdRequiredException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "DeploymentTargetIdRequiredException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/deployment_target_list_size_exceeded_exception.py

@@ -0,0 +1,56 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#DeploymentTargetListSizeExceededException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class DeploymentTargetListSizeExceededException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeploymentTargetListSizeExceededException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeploymentTargetListSizeExceededException_:
+    out: DeploymentTargetListSizeExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class DeploymentTargetListSizeExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#DeploymentTargetListSizeExceededException``."""
+
+    code: str | None = "DeploymentTargetListSizeExceededException"
+
+    def __init__(
+        self,
+        data: DeploymentTargetListSizeExceededException_,
+        message: str | None = None,
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DeploymentTargetListSizeExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "DeploymentTargetListSizeExceededException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/description_too_long_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#DescriptionTooLongException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class DescriptionTooLongException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DescriptionTooLongException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DescriptionTooLongException_:
+    out: DescriptionTooLongException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class DescriptionTooLongException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#DescriptionTooLongException``."""
+
+    code: str | None = "DescriptionTooLongException"
+
+    def __init__(self, data: DescriptionTooLongException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="DescriptionTooLongException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "DescriptionTooLongException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/ecs_service_mapping_limit_exceeded_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#ECSServiceMappingLimitExceededException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class ECSServiceMappingLimitExceededException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ECSServiceMappingLimitExceededException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ECSServiceMappingLimitExceededException_:
+    out: ECSServiceMappingLimitExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class ECSServiceMappingLimitExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#ECSServiceMappingLimitExceededException``."""
+
+    code: str | None = "ECSServiceMappingLimitExceededException"
+
+    def __init__(
+        self, data: ECSServiceMappingLimitExceededException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ECSServiceMappingLimitExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "ECSServiceMappingLimitExceededException":
+        return cls(deserialize_aws_json_1_1(data), message)