polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/jpeg.py

@@ -0,0 +1,361 @@
+# 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__))
+
+from polyfile.kaitai.parsers import exif
+class Jpeg(KaitaiStruct):
+    """JPEG File Interchange Format, or JFIF, or, more colloquially known
+    as just "JPEG" or "JPG", is a popular 2D bitmap image file format,
+    offering lossy compression which works reasonably well with
+    photographic images.
+    
+    Format is organized as a container format, serving multiple
+    "segments", each starting with a magic and a marker. JFIF standard
+    dictates order and mandatory apperance of segments:
+    
+    * SOI
+    * APP0 (with JFIF magic)
+    * APP0 (with JFXX magic, optional)
+    * everything else
+    * SOS
+    * JPEG-compressed stream
+    * EOI
+    """
+
+    class ComponentId(Enum):
+        y = 1
+        cb = 2
+        cr = 3
+        i = 4
+        q = 5
+    SEQ_FIELDS = ["segments"]
+    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['segments']['start'] = self._io.pos()
+        self.segments = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['segments']:
+                self._debug['segments']['arr'] = []
+            self._debug['segments']['arr'].append({'start': self._io.pos()})
+            _t_segments = Jpeg.Segment(self._io, self, self._root)
+            _t_segments._read()
+            self.segments.append(_t_segments)
+            self._debug['segments']['arr'][len(self.segments) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['segments']['end'] = self._io.pos()
+
+    class Segment(KaitaiStruct):
+
+        class MarkerEnum(Enum):
+            tem = 1
+            sof0 = 192
+            sof1 = 193
+            sof2 = 194
+            sof3 = 195
+            dht = 196
+            sof5 = 197
+            sof6 = 198
+            sof7 = 199
+            soi = 216
+            eoi = 217
+            sos = 218
+            dqt = 219
+            dnl = 220
+            dri = 221
+            dhp = 222
+            app0 = 224
+            app1 = 225
+            app2 = 226
+            app3 = 227
+            app4 = 228
+            app5 = 229
+            app6 = 230
+            app7 = 231
+            app8 = 232
+            app9 = 233
+            app10 = 234
+            app11 = 235
+            app12 = 236
+            app13 = 237
+            app14 = 238
+            app15 = 239
+            com = 254
+        SEQ_FIELDS = ["magic", "marker", "length", "data", "image_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['magic']['start'] = self._io.pos()
+            self.magic = self._io.read_bytes(1)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\xFF":
+                raise kaitaistruct.ValidationNotEqualError(b"\xFF", self.magic, self._io, u"/types/segment/seq/0")
+            self._debug['marker']['start'] = self._io.pos()
+            self.marker = KaitaiStream.resolve_enum(Jpeg.Segment.MarkerEnum, self._io.read_u1())
+            self._debug['marker']['end'] = self._io.pos()
+            if  ((self.marker != Jpeg.Segment.MarkerEnum.soi) and (self.marker != Jpeg.Segment.MarkerEnum.eoi)) :
+                self._debug['length']['start'] = self._io.pos()
+                self.length = self._io.read_u2be()
+                self._debug['length']['end'] = self._io.pos()
+
+            if  ((self.marker != Jpeg.Segment.MarkerEnum.soi) and (self.marker != Jpeg.Segment.MarkerEnum.eoi)) :
+                self._debug['data']['start'] = self._io.pos()
+                _on = self.marker
+                if _on == Jpeg.Segment.MarkerEnum.app1:
+                    self._raw_data = self._io.read_bytes((self.length - 2))
+                    _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+                    self.data = Jpeg.SegmentApp1(_io__raw_data, self, self._root)
+                    self.data._read()
+                elif _on == Jpeg.Segment.MarkerEnum.app0:
+                    self._raw_data = self._io.read_bytes((self.length - 2))
+                    _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+                    self.data = Jpeg.SegmentApp0(_io__raw_data, self, self._root)
+                    self.data._read()
+                elif _on == Jpeg.Segment.MarkerEnum.sof0:
+                    self._raw_data = self._io.read_bytes((self.length - 2))
+                    _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+                    self.data = Jpeg.SegmentSof0(_io__raw_data, self, self._root)
+                    self.data._read()
+                elif _on == Jpeg.Segment.MarkerEnum.sos:
+                    self._raw_data = self._io.read_bytes((self.length - 2))
+                    _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+                    self.data = Jpeg.SegmentSos(_io__raw_data, self, self._root)
+                    self.data._read()
+                else:
+                    self.data = self._io.read_bytes((self.length - 2))
+                self._debug['data']['end'] = self._io.pos()
+
+            if self.marker == Jpeg.Segment.MarkerEnum.sos:
+                self._debug['image_data']['start'] = self._io.pos()
+                self.image_data = self._io.read_bytes_full()
+                self._debug['image_data']['end'] = self._io.pos()
+
+
+
+    class SegmentSos(KaitaiStruct):
+        SEQ_FIELDS = ["num_components", "components", "start_spectral_selection", "end_spectral", "appr_bit_pos"]
+        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['num_components']['start'] = self._io.pos()
+            self.num_components = self._io.read_u1()
+            self._debug['num_components']['end'] = self._io.pos()
+            self._debug['components']['start'] = self._io.pos()
+            self.components = [None] * (self.num_components)
+            for i in range(self.num_components):
+                if not 'arr' in self._debug['components']:
+                    self._debug['components']['arr'] = []
+                self._debug['components']['arr'].append({'start': self._io.pos()})
+                _t_components = Jpeg.SegmentSos.Component(self._io, self, self._root)
+                _t_components._read()
+                self.components[i] = _t_components
+                self._debug['components']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['components']['end'] = self._io.pos()
+            self._debug['start_spectral_selection']['start'] = self._io.pos()
+            self.start_spectral_selection = self._io.read_u1()
+            self._debug['start_spectral_selection']['end'] = self._io.pos()
+            self._debug['end_spectral']['start'] = self._io.pos()
+            self.end_spectral = self._io.read_u1()
+            self._debug['end_spectral']['end'] = self._io.pos()
+            self._debug['appr_bit_pos']['start'] = self._io.pos()
+            self.appr_bit_pos = self._io.read_u1()
+            self._debug['appr_bit_pos']['end'] = self._io.pos()
+
+        class Component(KaitaiStruct):
+            SEQ_FIELDS = ["id", "huffman_table"]
+            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 = KaitaiStream.resolve_enum(Jpeg.ComponentId, self._io.read_u1())
+                self._debug['id']['end'] = self._io.pos()
+                self._debug['huffman_table']['start'] = self._io.pos()
+                self.huffman_table = self._io.read_u1()
+                self._debug['huffman_table']['end'] = self._io.pos()
+
+
+
+    class SegmentApp1(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "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['magic']['start'] = self._io.pos()
+            self.magic = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
+            self._debug['magic']['end'] = self._io.pos()
+            self._debug['body']['start'] = self._io.pos()
+            _on = self.magic
+            if _on == u"Exif":
+                self.body = Jpeg.ExifInJpeg(self._io, self, self._root)
+                self.body._read()
+            self._debug['body']['end'] = self._io.pos()
+
+
+    class SegmentSof0(KaitaiStruct):
+        SEQ_FIELDS = ["bits_per_sample", "image_height", "image_width", "num_components", "components"]
+        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['bits_per_sample']['start'] = self._io.pos()
+            self.bits_per_sample = self._io.read_u1()
+            self._debug['bits_per_sample']['end'] = self._io.pos()
+            self._debug['image_height']['start'] = self._io.pos()
+            self.image_height = self._io.read_u2be()
+            self._debug['image_height']['end'] = self._io.pos()
+            self._debug['image_width']['start'] = self._io.pos()
+            self.image_width = self._io.read_u2be()
+            self._debug['image_width']['end'] = self._io.pos()
+            self._debug['num_components']['start'] = self._io.pos()
+            self.num_components = self._io.read_u1()
+            self._debug['num_components']['end'] = self._io.pos()
+            self._debug['components']['start'] = self._io.pos()
+            self.components = [None] * (self.num_components)
+            for i in range(self.num_components):
+                if not 'arr' in self._debug['components']:
+                    self._debug['components']['arr'] = []
+                self._debug['components']['arr'].append({'start': self._io.pos()})
+                _t_components = Jpeg.SegmentSof0.Component(self._io, self, self._root)
+                _t_components._read()
+                self.components[i] = _t_components
+                self._debug['components']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['components']['end'] = self._io.pos()
+
+        class Component(KaitaiStruct):
+            SEQ_FIELDS = ["id", "sampling_factors", "quantization_table_id"]
+            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 = KaitaiStream.resolve_enum(Jpeg.ComponentId, self._io.read_u1())
+                self._debug['id']['end'] = self._io.pos()
+                self._debug['sampling_factors']['start'] = self._io.pos()
+                self.sampling_factors = self._io.read_u1()
+                self._debug['sampling_factors']['end'] = self._io.pos()
+                self._debug['quantization_table_id']['start'] = self._io.pos()
+                self.quantization_table_id = self._io.read_u1()
+                self._debug['quantization_table_id']['end'] = self._io.pos()
+
+            @property
+            def sampling_x(self):
+                if hasattr(self, '_m_sampling_x'):
+                    return self._m_sampling_x if hasattr(self, '_m_sampling_x') else None
+
+                self._m_sampling_x = ((self.sampling_factors & 240) >> 4)
+                return self._m_sampling_x if hasattr(self, '_m_sampling_x') else None
+
+            @property
+            def sampling_y(self):
+                if hasattr(self, '_m_sampling_y'):
+                    return self._m_sampling_y if hasattr(self, '_m_sampling_y') else None
+
+                self._m_sampling_y = (self.sampling_factors & 15)
+                return self._m_sampling_y if hasattr(self, '_m_sampling_y') else None
+
+
+
+    class ExifInJpeg(KaitaiStruct):
+        SEQ_FIELDS = ["extra_zero", "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['extra_zero']['start'] = self._io.pos()
+            self.extra_zero = self._io.read_bytes(1)
+            self._debug['extra_zero']['end'] = self._io.pos()
+            if not self.extra_zero == b"\x00":
+                raise kaitaistruct.ValidationNotEqualError(b"\x00", self.extra_zero, self._io, u"/types/exif_in_jpeg/seq/0")
+            self._debug['data']['start'] = self._io.pos()
+            self._raw_data = self._io.read_bytes_full()
+            _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+            self.data = exif.Exif(_io__raw_data)
+            self.data._read()
+            self._debug['data']['end'] = self._io.pos()
+
+
+    class SegmentApp0(KaitaiStruct):
+
+        class DensityUnit(Enum):
+            no_units = 0
+            pixels_per_inch = 1
+            pixels_per_cm = 2
+        SEQ_FIELDS = ["magic", "version_major", "version_minor", "density_units", "density_x", "density_y", "thumbnail_x", "thumbnail_y", "thumbnail"]
+        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(5)).decode(u"ASCII")
+            self._debug['magic']['end'] = self._io.pos()
+            self._debug['version_major']['start'] = self._io.pos()
+            self.version_major = self._io.read_u1()
+            self._debug['version_major']['end'] = self._io.pos()
+            self._debug['version_minor']['start'] = self._io.pos()
+            self.version_minor = self._io.read_u1()
+            self._debug['version_minor']['end'] = self._io.pos()
+            self._debug['density_units']['start'] = self._io.pos()
+            self.density_units = KaitaiStream.resolve_enum(Jpeg.SegmentApp0.DensityUnit, self._io.read_u1())
+            self._debug['density_units']['end'] = self._io.pos()
+            self._debug['density_x']['start'] = self._io.pos()
+            self.density_x = self._io.read_u2be()
+            self._debug['density_x']['end'] = self._io.pos()
+            self._debug['density_y']['start'] = self._io.pos()
+            self.density_y = self._io.read_u2be()
+            self._debug['density_y']['end'] = self._io.pos()
+            self._debug['thumbnail_x']['start'] = self._io.pos()
+            self.thumbnail_x = self._io.read_u1()
+            self._debug['thumbnail_x']['end'] = self._io.pos()
+            self._debug['thumbnail_y']['start'] = self._io.pos()
+            self.thumbnail_y = self._io.read_u1()
+            self._debug['thumbnail_y']['end'] = self._io.pos()
+            self._debug['thumbnail']['start'] = self._io.pos()
+            self.thumbnail = self._io.read_bytes(((self.thumbnail_x * self.thumbnail_y) * 3))
+            self._debug['thumbnail']['end'] = self._io.pos()
+
+
+

polyfile/kaitai/parsers/luks.py

@@ -0,0 +1,149 @@
+# 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__))
+
+class Luks(KaitaiStruct):
+    """Linux Unified Key Setup (LUKS) is a format specification for storing disk
+    encryption parameters and up to 8 user keys (which can unlock the master key).
+    
+    .. seealso::
+       Source - https://gitlab.com/cryptsetup/cryptsetup/-/wikis/LUKS-standard/on-disk-format.pdf
+    """
+    SEQ_FIELDS = ["partition_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['partition_header']['start'] = self._io.pos()
+        self.partition_header = Luks.PartitionHeader(self._io, self, self._root)
+        self.partition_header._read()
+        self._debug['partition_header']['end'] = self._io.pos()
+
+    class PartitionHeader(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "version", "cipher_name_specification", "cipher_mode_specification", "hash_specification", "payload_offset", "number_of_key_bytes", "master_key_checksum", "master_key_salt_parameter", "master_key_iterations_parameter", "uuid", "key_slots"]
+        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(6)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x4C\x55\x4B\x53\xBA\xBE":
+                raise kaitaistruct.ValidationNotEqualError(b"\x4C\x55\x4B\x53\xBA\xBE", self.magic, self._io, u"/types/partition_header/seq/0")
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.read_bytes(2)
+            self._debug['version']['end'] = self._io.pos()
+            if not self.version == b"\x00\x01":
+                raise kaitaistruct.ValidationNotEqualError(b"\x00\x01", self.version, self._io, u"/types/partition_header/seq/1")
+            self._debug['cipher_name_specification']['start'] = self._io.pos()
+            self.cipher_name_specification = (self._io.read_bytes(32)).decode(u"ASCII")
+            self._debug['cipher_name_specification']['end'] = self._io.pos()
+            self._debug['cipher_mode_specification']['start'] = self._io.pos()
+            self.cipher_mode_specification = (self._io.read_bytes(32)).decode(u"ASCII")
+            self._debug['cipher_mode_specification']['end'] = self._io.pos()
+            self._debug['hash_specification']['start'] = self._io.pos()
+            self.hash_specification = (self._io.read_bytes(32)).decode(u"ASCII")
+            self._debug['hash_specification']['end'] = self._io.pos()
+            self._debug['payload_offset']['start'] = self._io.pos()
+            self.payload_offset = self._io.read_u4be()
+            self._debug['payload_offset']['end'] = self._io.pos()
+            self._debug['number_of_key_bytes']['start'] = self._io.pos()
+            self.number_of_key_bytes = self._io.read_u4be()
+            self._debug['number_of_key_bytes']['end'] = self._io.pos()
+            self._debug['master_key_checksum']['start'] = self._io.pos()
+            self.master_key_checksum = self._io.read_bytes(20)
+            self._debug['master_key_checksum']['end'] = self._io.pos()
+            self._debug['master_key_salt_parameter']['start'] = self._io.pos()
+            self.master_key_salt_parameter = self._io.read_bytes(32)
+            self._debug['master_key_salt_parameter']['end'] = self._io.pos()
+            self._debug['master_key_iterations_parameter']['start'] = self._io.pos()
+            self.master_key_iterations_parameter = self._io.read_u4be()
+            self._debug['master_key_iterations_parameter']['end'] = self._io.pos()
+            self._debug['uuid']['start'] = self._io.pos()
+            self.uuid = (self._io.read_bytes(40)).decode(u"ASCII")
+            self._debug['uuid']['end'] = self._io.pos()
+            self._debug['key_slots']['start'] = self._io.pos()
+            self.key_slots = [None] * (8)
+            for i in range(8):
+                if not 'arr' in self._debug['key_slots']:
+                    self._debug['key_slots']['arr'] = []
+                self._debug['key_slots']['arr'].append({'start': self._io.pos()})
+                _t_key_slots = Luks.PartitionHeader.KeySlot(self._io, self, self._root)
+                _t_key_slots._read()
+                self.key_slots[i] = _t_key_slots
+                self._debug['key_slots']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['key_slots']['end'] = self._io.pos()
+
+        class KeySlot(KaitaiStruct):
+
+            class KeySlotStates(Enum):
+                disabled_key_slot = 57005
+                enabled_key_slot = 11301363
+            SEQ_FIELDS = ["state_of_key_slot", "iteration_parameter", "salt_parameter", "start_sector_of_key_material", "number_of_anti_forensic_stripes"]
+            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['state_of_key_slot']['start'] = self._io.pos()
+                self.state_of_key_slot = KaitaiStream.resolve_enum(Luks.PartitionHeader.KeySlot.KeySlotStates, self._io.read_u4be())
+                self._debug['state_of_key_slot']['end'] = self._io.pos()
+                self._debug['iteration_parameter']['start'] = self._io.pos()
+                self.iteration_parameter = self._io.read_u4be()
+                self._debug['iteration_parameter']['end'] = self._io.pos()
+                self._debug['salt_parameter']['start'] = self._io.pos()
+                self.salt_parameter = self._io.read_bytes(32)
+                self._debug['salt_parameter']['end'] = self._io.pos()
+                self._debug['start_sector_of_key_material']['start'] = self._io.pos()
+                self.start_sector_of_key_material = self._io.read_u4be()
+                self._debug['start_sector_of_key_material']['end'] = self._io.pos()
+                self._debug['number_of_anti_forensic_stripes']['start'] = self._io.pos()
+                self.number_of_anti_forensic_stripes = self._io.read_u4be()
+                self._debug['number_of_anti_forensic_stripes']['end'] = self._io.pos()
+
+            @property
+            def key_material(self):
+                if hasattr(self, '_m_key_material'):
+                    return self._m_key_material if hasattr(self, '_m_key_material') else None
+
+                _pos = self._io.pos()
+                self._io.seek((self.start_sector_of_key_material * 512))
+                self._debug['_m_key_material']['start'] = self._io.pos()
+                self._m_key_material = self._io.read_bytes((self._parent.number_of_key_bytes * self.number_of_anti_forensic_stripes))
+                self._debug['_m_key_material']['end'] = self._io.pos()
+                self._io.seek(_pos)
+                return self._m_key_material if hasattr(self, '_m_key_material') else None
+
+
+
+    @property
+    def payload(self):
+        if hasattr(self, '_m_payload'):
+            return self._m_payload if hasattr(self, '_m_payload') else None
+
+        _pos = self._io.pos()
+        self._io.seek((self.partition_header.payload_offset * 512))
+        self._debug['_m_payload']['start'] = self._io.pos()
+        self._m_payload = self._io.read_bytes_full()
+        self._debug['_m_payload']['end'] = self._io.pos()
+        self._io.seek(_pos)
+        return self._m_payload if hasattr(self, '_m_payload') else None
+
+

polyfile/kaitai/parsers/lzh.py

@@ -0,0 +1,165 @@
+# 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__))
+
+from polyfile.kaitai.parsers import dos_datetime
+class Lzh(KaitaiStruct):
+    """LHA (LHarc, LZH) is a file format used by a popular freeware
+    eponymous archiver, created in 1988 by Haruyasu Yoshizaki. Over the
+    years, many ports and implementations were developed, sporting many
+    extensions to original 1988 LZH.
+    
+    File format is pretty simple and essentially consists of a stream of
+    records.
+    """
+    SEQ_FIELDS = ["entries"]
+    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['entries']['start'] = self._io.pos()
+        self.entries = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['entries']:
+                self._debug['entries']['arr'] = []
+            self._debug['entries']['arr'].append({'start': self._io.pos()})
+            _t_entries = Lzh.Record(self._io, self, self._root)
+            _t_entries._read()
+            self.entries.append(_t_entries)
+            self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['entries']['end'] = self._io.pos()
+
+    class Record(KaitaiStruct):
+        SEQ_FIELDS = ["header_len", "file_record"]
+        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_len']['start'] = self._io.pos()
+            self.header_len = self._io.read_u1()
+            self._debug['header_len']['end'] = self._io.pos()
+            if self.header_len > 0:
+                self._debug['file_record']['start'] = self._io.pos()
+                self.file_record = Lzh.FileRecord(self._io, self, self._root)
+                self.file_record._read()
+                self._debug['file_record']['end'] = self._io.pos()
+
+
+
+    class FileRecord(KaitaiStruct):
+        SEQ_FIELDS = ["header", "file_uncompr_crc16", "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['header']['start'] = self._io.pos()
+            self._raw_header = self._io.read_bytes((self._parent.header_len - 1))
+            _io__raw_header = KaitaiStream(BytesIO(self._raw_header))
+            self.header = Lzh.Header(_io__raw_header, self, self._root)
+            self.header._read()
+            self._debug['header']['end'] = self._io.pos()
+            if self.header.header1.lha_level == 0:
+                self._debug['file_uncompr_crc16']['start'] = self._io.pos()
+                self.file_uncompr_crc16 = self._io.read_u2le()
+                self._debug['file_uncompr_crc16']['end'] = self._io.pos()
+
+            self._debug['body']['start'] = self._io.pos()
+            self.body = self._io.read_bytes(self.header.header1.file_size_compr)
+            self._debug['body']['end'] = self._io.pos()
+
+
+    class Header(KaitaiStruct):
+        SEQ_FIELDS = ["header1", "filename_len", "filename", "file_uncompr_crc16", "os", "ext_header_size"]
+        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['header1']['start'] = self._io.pos()
+            self.header1 = Lzh.Header1(self._io, self, self._root)
+            self.header1._read()
+            self._debug['header1']['end'] = self._io.pos()
+            if self.header1.lha_level == 0:
+                self._debug['filename_len']['start'] = self._io.pos()
+                self.filename_len = self._io.read_u1()
+                self._debug['filename_len']['end'] = self._io.pos()
+
+            if self.header1.lha_level == 0:
+                self._debug['filename']['start'] = self._io.pos()
+                self.filename = (self._io.read_bytes(self.filename_len)).decode(u"ASCII")
+                self._debug['filename']['end'] = self._io.pos()
+
+            if self.header1.lha_level == 2:
+                self._debug['file_uncompr_crc16']['start'] = self._io.pos()
+                self.file_uncompr_crc16 = self._io.read_u2le()
+                self._debug['file_uncompr_crc16']['end'] = self._io.pos()
+
+            if self.header1.lha_level == 2:
+                self._debug['os']['start'] = self._io.pos()
+                self.os = self._io.read_u1()
+                self._debug['os']['end'] = self._io.pos()
+
+            if self.header1.lha_level == 2:
+                self._debug['ext_header_size']['start'] = self._io.pos()
+                self.ext_header_size = self._io.read_u2le()
+                self._debug['ext_header_size']['end'] = self._io.pos()
+
+
+
+    class Header1(KaitaiStruct):
+        SEQ_FIELDS = ["header_checksum", "method_id", "file_size_compr", "file_size_uncompr", "file_timestamp", "attr", "lha_level"]
+        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_checksum']['start'] = self._io.pos()
+            self.header_checksum = self._io.read_u1()
+            self._debug['header_checksum']['end'] = self._io.pos()
+            self._debug['method_id']['start'] = self._io.pos()
+            self.method_id = (self._io.read_bytes(5)).decode(u"ASCII")
+            self._debug['method_id']['end'] = self._io.pos()
+            self._debug['file_size_compr']['start'] = self._io.pos()
+            self.file_size_compr = self._io.read_u4le()
+            self._debug['file_size_compr']['end'] = self._io.pos()
+            self._debug['file_size_uncompr']['start'] = self._io.pos()
+            self.file_size_uncompr = self._io.read_u4le()
+            self._debug['file_size_uncompr']['end'] = self._io.pos()
+            self._debug['file_timestamp']['start'] = self._io.pos()
+            self._raw_file_timestamp = self._io.read_bytes(4)
+            _io__raw_file_timestamp = KaitaiStream(BytesIO(self._raw_file_timestamp))
+            self.file_timestamp = dos_datetime.DosDatetime(_io__raw_file_timestamp)
+            self.file_timestamp._read()
+            self._debug['file_timestamp']['end'] = self._io.pos()
+            self._debug['attr']['start'] = self._io.pos()
+            self.attr = self._io.read_u1()
+            self._debug['attr']['end'] = self._io.pos()
+            self._debug['lha_level']['start'] = self._io.pos()
+            self.lha_level = self._io.read_u1()
+            self._debug['lha_level']['end'] = self._io.pos()
+
+
+