kafka-python 3.0.0__py3-none-any.whl → 3.0.2__py3-none-any.whl

kafka/admin/client.py

@@ -75,7 +75,7 @@ class KafkaAdminClient(
             broker connection. Default: 5.
         receive_message_max_bytes (int): Maximum allowed network frame size.
             Used to avoid OOM when decoding malformed network message header.
-            Default: 1000000.
+            Default: 100_000_000.
         receive_buffer_bytes (int): The size of the TCP receive buffer
             (SO_RCVBUF) to use when reading data. Default: None (relies on
             system defaults). Java client defaults to 32768.
@@ -177,7 +177,7 @@ class KafkaAdminClient(
         'reconnect_backoff_ms': 50,
         'reconnect_backoff_max_ms': 30000,
         'max_in_flight_requests_per_connection': 5,
-        'receive_message_max_bytes': 1000000,
+        'receive_message_max_bytes': 100_000_000,
         'receive_buffer_bytes': None,
         'send_buffer_bytes': None,
         'socket_options': [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)],

kafka/consumer/fetcher.py

@@ -26,6 +26,36 @@ _LOGGED_DESERIALIZE_WARNING = False
 ConsumerRecord = collections.namedtuple("ConsumerRecord",
     ["topic", "partition", "leader_epoch", "offset", "timestamp", "timestamp_type",
      "key", "value", "headers", "checksum", "serialized_key_size", "serialized_value_size", "serialized_header_size"])
+ConsumerRecord.__doc__ = """A single record (message) consumed from a topic partition.
+
+Yielded by :meth:`~kafka.KafkaConsumer.poll` (inside the returned
+``{TopicPartition: [ConsumerRecord, ...]}`` mapping) and by iterating
+over a :class:`~kafka.KafkaConsumer`. ``key`` and ``value`` are decoded
+by the consumer's configured deserializers.
+
+Keyword Arguments:
+    topic (str): The topic this record was received from.
+    partition (int): The partition this record was received from.
+    leader_epoch (int): The partition leader epoch for this record, or -1
+        if unknown.
+    offset (int): The position of this record in the topic partition.
+    timestamp (int): The timestamp of this record, in milliseconds since
+        the epoch (UTC), or -1 if unknown.
+    timestamp_type (int): The type of the timestamp: 0 for CreateTime (set
+        by the producer) or 1 for LogAppendTime (set by the broker).
+    key: The (deserialized) key of the record, or None.
+    value: The (deserialized) value of the record, or None.
+    headers (list): A list of ``(key, value)`` header tuples, where key is
+        a str and value is bytes.
+    checksum (int): Deprecated. The CRC32 checksum of the record, or None.
+        Removed in message format v2 (Kafka 0.11+).
+    serialized_key_size (int): The size of the serialized, uncompressed key
+        in bytes, or -1 if the key is None.
+    serialized_value_size (int): The size of the serialized, uncompressed
+        value in bytes, or -1 if the value is None.
+    serialized_header_size (int): The size of the serialized, uncompressed
+        headers in bytes, or -1 if there are no headers.
+"""
 
 
 CompletedFetch = collections.namedtuple("CompletedFetch",

kafka/consumer/group.py

@@ -180,7 +180,9 @@ class KafkaConsumer:
             rebalances. Default: 3000
         receive_message_max_bytes (int): Maximum allowed network frame size.
             Used to avoid OOM when decoding malformed network message header.
-            Default: 1000000.
+            Automatically raised to ``fetch_max_bytes + max_partition_fetch_bytes``
+            if configured lower, since a FetchResponse frame may be that large.
+            Default: 100_000_000.
         receive_buffer_bytes (int): The size of the TCP receive buffer
             (SO_RCVBUF) to use when reading data. Default: None (relies on
             system defaults). The java client defaults to 32768.
@@ -328,7 +330,7 @@ class KafkaConsumer:
         'heartbeat_interval_ms': 3000,
         'receive_buffer_bytes': None,
         'send_buffer_bytes': None,
-        'receive_message_max_bytes': 1000000,
+        'receive_message_max_bytes': 100_000_000,
         'socket_options': [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)],
         'consumer_timeout_ms': float('inf'),
         'security_protocol': 'PLAINTEXT',
@@ -389,6 +391,20 @@ class KafkaConsumer:
                 "fetch_max_wait_ms ({})."
                 .format(connections_max_idle_ms, request_timeout_ms, fetch_max_wait_ms))
 
+        # fetch_max_bytes (KIP-74) is a soft cap the broker applies to the
+        # *record data* in a FetchResponse body, not to the whole frame. The
+        # frame also carries the response header + per-topic/per-partition
+        # metadata, and the broker returns at least the first record batch even
+        # when it alone exceeds fetch_max_bytes. So a FetchResponse frame can be
+        # somewhat larger than fetch_max_bytes; give the frame-size guard
+        # max_partition_fetch_bytes of headroom over it so legitimate responses
+        # aren't rejected as InvalidReceiveError. Auto-raise so the guard tracks
+        # the fetch sizing unless the user explicitly configured a larger value.
+        fetch_response_max_bytes = (
+            self.config['fetch_max_bytes'] + self.config['max_partition_fetch_bytes'])
+        if self.config['receive_message_max_bytes'] < fetch_response_max_bytes:
+            self.config['receive_message_max_bytes'] = fetch_response_max_bytes
+
         if self.config['metrics_enabled']:
             metrics_tags = {'client-id': self.config['client_id']}
             metric_config = MetricConfig(samples=self.config['metrics_num_samples'],
@@ -662,13 +678,17 @@ class KafkaConsumer:
         self._coordinator.commit_offsets_sync(offsets, timeout_ms=timeout_ms)
 
     def group_metadata(self):
-        """Return a snapshot of this consumer's group membership (KIP-447).
+        """Return a snapshot of this consumer's group membership.
 
         Pass the result to KafkaProducer.send_offsets_to_transaction() so the
         broker can fence stale instances of this consumer when committing
-        offsets inside a transaction. The snapshot is always safe to call:
-        if no group_id is configured (manual assignment) the returned
-        ConsumerGroupMetadata has group_id=None.
+        offsets inside a transaction (KIP-447). The snapshot also exposes the
+        current MemberState (``state``), so callers can observe whether the
+        consumer has converged on a stable assignment.
+
+        The snapshot is always safe to call: if no group_id is configured
+        (manual assignment) the returned ConsumerGroupMetadata has
+        group_id=None and is permanently unjoined.
 
         Returns:
             ConsumerGroupMetadata

kafka/coordinator/base.py

@@ -16,19 +16,13 @@ from kafka.protocol.consumer import (
     HeartbeatRequest, JoinGroupRequest, LeaveGroupRequest, SyncGroupRequest,
     DEFAULT_GENERATION_ID, UNKNOWN_MEMBER_ID,
 )
-from kafka.structs import ConsumerGroupMetadata
+from kafka.structs import ConsumerGroupMetadata, MemberState
 from kafka.util import Timer
 
 log = logging.getLogger('kafka.coordinator')
 heartbeat_log = logging.getLogger('kafka.coordinator.heartbeat')
 
 
-class MemberState:
-    UNJOINED = '<unjoined>'  # the client is not part of a group
-    REBALANCING = '<rebalancing>'  # the client has begun rebalancing
-    STABLE = '<stable>'  # the client has joined and is sending heartbeats
-
-
 class Generation:
     def __init__(self, generation_id, member_id, protocol):
         self.generation_id = generation_id
@@ -891,13 +885,16 @@ class BaseCoordinator(ABC):
             return self._generation
 
     def group_metadata(self):
-        """Return a snapshot of this member's group identity (KIP-447).
+        """Return a snapshot of this member's group membership.
 
         Returns the current generation_id / member_id / group_instance_id even
         when the group is not stable; the caller (typically
         KafkaProducer.send_offsets_to_transaction) needs whatever is current
-        so the broker can fence stale instances. If the consumer has never
-        joined, the snapshot has the no-generation defaults.
+        so the broker can fence stale instances (KIP-447). If the consumer has
+        never joined, the snapshot has the no-generation defaults.
+
+        Also carries the live MemberState (``state``) so callers can observe
+        whether the group has converged (it is ignored by the fencing path).
         """
         with self._lock:
             return ConsumerGroupMetadata(
@@ -905,6 +902,7 @@ class BaseCoordinator(ABC):
                 generation_id=self._generation.generation_id,
                 member_id=self._generation.member_id,
                 group_instance_id=self.group_instance_id,
+                state=self.state,
             )
 
     # deprecated

kafka/net/selector.py

@@ -122,6 +122,21 @@ class Task:
             raise RuntimeError('Task exception is already set!')
         self._exc = exc
 
+    def close(self):
+        stack = self._stack
+        while stack:
+            coro, stack = stack
+            if inspect.isgenerator(coro) or inspect.iscoroutine(coro):
+                try:
+                    coro.close()
+                except ValueError:
+                    # currently-executing coroutine -- can't close it from
+                    # within itself; bail without corrupting _stack.
+                    return
+                except Exception:
+                    log.exception('Error closing coroutine for cancelled task')
+        self._stack = None
+
     @property
     def is_done(self):
         return self._stack is None
@@ -363,13 +378,29 @@ class NetworkSelector:
             result = await result
         return result
 
-    def unschedule(self, task):
+    def _remove_scheduled(self, task):
         if task.scheduled_at is not None:
-            self._scheduled.remove((task.scheduled_at, task))
+            try:
+                self._scheduled.remove((task.scheduled_at, task))
+            except ValueError:
+                pass
+            else:
+                # re-heapify to ensure heap structure is valid
+                heapq.heapify(self._scheduled)
             task.scheduled_at = None
 
+    def _retire_task(self, task):
+        if task is self._current:
+            return
+        self._pending_tasks.discard(task)
+        task.close()
+
+    def unschedule(self, task):
+        self._remove_scheduled(task)
+        self._retire_task(task)
+
     def reschedule(self, when, task):
-        self.unschedule(task)
+        self._remove_scheduled(task)
         self.call_at(when, task)
         return task
 

kafka/partitioner/abc.py

@@ -2,7 +2,51 @@ from abc import ABC, abstractmethod
 
 
 class Partitioner(ABC):
+    """Base class for pluggable partition selection strategies.
+
+    A :class:`~kafka.KafkaProducer` consults its configured partitioner to
+    choose a partition for each record whose ``partition`` was not supplied
+    explicitly to :meth:`~kafka.KafkaProducer.send`. Subclass this and
+    implement :meth:`partition`, then pass an instance via the
+    ``partitioner`` config argument.
+
+    Two built-in implementations are provided: ``DefaultPartitioner``
+    (murmur2-hash keyed records, random partition for null keys) and
+    ``StickyPartitioner`` (KIP-480; null-key records stick to one partition
+    per topic until a new batch is started, then rotate).
+
+    Sticky-style partitioners may additionally implement an optional
+    ``on_new_batch(self, topic, cluster, prev_partition)`` hook, which the
+    producer calls when a null-key record would have triggered a fresh
+    batch, giving the partitioner a chance to rotate off its current sticky
+    choice. The hook is looked up with ``getattr``, so it is entirely
+    optional.
+    """
+
     @abstractmethod
     def partition(self, topic, key, serialized_key, value, serialized_value, cluster):
+        """Choose a partition for a record.
+
+        Arguments:
+            topic (str): The topic the record is destined for.
+            key: The user-supplied key, before serialization. May be None.
+            serialized_key (bytes): The post-serializer key bytes, or None
+                when the caller passed ``key=None``.
+            value: The user-supplied value, before serialization.
+            serialized_value (bytes): The post-serializer value bytes, or
+                None when the caller passed ``value=None``.
+            cluster (ClusterMetadata): A live cluster snapshot. Use
+                ``cluster.partitions_for_topic(topic)`` for all partitions
+                and ``cluster.available_partitions_for_topic(topic)`` for
+                those whose leader is currently known.
+
+        Returns:
+            int: The partition id to assign the record to.
+
+        Raises:
+            ValueError: If the topic is not present in cluster metadata.
+                Partitioner exceptions surface to the caller via the
+                returned :class:`~kafka.producer.future.FutureRecordMetadata`.
+        """
         pass
 

kafka/producer/future.py

@@ -30,6 +30,19 @@ class FutureProduceResult(Future):
 
 
 class FutureRecordMetadata(Future):
+    """An asynchronous handle to the result of a single :meth:`~kafka.KafkaProducer.send`.
+
+    :meth:`~kafka.KafkaProducer.send` returns one of these immediately,
+    before the record has been transmitted to the broker. Call :meth:`get`
+    to block until the record is acknowledged and obtain its
+    :class:`RecordMetadata`, or register callbacks via
+    :meth:`~kafka.future.Future.add_callback` /
+    :meth:`~kafka.future.Future.add_errback` to be notified without
+    blocking. The future resolves successfully once the containing batch is
+    acknowledged according to the producer's ``acks`` configuration, or
+    fails with the relevant exception (for example
+    :class:`~kafka.errors.KafkaTimeoutError`).
+    """
     __slots__ = ('_produce_future', 'args')
     def __init__(self, produce_future, batch_index, timestamp_ms, checksum, serialized_key_size, serialized_value_size, serialized_header_size):
         super().__init__()
@@ -99,3 +112,28 @@ class FutureRecordMetadata(Future):
 RecordMetadata = collections.namedtuple(
     'RecordMetadata', ['topic', 'partition', 'topic_partition', 'offset', 'timestamp',
                        'checksum', 'serialized_key_size', 'serialized_value_size', 'serialized_header_size'])
+RecordMetadata.__doc__ = """Metadata about a record that has been acknowledged by the broker.
+
+Returned by :meth:`FutureRecordMetadata.get`, which resolves once the
+batch containing the record has been acknowledged according to the
+producer's ``acks`` configuration.
+
+Keyword Arguments:
+    topic (str): The topic the record was appended to.
+    partition (int): The partition the record was appended to.
+    topic_partition (TopicPartition): The ``(topic, partition)`` the record
+        was appended to.
+    offset (int): The offset of the record in the topic partition, or -1 if
+        the broker did not assign one (e.g. ``acks=0``).
+    timestamp (int): The timestamp of the record, in milliseconds since the
+        epoch (UTC). For CreateTime this is the producer-supplied timestamp;
+        for LogAppendTime it is the broker-assigned timestamp.
+    checksum (int): Deprecated. The CRC32 checksum of the record, or None.
+        Removed in message format v2 (Kafka 0.11+).
+    serialized_key_size (int): The size of the serialized, uncompressed key
+        in bytes, or -1 if the key is None.
+    serialized_value_size (int): The size of the serialized, uncompressed
+        value in bytes, or -1 if the value is None.
+    serialized_header_size (int): The size of the serialized, uncompressed
+        headers in bytes, or -1 if there are no headers.
+"""

kafka/producer/kafka.py

@@ -282,7 +282,7 @@ class KafkaProducer:
             Default: 30000.
         receive_message_max_bytes (int): Maximum allowed network frame size.
             Used to avoid OOM when decoding malformed network message header.
-            Default: 1000000.
+            Default: 100_000_000.
         receive_buffer_bytes (int): The size of the TCP receive buffer
             (SO_RCVBUF) to use when reading data. Default: None (relies on
             system defaults). Java client defaults to 32768.
@@ -425,7 +425,7 @@ class KafkaProducer:
         'client_dns_lookup': 'use_all_dns_ips',
         'retry_backoff_ms': 100,
         'request_timeout_ms': 30000,
-        'receive_message_max_bytes': 1000000,
+        'receive_message_max_bytes': 100_000_000,
         'receive_buffer_bytes': None,
         'send_buffer_bytes': None,
         'socket_options': [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)],

kafka/structs.py

@@ -51,19 +51,33 @@ Keyword Arguments:
 """
 
 
+class MemberState:
+    UNJOINED = '<unjoined>'  # the client is not part of a group
+    REBALANCING = '<rebalancing>'  # the client has begun rebalancing
+    STABLE = '<stable>'  # the client has joined and is sending heartbeats
+
+
 ConsumerGroupMetadata = namedtuple("ConsumerGroupMetadata",
-    ["group_id", "generation_id", "member_id", "group_instance_id"],
-    defaults=[-1, '', None])
-ConsumerGroupMetadata.__doc__ = """A snapshot of a consumer's group membership (KIP-447).
+    ["group_id", "generation_id", "member_id", "group_instance_id", "state"],
+    defaults=[None, -1, '', None, MemberState.UNJOINED])
+ConsumerGroupMetadata.__doc__ = """A snapshot of a consumer's group membership.
+
+The first four fields are the KIP-447 fencing identity: pass the snapshot to
+KafkaProducer.send_offsets_to_transaction() so the broker can fence stale
+consumer instances when committing offsets inside a transaction. The broker
+uses member_id + generation_id + group_instance_id to verify the producer is
+acting on behalf of the current group generation.
 
-Passed to KafkaProducer.send_offsets_to_transaction() so the broker can fence
-stale consumer instances when committing offsets inside a transaction. The
-broker uses member_id + generation_id + group_instance_id to verify the
-producer is acting on behalf of the current group generation.
+The ``state`` field exposes the live MemberState (it is ignored by the
+producer/fencing path). It lets callers observe whether the consumer has
+converged on a stable assignment - useful for monitoring and for tests that
+wait for a group to finish rebalancing.
 
 Keyword Arguments:
-    group_id (str): The consumer group id.
+    group_id (str): The consumer group id, or None for manual assignment.
     generation_id (int): The current generation id (-1 if unjoined).
     member_id (str): The current member id ('' if unjoined).
     group_instance_id (str): The static membership instance id, or None.
+    state (str): The current MemberState (one of MemberState.UNJOINED,
+        MemberState.REBALANCING, MemberState.STABLE).
 """

kafka/version.py

@@ -1 +1 @@
-__version__ = '3.0.0'
+__version__ = '3.0.2'

{kafka_python-3.0.0.dist-info → kafka_python-3.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kafka-python
-Version: 3.0.0
+Version: 3.0.2
 Summary: Pure Python client for Apache Kafka
 Author-email: Dana Powers <dana.powers@gmail.com>
 License-Expression: Apache-2.0

{kafka_python-3.0.0.dist-info → kafka_python-3.0.2.dist-info}/RECORD

@@ -4,9 +4,9 @@ kafka/cluster.py,sha256=P1-ylBAa33FAelwufsod_ouIp2FCfE-MI6_sNnxJyJc,32429
 kafka/codec.py,sha256=xApRCUaj6HsGM6T5q-AeK9kRPkH6Au1wqsXwXhwE2Lo,9843
 kafka/errors.py,sha256=9owgtTIcttdTCD1vAF9wz5jL9G72ljpR7M-vjLKEGvY,33206
 kafka/future.py,sha256=INmMIy2-BPxJ4zlw-V_i8Tj_OG9DMbyYyUEjOQ5pn_o,5440
-kafka/structs.py,sha256=XRIkQpiJOVgMWXItkv7zCvAT-x4O-55v9EhtGUcgk9A,2404
+kafka/structs.py,sha256=ZOFmVJRbhSXykkw9cnuv-DGYE7g2KjaUGsytSOv4xVw,3146
 kafka/util.py,sha256=hvSdRbh5-IsUbpD_BqjabjEldtNmXufZH68b_xCkNjE,5194
-kafka/version.py,sha256=WZxVB-2_454JxgdmIIsxG-DUc65ia-VgtyjcgvV4mro,22
+kafka/version.py,sha256=FDUC8xOuizaRKSkyG1VOmlDwzcPJgbzFUWz58fhdUGQ,22
 kafka/admin/__init__.py,sha256=nTXg2CQo8Bydxsj80pVBzF2-jq4IhK7_gLnboeNWG60,1575
 kafka/admin/__main__.py,sha256=l5ujkHa3lBFEbKPCl7U0_pi6IIgj1IJfmB219vtcj50,69
 kafka/admin/_acls.py,sha256=QJlHguEM9t46qlABoQqTEDFQErDgG2RKwfV1NOKeKmU,13983
@@ -17,7 +17,7 @@ kafka/admin/_partitions.py,sha256=xQ5toaocldfZOnghfa2-q95J7AdJjDJNMggzqCjRy9Q,26
 kafka/admin/_topics.py,sha256=B9xjKQXHcFosOCBg1faSvhrbh7AoqalUkn4t28jxxAo,12429
 kafka/admin/_transactions.py,sha256=D4iLBEu3aXbykFDm6Q1knVXc9GUMuap6TW4RI1U2Rvs,19917
 kafka/admin/_users.py,sha256=NKaxwUuskMTyRHXU__ImU7IGH1iaqrPe2Zp36Pvso54,6909
-kafka/admin/client.py,sha256=72oz4vy_Jr-mnk1Tj6D3_4XbT2g74T9XbdzQQJSXVSk,18308
+kafka/admin/client.py,sha256=YDitvRX6y1B7tz2mExzPtWKFJyrTOF5nxrqh-kpStW4,18316
 kafka/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kafka/benchmarks/consumer_performance.py,sha256=HBJTS7Szr6y3OAszrTHskr-5snW5ia8tk16ZtSz2gyA,4811
 kafka/benchmarks/load_example.py,sha256=aivu9HHYtkODnecIx4AxeLUx9U42bRjGwtWa_b_MO44,3425
@@ -83,11 +83,11 @@ kafka/cli/consumer/__init__.py,sha256=eNb-AFzLj9QJrEeZZsp427uZ-BDGSIG9Bp3bbOYgvp
 kafka/cli/producer/__init__.py,sha256=W3Rs0Darw2f3h1IZZawep1K-LVg2AA0bEuwEEaqPjKg,1682
 kafka/consumer/__init__.py,sha256=I7nuPUb103S1CvCqcudbIRG_isJbRgTXkK1mpHIhoVs,82
 kafka/consumer/__main__.py,sha256=bnxM30LbGVvLb0ZBcgJEt_8bZHADJpboHZCxzd8QEhA,72
-kafka/consumer/fetcher.py,sha256=tYeH8JFChgifxRX08TV7THiUbpKIQ3O087C6TF3XnJs,100781
-kafka/consumer/group.py,sha256=bnU0yulSTEnfLPe-eLI4RQl8t0WYZhNSj20edcogynE,67064
+kafka/consumer/fetcher.py,sha256=hOj0ecZxsp83pUf6K0PZY01PCpEZhBjoJymk9bpv4Qc,102423
+kafka/consumer/group.py,sha256=lJo2U_wHSk_j-qwfa2GeU_gOZq5kWbxh2qAkjyMer6Q,68423
 kafka/consumer/subscription_state.py,sha256=H1bDpDdy3uk3U8TtyjCuo_HmaZmSpOYevaYtrc7LvgY,38567
 kafka/coordinator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kafka/coordinator/base.py,sha256=9zrVjA2-tztXkZws3Xi_b6wq5eASnHrdRef5Zp1Gb-s,57868
+kafka/coordinator/base.py,sha256=gIzjv60NIC6zlkgUm1w-yG-S5i6fy_pSo3BJEBbOD9M,57841
 kafka/coordinator/consumer.py,sha256=cQ-zo0p_lL5H3j8DT4Q6ZrBBxCWWh4p1ub1X2IHlx5w,60186
 kafka/coordinator/heartbeat.py,sha256=JUlq_-TqOd6kwiFcapa20sgaM8lSZ2JgObEzeTTcDm0,3229
 kafka/coordinator/subscription.py,sha256=rq-syb2zwjRiY1797Yi4dxTZH-QFJSsaNAAJVwBHrqA,873
@@ -133,7 +133,7 @@ kafka/net/http_connect.py,sha256=j8R1yLNwhTF-nQVMEgRF88mOF5-v1Sdj7uwkBvvg5PU,513
 kafka/net/inet.py,sha256=zMo0NTCS7EY81uoNPri5ZHKcCnRVUIcCJiW6BeZWnCs,4730
 kafka/net/manager.py,sha256=nq7eKgzkazQ3sFLXQ-IOIFQ3FdyZYzfKxYxVrwYPGsc,19427
 kafka/net/metrics.py,sha256=-cdWXQtonCO7-LpovLoEcWM-_3R9sAtyQxWf_QHOAWE,7299
-kafka/net/selector.py,sha256=Vmgs69fWt3PnG5kLrDbGIX_W21M48naK2aZrvzhFYWg,24690
+kafka/net/selector.py,sha256=4_g3AtYQfmhMjzFgtFOE_TbkIIifFWW5B8zvQmyBJCI,25733
 kafka/net/socks5.py,sha256=euTwJl2avRmCJhVKyGmhZWInqgY6MNHPA1Tz2f2J1Z0,10361
 kafka/net/transport.py,sha256=hfdoQ9dMOXrMxxLJ6c4A69OGN3_FuRvDL5UuFJ1X-sA,15116
 kafka/net/wakeup_notifier.py,sha256=hmxwrrqZ8zFHSHGYaorV7vdOoKo9SF3-VoS7YGkPq_w,2926
@@ -146,13 +146,13 @@ kafka/net/sasl/plain.py,sha256=Vx3VfF2CRzHZV8A--1VRRyhQcJqadgaCmd9Gb2dpfes,1402
 kafka/net/sasl/scram.py,sha256=Q87VPsAoH-ujtAHOhWzvqY5Kks6BJ7NQPOXZ5-Fwbz0,5272
 kafka/net/sasl/sspi.py,sha256=mIZSXWutKKo4BXMa1Cuw4uL-r8VzicrVkkiJDMhBdDA,5027
 kafka/partitioner/__init__.py,sha256=xEF0Uta4wS0VLsOHsOZlkpnB095pavtgMBt1QVJuE_Q,204
-kafka/partitioner/abc.py,sha256=063N4YlEzU0LrJi7mD3p_kzHS3UQcmkmAhqAScn8j-M,183
+kafka/partitioner/abc.py,sha256=OXXFEvRf1sqAsebA2mKSWJ6jdKIyNgqoWTIj84me_78,2358
 kafka/partitioner/default.py,sha256=ZD8SeTffJCPsNjo4GZ7y4cWVW6iG6NybRZuWbul231g,2635
 kafka/partitioner/sticky.py,sha256=A3pfCrFl-jhmpqTANlRcQ5ixd_e-F3K8-d42ugaE378,4804
 kafka/producer/__init__.py,sha256=OPWP89JbP1dCYG4HSWl1iz6KLun0oJDYfqLAr0vAfHQ,82
 kafka/producer/__main__.py,sha256=h5u6-EfA7bJFszn0x-QV14pZt4MOJw0jiPHKuMSkCOY,72
-kafka/producer/future.py,sha256=iKtaZ49zfFsn8ZKmQiQI19_IIInr1T_NDC7kuJmg9p4,4580
-kafka/producer/kafka.py,sha256=u3_RzDKPA6o1aN27zwk45IhU7fbiKW-HXweoUImR0yE,59330
+kafka/producer/future.py,sha256=D5_8Hz-8CqJZYEVMieUk7wBhKS83skFnisGlsyosIbk,6669
+kafka/producer/kafka.py,sha256=j01YfmZn3sNigHBNITd5CLeohu4WF0FVTFE1E6Pj5O8,59338
 kafka/producer/producer_batch.py,sha256=gFuJNaUM9gHs0KpgQ0KFZCIlBy43OnrRyzo2xb0HSTo,8027
 kafka/producer/record_accumulator.py,sha256=B6C64fNzD7MIFsWV-kJFrahKRVS5dYniI3OFhnUqvRw,28039
 kafka/producer/sender.py,sha256=aV4skH8T1xncOidyS8do0Gv2jcr97u3CHx5wXlrPTik,44608
@@ -365,9 +365,9 @@ kafka/serializer/default.py,sha256=ZKzTWlG9N4vS3QXovFLygNVrnjAcMZKS0RE4OvQ6DL4,4
 kafka/serializer/json.py,sha256=lErgU66KZGf33hofwlObYIaxLDk9gcolhy_rlcOuf8Y,469
 kafka/serializer/wrapper.py,sha256=RGXFj-PXQyL3rdMXI9ACaohRa6Kg5SHOZTRruU9jluM,485
 kafka/vendor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kafka_python-3.0.0.dist-info/licenses/LICENSE,sha256=vxnoJsqm6bKl3ZWdI1Q7Ikw_k9cOvO3vcvZNsY_1fP8,11374
-kafka_python-3.0.0.dist-info/METADATA,sha256=aM-Hwgx22NuqI7XY4ALInMBRAke9d0ABG4XxsJ327mU,11590
-kafka_python-3.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-kafka_python-3.0.0.dist-info/entry_points.txt,sha256=LQvqZj3uM785ainO5HrXmukbjSrK-oPqrESqpvoR-As,51
-kafka_python-3.0.0.dist-info/top_level.txt,sha256=IivJz7l5WHdLNDT6RIiVAlhjQzYRwGqBBmKHZ7WjPeM,6
-kafka_python-3.0.0.dist-info/RECORD,,
+kafka_python-3.0.2.dist-info/licenses/LICENSE,sha256=vxnoJsqm6bKl3ZWdI1Q7Ikw_k9cOvO3vcvZNsY_1fP8,11374
+kafka_python-3.0.2.dist-info/METADATA,sha256=jQB9VNg9SS9r4_i52w7nofQF2k0ZWblwKCsiGc86a8k,11590
+kafka_python-3.0.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+kafka_python-3.0.2.dist-info/entry_points.txt,sha256=LQvqZj3uM785ainO5HrXmukbjSrK-oPqrESqpvoR-As,51
+kafka_python-3.0.2.dist-info/top_level.txt,sha256=IivJz7l5WHdLNDT6RIiVAlhjQzYRwGqBBmKHZ7WjPeM,6
+kafka_python-3.0.2.dist-info/RECORD,,