polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/btrfs_stream.py

@@ -0,0 +1,318 @@
+# 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 BtrfsStream(KaitaiStruct):
+    """Btrfs is a copy on write file system based on B-trees focusing on fault tolerance, repair and easy
+    administration. Btrfs is intended to address the lack of pooling, snapshots, checksums, and
+    integral multi-device spanning in Linux file systems.
+    Given any pair of subvolumes (or snapshots), Btrfs can generate a binary diff between them by
+    using the `btrfs send` command that can be replayed later by using `btrfs receive`, possibly on a
+    different Btrfs file system. The `btrfs send` command creates a set of data modifications required
+    for converting one subvolume into another.
+    This spec can be used to disassemble the binary diff created by the `btrfs send` command.
+    If you want a text representation you may want to checkout `btrfs receive --dump` instead.
+    
+    .. seealso::
+       Source - https://archive.kernel.org/oldwiki/btrfs.wiki.kernel.org/index.php/Design_notes_on_Send/Receive.html
+    """
+
+    class Command(Enum):
+        unspec = 0
+        subvol = 1
+        snapshot = 2
+        mkfile = 3
+        mkdir = 4
+        mknod = 5
+        mkfifo = 6
+        mksock = 7
+        symlink = 8
+        rename = 9
+        link = 10
+        unlink = 11
+        rmdir = 12
+        set_xattr = 13
+        remove_xattr = 14
+        write = 15
+        clone = 16
+        truncate = 17
+        chmod = 18
+        chown = 19
+        utimes = 20
+        end = 21
+        update_extent = 22
+
+    class Attribute(Enum):
+        unspec = 0
+        uuid = 1
+        ctransid = 2
+        ino = 3
+        size = 4
+        mode = 5
+        uid = 6
+        gid = 7
+        rdev = 8
+        ctime = 9
+        mtime = 10
+        atime = 11
+        otime = 12
+        xattr_name = 13
+        xattr_data = 14
+        path = 15
+        path_to = 16
+        path_link = 17
+        file_offset = 18
+        data = 19
+        clone_uuid = 20
+        clone_ctransid = 21
+        clone_path = 22
+        clone_offset = 23
+        clone_len = 24
+    SEQ_FIELDS = ["header", "commands"]
+    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 = BtrfsStream.SendStreamHeader(self._io, self, self._root)
+        self.header._read()
+        self._debug['header']['end'] = self._io.pos()
+        self._debug['commands']['start'] = self._io.pos()
+        self.commands = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['commands']:
+                self._debug['commands']['arr'] = []
+            self._debug['commands']['arr'].append({'start': self._io.pos()})
+            _t_commands = BtrfsStream.SendCommand(self._io, self, self._root)
+            _t_commands._read()
+            self.commands.append(_t_commands)
+            self._debug['commands']['arr'][len(self.commands) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['commands']['end'] = self._io.pos()
+
+    class SendStreamHeader(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "version"]
+        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(13)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x62\x74\x72\x66\x73\x2D\x73\x74\x72\x65\x61\x6D\x00":
+                raise kaitaistruct.ValidationNotEqualError(b"\x62\x74\x72\x66\x73\x2D\x73\x74\x72\x65\x61\x6D\x00", self.magic, self._io, u"/types/send_stream_header/seq/0")
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.read_u4le()
+            self._debug['version']['end'] = self._io.pos()
+
+
+    class SendCommand(KaitaiStruct):
+        SEQ_FIELDS = ["len_data", "type", "checksum", "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(BtrfsStream.Command, self._io.read_u2le())
+            self._debug['type']['end'] = self._io.pos()
+            self._debug['checksum']['start'] = self._io.pos()
+            self.checksum = self._io.read_bytes(4)
+            self._debug['checksum']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            self._raw_data = self._io.read_bytes(self.len_data)
+            _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+            self.data = BtrfsStream.SendCommand.Tlvs(_io__raw_data, self, self._root)
+            self.data._read()
+            self._debug['data']['end'] = self._io.pos()
+
+        class Tlv(KaitaiStruct):
+            SEQ_FIELDS = ["type", "length", "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['type']['start'] = self._io.pos()
+                self.type = KaitaiStream.resolve_enum(BtrfsStream.Attribute, self._io.read_u2le())
+                self._debug['type']['end'] = self._io.pos()
+                self._debug['length']['start'] = self._io.pos()
+                self.length = self._io.read_u2le()
+                self._debug['length']['end'] = self._io.pos()
+                self._debug['value']['start'] = self._io.pos()
+                _on = self.type
+                if _on == BtrfsStream.Attribute.ctransid:
+                    self.value = self._io.read_u8le()
+                elif _on == BtrfsStream.Attribute.size:
+                    self.value = self._io.read_u8le()
+                elif _on == BtrfsStream.Attribute.clone_uuid:
+                    self._raw_value = self._io.read_bytes(self.length)
+                    _io__raw_value = KaitaiStream(BytesIO(self._raw_value))
+                    self.value = BtrfsStream.SendCommand.Uuid(_io__raw_value, self, self._root)
+                    self.value._read()
+                elif _on == BtrfsStream.Attribute.file_offset:
+                    self.value = self._io.read_u8le()
+                elif _on == BtrfsStream.Attribute.otime:
+                    self._raw_value = self._io.read_bytes(self.length)
+                    _io__raw_value = KaitaiStream(BytesIO(self._raw_value))
+                    self.value = BtrfsStream.SendCommand.Timespec(_io__raw_value, self, self._root)
+                    self.value._read()
+                elif _on == BtrfsStream.Attribute.uid:
+                    self.value = self._io.read_u8le()
+                elif _on == BtrfsStream.Attribute.atime:
+                    self._raw_value = self._io.read_bytes(self.length)
+                    _io__raw_value = KaitaiStream(BytesIO(self._raw_value))
+                    self.value = BtrfsStream.SendCommand.Timespec(_io__raw_value, self, self._root)
+                    self.value._read()
+                elif _on == BtrfsStream.Attribute.ctime:
+                    self._raw_value = self._io.read_bytes(self.length)
+                    _io__raw_value = KaitaiStream(BytesIO(self._raw_value))
+                    self.value = BtrfsStream.SendCommand.Timespec(_io__raw_value, self, self._root)
+                    self.value._read()
+                elif _on == BtrfsStream.Attribute.uuid:
+                    self._raw_value = self._io.read_bytes(self.length)
+                    _io__raw_value = KaitaiStream(BytesIO(self._raw_value))
+                    self.value = BtrfsStream.SendCommand.Uuid(_io__raw_value, self, self._root)
+                    self.value._read()
+                elif _on == BtrfsStream.Attribute.clone_len:
+                    self.value = self._io.read_u8le()
+                elif _on == BtrfsStream.Attribute.xattr_name:
+                    self._raw_value = self._io.read_bytes(self.length)
+                    _io__raw_value = KaitaiStream(BytesIO(self._raw_value))
+                    self.value = BtrfsStream.SendCommand.String(_io__raw_value, self, self._root)
+                    self.value._read()
+                elif _on == BtrfsStream.Attribute.clone_ctransid:
+                    self.value = self._io.read_u8le()
+                elif _on == BtrfsStream.Attribute.mode:
+                    self.value = self._io.read_u8le()
+                elif _on == BtrfsStream.Attribute.mtime:
+                    self._raw_value = self._io.read_bytes(self.length)
+                    _io__raw_value = KaitaiStream(BytesIO(self._raw_value))
+                    self.value = BtrfsStream.SendCommand.Timespec(_io__raw_value, self, self._root)
+                    self.value._read()
+                elif _on == BtrfsStream.Attribute.path_link:
+                    self._raw_value = self._io.read_bytes(self.length)
+                    _io__raw_value = KaitaiStream(BytesIO(self._raw_value))
+                    self.value = BtrfsStream.SendCommand.String(_io__raw_value, self, self._root)
+                    self.value._read()
+                elif _on == BtrfsStream.Attribute.rdev:
+                    self.value = self._io.read_u8le()
+                elif _on == BtrfsStream.Attribute.path_to:
+                    self._raw_value = self._io.read_bytes(self.length)
+                    _io__raw_value = KaitaiStream(BytesIO(self._raw_value))
+                    self.value = BtrfsStream.SendCommand.String(_io__raw_value, self, self._root)
+                    self.value._read()
+                elif _on == BtrfsStream.Attribute.path:
+                    self._raw_value = self._io.read_bytes(self.length)
+                    _io__raw_value = KaitaiStream(BytesIO(self._raw_value))
+                    self.value = BtrfsStream.SendCommand.String(_io__raw_value, self, self._root)
+                    self.value._read()
+                elif _on == BtrfsStream.Attribute.clone_offset:
+                    self.value = self._io.read_u8le()
+                elif _on == BtrfsStream.Attribute.gid:
+                    self.value = self._io.read_u8le()
+                elif _on == BtrfsStream.Attribute.clone_path:
+                    self._raw_value = self._io.read_bytes(self.length)
+                    _io__raw_value = KaitaiStream(BytesIO(self._raw_value))
+                    self.value = BtrfsStream.SendCommand.String(_io__raw_value, self, self._root)
+                    self.value._read()
+                else:
+                    self.value = self._io.read_bytes(self.length)
+                self._debug['value']['end'] = self._io.pos()
+
+
+        class Uuid(KaitaiStruct):
+            SEQ_FIELDS = ["uuid"]
+            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['uuid']['start'] = self._io.pos()
+                self.uuid = self._io.read_bytes(16)
+                self._debug['uuid']['end'] = self._io.pos()
+
+
+        class Tlvs(KaitaiStruct):
+            SEQ_FIELDS = ["tlv"]
+            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['tlv']['start'] = self._io.pos()
+                self.tlv = []
+                i = 0
+                while not self._io.is_eof():
+                    if not 'arr' in self._debug['tlv']:
+                        self._debug['tlv']['arr'] = []
+                    self._debug['tlv']['arr'].append({'start': self._io.pos()})
+                    _t_tlv = BtrfsStream.SendCommand.Tlv(self._io, self, self._root)
+                    _t_tlv._read()
+                    self.tlv.append(_t_tlv)
+                    self._debug['tlv']['arr'][len(self.tlv) - 1]['end'] = self._io.pos()
+                    i += 1
+
+                self._debug['tlv']['end'] = self._io.pos()
+
+
+        class String(KaitaiStruct):
+            SEQ_FIELDS = ["string"]
+            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['string']['start'] = self._io.pos()
+                self.string = (self._io.read_bytes_full()).decode(u"UTF-8")
+                self._debug['string']['end'] = self._io.pos()
+
+
+        class Timespec(KaitaiStruct):
+            SEQ_FIELDS = ["ts_sec", "ts_nsec"]
+            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['ts_sec']['start'] = self._io.pos()
+                self.ts_sec = self._io.read_s8le()
+                self._debug['ts_sec']['end'] = self._io.pos()
+                self._debug['ts_nsec']['start'] = self._io.pos()
+                self.ts_nsec = self._io.read_s4le()
+                self._debug['ts_nsec']['end'] = self._io.pos()
+
+
+
+

polyfile/kaitai/parsers/bytes_with_io.py

@@ -0,0 +1,27 @@
+# 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
+
+
+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 BytesWithIo(KaitaiStruct):
+    """Helper type to work around Kaitai Struct not providing an `_io` member for plain byte arrays.
+    """
+    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/chrome_pak.py

@@ -0,0 +1,194 @@
+# 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 ChromePak(KaitaiStruct):
+    """Format mostly used by Google Chrome and various Android apps to store
+    resources such as translated strings, help messages and images.
+    
+    .. seealso::
+       Source - https://web.archive.org/web/20220126211447/https://dev.chromium.org/developers/design-documents/linuxresourcesandlocalizedstrings
+    
+    
+    .. seealso::
+       Source - https://chromium.googlesource.com/chromium/src/tools/grit/+/3c36f27/grit/format/data_pack.py
+    
+    
+    .. seealso::
+       Source - https://chromium.googlesource.com/chromium/src/tools/grit/+/8a23eae/grit/format/data_pack.py
+    """
+
+    class Encodings(Enum):
+        binary = 0
+        utf8 = 1
+        utf16 = 2
+    SEQ_FIELDS = ["version", "num_resources_v4", "encoding", "v5_part", "resources", "aliases"]
+    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_u4le()
+        self._debug['version']['end'] = self._io.pos()
+        if not  ((self.version == 4) or (self.version == 5)) :
+            raise kaitaistruct.ValidationNotAnyOfError(self.version, self._io, u"/seq/0")
+        if self.version == 4:
+            self._debug['num_resources_v4']['start'] = self._io.pos()
+            self.num_resources_v4 = self._io.read_u4le()
+            self._debug['num_resources_v4']['end'] = self._io.pos()
+
+        self._debug['encoding']['start'] = self._io.pos()
+        self.encoding = KaitaiStream.resolve_enum(ChromePak.Encodings, self._io.read_u1())
+        self._debug['encoding']['end'] = self._io.pos()
+        if self.version == 5:
+            self._debug['v5_part']['start'] = self._io.pos()
+            self.v5_part = ChromePak.HeaderV5Part(self._io, self, self._root)
+            self.v5_part._read()
+            self._debug['v5_part']['end'] = self._io.pos()
+
+        self._debug['resources']['start'] = self._io.pos()
+        self.resources = [None] * ((self.num_resources + 1))
+        for i in range((self.num_resources + 1)):
+            if not 'arr' in self._debug['resources']:
+                self._debug['resources']['arr'] = []
+            self._debug['resources']['arr'].append({'start': self._io.pos()})
+            _t_resources = ChromePak.Resource(i, i < self.num_resources, self._io, self, self._root)
+            _t_resources._read()
+            self.resources[i] = _t_resources
+            self._debug['resources']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['resources']['end'] = self._io.pos()
+        self._debug['aliases']['start'] = self._io.pos()
+        self.aliases = [None] * (self.num_aliases)
+        for i in range(self.num_aliases):
+            if not 'arr' in self._debug['aliases']:
+                self._debug['aliases']['arr'] = []
+            self._debug['aliases']['arr'].append({'start': self._io.pos()})
+            _t_aliases = ChromePak.Alias(self._io, self, self._root)
+            _t_aliases._read()
+            self.aliases[i] = _t_aliases
+            self._debug['aliases']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['aliases']['end'] = self._io.pos()
+
+    class HeaderV5Part(KaitaiStruct):
+        SEQ_FIELDS = ["encoding_padding", "num_resources", "num_aliases"]
+        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['encoding_padding']['start'] = self._io.pos()
+            self.encoding_padding = self._io.read_bytes(3)
+            self._debug['encoding_padding']['end'] = self._io.pos()
+            self._debug['num_resources']['start'] = self._io.pos()
+            self.num_resources = self._io.read_u2le()
+            self._debug['num_resources']['end'] = self._io.pos()
+            self._debug['num_aliases']['start'] = self._io.pos()
+            self.num_aliases = self._io.read_u2le()
+            self._debug['num_aliases']['end'] = self._io.pos()
+
+
+    class Resource(KaitaiStruct):
+        SEQ_FIELDS = ["id", "ofs_body"]
+        def __init__(self, idx, has_body, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self.idx = idx
+            self.has_body = has_body
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['id']['start'] = self._io.pos()
+            self.id = self._io.read_u2le()
+            self._debug['id']['end'] = self._io.pos()
+            self._debug['ofs_body']['start'] = self._io.pos()
+            self.ofs_body = self._io.read_u4le()
+            self._debug['ofs_body']['end'] = self._io.pos()
+
+        @property
+        def len_body(self):
+            """MUST NOT be accessed until the next `resource` is parsed."""
+            if hasattr(self, '_m_len_body'):
+                return self._m_len_body if hasattr(self, '_m_len_body') else None
+
+            if self.has_body:
+                self._m_len_body = (self._parent.resources[(self.idx + 1)].ofs_body - self.ofs_body)
+
+            return self._m_len_body if hasattr(self, '_m_len_body') else None
+
+        @property
+        def body(self):
+            """MUST NOT be accessed until the next `resource` is parsed."""
+            if hasattr(self, '_m_body'):
+                return self._m_body if hasattr(self, '_m_body') else None
+
+            if self.has_body:
+                _pos = self._io.pos()
+                self._io.seek(self.ofs_body)
+                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
+
+
+    class Alias(KaitaiStruct):
+        SEQ_FIELDS = ["id", "resource_idx"]
+        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['id']['start'] = self._io.pos()
+            self.id = self._io.read_u2le()
+            self._debug['id']['end'] = self._io.pos()
+            self._debug['resource_idx']['start'] = self._io.pos()
+            self.resource_idx = self._io.read_u2le()
+            self._debug['resource_idx']['end'] = self._io.pos()
+            if not self.resource_idx <= (self._parent.num_resources - 1):
+                raise kaitaistruct.ValidationGreaterThanError((self._parent.num_resources - 1), self.resource_idx, self._io, u"/types/alias/seq/1")
+
+        @property
+        def resource(self):
+            if hasattr(self, '_m_resource'):
+                return self._m_resource if hasattr(self, '_m_resource') else None
+
+            self._m_resource = self._parent.resources[self.resource_idx]
+            return self._m_resource if hasattr(self, '_m_resource') else None
+
+
+    @property
+    def num_resources(self):
+        if hasattr(self, '_m_num_resources'):
+            return self._m_num_resources if hasattr(self, '_m_num_resources') else None
+
+        self._m_num_resources = (self.v5_part.num_resources if self.version == 5 else self.num_resources_v4)
+        return self._m_num_resources if hasattr(self, '_m_num_resources') else None
+
+    @property
+    def num_aliases(self):
+        if hasattr(self, '_m_num_aliases'):
+            return self._m_num_aliases if hasattr(self, '_m_num_aliases') else None
+
+        self._m_num_aliases = (self.v5_part.num_aliases if self.version == 5 else 0)
+        return self._m_num_aliases if hasattr(self, '_m_num_aliases') else None
+
+