capo-codedeploy 0.1.0__py3-none-any.whl

capo_codedeploy/errors/resource_validation_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#ResourceValidationException``."""
+
+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 ResourceValidationException_(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: ResourceValidationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ResourceValidationException_:
+    out: ResourceValidationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class ResourceValidationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#ResourceValidationException``."""
+
+    code: str | None = "ResourceValidationException"
+
+    def __init__(self, data: ResourceValidationException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ResourceValidationException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "ResourceValidationException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/revision_does_not_exist_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#RevisionDoesNotExistException``."""
+
+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 RevisionDoesNotExistException_(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: RevisionDoesNotExistException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> RevisionDoesNotExistException_:
+    out: RevisionDoesNotExistException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class RevisionDoesNotExistException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#RevisionDoesNotExistException``."""
+
+    code: str | None = "RevisionDoesNotExistException"
+
+    def __init__(
+        self, data: RevisionDoesNotExistException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="RevisionDoesNotExistException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "RevisionDoesNotExistException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/revision_required_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#RevisionRequiredException``."""
+
+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 RevisionRequiredException_(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: RevisionRequiredException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> RevisionRequiredException_:
+    out: RevisionRequiredException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class RevisionRequiredException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#RevisionRequiredException``."""
+
+    code: str | None = "RevisionRequiredException"
+
+    def __init__(self, data: RevisionRequiredException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="RevisionRequiredException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "RevisionRequiredException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/role_required_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#RoleRequiredException``."""
+
+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 RoleRequiredException_(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: RoleRequiredException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> RoleRequiredException_:
+    out: RoleRequiredException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class RoleRequiredException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#RoleRequiredException``."""
+
+    code: str | None = "RoleRequiredException"
+
+    def __init__(self, data: RoleRequiredException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="RoleRequiredException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "RoleRequiredException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/tag_limit_exceeded_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#TagLimitExceededException``."""
+
+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 TagLimitExceededException_(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: TagLimitExceededException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> TagLimitExceededException_:
+    out: TagLimitExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class TagLimitExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#TagLimitExceededException``."""
+
+    code: str | None = "TagLimitExceededException"
+
+    def __init__(self, data: TagLimitExceededException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="TagLimitExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "TagLimitExceededException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/tag_required_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#TagRequiredException``."""
+
+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 TagRequiredException_(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: TagRequiredException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> TagRequiredException_:
+    out: TagRequiredException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class TagRequiredException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#TagRequiredException``."""
+
+    code: str | None = "TagRequiredException"
+
+    def __init__(self, data: TagRequiredException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="TagRequiredException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "TagRequiredException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/tag_set_list_limit_exceeded_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#TagSetListLimitExceededException``."""
+
+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 TagSetListLimitExceededException_(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: TagSetListLimitExceededException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> TagSetListLimitExceededException_:
+    out: TagSetListLimitExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class TagSetListLimitExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#TagSetListLimitExceededException``."""
+
+    code: str | None = "TagSetListLimitExceededException"
+
+    def __init__(
+        self, data: TagSetListLimitExceededException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="TagSetListLimitExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "TagSetListLimitExceededException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/throttling_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#ThrottlingException``."""
+
+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 ThrottlingException_(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: ThrottlingException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(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.codedeploy#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_1(
+        cls, data: dict, message: str | None = None
+    ) -> "ThrottlingException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/trigger_targets_limit_exceeded_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#TriggerTargetsLimitExceededException``."""
+
+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 TriggerTargetsLimitExceededException_(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: TriggerTargetsLimitExceededException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> TriggerTargetsLimitExceededException_:
+    out: TriggerTargetsLimitExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class TriggerTargetsLimitExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#TriggerTargetsLimitExceededException``."""
+
+    code: str | None = "TriggerTargetsLimitExceededException"
+
+    def __init__(
+        self, data: TriggerTargetsLimitExceededException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="TriggerTargetsLimitExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "TriggerTargetsLimitExceededException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/unsupported_action_for_deployment_type_exception.py

@@ -0,0 +1,58 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#UnsupportedActionForDeploymentTypeException``."""
+
+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 UnsupportedActionForDeploymentTypeException_(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: UnsupportedActionForDeploymentTypeException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(
+    data: dict,
+) -> UnsupportedActionForDeploymentTypeException_:
+    out: UnsupportedActionForDeploymentTypeException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class UnsupportedActionForDeploymentTypeException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#UnsupportedActionForDeploymentTypeException``."""
+
+    code: str | None = "UnsupportedActionForDeploymentTypeException"
+
+    def __init__(
+        self,
+        data: UnsupportedActionForDeploymentTypeException_,
+        message: str | None = None,
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="UnsupportedActionForDeploymentTypeException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "UnsupportedActionForDeploymentTypeException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/types/_prelude/blob.py

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

capo_codedeploy/types/_prelude/timestamp.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy prelude shape ``smithy.api#Timestamp``."""
+
+import datetime
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(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_1(data: float) -> datetime.datetime:
+    return datetime.datetime.fromtimestamp(float(data), tz=datetime.timezone.utc)

capo_codedeploy/types/add_tags_to_on_premises_instances_input.py

@@ -0,0 +1,59 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#AddTagsToOnPremisesInstancesInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codedeploy.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.instance_name_list
+    import capo_codedeploy.types.tag_list
+
+
+class AddTagsToOnPremisesInstancesInput(TypedDict, closed=True):
+    tags: "capo_codedeploy.types.tag_list.TagList"
+    """<p>The tag key-value pairs to add to the on-premises instances.</p> <p>Keys and values are both required. Keys cannot be null or empty strings. Value-only tags are not allowed.</p>"""
+    instance_names: "capo_codedeploy.types.instance_name_list.InstanceNameList"
+    """<p>The names of the on-premises instances to which to add tags.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: AddTagsToOnPremisesInstancesInput) -> dict:
+    out: dict = {}
+    import capo_codedeploy.types.tag_list
+
+    out["tags"] = capo_codedeploy.types.tag_list.serialize_aws_json_1_1(value["tags"])
+    import capo_codedeploy.types.instance_name_list
+
+    out["instanceNames"] = (
+        capo_codedeploy.types.instance_name_list.serialize_aws_json_1_1(
+            value["instance_names"]
+        )
+    )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> AddTagsToOnPremisesInstancesInput:
+    out: AddTagsToOnPremisesInstancesInput = {}  # type: ignore[typeddict-item]
+    if data.get("tags") is not None:
+        import capo_codedeploy.types.tag_list
+
+        out["tags"] = capo_codedeploy.types.tag_list.deserialize_aws_json_1_1(
+            data["tags"]
+        )
+    else:
+        raise DeserializationError("AddTagsToOnPremisesInstancesInput.tags required")
+    if data.get("instanceNames") is not None:
+        import capo_codedeploy.types.instance_name_list
+
+        out["instance_names"] = (
+            capo_codedeploy.types.instance_name_list.deserialize_aws_json_1_1(
+                data["instanceNames"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "AddTagsToOnPremisesInstancesInput.instance_names required"
+        )
+    return out

capo_codedeploy/types/additional_deployment_status_info.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#AdditionalDeploymentStatusInfo``."""
+
+from typing import TypeAlias
+
+AdditionalDeploymentStatusInfo: TypeAlias = str

capo_codedeploy/types/alarm.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#Alarm``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.alarm_name
+
+
+class Alarm(TypedDict, closed=True):
+    name: NotRequired["capo_codedeploy.types.alarm_name.AlarmName"]
+    """<p>The name of the alarm. Maximum length is 255 characters. Each alarm name can be used only once in a list of alarms.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: Alarm) -> dict:
+    out: dict = {}
+    if "name" in value:
+        out["name"] = value["name"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> Alarm:
+    out: Alarm = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    return out