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

kafka/cli/admin/cluster/versions.py

@@ -30,4 +30,4 @@ class GetBrokerVersion:
     def command(cls, client, args):
         broker_id = int(args.broker)
         bvd = client.get_broker_version_data(broker_id)
-        return {broker_id: '.'.join(map(str, bvd.broker_version))}
+        return {broker_id: bvd.broker_version_str}

kafka/cli/common.py

@@ -1,4 +1,5 @@
 import logging
+import logging.config
 
 
 def add_connect_cli_args(parser, bootstrap_required=True):
@@ -37,9 +38,13 @@ def build_kwargs(props):
 def build_connect_kwargs(config):
     if not config.bootstrap_servers:
         raise ValueError('python -m kafka: error: the following arguments are required: -b/--bootstrap-servers')
+    # Accept both repeated -b flags and comma-separated lists within a single flag
+    bootstrap_servers = []
+    for entry in config.bootstrap_servers:
+        bootstrap_servers.extend(s.strip() for s in entry.split(',') if s.strip())
     kwargs = build_kwargs(config.extra_config)
     kwargs.update({
-        'bootstrap_servers': config.bootstrap_servers,
+        'bootstrap_servers': bootstrap_servers,
         'security_protocol': config.security_protocol,
         'sasl_mechanism': config.sasl_mechanism,
         'sasl_plain_username': config.sasl_user,
@@ -59,12 +64,60 @@ def add_logging_cli_args(parser):
     logging_group.add_argument(
         '-D', '--disable-logger', type=str, action='append',
         help='disable a specific logger. Can be provided multiple times.')
+    logging_group.add_argument(
+        '--log-format', type=str, default=None,
+        help='log message format string, passed to logging.Formatter')
+    logging_group.add_argument(
+        '--log-date-format', type=str, default=None,
+        help='log date format string, passed to logging.Formatter')
+    logging_group.add_argument(
+        '--log-file', type=str, default=None,
+        help='write logs to this file instead of stderr')
+    logging_group.add_argument(
+        '--log-config', type=str, default=None,
+        help='path to a logging configuration file for full control over handlers, '
+             'formatters, etc. A .json (or .yaml/.yml, if PyYAML is installed) file is '
+             'loaded as a logging.config.dictConfig; any other extension is loaded as a '
+             'logging.config.fileConfig. The file owns handlers/formatters, so --log-format, '
+             '--log-date-format and --log-file are ignored, but --enable-logger and '
+             '--disable-logger still apply as logger level adjustments.')
+
+
+def add_extended_cli_args(parser):
     extended_group = parser.add_argument_group('extended')
     extended_group.add_argument(
         '-C', '--extra-config', type=str, action='append',
         help='additional configuration properties for client in "key=val" format. Can be provided multiple times.')
 
 
+def _load_log_config(path):
+    """Configure logging from a dictConfig (.json/.yaml) or fileConfig (.ini) file."""
+    if path.endswith(('.yaml', '.yml')):
+        try:
+            import yaml
+        except ImportError:
+            raise ValueError('PyYAML is required to load a YAML logging config: %s' % (path,))
+        with open(path) as f:
+            _dict_config(yaml.safe_load(f))
+    elif path.endswith('.json'):
+        import json
+        with open(path) as f:
+            _dict_config(json.load(f))
+    else:
+        # disable_existing_loggers defaults to True, which would silence loggers
+        # configured before this call (e.g. the loggers we are about to enable);
+        # keep them around so --enable-logger still works.
+        logging.config.fileConfig(path, disable_existing_loggers=False)
+
+
+def _dict_config(cfg):
+    # Default disable_existing_loggers to False (dictConfig defaults to True), so a
+    # config that does not mention an already-created logger does not silence it.
+    # A config may still set it explicitly to opt into the stdlib default.
+    cfg.setdefault('disable_existing_loggers', False)
+    logging.config.dictConfig(cfg)
+
+
 def configure_logging(config):
     _LOGGING_LEVELS = {
         'NOTSET': 0,
@@ -74,22 +127,43 @@ def configure_logging(config):
         'ERROR': 40,
         'CRITICAL': 50,
     }
-    if config.enable_logger is not None:
-        log_level = _LOGGING_LEVELS[config.log_level.upper()]
-        handler = logging.StreamHandler()
-        handler.setLevel(log_level)
-        handler.setFormatter(logging.Formatter(logging.BASIC_FORMAT))
-        for name in config.enable_logger:
-            logger = logging.getLogger(name)
-            logger.setLevel(log_level)
-            logger.addHandler(handler)
+    log_level = _LOGGING_LEVELS[config.log_level.upper()]
+    if getattr(config, 'log_config', None):
+        _load_log_config(config.log_config)
+        if config.enable_logger is not None:
+            # Preserve the no-config behavior of --enable-logger: ONLY the named
+            # loggers emit. The config file owns the handlers/formatters, so rather
+            # than attach our own we reuse them: silence everything else by raising
+            # the root level, then let each enabled logger opt back in and propagate
+            # its records up to the config's handlers.
+            logging.getLogger().setLevel(logging.CRITICAL + 1)
+            for name in config.enable_logger:
+                logger = logging.getLogger(name)
+                logger.disabled = False
+                logger.setLevel(log_level)
     else:
-        logging.basicConfig(level=_LOGGING_LEVELS[config.log_level.upper()])
-    if config.disable_logger is not None:
-        for name in config.disable_logger:
-            logging.getLogger(name).setLevel(logging.CRITICAL + 1)
+        log_format = config.log_format or logging.BASIC_FORMAT
+        if config.enable_logger is not None:
+            if config.log_file:
+                handler = logging.FileHandler(config.log_file)
+            else:
+                handler = logging.StreamHandler()
+            handler.setLevel(log_level)
+            handler.setFormatter(logging.Formatter(log_format, datefmt=config.log_date_format))
+            for name in config.enable_logger:
+                logger = logging.getLogger(name)
+                logger.setLevel(log_level)
+                logger.addHandler(handler)
+        else:
+            logging.basicConfig(
+                level=log_level, format=log_format,
+                datefmt=config.log_date_format, filename=config.log_file)
+    # --disable-logger silences a named logger in either mode by raising its level.
+    for name in config.disable_logger or []:
+        logging.getLogger(name).setLevel(logging.CRITICAL + 1)
 
 
 def add_common_cli_args(parser, bootstrap_required=True):
     add_connect_cli_args(parser, bootstrap_required)
     add_logging_cli_args(parser)
+    add_extended_cli_args(parser)

kafka/cluster.py

@@ -125,9 +125,8 @@ class ClusterMetadata:
             if ttl_ms == 0:
                 try:
                     await self.refresh_metadata()
-                except Errors.KafkaError as exc:
-                    log.debug('Metadata refresh failed: %s', exc)
-                    log.exception(exc)
+                except Errors.KafkaError:
+                    log.debug('Metadata refresh failed', exc_info=True)
                 continue
             try:
                 log.debug('Sleeping %s for next Metadata refresh', ttl_ms / 1000)
@@ -168,7 +167,6 @@ class ClusterMetadata:
             raise Errors.NodeNotReadyError('metadata')
         else:
             self._manager.reset_backoff('metadata')
-        log.info(f'Metadata refresh (node_id={node_id})')
         try:
             request = self.metadata_request()
             log.debug("Sending metadata request %s to node %s", request, node_id)
@@ -177,7 +175,7 @@ class ClusterMetadata:
             log.error('Metadata refresh: failed %s', exc)
             self.failed_update(exc)
             raise
-        log.debug('Metadata refresh: success')
+        log.debug(f'Metadata refresh: success (node_id={node_id})')
         self.update_metadata(response)
 
     def _generate_bootstrap_brokers(self):

kafka/consumer/fetcher.py

@@ -232,9 +232,18 @@ class Fetcher:
         # No records yet. Block until either an in-flight fetch
         # completes (records may have arrived) or a pending offset-reset
         # task completes (positions become available, enabling a fetch
-        # on the next caller iteration). add_both fires synchronously on
-        # already-done futures, closing the race where a future resolves
-        # between scheduling and the wait setup.
+        # on the next caller iteration).
+        #
+        # add_both fires synchronously on an already-done future: if a fetch
+        # response lands between the drain above and this wait setup, _wake
+        # fires immediately so we re-drain instead of stalling for the full
+        # timeout.
+        #
+        # This relies on _fetch_futures holding only *recent* completions.
+        # otherwise a fetch that completed and was already drained iterations
+        # ago lingers behind a slow broker's in-flight fetch and re-fires
+        # _wake on every call, busy-looping the poll loop until that slow
+        # fetch finally returns.
         waited_on = list(self._fetch_futures)
         if self._reset_task is not None and not self._reset_task.is_done:
             waited_on.append(self._reset_task)
@@ -277,21 +286,66 @@ class Fetcher:
             future.add_both(self._clear_pending_fetch_request, node_id)
             futures.append(future)
         self._fetch_futures.extend(futures)
-        self._clean_done_fetch_futures()
+        await self._clean_done_fetch_futures()
         return futures
 
-    def _clean_done_fetch_futures(self):
-        while True:
-            if not self._fetch_futures:
-                break
-            if not self._fetch_futures[0].is_done:
-                break
-            self._fetch_futures.popleft()
+    async def _clean_done_fetch_futures(self):
+        # Drop every completed fetch future. With multiple brokers, fetches
+        # may complete out of order. fetch_records() relies on _fetch_futures
+        # holding only recent completions (it fires _wake synchronously on any
+        # done future to avoid stalling -- see the wait setup there); a
+        # lingering stale completion re-fires that wake on every call and busy-
+        # loops the poll loop until the slow broker's in-flight fetch returns.
+        #
+        # Threading: this REBINDS self._fetch_futures, which must happen on the
+        # IO thread so it never races the foreground's list(self._fetch_futures)
+        # read in fetch_records(). Defined async to enforce that -- the body
+        # can only run by being driven on the IO loop (awaited from another
+        # coroutine, or scheduled via manager.run/call_soon), so the rebind
+        # always executes on the IO thread regardless of who initiates it.
+        # The rebind is a single atomic attribute store, so a foreground reader
+        # always sees either the old or the new deque, never a half-cleaned one.
+        #
+        # Two alternate designs we considered (either would remove the need for
+        # this "evict every done future + rebind" dance):
+        #
+        #   1. Wakeup flag (Apache Kafka Java client, FetchBuffer). Instead of
+        #      waiting on the fetch-future objects, wait on a single consumable
+        #      signal: the IO thread sets a flag (wokenup) when it buffers a
+        #      completed fetch; the foreground's wait loops `while not woken:
+        #      await` and consumes the flag (compareAndSet true->false) on each
+        #      pass. Because the signal is cleared on consumption and is not
+        #      re-derived from lingering future objects, a stale/drained
+        #      completion cannot re-trigger it -- so no busy-loop and no
+        #      per-call cleanup of a future list at all. This is the most
+        #      faithful port of the threaded Java consumer's design.
+        #
+        #   2. Per-node fetch tracking. Key fetches by broker: dict[node_id,
+        #      deque] (or just dict[node_id, Future], since _create_fetch_-
+        #      requests keeps at most one in-flight fetch per node). Within a
+        #      single connection responses return in request order, so each
+        #      per-node deque completes in order and the simple head-only
+        #      popleft cleanup is correct again -- no out-of-order stranding,
+        #      and cleanup is an in-place popleft (atomic, no rebind, so the
+        #      threading note above goes away). This structure could also
+        #      subsume _nodes_with_pending_fetch_requests entirely ("pending"
+        #      == the node's last future is not done), collapsing two
+        #      structures into one source of truth.
+        if not self._fetch_futures:
+            return
+        self._fetch_futures = collections.deque(
+            fut for fut in self._fetch_futures if not fut.is_done)
 
     def in_flight_fetches(self):
-        """Return True if there are any unprocessed FetchRequests in flight."""
-        self._clean_done_fetch_futures()
-        return bool(self._fetch_futures)
+        """Return True if there are any unprocessed (incomplete) FetchRequests
+        in flight."""
+
+        # Read-only on purpose: this may be called from the foreground thread,
+        # which must not mutate _fetch_futures (see _clean_done_fetch_futures --
+        # cleanup is IO-thread-only). Snapshot first so we never iterate the
+        # deque while the IO thread extends it, and check is_done directly
+        # rather than relying on a prior cleanup pass.
+        return any(not fut.is_done for fut in list(self._fetch_futures))
 
     def reset_offsets_if_needed(self, timeout_ms=None):
         """Schedule pending offset resets and return the in-flight Task.

kafka/coordinator/base.py

@@ -1117,10 +1117,11 @@ class BaseCoordinator(ABC):
         try:
             send_time = time.monotonic()
             response = await self._manager.send(request, node_id=self.coordinator_id)
-            return self._handle_heartbeat_response(response, send_time)
         except Errors.KafkaError as exc:
             self._failed_request(self.coordinator_id, request, exc)
             raise
+        else:
+            return self._handle_heartbeat_response(response, send_time)
 
     def _handle_heartbeat_response(self, response, send_time):
         if self._sensors:
@@ -1138,8 +1139,7 @@ class BaseCoordinator(ABC):
                         self.coordinator_id)
             self.coordinator_dead(error)
         elif error_type is Errors.RebalanceInProgressError:
-            heartbeat_log.warning("Heartbeat failed for group %s because it is"
-                                  " rebalancing", self.group_id)
+            heartbeat_log.info("Group %s is rebalancing; rejoining.", self.group_id)
             self.request_rejoin()
         elif error_type is Errors.IllegalGenerationError:
             heartbeat_log.warning("Heartbeat failed for group %s: generation id is not "
@@ -1158,7 +1158,6 @@ class BaseCoordinator(ABC):
             heartbeat_log.error("Heartbeat failed: authorization error: %s", error)
         else:
             heartbeat_log.error("Heartbeat failed: Unhandled error: %s", error)
-
         raise error
 
 

kafka/net/connection.py

@@ -96,7 +96,7 @@ class KafkaConnection:
         return self._init_future
 
     def __await__(self):
-        yield self.init_future
+        yield from self.init_future.__await__()   # == await self.init_future; raises on failure
         return self
 
     @property
@@ -203,7 +203,7 @@ class KafkaConnection:
             if req_correlation_id != resp_correlation_id:
                 return self.close(Errors.KafkaConnectionError('Received unrecognized correlation id'))
 
-            self.net.unschedule(timeout_task)
+            self.net.cancel(timeout_task)
             latency_ms = (time.monotonic() - sent_time) * 1000
             if self._sensors:
                 self._sensors.request_time.record(latency_ms)
@@ -239,8 +239,10 @@ class KafkaConnection:
             self._init_future.failure(error)
         if not self._close_future.is_done:
             if exc is None:
+                log.info('%s: Connection closed', self)
                 self._close_future.success(None)
             else:
+                log.error('%s: Connection lost: %s', self, exc)
                 self._close_future.failure(exc)
 
     def fail_in_flight_requests(self, error):
@@ -252,7 +254,7 @@ class KafkaConnection:
             future.failure(error)
         while self.in_flight_requests:
             _, future, _, _, timeout_task = self.in_flight_requests.popleft()
-            self.net.unschedule(timeout_task)
+            self.net.cancel(timeout_task)
             future.failure(error)
 
     def connection_made(self, transport):
@@ -262,6 +264,13 @@ class KafkaConnection:
         To receive data, wait for data_received() calls.
         When the connection is closed, connection_lost() is called.
         """
+        if self.closed:
+            # A concurrent close() may have torn the connection down while the
+            # transport was still being built. Setting initializing=True below
+            # would resurrect an already-closed connection mid-teardown and
+            # break the fail_in_flight_requests invariant; refuse instead. The
+            # caller (manager._connect) closes the orphaned transport.
+            raise Errors.KafkaConnectionError('Connection closed during connect')
         self.transport = transport
         if self.transport.get_protocol() != self:
             self.transport.set_protocol(self)
@@ -276,6 +285,7 @@ class KafkaConnection:
             client_id=self.config['client_id'],
             receive_message_max_bytes=self.config['receive_message_max_bytes'],
             ident=log_prefix)
+        log.debug('%s: Connection made', self)
 
     def pause(self, v):
         self.paused.add(v)
@@ -362,6 +372,7 @@ class KafkaConnection:
             self.close(error)
         else:
             self._init_complete()
+            log.info('%s: Connected', self)
 
     async def _get_api_versions(self, timeout_at=None):
         if timeout_at is None:
@@ -400,11 +411,15 @@ class KafkaConnection:
         api_versions = {api_version.api_key: (api_version.min_version, api_version.max_version)
                         for api_version in response.api_keys}
         bvd = BrokerVersionData(api_versions=api_versions)
-        log.info('%s: Broker version identified as %s', self, '.'.join(map(str, bvd.broker_version)))
-        if self.broker_version_data is None or self.broker_version_data > bvd:
+        if self.broker_version_data is None:
+            log.info('%s: Broker version identified as %s', self, bvd.broker_version_str)
             self.broker_version_data = bvd
-        else:
-            log.info('%s: Clamping client to user-supplied broker version %s', self, '.'.join(map(str, self.broker_version)))
+        elif self.broker_version_data > bvd:
+            log.info('%s: Broker version identified as %s (lower than user-supplied %s)', self, bvd.broker_version_str, self.broker_version_data.broker_version_str)
+            self.broker_version_data = bvd
+        elif self.broker_version_data is not None and self.broker_version_data < bvd:
+            log.info('%s: Broker version identified as %s; clamping to user-supplied %s', self, bvd.broker_version_str, self.broker_version_data.broker_version_str)
+        # No log if user-supplied api_version is the same as broker-identified version
 
     @property
     def sasl_enabled(self):
@@ -534,10 +549,7 @@ class SaslReauthenticator:
         """Cancel any pending re-auth and fail the drain awaiter if present.
         Called from KafkaConnection.connection_lost."""
         if self._task is not None:
-            try:
-                self._conn.net.unschedule(self._task)
-            except (ValueError, KeyError):
-                pass
+            self._conn.net.cancel(self._task)
             self._task = None
         if self._drain_future is not None and not self._drain_future.is_done:
             self._drain_future.failure(Errors.KafkaConnectionError())

kafka/net/manager.py

@@ -73,7 +73,7 @@ class KafkaConnectionManager:
                 "client_dns_lookup must be one of %s; got %r"
                 % (self._VALID_DNS_LOOKUP_MODES, self.config['client_dns_lookup']))
 
-        if 'socks5_proxy' in configs:
+        if configs.get('socks5_proxy') is not None:
             if self.config['proxy_url'] is None:
                 log.warning('socks5_proxy is deprecated, use proxy_url instead')
                 self.config['proxy_url'] = configs['socks5_proxy']
@@ -117,7 +117,9 @@ class KafkaConnectionManager:
     async def _do_bootstrap(self, deadline):
         while not self.closed and (deadline is None or time.monotonic() < deadline):
             bootstrap_broker = random.choice(self.cluster.bootstrap_brokers())
-            log.debug('Attempting bootstrap with %s', bootstrap_broker)
+            log.info('Attempting bootstrap to %s at %s:%s (rack %s)',
+                     bootstrap_broker.node_id, bootstrap_broker.host,
+                     bootstrap_broker.port, bootstrap_broker.rack)
             try:
                 timeout_ms = (deadline - time.monotonic()) * 1000 if deadline is not None else None
                 conn = self.get_connection(bootstrap_broker.node_id,
@@ -129,7 +131,7 @@ class KafkaConnectionManager:
                 delay = self.connection_delay(bootstrap_broker.node_id)
                 if deadline is not None:
                     delay = min(delay, max(0, deadline - time.monotonic()))
-                log.debug('Bootstrap %s NodeNotReadyError: backoff %s', bootstrap_broker, delay)
+                log.warning('Bootstrap %s not ready; waiting %.2f secs', bootstrap_broker.node_id, delay)
                 await self._bootstrap_wakeup(delay)
                 continue
 
@@ -145,12 +147,12 @@ class KafkaConnectionManager:
             try:
                 await self.cluster.refresh_metadata(bootstrap_broker.node_id)
                 if not self.cluster.brokers():
-                    log.warning('Bootstrap metadata response has no brokers. Retrying.')
-                    self.update_backoff(bootstrap_broker.node_id)
+                    backoff_ms = self.update_backoff(bootstrap_broker.node_id)
+                    log.warning('Bootstrap metadata response has no brokers. Retrying in %.2f secs.', backoff_ms / 1000)
                     continue
             except Exception as exc:
-                log.error(f'Bootstrap attempt to {bootstrap_broker.node_id} failed: {exc}')
-                self.update_backoff(bootstrap_broker.node_id)
+                backoff_ms = self.update_backoff(bootstrap_broker.node_id)
+                log.error(f'Bootstrap attempt to {bootstrap_broker.node_id} failed: {exc} (backoff {(backoff_ms / 1000):.2f} secs)')
                 continue
             else:
                 self.reset_backoff(bootstrap_broker.node_id)
@@ -158,6 +160,7 @@ class KafkaConnectionManager:
                 log.info('Bootstrap complete: %s', self.cluster)
                 return True
             finally:
+                log.info('Closing bootstrap connection %s', bootstrap_broker.node_id)
                 self._conns.pop(bootstrap_broker.node_id, conn).close()
         else:
             raise Errors.KafkaTimeoutError(
@@ -239,9 +242,22 @@ class KafkaConnectionManager:
             return transport
 
     async def _connect(self, node, conn, reset_backoff_on_connect=True, timeout_at=None):
+        # Tracks ownership of the freshly built transport: while non-None it is
+        # ours to clean up (the connection hasn't taken it over yet), so the
+        # finally clause closes it. Cleared once connection_made() succeeds.
+        transport = None
         try:
             transport = await self._build_transport(node, timeout_at=timeout_at)
+            # The connection (or the whole manager) may have been closed while
+            # we were building the transport. Handing it to connection_made()
+            # would flip the conn back to `initializing` and resurrect a
+            # connection that is already being torn down. Discard
+            # the new transport instead of reviving a dead connection.
+            if conn.closed or self.closed:
+                log.debug('%s: closed during connect; discarding new transport', conn)
+                return
             conn.connection_made(transport)
+            transport = None  # conn owns cleanup now; skip finally: transport.close()
             await conn.initialize(timeout_at=timeout_at)
         except Exception as exc:
             log.error('Connection failed: %s', exc)
@@ -251,6 +267,9 @@ class KafkaConnectionManager:
                                 Errors.AuthorizationError)):
                 self._auth_failures[node.node_id] = exc
             return
+        finally:
+            if transport is not None:
+                transport.close()
 
         if self._sensors:
             self._sensors.connection_created.record()
@@ -275,6 +294,7 @@ class KafkaConnectionManager:
         node = self.cluster.broker_metadata(node_id)
         if node is None:
             raise Errors.UnknownBrokerIdError(node_id)
+        log.info('Initializing connection for node_id %s at %s:%s (rack=%s)', node_id, node.host, node.port, node.rack)
         conn = KafkaConnection(self._net, node_id=node_id, broker_version_data=self.broker_version_data, **self.config)
         if pop_on_close:
             conn.close_future.add_both(lambda _: self._conns.pop(node.node_id, None))
@@ -359,6 +379,7 @@ class KafkaConnectionManager:
                   node_id, backoff_ms, connect_ms, failures)
         backoff_until_time = time.monotonic() + (backoff_ms / 1000)
         self._backoff[node_id] = (failures, backoff_until_time, connect_ms)
+        return backoff_ms
 
     def connection_delay(self, node_id):
         """Connection delay in seconds.
@@ -423,11 +444,7 @@ class KafkaConnectionManager:
         try:
             return await wrapper
         finally:
-            if not timer.is_done:
-                try:
-                    self._net.unschedule(timer)
-                except ValueError:
-                    pass
+            self._net.cancel(timer)
 
     def call_soon(self, coro, *args):
         """Accepts a coroutine / awaitable / function and schedules it on the event loop.

kafka/net/selector.py

@@ -1,5 +1,6 @@
 import collections
 import copy
+import enum
 import inspect
 import logging
 import heapq
@@ -48,12 +49,25 @@ class KernelEvent:
         return (yield self)
 
 
+class TaskState(enum.Enum):
+    CREATED     = 'created'
+    SCHEDULED   = 'scheduled'   # in _scheduled heap
+    UNSCHEDULED = 'unscheduled' # maybe lost
+    READY       = 'ready'       # in _ready deque
+    RUNNING     = 'running'     # is _current
+    WAIT_IO     = 'wait_io'     # parked on I/O
+    WAIT_FUTURE = 'wait_future' # waiting on Future to resolve
+    DONE        = 'done'        # completed (exception is None or not)
+    CANCELLED   = 'cancelled'
+
+
 class Task:
     def __init__(self, coro):
         self._stack = (_initialize_coro(coro), None)
         self._res = None
         self._exc = None
         self.scheduled_at = None
+        self.state = TaskState.CREATED
 
     def __lt__(self, other):
         # heapq requires the heap entries to be orderable. When two tasks
@@ -93,6 +107,7 @@ class Task:
                 self._stack = self._stack[1]
                 if not self._stack:
                     # we're done, back to event loop
+                    self.state = TaskState.DONE
                     self._res = final.value
                     raise
                 else:
@@ -102,6 +117,7 @@ class Task:
             except BaseException as e:
                 self._stack = self._stack[1]
                 if not self._stack:
+                    self.state = TaskState.DONE
                     self._exc = e
                     raise
                 else:
@@ -123,19 +139,20 @@ class Task:
         self._exc = exc
 
     def close(self):
+        if self.is_done:
+            return
+        assert self.state is not TaskState.RUNNING
         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
+        self.state = TaskState.CANCELLED
+        self._exc = Errors.Cancelled()
 
     @property
     def is_done(self):
@@ -298,7 +315,11 @@ class NetworkSelector:
             try:
                 state['value'] = await self._invoke(coro, *args)
             except BaseException as exc:
-                state['exception'] = exc
+                # fail_pending_waiters sets 'exception'; dont overwrite
+                if state['exception'] is None:
+                    state['exception'] = exc
+                elif not isinstance(exc, GeneratorExit):
+                    log.warning("During exception %s, caught additional error %s (ignoring)", state['exception'], exc)
             finally:
                 with self._pending_waiters_lock:
                     self._pending_waiters.pop(event, None)
@@ -321,6 +342,7 @@ class NetworkSelector:
         if not isinstance(task, Task):
             task = Task(task)
         task.scheduled_at = when
+        task.state = TaskState.SCHEDULED
         heapq.heappush(self._scheduled, (when, task))
         self._pending_tasks.add(task)
         return task
@@ -331,10 +353,20 @@ class NetworkSelector:
         self.call_at(time.monotonic() + delay, task)
         return task
 
+    def _add_ready_task(self, task):
+        self._ready.append(task)
+        task.state = TaskState.READY
+
+    def _task_done(self, task):
+        if not task.is_done:
+            raise RuntimeError('Task is not done yet!')
+        self._pending_tasks.discard(task)
+        task.state = TaskState.DONE
+
     def call_soon(self, task):
         if not isinstance(task, Task):
             task = Task(task)
-        self._ready.append(task)
+        self._add_ready_task(task)
         self._pending_tasks.add(task)
         return task
 
@@ -378,29 +410,38 @@ class NetworkSelector:
             result = await result
         return result
 
-    def _remove_scheduled(self, task):
-        if task.scheduled_at is not None:
-            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 _unschedule(self, task):
+        assert task.state is TaskState.SCHEDULED
+        assert task.scheduled_at is not None
+        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
+        task.state = TaskState.UNSCHEDULED
 
-    def _retire_task(self, task):
-        if task is self._current:
+    def cancel(self, task):
+        if task.state in (TaskState.DONE, TaskState.CANCELLED):
             return
+        elif task.state is TaskState.RUNNING:
+            assert task is self._current
+            self._current.state = TaskState.CANCELLED
+            return
+        elif task.state is TaskState.SCHEDULED:
+            self._unschedule(task)
+        elif task.state is TaskState.WAIT_IO:
+            # close() below drives the io_guard finalizer, which unregisters
+            # the fileobj and cancels any paired timeout timer.
+            pass
         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._remove_scheduled(task)
+        if task.state is TaskState.SCHEDULED:
+            self._unschedule(task)
         self.call_at(when, task)
         return task
 
@@ -425,37 +466,45 @@ class NetworkSelector:
     def _wait_io(self, fileobj, event, timeout_at):
         suspended = self._current
         self.register_event(fileobj, event, suspended)
-        if timeout_at is None or self._closed:
-            suspended.push_stack(lambda: self.unregister_event(fileobj, event))
-            return
 
-        state = {'fired': False, 'timer': None}
+        timer = None  # set below iff there is a timeout
 
-        def on_resume():
-            state['fired'] = True
-            if state['timer'] is not None:
-                try:
-                    self.unschedule(state['timer'])
-                except ValueError:
-                    pass
-            self.unregister_event(fileobj, event)
+        def io_guard():
+            # Primed and parked on the stack just above the waiting coroutine.
+            # Its finally runs exactly once, whichever way the wait ends:
+            #   I/O ready -> driven past the yield
+            #   cancel()  -> Task.close() throws GeneratorExit in at the yield
+            #   timeout   -> on_timeout injects an exc that propagates through
+            try:
+                yield
+            finally:
+                if timer is not None and not timer.is_done:
+                    self.cancel(timer)
+                self.unregister_event(fileobj, event)
+
+        guard = io_guard()
+        next(guard)  # prime: suspend at the yield so close() triggers finally
+        suspended.push_stack(guard)
+        suspended.state = TaskState.WAIT_IO
+
+        if timeout_at is None or self._closed:
+            return
 
         def on_timeout():
-            if state['fired']:
+            nonlocal timer
+            timer = None  # we are the timer; don't try to cancel ourselves
+            if suspended.is_done:
                 return
-            state['fired'] = True
-            self.unregister_event(fileobj, event)
             suspended.inject_exc(Errors.KafkaTimeoutError('I/O wait timed out'))
-            self._ready.append(suspended)
+            self._add_ready_task(suspended)
 
-        suspended.push_stack(on_resume)
-        state['timer'] = self.call_at(timeout_at, on_timeout)
+        timer = self.call_at(timeout_at, on_timeout)
 
     def _schedule_tasks(self):
         while self._scheduled and self._scheduled[0][0] <= time.monotonic():
             _, task = heapq.heappop(self._scheduled)
             task.scheduled_at = None
-            self._ready.append(task)
+            self._add_ready_task(task)
 
     def _next_scheduled_timeout(self, now):
         try:
@@ -489,7 +538,11 @@ class NetworkSelector:
                 self._selector.unregister(fileobj)
             else:
                 self._selector.modify(fileobj, events, (None, writer) if event == selectors.EVENT_READ else (reader, None))
-        except KeyError:
+        except (KeyError, ValueError):
+            # KeyError: fileobj was never registered.
+            # ValueError: fileobj is closed (fileno() == -1) and no longer in
+            # the selector map -- e.g. the socket was closed before the wait's
+            # io_guard ran during shutdown. Either way there is nothing to do.
             pass
 
     def add_reader(self, fileobj, task):
@@ -555,35 +608,52 @@ class NetworkSelector:
             n = len(self._ready)
             for i in range(n):
                 self._current = self._ready.popleft()
+                # Silently skip tasks that are done or cancelled
+                if self._current.state in (TaskState.DONE, TaskState.CANCELLED):
+                    continue
+                self._current.state = TaskState.RUNNING
                 step_start = time.monotonic() if threshold else None
                 try:
                     log_trace('Calling task %s', self._current)
-                    inject = self._current._exc
-                    if inject is not None:
-                        self._current._exc = None
-                        event = self._current(inject)
-                    else:
-                        event = self._current()
+                    # __call__ consumes self._exc (set via inject_exc) itself;
+                    # don't clear it here or the injected exception is dropped.
+                    event = self._current()
 
                 except StopIteration:
-                    # Task ran to completion. Drop the strong ref so the Task
-                    # (and its coroutine, frames, locals) is now collectable.
-                    self._pending_tasks.discard(self._current)
+                    self._task_done(self._current)
 
-                except BaseException as e:
-                    log.exception(e)
+                except BaseException:
+                    log.exception('Unhandled exception in task %s:', self._current)
                     # Same as StopIteration -- task is done either way.
-                    self._pending_tasks.discard(self._current)
+                    self._task_done(self._current)
 
                 else:
-                    if isinstance(event, KernelEvent):
+                    if self._current.state is TaskState.CANCELLED:
+                        # ignores any returned KernelEvent/Future
+                        self._pending_tasks.discard(self._current)
+                        self._current.close()
+                    elif isinstance(event, KernelEvent):
                         log_trace('kernel event %s', event.method)
-                        getattr(self, event.method)(*event.args)
+                        try:
+                            getattr(self, event.method)(*event.args)
+                        except BaseException as e:
+                            log_trace('kernel event %s raised %r; injecting into %s',
+                                      event.method, e, self._current)
+                            self._current.inject_exc(e)
+                            self._add_ready_task(self._current)
                     elif isinstance(event, Future):
                         event.add_both(lambda _, task=self._current: self.call_soon(task))
+                        self._current.state = TaskState.WAIT_FUTURE
                     else:
                         raise RuntimeError('Unhandled event type: %s' % event)
 
+                finally:
+                    # No Task should leave io_loop in RUNNING state.
+                    if self._current is not None and self._current.state is TaskState.RUNNING:
+                        log.warning('Task %s left RUNNING after step; demoting to '
+                                    'UNSCHEDULED', self._current)
+                        self._current.state = TaskState.UNSCHEDULED
+
                 if threshold:
                     elapsed = time.monotonic() - step_start
                     if elapsed > threshold:
@@ -632,6 +702,8 @@ class NetworkSelector:
         if self._io_thread is not None:
             self.stop()
         self.drain()
+        for task in list(self._pending_tasks):
+            self.cancel(task)
         for s in (self._wakeup_r, self._wakeup_w):
             try:
                 self._selector.unregister(s)
@@ -664,12 +736,12 @@ class NetworkSelector:
 
             if events & selectors.EVENT_WRITE:
                 if writer is not None:
-                    self._ready.append(writer)
+                    self._add_ready_task(writer)
                 else:
                     log.warning("Selector got WRITE event without writer...")
 
             if events & selectors.EVENT_READ:
                 if reader is not None:
-                    self._ready.append(reader)
+                    self._add_ready_task(reader)
                 else:
                     log.warning("Selector got READ event without reader...")

kafka/net/transport.py

@@ -186,7 +186,7 @@ class KafkaTCPTransport:
 
     async def _write_to_sock(self):
         try:
-            while self._write and not self._closed and self._write_buffer:
+            while self._write_buffer:
                 await self._net.wait_write(self._sock)
                 total_bytes, err = self._sock_send()
                 if err:
@@ -197,11 +197,18 @@ class KafkaTCPTransport:
                     self._protocol._sensors.bytes_sent.record(total_bytes)
         finally:
             self._writing = False
-        if not self._write:
-            self._sock.shutdown(socket.SHUT_WR)
+        if self._closed:
+            self._close()
+        elif not self._write:
+            try:
+                self._sock.shutdown(socket.SHUT_WR)
+            except OSError:
+                pass
 
     def _sock_send(self):
         total_bytes = 0
+        if self._sock is None:
+            return total_bytes, Errors.KafkaConnectionError('Connection closed during send')
         while self._write_buffer:
             next_chunk = self._write_buffer.popleft()
             # Wrap in memoryview so partial-send slicing is O(1) instead of
@@ -260,6 +267,10 @@ class KafkaTCPTransport:
                 self._net.unregister_event(sock, selectors.EVENT_READ | selectors.EVENT_WRITE)
             except (KeyError, ValueError):
                 pass
+            try:
+                sock.shutdown(socket.SHUT_RDWR)
+            except OSError:
+                pass
             sock.close()
         proto = self._protocol
         self._protocol = None
@@ -333,7 +344,7 @@ class KafkaTCPTransport:
         return self.writelines(data)
 
     async def handshake(self):
-        pass
+        log.info('%s: connected to %s', self, self._sock)
 
     def host_port(self):
         if self._sock is None:
@@ -365,6 +376,7 @@ class KafkaSSLTransport(KafkaTCPTransport):
         while True:
             try:
                 self._sock.do_handshake()
+                log.info('%s: connected to %s', self, self._sock)
                 return
             except ssl.SSLWantReadError:
                 await self._net.wait_read(self._sock)
@@ -397,6 +409,8 @@ class KafkaSSLTransport(KafkaTCPTransport):
     def _sock_send(self):
         total_bytes = 0
         err = None
+        if self._sock is None:
+            return total_bytes, Errors.KafkaConnectionError('Connection closed during send')
         while self._write_buffer:
             next_chunk = self._write_buffer.popleft()
             while next_chunk:

kafka/net/wakeup_notifier.py

@@ -53,11 +53,8 @@ class WakeupNotifier:
             await self._fut
         finally:
             self._fut = None
-            if timer is not None and not timer.is_done:
-                try:
-                    self._net.unschedule(timer)
-                except (ValueError, RuntimeError, ReferenceError):
-                    pass
+            if timer is not None:
+                self._net.cancel(timer)
 
     def notify(self):
         # Always queue _wakeup on the IO thread. Skipping the queue when

kafka/protocol/broker_version_data.py

@@ -100,8 +100,12 @@ class BrokerVersionData:
                 f" and broker [{broker_min_version}-{broker_max_version}].")
         return min(max_version, broker_max_version)
 
+    @property
+    def broker_version_str(self):
+        return '.'.join(map(str, self.broker_version))
+
     def __str__(self):
-        return '<BrokerVersionData %s>' % '.'.join(map(str, self.broker_version))
+        return '<BrokerVersionData %s>' % self.broker_version_str
 
     def __eq__(self, other):
         return self.broker_version == other.broker_version and self.api_versions == other.api_versions

kafka/version.py

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

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

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

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

@@ -1,12 +1,12 @@
 kafka/__init__.py,sha256=lp8Gk_P3zzDabNl6PZxJ8B24Xit-D-LvJY8rauL3FnI,1200
 kafka/__main__.py,sha256=HNnJxekZZkNDXQwqnE5AfaM56JNCNYvq135wu4jxvhk,107
-kafka/cluster.py,sha256=P1-ylBAa33FAelwufsod_ouIp2FCfE-MI6_sNnxJyJc,32429
+kafka/cluster.py,sha256=wePKTGh8aO7EYigy5_ob8Vz1FBmLlV4SD7Qmigmytj0,32352
 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=ZOFmVJRbhSXykkw9cnuv-DGYE7g2KjaUGsytSOv4xVw,3146
 kafka/util.py,sha256=hvSdRbh5-IsUbpD_BqjabjEldtNmXufZH68b_xCkNjE,5194
-kafka/version.py,sha256=FDUC8xOuizaRKSkyG1VOmlDwzcPJgbzFUWz58fhdUGQ,22
+kafka/version.py,sha256=zL37B2sw3qNZN5JX3JbC-5k0KFwjSViL9oBB2x4vwDY,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
@@ -29,7 +29,7 @@ kafka/benchmarks/record_batch_compose.py,sha256=_oYa6kqjeKDOCCvi-HB5owz2elGpoCCY
 kafka/benchmarks/record_batch_read.py,sha256=edlq0Z42p4f0TIceAUeF-DCff35jtM5c84xnoYhEhhA,2146
 kafka/benchmarks/varint_speed.py,sha256=FfLikmv0y_70uWWPvowp6Fv82rm5xVHScL3oMGgItfA,12260
 kafka/cli/__init__.py,sha256=rC9r6I9d4ypNbFcZPI80FHehudqpCKmlRGe6YIn6uj0,1055
-kafka/cli/common.py,sha256=G7Bh68Dw-l0El46IgWJOCXgnrGOI89QcOPcHeEhCsts,3586
+kafka/cli/common.py,sha256=VCn8eDXxrPdc9ODT-Sr0zL3CIANyLJ0efhJtFRqVleU,7248
 kafka/cli/admin/__init__.py,sha256=GTABhBAWy5PJAy4ZyUWwiS6V-TsKdVXH3CSj4It4mjM,3655
 kafka/cli/admin/acls/__init__.py,sha256=FjGMmvaoYs0zW7N_PoUsqt0RDroOhe4DCCcE8QzQqOM,227
 kafka/cli/admin/acls/common.py,sha256=N8vmQWaoZ1mYAr6y43YVWXfz0rnIxcZRYSVyvh0Mf3k,3732
@@ -41,7 +41,7 @@ kafka/cli/admin/cluster/describe.py,sha256=WEAir7STL7AJNvDRWfhPL_brafYZ6cfRH8i3X
 kafka/cli/admin/cluster/describe_quorum.py,sha256=ikCcC57t7tRtXXBxSYFR8hJqcOCtn0ttkn-O45CgyT0,272
 kafka/cli/admin/cluster/features.py,sha256=pLnvWsJSYVQdY5RVCdxicP8bLWjH0v1i_3V2h8v20Zk,1943
 kafka/cli/admin/cluster/log_dirs.py,sha256=N4_ULfQa1Jhl96GolE5b-4UZ6wy5sGnRoTCaAo4Gsdo,1692
-kafka/cli/admin/cluster/versions.py,sha256=7s-dc1ZKzMVyO_5Vrgqdp4fokb5spwAmur6ShRs2d9E,1078
+kafka/cli/admin/cluster/versions.py,sha256=MILUv9ycelvvRHo-HIi8dPnNceXRGyR5o9noX4jvpcA,1062
 kafka/cli/admin/configs/__init__.py,sha256=JrD3hOX2s7KUkw2LzozFrsM6NwP5EH33-tSXmoUM5-c,313
 kafka/cli/admin/configs/alter.py,sha256=nd9iAwPJPvcOgM8_gyPKiR9J-8M0c607KnPHY2ymmJA,1921
 kafka/cli/admin/configs/common.py,sha256=NXSQ0Of7B2tWRGTmmPdDUGFobBzQwgadu3-p_F_NRQc,712
@@ -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=hOj0ecZxsp83pUf6K0PZY01PCpEZhBjoJymk9bpv4Qc,102423
+kafka/consumer/fetcher.py,sha256=Xr-JNlyNZgVNanh6AlYn1ImsyuBbpMqjPGwMZL50Hmc,106075
 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=gIzjv60NIC6zlkgUm1w-yG-S5i6fy_pSo3BJEBbOD9M,57841
+kafka/coordinator/base.py,sha256=UgMXWES0VVgDsvLEEZB8tAvchGFRzJFO6N9bL06vGm4,57794
 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
@@ -128,15 +128,15 @@ kafka/metrics/stats/sensor.py,sha256=OiW7qWkIWxJykubKGfklLl1MEpjy668ZJL42Bifwd-k
 kafka/metrics/stats/total.py,sha256=YSWSlkkSPygFrqoJS7LEdcQDm14ABCS-6MODo413l7o,407
 kafka/net/__init__.py,sha256=Dd0ZrMv3hyhMHIiAeY2CFEeKGEFyqHmOdAoh7-squOE,751
 kafka/net/compat.py,sha256=xBwWj5WgcfFbiPWy-46VCa25jDC9x5DOTl_ds_VXdyg,6415
-kafka/net/connection.py,sha256=D7D8KDU3TIoY9cLutfmYLXZNGjC7FjS-nZWWJuvrI00,25274
+kafka/net/connection.py,sha256=gxUHGAESQneccx0JXY0apoxcsyL-XtMmryCJV4r_DOQ,26349
 kafka/net/http_connect.py,sha256=j8R1yLNwhTF-nQVMEgRF88mOF5-v1Sdj7uwkBvvg5PU,5133
 kafka/net/inet.py,sha256=zMo0NTCS7EY81uoNPri5ZHKcCnRVUIcCJiW6BeZWnCs,4730
-kafka/net/manager.py,sha256=nq7eKgzkazQ3sFLXQ-IOIFQ3FdyZYzfKxYxVrwYPGsc,19427
+kafka/net/manager.py,sha256=R5dlShO8gPzJstHIh-r-ICAMdH2gxlhmO9eEfyL9_zs,20744
 kafka/net/metrics.py,sha256=-cdWXQtonCO7-LpovLoEcWM-_3R9sAtyQxWf_QHOAWE,7299
-kafka/net/selector.py,sha256=4_g3AtYQfmhMjzFgtFOE_TbkIIifFWW5B8zvQmyBJCI,25733
+kafka/net/selector.py,sha256=kKKhVA6UdyiTNAnRDlRJNA3rC-C0anUcpYHnQy_yRZQ,29333
 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
+kafka/net/transport.py,sha256=ZQOTR8cqtjAmvsaQZndlyOKH_U0lJSBhkLPPknInxgU,15675
+kafka/net/wakeup_notifier.py,sha256=gLnfg-HEjVS5J9p-7kZfZpIeLT0AjvK5MOc6EMj3R88,2783
 kafka/net/sasl/__init__.py,sha256=vKE2jkS_BZ2OEVANlXZhW2xIVvH5C1o2kCxugw2PfYY,1006
 kafka/net/sasl/abc.py,sha256=H3tHUPevoaQdS395_ID88Wxhwvc8XjOTcAP8dKXxO9I,547
 kafka/net/sasl/gssapi.py,sha256=VIzRgrDw0sQUp8bUo2kEM5L6ngeNBUCpCkI6dolUsCY,4676
@@ -162,7 +162,7 @@ kafka/protocol/api_data.py,sha256=fyiEuEftBfJl23SL3EkF-Sd0lps9ZmTlDT9PY6YV_PY,47
 kafka/protocol/api_header.py,sha256=UZxHNQon5K2UnyUIj_XeGE1WqV_S8Qg3L0VK4wdvxcI,2356
 kafka/protocol/api_key.py,sha256=c87C4FtfUujUvcukS9iRieBSAy-a7zOCGTXYlvvRFc8,2456
 kafka/protocol/api_message.py,sha256=832m3NeRZarniJFkArtpB5zdnhNVVcZuW1MympXQ3bQ,11096
-kafka/protocol/broker_version_data.py,sha256=UhSRsfHWq1eZ5sicWcRqp4TLGrHp4RRDzrpc5IyrZfU,27140
+kafka/protocol/broker_version_data.py,sha256=tzBE3GPTu8pW4bJcjYi5dMIwWGN0GbqRW0AoIUm566c,27228
 kafka/protocol/data_container.py,sha256=mp2YQPQy8QkahQ_gf3JXjzLklz8T4hfyu6BV5oMGnsU,7783
 kafka/protocol/frame.py,sha256=exKvWkszmCgkDpjlUQv-Jyz4_mCQwnQmgFx4QtJ4ZcI,718
 kafka/protocol/generate_stubs.py,sha256=bZIQUPCiyN-eckI7h72oGbscdjwmCc3sJ1hWfG7bvtk,17176
@@ -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.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,,
+kafka_python-3.0.4.dist-info/licenses/LICENSE,sha256=vxnoJsqm6bKl3ZWdI1Q7Ikw_k9cOvO3vcvZNsY_1fP8,11374
+kafka_python-3.0.4.dist-info/METADATA,sha256=7jklPUJ14w6vgdx3Dc3dJ1f3WG-LE7tEjIp8_QC-TKg,11590
+kafka_python-3.0.4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+kafka_python-3.0.4.dist-info/entry_points.txt,sha256=LQvqZj3uM785ainO5HrXmukbjSrK-oPqrESqpvoR-As,51
+kafka_python-3.0.4.dist-info/top_level.txt,sha256=IivJz7l5WHdLNDT6RIiVAlhjQzYRwGqBBmKHZ7WjPeM,6
+kafka_python-3.0.4.dist-info/RECORD,,