diff --git a/codegen/__init__.py b/codegen/__init__.py index 2f8d66ec..ebb95e00 100644 --- a/codegen/__init__.py +++ b/codegen/__init__.py @@ -2,4 +2,4 @@ # Note: the kafka-clients dependency of the Java tester also needs updating when # this is bumped (in java_tester/build.gradle). -build_tag: Final = "3.7.0" +build_tag: Final = "3.8.0" diff --git a/compose.yml b/compose.yml index 6426d9e5..214cb80b 100644 --- a/compose.yml +++ b/compose.yml @@ -1,7 +1,7 @@ name: kio services: kafka: - image: apache/kafka:3.7.0 + image: apache/kafka:3.8.0 hostname: broker container_name: broker ports: @@ -26,8 +26,6 @@ services: KAFKA_BUFFER_MEMORY: 104857600 KAFKA_MAX_REQUEST_SIZE: 104857600 KAFKA_REPLICA_FETCH_MAX_BYTES: 104857600 - tmpfs: - - /tmp java_tester: build: diff --git a/java_tester/build.gradle b/java_tester/build.gradle index 5553951d..1187e0c4 100644 --- a/java_tester/build.gradle +++ b/java_tester/build.gradle @@ -13,7 +13,7 @@ repositories { } dependencies { - implementation 'org.apache.kafka:kafka-clients:3.7.0' + implementation 'org.apache.kafka:kafka-clients:3.8.0' implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.2' implementation 'org.apache.commons:commons-text:1.9' } diff --git a/java_tester/src/main/java/io/aiven/kio/java_tester/RootMessageInfo.java b/java_tester/src/main/java/io/aiven/kio/java_tester/RootMessageInfo.java index 26880d15..4d663590 100644 --- a/java_tester/src/main/java/io/aiven/kio/java_tester/RootMessageInfo.java +++ b/java_tester/src/main/java/io/aiven/kio/java_tester/RootMessageInfo.java @@ -57,6 +57,8 @@ private static EntityClass getRootClass(String shortClassName) throw && !shortClassName.equals("ConsumerProtocolSubscription") && !shortClassName.equals("LeaderChangeMessage") && !shortClassName.equals("DefaultPrincipalData") + && !shortClassName.equals("KRaftVersionRecord") + && !shortClassName.equals("VotersRecord") ) { className += "Data"; } diff --git a/src/kio/schema/add_offsets_to_txn/v4/__init__.py b/src/kio/schema/add_offsets_to_txn/v4/__init__.py new file mode 100644 index 00000000..6575ee8b --- /dev/null +++ b/src/kio/schema/add_offsets_to_txn/v4/__init__.py @@ -0,0 +1,7 @@ +from .request import AddOffsetsToTxnRequest +from .response import AddOffsetsToTxnResponse + +__all__ = ( + "AddOffsetsToTxnRequest", + "AddOffsetsToTxnResponse", +) diff --git a/src/kio/schema/add_offsets_to_txn/v4/request.py b/src/kio/schema/add_offsets_to_txn/v4/request.py new file mode 100644 index 00000000..1cd864ce --- /dev/null +++ b/src/kio/schema/add_offsets_to_txn/v4/request.py @@ -0,0 +1,31 @@ +""" +Generated from ``clients/src/main/resources/common/message/AddOffsetsToTxnRequest.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.request_header.v2.header import RequestHeader +from kio.schema.types import GroupId +from kio.schema.types import ProducerId +from kio.schema.types import TransactionalId +from kio.static.constants import EntityType +from kio.static.primitive import i16 + + +@dataclass(frozen=True, slots=True, kw_only=True) +class AddOffsetsToTxnRequest: + __type__: ClassVar = EntityType.request + __version__: ClassVar[i16] = i16(4) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(25) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + transactional_id: TransactionalId = field(metadata={"kafka_type": "string"}) + """The transactional id corresponding to the transaction.""" + producer_id: ProducerId = field(metadata={"kafka_type": "int64"}) + """Current producer id in use by the transactional id.""" + producer_epoch: i16 = field(metadata={"kafka_type": "int16"}) + """Current epoch associated with the producer id.""" + group_id: GroupId = field(metadata={"kafka_type": "string"}) + """The unique group identifier.""" diff --git a/src/kio/schema/add_offsets_to_txn/v4/response.py b/src/kio/schema/add_offsets_to_txn/v4/response.py new file mode 100644 index 00000000..c856dfd7 --- /dev/null +++ b/src/kio/schema/add_offsets_to_txn/v4/response.py @@ -0,0 +1,26 @@ +""" +Generated from ``clients/src/main/resources/common/message/AddOffsetsToTxnResponse.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.errors import ErrorCode +from kio.schema.response_header.v1.header import ResponseHeader +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32Timedelta + + +@dataclass(frozen=True, slots=True, kw_only=True) +class AddOffsetsToTxnResponse: + __type__: ClassVar = EntityType.response + __version__: ClassVar[i16] = i16(4) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(25) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) + """Duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" + error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The response error code, or 0 if there was no error.""" diff --git a/src/kio/schema/add_partitions_to_txn/v5/__init__.py b/src/kio/schema/add_partitions_to_txn/v5/__init__.py new file mode 100644 index 00000000..611f03da --- /dev/null +++ b/src/kio/schema/add_partitions_to_txn/v5/__init__.py @@ -0,0 +1,7 @@ +from .request import AddPartitionsToTxnRequest +from .response import AddPartitionsToTxnResponse + +__all__ = ( + "AddPartitionsToTxnRequest", + "AddPartitionsToTxnResponse", +) diff --git a/src/kio/schema/add_partitions_to_txn/v5/request.py b/src/kio/schema/add_partitions_to_txn/v5/request.py new file mode 100644 index 00000000..f78c9f5b --- /dev/null +++ b/src/kio/schema/add_partitions_to_txn/v5/request.py @@ -0,0 +1,58 @@ +""" +Generated from ``clients/src/main/resources/common/message/AddPartitionsToTxnRequest.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.request_header.v2.header import RequestHeader +from kio.schema.types import ProducerId +from kio.schema.types import TopicName +from kio.schema.types import TransactionalId +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32 + + +@dataclass(frozen=True, slots=True, kw_only=True) +class AddPartitionsToTxnTopic: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(24) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + name: TopicName = field(metadata={"kafka_type": "string"}) + """The name of the topic.""" + partitions: tuple[i32, ...] = field(metadata={"kafka_type": "int32"}, default=()) + """The partition indexes to add to the transaction""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class AddPartitionsToTxnTransaction: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(24) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + transactional_id: TransactionalId = field(metadata={"kafka_type": "string"}) + """The transactional id corresponding to the transaction.""" + producer_id: ProducerId = field(metadata={"kafka_type": "int64"}) + """Current producer id in use by the transactional id.""" + producer_epoch: i16 = field(metadata={"kafka_type": "int16"}) + """Current epoch associated with the producer id.""" + verify_only: bool = field(metadata={"kafka_type": "bool"}, default=False) + """Boolean to signify if we want to check if the partition is in the transaction rather than add it.""" + topics: tuple[AddPartitionsToTxnTopic, ...] + """The partitions to add to the transaction.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class AddPartitionsToTxnRequest: + __type__: ClassVar = EntityType.request + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(24) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + transactions: tuple[AddPartitionsToTxnTransaction, ...] + """List of transactions to add partitions to.""" diff --git a/src/kio/schema/add_partitions_to_txn/v5/response.py b/src/kio/schema/add_partitions_to_txn/v5/response.py new file mode 100644 index 00000000..6bc1d498 --- /dev/null +++ b/src/kio/schema/add_partitions_to_txn/v5/response.py @@ -0,0 +1,70 @@ +""" +Generated from ``clients/src/main/resources/common/message/AddPartitionsToTxnResponse.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.errors import ErrorCode +from kio.schema.response_header.v1.header import ResponseHeader +from kio.schema.types import TopicName +from kio.schema.types import TransactionalId +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32 +from kio.static.primitive import i32Timedelta + + +@dataclass(frozen=True, slots=True, kw_only=True) +class AddPartitionsToTxnPartitionResult: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(24) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + partition_index: i32 = field(metadata={"kafka_type": "int32"}) + """The partition indexes.""" + partition_error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The response error code.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class AddPartitionsToTxnTopicResult: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(24) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + name: TopicName = field(metadata={"kafka_type": "string"}) + """The topic name.""" + results_by_partition: tuple[AddPartitionsToTxnPartitionResult, ...] + """The results for each partition""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class AddPartitionsToTxnResult: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(24) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + transactional_id: TransactionalId = field(metadata={"kafka_type": "string"}) + """The transactional id corresponding to the transaction.""" + topic_results: tuple[AddPartitionsToTxnTopicResult, ...] + """The results for each topic.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class AddPartitionsToTxnResponse: + __type__: ClassVar = EntityType.response + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(24) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) + """Duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" + error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The response top level error code.""" + results_by_transaction: tuple[AddPartitionsToTxnResult, ...] + """Results categorized by transactional ID.""" diff --git a/src/kio/schema/consumer_group_describe/v0/response.py b/src/kio/schema/consumer_group_describe/v0/response.py index 906f5f84..9d56251f 100644 --- a/src/kio/schema/consumer_group_describe/v0/response.py +++ b/src/kio/schema/consumer_group_describe/v0/response.py @@ -13,7 +13,6 @@ from kio.schema.types import GroupId from kio.schema.types import TopicName from kio.static.constants import EntityType -from kio.static.primitive import i8 from kio.static.primitive import i16 from kio.static.primitive import i32 from kio.static.primitive import i32Timedelta @@ -43,12 +42,6 @@ class Assignment: __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader topic_partitions: tuple[TopicPartitions, ...] """The assigned topic-partitions to the member.""" - error: i8 = field(metadata={"kafka_type": "int8"}) - """The assigned error.""" - metadata_version: i32 = field(metadata={"kafka_type": "int32"}) - """The assignor metadata version.""" - metadata_bytes: bytes = field(metadata={"kafka_type": "bytes"}) - """The assignor metadata bytes.""" @dataclass(frozen=True, slots=True, kw_only=True) diff --git a/src/kio/schema/describe_topic_partitions/__init__.py b/src/kio/schema/describe_topic_partitions/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/kio/schema/describe_topic_partitions/v0/__init__.py b/src/kio/schema/describe_topic_partitions/v0/__init__.py new file mode 100644 index 00000000..645449d2 --- /dev/null +++ b/src/kio/schema/describe_topic_partitions/v0/__init__.py @@ -0,0 +1,7 @@ +from .request import DescribeTopicPartitionsRequest +from .response import DescribeTopicPartitionsResponse + +__all__ = ( + "DescribeTopicPartitionsRequest", + "DescribeTopicPartitionsResponse", +) diff --git a/src/kio/schema/describe_topic_partitions/v0/request.py b/src/kio/schema/describe_topic_partitions/v0/request.py new file mode 100644 index 00000000..e3be8e28 --- /dev/null +++ b/src/kio/schema/describe_topic_partitions/v0/request.py @@ -0,0 +1,54 @@ +""" +Generated from ``clients/src/main/resources/common/message/DescribeTopicPartitionsRequest.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.request_header.v2.header import RequestHeader +from kio.schema.types import TopicName +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32 + + +@dataclass(frozen=True, slots=True, kw_only=True) +class TopicRequest: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(75) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + name: TopicName = field(metadata={"kafka_type": "string"}) + """The topic name""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class Cursor: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(75) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + topic_name: TopicName = field(metadata={"kafka_type": "string"}) + """The name for the first topic to process""" + partition_index: i32 = field(metadata={"kafka_type": "int32"}) + """The partition index to start with""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class DescribeTopicPartitionsRequest: + __type__: ClassVar = EntityType.request + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(75) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + topics: tuple[TopicRequest, ...] + """The topics to fetch details for.""" + response_partition_limit: i32 = field( + metadata={"kafka_type": "int32"}, default=i32(2000) + ) + """The maximum number of partitions included in the response.""" + cursor: Cursor | None = field(default=None) + """The first topic and partition index to fetch details for.""" diff --git a/src/kio/schema/describe_topic_partitions/v0/response.py b/src/kio/schema/describe_topic_partitions/v0/response.py new file mode 100644 index 00000000..98db9879 --- /dev/null +++ b/src/kio/schema/describe_topic_partitions/v0/response.py @@ -0,0 +1,106 @@ +""" +Generated from ``clients/src/main/resources/common/message/DescribeTopicPartitionsResponse.json``. +""" + +import uuid + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.errors import ErrorCode +from kio.schema.response_header.v1.header import ResponseHeader +from kio.schema.types import BrokerId +from kio.schema.types import TopicName +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32 +from kio.static.primitive import i32Timedelta + + +@dataclass(frozen=True, slots=True, kw_only=True) +class DescribeTopicPartitionsResponsePartition: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(75) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The partition error, or 0 if there was no error.""" + partition_index: i32 = field(metadata={"kafka_type": "int32"}) + """The partition index.""" + leader_id: BrokerId = field(metadata={"kafka_type": "int32"}) + """The ID of the leader broker.""" + leader_epoch: i32 = field(metadata={"kafka_type": "int32"}, default=i32(-1)) + """The leader epoch of this partition.""" + replica_nodes: tuple[BrokerId, ...] = field( + metadata={"kafka_type": "int32"}, default=() + ) + """The set of all nodes that host this partition.""" + isr_nodes: tuple[BrokerId, ...] = field( + metadata={"kafka_type": "int32"}, default=() + ) + """The set of nodes that are in sync with the leader for this partition.""" + eligible_leader_replicas: tuple[BrokerId, ...] = field( + metadata={"kafka_type": "int32"}, default=() + ) + """The new eligible leader replicas otherwise.""" + last_known_elr: tuple[BrokerId, ...] = field( + metadata={"kafka_type": "int32"}, default=() + ) + """The last known ELR.""" + offline_replicas: tuple[BrokerId, ...] = field( + metadata={"kafka_type": "int32"}, default=() + ) + """The set of offline replicas of this partition.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class DescribeTopicPartitionsResponseTopic: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(75) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The topic error, or 0 if there was no error.""" + name: TopicName | None = field(metadata={"kafka_type": "string"}) + """The topic name.""" + topic_id: uuid.UUID | None = field(metadata={"kafka_type": "uuid"}) + """The topic id.""" + is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) + """True if the topic is internal.""" + partitions: tuple[DescribeTopicPartitionsResponsePartition, ...] + """Each partition in the topic.""" + topic_authorized_operations: i32 = field( + metadata={"kafka_type": "int32"}, default=i32(-2147483648) + ) + """32-bit bitfield to represent authorized operations for this topic.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class Cursor: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(75) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + topic_name: TopicName = field(metadata={"kafka_type": "string"}) + """The name for the first topic to process""" + partition_index: i32 = field(metadata={"kafka_type": "int32"}) + """The partition index to start with""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class DescribeTopicPartitionsResponse: + __type__: ClassVar = EntityType.response + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(75) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) + """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" + topics: tuple[DescribeTopicPartitionsResponseTopic, ...] + """Each topic in the response.""" + next_cursor: Cursor | None = field(default=None) + """The next topic and partition index to fetch details for.""" diff --git a/src/kio/schema/end_txn/v4/__init__.py b/src/kio/schema/end_txn/v4/__init__.py new file mode 100644 index 00000000..9b809315 --- /dev/null +++ b/src/kio/schema/end_txn/v4/__init__.py @@ -0,0 +1,7 @@ +from .request import EndTxnRequest +from .response import EndTxnResponse + +__all__ = ( + "EndTxnRequest", + "EndTxnResponse", +) diff --git a/src/kio/schema/end_txn/v4/request.py b/src/kio/schema/end_txn/v4/request.py new file mode 100644 index 00000000..2e3a8a29 --- /dev/null +++ b/src/kio/schema/end_txn/v4/request.py @@ -0,0 +1,30 @@ +""" +Generated from ``clients/src/main/resources/common/message/EndTxnRequest.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.request_header.v2.header import RequestHeader +from kio.schema.types import ProducerId +from kio.schema.types import TransactionalId +from kio.static.constants import EntityType +from kio.static.primitive import i16 + + +@dataclass(frozen=True, slots=True, kw_only=True) +class EndTxnRequest: + __type__: ClassVar = EntityType.request + __version__: ClassVar[i16] = i16(4) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(26) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + transactional_id: TransactionalId = field(metadata={"kafka_type": "string"}) + """The ID of the transaction to end.""" + producer_id: ProducerId = field(metadata={"kafka_type": "int64"}) + """The producer ID.""" + producer_epoch: i16 = field(metadata={"kafka_type": "int16"}) + """The current epoch associated with the producer.""" + committed: bool = field(metadata={"kafka_type": "bool"}) + """True if the transaction was committed, false if it was aborted.""" diff --git a/src/kio/schema/end_txn/v4/response.py b/src/kio/schema/end_txn/v4/response.py new file mode 100644 index 00000000..b9c78316 --- /dev/null +++ b/src/kio/schema/end_txn/v4/response.py @@ -0,0 +1,26 @@ +""" +Generated from ``clients/src/main/resources/common/message/EndTxnResponse.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.errors import ErrorCode +from kio.schema.response_header.v1.header import ResponseHeader +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32Timedelta + + +@dataclass(frozen=True, slots=True, kw_only=True) +class EndTxnResponse: + __type__: ClassVar = EntityType.response + __version__: ClassVar[i16] = i16(4) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(26) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) + """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" + error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The error code, or 0 if there was no error.""" diff --git a/src/kio/schema/errors.py b/src/kio/schema/errors.py index 7a8497a9..50197887 100644 --- a/src/kio/schema/errors.py +++ b/src/kio/schema/errors.py @@ -212,7 +212,7 @@ def __new__(cls, value: int, retriable: bool) -> ErrorCode: unacceptable_credential = 93, False """Requested credential would not meet criteria for acceptability.""" inconsistent_voter_set = 94, False - """Indicates that the either the sender or recipient of a voter-only request is not one of the expected voters""" + """Indicates that the either the sender or recipient of a voter-only request is not one of the expected voters.""" invalid_update_version = 95, False """The given update version was invalid.""" feature_update_failed = 96, False @@ -220,7 +220,7 @@ def __new__(cls, value: int, retriable: bool) -> ErrorCode: principal_deserialization_failure = 97, False """Request principal deserialization failed during forwarding. This indicates an internal error on the broker cluster security setup.""" snapshot_not_found = 98, False - """Requested snapshot was not found""" + """Requested snapshot was not found.""" position_out_of_range = 99, False """Requested position is not greater than or equal to zero, and less than the size of the snapshot.""" unknown_topic_id = 100, True @@ -230,13 +230,13 @@ def __new__(cls, value: int, retriable: bool) -> ErrorCode: broker_id_not_registered = 102, False """The given broker ID was not registered.""" inconsistent_topic_id = 103, True - """The log's topic ID did not match the topic ID in the request""" + """The log's topic ID did not match the topic ID in the request.""" inconsistent_cluster_id = 104, False - """The clusterId in the request does not match that found on the server""" + """The clusterId in the request does not match that found on the server.""" transactional_id_not_found = 105, False - """The transactionalId could not be found""" + """The transactionalId could not be found.""" fetch_session_topic_id_error = 106, True - """The fetch session encountered inconsistent topic ID usage""" + """The fetch session encountered inconsistent topic ID usage.""" ineligible_replica = 107, False """The new ISR contains at least one ineligible replica.""" new_leader_elected = 108, False @@ -263,3 +263,5 @@ def __new__(cls, value: int, retriable: bool) -> ErrorCode: """Client sent a push telemetry request larger than the maximum size the broker will accept.""" invalid_registration = 119, False """The controller has considered the broker registration to be invalid.""" + transaction_abortable = 120, False + """The server encountered an error with the transaction. The client can abort the transaction to continue using this transactional ID.""" diff --git a/src/kio/schema/find_coordinator/v5/__init__.py b/src/kio/schema/find_coordinator/v5/__init__.py new file mode 100644 index 00000000..ecac31b6 --- /dev/null +++ b/src/kio/schema/find_coordinator/v5/__init__.py @@ -0,0 +1,7 @@ +from .request import FindCoordinatorRequest +from .response import FindCoordinatorResponse + +__all__ = ( + "FindCoordinatorRequest", + "FindCoordinatorResponse", +) diff --git a/src/kio/schema/find_coordinator/v5/request.py b/src/kio/schema/find_coordinator/v5/request.py new file mode 100644 index 00000000..8799fd03 --- /dev/null +++ b/src/kio/schema/find_coordinator/v5/request.py @@ -0,0 +1,27 @@ +""" +Generated from ``clients/src/main/resources/common/message/FindCoordinatorRequest.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.request_header.v2.header import RequestHeader +from kio.static.constants import EntityType +from kio.static.primitive import i8 +from kio.static.primitive import i16 + + +@dataclass(frozen=True, slots=True, kw_only=True) +class FindCoordinatorRequest: + __type__: ClassVar = EntityType.request + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(10) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + key_type: i8 = field(metadata={"kafka_type": "int8"}, default=i8(0)) + """The coordinator key type. (Group, transaction, etc.)""" + coordinator_keys: tuple[str, ...] = field( + metadata={"kafka_type": "string"}, default=() + ) + """The coordinator keys.""" diff --git a/src/kio/schema/find_coordinator/v5/response.py b/src/kio/schema/find_coordinator/v5/response.py new file mode 100644 index 00000000..d5141743 --- /dev/null +++ b/src/kio/schema/find_coordinator/v5/response.py @@ -0,0 +1,49 @@ +""" +Generated from ``clients/src/main/resources/common/message/FindCoordinatorResponse.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.errors import ErrorCode +from kio.schema.response_header.v1.header import ResponseHeader +from kio.schema.types import BrokerId +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32 +from kio.static.primitive import i32Timedelta + + +@dataclass(frozen=True, slots=True, kw_only=True) +class Coordinator: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(10) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + key: str = field(metadata={"kafka_type": "string"}) + """The coordinator key.""" + node_id: BrokerId = field(metadata={"kafka_type": "int32"}) + """The node id.""" + host: str = field(metadata={"kafka_type": "string"}) + """The host name.""" + port: i32 = field(metadata={"kafka_type": "int32"}) + """The port.""" + error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The error code, or 0 if there was no error.""" + error_message: str | None = field(metadata={"kafka_type": "string"}) + """The error message, or null if there was no error.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class FindCoordinatorResponse: + __type__: ClassVar = EntityType.response + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(10) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) + """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" + coordinators: tuple[Coordinator, ...] + """Each coordinator result in the response""" diff --git a/src/kio/schema/index.py b/src/kio/schema/index.py index 05f41b4b..2c84074c 100644 --- a/src/kio/schema/index.py +++ b/src/kio/schema/index.py @@ -100,6 +100,7 @@ 72: "push_telemetry", 73: "assign_replicas_to_dirs", 74: "list_client_metrics_resources", + 75: "describe_topic_partitions", } ) @@ -147,6 +148,16 @@ ), } ), + 4: MappingProxyType( + { + EntityType.request: ( + "kio.schema.add_offsets_to_txn.v4.request:AddOffsetsToTxnRequest" + ), + EntityType.response: ( + "kio.schema.add_offsets_to_txn.v4.response:AddOffsetsToTxnResponse" + ), + } + ), } ), "add_partitions_to_txn": MappingProxyType( @@ -201,6 +212,16 @@ ), } ), + 5: MappingProxyType( + { + EntityType.request: ( + "kio.schema.add_partitions_to_txn.v5.request:AddPartitionsToTxnRequest" + ), + EntityType.response: ( + "kio.schema.add_partitions_to_txn.v5.response:AddPartitionsToTxnResponse" + ), + } + ), } ), "allocate_producer_ids": MappingProxyType( @@ -1430,6 +1451,20 @@ ), } ), + "describe_topic_partitions": MappingProxyType( + { + 0: MappingProxyType( + { + EntityType.request: ( + "kio.schema.describe_topic_partitions.v0.request:DescribeTopicPartitionsRequest" + ), + EntityType.response: ( + "kio.schema.describe_topic_partitions.v0.response:DescribeTopicPartitionsResponse" + ), + } + ), + } + ), "describe_transactions": MappingProxyType( { 0: MappingProxyType( @@ -1548,6 +1583,16 @@ ), } ), + 4: MappingProxyType( + { + EntityType.request: ( + "kio.schema.end_txn.v4.request:EndTxnRequest" + ), + EntityType.response: ( + "kio.schema.end_txn.v4.response:EndTxnResponse" + ), + } + ), } ), "envelope": MappingProxyType( @@ -1838,6 +1883,16 @@ ), } ), + 5: MappingProxyType( + { + EntityType.request: ( + "kio.schema.find_coordinator.v5.request:FindCoordinatorRequest" + ), + EntityType.response: ( + "kio.schema.find_coordinator.v5.response:FindCoordinatorResponse" + ), + } + ), } ), "get_telemetry_subscriptions": MappingProxyType( @@ -1984,6 +2039,16 @@ ), } ), + 5: MappingProxyType( + { + EntityType.request: ( + "kio.schema.init_producer_id.v5.request:InitProducerIdRequest" + ), + EntityType.response: ( + "kio.schema.init_producer_id.v5.response:InitProducerIdResponse" + ), + } + ), } ), "join_group": MappingProxyType( @@ -2090,6 +2155,17 @@ ), } ), + "k_raft_version_record": MappingProxyType( + { + 0: MappingProxyType( + { + EntityType.data: ( + "kio.schema.k_raft_version_record.v0.data:KRaftVersionRecord" + ), + } + ), + } + ), "leader_and_isr": MappingProxyType( { 0: MappingProxyType( @@ -2315,6 +2391,16 @@ ), } ), + 5: MappingProxyType( + { + EntityType.request: ( + "kio.schema.list_groups.v5.request:ListGroupsRequest" + ), + EntityType.response: ( + "kio.schema.list_groups.v5.response:ListGroupsResponse" + ), + } + ), } ), "list_offsets": MappingProxyType( @@ -2437,6 +2523,16 @@ ), } ), + 1: MappingProxyType( + { + EntityType.request: ( + "kio.schema.list_transactions.v1.request:ListTransactionsRequest" + ), + EntityType.response: ( + "kio.schema.list_transactions.v1.response:ListTransactionsResponse" + ), + } + ), } ), "metadata": MappingProxyType( @@ -2881,6 +2977,16 @@ ), } ), + 11: MappingProxyType( + { + EntityType.request: ( + "kio.schema.produce.v11.request:ProduceRequest" + ), + EntityType.response: ( + "kio.schema.produce.v11.response:ProduceResponse" + ), + } + ), 2: MappingProxyType( { EntityType.request: ( @@ -3294,6 +3400,16 @@ ), } ), + 4: MappingProxyType( + { + EntityType.request: ( + "kio.schema.txn_offset_commit.v4.request:TxnOffsetCommitRequest" + ), + EntityType.response: ( + "kio.schema.txn_offset_commit.v4.response:TxnOffsetCommitResponse" + ), + } + ), } ), "unregister_broker": MappingProxyType( @@ -3440,6 +3556,17 @@ ), } ), + "voters_record": MappingProxyType( + { + 0: MappingProxyType( + { + EntityType.data: ( + "kio.schema.voters_record.v0.data:VotersRecord" + ), + } + ), + } + ), "write_txn_markers": MappingProxyType( { 0: MappingProxyType( diff --git a/src/kio/schema/init_producer_id/v5/__init__.py b/src/kio/schema/init_producer_id/v5/__init__.py new file mode 100644 index 00000000..58149864 --- /dev/null +++ b/src/kio/schema/init_producer_id/v5/__init__.py @@ -0,0 +1,7 @@ +from .request import InitProducerIdRequest +from .response import InitProducerIdResponse + +__all__ = ( + "InitProducerIdRequest", + "InitProducerIdResponse", +) diff --git a/src/kio/schema/init_producer_id/v5/request.py b/src/kio/schema/init_producer_id/v5/request.py new file mode 100644 index 00000000..0fee95f2 --- /dev/null +++ b/src/kio/schema/init_producer_id/v5/request.py @@ -0,0 +1,33 @@ +""" +Generated from ``clients/src/main/resources/common/message/InitProducerIdRequest.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.request_header.v2.header import RequestHeader +from kio.schema.types import ProducerId +from kio.schema.types import TransactionalId +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32Timedelta + + +@dataclass(frozen=True, slots=True, kw_only=True) +class InitProducerIdRequest: + __type__: ClassVar = EntityType.request + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(22) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + transactional_id: TransactionalId | None = field(metadata={"kafka_type": "string"}) + """The transactional id, or null if the producer is not transactional.""" + transaction_timeout: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) + """The time in ms to wait before aborting idle transactions sent by this producer. This is only relevant if a TransactionalId has been defined.""" + producer_id: ProducerId = field( + metadata={"kafka_type": "int64"}, default=ProducerId(-1) + ) + """The producer id. This is used to disambiguate requests if a transactional id is reused following its expiration.""" + producer_epoch: i16 = field(metadata={"kafka_type": "int16"}, default=i16(-1)) + """The producer's current epoch. This will be checked against the producer epoch on the broker, and the request will return an error if they do not match.""" diff --git a/src/kio/schema/init_producer_id/v5/response.py b/src/kio/schema/init_producer_id/v5/response.py new file mode 100644 index 00000000..11afa4f4 --- /dev/null +++ b/src/kio/schema/init_producer_id/v5/response.py @@ -0,0 +1,33 @@ +""" +Generated from ``clients/src/main/resources/common/message/InitProducerIdResponse.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.errors import ErrorCode +from kio.schema.response_header.v1.header import ResponseHeader +from kio.schema.types import ProducerId +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32Timedelta + + +@dataclass(frozen=True, slots=True, kw_only=True) +class InitProducerIdResponse: + __type__: ClassVar = EntityType.response + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(22) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) + """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" + error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The error code, or 0 if there was no error.""" + producer_id: ProducerId = field( + metadata={"kafka_type": "int64"}, default=ProducerId(-1) + ) + """The current producer id.""" + producer_epoch: i16 = field(metadata={"kafka_type": "int16"}) + """The current epoch associated with the producer id.""" diff --git a/src/kio/schema/k_raft_version_record/__init__.py b/src/kio/schema/k_raft_version_record/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/kio/schema/k_raft_version_record/v0/__init__.py b/src/kio/schema/k_raft_version_record/v0/__init__.py new file mode 100644 index 00000000..4ee19bd3 --- /dev/null +++ b/src/kio/schema/k_raft_version_record/v0/__init__.py @@ -0,0 +1,3 @@ +from .data import KRaftVersionRecord + +__all__ = ("KRaftVersionRecord",) diff --git a/src/kio/schema/k_raft_version_record/v0/data.py b/src/kio/schema/k_raft_version_record/v0/data.py new file mode 100644 index 00000000..c1172835 --- /dev/null +++ b/src/kio/schema/k_raft_version_record/v0/data.py @@ -0,0 +1,21 @@ +""" +Generated from ``clients/src/main/resources/common/message/KRaftVersionRecord.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.static.constants import EntityType +from kio.static.primitive import i16 + + +@dataclass(frozen=True, slots=True, kw_only=True) +class KRaftVersionRecord: + __type__: ClassVar = EntityType.data + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + version: i16 = field(metadata={"kafka_type": "int16"}) + """The version of the kraft version record""" + k_raft_version: i16 = field(metadata={"kafka_type": "int16"}) + """The kraft protocol version""" diff --git a/src/kio/schema/list_client_metrics_resources/v0/response.py b/src/kio/schema/list_client_metrics_resources/v0/response.py index 413937a7..b33f5437 100644 --- a/src/kio/schema/list_client_metrics_resources/v0/response.py +++ b/src/kio/schema/list_client_metrics_resources/v0/response.py @@ -21,6 +21,7 @@ class ClientMetricsResource: __api_key__: ClassVar[i16] = i16(74) __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader name: str = field(metadata={"kafka_type": "string"}) + """The resource name.""" @dataclass(frozen=True, slots=True, kw_only=True) @@ -33,4 +34,6 @@ class ListClientMetricsResourcesResponse: throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The error code, or 0 if there was no error.""" client_metrics_resources: tuple[ClientMetricsResource, ...] + """Each client metrics resource in the response.""" diff --git a/src/kio/schema/list_groups/v4/request.py b/src/kio/schema/list_groups/v4/request.py index 139eb7dd..6b55a634 100644 --- a/src/kio/schema/list_groups/v4/request.py +++ b/src/kio/schema/list_groups/v4/request.py @@ -21,4 +21,4 @@ class ListGroupsRequest: states_filter: tuple[str, ...] = field( metadata={"kafka_type": "string"}, default=() ) - """The states of the groups we want to list. If empty all groups are returned with their state.""" + """The states of the groups we want to list. If empty, all groups are returned with their state.""" diff --git a/src/kio/schema/list_groups/v5/__init__.py b/src/kio/schema/list_groups/v5/__init__.py new file mode 100644 index 00000000..1ad3bd36 --- /dev/null +++ b/src/kio/schema/list_groups/v5/__init__.py @@ -0,0 +1,7 @@ +from .request import ListGroupsRequest +from .response import ListGroupsResponse + +__all__ = ( + "ListGroupsRequest", + "ListGroupsResponse", +) diff --git a/src/kio/schema/list_groups/v5/request.py b/src/kio/schema/list_groups/v5/request.py new file mode 100644 index 00000000..b09262a5 --- /dev/null +++ b/src/kio/schema/list_groups/v5/request.py @@ -0,0 +1,26 @@ +""" +Generated from ``clients/src/main/resources/common/message/ListGroupsRequest.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.request_header.v2.header import RequestHeader +from kio.static.constants import EntityType +from kio.static.primitive import i16 + + +@dataclass(frozen=True, slots=True, kw_only=True) +class ListGroupsRequest: + __type__: ClassVar = EntityType.request + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(16) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + states_filter: tuple[str, ...] = field( + metadata={"kafka_type": "string"}, default=() + ) + """The states of the groups we want to list. If empty, all groups are returned with their state.""" + types_filter: tuple[str, ...] = field(metadata={"kafka_type": "string"}, default=()) + """The types of the groups we want to list. If empty, all groups are returned with their type.""" diff --git a/src/kio/schema/list_groups/v5/response.py b/src/kio/schema/list_groups/v5/response.py new file mode 100644 index 00000000..acd98399 --- /dev/null +++ b/src/kio/schema/list_groups/v5/response.py @@ -0,0 +1,46 @@ +""" +Generated from ``clients/src/main/resources/common/message/ListGroupsResponse.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.errors import ErrorCode +from kio.schema.response_header.v1.header import ResponseHeader +from kio.schema.types import GroupId +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32Timedelta + + +@dataclass(frozen=True, slots=True, kw_only=True) +class ListedGroup: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(16) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + group_id: GroupId = field(metadata={"kafka_type": "string"}) + """The group ID.""" + protocol_type: str = field(metadata={"kafka_type": "string"}) + """The group protocol type.""" + group_state: str = field(metadata={"kafka_type": "string"}) + """The group state name.""" + group_type: str = field(metadata={"kafka_type": "string"}) + """The group type name.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class ListGroupsResponse: + __type__: ClassVar = EntityType.response + __version__: ClassVar[i16] = i16(5) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(16) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) + """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" + error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The error code, or 0 if there was no error.""" + groups: tuple[ListedGroup, ...] + """Each group in the response.""" diff --git a/src/kio/schema/list_transactions/v1/__init__.py b/src/kio/schema/list_transactions/v1/__init__.py new file mode 100644 index 00000000..65693907 --- /dev/null +++ b/src/kio/schema/list_transactions/v1/__init__.py @@ -0,0 +1,7 @@ +from .request import ListTransactionsRequest +from .response import ListTransactionsResponse + +__all__ = ( + "ListTransactionsRequest", + "ListTransactionsResponse", +) diff --git a/src/kio/schema/list_transactions/v1/request.py b/src/kio/schema/list_transactions/v1/request.py new file mode 100644 index 00000000..af432905 --- /dev/null +++ b/src/kio/schema/list_transactions/v1/request.py @@ -0,0 +1,32 @@ +""" +Generated from ``clients/src/main/resources/common/message/ListTransactionsRequest.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.request_header.v2.header import RequestHeader +from kio.schema.types import ProducerId +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i64 + + +@dataclass(frozen=True, slots=True, kw_only=True) +class ListTransactionsRequest: + __type__: ClassVar = EntityType.request + __version__: ClassVar[i16] = i16(1) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(66) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + state_filters: tuple[str, ...] = field( + metadata={"kafka_type": "string"}, default=() + ) + """The transaction states to filter by: if empty, all transactions are returned; if non-empty, then only transactions matching one of the filtered states will be returned""" + producer_id_filters: tuple[ProducerId, ...] = field( + metadata={"kafka_type": "int64"}, default=() + ) + """The producerIds to filter by: if empty, all transactions will be returned; if non-empty, only transactions which match one of the filtered producerIds will be returned""" + duration_filter: i64 = field(metadata={"kafka_type": "int64"}, default=i64(-1)) + """Duration (in millis) to filter by: if < 0, all transactions will be returned; otherwise, only transactions running longer than this duration will be returned""" diff --git a/src/kio/schema/list_transactions/v1/response.py b/src/kio/schema/list_transactions/v1/response.py new file mode 100644 index 00000000..be03ea85 --- /dev/null +++ b/src/kio/schema/list_transactions/v1/response.py @@ -0,0 +1,45 @@ +""" +Generated from ``clients/src/main/resources/common/message/ListTransactionsResponse.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.errors import ErrorCode +from kio.schema.response_header.v1.header import ResponseHeader +from kio.schema.types import ProducerId +from kio.schema.types import TransactionalId +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32Timedelta + + +@dataclass(frozen=True, slots=True, kw_only=True) +class TransactionState: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(1) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(66) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + transactional_id: TransactionalId = field(metadata={"kafka_type": "string"}) + producer_id: ProducerId = field(metadata={"kafka_type": "int64"}) + transaction_state: str = field(metadata={"kafka_type": "string"}) + """The current transaction state of the producer""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class ListTransactionsResponse: + __type__: ClassVar = EntityType.response + __version__: ClassVar[i16] = i16(1) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(66) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) + """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" + error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + unknown_state_filters: tuple[str, ...] = field( + metadata={"kafka_type": "string"}, default=() + ) + """Set of state filters provided in the request which were unknown to the transaction coordinator""" + transaction_states: tuple[TransactionState, ...] diff --git a/src/kio/schema/metadata/v0/response.py b/src/kio/schema/metadata/v0/response.py index 2815413f..98d0aaf5 100644 --- a/src/kio/schema/metadata/v0/response.py +++ b/src/kio/schema/metadata/v0/response.py @@ -63,7 +63,7 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" partitions: tuple[MetadataResponsePartition, ...] """Each partition in the topic.""" @@ -76,6 +76,6 @@ class MetadataResponse: __api_key__: ClassVar[i16] = i16(3) __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" topics: tuple[MetadataResponseTopic, ...] """Each topic in the response.""" diff --git a/src/kio/schema/metadata/v1/response.py b/src/kio/schema/metadata/v1/response.py index ce4b88c9..63390fc6 100644 --- a/src/kio/schema/metadata/v1/response.py +++ b/src/kio/schema/metadata/v1/response.py @@ -65,7 +65,7 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -80,7 +80,7 @@ class MetadataResponse: __api_key__: ClassVar[i16] = i16(3) __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" controller_id: BrokerId = field( metadata={"kafka_type": "int32"}, default=BrokerId(-1) ) diff --git a/src/kio/schema/metadata/v10/response.py b/src/kio/schema/metadata/v10/response.py index c6d083fe..82c074a5 100644 --- a/src/kio/schema/metadata/v10/response.py +++ b/src/kio/schema/metadata/v10/response.py @@ -74,9 +74,9 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" topic_id: uuid.UUID | None = field(metadata={"kafka_type": "uuid"}) - """The topic id.""" + """The topic id. Zero for non-existing topics queried by name. This is never zero when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -97,7 +97,7 @@ class MetadataResponse: throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" cluster_id: str | None = field(metadata={"kafka_type": "string"}, default=None) """The cluster ID that responding broker belongs to.""" controller_id: BrokerId = field( diff --git a/src/kio/schema/metadata/v11/response.py b/src/kio/schema/metadata/v11/response.py index ee3d83a9..3bbc8429 100644 --- a/src/kio/schema/metadata/v11/response.py +++ b/src/kio/schema/metadata/v11/response.py @@ -74,9 +74,9 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" topic_id: uuid.UUID | None = field(metadata={"kafka_type": "uuid"}) - """The topic id.""" + """The topic id. Zero for non-existing topics queried by name. This is never zero when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -97,7 +97,7 @@ class MetadataResponse: throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" cluster_id: str | None = field(metadata={"kafka_type": "string"}, default=None) """The cluster ID that responding broker belongs to.""" controller_id: BrokerId = field( diff --git a/src/kio/schema/metadata/v12/response.py b/src/kio/schema/metadata/v12/response.py index 494c21ac..ec1cdbf3 100644 --- a/src/kio/schema/metadata/v12/response.py +++ b/src/kio/schema/metadata/v12/response.py @@ -74,9 +74,9 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName | None = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" topic_id: uuid.UUID | None = field(metadata={"kafka_type": "uuid"}) - """The topic id.""" + """The topic id. Zero for non-existing topics queried by name. This is never zero when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -97,7 +97,7 @@ class MetadataResponse: throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" cluster_id: str | None = field(metadata={"kafka_type": "string"}, default=None) """The cluster ID that responding broker belongs to.""" controller_id: BrokerId = field( diff --git a/src/kio/schema/metadata/v2/response.py b/src/kio/schema/metadata/v2/response.py index 8b5f7082..b8aa5aac 100644 --- a/src/kio/schema/metadata/v2/response.py +++ b/src/kio/schema/metadata/v2/response.py @@ -65,7 +65,7 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -80,7 +80,7 @@ class MetadataResponse: __api_key__: ClassVar[i16] = i16(3) __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" cluster_id: str | None = field(metadata={"kafka_type": "string"}, default=None) """The cluster ID that responding broker belongs to.""" controller_id: BrokerId = field( diff --git a/src/kio/schema/metadata/v3/response.py b/src/kio/schema/metadata/v3/response.py index 64a85a68..9a6710fb 100644 --- a/src/kio/schema/metadata/v3/response.py +++ b/src/kio/schema/metadata/v3/response.py @@ -66,7 +66,7 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -83,7 +83,7 @@ class MetadataResponse: throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" cluster_id: str | None = field(metadata={"kafka_type": "string"}, default=None) """The cluster ID that responding broker belongs to.""" controller_id: BrokerId = field( diff --git a/src/kio/schema/metadata/v4/response.py b/src/kio/schema/metadata/v4/response.py index 86bc5b25..854e1ba8 100644 --- a/src/kio/schema/metadata/v4/response.py +++ b/src/kio/schema/metadata/v4/response.py @@ -66,7 +66,7 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -83,7 +83,7 @@ class MetadataResponse: throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" cluster_id: str | None = field(metadata={"kafka_type": "string"}, default=None) """The cluster ID that responding broker belongs to.""" controller_id: BrokerId = field( diff --git a/src/kio/schema/metadata/v5/response.py b/src/kio/schema/metadata/v5/response.py index 0d9b9b2b..cf79d821 100644 --- a/src/kio/schema/metadata/v5/response.py +++ b/src/kio/schema/metadata/v5/response.py @@ -70,7 +70,7 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -87,7 +87,7 @@ class MetadataResponse: throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" cluster_id: str | None = field(metadata={"kafka_type": "string"}, default=None) """The cluster ID that responding broker belongs to.""" controller_id: BrokerId = field( diff --git a/src/kio/schema/metadata/v6/response.py b/src/kio/schema/metadata/v6/response.py index 4cd15724..c4ed99e3 100644 --- a/src/kio/schema/metadata/v6/response.py +++ b/src/kio/schema/metadata/v6/response.py @@ -70,7 +70,7 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -87,7 +87,7 @@ class MetadataResponse: throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" cluster_id: str | None = field(metadata={"kafka_type": "string"}, default=None) """The cluster ID that responding broker belongs to.""" controller_id: BrokerId = field( diff --git a/src/kio/schema/metadata/v7/response.py b/src/kio/schema/metadata/v7/response.py index 60665c33..236b39fa 100644 --- a/src/kio/schema/metadata/v7/response.py +++ b/src/kio/schema/metadata/v7/response.py @@ -72,7 +72,7 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -89,7 +89,7 @@ class MetadataResponse: throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" cluster_id: str | None = field(metadata={"kafka_type": "string"}, default=None) """The cluster ID that responding broker belongs to.""" controller_id: BrokerId = field( diff --git a/src/kio/schema/metadata/v8/response.py b/src/kio/schema/metadata/v8/response.py index f56f8421..a8ea6f9c 100644 --- a/src/kio/schema/metadata/v8/response.py +++ b/src/kio/schema/metadata/v8/response.py @@ -72,7 +72,7 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -93,7 +93,7 @@ class MetadataResponse: throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" cluster_id: str | None = field(metadata={"kafka_type": "string"}, default=None) """The cluster ID that responding broker belongs to.""" controller_id: BrokerId = field( diff --git a/src/kio/schema/metadata/v9/response.py b/src/kio/schema/metadata/v9/response.py index 51a0b7d7..5d291bbf 100644 --- a/src/kio/schema/metadata/v9/response.py +++ b/src/kio/schema/metadata/v9/response.py @@ -72,7 +72,7 @@ class MetadataResponseTopic: error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) """The topic error, or 0 if there was no error.""" name: TopicName = field(metadata={"kafka_type": "string"}) - """The topic name.""" + """The topic name. Null for non-existing topics queried by ID. This is never null when ErrorCode is zero. One of Name and TopicId is always populated.""" is_internal: bool = field(metadata={"kafka_type": "bool"}, default=False) """True if the topic is internal.""" partitions: tuple[MetadataResponsePartition, ...] @@ -93,7 +93,7 @@ class MetadataResponse: throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" brokers: tuple[MetadataResponseBroker, ...] - """Each broker in the response.""" + """A list of brokers present in the cluster.""" cluster_id: str | None = field(metadata={"kafka_type": "string"}, default=None) """The cluster ID that responding broker belongs to.""" controller_id: BrokerId = field( diff --git a/src/kio/schema/produce/v11/__init__.py b/src/kio/schema/produce/v11/__init__.py new file mode 100644 index 00000000..dc429be3 --- /dev/null +++ b/src/kio/schema/produce/v11/__init__.py @@ -0,0 +1,7 @@ +from .request import ProduceRequest +from .response import ProduceResponse + +__all__ = ( + "ProduceRequest", + "ProduceResponse", +) diff --git a/src/kio/schema/produce/v11/request.py b/src/kio/schema/produce/v11/request.py new file mode 100644 index 00000000..c0ea7773 --- /dev/null +++ b/src/kio/schema/produce/v11/request.py @@ -0,0 +1,61 @@ +""" +Generated from ``clients/src/main/resources/common/message/ProduceRequest.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.request_header.v2.header import RequestHeader +from kio.schema.types import TopicName +from kio.schema.types import TransactionalId +from kio.static.constants import EntityType +from kio.static.primitive import Records +from kio.static.primitive import i16 +from kio.static.primitive import i32 +from kio.static.primitive import i32Timedelta + + +@dataclass(frozen=True, slots=True, kw_only=True) +class PartitionProduceData: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(11) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(0) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + index: i32 = field(metadata={"kafka_type": "int32"}) + """The partition index.""" + records: Records | None = field(metadata={"kafka_type": "records"}) + """The record data to be produced.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class TopicProduceData: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(11) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(0) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + name: TopicName = field(metadata={"kafka_type": "string"}) + """The topic name.""" + partition_data: tuple[PartitionProduceData, ...] + """Each partition to produce to.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class ProduceRequest: + __type__: ClassVar = EntityType.request + __version__: ClassVar[i16] = i16(11) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(0) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + transactional_id: TransactionalId | None = field( + metadata={"kafka_type": "string"}, default=None + ) + """The transactional ID, or null if the producer is not transactional.""" + acks: i16 = field(metadata={"kafka_type": "int16"}) + """The number of acknowledgments the producer requires the leader to have received before considering a request complete. Allowed values: 0 for no acknowledgments, 1 for only the leader and -1 for the full ISR.""" + timeout: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) + """The timeout to await a response in milliseconds.""" + topic_data: tuple[TopicProduceData, ...] + """Each topic to produce to.""" diff --git a/src/kio/schema/produce/v11/response.py b/src/kio/schema/produce/v11/response.py new file mode 100644 index 00000000..46e22668 --- /dev/null +++ b/src/kio/schema/produce/v11/response.py @@ -0,0 +1,124 @@ +""" +Generated from ``clients/src/main/resources/common/message/ProduceResponse.json``. +""" + +import datetime + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.errors import ErrorCode +from kio.schema.response_header.v1.header import ResponseHeader +from kio.schema.types import BrokerId +from kio.schema.types import TopicName +from kio.static.constants import EntityType +from kio.static.primitive import TZAware +from kio.static.primitive import i16 +from kio.static.primitive import i32 +from kio.static.primitive import i32Timedelta +from kio.static.primitive import i64 + + +@dataclass(frozen=True, slots=True, kw_only=True) +class BatchIndexAndErrorMessage: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(11) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(0) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + batch_index: i32 = field(metadata={"kafka_type": "int32"}) + """The batch index of the record that cause the batch to be dropped""" + batch_index_error_message: str | None = field( + metadata={"kafka_type": "string"}, default=None + ) + """The error message of the record that caused the batch to be dropped""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class LeaderIdAndEpoch: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(11) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(0) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + leader_id: BrokerId = field(metadata={"kafka_type": "int32"}, default=BrokerId(-1)) + """The ID of the current leader or -1 if the leader is unknown.""" + leader_epoch: i32 = field(metadata={"kafka_type": "int32"}, default=i32(-1)) + """The latest known leader epoch""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class PartitionProduceResponse: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(11) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(0) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + index: i32 = field(metadata={"kafka_type": "int32"}) + """The partition index.""" + error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The error code, or 0 if there was no error.""" + base_offset: i64 = field(metadata={"kafka_type": "int64"}) + """The base offset.""" + log_append_time: TZAware | None = field( + metadata={"kafka_type": "datetime_i64"}, default=None + ) + """The timestamp returned by broker after appending the messages. If CreateTime is used for the topic, the timestamp will be -1. If LogAppendTime is used for the topic, the timestamp will be the broker local time when the messages are appended.""" + log_start_offset: i64 = field(metadata={"kafka_type": "int64"}, default=i64(-1)) + """The log start offset.""" + record_errors: tuple[BatchIndexAndErrorMessage, ...] + """The batch indices of records that caused the batch to be dropped""" + error_message: str | None = field(metadata={"kafka_type": "string"}, default=None) + """The global error message summarizing the common root cause of the records that caused the batch to be dropped""" + current_leader: LeaderIdAndEpoch = field( + metadata={"tag": 0}, default=LeaderIdAndEpoch() + ) + + +@dataclass(frozen=True, slots=True, kw_only=True) +class TopicProduceResponse: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(11) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(0) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + name: TopicName = field(metadata={"kafka_type": "string"}) + """The topic name""" + partition_responses: tuple[PartitionProduceResponse, ...] + """Each partition that we produced to within the topic.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class NodeEndpoint: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(11) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(0) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + node_id: BrokerId = field(metadata={"kafka_type": "int32"}) + """The ID of the associated node.""" + host: str = field(metadata={"kafka_type": "string"}) + """The node's hostname.""" + port: i32 = field(metadata={"kafka_type": "int32"}) + """The node's port.""" + rack: str | None = field(metadata={"kafka_type": "string"}, default=None) + """The rack of the node, or null if it has not been assigned to a rack.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class ProduceResponse: + __type__: ClassVar = EntityType.response + __version__: ClassVar[i16] = i16(11) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(0) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + responses: tuple[TopicProduceResponse, ...] + """Each produce response""" + throttle_time: i32Timedelta = field( + metadata={"kafka_type": "timedelta_i32"}, + default=i32Timedelta.parse(datetime.timedelta(milliseconds=0)), + ) + """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" + node_endpoints: tuple[NodeEndpoint, ...] = field(metadata={"tag": 0}, default=()) + """Endpoints for all current-leaders enumerated in PartitionProduceResponses, with errors NOT_LEADER_OR_FOLLOWER.""" diff --git a/src/kio/schema/txn_offset_commit/v4/__init__.py b/src/kio/schema/txn_offset_commit/v4/__init__.py new file mode 100644 index 00000000..069da744 --- /dev/null +++ b/src/kio/schema/txn_offset_commit/v4/__init__.py @@ -0,0 +1,7 @@ +from .request import TxnOffsetCommitRequest +from .response import TxnOffsetCommitResponse + +__all__ = ( + "TxnOffsetCommitRequest", + "TxnOffsetCommitResponse", +) diff --git a/src/kio/schema/txn_offset_commit/v4/request.py b/src/kio/schema/txn_offset_commit/v4/request.py new file mode 100644 index 00000000..ba879f80 --- /dev/null +++ b/src/kio/schema/txn_offset_commit/v4/request.py @@ -0,0 +1,76 @@ +""" +Generated from ``clients/src/main/resources/common/message/TxnOffsetCommitRequest.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.request_header.v2.header import RequestHeader +from kio.schema.types import GroupId +from kio.schema.types import ProducerId +from kio.schema.types import TopicName +from kio.schema.types import TransactionalId +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32 +from kio.static.primitive import i64 + + +@dataclass(frozen=True, slots=True, kw_only=True) +class TxnOffsetCommitRequestPartition: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(4) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(28) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + partition_index: i32 = field(metadata={"kafka_type": "int32"}) + """The index of the partition within the topic.""" + committed_offset: i64 = field(metadata={"kafka_type": "int64"}) + """The message offset to be committed.""" + committed_leader_epoch: i32 = field( + metadata={"kafka_type": "int32"}, default=i32(-1) + ) + """The leader epoch of the last consumed record.""" + committed_metadata: str | None = field(metadata={"kafka_type": "string"}) + """Any associated metadata the client wants to keep.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class TxnOffsetCommitRequestTopic: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(4) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(28) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + name: TopicName = field(metadata={"kafka_type": "string"}) + """The topic name.""" + partitions: tuple[TxnOffsetCommitRequestPartition, ...] + """The partitions inside the topic that we want to commit offsets for.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class TxnOffsetCommitRequest: + __type__: ClassVar = EntityType.request + __version__: ClassVar[i16] = i16(4) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(28) + __header_schema__: ClassVar[type[RequestHeader]] = RequestHeader + transactional_id: TransactionalId = field(metadata={"kafka_type": "string"}) + """The ID of the transaction.""" + group_id: GroupId = field(metadata={"kafka_type": "string"}) + """The ID of the group.""" + producer_id: ProducerId = field(metadata={"kafka_type": "int64"}) + """The current producer ID in use by the transactional ID.""" + producer_epoch: i16 = field(metadata={"kafka_type": "int16"}) + """The current epoch associated with the producer ID.""" + generation_id: i32 = field(metadata={"kafka_type": "int32"}, default=i32(-1)) + """The generation of the consumer.""" + member_id: str = field(metadata={"kafka_type": "string"}, default="") + """The member ID assigned by the group coordinator.""" + group_instance_id: str | None = field( + metadata={"kafka_type": "string"}, default=None + ) + """The unique identifier of the consumer instance provided by end user.""" + topics: tuple[TxnOffsetCommitRequestTopic, ...] + """Each topic that we want to commit offsets for.""" diff --git a/src/kio/schema/txn_offset_commit/v4/response.py b/src/kio/schema/txn_offset_commit/v4/response.py new file mode 100644 index 00000000..63b14544 --- /dev/null +++ b/src/kio/schema/txn_offset_commit/v4/response.py @@ -0,0 +1,54 @@ +""" +Generated from ``clients/src/main/resources/common/message/TxnOffsetCommitResponse.json``. +""" + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.errors import ErrorCode +from kio.schema.response_header.v1.header import ResponseHeader +from kio.schema.types import TopicName +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import i32 +from kio.static.primitive import i32Timedelta + + +@dataclass(frozen=True, slots=True, kw_only=True) +class TxnOffsetCommitResponsePartition: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(4) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(28) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + partition_index: i32 = field(metadata={"kafka_type": "int32"}) + """The partition index.""" + error_code: ErrorCode = field(metadata={"kafka_type": "error_code"}) + """The error code, or 0 if there was no error.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class TxnOffsetCommitResponseTopic: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(4) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(28) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + name: TopicName = field(metadata={"kafka_type": "string"}) + """The topic name.""" + partitions: tuple[TxnOffsetCommitResponsePartition, ...] + """The responses for each partition in the topic.""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class TxnOffsetCommitResponse: + __type__: ClassVar = EntityType.response + __version__: ClassVar[i16] = i16(4) + __flexible__: ClassVar[bool] = True + __api_key__: ClassVar[i16] = i16(28) + __header_schema__: ClassVar[type[ResponseHeader]] = ResponseHeader + throttle_time: i32Timedelta = field(metadata={"kafka_type": "timedelta_i32"}) + """The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.""" + topics: tuple[TxnOffsetCommitResponseTopic, ...] + """The responses for each topic.""" diff --git a/src/kio/schema/voters_record/__init__.py b/src/kio/schema/voters_record/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/kio/schema/voters_record/v0/__init__.py b/src/kio/schema/voters_record/v0/__init__.py new file mode 100644 index 00000000..ec8997c9 --- /dev/null +++ b/src/kio/schema/voters_record/v0/__init__.py @@ -0,0 +1,3 @@ +from .data import VotersRecord + +__all__ = ("VotersRecord",) diff --git a/src/kio/schema/voters_record/v0/data.py b/src/kio/schema/voters_record/v0/data.py new file mode 100644 index 00000000..c35395c6 --- /dev/null +++ b/src/kio/schema/voters_record/v0/data.py @@ -0,0 +1,63 @@ +""" +Generated from ``clients/src/main/resources/common/message/VotersRecord.json``. +""" + +import uuid + +from dataclasses import dataclass +from dataclasses import field +from typing import ClassVar + +from kio.schema.types import BrokerId +from kio.static.constants import EntityType +from kio.static.primitive import i16 +from kio.static.primitive import u16 + + +@dataclass(frozen=True, slots=True, kw_only=True) +class Endpoint: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + name: str = field(metadata={"kafka_type": "string"}) + """The name of the endpoint""" + host: str = field(metadata={"kafka_type": "string"}) + """The hostname""" + port: u16 = field(metadata={"kafka_type": "uint16"}) + """The port""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class KRaftVersionFeature: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + min_supported_version: i16 = field(metadata={"kafka_type": "int16"}) + """The minimum supported KRaft protocol version""" + max_supported_version: i16 = field(metadata={"kafka_type": "int16"}) + """The maximum supported KRaft protocol version""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class Voter: + __type__: ClassVar = EntityType.nested + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + voter_id: BrokerId = field(metadata={"kafka_type": "int32"}) + """The replica id of the voter in the topic partition""" + voter_directory_id: uuid.UUID | None = field(metadata={"kafka_type": "uuid"}) + """The directory id of the voter in the topic partition""" + endpoints: tuple[Endpoint, ...] + """The endpoint that can be used to communicate with the voter""" + k_raft_version_feature: KRaftVersionFeature + """The range of versions of the protocol that the replica supports""" + + +@dataclass(frozen=True, slots=True, kw_only=True) +class VotersRecord: + __type__: ClassVar = EntityType.data + __version__: ClassVar[i16] = i16(0) + __flexible__: ClassVar[bool] = True + version: i16 = field(metadata={"kafka_type": "int16"}) + """The version of the voters record""" + voters: tuple[Voter, ...] diff --git a/tests/generated/test_add_offsets_to_txn_v4_request.py b/tests/generated/test_add_offsets_to_txn_v4_request.py new file mode 100644 index 00000000..12717391 --- /dev/null +++ b/tests/generated/test_add_offsets_to_txn_v4_request.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.add_offsets_to_txn.v4.request import AddOffsetsToTxnRequest +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_add_offsets_to_txn_request: Final = entity_reader(AddOffsetsToTxnRequest) + + +@pytest.mark.roundtrip +@given(from_type(AddOffsetsToTxnRequest)) +def test_add_offsets_to_txn_request_roundtrip(instance: AddOffsetsToTxnRequest) -> None: + writer = entity_writer(AddOffsetsToTxnRequest) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_add_offsets_to_txn_request(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(AddOffsetsToTxnRequest)) +def test_add_offsets_to_txn_request_java( + instance: AddOffsetsToTxnRequest, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_add_offsets_to_txn_v4_response.py b/tests/generated/test_add_offsets_to_txn_v4_response.py new file mode 100644 index 00000000..ec424583 --- /dev/null +++ b/tests/generated/test_add_offsets_to_txn_v4_response.py @@ -0,0 +1,37 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.add_offsets_to_txn.v4.response import AddOffsetsToTxnResponse +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_add_offsets_to_txn_response: Final = entity_reader(AddOffsetsToTxnResponse) + + +@pytest.mark.roundtrip +@given(from_type(AddOffsetsToTxnResponse)) +def test_add_offsets_to_txn_response_roundtrip( + instance: AddOffsetsToTxnResponse, +) -> None: + writer = entity_writer(AddOffsetsToTxnResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_add_offsets_to_txn_response(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(AddOffsetsToTxnResponse)) +def test_add_offsets_to_txn_response_java( + instance: AddOffsetsToTxnResponse, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_add_partitions_to_txn_v5_request.py b/tests/generated/test_add_partitions_to_txn_v5_request.py new file mode 100644 index 00000000..0cd31b41 --- /dev/null +++ b/tests/generated/test_add_partitions_to_txn_v5_request.py @@ -0,0 +1,73 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.add_partitions_to_txn.v5.request import AddPartitionsToTxnRequest +from kio.schema.add_partitions_to_txn.v5.request import AddPartitionsToTxnTopic +from kio.schema.add_partitions_to_txn.v5.request import AddPartitionsToTxnTransaction +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_add_partitions_to_txn_topic: Final = entity_reader(AddPartitionsToTxnTopic) + + +@pytest.mark.roundtrip +@given(from_type(AddPartitionsToTxnTopic)) +def test_add_partitions_to_txn_topic_roundtrip( + instance: AddPartitionsToTxnTopic, +) -> None: + writer = entity_writer(AddPartitionsToTxnTopic) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_add_partitions_to_txn_topic(buffer) + assert instance == result + + +read_add_partitions_to_txn_transaction: Final = entity_reader( + AddPartitionsToTxnTransaction +) + + +@pytest.mark.roundtrip +@given(from_type(AddPartitionsToTxnTransaction)) +def test_add_partitions_to_txn_transaction_roundtrip( + instance: AddPartitionsToTxnTransaction, +) -> None: + writer = entity_writer(AddPartitionsToTxnTransaction) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_add_partitions_to_txn_transaction(buffer) + assert instance == result + + +read_add_partitions_to_txn_request: Final = entity_reader(AddPartitionsToTxnRequest) + + +@pytest.mark.roundtrip +@given(from_type(AddPartitionsToTxnRequest)) +def test_add_partitions_to_txn_request_roundtrip( + instance: AddPartitionsToTxnRequest, +) -> None: + writer = entity_writer(AddPartitionsToTxnRequest) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_add_partitions_to_txn_request(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(AddPartitionsToTxnRequest)) +def test_add_partitions_to_txn_request_java( + instance: AddPartitionsToTxnRequest, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_add_partitions_to_txn_v5_response.py b/tests/generated/test_add_partitions_to_txn_v5_response.py new file mode 100644 index 00000000..f3b94815 --- /dev/null +++ b/tests/generated/test_add_partitions_to_txn_v5_response.py @@ -0,0 +1,94 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.add_partitions_to_txn.v5.response import ( + AddPartitionsToTxnPartitionResult, +) +from kio.schema.add_partitions_to_txn.v5.response import AddPartitionsToTxnResponse +from kio.schema.add_partitions_to_txn.v5.response import AddPartitionsToTxnResult +from kio.schema.add_partitions_to_txn.v5.response import AddPartitionsToTxnTopicResult +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_add_partitions_to_txn_partition_result: Final = entity_reader( + AddPartitionsToTxnPartitionResult +) + + +@pytest.mark.roundtrip +@given(from_type(AddPartitionsToTxnPartitionResult)) +def test_add_partitions_to_txn_partition_result_roundtrip( + instance: AddPartitionsToTxnPartitionResult, +) -> None: + writer = entity_writer(AddPartitionsToTxnPartitionResult) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_add_partitions_to_txn_partition_result(buffer) + assert instance == result + + +read_add_partitions_to_txn_topic_result: Final = entity_reader( + AddPartitionsToTxnTopicResult +) + + +@pytest.mark.roundtrip +@given(from_type(AddPartitionsToTxnTopicResult)) +def test_add_partitions_to_txn_topic_result_roundtrip( + instance: AddPartitionsToTxnTopicResult, +) -> None: + writer = entity_writer(AddPartitionsToTxnTopicResult) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_add_partitions_to_txn_topic_result(buffer) + assert instance == result + + +read_add_partitions_to_txn_result: Final = entity_reader(AddPartitionsToTxnResult) + + +@pytest.mark.roundtrip +@given(from_type(AddPartitionsToTxnResult)) +def test_add_partitions_to_txn_result_roundtrip( + instance: AddPartitionsToTxnResult, +) -> None: + writer = entity_writer(AddPartitionsToTxnResult) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_add_partitions_to_txn_result(buffer) + assert instance == result + + +read_add_partitions_to_txn_response: Final = entity_reader(AddPartitionsToTxnResponse) + + +@pytest.mark.roundtrip +@given(from_type(AddPartitionsToTxnResponse)) +def test_add_partitions_to_txn_response_roundtrip( + instance: AddPartitionsToTxnResponse, +) -> None: + writer = entity_writer(AddPartitionsToTxnResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_add_partitions_to_txn_response(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(AddPartitionsToTxnResponse)) +def test_add_partitions_to_txn_response_java( + instance: AddPartitionsToTxnResponse, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_describe_topic_partitions_v0_request.py b/tests/generated/test_describe_topic_partitions_v0_request.py new file mode 100644 index 00000000..50685375 --- /dev/null +++ b/tests/generated/test_describe_topic_partitions_v0_request.py @@ -0,0 +1,71 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.describe_topic_partitions.v0.request import Cursor +from kio.schema.describe_topic_partitions.v0.request import ( + DescribeTopicPartitionsRequest, +) +from kio.schema.describe_topic_partitions.v0.request import TopicRequest +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_topic_request: Final = entity_reader(TopicRequest) + + +@pytest.mark.roundtrip +@given(from_type(TopicRequest)) +def test_topic_request_roundtrip(instance: TopicRequest) -> None: + writer = entity_writer(TopicRequest) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_topic_request(buffer) + assert instance == result + + +read_cursor: Final = entity_reader(Cursor) + + +@pytest.mark.roundtrip +@given(from_type(Cursor)) +def test_cursor_roundtrip(instance: Cursor) -> None: + writer = entity_writer(Cursor) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_cursor(buffer) + assert instance == result + + +read_describe_topic_partitions_request: Final = entity_reader( + DescribeTopicPartitionsRequest +) + + +@pytest.mark.roundtrip +@given(from_type(DescribeTopicPartitionsRequest)) +def test_describe_topic_partitions_request_roundtrip( + instance: DescribeTopicPartitionsRequest, +) -> None: + writer = entity_writer(DescribeTopicPartitionsRequest) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_describe_topic_partitions_request(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(DescribeTopicPartitionsRequest)) +def test_describe_topic_partitions_request_java( + instance: DescribeTopicPartitionsRequest, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_describe_topic_partitions_v0_response.py b/tests/generated/test_describe_topic_partitions_v0_response.py new file mode 100644 index 00000000..7f19cf89 --- /dev/null +++ b/tests/generated/test_describe_topic_partitions_v0_response.py @@ -0,0 +1,98 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.describe_topic_partitions.v0.response import Cursor +from kio.schema.describe_topic_partitions.v0.response import ( + DescribeTopicPartitionsResponse, +) +from kio.schema.describe_topic_partitions.v0.response import ( + DescribeTopicPartitionsResponsePartition, +) +from kio.schema.describe_topic_partitions.v0.response import ( + DescribeTopicPartitionsResponseTopic, +) +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_describe_topic_partitions_response_partition: Final = entity_reader( + DescribeTopicPartitionsResponsePartition +) + + +@pytest.mark.roundtrip +@given(from_type(DescribeTopicPartitionsResponsePartition)) +def test_describe_topic_partitions_response_partition_roundtrip( + instance: DescribeTopicPartitionsResponsePartition, +) -> None: + writer = entity_writer(DescribeTopicPartitionsResponsePartition) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_describe_topic_partitions_response_partition(buffer) + assert instance == result + + +read_describe_topic_partitions_response_topic: Final = entity_reader( + DescribeTopicPartitionsResponseTopic +) + + +@pytest.mark.roundtrip +@given(from_type(DescribeTopicPartitionsResponseTopic)) +def test_describe_topic_partitions_response_topic_roundtrip( + instance: DescribeTopicPartitionsResponseTopic, +) -> None: + writer = entity_writer(DescribeTopicPartitionsResponseTopic) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_describe_topic_partitions_response_topic(buffer) + assert instance == result + + +read_cursor: Final = entity_reader(Cursor) + + +@pytest.mark.roundtrip +@given(from_type(Cursor)) +def test_cursor_roundtrip(instance: Cursor) -> None: + writer = entity_writer(Cursor) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_cursor(buffer) + assert instance == result + + +read_describe_topic_partitions_response: Final = entity_reader( + DescribeTopicPartitionsResponse +) + + +@pytest.mark.roundtrip +@given(from_type(DescribeTopicPartitionsResponse)) +def test_describe_topic_partitions_response_roundtrip( + instance: DescribeTopicPartitionsResponse, +) -> None: + writer = entity_writer(DescribeTopicPartitionsResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_describe_topic_partitions_response(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(DescribeTopicPartitionsResponse)) +def test_describe_topic_partitions_response_java( + instance: DescribeTopicPartitionsResponse, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_end_txn_v4_request.py b/tests/generated/test_end_txn_v4_request.py new file mode 100644 index 00000000..9d5438ce --- /dev/null +++ b/tests/generated/test_end_txn_v4_request.py @@ -0,0 +1,33 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.end_txn.v4.request import EndTxnRequest +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_end_txn_request: Final = entity_reader(EndTxnRequest) + + +@pytest.mark.roundtrip +@given(from_type(EndTxnRequest)) +def test_end_txn_request_roundtrip(instance: EndTxnRequest) -> None: + writer = entity_writer(EndTxnRequest) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_end_txn_request(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(EndTxnRequest)) +def test_end_txn_request_java(instance: EndTxnRequest, java_tester: JavaTester) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_end_txn_v4_response.py b/tests/generated/test_end_txn_v4_response.py new file mode 100644 index 00000000..ad3eff3d --- /dev/null +++ b/tests/generated/test_end_txn_v4_response.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.end_txn.v4.response import EndTxnResponse +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_end_txn_response: Final = entity_reader(EndTxnResponse) + + +@pytest.mark.roundtrip +@given(from_type(EndTxnResponse)) +def test_end_txn_response_roundtrip(instance: EndTxnResponse) -> None: + writer = entity_writer(EndTxnResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_end_txn_response(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(EndTxnResponse)) +def test_end_txn_response_java( + instance: EndTxnResponse, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_find_coordinator_v5_request.py b/tests/generated/test_find_coordinator_v5_request.py new file mode 100644 index 00000000..4b3c97ff --- /dev/null +++ b/tests/generated/test_find_coordinator_v5_request.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.find_coordinator.v5.request import FindCoordinatorRequest +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_find_coordinator_request: Final = entity_reader(FindCoordinatorRequest) + + +@pytest.mark.roundtrip +@given(from_type(FindCoordinatorRequest)) +def test_find_coordinator_request_roundtrip(instance: FindCoordinatorRequest) -> None: + writer = entity_writer(FindCoordinatorRequest) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_find_coordinator_request(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(FindCoordinatorRequest)) +def test_find_coordinator_request_java( + instance: FindCoordinatorRequest, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_find_coordinator_v5_response.py b/tests/generated/test_find_coordinator_v5_response.py new file mode 100644 index 00000000..665dac8e --- /dev/null +++ b/tests/generated/test_find_coordinator_v5_response.py @@ -0,0 +1,50 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.find_coordinator.v5.response import Coordinator +from kio.schema.find_coordinator.v5.response import FindCoordinatorResponse +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_coordinator: Final = entity_reader(Coordinator) + + +@pytest.mark.roundtrip +@given(from_type(Coordinator)) +def test_coordinator_roundtrip(instance: Coordinator) -> None: + writer = entity_writer(Coordinator) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_coordinator(buffer) + assert instance == result + + +read_find_coordinator_response: Final = entity_reader(FindCoordinatorResponse) + + +@pytest.mark.roundtrip +@given(from_type(FindCoordinatorResponse)) +def test_find_coordinator_response_roundtrip(instance: FindCoordinatorResponse) -> None: + writer = entity_writer(FindCoordinatorResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_find_coordinator_response(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(FindCoordinatorResponse)) +def test_find_coordinator_response_java( + instance: FindCoordinatorResponse, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_init_producer_id_v5_request.py b/tests/generated/test_init_producer_id_v5_request.py new file mode 100644 index 00000000..3c484615 --- /dev/null +++ b/tests/generated/test_init_producer_id_v5_request.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.init_producer_id.v5.request import InitProducerIdRequest +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_init_producer_id_request: Final = entity_reader(InitProducerIdRequest) + + +@pytest.mark.roundtrip +@given(from_type(InitProducerIdRequest)) +def test_init_producer_id_request_roundtrip(instance: InitProducerIdRequest) -> None: + writer = entity_writer(InitProducerIdRequest) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_init_producer_id_request(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(InitProducerIdRequest)) +def test_init_producer_id_request_java( + instance: InitProducerIdRequest, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_init_producer_id_v5_response.py b/tests/generated/test_init_producer_id_v5_response.py new file mode 100644 index 00000000..dc4de5e0 --- /dev/null +++ b/tests/generated/test_init_producer_id_v5_response.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.init_producer_id.v5.response import InitProducerIdResponse +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_init_producer_id_response: Final = entity_reader(InitProducerIdResponse) + + +@pytest.mark.roundtrip +@given(from_type(InitProducerIdResponse)) +def test_init_producer_id_response_roundtrip(instance: InitProducerIdResponse) -> None: + writer = entity_writer(InitProducerIdResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_init_producer_id_response(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(InitProducerIdResponse)) +def test_init_producer_id_response_java( + instance: InitProducerIdResponse, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_k_raft_version_record_v0_data.py b/tests/generated/test_k_raft_version_record_v0_data.py new file mode 100644 index 00000000..d8e88ee2 --- /dev/null +++ b/tests/generated/test_k_raft_version_record_v0_data.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.k_raft_version_record.v0.data import KRaftVersionRecord +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_k_raft_version_record: Final = entity_reader(KRaftVersionRecord) + + +@pytest.mark.roundtrip +@given(from_type(KRaftVersionRecord)) +def test_k_raft_version_record_roundtrip(instance: KRaftVersionRecord) -> None: + writer = entity_writer(KRaftVersionRecord) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_k_raft_version_record(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(KRaftVersionRecord)) +def test_k_raft_version_record_java( + instance: KRaftVersionRecord, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_list_groups_v5_request.py b/tests/generated/test_list_groups_v5_request.py new file mode 100644 index 00000000..974aed11 --- /dev/null +++ b/tests/generated/test_list_groups_v5_request.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.list_groups.v5.request import ListGroupsRequest +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_list_groups_request: Final = entity_reader(ListGroupsRequest) + + +@pytest.mark.roundtrip +@given(from_type(ListGroupsRequest)) +def test_list_groups_request_roundtrip(instance: ListGroupsRequest) -> None: + writer = entity_writer(ListGroupsRequest) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_list_groups_request(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(ListGroupsRequest)) +def test_list_groups_request_java( + instance: ListGroupsRequest, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_list_groups_v5_response.py b/tests/generated/test_list_groups_v5_response.py new file mode 100644 index 00000000..e2de841c --- /dev/null +++ b/tests/generated/test_list_groups_v5_response.py @@ -0,0 +1,50 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.list_groups.v5.response import ListedGroup +from kio.schema.list_groups.v5.response import ListGroupsResponse +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_listed_group: Final = entity_reader(ListedGroup) + + +@pytest.mark.roundtrip +@given(from_type(ListedGroup)) +def test_listed_group_roundtrip(instance: ListedGroup) -> None: + writer = entity_writer(ListedGroup) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_listed_group(buffer) + assert instance == result + + +read_list_groups_response: Final = entity_reader(ListGroupsResponse) + + +@pytest.mark.roundtrip +@given(from_type(ListGroupsResponse)) +def test_list_groups_response_roundtrip(instance: ListGroupsResponse) -> None: + writer = entity_writer(ListGroupsResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_list_groups_response(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(ListGroupsResponse)) +def test_list_groups_response_java( + instance: ListGroupsResponse, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_list_transactions_v1_request.py b/tests/generated/test_list_transactions_v1_request.py new file mode 100644 index 00000000..c966b372 --- /dev/null +++ b/tests/generated/test_list_transactions_v1_request.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.list_transactions.v1.request import ListTransactionsRequest +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_list_transactions_request: Final = entity_reader(ListTransactionsRequest) + + +@pytest.mark.roundtrip +@given(from_type(ListTransactionsRequest)) +def test_list_transactions_request_roundtrip(instance: ListTransactionsRequest) -> None: + writer = entity_writer(ListTransactionsRequest) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_list_transactions_request(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(ListTransactionsRequest)) +def test_list_transactions_request_java( + instance: ListTransactionsRequest, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_list_transactions_v1_response.py b/tests/generated/test_list_transactions_v1_response.py new file mode 100644 index 00000000..c58bfb42 --- /dev/null +++ b/tests/generated/test_list_transactions_v1_response.py @@ -0,0 +1,52 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.list_transactions.v1.response import ListTransactionsResponse +from kio.schema.list_transactions.v1.response import TransactionState +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_transaction_state: Final = entity_reader(TransactionState) + + +@pytest.mark.roundtrip +@given(from_type(TransactionState)) +def test_transaction_state_roundtrip(instance: TransactionState) -> None: + writer = entity_writer(TransactionState) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_transaction_state(buffer) + assert instance == result + + +read_list_transactions_response: Final = entity_reader(ListTransactionsResponse) + + +@pytest.mark.roundtrip +@given(from_type(ListTransactionsResponse)) +def test_list_transactions_response_roundtrip( + instance: ListTransactionsResponse, +) -> None: + writer = entity_writer(ListTransactionsResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_list_transactions_response(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(ListTransactionsResponse)) +def test_list_transactions_response_java( + instance: ListTransactionsResponse, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_produce_v11_request.py b/tests/generated/test_produce_v11_request.py new file mode 100644 index 00000000..94b75f6b --- /dev/null +++ b/tests/generated/test_produce_v11_request.py @@ -0,0 +1,65 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.produce.v11.request import PartitionProduceData +from kio.schema.produce.v11.request import ProduceRequest +from kio.schema.produce.v11.request import TopicProduceData +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_partition_produce_data: Final = entity_reader(PartitionProduceData) + + +@pytest.mark.roundtrip +@given(from_type(PartitionProduceData)) +def test_partition_produce_data_roundtrip(instance: PartitionProduceData) -> None: + writer = entity_writer(PartitionProduceData) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_partition_produce_data(buffer) + assert instance == result + + +read_topic_produce_data: Final = entity_reader(TopicProduceData) + + +@pytest.mark.roundtrip +@given(from_type(TopicProduceData)) +def test_topic_produce_data_roundtrip(instance: TopicProduceData) -> None: + writer = entity_writer(TopicProduceData) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_topic_produce_data(buffer) + assert instance == result + + +read_produce_request: Final = entity_reader(ProduceRequest) + + +@pytest.mark.roundtrip +@given(from_type(ProduceRequest)) +def test_produce_request_roundtrip(instance: ProduceRequest) -> None: + writer = entity_writer(ProduceRequest) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_produce_request(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(ProduceRequest)) +def test_produce_request_java( + instance: ProduceRequest, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_produce_v11_response.py b/tests/generated/test_produce_v11_response.py new file mode 100644 index 00000000..ac8c1464 --- /dev/null +++ b/tests/generated/test_produce_v11_response.py @@ -0,0 +1,114 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.produce.v11.response import BatchIndexAndErrorMessage +from kio.schema.produce.v11.response import LeaderIdAndEpoch +from kio.schema.produce.v11.response import NodeEndpoint +from kio.schema.produce.v11.response import PartitionProduceResponse +from kio.schema.produce.v11.response import ProduceResponse +from kio.schema.produce.v11.response import TopicProduceResponse +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_batch_index_and_error_message: Final = entity_reader(BatchIndexAndErrorMessage) + + +@pytest.mark.roundtrip +@given(from_type(BatchIndexAndErrorMessage)) +def test_batch_index_and_error_message_roundtrip( + instance: BatchIndexAndErrorMessage, +) -> None: + writer = entity_writer(BatchIndexAndErrorMessage) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_batch_index_and_error_message(buffer) + assert instance == result + + +read_leader_id_and_epoch: Final = entity_reader(LeaderIdAndEpoch) + + +@pytest.mark.roundtrip +@given(from_type(LeaderIdAndEpoch)) +def test_leader_id_and_epoch_roundtrip(instance: LeaderIdAndEpoch) -> None: + writer = entity_writer(LeaderIdAndEpoch) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_leader_id_and_epoch(buffer) + assert instance == result + + +read_partition_produce_response: Final = entity_reader(PartitionProduceResponse) + + +@pytest.mark.roundtrip +@given(from_type(PartitionProduceResponse)) +def test_partition_produce_response_roundtrip( + instance: PartitionProduceResponse, +) -> None: + writer = entity_writer(PartitionProduceResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_partition_produce_response(buffer) + assert instance == result + + +read_topic_produce_response: Final = entity_reader(TopicProduceResponse) + + +@pytest.mark.roundtrip +@given(from_type(TopicProduceResponse)) +def test_topic_produce_response_roundtrip(instance: TopicProduceResponse) -> None: + writer = entity_writer(TopicProduceResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_topic_produce_response(buffer) + assert instance == result + + +read_node_endpoint: Final = entity_reader(NodeEndpoint) + + +@pytest.mark.roundtrip +@given(from_type(NodeEndpoint)) +def test_node_endpoint_roundtrip(instance: NodeEndpoint) -> None: + writer = entity_writer(NodeEndpoint) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_node_endpoint(buffer) + assert instance == result + + +read_produce_response: Final = entity_reader(ProduceResponse) + + +@pytest.mark.roundtrip +@given(from_type(ProduceResponse)) +def test_produce_response_roundtrip(instance: ProduceResponse) -> None: + writer = entity_writer(ProduceResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_produce_response(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(ProduceResponse)) +def test_produce_response_java( + instance: ProduceResponse, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_txn_offset_commit_v4_request.py b/tests/generated/test_txn_offset_commit_v4_request.py new file mode 100644 index 00000000..380e1a3f --- /dev/null +++ b/tests/generated/test_txn_offset_commit_v4_request.py @@ -0,0 +1,71 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.txn_offset_commit.v4.request import TxnOffsetCommitRequest +from kio.schema.txn_offset_commit.v4.request import TxnOffsetCommitRequestPartition +from kio.schema.txn_offset_commit.v4.request import TxnOffsetCommitRequestTopic +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_txn_offset_commit_request_partition: Final = entity_reader( + TxnOffsetCommitRequestPartition +) + + +@pytest.mark.roundtrip +@given(from_type(TxnOffsetCommitRequestPartition)) +def test_txn_offset_commit_request_partition_roundtrip( + instance: TxnOffsetCommitRequestPartition, +) -> None: + writer = entity_writer(TxnOffsetCommitRequestPartition) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_txn_offset_commit_request_partition(buffer) + assert instance == result + + +read_txn_offset_commit_request_topic: Final = entity_reader(TxnOffsetCommitRequestTopic) + + +@pytest.mark.roundtrip +@given(from_type(TxnOffsetCommitRequestTopic)) +def test_txn_offset_commit_request_topic_roundtrip( + instance: TxnOffsetCommitRequestTopic, +) -> None: + writer = entity_writer(TxnOffsetCommitRequestTopic) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_txn_offset_commit_request_topic(buffer) + assert instance == result + + +read_txn_offset_commit_request: Final = entity_reader(TxnOffsetCommitRequest) + + +@pytest.mark.roundtrip +@given(from_type(TxnOffsetCommitRequest)) +def test_txn_offset_commit_request_roundtrip(instance: TxnOffsetCommitRequest) -> None: + writer = entity_writer(TxnOffsetCommitRequest) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_txn_offset_commit_request(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(TxnOffsetCommitRequest)) +def test_txn_offset_commit_request_java( + instance: TxnOffsetCommitRequest, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_txn_offset_commit_v4_response.py b/tests/generated/test_txn_offset_commit_v4_response.py new file mode 100644 index 00000000..2efa26e2 --- /dev/null +++ b/tests/generated/test_txn_offset_commit_v4_response.py @@ -0,0 +1,75 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.txn_offset_commit.v4.response import TxnOffsetCommitResponse +from kio.schema.txn_offset_commit.v4.response import TxnOffsetCommitResponsePartition +from kio.schema.txn_offset_commit.v4.response import TxnOffsetCommitResponseTopic +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_txn_offset_commit_response_partition: Final = entity_reader( + TxnOffsetCommitResponsePartition +) + + +@pytest.mark.roundtrip +@given(from_type(TxnOffsetCommitResponsePartition)) +def test_txn_offset_commit_response_partition_roundtrip( + instance: TxnOffsetCommitResponsePartition, +) -> None: + writer = entity_writer(TxnOffsetCommitResponsePartition) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_txn_offset_commit_response_partition(buffer) + assert instance == result + + +read_txn_offset_commit_response_topic: Final = entity_reader( + TxnOffsetCommitResponseTopic +) + + +@pytest.mark.roundtrip +@given(from_type(TxnOffsetCommitResponseTopic)) +def test_txn_offset_commit_response_topic_roundtrip( + instance: TxnOffsetCommitResponseTopic, +) -> None: + writer = entity_writer(TxnOffsetCommitResponseTopic) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_txn_offset_commit_response_topic(buffer) + assert instance == result + + +read_txn_offset_commit_response: Final = entity_reader(TxnOffsetCommitResponse) + + +@pytest.mark.roundtrip +@given(from_type(TxnOffsetCommitResponse)) +def test_txn_offset_commit_response_roundtrip( + instance: TxnOffsetCommitResponse, +) -> None: + writer = entity_writer(TxnOffsetCommitResponse) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_txn_offset_commit_response(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(TxnOffsetCommitResponse)) +def test_txn_offset_commit_response_java( + instance: TxnOffsetCommitResponse, java_tester: JavaTester +) -> None: + java_tester.test(instance) diff --git a/tests/generated/test_voters_record_v0_data.py b/tests/generated/test_voters_record_v0_data.py new file mode 100644 index 00000000..5bbb36d1 --- /dev/null +++ b/tests/generated/test_voters_record_v0_data.py @@ -0,0 +1,78 @@ +from __future__ import annotations + +from typing import Final + +import pytest + +from hypothesis import given +from hypothesis.strategies import from_type + +from kio.schema.voters_record.v0.data import Endpoint +from kio.schema.voters_record.v0.data import KRaftVersionFeature +from kio.schema.voters_record.v0.data import Voter +from kio.schema.voters_record.v0.data import VotersRecord +from kio.serial import entity_reader +from kio.serial import entity_writer +from tests.conftest import JavaTester +from tests.conftest import setup_buffer + +read_endpoint: Final = entity_reader(Endpoint) + + +@pytest.mark.roundtrip +@given(from_type(Endpoint)) +def test_endpoint_roundtrip(instance: Endpoint) -> None: + writer = entity_writer(Endpoint) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_endpoint(buffer) + assert instance == result + + +read_k_raft_version_feature: Final = entity_reader(KRaftVersionFeature) + + +@pytest.mark.roundtrip +@given(from_type(KRaftVersionFeature)) +def test_k_raft_version_feature_roundtrip(instance: KRaftVersionFeature) -> None: + writer = entity_writer(KRaftVersionFeature) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_k_raft_version_feature(buffer) + assert instance == result + + +read_voter: Final = entity_reader(Voter) + + +@pytest.mark.roundtrip +@given(from_type(Voter)) +def test_voter_roundtrip(instance: Voter) -> None: + writer = entity_writer(Voter) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_voter(buffer) + assert instance == result + + +read_voters_record: Final = entity_reader(VotersRecord) + + +@pytest.mark.roundtrip +@given(from_type(VotersRecord)) +def test_voters_record_roundtrip(instance: VotersRecord) -> None: + writer = entity_writer(VotersRecord) + with setup_buffer() as buffer: + writer(buffer, instance) + buffer.seek(0) + result = read_voters_record(buffer) + assert instance == result + + +@pytest.mark.java +@given(instance=from_type(VotersRecord)) +def test_voters_record_java(instance: VotersRecord, java_tester: JavaTester) -> None: + java_tester.test(instance) diff --git a/tests/test_integration.py b/tests/test_integration.py index c1d8992b..6c5b57e1 100644 --- a/tests/test_integration.py +++ b/tests/test_integration.py @@ -201,43 +201,43 @@ async def test_roundtrip_api_versions_v3() -> None: api_versions_v3_response.SupportedFeatureKey( name="metadata.version", min_version=i16(1), - max_version=i16(19), + max_version=i16(20), ), ), finalized_features=( api_versions_v3_response.FinalizedFeatureKey( name="metadata.version", - min_version_level=i16(19), - max_version_level=i16(19), + min_version_level=i16(20), + max_version_level=i16(20), ), ), finalized_features_epoch=mock.ANY, api_keys=( - ApiVersion(api_key=i16(0), min_version=i16(0), max_version=i16(10)), + ApiVersion(api_key=i16(0), min_version=i16(0), max_version=i16(11)), ApiVersion(api_key=i16(1), min_version=i16(0), max_version=i16(16)), ApiVersion(api_key=i16(2), min_version=i16(0), max_version=i16(8)), ApiVersion(api_key=i16(3), min_version=i16(0), max_version=i16(12)), ApiVersion(api_key=i16(8), min_version=i16(0), max_version=i16(9)), ApiVersion(api_key=i16(9), min_version=i16(0), max_version=i16(9)), - ApiVersion(api_key=i16(10), min_version=i16(0), max_version=i16(4)), + ApiVersion(api_key=i16(10), min_version=i16(0), max_version=i16(5)), ApiVersion(api_key=i16(11), min_version=i16(0), max_version=i16(9)), ApiVersion(api_key=i16(12), min_version=i16(0), max_version=i16(4)), ApiVersion(api_key=i16(13), min_version=i16(0), max_version=i16(5)), ApiVersion(api_key=i16(14), min_version=i16(0), max_version=i16(5)), ApiVersion(api_key=i16(15), min_version=i16(0), max_version=i16(5)), - ApiVersion(api_key=i16(16), min_version=i16(0), max_version=i16(4)), + ApiVersion(api_key=i16(16), min_version=i16(0), max_version=i16(5)), ApiVersion(api_key=i16(17), min_version=i16(0), max_version=i16(1)), ApiVersion(api_key=i16(18), min_version=i16(0), max_version=i16(3)), ApiVersion(api_key=i16(19), min_version=i16(0), max_version=i16(7)), ApiVersion(api_key=i16(20), min_version=i16(0), max_version=i16(6)), ApiVersion(api_key=i16(21), min_version=i16(0), max_version=i16(2)), - ApiVersion(api_key=i16(22), min_version=i16(0), max_version=i16(4)), + ApiVersion(api_key=i16(22), min_version=i16(0), max_version=i16(5)), ApiVersion(api_key=i16(23), min_version=i16(0), max_version=i16(4)), - ApiVersion(api_key=i16(24), min_version=i16(0), max_version=i16(4)), - ApiVersion(api_key=i16(25), min_version=i16(0), max_version=i16(3)), - ApiVersion(api_key=i16(26), min_version=i16(0), max_version=i16(3)), + ApiVersion(api_key=i16(24), min_version=i16(0), max_version=i16(5)), + ApiVersion(api_key=i16(25), min_version=i16(0), max_version=i16(4)), + ApiVersion(api_key=i16(26), min_version=i16(0), max_version=i16(4)), ApiVersion(api_key=i16(27), min_version=i16(0), max_version=i16(1)), - ApiVersion(api_key=i16(28), min_version=i16(0), max_version=i16(3)), + ApiVersion(api_key=i16(28), min_version=i16(0), max_version=i16(4)), ApiVersion(api_key=i16(29), min_version=i16(0), max_version=i16(3)), ApiVersion(api_key=i16(30), min_version=i16(0), max_version=i16(3)), ApiVersion(api_key=i16(31), min_version=i16(0), max_version=i16(3)), @@ -267,9 +267,11 @@ async def test_roundtrip_api_versions_v3() -> None: ApiVersion(api_key=i16(61), min_version=i16(0), max_version=i16(0)), ApiVersion(api_key=i16(64), min_version=i16(0), max_version=i16(0)), ApiVersion(api_key=i16(65), min_version=i16(0), max_version=i16(0)), - ApiVersion(api_key=i16(66), min_version=i16(0), max_version=i16(0)), + ApiVersion(api_key=i16(66), min_version=i16(0), max_version=i16(1)), ApiVersion(api_key=i16(68), min_version=i16(0), max_version=i16(0)), + ApiVersion(api_key=i16(69), min_version=i16(0), max_version=i16(0)), ApiVersion(api_key=i16(74), min_version=i16(0), max_version=i16(0)), + ApiVersion(api_key=i16(75), min_version=i16(0), max_version=i16(0)), ), zk_migration_ready=False, ) @@ -285,31 +287,31 @@ async def test_roundtrip_api_versions_v2() -> None: error_code=ErrorCode.none, throttle_time=timedelta_zero, api_keys=( - ApiVersion(api_key=i16(0), min_version=i16(0), max_version=i16(10)), + ApiVersion(api_key=i16(0), min_version=i16(0), max_version=i16(11)), ApiVersion(api_key=i16(1), min_version=i16(0), max_version=i16(16)), ApiVersion(api_key=i16(2), min_version=i16(0), max_version=i16(8)), ApiVersion(api_key=i16(3), min_version=i16(0), max_version=i16(12)), ApiVersion(api_key=i16(8), min_version=i16(0), max_version=i16(9)), ApiVersion(api_key=i16(9), min_version=i16(0), max_version=i16(9)), - ApiVersion(api_key=i16(10), min_version=i16(0), max_version=i16(4)), + ApiVersion(api_key=i16(10), min_version=i16(0), max_version=i16(5)), ApiVersion(api_key=i16(11), min_version=i16(0), max_version=i16(9)), ApiVersion(api_key=i16(12), min_version=i16(0), max_version=i16(4)), ApiVersion(api_key=i16(13), min_version=i16(0), max_version=i16(5)), ApiVersion(api_key=i16(14), min_version=i16(0), max_version=i16(5)), ApiVersion(api_key=i16(15), min_version=i16(0), max_version=i16(5)), - ApiVersion(api_key=i16(16), min_version=i16(0), max_version=i16(4)), + ApiVersion(api_key=i16(16), min_version=i16(0), max_version=i16(5)), ApiVersion(api_key=i16(17), min_version=i16(0), max_version=i16(1)), ApiVersion(api_key=i16(18), min_version=i16(0), max_version=i16(3)), ApiVersion(api_key=i16(19), min_version=i16(0), max_version=i16(7)), ApiVersion(api_key=i16(20), min_version=i16(0), max_version=i16(6)), ApiVersion(api_key=i16(21), min_version=i16(0), max_version=i16(2)), - ApiVersion(api_key=i16(22), min_version=i16(0), max_version=i16(4)), + ApiVersion(api_key=i16(22), min_version=i16(0), max_version=i16(5)), ApiVersion(api_key=i16(23), min_version=i16(0), max_version=i16(4)), - ApiVersion(api_key=i16(24), min_version=i16(0), max_version=i16(4)), - ApiVersion(api_key=i16(25), min_version=i16(0), max_version=i16(3)), - ApiVersion(api_key=i16(26), min_version=i16(0), max_version=i16(3)), + ApiVersion(api_key=i16(24), min_version=i16(0), max_version=i16(5)), + ApiVersion(api_key=i16(25), min_version=i16(0), max_version=i16(4)), + ApiVersion(api_key=i16(26), min_version=i16(0), max_version=i16(4)), ApiVersion(api_key=i16(27), min_version=i16(0), max_version=i16(1)), - ApiVersion(api_key=i16(28), min_version=i16(0), max_version=i16(3)), + ApiVersion(api_key=i16(28), min_version=i16(0), max_version=i16(4)), ApiVersion(api_key=i16(29), min_version=i16(0), max_version=i16(3)), ApiVersion(api_key=i16(30), min_version=i16(0), max_version=i16(3)), ApiVersion(api_key=i16(31), min_version=i16(0), max_version=i16(3)), @@ -339,9 +341,11 @@ async def test_roundtrip_api_versions_v2() -> None: ApiVersion(api_key=i16(61), min_version=i16(0), max_version=i16(0)), ApiVersion(api_key=i16(64), min_version=i16(0), max_version=i16(0)), ApiVersion(api_key=i16(65), min_version=i16(0), max_version=i16(0)), - ApiVersion(api_key=i16(66), min_version=i16(0), max_version=i16(0)), + ApiVersion(api_key=i16(66), min_version=i16(0), max_version=i16(1)), ApiVersion(api_key=i16(68), min_version=i16(0), max_version=i16(0)), + ApiVersion(api_key=i16(69), min_version=i16(0), max_version=i16(0)), ApiVersion(api_key=i16(74), min_version=i16(0), max_version=i16(0)), + ApiVersion(api_key=i16(75), min_version=i16(0), max_version=i16(0)), ), )