capo-codedeploy 0.1.0__py3-none-any.whl

capo_codedeploy/types/blue_instance_termination_option.py

@@ -0,0 +1,46 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#BlueInstanceTerminationOption``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.duration
+    import capo_codedeploy.types.instance_action
+
+
+class BlueInstanceTerminationOption(TypedDict, closed=True):
+    action: NotRequired["capo_codedeploy.types.instance_action.InstanceAction"]
+    """<p>The action to take on instances in the original environment after a successful blue/green deployment.</p> <ul> <li> <p> <code>TERMINATE</code>: Instances are terminated after a specified wait time.</p> </li> <li> <p> <code>KEEP_ALIVE</code>: Instances are left running after they are deregistered from the load balancer and removed from the deployment group.</p> </li> </ul>"""
+    termination_wait_time_in_minutes: "capo_codedeploy.types.duration.Duration"
+    """<p>For an Amazon EC2 deployment, the number of minutes to wait after a successful blue/green deployment before terminating instances from the original environment.</p> <p> For an Amazon ECS deployment, the number of minutes before deleting the original (blue) task set. During an Amazon ECS deployment, CodeDeploy shifts traffic from the original (blue) task set to a replacement (green) task set. </p> <p> The maximum setting is 2880 minutes (2 days). </p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BlueInstanceTerminationOption) -> dict:
+    out: dict = {}
+    if "action" in value:
+        import capo_codedeploy.types.instance_action
+
+        out["action"] = capo_codedeploy.types.instance_action.serialize_aws_json_1_1(
+            value["action"]
+        )
+    out["terminationWaitTimeInMinutes"] = value.get(
+        "termination_wait_time_in_minutes", 0
+    )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> BlueInstanceTerminationOption:
+    out: BlueInstanceTerminationOption = {}  # type: ignore[typeddict-item]
+    if data.get("action") is not None:
+        import capo_codedeploy.types.instance_action
+
+        out["action"] = capo_codedeploy.types.instance_action.deserialize_aws_json_1_1(
+            data["action"]
+        )
+    if data.get("terminationWaitTimeInMinutes") is not None:
+        out["termination_wait_time_in_minutes"] = data["terminationWaitTimeInMinutes"]
+    else:
+        out["termination_wait_time_in_minutes"] = 0
+    return out

capo_codedeploy/types/boolean.py

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

capo_codedeploy/types/bundle_type.py

@@ -0,0 +1,20 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#BundleType``."""
+
+from typing import Literal, TypeAlias, cast
+
+BundleType: TypeAlias = Literal[
+    "tar",
+    "tgz",
+    "zip",
+    "YAML",
+    "JSON",
+]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BundleType) -> str:
+    return value
+
+
+def deserialize_aws_json_1_1(data: str) -> BundleType:
+    return cast(BundleType, data)

capo_codedeploy/types/cloud_formation_resource_type.py

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

capo_codedeploy/types/cloud_formation_target.py

@@ -0,0 +1,112 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#CloudFormationTarget``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.cloud_formation_resource_type
+    import capo_codedeploy.types.deployment_id
+    import capo_codedeploy.types.lifecycle_event_list
+    import capo_codedeploy.types.target_id
+    import capo_codedeploy.types.target_status
+    import capo_codedeploy.types.time
+    import capo_codedeploy.types.traffic_weight
+
+
+class CloudFormationTarget(TypedDict, closed=True):
+    deployment_id: NotRequired["capo_codedeploy.types.deployment_id.DeploymentId"]
+    """<p>The unique ID of an CloudFormation blue/green deployment.</p>"""
+    target_id: NotRequired["capo_codedeploy.types.target_id.TargetId"]
+    """<p> The unique ID of a deployment target that has a type of <code>CloudFormationTarget</code>. </p>"""
+    last_updated_at: NotRequired["capo_codedeploy.types.time.Time"]
+    """<p> The date and time when the target application was updated by an CloudFormation blue/green deployment. </p>"""
+    lifecycle_events: NotRequired[
+        "capo_codedeploy.types.lifecycle_event_list.LifecycleEventList"
+    ]
+    """<p> The lifecycle events of the CloudFormation blue/green deployment to this target application. </p>"""
+    status: NotRequired["capo_codedeploy.types.target_status.TargetStatus"]
+    """<p> The status of an CloudFormation blue/green deployment's target application. </p>"""
+    resource_type: NotRequired[
+        "capo_codedeploy.types.cloud_formation_resource_type.CloudFormationResourceType"
+    ]
+    """<p>The resource type for the CloudFormation blue/green deployment.</p>"""
+    target_version_weight: "capo_codedeploy.types.traffic_weight.TrafficWeight"
+    """<p>The percentage of production traffic that the target version of an CloudFormation blue/green deployment receives.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CloudFormationTarget) -> dict:
+    out: dict = {}
+    if "deployment_id" in value:
+        out["deploymentId"] = value["deployment_id"]
+    if "target_id" in value:
+        out["targetId"] = value["target_id"]
+    if "last_updated_at" in value:
+        import capo_codedeploy.types.time
+
+        out["lastUpdatedAt"] = capo_codedeploy.types.time.serialize_aws_json_1_1(
+            value["last_updated_at"]
+        )
+    if "lifecycle_events" in value:
+        import capo_codedeploy.types.lifecycle_event_list
+
+        out["lifecycleEvents"] = (
+            capo_codedeploy.types.lifecycle_event_list.serialize_aws_json_1_1(
+                value["lifecycle_events"]
+            )
+        )
+    if "status" in value:
+        import capo_codedeploy.types.target_status
+
+        out["status"] = capo_codedeploy.types.target_status.serialize_aws_json_1_1(
+            value["status"]
+        )
+    if "resource_type" in value:
+        out["resourceType"] = value["resource_type"]
+    out["targetVersionWeight"] = (
+        "NaN"
+        if value.get("target_version_weight", 0)
+        != value.get("target_version_weight", 0)
+        else "Infinity"
+        if value.get("target_version_weight", 0) == float("inf")
+        else "-Infinity"
+        if value.get("target_version_weight", 0) == float("-inf")
+        else value.get("target_version_weight", 0)
+    )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CloudFormationTarget:
+    out: CloudFormationTarget = {}  # type: ignore[typeddict-item]
+    if data.get("deploymentId") is not None:
+        out["deployment_id"] = data["deploymentId"]
+    if data.get("targetId") is not None:
+        out["target_id"] = data["targetId"]
+    if data.get("lastUpdatedAt") is not None:
+        import capo_codedeploy.types.time
+
+        out["last_updated_at"] = capo_codedeploy.types.time.deserialize_aws_json_1_1(
+            data["lastUpdatedAt"]
+        )
+    if data.get("lifecycleEvents") is not None:
+        import capo_codedeploy.types.lifecycle_event_list
+
+        out["lifecycle_events"] = (
+            capo_codedeploy.types.lifecycle_event_list.deserialize_aws_json_1_1(
+                data["lifecycleEvents"]
+            )
+        )
+    if data.get("status") is not None:
+        import capo_codedeploy.types.target_status
+
+        out["status"] = capo_codedeploy.types.target_status.deserialize_aws_json_1_1(
+            data["status"]
+        )
+    if data.get("resourceType") is not None:
+        out["resource_type"] = data["resourceType"]
+    if data.get("targetVersionWeight") is not None:
+        out["target_version_weight"] = float(data["targetVersionWeight"])
+    else:
+        out["target_version_weight"] = 0
+    return out

capo_codedeploy/types/commit_id.py

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

capo_codedeploy/types/compute_platform.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#ComputePlatform``."""
+
+from typing import Literal, TypeAlias, cast
+
+ComputePlatform: TypeAlias = Literal[
+    "Server",
+    "Lambda",
+    "ECS",
+]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ComputePlatform) -> str:
+    return value
+
+
+def deserialize_aws_json_1_1(data: str) -> ComputePlatform:
+    return cast(ComputePlatform, data)

capo_codedeploy/types/continue_deployment_input.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#ContinueDeploymentInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.deployment_id
+    import capo_codedeploy.types.deployment_wait_type
+
+
+class ContinueDeploymentInput(TypedDict, closed=True):
+    deployment_id: NotRequired["capo_codedeploy.types.deployment_id.DeploymentId"]
+    """<p> The unique ID of a blue/green deployment for which you want to start rerouting traffic to the replacement environment. </p>"""
+    deployment_wait_type: NotRequired[
+        "capo_codedeploy.types.deployment_wait_type.DeploymentWaitType"
+    ]
+    """<p> The status of the deployment's waiting period. <code>READY_WAIT</code> indicates that the deployment is ready to start shifting traffic. <code>TERMINATION_WAIT</code> indicates that the traffic is shifted, but the original target is not terminated. </p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ContinueDeploymentInput) -> dict:
+    out: dict = {}
+    if "deployment_id" in value:
+        out["deploymentId"] = value["deployment_id"]
+    if "deployment_wait_type" in value:
+        import capo_codedeploy.types.deployment_wait_type
+
+        out["deploymentWaitType"] = (
+            capo_codedeploy.types.deployment_wait_type.serialize_aws_json_1_1(
+                value["deployment_wait_type"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ContinueDeploymentInput:
+    out: ContinueDeploymentInput = {}  # type: ignore[typeddict-item]
+    if data.get("deploymentId") is not None:
+        out["deployment_id"] = data["deploymentId"]
+    if data.get("deploymentWaitType") is not None:
+        import capo_codedeploy.types.deployment_wait_type
+
+        out["deployment_wait_type"] = (
+            capo_codedeploy.types.deployment_wait_type.deserialize_aws_json_1_1(
+                data["deploymentWaitType"]
+            )
+        )
+    return out

capo_codedeploy/types/create_application_input.py

@@ -0,0 +1,67 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#CreateApplicationInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.application_name
+    import capo_codedeploy.types.compute_platform
+    import capo_codedeploy.types.tag_list
+
+
+class CreateApplicationInput(TypedDict, closed=True):
+    application_name: "capo_codedeploy.types.application_name.ApplicationName"
+    """<p>The name of the application. This name must be unique with the applicable user or Amazon Web Services account.</p>"""
+    compute_platform: NotRequired[
+        "capo_codedeploy.types.compute_platform.ComputePlatform"
+    ]
+    """<p> The destination platform type for the deployment (<code>Lambda</code>, <code>Server</code>, or <code>ECS</code>).</p>"""
+    tags: NotRequired["capo_codedeploy.types.tag_list.TagList"]
+    """<p> The metadata that you apply to CodeDeploy applications to help you organize and categorize them. Each tag consists of a key and an optional value, both of which you define. </p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateApplicationInput) -> dict:
+    out: dict = {}
+    out["applicationName"] = value["application_name"]
+    if "compute_platform" in value:
+        import capo_codedeploy.types.compute_platform
+
+        out["computePlatform"] = (
+            capo_codedeploy.types.compute_platform.serialize_aws_json_1_1(
+                value["compute_platform"]
+            )
+        )
+    if "tags" in value:
+        import capo_codedeploy.types.tag_list
+
+        out["tags"] = capo_codedeploy.types.tag_list.serialize_aws_json_1_1(
+            value["tags"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateApplicationInput:
+    out: CreateApplicationInput = {}  # type: ignore[typeddict-item]
+    if data.get("applicationName") is not None:
+        out["application_name"] = data["applicationName"]
+    else:
+        raise DeserializationError("CreateApplicationInput.application_name required")
+    if data.get("computePlatform") is not None:
+        import capo_codedeploy.types.compute_platform
+
+        out["compute_platform"] = (
+            capo_codedeploy.types.compute_platform.deserialize_aws_json_1_1(
+                data["computePlatform"]
+            )
+        )
+    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"]
+        )
+    return out

capo_codedeploy/types/create_application_output.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#CreateApplicationOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.application_id
+
+
+class CreateApplicationOutput(TypedDict, closed=True):
+    application_id: NotRequired["capo_codedeploy.types.application_id.ApplicationId"]
+    """<p>A unique application ID.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateApplicationOutput) -> dict:
+    out: dict = {}
+    if "application_id" in value:
+        out["applicationId"] = value["application_id"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateApplicationOutput:
+    out: CreateApplicationOutput = {}  # type: ignore[typeddict-item]
+    if data.get("applicationId") is not None:
+        out["application_id"] = data["applicationId"]
+    return out

capo_codedeploy/types/create_deployment_config_input.py

@@ -0,0 +1,115 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#CreateDeploymentConfigInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.compute_platform
+    import capo_codedeploy.types.deployment_config_name
+    import capo_codedeploy.types.minimum_healthy_hosts
+    import capo_codedeploy.types.traffic_routing_config
+    import capo_codedeploy.types.zonal_config
+
+
+class CreateDeploymentConfigInput(TypedDict, closed=True):
+    deployment_config_name: (
+        "capo_codedeploy.types.deployment_config_name.DeploymentConfigName"
+    )
+    """<p>The name of the deployment configuration to create.</p>"""
+    minimum_healthy_hosts: NotRequired[
+        "capo_codedeploy.types.minimum_healthy_hosts.MinimumHealthyHosts"
+    ]
+    """<p>The minimum number of healthy instances that should be available at any time during the deployment. There are two parameters expected in the input: type and value.</p> <p>The type parameter takes either of the following values:</p> <ul> <li> <p>HOST_COUNT: The value parameter represents the minimum number of healthy instances as an absolute value.</p> </li> <li> <p>FLEET_PERCENT: The value parameter represents the minimum number of healthy instances as a percentage of the total number of instances in the deployment. If you specify FLEET_PERCENT, at the start of the deployment, CodeDeploy converts the percentage to the equivalent number of instances and rounds up fractional instances.</p> </li> </ul> <p>The value parameter takes an integer.</p> <p>For example, to set a minimum of 95% healthy instance, specify a type of FLEET_PERCENT and a value of 95.</p>"""
+    traffic_routing_config: NotRequired[
+        "capo_codedeploy.types.traffic_routing_config.TrafficRoutingConfig"
+    ]
+    """<p>The configuration that specifies how the deployment traffic is routed.</p>"""
+    compute_platform: NotRequired[
+        "capo_codedeploy.types.compute_platform.ComputePlatform"
+    ]
+    """<p>The destination platform type for the deployment (<code>Lambda</code>, <code>Server</code>, or <code>ECS</code>).</p>"""
+    zonal_config: NotRequired["capo_codedeploy.types.zonal_config.ZonalConfig"]
+    r"""<p>Configure the <code>ZonalConfig</code> object if you want CodeDeploy to deploy your application to one <a href=\"https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-availability-zones\">Availability Zone</a> at a time, within an Amazon Web Services Region.</p> <p>For more information about the zonal configuration feature, see <a href=\"https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations-create.html#zonal-config\">zonal configuration</a> in the <i>CodeDeploy User Guide</i>.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateDeploymentConfigInput) -> dict:
+    out: dict = {}
+    out["deploymentConfigName"] = value["deployment_config_name"]
+    if "minimum_healthy_hosts" in value:
+        import capo_codedeploy.types.minimum_healthy_hosts
+
+        out["minimumHealthyHosts"] = (
+            capo_codedeploy.types.minimum_healthy_hosts.serialize_aws_json_1_1(
+                value["minimum_healthy_hosts"]
+            )
+        )
+    if "traffic_routing_config" in value:
+        import capo_codedeploy.types.traffic_routing_config
+
+        out["trafficRoutingConfig"] = (
+            capo_codedeploy.types.traffic_routing_config.serialize_aws_json_1_1(
+                value["traffic_routing_config"]
+            )
+        )
+    if "compute_platform" in value:
+        import capo_codedeploy.types.compute_platform
+
+        out["computePlatform"] = (
+            capo_codedeploy.types.compute_platform.serialize_aws_json_1_1(
+                value["compute_platform"]
+            )
+        )
+    if "zonal_config" in value:
+        import capo_codedeploy.types.zonal_config
+
+        out["zonalConfig"] = capo_codedeploy.types.zonal_config.serialize_aws_json_1_1(
+            value["zonal_config"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateDeploymentConfigInput:
+    out: CreateDeploymentConfigInput = {}  # type: ignore[typeddict-item]
+    if data.get("deploymentConfigName") is not None:
+        out["deployment_config_name"] = data["deploymentConfigName"]
+    else:
+        raise DeserializationError(
+            "CreateDeploymentConfigInput.deployment_config_name required"
+        )
+    if data.get("minimumHealthyHosts") is not None:
+        import capo_codedeploy.types.minimum_healthy_hosts
+
+        out["minimum_healthy_hosts"] = (
+            capo_codedeploy.types.minimum_healthy_hosts.deserialize_aws_json_1_1(
+                data["minimumHealthyHosts"]
+            )
+        )
+    if data.get("trafficRoutingConfig") is not None:
+        import capo_codedeploy.types.traffic_routing_config
+
+        out["traffic_routing_config"] = (
+            capo_codedeploy.types.traffic_routing_config.deserialize_aws_json_1_1(
+                data["trafficRoutingConfig"]
+            )
+        )
+    if data.get("computePlatform") is not None:
+        import capo_codedeploy.types.compute_platform
+
+        out["compute_platform"] = (
+            capo_codedeploy.types.compute_platform.deserialize_aws_json_1_1(
+                data["computePlatform"]
+            )
+        )
+    if data.get("zonalConfig") is not None:
+        import capo_codedeploy.types.zonal_config
+
+        out["zonal_config"] = (
+            capo_codedeploy.types.zonal_config.deserialize_aws_json_1_1(
+                data["zonalConfig"]
+            )
+        )
+    return out

capo_codedeploy/types/create_deployment_config_output.py

@@ -0,0 +1,30 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#CreateDeploymentConfigOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.deployment_config_id
+
+
+class CreateDeploymentConfigOutput(TypedDict, closed=True):
+    deployment_config_id: NotRequired[
+        "capo_codedeploy.types.deployment_config_id.DeploymentConfigId"
+    ]
+    """<p>A unique deployment configuration ID.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateDeploymentConfigOutput) -> dict:
+    out: dict = {}
+    if "deployment_config_id" in value:
+        out["deploymentConfigId"] = value["deployment_config_id"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateDeploymentConfigOutput:
+    out: CreateDeploymentConfigOutput = {}  # type: ignore[typeddict-item]
+    if data.get("deploymentConfigId") is not None:
+        out["deployment_config_id"] = data["deploymentConfigId"]
+    return out