kafka-python 3.0.0__py3-none-any.whl

kafka/cli/admin/groups/reset_offsets.py

@@ -0,0 +1,139 @@
+import re
+from collections import defaultdict
+from datetime import datetime, timedelta, timezone
+
+from kafka.admin import OffsetSpec, OffsetTimestamp
+from kafka.structs import TopicPartition
+
+
+class ResetGroupOffsets:
+    COMMAND = 'reset-offsets'
+    HELP = 'Reset committed offsets for a consumer group'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument('-g', '--group-id', type=str, required=True)
+        parser.add_argument(
+            '-p', '--partition', type=str, action='append',
+            dest='partitions', default=[],
+            help='TOPIC:PARTITION pair (repeatable). Scopes the reset to these '
+                 'partitions. If omitted, the reset applies to every partition '
+                 'currently committed by the group.')
+        mode = parser.add_mutually_exclusive_group(required=True)
+        mode.add_argument(
+            '-s', '--spec', type=str,
+            help='Spec may be one of earliest, latest, max-timestamp, '
+                 'earliest-local, latest-tiered, or a millisecond timestamp.')
+        mode.add_argument(
+            '--to-offset', type=int, dest='to_offset',
+            help='Reset all in-scope partitions to this explicit offset '
+                 '(clamped to [earliest, latest]).')
+        mode.add_argument(
+            '--shift-by', type=int, dest='shift_by',
+            help='Shift each in-scope committed offset by N positions (may be '
+                 'negative); clamped to [earliest, latest]. Requires a current '
+                 'commit for each in-scope partition.')
+        mode.add_argument(
+            '--by-duration', type=str, dest='by_duration',
+            help='Reset to the offset at (now - DURATION). DURATION is ISO-8601, '
+                 'e.g. P7D, PT1H, PT30M.')
+        mode.add_argument(
+            '--to-datetime', type=str, dest='to_datetime',
+            help='Reset to the offset at the given ISO-8601 datetime (UTC assumed '
+                 'if no tz offset is provided).')
+        mode.add_argument(
+            '--to-current', action='store_true', dest='to_current',
+            help='Re-commit the current committed offsets, clamped to '
+                 '[earliest, latest]. Useful to heal out-of-range offsets. '
+                 'Requires a current commit for each in-scope partition.')
+
+    @classmethod
+    def command(cls, client, args):
+        group = client.describe_groups([args.group_id])
+        state = group[args.group_id]['group_state']
+        if state not in ('Empty', 'Dead'):
+            raise RuntimeError(f'Group {args.group_id} is {state}, expecting Empty or Dead!')
+
+        targets = cls._build_targets(client, args)
+        result = client.reset_group_offsets(args.group_id, targets)
+        output = defaultdict(dict)
+        for tp, res in result.items():
+            res['error'] = res['error'].__name__
+            output[tp.topic][tp.partition] = res
+        return dict(output)
+
+    @classmethod
+    def _build_targets(cls, client, args):
+        explicit_scope = [cls._parse_tp(p) for p in args.partitions] if args.partitions else None
+
+        if args.spec is not None:
+            scope = explicit_scope if explicit_scope is not None else list(client.list_group_offsets(args.group_id))
+            spec = cls._parse_spec(args.spec)
+            return {tp: spec for tp in scope}
+
+        if args.to_offset is not None:
+            scope = explicit_scope if explicit_scope is not None else list(client.list_group_offsets(args.group_id))
+            return {tp: args.to_offset for tp in scope}
+
+        if args.by_duration:
+            delta = cls._parse_duration(args.by_duration)
+            ts = OffsetTimestamp(int((datetime.now(timezone.utc) - delta).timestamp() * 1000))
+            scope = explicit_scope if explicit_scope is not None else list(client.list_group_offsets(args.group_id))
+            return {tp: ts for tp in scope}
+
+        if args.to_datetime:
+            dt = cls._parse_datetime(args.to_datetime)
+            ts = OffsetTimestamp(int(dt.timestamp() * 1000))
+            scope = explicit_scope if explicit_scope is not None else list(client.list_group_offsets(args.group_id))
+            return {tp: ts for tp in scope}
+
+        current = client.list_group_offsets(args.group_id)
+        scope = explicit_scope if explicit_scope is not None else list(current)
+        missing = [tp for tp in scope if tp not in current]
+        if missing:
+            raise ValueError(
+                f'No committed offset for {missing}; --shift-by / --to-current '
+                'require a current commit per in-scope partition')
+
+        if args.shift_by is not None:
+            return {tp: current[tp].offset + args.shift_by for tp in scope}
+        if args.to_current:
+            return {tp: current[tp].offset for tp in scope}
+        raise ValueError('No reset mode selected')
+
+    @classmethod
+    def _parse_tp(cls, entry):
+        topic, partition = entry.rsplit(':', 1)
+        return TopicPartition(topic, int(partition))
+
+    @classmethod
+    def _parse_spec(cls, spec_str):
+        try:
+            return OffsetSpec.build_from(spec_str)
+        except ValueError:
+            return OffsetTimestamp(int(spec_str))
+
+    @classmethod
+    def _parse_duration(cls, duration):
+        m = re.match(
+            r'^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$',
+            duration)
+        if not m or not any(m.groups()):
+            raise ValueError(f'Invalid ISO-8601 duration: {duration}')
+        days, hours, mins, secs = m.groups()
+        return timedelta(
+            days=int(days) if days else 0,
+            hours=int(hours) if hours else 0,
+            minutes=int(mins) if mins else 0,
+            seconds=float(secs) if secs else 0,
+        )
+
+    @classmethod
+    def _parse_datetime(cls, dt_str):
+        try:
+            dt = datetime.fromisoformat(dt_str)
+        except ValueError:
+            raise ValueError(f'Invalid ISO-8601 datetime: {dt_str}')
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return dt

kafka/cli/admin/partitions/__init__.py

@@ -0,0 +1,21 @@
+from .alter_reassignments import AlterPartitionReassignments
+from .create import CreatePartitions
+from .delete_records import DeleteRecords
+from .describe import DescribeTopicPartitions
+from .elect_leaders import ElectLeaders
+from .list_offsets import ListPartitionOffsets
+from .list_reassignments import ListPartitionReassignments
+
+
+class PartitionsCommandGroup:
+    GROUP = 'partitions'
+    HELP = 'Manage Kafka Partitions'
+    COMMANDS = [
+        CreatePartitions,
+        DescribeTopicPartitions,
+        ListPartitionOffsets,
+        ListPartitionReassignments,
+        AlterPartitionReassignments,
+        DeleteRecords,
+        ElectLeaders,
+    ]

kafka/cli/admin/partitions/alter_reassignments.py

@@ -0,0 +1,37 @@
+from kafka.structs import TopicPartition
+
+
+class AlterPartitionReassignments:
+    COMMAND = 'alter-reassignments'
+    HELP = 'Alter replica assignments for partitions'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument(
+            '-r', '--reassign', type=str, action='append',
+            dest='reassignments', default=[], required=True,
+            help='TOPIC:PARTITION=BROKER_ID[,BROKER_ID...] to set a new '
+                 'replica set, or TOPIC:PARTITION=cancel to cancel an '
+                 'in-progress reassignment for that partition. Repeatable.')
+        parser.add_argument(
+            '--timeout-ms', type=int, default=None,
+            help='Request timeout in milliseconds')
+
+    @classmethod
+    def command(cls, client, args):
+        reassignments = {}
+        for spec in args.reassignments:
+            tp_str, replicas_str = spec.rsplit('=', 1)
+            topic, partition = tp_str.rsplit(':', 1)
+            tp = TopicPartition(topic, int(partition))
+            if replicas_str.lower() == 'cancel':
+                reassignments[tp] = None
+            else:
+                reassignments[tp] = [int(b) for b in replicas_str.split(',') if b]
+        results = client.alter_partition_reassignments(
+            reassignments,
+            timeout_ms=args.timeout_ms)
+        return {
+            '%s:%d' % (tp.topic, tp.partition): (err.__name__ if err else None)
+            for tp, err in results.items()
+        }

kafka/cli/admin/partitions/create.py

@@ -0,0 +1,27 @@
+class CreatePartitions:
+    COMMAND = 'create'
+    HELP = 'Create additional partitions for existing topics'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument(
+            '-p', '--topic-partitions', type=str, action='append',
+            dest='topic_partitions', default=[], required=True,
+            help='TOPIC:TOTAL_PARTITION_COUNT pair (repeatable)')
+        parser.add_argument(
+            '--timeout-ms', type=int, default=None,
+            help='Request timeout in milliseconds')
+        parser.add_argument(
+            '--validate-only', action='store_true',
+            help='Validate the request without actually creating partitions')
+
+    @classmethod
+    def command(cls, client, args):
+        topic_partitions = {}
+        for spec in args.topic_partitions:
+            topic, count = spec.rsplit(':', 1)
+            topic_partitions[topic] = int(count)
+        return client.create_partitions(
+            topic_partitions,
+            timeout_ms=args.timeout_ms,
+            validate_only=args.validate_only)

kafka/cli/admin/partitions/delete_records.py

@@ -0,0 +1,31 @@
+from kafka.structs import TopicPartition
+
+
+class DeleteRecords:
+    COMMAND = 'delete-records'
+    HELP = 'Delete records from partitions up to a given offset'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument(
+            '-r', '--record', type=str, action='append',
+            dest='records', default=[], required=True,
+            help='TOPIC:PARTITION:OFFSET triple (repeatable). '
+                 'Use -1 as OFFSET to delete up to the current high-water mark.')
+        parser.add_argument(
+            '--timeout-ms', type=int, default=None,
+            help='Request timeout in milliseconds')
+        parser.add_argument(
+            '--partition-leader-id', type=int, default=None,
+            help='Send all delete requests to this broker id, skipping metadata lookup')
+
+    @classmethod
+    def command(cls, client, args):
+        records_to_delete = {}
+        for spec in args.records:
+            topic, partition, offset = spec.rsplit(':', 2)
+            records_to_delete[TopicPartition(topic, int(partition))] = int(offset)
+        return client.delete_records(
+            records_to_delete,
+            timeout_ms=args.timeout_ms,
+            partition_leader_id=args.partition_leader_id)

kafka/cli/admin/partitions/describe.py

@@ -0,0 +1,36 @@
+class DescribeTopicPartitions:
+    COMMAND = 'describe'
+    HELP = 'Describe topic partitions with pagination (KIP-966, broker >=3.9)'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument(
+            '-t', '--topic', type=str, action='append',
+            dest='topics', default=[], required=True,
+            help='Topic to describe (repeatable)')
+        parser.add_argument(
+            '--response-partition-limit', type=int, default=2000,
+            help='Maximum number of partitions to include in the response '
+                 '(default: 2000)')
+        parser.add_argument(
+            '--cursor-topic', type=str, default=None,
+            help='Topic name to start pagination from')
+        parser.add_argument(
+            '--cursor-partition', type=int, default=None,
+            help='Partition index to start pagination from')
+
+    @classmethod
+    def command(cls, client, args):
+        cursor = None
+        if args.cursor_topic is not None or args.cursor_partition is not None:
+            if args.cursor_topic is None or args.cursor_partition is None:
+                raise ValueError(
+                    '--cursor-topic and --cursor-partition must be used together')
+            cursor = {
+                'topic_name': args.cursor_topic,
+                'partition_index': args.cursor_partition,
+            }
+        return client.describe_topic_partitions(
+            args.topics,
+            response_partition_limit=args.response_partition_limit,
+            cursor=cursor)

kafka/cli/admin/partitions/elect_leaders.py

@@ -0,0 +1,53 @@
+from collections import defaultdict
+
+
+_ELECTION_TYPES = {'preferred': 0, 'unclean': 1}
+
+
+class ElectLeaders:
+    COMMAND = 'elect-leaders'
+    HELP = 'Trigger leader election for partitions'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument(
+            '--election-type', type=str, default='preferred',
+            choices=sorted(_ELECTION_TYPES),
+            help='Election type (default: preferred)')
+        parser.add_argument(
+            '-p', '--topic-partition', type=str, action='append',
+            dest='topic_partitions', default=[],
+            help='TOPIC:PARTITION pair (repeatable). Omit to elect leaders for '
+                 'all partitions of all topics.')
+        parser.add_argument(
+            '-t', '--topic', type=str, action='append',
+            dest='topics', default=[],
+            help='Elect leaders for all partitions of TOPIC (repeatable). '
+                 'Mutually exclusive with --topic-partition.')
+        parser.add_argument(
+            '--timeout-ms', type=int, default=None,
+            help='Request timeout in milliseconds')
+        parser.add_argument(
+            '--no-raise-errors', dest='raise_errors', action='store_false',
+            help='Do not raise on partition-level errors; return the response instead')
+
+    @classmethod
+    def command(cls, client, args):
+        if args.topic_partitions and args.topics:
+            raise ValueError(
+                '--topic-partition and --topic are mutually exclusive')
+        if args.topic_partitions:
+            topic2partitions = defaultdict(list)
+            for spec in args.topic_partitions:
+                topic, partition = spec.rsplit(':', 1)
+                topic2partitions[topic].append(int(partition))
+            topic_partitions = dict(topic2partitions)
+        elif args.topics:
+            topic_partitions = args.topics
+        else:
+            topic_partitions = None
+        return client.elect_leaders(
+            _ELECTION_TYPES[args.election_type],
+            topic_partitions=topic_partitions,
+            timeout_ms=args.timeout_ms,
+            raise_errors=args.raise_errors)

kafka/cli/admin/partitions/list_offsets.py

@@ -0,0 +1,88 @@
+from collections import defaultdict
+
+from kafka.protocol.consumer import OffsetSpec
+from kafka.structs import TopicPartition
+
+
+class ListPartitionOffsets:
+    COMMAND = 'list-offsets'
+    HELP = 'List offsets for partitions by spec (earliest/latest/timestamp)'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument(
+            '-t', '--topic', type=str)
+        parser.add_argument(
+            '-s', '--spec', type=str,
+            help='Spec may be one of earliest, latest, max-timestamp, earliest-local, '
+            'latest-tiered, or a millisecond timestamp.')
+        parser.add_argument(
+            '-p', '--partition', type=str, action='append',
+            dest='partitions', default=[],
+            help='TOPIC:PARTITION:SPEC triple (repeatable). PARTITION may be a '
+                 'single partition, a closed range (0-2), an open range (1-), or '
+                 'a single wildcard "*" for all partitions. SPEC may be one of '
+                 'earliest, latest, max-timestamp, earliest-local, latest-tiered, '
+                 'or a millisecond timestamp.')
+
+    @classmethod
+    def command(cls, client, args):
+        tp_offsets = cls._parse_partition_specs(client, args)
+        output = defaultdict(dict)
+        result = client.list_partition_offsets(tp_offsets)
+        for tp, info in result.items():
+            output[tp.topic][tp.partition] = {
+                'offset': info.offset,
+                'timestamp': info.timestamp,
+                'leader_epoch': info.leader_epoch,
+                'spec': tp_offsets[tp]
+            }
+        return dict(output)
+
+    @classmethod
+    def _parse_partition_specs(cls, client, args):
+        if args.partitions:
+            if args.topic or args.spec:
+                raise ValueError("Either --partition or (--topic and --spec) is supported, but not both.")
+            partitions = args.partitions
+        else:
+            if not args.topic or not args.spec:
+                raise ValueError("Both --topic and --spec must be provided.")
+            partitions = [f'{args.topic}:*:{args.spec}']
+        tp_offsets = {}
+        for entry in partitions:
+            topic, partition, spec_str = entry.rsplit(':', 2)
+            spec = OffsetSpec.build_from(spec_str)
+            for tp in cls._parse_tp(client, topic, partition):
+                if tp in tp_offsets:
+                    # Passing multiple specs for a single partition results in an InvalidRequestError
+                    raise ValueError('Only one spec allowed per partition')
+                tp_offsets[tp] = spec
+        return tp_offsets
+
+    @classmethod
+    def _parse_tp(cls, client, topic, partition, cache={}):
+        try:
+            return [TopicPartition(topic, int(partition))]
+        except ValueError:
+            pass
+        if not partition == '*' and '-' not in partition:
+            raise ValueError(f'Unrecognized partition: {partition}')
+
+        if topic not in cache:
+            cache[topic] = sorted([p['partition_index'] for p in client.describe_topics([topic])[0]['partitions']])
+
+        if partition == '*':
+            return [TopicPartition(topic, p)
+                    for p in cache[topic]]
+
+        elif '-' in partition:
+            start, end = partition.split('-')
+            if not start and not end:
+                raise ValueError(f'Unrecognized partition: {partition}')
+            if not start:
+                start = cache[topic][0]
+            if not end:
+                end = cache[topic][-1]
+            return [TopicPartition(topic, p)
+                    for p in range(int(start), int(end) + 1)]

kafka/cli/admin/partitions/list_reassignments.py

@@ -0,0 +1,35 @@
+from collections import defaultdict
+
+from kafka.structs import TopicPartition
+
+
+class ListPartitionReassignments:
+    COMMAND = 'list-reassignments'
+    HELP = 'List the current ongoing partition reassignments'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument(
+            '-p', '--topic-partition', type=str, action='append',
+            dest='topic_partitions', default=[],
+            help='TOPIC:PARTITION pair (repeatable). Omit to list '
+                 'reassignments for all partitions.')
+        parser.add_argument(
+            '--timeout-ms', type=int, default=None,
+            help='Request timeout in milliseconds')
+
+    @classmethod
+    def command(cls, client, args):
+        if args.topic_partitions:
+            topic2partitions = defaultdict(list)
+            for spec in args.topic_partitions:
+                topic, partition = spec.rsplit(':', 1)
+                topic2partitions[topic].append(int(partition))
+            topic_partitions = dict(topic2partitions)
+        else:
+            topic_partitions = None
+        result = client.list_partition_reassignments(
+            topic_partitions, timeout_ms=args.timeout_ms)
+        # TopicPartition keys don't render cleanly in --format json; normalize
+        # to "topic:partition" strings for CLI output.
+        return {'%s:%d' % (tp.topic, tp.partition): v for tp, v in result.items()}

kafka/cli/admin/topics/__init__.py

@@ -0,0 +1,10 @@
+from .create import CreateTopic
+from .delete import DeleteTopic
+from .describe import DescribeTopics
+from .list import ListTopics
+
+
+class TopicsCommandGroup:
+    GROUP = 'topics'
+    HELP = 'Manage Kafka Topics'
+    COMMANDS = [ListTopics, DescribeTopics, CreateTopic, DeleteTopic]

kafka/cli/admin/topics/create.py

@@ -0,0 +1,13 @@
+class CreateTopic:
+    COMMAND = 'create'
+    HELP = 'Create a Kafka Topic'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument('-t', '--topic', type=str, required=True)
+        parser.add_argument('--num-partitions', type=int, default=-1)
+        parser.add_argument('--replication-factor', type=int, default=-1)
+
+    @classmethod
+    def command(cls, client, args):
+        return client.create_topics({args.topic: {'num_partitions': args.num_partitions, 'replication_factor': args.replication_factor}})

kafka/cli/admin/topics/delete.py

@@ -0,0 +1,19 @@
+import uuid
+
+
+class DeleteTopic:
+    COMMAND = 'delete'
+    HELP = 'Delete Kafka Topic'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument('-t', '--topic', type=str, action='append', dest='topics', default=[], help='topic name')
+        parser.add_argument('--id', type=str, action='append', dest='topic_ids', default=[], help='topic UUID')
+
+    @classmethod
+    def command(cls, client, args):
+        if not args.topics and not args.topic_ids:
+            raise ValueError('At least one topic or topic_id is required!')
+        topic_ids = [uuid.UUID(topic_id) for topic_id in args.topic_ids]
+        topic_names = args.topics
+        return client.delete_topics(topic_names + topic_ids)

kafka/cli/admin/topics/describe.py

@@ -0,0 +1,18 @@
+import uuid
+
+
+class DescribeTopics:
+    COMMAND = 'describe'
+    HELP = 'Describe Kafka Topics'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument('-t', '--topic', type=str, action='append', dest='topics', default=[], help='topic name')
+        parser.add_argument('--id', type=str, action='append', dest='topic_ids', default=[],
+                            help='topic UUID (requires broker >= 2.8, KIP-516)')
+
+    @classmethod
+    def command(cls, client, args):
+        topic_ids = [uuid.UUID(topic_id) for topic_id in args.topic_ids]
+        topics = args.topics + topic_ids
+        return client.describe_topics(topics or None)

kafka/cli/admin/topics/list.py

@@ -0,0 +1,11 @@
+class ListTopics:
+    COMMAND = 'list'
+    HELP = 'List Kafka Topics'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        pass
+
+    @classmethod
+    def command(cls, client, args):
+        return client.list_topics()

kafka/cli/admin/transactions/__init__.py

@@ -0,0 +1,17 @@
+from .abort import AbortTransaction
+from .describe import DescribeTransactions
+from .describe_producers import DescribeProducers
+from .find_hanging import FindHangingTransactions
+from .list import ListTransactions
+
+
+class TransactionsCommandGroup:
+    GROUP = 'transactions'
+    HELP = 'Inspect and recover from hanging transactions (KIP-664)'
+    COMMANDS = [
+        ListTransactions,
+        DescribeTransactions,
+        DescribeProducers,
+        FindHangingTransactions,
+        AbortTransaction,
+    ]

kafka/cli/admin/transactions/abort.py

@@ -0,0 +1,38 @@
+from kafka.admin import AbortTransactionSpec
+from kafka.structs import TopicPartition
+
+
+class AbortTransaction:
+    COMMAND = 'abort'
+    HELP = 'Administratively abort an open transaction on a partition'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument(
+            '-t', '--topic', type=str, required=True,
+            help='Topic name.')
+        parser.add_argument(
+            '-p', '--partition', type=int, required=True,
+            help='Partition index.')
+        parser.add_argument(
+            '--producer-id', type=int, required=True,
+            help='Producer id of the hanging transaction.')
+        parser.add_argument(
+            '--producer-epoch', type=int, required=True,
+            help='Producer epoch of the hanging transaction.')
+        parser.add_argument(
+            '--coordinator-epoch', type=int, default=-1,
+            help='Coordinator epoch (default: -1, the admin sentinel).')
+
+    @classmethod
+    def command(cls, client, args):
+        spec = AbortTransactionSpec(
+            topic_partition=TopicPartition(args.topic, args.partition),
+            producer_id=args.producer_id,
+            producer_epoch=args.producer_epoch,
+            coordinator_epoch=args.coordinator_epoch,
+        )
+        client.abort_transaction(spec)
+        return {'aborted': {'topic': args.topic, 'partition': args.partition,
+                            'producer_id': args.producer_id,
+                            'producer_epoch': args.producer_epoch}}

kafka/cli/admin/transactions/describe.py

@@ -0,0 +1,24 @@
+class DescribeTransactions:
+    COMMAND = 'describe'
+    HELP = 'Describe one or more transactional ids (broker >= 3.0)'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument(
+            '--transactional-id', type=str, action='append',
+            dest='transactional_ids', required=True,
+            help='Transactional id to describe (repeatable).')
+
+    @classmethod
+    def command(cls, client, args):
+        results = client.describe_transactions(args.transactional_ids)
+        output = {}
+        for txn_id, desc in results.items():
+            out = desc._asdict()
+            out['state'] = desc.state.value
+            out['topic_partitions'] = sorted(
+                [{'topic': tp.topic, 'partition': tp.partition}
+                 for tp in desc.topic_partitions],
+                key=lambda p: (p['topic'], p['partition']))
+            output[txn_id] = out
+        return output

kafka/cli/admin/transactions/describe_producers.py

@@ -0,0 +1,29 @@
+from kafka.structs import TopicPartition
+
+
+class DescribeProducers:
+    COMMAND = 'describe-producers'
+    HELP = 'Describe active producers on a partition (broker >= 2.8)'
+
+    @classmethod
+    def add_arguments(cls, parser):
+        parser.add_argument(
+            '-t', '--topic', type=str, required=True,
+            help='Topic name.')
+        parser.add_argument(
+            '-p', '--partition', type=int, action='append',
+            dest='partitions', required=True,
+            help='Partition index (repeatable).')
+        parser.add_argument(
+            '--broker-id', type=int, default=None,
+            help='Send to this replica instead of the partition leader.')
+
+    @classmethod
+    def command(cls, client, args):
+        tps = [TopicPartition(args.topic, p) for p in args.partitions]
+        results = client.describe_producers(tps, broker_id=args.broker_id)
+        return {
+            f'{tp.topic}:{tp.partition}': {
+                'active_producers': [p._asdict() for p in state.active_producers],
+            } for tp, state in results.items()
+        }