capo-keyspaces 0.1.0__py3-none-any.whl

capo_keyspaces/types/encryption_specification.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#EncryptionSpecification``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.encryption_type
+    import capo_keyspaces.types.kms_key_arn
+
+
+class EncryptionSpecification(TypedDict, closed=True):
+    type: "capo_keyspaces.types.encryption_type.EncryptionType"
+    r"""<p>The encryption option specified for the table. You can choose one of the following KMS keys (KMS keys):</p> <ul> <li> <p> <code>type:AWS_OWNED_KMS_KEY</code> - This key is owned by Amazon Keyspaces. </p> </li> <li> <p> <code>type:CUSTOMER_MANAGED_KMS_KEY</code> - This key is stored in your account and is created, owned, and managed by you. This option requires the <code>kms_key_identifier</code> of the KMS key in Amazon Resource Name (ARN) format as input. </p> </li> </ul> <p>The default is <code>type:AWS_OWNED_KMS_KEY</code>. </p> <p>For more information, see <a href=\"https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html\">Encryption at rest</a> in the <i>Amazon Keyspaces Developer Guide</i>.</p>"""
+    kms_key_identifier: NotRequired["capo_keyspaces.types.kms_key_arn.kmsKeyARN"]
+    """<p>The Amazon Resource Name (ARN) of the customer managed KMS key, for example <code>kms_key_identifier:ARN</code>.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: EncryptionSpecification) -> dict:
+    out: dict = {}
+    out["type"] = value["type"]
+    if "kms_key_identifier" in value:
+        out["kmsKeyIdentifier"] = value["kms_key_identifier"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> EncryptionSpecification:
+    out: EncryptionSpecification = {}  # type: ignore[typeddict-item]
+    if data.get("type") is not None:
+        out["type"] = data["type"]
+    else:
+        raise DeserializationError("EncryptionSpecification.type required")
+    if data.get("kmsKeyIdentifier") is not None:
+        out["kms_key_identifier"] = data["kmsKeyIdentifier"]
+    return out

capo_keyspaces/types/encryption_type.py

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

capo_keyspaces/types/field_definition.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#FieldDefinition``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.generic_string
+
+
+class FieldDefinition(TypedDict, closed=True):
+    name: "capo_keyspaces.types.generic_string.GenericString"
+    """<p> The identifier. </p>"""
+    type: "capo_keyspaces.types.generic_string.GenericString"
+    r"""<p> Any supported Cassandra data type, including collections and other user-defined types that are contained in the same keyspace. </p> <p>For more information, see <a href=\"https://docs.aws.amazon.com/keyspaces/latest/devguide/cassandra-apis.html#cassandra-data-type\">Cassandra data type support</a> in the <i>Amazon Keyspaces Developer Guide</i>.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: FieldDefinition) -> dict:
+    out: dict = {}
+    out["name"] = value["name"]
+    out["type"] = value["type"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> FieldDefinition:
+    out: FieldDefinition = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("FieldDefinition.name required")
+    if data.get("type") is not None:
+        out["type"] = data["type"]
+    else:
+        raise DeserializationError("FieldDefinition.type required")
+    return out

capo_keyspaces/types/field_list.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#FieldList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.field_definition
+
+FieldList: TypeAlias = list["capo_keyspaces.types.field_definition.FieldDefinition"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: FieldList) -> list:
+    import capo_keyspaces.types.field_definition
+
+    out: list = []
+    for item in value:
+        out.append(capo_keyspaces.types.field_definition.serialize_aws_json_1_0(item))
+    return out
+
+
+def deserialize_aws_json_1_0(data: list) -> FieldList:
+    import capo_keyspaces.types.field_definition
+
+    out: FieldList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_keyspaces.types.field_definition.deserialize_aws_json_1_0(item))
+    return out

capo_keyspaces/types/generic_string.py

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

capo_keyspaces/types/get_keyspace_request.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#GetKeyspaceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.keyspace_name
+
+
+class GetKeyspaceRequest(TypedDict, closed=True):
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p>The name of the keyspace.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: GetKeyspaceRequest) -> dict:
+    out: dict = {}
+    out["keyspaceName"] = value["keyspace_name"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> GetKeyspaceRequest:
+    out: GetKeyspaceRequest = {}  # type: ignore[typeddict-item]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError("GetKeyspaceRequest.keyspace_name required")
+    return out

capo_keyspaces/types/get_keyspace_response.py

@@ -0,0 +1,87 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#GetKeyspaceResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.arn
+    import capo_keyspaces.types.keyspace_name
+    import capo_keyspaces.types.region_list
+    import capo_keyspaces.types.replication_group_status_list
+    import capo_keyspaces.types.rs
+
+
+class GetKeyspaceResponse(TypedDict, closed=True):
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p>The name of the keyspace.</p>"""
+    resource_arn: "capo_keyspaces.types.arn.ARN"
+    """<p>Returns the ARN of the keyspace.</p>"""
+    replication_strategy: "capo_keyspaces.types.rs.rs"
+    """<p> Returns the replication strategy of the keyspace. The options are <code>SINGLE_REGION</code> or <code>MULTI_REGION</code>. </p>"""
+    replication_regions: NotRequired["capo_keyspaces.types.region_list.RegionList"]
+    """<p> If the <code>replicationStrategy</code> of the keyspace is <code>MULTI_REGION</code>, a list of replication Regions is returned. </p>"""
+    replication_group_statuses: NotRequired[
+        "capo_keyspaces.types.replication_group_status_list.ReplicationGroupStatusList"
+    ]
+    """<p> A list of all Regions the keyspace is replicated in after the update keyspace operation and their status. </p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: GetKeyspaceResponse) -> dict:
+    out: dict = {}
+    out["keyspaceName"] = value["keyspace_name"]
+    out["resourceArn"] = value["resource_arn"]
+    out["replicationStrategy"] = value["replication_strategy"]
+    if "replication_regions" in value:
+        import capo_keyspaces.types.region_list
+
+        out["replicationRegions"] = (
+            capo_keyspaces.types.region_list.serialize_aws_json_1_0(
+                value["replication_regions"]
+            )
+        )
+    if "replication_group_statuses" in value:
+        import capo_keyspaces.types.replication_group_status_list
+
+        out["replicationGroupStatuses"] = (
+            capo_keyspaces.types.replication_group_status_list.serialize_aws_json_1_0(
+                value["replication_group_statuses"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> GetKeyspaceResponse:
+    out: GetKeyspaceResponse = {}  # type: ignore[typeddict-item]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError("GetKeyspaceResponse.keyspace_name required")
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError("GetKeyspaceResponse.resource_arn required")
+    if data.get("replicationStrategy") is not None:
+        out["replication_strategy"] = data["replicationStrategy"]
+    else:
+        raise DeserializationError("GetKeyspaceResponse.replication_strategy required")
+    if data.get("replicationRegions") is not None:
+        import capo_keyspaces.types.region_list
+
+        out["replication_regions"] = (
+            capo_keyspaces.types.region_list.deserialize_aws_json_1_0(
+                data["replicationRegions"]
+            )
+        )
+    if data.get("replicationGroupStatuses") is not None:
+        import capo_keyspaces.types.replication_group_status_list
+
+        out["replication_group_statuses"] = (
+            capo_keyspaces.types.replication_group_status_list.deserialize_aws_json_1_0(
+                data["replicationGroupStatuses"]
+            )
+        )
+    return out

capo_keyspaces/types/get_table_auto_scaling_settings_request.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#GetTableAutoScalingSettingsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.keyspace_name
+    import capo_keyspaces.types.table_name
+
+
+class GetTableAutoScalingSettingsRequest(TypedDict, closed=True):
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p>The name of the keyspace.</p>"""
+    table_name: "capo_keyspaces.types.table_name.TableName"
+    """<p>The name of the table.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: GetTableAutoScalingSettingsRequest) -> dict:
+    out: dict = {}
+    out["keyspaceName"] = value["keyspace_name"]
+    out["tableName"] = value["table_name"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> GetTableAutoScalingSettingsRequest:
+    out: GetTableAutoScalingSettingsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError(
+            "GetTableAutoScalingSettingsRequest.keyspace_name required"
+        )
+    if data.get("tableName") is not None:
+        out["table_name"] = data["tableName"]
+    else:
+        raise DeserializationError(
+            "GetTableAutoScalingSettingsRequest.table_name required"
+        )
+    return out

capo_keyspaces/types/get_table_auto_scaling_settings_response.py

@@ -0,0 +1,95 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#GetTableAutoScalingSettingsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.arn
+    import capo_keyspaces.types.auto_scaling_specification
+    import capo_keyspaces.types.keyspace_name
+    import capo_keyspaces.types.replica_auto_scaling_specification_list
+    import capo_keyspaces.types.table_name
+
+
+class GetTableAutoScalingSettingsResponse(TypedDict, closed=True):
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p>The name of the keyspace.</p>"""
+    table_name: "capo_keyspaces.types.table_name.TableName"
+    """<p>The name of the table.</p>"""
+    resource_arn: "capo_keyspaces.types.arn.ARN"
+    """<p>The Amazon Resource Name (ARN) of the table.</p>"""
+    auto_scaling_specification: NotRequired[
+        "capo_keyspaces.types.auto_scaling_specification.AutoScalingSpecification"
+    ]
+    """<p>The auto scaling settings of the table.</p>"""
+    replica_specifications: NotRequired[
+        "capo_keyspaces.types.replica_auto_scaling_specification_list.ReplicaAutoScalingSpecificationList"
+    ]
+    """<p>The Amazon Web Services Region specific settings of a multi-Region table. Returns the settings for all Regions the table is replicated in.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: GetTableAutoScalingSettingsResponse) -> dict:
+    out: dict = {}
+    out["keyspaceName"] = value["keyspace_name"]
+    out["tableName"] = value["table_name"]
+    out["resourceArn"] = value["resource_arn"]
+    if "auto_scaling_specification" in value:
+        import capo_keyspaces.types.auto_scaling_specification
+
+        out["autoScalingSpecification"] = (
+            capo_keyspaces.types.auto_scaling_specification.serialize_aws_json_1_0(
+                value["auto_scaling_specification"]
+            )
+        )
+    if "replica_specifications" in value:
+        import capo_keyspaces.types.replica_auto_scaling_specification_list
+
+        out["replicaSpecifications"] = (
+            capo_keyspaces.types.replica_auto_scaling_specification_list.serialize_aws_json_1_0(
+                value["replica_specifications"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> GetTableAutoScalingSettingsResponse:
+    out: GetTableAutoScalingSettingsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError(
+            "GetTableAutoScalingSettingsResponse.keyspace_name required"
+        )
+    if data.get("tableName") is not None:
+        out["table_name"] = data["tableName"]
+    else:
+        raise DeserializationError(
+            "GetTableAutoScalingSettingsResponse.table_name required"
+        )
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError(
+            "GetTableAutoScalingSettingsResponse.resource_arn required"
+        )
+    if data.get("autoScalingSpecification") is not None:
+        import capo_keyspaces.types.auto_scaling_specification
+
+        out["auto_scaling_specification"] = (
+            capo_keyspaces.types.auto_scaling_specification.deserialize_aws_json_1_0(
+                data["autoScalingSpecification"]
+            )
+        )
+    if data.get("replicaSpecifications") is not None:
+        import capo_keyspaces.types.replica_auto_scaling_specification_list
+
+        out["replica_specifications"] = (
+            capo_keyspaces.types.replica_auto_scaling_specification_list.deserialize_aws_json_1_0(
+                data["replicaSpecifications"]
+            )
+        )
+    return out

capo_keyspaces/types/get_table_request.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#GetTableRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.keyspace_name
+    import capo_keyspaces.types.table_name
+
+
+class GetTableRequest(TypedDict, closed=True):
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p>The name of the keyspace that the table is stored in.</p>"""
+    table_name: "capo_keyspaces.types.table_name.TableName"
+    """<p>The name of the table.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: GetTableRequest) -> dict:
+    out: dict = {}
+    out["keyspaceName"] = value["keyspace_name"]
+    out["tableName"] = value["table_name"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> GetTableRequest:
+    out: GetTableRequest = {}  # type: ignore[typeddict-item]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError("GetTableRequest.keyspace_name required")
+    if data.get("tableName") is not None:
+        out["table_name"] = data["tableName"]
+    else:
+        raise DeserializationError("GetTableRequest.table_name required")
+    return out