polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/gimp_brush.py

@@ -0,0 +1,244 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class GimpBrush(KaitaiStruct):
+    """GIMP brush format is native to the GIMP image editor for storing a brush or a texture.
+    It can be used in all [Paint Tools](https://docs.gimp.org/2.10/en/gimp-tools-paint.html),
+    for example Pencil and Paintbrush. It works by repeating the brush bitmap as you move
+    the tool. The Spacing parameter sets the distance between the brush marks as a percentage
+    of brush width. Its default value can be set in the brush file.
+    
+    You can also use GIMP to create new brushes in this format. Custom brushes can be loaded
+    into GIMP for use in the paint tools by copying them into one of the Brush Folders -
+    select **Edit** > **Preferences** in the menu bar, expand the **Folders** section
+    and choose **Brushes** to see the recognized Brush Folders or to add new ones.
+    
+    .. seealso::
+       Source - https://github.com/GNOME/gimp/blob/441631322b/devel-docs/gbr.txt
+    """
+
+    class ColorDepth(Enum):
+        grayscale = 1
+        rgba = 4
+    SEQ_FIELDS = ["len_header", "header"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['len_header']['start'] = self._io.pos()
+        self.len_header = self._io.read_u4be()
+        self._debug['len_header']['end'] = self._io.pos()
+        self._debug['header']['start'] = self._io.pos()
+        self._raw_header = self._io.read_bytes((self.len_header - 4))
+        _io__raw_header = KaitaiStream(BytesIO(self._raw_header))
+        self.header = GimpBrush.Header(_io__raw_header, self, self._root)
+        self.header._read()
+        self._debug['header']['end'] = self._io.pos()
+
+    class Header(KaitaiStruct):
+        SEQ_FIELDS = ["version", "width", "height", "bytes_per_pixel", "magic", "spacing", "brush_name"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.read_u4be()
+            self._debug['version']['end'] = self._io.pos()
+            if not self.version == 2:
+                raise kaitaistruct.ValidationNotEqualError(2, self.version, self._io, u"/types/header/seq/0")
+            self._debug['width']['start'] = self._io.pos()
+            self.width = self._io.read_u4be()
+            self._debug['width']['end'] = self._io.pos()
+            if not self.width >= 1:
+                raise kaitaistruct.ValidationLessThanError(1, self.width, self._io, u"/types/header/seq/1")
+            if not self.width <= 10000:
+                raise kaitaistruct.ValidationGreaterThanError(10000, self.width, self._io, u"/types/header/seq/1")
+            self._debug['height']['start'] = self._io.pos()
+            self.height = self._io.read_u4be()
+            self._debug['height']['end'] = self._io.pos()
+            if not self.height >= 1:
+                raise kaitaistruct.ValidationLessThanError(1, self.height, self._io, u"/types/header/seq/2")
+            if not self.height <= 10000:
+                raise kaitaistruct.ValidationGreaterThanError(10000, self.height, self._io, u"/types/header/seq/2")
+            self._debug['bytes_per_pixel']['start'] = self._io.pos()
+            self.bytes_per_pixel = KaitaiStream.resolve_enum(GimpBrush.ColorDepth, self._io.read_u4be())
+            self._debug['bytes_per_pixel']['end'] = self._io.pos()
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.read_bytes(4)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x47\x49\x4D\x50":
+                raise kaitaistruct.ValidationNotEqualError(b"\x47\x49\x4D\x50", self.magic, self._io, u"/types/header/seq/4")
+            self._debug['spacing']['start'] = self._io.pos()
+            self.spacing = self._io.read_u4be()
+            self._debug['spacing']['end'] = self._io.pos()
+            self._debug['brush_name']['start'] = self._io.pos()
+            self.brush_name = (KaitaiStream.bytes_terminate(self._io.read_bytes_full(), 0, False)).decode(u"UTF-8")
+            self._debug['brush_name']['end'] = self._io.pos()
+
+
+    class Bitmap(KaitaiStruct):
+        SEQ_FIELDS = ["rows"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['rows']['start'] = self._io.pos()
+            self.rows = [None] * (self._root.header.height)
+            for i in range(self._root.header.height):
+                if not 'arr' in self._debug['rows']:
+                    self._debug['rows']['arr'] = []
+                self._debug['rows']['arr'].append({'start': self._io.pos()})
+                _t_rows = GimpBrush.Row(self._io, self, self._root)
+                _t_rows._read()
+                self.rows[i] = _t_rows
+                self._debug['rows']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['rows']['end'] = self._io.pos()
+
+
+    class Row(KaitaiStruct):
+        SEQ_FIELDS = ["pixels"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['pixels']['start'] = self._io.pos()
+            self.pixels = [None] * (self._root.header.width)
+            for i in range(self._root.header.width):
+                if not 'arr' in self._debug['pixels']:
+                    self._debug['pixels']['arr'] = []
+                self._debug['pixels']['arr'].append({'start': self._io.pos()})
+                _on = self._root.header.bytes_per_pixel
+                if _on == GimpBrush.ColorDepth.grayscale:
+                    if not 'arr' in self._debug['pixels']:
+                        self._debug['pixels']['arr'] = []
+                    self._debug['pixels']['arr'].append({'start': self._io.pos()})
+                    _t_pixels = GimpBrush.Row.PixelGray(self._io, self, self._root)
+                    _t_pixels._read()
+                    self.pixels[i] = _t_pixels
+                    self._debug['pixels']['arr'][i]['end'] = self._io.pos()
+                elif _on == GimpBrush.ColorDepth.rgba:
+                    if not 'arr' in self._debug['pixels']:
+                        self._debug['pixels']['arr'] = []
+                    self._debug['pixels']['arr'].append({'start': self._io.pos()})
+                    _t_pixels = GimpBrush.Row.PixelRgba(self._io, self, self._root)
+                    _t_pixels._read()
+                    self.pixels[i] = _t_pixels
+                    self._debug['pixels']['arr'][i]['end'] = self._io.pos()
+                self._debug['pixels']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['pixels']['end'] = self._io.pos()
+
+        class PixelGray(KaitaiStruct):
+            SEQ_FIELDS = ["gray"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['gray']['start'] = self._io.pos()
+                self.gray = self._io.read_u1()
+                self._debug['gray']['end'] = self._io.pos()
+
+            @property
+            def red(self):
+                if hasattr(self, '_m_red'):
+                    return self._m_red if hasattr(self, '_m_red') else None
+
+                self._m_red = 0
+                return self._m_red if hasattr(self, '_m_red') else None
+
+            @property
+            def green(self):
+                if hasattr(self, '_m_green'):
+                    return self._m_green if hasattr(self, '_m_green') else None
+
+                self._m_green = 0
+                return self._m_green if hasattr(self, '_m_green') else None
+
+            @property
+            def blue(self):
+                if hasattr(self, '_m_blue'):
+                    return self._m_blue if hasattr(self, '_m_blue') else None
+
+                self._m_blue = 0
+                return self._m_blue if hasattr(self, '_m_blue') else None
+
+            @property
+            def alpha(self):
+                if hasattr(self, '_m_alpha'):
+                    return self._m_alpha if hasattr(self, '_m_alpha') else None
+
+                self._m_alpha = self.gray
+                return self._m_alpha if hasattr(self, '_m_alpha') else None
+
+
+        class PixelRgba(KaitaiStruct):
+            SEQ_FIELDS = ["red", "green", "blue", "alpha"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['red']['start'] = self._io.pos()
+                self.red = self._io.read_u1()
+                self._debug['red']['end'] = self._io.pos()
+                self._debug['green']['start'] = self._io.pos()
+                self.green = self._io.read_u1()
+                self._debug['green']['end'] = self._io.pos()
+                self._debug['blue']['start'] = self._io.pos()
+                self.blue = self._io.read_u1()
+                self._debug['blue']['end'] = self._io.pos()
+                self._debug['alpha']['start'] = self._io.pos()
+                self.alpha = self._io.read_u1()
+                self._debug['alpha']['end'] = self._io.pos()
+
+
+
+    @property
+    def len_body(self):
+        if hasattr(self, '_m_len_body'):
+            return self._m_len_body if hasattr(self, '_m_len_body') else None
+
+        self._m_len_body = ((self.header.width * self.header.height) * self.header.bytes_per_pixel.value)
+        return self._m_len_body if hasattr(self, '_m_len_body') else None
+
+    @property
+    def body(self):
+        if hasattr(self, '_m_body'):
+            return self._m_body if hasattr(self, '_m_body') else None
+
+        _pos = self._io.pos()
+        self._io.seek(self.len_header)
+        self._debug['_m_body']['start'] = self._io.pos()
+        self._m_body = self._io.read_bytes(self.len_body)
+        self._debug['_m_body']['end'] = self._io.pos()
+        self._io.seek(_pos)
+        return self._m_body if hasattr(self, '_m_body') else None
+
+

polyfile/kaitai/parsers/glibc_utmp.py

@@ -0,0 +1,114 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class GlibcUtmp(KaitaiStruct):
+
+    class EntryType(Enum):
+        empty = 0
+        run_lvl = 1
+        boot_time = 2
+        new_time = 3
+        old_time = 4
+        init_process = 5
+        login_process = 6
+        user_process = 7
+        dead_process = 8
+        accounting = 9
+    SEQ_FIELDS = ["records"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['records']['start'] = self._io.pos()
+        self._raw_records = []
+        self.records = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['records']:
+                self._debug['records']['arr'] = []
+            self._debug['records']['arr'].append({'start': self._io.pos()})
+            self._raw_records.append(self._io.read_bytes(384))
+            _io__raw_records = KaitaiStream(BytesIO(self._raw_records[-1]))
+            _t_records = GlibcUtmp.Record(_io__raw_records, self, self._root)
+            _t_records._read()
+            self.records.append(_t_records)
+            self._debug['records']['arr'][len(self.records) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['records']['end'] = self._io.pos()
+
+    class Record(KaitaiStruct):
+        SEQ_FIELDS = ["ut_type", "pid", "line", "id", "user", "host", "exit", "session", "tv", "addr_v6", "reserved"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['ut_type']['start'] = self._io.pos()
+            self.ut_type = KaitaiStream.resolve_enum(GlibcUtmp.EntryType, self._io.read_s4le())
+            self._debug['ut_type']['end'] = self._io.pos()
+            self._debug['pid']['start'] = self._io.pos()
+            self.pid = self._io.read_u4le()
+            self._debug['pid']['end'] = self._io.pos()
+            self._debug['line']['start'] = self._io.pos()
+            self.line = (self._io.read_bytes(32)).decode(u"UTF-8")
+            self._debug['line']['end'] = self._io.pos()
+            self._debug['id']['start'] = self._io.pos()
+            self.id = (self._io.read_bytes(4)).decode(u"UTF-8")
+            self._debug['id']['end'] = self._io.pos()
+            self._debug['user']['start'] = self._io.pos()
+            self.user = (self._io.read_bytes(32)).decode(u"UTF-8")
+            self._debug['user']['end'] = self._io.pos()
+            self._debug['host']['start'] = self._io.pos()
+            self.host = (self._io.read_bytes(256)).decode(u"UTF-8")
+            self._debug['host']['end'] = self._io.pos()
+            self._debug['exit']['start'] = self._io.pos()
+            self.exit = self._io.read_u4le()
+            self._debug['exit']['end'] = self._io.pos()
+            self._debug['session']['start'] = self._io.pos()
+            self.session = self._io.read_s4le()
+            self._debug['session']['end'] = self._io.pos()
+            self._debug['tv']['start'] = self._io.pos()
+            self.tv = GlibcUtmp.Timeval(self._io, self, self._root)
+            self.tv._read()
+            self._debug['tv']['end'] = self._io.pos()
+            self._debug['addr_v6']['start'] = self._io.pos()
+            self.addr_v6 = self._io.read_bytes(16)
+            self._debug['addr_v6']['end'] = self._io.pos()
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_bytes(20)
+            self._debug['reserved']['end'] = self._io.pos()
+
+
+    class Timeval(KaitaiStruct):
+        SEQ_FIELDS = ["sec", "usec"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['sec']['start'] = self._io.pos()
+            self.sec = self._io.read_s4le()
+            self._debug['sec']['end'] = self._io.pos()
+            self._debug['usec']['start'] = self._io.pos()
+            self.usec = self._io.read_s4le()
+            self._debug['usec']['end'] = self._io.pos()
+
+
+

polyfile/kaitai/parsers/gltf_binary.py

@@ -0,0 +1,132 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class GltfBinary(KaitaiStruct):
+    """glTF is a format for distribution of 3D models optimized for being used in software
+    
+    .. seealso::
+       Source - https://github.com/KhronosGroup/glTF/tree/2354846/specification/2.0#binary-gltf-layout
+    """
+
+    class ChunkType(Enum):
+        bin = 5130562
+        json = 1313821514
+    SEQ_FIELDS = ["header", "chunks"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['header']['start'] = self._io.pos()
+        self.header = GltfBinary.Header(self._io, self, self._root)
+        self.header._read()
+        self._debug['header']['end'] = self._io.pos()
+        self._debug['chunks']['start'] = self._io.pos()
+        self.chunks = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['chunks']:
+                self._debug['chunks']['arr'] = []
+            self._debug['chunks']['arr'].append({'start': self._io.pos()})
+            _t_chunks = GltfBinary.Chunk(self._io, self, self._root)
+            _t_chunks._read()
+            self.chunks.append(_t_chunks)
+            self._debug['chunks']['arr'][len(self.chunks) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['chunks']['end'] = self._io.pos()
+
+    class Header(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "version", "length"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.read_bytes(4)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x67\x6C\x54\x46":
+                raise kaitaistruct.ValidationNotEqualError(b"\x67\x6C\x54\x46", self.magic, self._io, u"/types/header/seq/0")
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.read_u4le()
+            self._debug['version']['end'] = self._io.pos()
+            self._debug['length']['start'] = self._io.pos()
+            self.length = self._io.read_u4le()
+            self._debug['length']['end'] = self._io.pos()
+
+
+    class Chunk(KaitaiStruct):
+        SEQ_FIELDS = ["len_data", "type", "data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['len_data']['start'] = self._io.pos()
+            self.len_data = self._io.read_u4le()
+            self._debug['len_data']['end'] = self._io.pos()
+            self._debug['type']['start'] = self._io.pos()
+            self.type = KaitaiStream.resolve_enum(GltfBinary.ChunkType, self._io.read_u4le())
+            self._debug['type']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            _on = self.type
+            if _on == GltfBinary.ChunkType.json:
+                self._raw_data = self._io.read_bytes(self.len_data)
+                _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+                self.data = GltfBinary.Json(_io__raw_data, self, self._root)
+                self.data._read()
+            elif _on == GltfBinary.ChunkType.bin:
+                self._raw_data = self._io.read_bytes(self.len_data)
+                _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+                self.data = GltfBinary.Bin(_io__raw_data, self, self._root)
+                self.data._read()
+            else:
+                self.data = self._io.read_bytes(self.len_data)
+            self._debug['data']['end'] = self._io.pos()
+
+
+    class Json(KaitaiStruct):
+        SEQ_FIELDS = ["data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['data']['start'] = self._io.pos()
+            self.data = (self._io.read_bytes_full()).decode(u"UTF-8")
+            self._debug['data']['end'] = self._io.pos()
+
+
+    class Bin(KaitaiStruct):
+        SEQ_FIELDS = ["data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['data']['start'] = self._io.pos()
+            self.data = self._io.read_bytes_full()
+            self._debug['data']['end'] = self._io.pos()
+
+
+

polyfile/kaitai/parsers/google_protobuf.py

@@ -0,0 +1,151 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+from enum import Enum
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+from polyfile.kaitai.parsers import vlq_base128_le
+class GoogleProtobuf(KaitaiStruct):
+    """Google Protocol Buffers (AKA protobuf) is a popular data
+    serialization scheme used for communication protocols, data storage,
+    etc. There are implementations are available for almost every
+    popular language. The focus points of this scheme are brevity (data
+    is encoded in a very size-efficient manner) and extensibility (one
+    can add keys to the structure, while keeping it readable in previous
+    version of software).
+    
+    Protobuf uses semi-self-describing encoding scheme for its
+    messages. It means that it is possible to parse overall structure of
+    the message (skipping over fields one can't understand), but to
+    fully understand the message, one needs a protocol definition file
+    (`.proto`). To be specific:
+    
+    * "Keys" in key-value pairs provided in the message are identified
+      only with an integer "field tag". `.proto` file provides info on
+      which symbolic field names these field tags map to.
+    * "Keys" also provide something called "wire type". It's not a data
+      type in its common sense (i.e. you can't, for example, distinguish
+      `sint32` vs `uint32` vs some enum, or `string` from `bytes`), but
+      it's enough information to determine how many bytes to
+      parse. Interpretation of the value should be done according to the
+      type specified in `.proto` file.
+    * There's no direct information on which fields are optional /
+      required, which fields may be repeated or constitute a map, what
+      restrictions are placed on fields usage in a single message, what
+      are the fields' default values, etc, etc.
+    
+    .. seealso::
+       Source - https://protobuf.dev/programming-guides/encoding/
+    """
+    SEQ_FIELDS = ["pairs"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['pairs']['start'] = self._io.pos()
+        self.pairs = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['pairs']:
+                self._debug['pairs']['arr'] = []
+            self._debug['pairs']['arr'].append({'start': self._io.pos()})
+            _t_pairs = GoogleProtobuf.Pair(self._io, self, self._root)
+            _t_pairs._read()
+            self.pairs.append(_t_pairs)
+            self._debug['pairs']['arr'][len(self.pairs) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['pairs']['end'] = self._io.pos()
+
+    class Pair(KaitaiStruct):
+        """Key-value pair."""
+
+        class WireTypes(Enum):
+            varint = 0
+            bit_64 = 1
+            len_delimited = 2
+            group_start = 3
+            group_end = 4
+            bit_32 = 5
+        SEQ_FIELDS = ["key", "value"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['key']['start'] = self._io.pos()
+            self.key = vlq_base128_le.VlqBase128Le(self._io)
+            self.key._read()
+            self._debug['key']['end'] = self._io.pos()
+            self._debug['value']['start'] = self._io.pos()
+            _on = self.wire_type
+            if _on == GoogleProtobuf.Pair.WireTypes.varint:
+                self.value = vlq_base128_le.VlqBase128Le(self._io)
+                self.value._read()
+            elif _on == GoogleProtobuf.Pair.WireTypes.len_delimited:
+                self.value = GoogleProtobuf.DelimitedBytes(self._io, self, self._root)
+                self.value._read()
+            elif _on == GoogleProtobuf.Pair.WireTypes.bit_64:
+                self.value = self._io.read_u8le()
+            elif _on == GoogleProtobuf.Pair.WireTypes.bit_32:
+                self.value = self._io.read_u4le()
+            self._debug['value']['end'] = self._io.pos()
+
+        @property
+        def wire_type(self):
+            """"Wire type" is a part of the "key" that carries enough
+            information to parse value from the wire, i.e. read correct
+            amount of bytes, but there's not enough informaton to
+            interprete in unambiguously. For example, one can't clearly
+            distinguish 64-bit fixed-sized integers from 64-bit floats,
+            signed zigzag-encoded varints from regular unsigned varints,
+            arbitrary bytes from UTF-8 encoded strings, etc.
+            """
+            if hasattr(self, '_m_wire_type'):
+                return self._m_wire_type if hasattr(self, '_m_wire_type') else None
+
+            self._m_wire_type = KaitaiStream.resolve_enum(GoogleProtobuf.Pair.WireTypes, (self.key.value & 7))
+            return self._m_wire_type if hasattr(self, '_m_wire_type') else None
+
+        @property
+        def field_tag(self):
+            """Identifies a field of protocol. One can look up symbolic
+            field name in a `.proto` file by this field tag.
+            """
+            if hasattr(self, '_m_field_tag'):
+                return self._m_field_tag if hasattr(self, '_m_field_tag') else None
+
+            self._m_field_tag = (self.key.value >> 3)
+            return self._m_field_tag if hasattr(self, '_m_field_tag') else None
+
+
+    class DelimitedBytes(KaitaiStruct):
+        SEQ_FIELDS = ["len", "body"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['len']['start'] = self._io.pos()
+            self.len = vlq_base128_le.VlqBase128Le(self._io)
+            self.len._read()
+            self._debug['len']['end'] = self._io.pos()
+            self._debug['body']['start'] = self._io.pos()
+            self.body = self._io.read_bytes(self.len.value)
+            self._debug['body']['end'] = self._io.pos()
+
+
+