kafka-python 3.0.0__py3-none-any.whl

kafka/protocol/schemas/fields/struct.py

@@ -0,0 +1,357 @@
+from .base import BaseField
+from .codecs.tagged_fields import TaggedFields
+from .codecs.types import UnsignedVarInt32
+from .codegen import CodegenContext
+
+
+class StructField(BaseField):
+    @classmethod
+    def parse_json(cls, json):
+        if 'type' not in json or json['type'].startswith('[]'):
+            return
+        if 'fields' in json:
+            return cls(json)
+
+    # Cases
+    # oldschool  - standard types, no tagged fields
+    # newschool  - compact types, tagged fields
+    # nested tag - compact types, no (nested) tagged fields
+    def __init__(self, json):
+        super().__init__(json)
+        self._field_map = {field.name: field for field in self._fields}
+        self._data_class = None
+        self._untagged_fields_cache = {}
+        self._tagged_fields_cache = {}
+        self._compiled_encoders = {}
+
+    @property
+    def fields(self):
+        return self._field_map
+
+    def is_struct(self):
+        return True
+
+    def has_data_class(self):
+        return self._data_class is not None
+
+    def set_data_class(self, data_class):
+        assert self._data_class is None
+        self._data_class = data_class
+
+    @property
+    def data_class(self):
+        return self._data_class
+
+    def __call__(self, *args, **kw):
+        return self.data_class(*args, **kw) # pylint: disable=E1102
+
+    def _calculate_default(self, default):
+        if default == 'null':
+            return None
+        if self._tag is not None:
+            return None
+        elif not default:
+            raise NotImplementedError(f"Default value not implemented for struct field '{self._name}'")
+        else:
+            raise ValueError('Invalid default for struct field %s. The only valid default is null.' % self._name)
+
+    def tagged_fields(self, version):
+        if version not in self._tagged_fields_cache:
+            self._tagged_fields_cache[version] = TaggedFields(
+                [field for field in self._fields
+                 if field.for_version_q(version)
+                 and field.tagged_field_q(version)])
+        return self._tagged_fields_cache[version]
+
+    def untagged_fields(self, version):
+        if version not in self._untagged_fields_cache:
+            self._untagged_fields_cache[version] = [
+                field for field in self._fields
+                if field.for_version_q(version)
+                and not field.tagged_field_q(version)]
+        return self._untagged_fields_cache[version]
+
+    def encode(self, item, version=None, compact=False, tagged=False):
+        # Nested nullable struct (KIP-893): 1-byte INT8 prefix, -1 = null,
+        # 1 = present. Top-level message structs never have nullableVersions
+        # set, so this check is safe without a top-level guard.
+        if self.nullable_for_version_q(version):
+            if item is None:
+                return b'\xff'
+            prefix = b'\x01'
+        else:
+            prefix = b''
+        fields = self.untagged_fields(version)
+        if isinstance(item, tuple):
+            getter = lambda item, i, field: item[i]
+            tags = {} if len(item) == len(fields) else item[-1]
+        elif isinstance(item, dict):
+            getter = lambda item, i, field: item.get(field.name) # defaults?
+            tags = item
+        elif isinstance(item, (str, int, float)):
+            assert len(fields) == 1, "Encoding single value item (str/int/float) requires single field struct"
+            getter = lambda item, i, field: item
+            tags = {}
+        else:
+            getter = lambda item, i, field: getattr(item, field.name)
+            tags = item
+        encoded = [field.encode(getter(item, i, field),
+                                version=version, compact=compact, tagged=tagged)
+                   for i, field in enumerate(fields)]
+        if tagged:
+            # TaggedFields are always compact and never include nested tagged fields
+            encoded.append(self.tagged_fields(version).encode(tags, version=version))
+        elif tagged is None:
+            encoded.append(TaggedFields.encode_empty())
+        return prefix + b''.join(encoded)
+
+    def emit_encode_into(self, ctx, item_expr, indent, version=None, compact=False,
+                         tagged=False, tuple_access=False):
+        # Top-level struct (item_expr == 'item') has its nullability handled
+        # by the parent struct; only inline null-prefix when this is a nested
+        # nullable struct field.
+        inline_nullable = (
+            self.nullable_for_version_q(version)
+            and item_expr != 'item'
+            and not tuple_access
+        )
+        if inline_nullable:
+            ctx.emit(indent, 'if %s is None:' % item_expr)
+            ctx.emit(indent, '    buf[pos] = 0xff')
+            ctx.emit(indent, '    pos += 1')
+            ctx.emit(indent, 'else:')
+            ctx.emit(indent, '    buf[pos] = 1')
+            ctx.emit(indent, '    pos += 1')
+            indent = indent + '    '
+        fields = self.untagged_fields(version)
+        for i, field in enumerate(fields):
+            if tuple_access:
+                val_expr = '%s[%d]' % (item_expr, i)
+            else:
+                val_expr = '%s.%s' % (item_expr, field.name)
+            field.emit_encode_into(ctx, val_expr, indent, version=version,
+                                   compact=compact, tagged=tagged)
+        if tagged:
+            tf_var = ctx.next_var('tf')
+            ctx.globs[tf_var] = self.tagged_fields(version)
+            ctx.emit(indent, 'out.pos = pos')
+            ctx.emit(indent, '%s.encode_into(%s, out, version=%d)' % (tf_var, item_expr, version))
+            ctx.emit(indent, 'pos = out.pos')
+        elif tagged is None:
+            ctx.emit(indent, 'buf[pos] = 0')
+            ctx.emit(indent, 'pos += 1')
+
+    def encode_into(self, item, out, version=None, compact=False, tagged=False):
+        if self.nullable_for_version_q(version):
+            out.ensure(1)
+            if item is None:
+                out.buf[out.pos] = 0xff
+                out.pos += 1
+                return
+            out.buf[out.pos] = 1
+            out.pos += 1
+        fields = self.untagged_fields(version)
+        if isinstance(item, tuple):
+            for i, field in enumerate(fields):
+                field.encode_into(item[i], out, version=version, compact=compact, tagged=tagged)
+        elif isinstance(item, dict):
+            for field in fields:
+                field.encode_into(item.get(field.name), out, version=version, compact=compact, tagged=tagged)
+        elif isinstance(item, (str, int, float)):
+            fields[0].encode_into(item, out, version=version, compact=compact, tagged=tagged)
+        else:
+            for field in fields:
+                field.encode_into(getattr(item, field.name), out, version=version, compact=compact, tagged=tagged)
+        if tagged:
+            self.tagged_fields(version).encode_into(item, out, version=version)
+        elif tagged is None:
+            UnsignedVarInt32.encode_into(out, 0)
+
+    def encode_into__optimized_context(self, version, compact=False, tagged=False):
+        ctx = CodegenContext()
+        indent = '    '
+        ctx.lines.append('def _encode(item, out):')
+        ctx.emit(indent, 'buf = out.buf')
+        ctx.emit(indent, 'pos = out.pos')
+        self.emit_encode_into(ctx, 'item', indent, version=version, compact=compact, tagged=tagged)
+        ctx.emit(indent, 'out.pos = pos')
+        return ctx
+
+    def compiled_encode_into(self, version, compact=False, tagged=False):
+        """Return a compiled flat encode function for this struct+version.
+
+        Lazily compiled on first call and cached. The returned function has
+        signature: f(item, out) where out is an EncodeBuffer.
+        """
+        key = (version, compact, tagged)
+        if key not in self._compiled_encoders:
+            ctx = self.encode_into__optimized_context(version, compact=compact, tagged=tagged)
+            exec(compile(ctx.source(), '<codegen:%s_v%d>' % (self.name, version), 'exec'), ctx.globs)
+            self._compiled_encoders[key] = ctx.globs['_encode']
+        return self._compiled_encoders[key]
+
+    def emit_decode_from(self, ctx, var_name, indent, version=None, compact=False, tagged=False):
+        """Emit decode code that creates a DataContainer via __new__ + direct slot assignment.
+
+        Batches adjacent batchable fields into single unpack_from calls.
+        """
+        # Top-level struct decode (var_name == 'obj') has no outer null-prefix;
+        # only a nested nullable struct field consumes one.
+        inline_nullable = (
+            self.nullable_for_version_q(version)
+            and var_name != 'obj'
+        )
+        if inline_nullable:
+            ctx.emit(indent, 'if data[pos] == 0xff:')
+            ctx.emit(indent, '    pos += 1')
+            ctx.emit(indent, '    %s = None' % var_name)
+            ctx.emit(indent, 'else:')
+            ctx.emit(indent, '    pos += 1')
+            indent = indent + '    '
+        fields = self.untagged_fields(version)
+        data_class = self.data_class
+
+        if data_class is not None:
+            dc_var = ctx.next_var('dc')
+            ctx.globs[dc_var] = data_class
+            ctx.emit(indent, '%s = object.__new__(%s)' % (var_name, dc_var))
+            ctx.emit(indent, '%s._version = %d' % (var_name, version))
+            ctx.emit(indent, '%s.tags = None' % var_name)
+            ctx.emit(indent, '%s.unknown_tags = None' % var_name)
+
+        # Walk fields, batching adjacent batchable fields
+        i = 0
+        while i < len(fields):
+            field = fields[i]
+
+            # Try to batch consecutive batchable fields.
+            if field.is_batchable():
+                # Collect the run
+                batch_fields = []
+                batch_fmt = '>'
+                batch_size = 0
+                while i < len(fields):
+                    f = fields[i]
+                    if f.is_batchable():
+                        batch_fields.append(f)
+                        batch_fmt += f._type.fmt
+                        batch_size += f._type.size
+                        i += 1
+                    else:
+                        break
+
+                if len(batch_fields) == 1:
+                    # Single field - no batching benefit
+                    f = batch_fields[0]
+                    v = ctx.next_var('val')
+                    f.emit_decode_from(ctx, v, indent, version=version,
+                                       compact=compact, tagged=tagged)
+                    if data_class is not None:
+                        ctx.emit(indent, '%s.%s = %s' % (var_name, f.name, v))
+                else:
+                    # Batched unpack
+                    var_names = [ctx.next_var('val') for _ in batch_fields]
+                    ctx.emit(indent, '%s = unpack_from("%s", data, pos)' % (
+                        ', '.join(var_names), batch_fmt))
+                    ctx.emit(indent, 'pos += %d' % batch_size)
+                    if data_class is not None:
+                        for f, v in zip(batch_fields, var_names):
+                            ctx.emit(indent, '%s.%s = %s' % (var_name, f.name, v))
+            else:
+                # Non-batchable field (String, Bytes, Array, Struct, etc.)
+                v = ctx.next_var('val')
+                field.emit_decode_from(ctx, v, indent, version=version,
+                                       compact=compact, tagged=tagged)
+                if data_class is not None:
+                    ctx.emit(indent, '%s.%s = %s' % (var_name, field.name, v))
+                i += 1
+
+        if tagged:
+            # Fast path: most messages have zero tagged fields (single 0x00 byte).
+            # Only fall back to full TaggedFields.decode when tags are present.
+            ctx.emit(indent, 'if data[pos] == 0:')
+            ctx.emit(indent, '    pos += 1')
+            ctx.emit(indent, 'else:')
+            self._emit_tagged_decode(ctx, var_name, indent + '    ', version)
+        elif tagged is None:
+            # Empty tagged fields: single 0x00 byte
+            ctx.emit(indent, 'pos += 1  # empty tagged fields')
+
+    def _emit_tagged_decode(self, ctx, var_name, indent, version):
+        """Emit tagged fields decode - falls back to method-based decode."""
+        tf_var = ctx.next_var('tf')
+        ctx.globs[tf_var] = self.tagged_fields(version)
+        ctx.globs['_BytesIO'] = __import__('io').BytesIO
+        bio_var = ctx.next_var('bio')
+        ctx.emit(indent, '%s = _BytesIO(bytes(data[pos:]))' % bio_var)
+        ctx.emit(indent, '_tfd = %s.decode(%s, version=%d)' % (tf_var, bio_var, version))
+        ctx.emit(indent, 'pos += %s.tell()' % bio_var)
+        ctx.emit(indent, 'if _tfd:')
+        ctx.emit(indent, '    for _tk, _tv in _tfd.items():')
+        ctx.emit(indent, '        if _tk.startswith("_"):')
+        ctx.emit(indent, '            if %s.unknown_tags is None: %s.unknown_tags = {}' % (var_name, var_name))
+        ctx.emit(indent, '            %s.unknown_tags[_tk] = _tv' % var_name)
+        ctx.emit(indent, '        else:')
+        ctx.emit(indent, '            if %s.tags is None: %s.tags = set()' % (var_name, var_name))
+        ctx.emit(indent, '            %s.tags.add(_tk)' % var_name)
+        ctx.emit(indent, '            setattr(%s, _tk, _tv)' % var_name)
+
+    def compiled_decode_from(self, version, compact=False, tagged=False, data_class=None):
+        """Return a compiled flat decode function for this struct+version.
+
+        Lazily compiled on first call and cached. The returned function has
+        signature: f(data, pos) -> (obj, pos) where data is a memoryview/bytes.
+        data_class overrides self.data_class for the top-level object (needed
+        to resolve weakref proxies on ApiMessage classes).
+        """
+        key = ('decode', version, compact, tagged, data_class)
+        if key not in self._compiled_encoders:
+            # Temporarily override data_class for codegen if provided
+            saved = self._data_class
+            if data_class is not None:
+                self._data_class = data_class
+            try:
+                ctx = CodegenContext()
+                indent = '    '
+                ctx.lines.append('def _decode(data, pos):')
+                self.emit_decode_from(ctx, 'obj', indent, version=version,
+                                      compact=compact, tagged=tagged)
+                ctx.emit(indent, 'return obj, pos')
+                code = ctx.source()
+                exec(compile(code, '<codegen_decode:%s_v%d>' % (self.name, version), 'exec'), ctx.globs)
+                self._compiled_encoders[key] = ctx.globs['_decode']
+            finally:
+                self._data_class = saved
+        return self._compiled_encoders[key]
+
+    def decode(self, data, version=None, compact=False, tagged=False, data_class=None):
+        if self.nullable_for_version_q(version):
+            if data.read(1) == b'\xff':
+                return None
+        if data_class is None:
+            data_class = self.data_class
+        decoded = {
+            field.name: field.decode(data, version=version, compact=compact, tagged=tagged)
+            for field in self.untagged_fields(version)
+        }
+        if tagged:
+            decoded.update(self.tagged_fields(version).decode(data, version=version))
+        elif tagged is None:
+            TaggedFields.decode_empty(data)
+
+        if data_class is not None:
+            return data_class(version=version, **decoded)
+        return decoded
+
+    def __len__(self):
+        return len(self._fields)
+
+    def __eq__(self, other):
+        if not super().__eq__(other):
+            return False
+        if self._fields != other._fields:
+            return False
+        return True
+
+    def __repr__(self):
+        return 'StructField(%s)' % self._json

kafka/protocol/schemas/fields/struct_array.py

@@ -0,0 +1,142 @@
+from .array import ArrayField
+from .struct import StructField
+
+
+class StructArrayField(ArrayField):
+    @classmethod
+    def parse_inner_type(cls, json):
+        # StructArrayField requires non-empty fields
+        if 'fields' not in json:
+            return
+        assert len(json['fields']) > 0, 'Unexpected empty fields in json'
+        type_str = cls.parse_array_type(json)
+        if type_str is None:
+            return
+        inner_json = {**json, 'type': type_str}
+        return StructField.parse_json(inner_json)
+
+    @classmethod
+    def parse_json(cls, json):
+        inner_type = cls.parse_inner_type(json)
+        if inner_type is not None:
+            return cls(json, array_of=inner_type)
+
+    def __init__(self, json, array_of=None):
+        if array_of is None:
+            array_of = self.parse_inner_type(json)
+            assert array_of is not None, 'json does not contain a StructArray!'
+        super().__init__(json, array_of=array_of)
+        # nullableVersions on the JSON describes the array's nullability, not
+        # the inner struct's. Clear it on the inner struct so StructField does
+        # not try to emit a per-element null-prefix when encoding/decoding.
+        array_of._nullable_versions = None
+        # map_key will be (idx, field) of the mapKey field if found
+        self.map_key = next(filter(lambda x: x[1]._json.get('mapKey'), enumerate(self._fields)), None)
+
+    @property
+    def type_str(self):
+        return self._type_str[2:]
+
+    def is_struct_array(self):
+        return True
+
+    @property
+    def fields(self):
+        return self.array_of.fields
+
+    def tagged_fields(self, version):
+        return self.array_of.tagged_fields(version)
+
+    def untagged_fields(self, version):
+        return self.array_of.untagged_fields(version)
+
+    def has_data_class(self):
+        return self.array_of.has_data_class()
+
+    def set_data_class(self, data_class):
+        return self.array_of.set_data_class(data_class)
+
+    @property
+    def data_class(self):
+        return self.array_of.data_class
+
+    def __call__(self, *args, **kw):
+        return self.data_class(*args, **kw) # pylint: disable=E1102
+
+    def emit_decode_from(self, ctx, var_name, indent, version=None, compact=False, tagged=False):
+        from .codecs import UnsignedVarInt32
+        inner_struct = self.array_of
+        n = ctx.next_var('n')
+        if compact:
+            UnsignedVarInt32.emit_decode_from(ctx, n, indent)
+            ctx.emit(indent, '%s -= 1' % n)
+        else:
+            ctx.emit(indent, '%s = unpack_from(">i", data, pos)[0]' % n)
+            ctx.emit(indent, 'pos += 4')
+        ctx.emit(indent, 'if %s == -1:' % n)
+        ctx.emit(indent, '    %s = None' % var_name)
+        ctx.emit(indent, 'else:')
+        inner_indent = indent + '    '
+        ctx.emit(inner_indent, '%s = []' % var_name)
+        idx = ctx.next_var('idx')
+        item = ctx.next_var('obj')
+        ctx.emit(inner_indent, 'for %s in range(%s):' % (idx, n))
+        inner_struct.emit_decode_from(ctx, item, inner_indent + '    ',
+                                       version=version, compact=compact, tagged=tagged)
+        ctx.emit(inner_indent, '    %s.append(%s)' % (var_name, item))
+
+    def emit_encode_into(self, ctx, val_expr, indent, version=None, compact=False, tagged=False):
+        from .codecs import UnsignedVarInt32
+        inner_struct = self.array_of
+        fields = inner_struct.untagged_fields(version)
+        if compact:
+            an = ctx.next_var('an')
+            ctx.emit(indent, '%s = len(%s) + 1 if %s is not None else 0' % (an, val_expr, val_expr))
+            UnsignedVarInt32.emit_encode_into(ctx, an, indent)
+            ctx.emit(indent, 'if %s is not None:' % val_expr)
+        else:
+            ctx.emit(indent, 'if %s is None:' % val_expr)
+            ctx.emit(indent, "    pack_into('>i', buf, pos, -1)")
+            ctx.emit(indent, '    pos += 4')
+            ctx.emit(indent, 'else:')
+            ctx.emit(indent, "    pack_into('>i', buf, pos, len(%s))" % val_expr)
+            ctx.emit(indent, '    pos += 4')
+        guard = indent + '    '
+        item_var = ctx.next_var('si')
+        if len(fields) == 1:
+            # Single-field struct: items may be scalars (str, int, etc.)
+            ctx.emit(guard, 'for %s in %s:' % (item_var, val_expr))
+            scalar_indent = guard + '    '
+            ctx.emit(scalar_indent, 'if isinstance(%s, tuple): %s = %s[0]' % (item_var, item_var, item_var))
+            ctx.emit(scalar_indent, 'elif hasattr(%s, "%s"): %s = %s.%s' % (
+                item_var, fields[0].name, item_var, item_var, fields[0].name))
+            fields[0].emit_encode_into(ctx, item_var, scalar_indent,
+                                        version=version, compact=compact, tagged=tagged)
+            if tagged:
+                tf_var = ctx.next_var('tf')
+                ctx.globs[tf_var] = inner_struct.tagged_fields(version)
+                ctx.emit(scalar_indent, 'out.pos = pos')
+                ctx.emit(scalar_indent, '# tagged fields for single-field struct')
+                ctx.emit(scalar_indent, '%s.encode_into(%s, out, version=%d)' % (tf_var, item_var, version))
+                ctx.emit(scalar_indent, 'pos = out.pos')
+            elif tagged is None:
+                ctx.emit(scalar_indent, 'buf[pos] = 0')
+                ctx.emit(scalar_indent, 'pos += 1')
+        else:
+            # Multi-field struct: emit both tuple and attribute access paths.
+            # Use list() to handle non-subscriptable iterables (e.g., dict_items).
+            list_var = ctx.next_var('lst')
+            ctx.emit(guard, '%s = %s if isinstance(%s, list) else list(%s)' % (list_var, val_expr, val_expr, val_expr))
+            ctx.emit(guard, 'if %s and isinstance(%s[0], tuple):' % (list_var, list_var))
+            ctx.emit(guard, '    for %s in %s:' % (item_var, list_var))
+            inner_struct.emit_encode_into(ctx, item_var, guard + '        ',
+                                           version=version, compact=compact, tagged=tagged,
+                                           tuple_access=True)
+            ctx.emit(guard, 'else:')
+            ctx.emit(guard, '    for %s in %s:' % (item_var, list_var))
+            inner_struct.emit_encode_into(ctx, item_var, guard + '        ',
+                                           version=version, compact=compact, tagged=tagged,
+                                           tuple_access=False)
+
+    def __repr__(self):
+        return 'StructArrayField(%s)' % self._json

kafka/protocol/schemas/load_json.py

@@ -0,0 +1,42 @@
+import importlib.resources
+import inspect
+import json
+import re
+
+
+def load_json(msg_type, package=None):
+    if package is None:
+        package = __package__ + '.resources'
+    elif inspect.ismodule(package):
+        package = package.__package__
+    COMMENTS_REGEX = r"(?m)((?:^\s*//.*\n?)+)"
+    # Raises FileNotFoundError if not found
+    msg_json = importlib.resources.read_text(package, msg_type + '.json')
+    data = json.loads(re.sub(COMMENTS_REGEX, '', msg_json))
+    comments = re.findall(COMMENTS_REGEX, msg_json)
+    if comments:
+        data['license'] = comments[0]
+        if len(comments) > 1:
+            data['doc'] = comments[1]
+    common_structs = {s['name']: s['fields'] for s in data.get('commonStructs', [])}
+    if common_structs:
+        _resolve_common_structs(data.get('fields', []), common_structs)
+    return data
+
+
+def _resolve_common_structs(fields, common_structs):
+    for field in fields:
+        field_type = field['type']
+        struct_name = None
+        if field_type.startswith('[]'):
+            inner_type = field_type[2:]
+            if inner_type and inner_type[0].isupper():
+                struct_name = inner_type
+        elif field_type and field_type[0].isupper():
+            struct_name = field_type
+
+        if struct_name and struct_name in common_structs and 'fields' not in field:
+            field['fields'] = common_structs[struct_name]
+
+        if 'fields' in field:
+            _resolve_common_structs(field['fields'], common_structs)

kafka/protocol/schemas/resources/AddOffsetsToTxnRequest.json

@@ -0,0 +1,40 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+{
+  "apiKey": 25,
+  "type": "request",
+  "listeners": ["broker"],
+  "name": "AddOffsetsToTxnRequest",
+  // Version 1 is the same as version 0.
+  //
+  // Version 2 adds the support for new error code PRODUCER_FENCED.
+  //
+  // Version 3 enables flexible versions.
+  //
+  // Version 4 adds support for new error code TRANSACTION_ABORTABLE (KIP-890).
+  "validVersions": "0-4",
+  "flexibleVersions": "3+",
+  "fields": [
+    { "name": "TransactionalId", "type": "string", "versions": "0+", "entityType": "transactionalId",
+      "about": "The transactional id corresponding to the transaction."},
+    { "name": "ProducerId", "type": "int64", "versions": "0+", "entityType": "producerId",
+      "about": "Current producer id in use by the transactional id." },
+    { "name": "ProducerEpoch", "type": "int16", "versions": "0+",
+      "about": "Current epoch associated with the producer id." },
+    { "name": "GroupId", "type": "string", "versions": "0+", "entityType": "groupId",
+      "about": "The unique group identifier." }
+  ]
+}

kafka/protocol/schemas/resources/AddOffsetsToTxnResponse.json

@@ -0,0 +1,35 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+{
+  "apiKey": 25,
+  "type": "response",
+  "name": "AddOffsetsToTxnResponse",
+  // Starting in version 1, on quota violation brokers send out responses before throttling.
+  //
+  // Version 2 adds the support for new error code PRODUCER_FENCED.
+  //
+  // Version 3 enables flexible versions.
+  //
+  // Version 4 adds support for new error code TRANSACTION_ABORTABLE (KIP-890).
+  "validVersions": "0-4",
+  "flexibleVersions": "3+",
+  "fields": [
+    { "name": "ThrottleTimeMs", "type": "int32", "versions": "0+",
+      "about": "Duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota." },
+    { "name": "ErrorCode", "type": "int16", "versions": "0+",
+      "about": "The response error code, or 0 if there was no error." }
+  ]
+}