capo-keyspacesstreams 0.1.0__py3-none-any.whl

capo_keyspacesstreams/types/record.py

@@ -0,0 +1,146 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#Record``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.date
+    import capo_keyspacesstreams.types.keyspaces_keys_map
+    import capo_keyspacesstreams.types.keyspaces_row
+    import capo_keyspacesstreams.types.origin_type
+    import capo_keyspacesstreams.types.sequence_number
+
+
+class Record(TypedDict, closed=True):
+    event_version: NotRequired["str"]
+    """<p>The version of the record format, used to track the evolution of the record structure over time.</p>"""
+    created_at: NotRequired["capo_keyspacesstreams.types.date.Date"]
+    """<p>The timestamp indicating when this change data capture record was created.</p>"""
+    origin: NotRequired["capo_keyspacesstreams.types.origin_type.OriginType"]
+    """<p>The origin or source of this change data capture record.</p>"""
+    partition_keys: NotRequired[
+        "capo_keyspacesstreams.types.keyspaces_keys_map.KeyspacesKeysMap"
+    ]
+    """<p>The partition key columns and their values for the affected row.</p>"""
+    clustering_keys: NotRequired[
+        "capo_keyspacesstreams.types.keyspaces_keys_map.KeyspacesKeysMap"
+    ]
+    """<p>The clustering key columns and their values for the affected row, which determine the order of rows within a partition.</p>"""
+    new_image: NotRequired["capo_keyspacesstreams.types.keyspaces_row.KeyspacesRow"]
+    """<p>The state of the row after the change operation that generated this record.</p>"""
+    old_image: NotRequired["capo_keyspacesstreams.types.keyspaces_row.KeyspacesRow"]
+    """<p>The state of the row before the change operation that generated this record.</p>"""
+    sequence_number: NotRequired[
+        "capo_keyspacesstreams.types.sequence_number.SequenceNumber"
+    ]
+    """<p>A unique identifier assigned to this record within the shard, used for ordering and tracking purposes.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: Record) -> dict:
+    out: dict = {}
+    if "event_version" in value:
+        out["eventVersion"] = value["event_version"]
+    if "created_at" in value:
+        import capo_keyspacesstreams.types.date
+
+        out["createdAt"] = capo_keyspacesstreams.types.date.serialize_aws_json_1_0(
+            value["created_at"]
+        )
+    if "origin" in value:
+        import capo_keyspacesstreams.types.origin_type
+
+        out["origin"] = capo_keyspacesstreams.types.origin_type.serialize_aws_json_1_0(
+            value["origin"]
+        )
+    if "partition_keys" in value:
+        import capo_keyspacesstreams.types.keyspaces_keys_map
+
+        out["partitionKeys"] = (
+            capo_keyspacesstreams.types.keyspaces_keys_map.serialize_aws_json_1_0(
+                value["partition_keys"]
+            )
+        )
+    if "clustering_keys" in value:
+        import capo_keyspacesstreams.types.keyspaces_keys_map
+
+        out["clusteringKeys"] = (
+            capo_keyspacesstreams.types.keyspaces_keys_map.serialize_aws_json_1_0(
+                value["clustering_keys"]
+            )
+        )
+    if "new_image" in value:
+        import capo_keyspacesstreams.types.keyspaces_row
+
+        out["newImage"] = (
+            capo_keyspacesstreams.types.keyspaces_row.serialize_aws_json_1_0(
+                value["new_image"]
+            )
+        )
+    if "old_image" in value:
+        import capo_keyspacesstreams.types.keyspaces_row
+
+        out["oldImage"] = (
+            capo_keyspacesstreams.types.keyspaces_row.serialize_aws_json_1_0(
+                value["old_image"]
+            )
+        )
+    if "sequence_number" in value:
+        out["sequenceNumber"] = value["sequence_number"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> Record:
+    out: Record = {}  # type: ignore[typeddict-item]
+    if data.get("eventVersion") is not None:
+        out["event_version"] = data["eventVersion"]
+    if data.get("createdAt") is not None:
+        import capo_keyspacesstreams.types.date
+
+        out["created_at"] = capo_keyspacesstreams.types.date.deserialize_aws_json_1_0(
+            data["createdAt"]
+        )
+    if data.get("origin") is not None:
+        import capo_keyspacesstreams.types.origin_type
+
+        out["origin"] = (
+            capo_keyspacesstreams.types.origin_type.deserialize_aws_json_1_0(
+                data["origin"]
+            )
+        )
+    if data.get("partitionKeys") is not None:
+        import capo_keyspacesstreams.types.keyspaces_keys_map
+
+        out["partition_keys"] = (
+            capo_keyspacesstreams.types.keyspaces_keys_map.deserialize_aws_json_1_0(
+                data["partitionKeys"]
+            )
+        )
+    if data.get("clusteringKeys") is not None:
+        import capo_keyspacesstreams.types.keyspaces_keys_map
+
+        out["clustering_keys"] = (
+            capo_keyspacesstreams.types.keyspaces_keys_map.deserialize_aws_json_1_0(
+                data["clusteringKeys"]
+            )
+        )
+    if data.get("newImage") is not None:
+        import capo_keyspacesstreams.types.keyspaces_row
+
+        out["new_image"] = (
+            capo_keyspacesstreams.types.keyspaces_row.deserialize_aws_json_1_0(
+                data["newImage"]
+            )
+        )
+    if data.get("oldImage") is not None:
+        import capo_keyspacesstreams.types.keyspaces_row
+
+        out["old_image"] = (
+            capo_keyspacesstreams.types.keyspaces_row.deserialize_aws_json_1_0(
+                data["oldImage"]
+            )
+        )
+    if data.get("sequenceNumber") is not None:
+        out["sequence_number"] = data["sequenceNumber"]
+    return out

capo_keyspacesstreams/types/record_list.py

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

capo_keyspacesstreams/types/sequence_number.py

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

capo_keyspacesstreams/types/sequence_number_range.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#SequenceNumberRange``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.sequence_number
+
+
+class SequenceNumberRange(TypedDict, closed=True):
+    starting_sequence_number: NotRequired[
+        "capo_keyspacesstreams.types.sequence_number.SequenceNumber"
+    ]
+    """<p>The starting sequence number of the range.</p>"""
+    ending_sequence_number: NotRequired[
+        "capo_keyspacesstreams.types.sequence_number.SequenceNumber"
+    ]
+    """<p>The ending sequence number of the range, which may be null for open-ended ranges.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: SequenceNumberRange) -> dict:
+    out: dict = {}
+    if "starting_sequence_number" in value:
+        out["startingSequenceNumber"] = value["starting_sequence_number"]
+    if "ending_sequence_number" in value:
+        out["endingSequenceNumber"] = value["ending_sequence_number"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> SequenceNumberRange:
+    out: SequenceNumberRange = {}  # type: ignore[typeddict-item]
+    if data.get("startingSequenceNumber") is not None:
+        out["starting_sequence_number"] = data["startingSequenceNumber"]
+    if data.get("endingSequenceNumber") is not None:
+        out["ending_sequence_number"] = data["endingSequenceNumber"]
+    return out

capo_keyspacesstreams/types/shard.py

@@ -0,0 +1,70 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#Shard``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.sequence_number_range
+    import capo_keyspacesstreams.types.shard_id
+    import capo_keyspacesstreams.types.shard_id_list
+
+
+class Shard(TypedDict, closed=True):
+    shard_id: NotRequired["capo_keyspacesstreams.types.shard_id.ShardId"]
+    """<p>A unique identifier for this shard within the stream.</p>"""
+    sequence_number_range: NotRequired[
+        "capo_keyspacesstreams.types.sequence_number_range.SequenceNumberRange"
+    ]
+    """<p>The range of sequence numbers contained within this shard.</p>"""
+    parent_shard_ids: NotRequired[
+        "capo_keyspacesstreams.types.shard_id_list.ShardIdList"
+    ]
+    """<p>The identifiers of parent shards that this shard evolved from, if this shard was created through resharding.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: Shard) -> dict:
+    out: dict = {}
+    if "shard_id" in value:
+        out["shardId"] = value["shard_id"]
+    if "sequence_number_range" in value:
+        import capo_keyspacesstreams.types.sequence_number_range
+
+        out["sequenceNumberRange"] = (
+            capo_keyspacesstreams.types.sequence_number_range.serialize_aws_json_1_0(
+                value["sequence_number_range"]
+            )
+        )
+    if "parent_shard_ids" in value:
+        import capo_keyspacesstreams.types.shard_id_list
+
+        out["parentShardIds"] = (
+            capo_keyspacesstreams.types.shard_id_list.serialize_aws_json_1_0(
+                value["parent_shard_ids"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> Shard:
+    out: Shard = {}  # type: ignore[typeddict-item]
+    if data.get("shardId") is not None:
+        out["shard_id"] = data["shardId"]
+    if data.get("sequenceNumberRange") is not None:
+        import capo_keyspacesstreams.types.sequence_number_range
+
+        out["sequence_number_range"] = (
+            capo_keyspacesstreams.types.sequence_number_range.deserialize_aws_json_1_0(
+                data["sequenceNumberRange"]
+            )
+        )
+    if data.get("parentShardIds") is not None:
+        import capo_keyspacesstreams.types.shard_id_list
+
+        out["parent_shard_ids"] = (
+            capo_keyspacesstreams.types.shard_id_list.deserialize_aws_json_1_0(
+                data["parentShardIds"]
+            )
+        )
+    return out

capo_keyspacesstreams/types/shard_description_list.py

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

capo_keyspacesstreams/types/shard_filter.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#ShardFilter``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.shard_filter_type
+    import capo_keyspacesstreams.types.shard_id
+
+
+class ShardFilter(TypedDict, closed=True):
+    type: NotRequired["capo_keyspacesstreams.types.shard_filter_type.ShardFilterType"]
+    """<p>The type of shard filter to use, which determines how the shardId parameter is interpreted.</p>"""
+    shard_id: NotRequired["capo_keyspacesstreams.types.shard_id.ShardId"]
+    """<p>The identifier of a specific shard used to filter results based on the specified filter type.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ShardFilter) -> dict:
+    out: dict = {}
+    if "type" in value:
+        import capo_keyspacesstreams.types.shard_filter_type
+
+        out["type"] = (
+            capo_keyspacesstreams.types.shard_filter_type.serialize_aws_json_1_0(
+                value["type"]
+            )
+        )
+    if "shard_id" in value:
+        out["shardId"] = value["shard_id"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ShardFilter:
+    out: ShardFilter = {}  # type: ignore[typeddict-item]
+    if data.get("type") is not None:
+        import capo_keyspacesstreams.types.shard_filter_type
+
+        out["type"] = (
+            capo_keyspacesstreams.types.shard_filter_type.deserialize_aws_json_1_0(
+                data["type"]
+            )
+        )
+    if data.get("shardId") is not None:
+        out["shard_id"] = data["shardId"]
+    return out

capo_keyspacesstreams/types/shard_filter_type.py

@@ -0,0 +1,14 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#ShardFilterType``."""
+
+from typing import Literal, TypeAlias, cast
+
+ShardFilterType: TypeAlias = Literal["CHILD_SHARDS",]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ShardFilterType) -> str:
+    return value
+
+
+def deserialize_aws_json_1_0(data: str) -> ShardFilterType:
+    return cast(ShardFilterType, data)

capo_keyspacesstreams/types/shard_id.py

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

capo_keyspacesstreams/types/shard_id_list.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#ShardIdList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.shard_id
+
+ShardIdList: TypeAlias = list["capo_keyspacesstreams.types.shard_id.ShardId"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ShardIdList) -> list:
+    return list(value)
+
+
+def deserialize_aws_json_1_0(data: list) -> ShardIdList:
+    return [item for item in data if item is not None]

capo_keyspacesstreams/types/shard_id_token.py

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

capo_keyspacesstreams/types/shard_iterator.py

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

capo_keyspacesstreams/types/shard_iterator_type.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#ShardIteratorType``."""
+
+from typing import Literal, TypeAlias, cast
+
+ShardIteratorType: TypeAlias = Literal[
+    "TRIM_HORIZON",
+    "LATEST",
+    "AT_SEQUENCE_NUMBER",
+    "AFTER_SEQUENCE_NUMBER",
+]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ShardIteratorType) -> str:
+    return value
+
+
+def deserialize_aws_json_1_0(data: str) -> ShardIteratorType:
+    return cast(ShardIteratorType, data)

capo_keyspacesstreams/types/stream.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#Stream``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspacesstreams.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.keyspace_name
+    import capo_keyspacesstreams.types.stream_arn
+    import capo_keyspacesstreams.types.table_name
+
+
+class Stream(TypedDict, closed=True):
+    stream_arn: "capo_keyspacesstreams.types.stream_arn.StreamArn"
+    """<p>The Amazon Resource Name (ARN) that uniquely identifies this stream.</p>"""
+    keyspace_name: "capo_keyspacesstreams.types.keyspace_name.KeyspaceName"
+    """<p>The name of the keyspace containing the table associated with this stream.</p>"""
+    table_name: "capo_keyspacesstreams.types.table_name.TableName"
+    """<p>The name of the table associated with this stream.</p>"""
+    stream_label: "str"
+    """<p>A unique identifier for this stream that can be used in stream operations.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: Stream) -> dict:
+    out: dict = {}
+    out["streamArn"] = value["stream_arn"]
+    out["keyspaceName"] = value["keyspace_name"]
+    out["tableName"] = value["table_name"]
+    out["streamLabel"] = value["stream_label"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> Stream:
+    out: Stream = {}  # type: ignore[typeddict-item]
+    if data.get("streamArn") is not None:
+        out["stream_arn"] = data["streamArn"]
+    else:
+        raise DeserializationError("Stream.stream_arn required")
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError("Stream.keyspace_name required")
+    if data.get("tableName") is not None:
+        out["table_name"] = data["tableName"]
+    else:
+        raise DeserializationError("Stream.table_name required")
+    if data.get("streamLabel") is not None:
+        out["stream_label"] = data["streamLabel"]
+    else:
+        raise DeserializationError("Stream.stream_label required")
+    return out

capo_keyspacesstreams/types/stream_arn.py

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

capo_keyspacesstreams/types/stream_arn_token.py

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

capo_keyspacesstreams/types/stream_list.py

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

capo_keyspacesstreams/types/stream_status.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#StreamStatus``."""
+
+from typing import Literal, TypeAlias, cast
+
+StreamStatus: TypeAlias = Literal[
+    "ENABLING",
+    "ENABLED",
+    "DISABLING",
+    "DISABLED",
+]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: StreamStatus) -> str:
+    return value
+
+
+def deserialize_aws_json_1_0(data: str) -> StreamStatus:
+    return cast(StreamStatus, data)

capo_keyspacesstreams/types/stream_view_type.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#StreamViewType``."""
+
+from typing import Literal, TypeAlias, cast
+
+StreamViewType: TypeAlias = Literal[
+    "NEW_IMAGE",
+    "OLD_IMAGE",
+    "NEW_AND_OLD_IMAGES",
+    "KEYS_ONLY",
+]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: StreamViewType) -> str:
+    return value
+
+
+def deserialize_aws_json_1_0(data: str) -> StreamViewType:
+    return cast(StreamViewType, data)

capo_keyspacesstreams/types/table_name.py

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

capo_keyspacesstreams/types/validation_exception_type.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#ValidationExceptionType``."""
+
+from typing import Literal, TypeAlias, cast
+
+ValidationExceptionType: TypeAlias = Literal[
+    "InvalidFormat",
+    "TrimmedDataAccess",
+    "ExpiredIterator",
+    "ExpiredNextToken",
+]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ValidationExceptionType) -> str:
+    return value
+
+
+def deserialize_aws_json_1_0(data: str) -> ValidationExceptionType:
+    return cast(ValidationExceptionType, data)