types-kafka-python 2.3.0.20260523__py3-none-any.whl

kafka-stubs/consumer/fetcher.pyi

@@ -0,0 +1,150 @@
+from _typeshed import Incomplete
+from typing import ClassVar, NamedTuple
+
+import kafka.errors as Errors
+
+log: Incomplete
+READ_UNCOMMITTED: int
+READ_COMMITTED: int
+ISOLATION_LEVEL_CONFIG: Incomplete
+
+class ConsumerRecord(NamedTuple):
+    topic: str
+    partition: int
+    leader_epoch: int | None
+    offset: int
+    timestamp: int
+    timestamp_type: int
+    key: Incomplete
+    value: Incomplete
+    headers: list[tuple[str, bytes]]
+    checksum: int | None
+    serialized_key_size: int
+    serialized_value_size: int
+    serialized_header_size: int
+
+class CompletedFetch(NamedTuple):
+    topic_partition: Incomplete
+    fetched_offset: Incomplete
+    response_version: Incomplete
+    partition_data: Incomplete
+    metric_aggregator: Incomplete
+
+class ExceptionMetadata(NamedTuple):
+    partition: Incomplete
+    fetched_offset: Incomplete
+    exception: Incomplete
+
+class NoOffsetForPartitionError(Errors.KafkaError): ...
+class RecordTooLargeError(Errors.KafkaError): ...
+
+class Fetcher:
+    DEFAULT_CONFIG: Incomplete
+    config: Incomplete
+    def __init__(self, client, subscriptions, **configs) -> None: ...
+    def send_fetches(self): ...
+    def in_flight_fetches(self): ...
+    def reset_offsets_if_needed(self): ...
+    def offsets_by_times(self, timestamps, timeout_ms=None): ...
+    def beginning_offsets(self, partitions, timeout_ms): ...
+    def end_offsets(self, partitions, timeout_ms): ...
+    def beginning_or_end_offset(self, partitions, timestamp, timeout_ms): ...
+    def fetched_records(self, max_records=None, update_offsets: bool = True): ...
+    def close(self) -> None: ...
+
+    class PartitionRecords:
+        fetch_offset: Incomplete
+        topic_partition: Incomplete
+        leader_epoch: int
+        next_fetch_offset: Incomplete
+        bytes_read: int
+        records_read: int
+        isolation_level: Incomplete
+        aborted_producer_ids: Incomplete
+        aborted_transactions: Incomplete
+        metric_aggregator: Incomplete
+        check_crcs: Incomplete
+        record_iterator: Incomplete
+        on_drain: Incomplete
+        def __init__(
+            self,
+            fetch_offset,
+            tp,
+            records,
+            key_deserializer=None,
+            value_deserializer=None,
+            check_crcs: bool = True,
+            isolation_level=0,
+            aborted_transactions=None,
+            metric_aggregator=None,
+            on_drain=...,
+        ) -> None: ...
+        def __bool__(self) -> bool: ...
+        __nonzero__ = __bool__
+        def drain(self) -> None: ...
+        def take(self, n=None): ...
+
+class FetchSessionHandler:
+    node_id: Incomplete
+    next_metadata: Incomplete
+    session_partitions: Incomplete
+    def __init__(self, node_id) -> None: ...
+    def build_next(self, next_partitions): ...
+    def handle_response(self, response): ...
+    def handle_error(self, _exception) -> None: ...
+
+class FetchMetadata:
+    MAX_EPOCH: int
+    INVALID_SESSION_ID: int
+    THROTTLED_SESSION_ID: int
+    INITIAL_EPOCH: int
+    FINAL_EPOCH: int
+    INITIAL: ClassVar[FetchMetadata]
+    LEGACY: ClassVar[FetchMetadata]
+    session_id: Incomplete
+    epoch: Incomplete
+    def __init__(self, session_id, epoch) -> None: ...
+    @property
+    def is_full(self): ...
+    @classmethod
+    def next_epoch(cls, prev_epoch): ...
+    def next_close_existing(self): ...
+    @classmethod
+    def new_incremental(cls, session_id): ...
+    def next_incremental(self): ...
+
+class FetchRequestData:
+    def __init__(self, to_send, to_forget, metadata) -> None: ...
+    @property
+    def metadata(self): ...
+    @property
+    def id(self): ...
+    @property
+    def epoch(self): ...
+    @property
+    def to_send(self): ...
+    @property
+    def to_forget(self): ...
+
+class FetchMetrics:
+    total_bytes: int
+    total_records: int
+    def __init__(self) -> None: ...
+
+class FetchResponseMetricAggregator:
+    sensors: Incomplete
+    unrecorded_partitions: Incomplete
+    fetch_metrics: Incomplete
+    topic_fetch_metrics: Incomplete
+    def __init__(self, sensors, partitions) -> None: ...
+    def record(self, partition, num_bytes, num_records) -> None: ...
+
+class FetchManagerMetrics:
+    metrics: Incomplete
+    group_name: Incomplete
+    bytes_fetched: Incomplete
+    records_fetched: Incomplete
+    fetch_latency: Incomplete
+    records_fetch_lag: Incomplete
+    def __init__(self, metrics, prefix) -> None: ...
+    def record_topic_fetch_metrics(self, topic, num_bytes, num_records) -> None: ...

kafka-stubs/consumer/group.pyi

@@ -0,0 +1,143 @@
+import selectors
+import ssl
+from _typeshed import Incomplete
+from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
+from typing import Literal, TypeAlias, TypedDict, overload, type_check_only
+from typing_extensions import Self, Unpack
+
+from kafka.consumer.fetcher import ConsumerRecord
+from kafka.consumer.subscription_state import ConsumerRebalanceListener
+from kafka.future import Future
+from kafka.serializer.abstract import Deserializer
+from kafka.structs import OffsetAndMetadata, OffsetAndTimestamp, TopicPartition
+
+_ApiVersion: TypeAlias = tuple[int, ...]
+_BootstrapServers: TypeAlias = str | Sequence[str]
+_CommitCallback: TypeAlias = Callable[[Mapping[TopicPartition, OffsetAndMetadata], object], object]
+_ConsumerDeserializer: TypeAlias = Deserializer | Callable[[bytes | None], object]
+_KafkaClientFactory: TypeAlias = Callable[..., object]
+_SaslMechanism: TypeAlias = Literal["PLAIN", "GSSAPI", "OAUTHBEARER", "SCRAM-SHA-256", "SCRAM-SHA-512"]
+_SecurityProtocol: TypeAlias = Literal["PLAINTEXT", "SSL", "SASL_PLAINTEXT", "SASL_SSL"]
+_SocketOption: TypeAlias = tuple[int, int, int]
+
+@type_check_only
+class _KafkaConsumerConfig(TypedDict, total=False):
+    bootstrap_servers: _BootstrapServers
+    client_id: str
+    group_id: str | None
+    group_instance_id: str | None
+    key_deserializer: _ConsumerDeserializer | None
+    value_deserializer: _ConsumerDeserializer | None
+    enable_incremental_fetch_sessions: bool
+    fetch_max_wait_ms: int
+    fetch_min_bytes: int
+    fetch_max_bytes: int
+    max_partition_fetch_bytes: int
+    request_timeout_ms: int
+    retry_backoff_ms: int
+    reconnect_backoff_ms: int
+    reconnect_backoff_max_ms: int
+    max_in_flight_requests_per_connection: int
+    auto_offset_reset: Literal["earliest", "latest", "smallest", "largest"]
+    enable_auto_commit: bool
+    auto_commit_interval_ms: int
+    default_offset_commit_callback: _CommitCallback
+    check_crcs: bool
+    isolation_level: Literal["read_uncommitted", "read_committed"]
+    allow_auto_create_topics: bool
+    metadata_max_age_ms: int
+    partition_assignment_strategy: Sequence[type[object]]
+    max_poll_records: int
+    max_poll_interval_ms: int
+    session_timeout_ms: int
+    heartbeat_interval_ms: int
+    receive_buffer_bytes: int | None
+    send_buffer_bytes: int | None
+    socket_options: Sequence[_SocketOption]
+    sock_chunk_bytes: int
+    sock_chunk_buffer_count: int
+    consumer_timeout_ms: int | float
+    security_protocol: _SecurityProtocol
+    ssl_context: ssl.SSLContext | None
+    ssl_check_hostname: bool
+    ssl_cafile: str | None
+    ssl_certfile: str | None
+    ssl_keyfile: str | None
+    ssl_crlfile: str | None
+    ssl_password: str | None
+    ssl_ciphers: str | None
+    api_version: _ApiVersion | None
+    api_version_auto_timeout_ms: int
+    connections_max_idle_ms: int
+    metric_reporters: Sequence[type[object]]
+    metrics_enabled: bool
+    metrics_num_samples: int
+    metrics_sample_window_ms: int
+    metric_group_prefix: str
+    selector: type[selectors.BaseSelector]
+    exclude_internal_topics: bool
+    sasl_mechanism: _SaslMechanism | None
+    sasl_plain_username: str | None
+    sasl_plain_password: str | None
+    sasl_kerberos_name: object | None
+    sasl_kerberos_service_name: str
+    sasl_kerberos_domain_name: str | None
+    sasl_oauth_token_provider: object | None
+    socks5_proxy: str | None
+    kafka_client: _KafkaClientFactory
+
+log: Incomplete
+
+class KafkaConsumer(Iterator[ConsumerRecord]):
+    DEFAULT_CONFIG: Incomplete
+    DEFAULT_SESSION_TIMEOUT_MS_0_9: int
+    config: Incomplete
+    def __init__(self, *topics: str, **configs: Unpack[_KafkaConsumerConfig]) -> None: ...
+    def bootstrap_connected(self): ...
+    def assign(self, partitions: Iterable[TopicPartition]) -> None: ...
+    def assignment(self) -> set[TopicPartition]: ...
+    def close(self, autocommit: bool = True, timeout_ms: int | None = None) -> None: ...
+    def commit_async(
+        self, offsets: Mapping[TopicPartition, OffsetAndMetadata] | None = None, callback: _CommitCallback | None = None
+    ) -> Future: ...
+    def commit(
+        self, offsets: Mapping[TopicPartition, OffsetAndMetadata] | None = None, timeout_ms: int | None = None
+    ) -> None: ...
+
+    @overload
+    def committed(
+        self, partition: TopicPartition, metadata: Literal[False] = False, timeout_ms: int | None = None
+    ) -> int | None: ...
+    @overload
+    def committed(
+        self, partition: TopicPartition, metadata: Literal[True], timeout_ms: int | None = None
+    ) -> OffsetAndMetadata | None: ...
+    @overload
+    def committed(
+        self, partition: TopicPartition, metadata: bool, timeout_ms: int | None = None
+    ) -> int | OffsetAndMetadata | None: ...
+
+    def topics(self) -> set[str]: ...
+    def partitions_for_topic(self, topic: str) -> set[int]: ...
+    def poll(
+        self, timeout_ms: int = 0, max_records: int | None = None, update_offsets: bool = True
+    ) -> dict[TopicPartition, list[ConsumerRecord]]: ...
+    def position(self, partition: TopicPartition, timeout_ms: int | None = None) -> int | None: ...
+    def highwater(self, partition: TopicPartition) -> int | None: ...
+    def pause(self, *partitions: TopicPartition) -> None: ...
+    def paused(self) -> set[TopicPartition]: ...
+    def resume(self, *partitions: TopicPartition) -> None: ...
+    def seek(self, partition: TopicPartition, offset: int) -> None: ...
+    def seek_to_beginning(self, *partitions: TopicPartition) -> None: ...
+    def seek_to_end(self, *partitions: TopicPartition) -> None: ...
+    def subscribe(
+        self, topics: Iterable[str] = (), pattern: str | None = None, listener: ConsumerRebalanceListener | None = None
+    ) -> None: ...
+    def subscription(self) -> set[str]: ...
+    def unsubscribe(self) -> None: ...
+    def metrics(self, raw: bool = False) -> dict[str, dict[str, object]] | dict[object, object] | None: ...
+    def offsets_for_times(self, timestamps: Mapping[TopicPartition, int]) -> dict[TopicPartition, OffsetAndTimestamp | None]: ...
+    def beginning_offsets(self, partitions: Iterable[TopicPartition]) -> dict[TopicPartition, int]: ...
+    def end_offsets(self, partitions: Iterable[TopicPartition]) -> dict[TopicPartition, int]: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> ConsumerRecord: ...

kafka-stubs/consumer/subscription_state.pyi

@@ -0,0 +1,112 @@
+import abc
+from _typeshed import Incomplete
+from enum import IntEnum
+
+from kafka.util import synchronized
+
+log: Incomplete
+
+class SubscriptionType(IntEnum):
+    NONE = 0
+    AUTO_TOPICS = 1
+    AUTO_PATTERN = 2
+    USER_ASSIGNED = 3
+
+class SubscriptionState:
+    subscription: Incomplete
+    subscription_type: Incomplete
+    subscribed_pattern: Incomplete
+    assignment: Incomplete
+    rebalance_listener: Incomplete
+    listeners: Incomplete
+    def __init__(self, offset_reset_strategy: str = "earliest") -> None: ...
+    @synchronized
+    def subscribe(self, topics=(), pattern=None, listener=None) -> None: ...
+    @synchronized
+    def change_subscription(self, topics) -> None: ...
+    @synchronized
+    def group_subscribe(self, topics) -> None: ...
+    @synchronized
+    def reset_group_subscription(self) -> None: ...
+    @synchronized
+    def assign_from_user(self, partitions) -> None: ...
+    @synchronized
+    def assign_from_subscribed(self, assignments) -> None: ...
+    @synchronized
+    def unsubscribe(self) -> None: ...
+    @synchronized
+    def group_subscription(self): ...
+    @synchronized
+    def seek(self, partition, offset) -> None: ...
+    @synchronized
+    def assigned_partitions(self): ...
+    @synchronized
+    def paused_partitions(self): ...
+    @synchronized
+    def fetchable_partitions(self): ...
+    @synchronized
+    def partitions_auto_assigned(self): ...
+    @synchronized
+    def all_consumed_offsets(self): ...
+    @synchronized
+    def request_offset_reset(self, partition, offset_reset_strategy=None) -> None: ...
+    @synchronized
+    def set_reset_pending(self, partitions, next_allowed_reset_time) -> None: ...
+    @synchronized
+    def has_default_offset_reset_policy(self): ...
+    @synchronized
+    def is_offset_reset_needed(self, partition): ...
+    @synchronized
+    def has_all_fetch_positions(self): ...
+    @synchronized
+    def missing_fetch_positions(self): ...
+    @synchronized
+    def has_valid_position(self, partition): ...
+    @synchronized
+    def reset_missing_positions(self) -> None: ...
+    @synchronized
+    def partitions_needing_reset(self): ...
+    @synchronized
+    def is_assigned(self, partition): ...
+    @synchronized
+    def is_paused(self, partition): ...
+    @synchronized
+    def is_fetchable(self, partition): ...
+    @synchronized
+    def pause(self, partition) -> None: ...
+    @synchronized
+    def resume(self, partition) -> None: ...
+    @synchronized
+    def reset_failed(self, partitions, next_retry_time) -> None: ...
+    @synchronized
+    def move_partition_to_end(self, partition) -> None: ...
+    @synchronized
+    def position(self, partition): ...
+
+class TopicPartitionState:
+    paused: bool
+    reset_strategy: Incomplete
+    highwater: Incomplete
+    drop_pending_record_batch: bool
+    next_allowed_retry_time: Incomplete
+    def __init__(self) -> None: ...
+    position: Incomplete
+    def reset(self, strategy) -> None: ...
+    def is_reset_allowed(self): ...
+    @property
+    def awaiting_reset(self): ...
+    def set_reset_pending(self, next_allowed_retry_time) -> None: ...
+    def reset_failed(self, next_allowed_retry_time) -> None: ...
+    @property
+    def has_valid_position(self): ...
+    def is_missing_position(self): ...
+    def seek(self, offset) -> None: ...
+    def pause(self) -> None: ...
+    def resume(self) -> None: ...
+    def is_fetchable(self): ...
+
+class ConsumerRebalanceListener(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def on_partitions_revoked(self, revoked): ...
+    @abc.abstractmethod
+    def on_partitions_assigned(self, assigned): ...

kafka-stubs/coordinator/assignors/abstract.pyi

@@ -0,0 +1,15 @@
+import abc
+from _typeshed import Incomplete
+
+log: Incomplete
+
+class AbstractPartitionAssignor(metaclass=abc.ABCMeta):
+    @property
+    @abc.abstractmethod
+    def name(self): ...
+    @abc.abstractmethod
+    def assign(self, cluster, members): ...
+    @abc.abstractmethod
+    def metadata(self, topics): ...
+    @abc.abstractmethod
+    def on_assignment(self, assignment): ...

kafka-stubs/coordinator/assignors/range.pyi

@@ -0,0 +1,15 @@
+from _typeshed import Incomplete
+
+from kafka.coordinator.assignors.abstract import AbstractPartitionAssignor
+
+log: Incomplete
+
+class RangePartitionAssignor(AbstractPartitionAssignor):
+    name: str
+    version: int
+    @classmethod
+    def assign(cls, cluster, group_subscriptions): ...
+    @classmethod
+    def metadata(cls, topics): ...
+    @classmethod
+    def on_assignment(cls, assignment) -> None: ...

kafka-stubs/coordinator/assignors/roundrobin.pyi

@@ -0,0 +1,15 @@
+from _typeshed import Incomplete
+
+from kafka.coordinator.assignors.abstract import AbstractPartitionAssignor
+
+log: Incomplete
+
+class RoundRobinPartitionAssignor(AbstractPartitionAssignor):
+    name: str
+    version: int
+    @classmethod
+    def assign(cls, cluster, group_subscriptions): ...
+    @classmethod
+    def metadata(cls, topics): ...
+    @classmethod
+    def on_assignment(cls, assignment) -> None: ...

kafka-stubs/coordinator/assignors/sticky/partition_movements.pyi

@@ -0,0 +1,18 @@
+from _typeshed import Incomplete
+from typing import NamedTuple
+
+log: Incomplete
+
+class ConsumerPair(NamedTuple):
+    src_member_id: Incomplete
+    dst_member_id: Incomplete
+
+def is_sublist(source, target): ...
+
+class PartitionMovements:
+    partition_movements_by_topic: Incomplete
+    partition_movements: Incomplete
+    def __init__(self) -> None: ...
+    def move_partition(self, partition, old_consumer, new_consumer) -> None: ...
+    def get_partition_to_be_moved(self, partition, old_consumer, new_consumer): ...
+    def are_sticky(self): ...

kafka-stubs/coordinator/assignors/sticky/sorted_set.pyi

@@ -0,0 +1,13 @@
+from _typeshed import Incomplete
+
+class SortedSet:
+    def __init__(self, iterable=None, key=None) -> None: ...
+    def first(self): ...
+    def last(self): ...
+    def pop_last(self): ...
+    def add(self, value): ...
+    def remove(self, value): ...
+    def __contains__(self, value) -> bool: ...
+    def __iter__(self): ...
+    __nonzero__: Incomplete
+    __bool__: Incomplete

kafka-stubs/coordinator/assignors/sticky/sticky_assignor.pyi

@@ -0,0 +1,59 @@
+from _typeshed import Incomplete
+from typing import NamedTuple
+
+from kafka.coordinator.assignors.abstract import AbstractPartitionAssignor
+from kafka.protocol.struct import Struct
+
+log: Incomplete
+
+class ConsumerGenerationPair(NamedTuple):
+    consumer: Incomplete
+    generation: Incomplete
+
+def has_identical_list_elements(list_): ...
+def subscriptions_comparator_key(element): ...
+def partitions_comparator_key(element): ...
+def remove_if_present(collection, element) -> None: ...
+
+class StickyAssignorMemberMetadataV1(NamedTuple):
+    subscription: Incomplete
+    partitions: Incomplete
+    generation: Incomplete
+
+class StickyAssignorUserDataV1(Struct):
+    SCHEMA: Incomplete
+
+class StickyAssignmentExecutor:
+    members: Incomplete
+    current_assignment: Incomplete
+    previous_assignment: Incomplete
+    current_partition_consumer: Incomplete
+    is_fresh_assignment: bool
+    partition_to_all_potential_consumers: Incomplete
+    consumer_to_all_potential_partitions: Incomplete
+    sorted_current_subscriptions: Incomplete
+    sorted_partitions: Incomplete
+    unassigned_partitions: Incomplete
+    revocation_required: bool
+    partition_movements: Incomplete
+    def __init__(self, cluster, members) -> None: ...
+    def perform_initial_assignment(self) -> None: ...
+    def balance(self) -> None: ...
+    def get_final_assignment(self, member_id): ...
+
+class StickyPartitionAssignor(AbstractPartitionAssignor):
+    DEFAULT_GENERATION_ID: int
+    name: str
+    version: int
+    member_assignment: Incomplete
+    generation = DEFAULT_GENERATION_ID
+    @classmethod
+    def assign(cls, cluster, members): ...
+    @classmethod
+    def parse_member_metadata(cls, metadata): ...
+    @classmethod
+    def metadata(cls, topics): ...
+    @classmethod
+    def on_assignment(cls, assignment) -> None: ...
+    @classmethod
+    def on_generation_assignment(cls, generation) -> None: ...

kafka-stubs/coordinator/base.pyi

@@ -0,0 +1,86 @@
+import abc
+import threading
+from _typeshed import Incomplete
+from typing import ClassVar
+
+from kafka import errors as Errors
+
+log: Incomplete
+heartbeat_log: Incomplete
+
+class MemberState:
+    UNJOINED: str
+    REBALANCING: str
+    STABLE: str
+
+class Generation:
+    NO_GENERATION: ClassVar[Generation]
+    generation_id: Incomplete
+    member_id: Incomplete
+    protocol: Incomplete
+    def __init__(self, generation_id, member_id, protocol) -> None: ...
+    def has_member_id(self): ...
+    def __eq__(self, other): ...
+
+class UnjoinedGroupException(Errors.KafkaError):
+    retriable: bool
+
+class BaseCoordinator(metaclass=abc.ABCMeta):
+    DEFAULT_CONFIG: Incomplete
+    config: Incomplete
+    heartbeat: Incomplete
+    rejoin_needed: bool
+    rejoining: bool
+    state: Incomplete
+    join_future: Incomplete
+    coordinator_id: Incomplete
+    def __init__(self, client, **configs) -> None: ...
+    @property
+    def group_id(self): ...
+    @property
+    def group_instance_id(self): ...
+    @abc.abstractmethod
+    def protocol_type(self): ...
+    @abc.abstractmethod
+    def group_protocols(self): ...
+    def coordinator_unknown(self): ...
+    def coordinator(self): ...
+    def connected(self): ...
+    def ensure_coordinator_ready(self, timeout_ms=None): ...
+    def lookup_coordinator(self): ...
+    def need_rejoin(self): ...
+    def poll_heartbeat(self) -> None: ...
+    def time_to_next_heartbeat(self): ...
+    def ensure_active_group(self, timeout_ms=None): ...
+    def join_group(self, timeout_ms=None): ...
+    def coordinator_dead(self, error) -> None: ...
+    def generation_if_stable(self): ...
+    def generation(self): ...
+    def rebalance_in_progress(self): ...
+    def reset_generation(self, member_id="") -> None: ...
+    def request_rejoin(self) -> None: ...
+    def __del__(self) -> None: ...
+    def close(self, timeout_ms=None) -> None: ...
+    def is_dynamic_member(self): ...
+    def maybe_leave_group(self, timeout_ms=None) -> None: ...
+
+class GroupCoordinatorMetrics:
+    heartbeat: Incomplete
+    metrics: Incomplete
+    metric_group_name: Incomplete
+    heartbeat_latency: Incomplete
+    join_latency: Incomplete
+    sync_latency: Incomplete
+    def __init__(self, heartbeat, metrics, prefix, tags=None) -> None: ...
+
+class HeartbeatThread(threading.Thread):
+    name: Incomplete
+    coordinator: Incomplete
+    enabled: bool
+    closed: bool
+    failed: Incomplete
+    def __init__(self, coordinator) -> None: ...
+    def enable(self) -> None: ...
+    def disable(self) -> None: ...
+    def close(self, timeout_ms=None) -> None: ...
+    def run(self) -> None: ...

kafka-stubs/coordinator/consumer.pyi

@@ -0,0 +1,31 @@
+from _typeshed import Incomplete
+
+from kafka.coordinator.base import BaseCoordinator
+
+log: Incomplete
+
+class ConsumerCoordinator(BaseCoordinator):
+    DEFAULT_CONFIG: Incomplete
+    config: Incomplete
+    auto_commit_interval: Incomplete
+    next_auto_commit_deadline: Incomplete
+    completed_offset_commits: Incomplete
+    def __init__(self, client, subscription, **configs) -> None: ...
+    def __del__(self) -> None: ...
+    def protocol_type(self): ...
+    def group_protocols(self): ...
+    def poll(self, timeout_ms=None): ...
+    def time_to_next_poll(self): ...
+    def need_rejoin(self): ...
+    def refresh_committed_offsets_if_needed(self, timeout_ms=None): ...
+    def fetch_committed_offsets(self, partitions, timeout_ms=None): ...
+    def close(self, autocommit: bool = True, timeout_ms=None) -> None: ...  # type: ignore[override]
+    def commit_offsets_async(self, offsets, callback=None): ...
+    def commit_offsets_sync(self, offsets, timeout_ms=None): ...
+    def maybe_auto_commit_offsets_now(self) -> None: ...
+
+class ConsumerCoordinatorMetrics:
+    metrics: Incomplete
+    metric_group_name: Incomplete
+    commit_latency: Incomplete
+    def __init__(self, metrics, metric_group_prefix, subscription) -> None: ...