polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/creative_voice_file.py

@@ -0,0 +1,342 @@
+# 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 CreativeVoiceFile(KaitaiStruct):
+    """Creative Voice File is a container file format for digital audio
+    wave data. Initial revisions were able to support only unsigned
+    8-bit PCM and ADPCM data, later versions were revised to add support
+    for 16-bit PCM and a-law / u-law formats.
+    
+    This format was actively used in 1990s, around the advent of
+    Creative's sound cards (Sound Blaster family). It was a popular
+    choice for a digital sound container in lots of games and multimedia
+    software due to simplicity and availability of Creative's recording
+    / editing tools.
+    
+    .. seealso::
+       Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice
+    """
+
+    class BlockTypes(Enum):
+        terminator = 0
+        sound_data = 1
+        sound_data_cont = 2
+        silence = 3
+        marker = 4
+        text = 5
+        repeat_start = 6
+        repeat_end = 7
+        extra_info = 8
+        sound_data_new = 9
+
+    class Codecs(Enum):
+        pcm_8bit_unsigned = 0
+        adpcm_4bit = 1
+        adpcm_2_6bit = 2
+        adpcm_2_bit = 3
+        pcm_16bit_signed = 4
+        alaw = 6
+        ulaw = 7
+        adpcm_4_to_16bit = 512
+    SEQ_FIELDS = ["magic", "header_size", "version", "checksum", "blocks"]
+    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(20)
+        self._debug['magic']['end'] = self._io.pos()
+        if not self.magic == b"\x43\x72\x65\x61\x74\x69\x76\x65\x20\x56\x6F\x69\x63\x65\x20\x46\x69\x6C\x65\x1A":
+            raise kaitaistruct.ValidationNotEqualError(b"\x43\x72\x65\x61\x74\x69\x76\x65\x20\x56\x6F\x69\x63\x65\x20\x46\x69\x6C\x65\x1A", self.magic, self._io, u"/seq/0")
+        self._debug['header_size']['start'] = self._io.pos()
+        self.header_size = self._io.read_u2le()
+        self._debug['header_size']['end'] = self._io.pos()
+        self._debug['version']['start'] = self._io.pos()
+        self.version = self._io.read_u2le()
+        self._debug['version']['end'] = self._io.pos()
+        self._debug['checksum']['start'] = self._io.pos()
+        self.checksum = self._io.read_u2le()
+        self._debug['checksum']['end'] = self._io.pos()
+        self._debug['blocks']['start'] = self._io.pos()
+        self.blocks = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['blocks']:
+                self._debug['blocks']['arr'] = []
+            self._debug['blocks']['arr'].append({'start': self._io.pos()})
+            _t_blocks = CreativeVoiceFile.Block(self._io, self, self._root)
+            _t_blocks._read()
+            self.blocks.append(_t_blocks)
+            self._debug['blocks']['arr'][len(self.blocks) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['blocks']['end'] = self._io.pos()
+
+    class BlockMarker(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x04:_Marker
+        """
+        SEQ_FIELDS = ["marker_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['marker_id']['start'] = self._io.pos()
+            self.marker_id = self._io.read_u2le()
+            self._debug['marker_id']['end'] = self._io.pos()
+
+
+    class BlockSilence(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x03:_Silence
+        """
+        SEQ_FIELDS = ["duration_samples", "freq_div"]
+        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['duration_samples']['start'] = self._io.pos()
+            self.duration_samples = self._io.read_u2le()
+            self._debug['duration_samples']['end'] = self._io.pos()
+            self._debug['freq_div']['start'] = self._io.pos()
+            self.freq_div = self._io.read_u1()
+            self._debug['freq_div']['end'] = self._io.pos()
+
+        @property
+        def sample_rate(self):
+            if hasattr(self, '_m_sample_rate'):
+                return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+            self._m_sample_rate = (1000000.0 / (256 - self.freq_div))
+            return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+        @property
+        def duration_sec(self):
+            """Duration of silence, in seconds."""
+            if hasattr(self, '_m_duration_sec'):
+                return self._m_duration_sec if hasattr(self, '_m_duration_sec') else None
+
+            self._m_duration_sec = (self.duration_samples / self.sample_rate)
+            return self._m_duration_sec if hasattr(self, '_m_duration_sec') else None
+
+
+    class BlockSoundDataNew(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x09:_Sound_data_.28New_format.29
+        """
+        SEQ_FIELDS = ["sample_rate", "bits_per_sample", "num_channels", "codec", "reserved", "wave"]
+        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['sample_rate']['start'] = self._io.pos()
+            self.sample_rate = self._io.read_u4le()
+            self._debug['sample_rate']['end'] = self._io.pos()
+            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['num_channels']['start'] = self._io.pos()
+            self.num_channels = self._io.read_u1()
+            self._debug['num_channels']['end'] = self._io.pos()
+            self._debug['codec']['start'] = self._io.pos()
+            self.codec = KaitaiStream.resolve_enum(CreativeVoiceFile.Codecs, self._io.read_u2le())
+            self._debug['codec']['end'] = self._io.pos()
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_bytes(4)
+            self._debug['reserved']['end'] = self._io.pos()
+            self._debug['wave']['start'] = self._io.pos()
+            self.wave = self._io.read_bytes_full()
+            self._debug['wave']['end'] = self._io.pos()
+
+
+    class Block(KaitaiStruct):
+        SEQ_FIELDS = ["block_type", "body_size1", "body_size2", "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['block_type']['start'] = self._io.pos()
+            self.block_type = KaitaiStream.resolve_enum(CreativeVoiceFile.BlockTypes, self._io.read_u1())
+            self._debug['block_type']['end'] = self._io.pos()
+            if self.block_type != CreativeVoiceFile.BlockTypes.terminator:
+                self._debug['body_size1']['start'] = self._io.pos()
+                self.body_size1 = self._io.read_u2le()
+                self._debug['body_size1']['end'] = self._io.pos()
+
+            if self.block_type != CreativeVoiceFile.BlockTypes.terminator:
+                self._debug['body_size2']['start'] = self._io.pos()
+                self.body_size2 = self._io.read_u1()
+                self._debug['body_size2']['end'] = self._io.pos()
+
+            if self.block_type != CreativeVoiceFile.BlockTypes.terminator:
+                self._debug['body']['start'] = self._io.pos()
+                _on = self.block_type
+                if _on == CreativeVoiceFile.BlockTypes.sound_data_new:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = CreativeVoiceFile.BlockSoundDataNew(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == CreativeVoiceFile.BlockTypes.repeat_start:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = CreativeVoiceFile.BlockRepeatStart(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == CreativeVoiceFile.BlockTypes.marker:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = CreativeVoiceFile.BlockMarker(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == CreativeVoiceFile.BlockTypes.sound_data:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = CreativeVoiceFile.BlockSoundData(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == CreativeVoiceFile.BlockTypes.extra_info:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = CreativeVoiceFile.BlockExtraInfo(_io__raw_body, self, self._root)
+                    self.body._read()
+                elif _on == CreativeVoiceFile.BlockTypes.silence:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    _io__raw_body = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = CreativeVoiceFile.BlockSilence(_io__raw_body, self, self._root)
+                    self.body._read()
+                else:
+                    self.body = self._io.read_bytes(self.body_size)
+                self._debug['body']['end'] = self._io.pos()
+
+
+        @property
+        def body_size(self):
+            """body_size is a 24-bit little-endian integer, so we're
+            emulating that by adding two standard-sized integers
+            (body_size1 and body_size2).
+            """
+            if hasattr(self, '_m_body_size'):
+                return self._m_body_size if hasattr(self, '_m_body_size') else None
+
+            if self.block_type != CreativeVoiceFile.BlockTypes.terminator:
+                self._m_body_size = (self.body_size1 + (self.body_size2 << 16))
+
+            return self._m_body_size if hasattr(self, '_m_body_size') else None
+
+
+    class BlockRepeatStart(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x06:_Repeat_start
+        """
+        SEQ_FIELDS = ["repeat_count_1"]
+        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['repeat_count_1']['start'] = self._io.pos()
+            self.repeat_count_1 = self._io.read_u2le()
+            self._debug['repeat_count_1']['end'] = self._io.pos()
+
+
+    class BlockSoundData(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x01:_Sound_data
+        """
+        SEQ_FIELDS = ["freq_div", "codec", "wave"]
+        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['freq_div']['start'] = self._io.pos()
+            self.freq_div = self._io.read_u1()
+            self._debug['freq_div']['end'] = self._io.pos()
+            self._debug['codec']['start'] = self._io.pos()
+            self.codec = KaitaiStream.resolve_enum(CreativeVoiceFile.Codecs, self._io.read_u1())
+            self._debug['codec']['end'] = self._io.pos()
+            self._debug['wave']['start'] = self._io.pos()
+            self.wave = self._io.read_bytes_full()
+            self._debug['wave']['end'] = self._io.pos()
+
+        @property
+        def sample_rate(self):
+            if hasattr(self, '_m_sample_rate'):
+                return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+            self._m_sample_rate = (1000000.0 / (256 - self.freq_div))
+            return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+
+    class BlockExtraInfo(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x08:_Extra_info
+        """
+        SEQ_FIELDS = ["freq_div", "codec", "num_channels_1"]
+        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['freq_div']['start'] = self._io.pos()
+            self.freq_div = self._io.read_u2le()
+            self._debug['freq_div']['end'] = self._io.pos()
+            self._debug['codec']['start'] = self._io.pos()
+            self.codec = KaitaiStream.resolve_enum(CreativeVoiceFile.Codecs, self._io.read_u1())
+            self._debug['codec']['end'] = self._io.pos()
+            self._debug['num_channels_1']['start'] = self._io.pos()
+            self.num_channels_1 = self._io.read_u1()
+            self._debug['num_channels_1']['end'] = self._io.pos()
+
+        @property
+        def num_channels(self):
+            """Number of channels (1 = mono, 2 = stereo)."""
+            if hasattr(self, '_m_num_channels'):
+                return self._m_num_channels if hasattr(self, '_m_num_channels') else None
+
+            self._m_num_channels = (self.num_channels_1 + 1)
+            return self._m_num_channels if hasattr(self, '_m_num_channels') else None
+
+        @property
+        def sample_rate(self):
+            if hasattr(self, '_m_sample_rate'):
+                return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+            self._m_sample_rate = (256000000.0 / (self.num_channels * (65536 - self.freq_div)))
+            return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+
+

polyfile/kaitai/parsers/dbf.py

@@ -0,0 +1,274 @@
+# 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 Dbf(KaitaiStruct):
+    """.dbf is a relational database format introduced in DOS database
+    management system dBASE in 1982.
+    
+    One .dbf file corresponds to one table and contains a series of headers,
+    specification of fields, and a number of fixed-size records.
+    
+    .. seealso::
+       Source - http://www.dbase.com/Knowledgebase/INT/db7_file_fmt.htm
+    """
+
+    class DeleteState(Enum):
+        false = 32
+        true = 42
+    SEQ_FIELDS = ["header1", "header2", "header_terminator", "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['header1']['start'] = self._io.pos()
+        self.header1 = Dbf.Header1(self._io, self, self._root)
+        self.header1._read()
+        self._debug['header1']['end'] = self._io.pos()
+        self._debug['header2']['start'] = self._io.pos()
+        self._raw_header2 = self._io.read_bytes(((self.header1.len_header - 12) - 1))
+        _io__raw_header2 = KaitaiStream(BytesIO(self._raw_header2))
+        self.header2 = Dbf.Header2(_io__raw_header2, self, self._root)
+        self.header2._read()
+        self._debug['header2']['end'] = self._io.pos()
+        self._debug['header_terminator']['start'] = self._io.pos()
+        self.header_terminator = self._io.read_bytes(1)
+        self._debug['header_terminator']['end'] = self._io.pos()
+        if not self.header_terminator == b"\x0D":
+            raise kaitaistruct.ValidationNotEqualError(b"\x0D", self.header_terminator, self._io, u"/seq/2")
+        self._debug['records']['start'] = self._io.pos()
+        self._raw_records = [None] * (self.header1.num_records)
+        self.records = [None] * (self.header1.num_records)
+        for i in range(self.header1.num_records):
+            if not 'arr' in self._debug['records']:
+                self._debug['records']['arr'] = []
+            self._debug['records']['arr'].append({'start': self._io.pos()})
+            self._raw_records[i] = self._io.read_bytes(self.header1.len_record)
+            _io__raw_records = KaitaiStream(BytesIO(self._raw_records[i]))
+            _t_records = Dbf.Record(_io__raw_records, self, self._root)
+            _t_records._read()
+            self.records[i] = _t_records
+            self._debug['records']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['records']['end'] = self._io.pos()
+
+    class Header2(KaitaiStruct):
+        SEQ_FIELDS = ["header_dbase_3", "header_dbase_7", "fields"]
+        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):
+            if self._root.header1.dbase_level == 3:
+                self._debug['header_dbase_3']['start'] = self._io.pos()
+                self.header_dbase_3 = Dbf.HeaderDbase3(self._io, self, self._root)
+                self.header_dbase_3._read()
+                self._debug['header_dbase_3']['end'] = self._io.pos()
+
+            if self._root.header1.dbase_level == 7:
+                self._debug['header_dbase_7']['start'] = self._io.pos()
+                self.header_dbase_7 = Dbf.HeaderDbase7(self._io, self, self._root)
+                self.header_dbase_7._read()
+                self._debug['header_dbase_7']['end'] = self._io.pos()
+
+            self._debug['fields']['start'] = self._io.pos()
+            self.fields = []
+            i = 0
+            while not self._io.is_eof():
+                if not 'arr' in self._debug['fields']:
+                    self._debug['fields']['arr'] = []
+                self._debug['fields']['arr'].append({'start': self._io.pos()})
+                _t_fields = Dbf.Field(self._io, self, self._root)
+                _t_fields._read()
+                self.fields.append(_t_fields)
+                self._debug['fields']['arr'][len(self.fields) - 1]['end'] = self._io.pos()
+                i += 1
+
+            self._debug['fields']['end'] = self._io.pos()
+
+
+    class Field(KaitaiStruct):
+        SEQ_FIELDS = ["name", "datatype", "data_address", "length", "decimal_count", "reserved1", "work_area_id", "reserved2", "set_fields_flag", "reserved3"]
+        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['name']['start'] = self._io.pos()
+            self.name = (KaitaiStream.bytes_terminate(self._io.read_bytes(11), 0, False)).decode(u"ASCII")
+            self._debug['name']['end'] = self._io.pos()
+            self._debug['datatype']['start'] = self._io.pos()
+            self.datatype = self._io.read_u1()
+            self._debug['datatype']['end'] = self._io.pos()
+            self._debug['data_address']['start'] = self._io.pos()
+            self.data_address = self._io.read_u4le()
+            self._debug['data_address']['end'] = self._io.pos()
+            self._debug['length']['start'] = self._io.pos()
+            self.length = self._io.read_u1()
+            self._debug['length']['end'] = self._io.pos()
+            self._debug['decimal_count']['start'] = self._io.pos()
+            self.decimal_count = self._io.read_u1()
+            self._debug['decimal_count']['end'] = self._io.pos()
+            self._debug['reserved1']['start'] = self._io.pos()
+            self.reserved1 = self._io.read_bytes(2)
+            self._debug['reserved1']['end'] = self._io.pos()
+            self._debug['work_area_id']['start'] = self._io.pos()
+            self.work_area_id = self._io.read_u1()
+            self._debug['work_area_id']['end'] = self._io.pos()
+            self._debug['reserved2']['start'] = self._io.pos()
+            self.reserved2 = self._io.read_bytes(2)
+            self._debug['reserved2']['end'] = self._io.pos()
+            self._debug['set_fields_flag']['start'] = self._io.pos()
+            self.set_fields_flag = self._io.read_u1()
+            self._debug['set_fields_flag']['end'] = self._io.pos()
+            self._debug['reserved3']['start'] = self._io.pos()
+            self.reserved3 = self._io.read_bytes(8)
+            self._debug['reserved3']['end'] = self._io.pos()
+
+
+    class Header1(KaitaiStruct):
+        """
+        .. seealso::
+           - section 1.1 - http://www.dbase.com/Knowledgebase/INT/db7_file_fmt.htm
+        """
+        SEQ_FIELDS = ["version", "last_update_y", "last_update_m", "last_update_d", "num_records", "len_header", "len_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['version']['start'] = self._io.pos()
+            self.version = self._io.read_u1()
+            self._debug['version']['end'] = self._io.pos()
+            self._debug['last_update_y']['start'] = self._io.pos()
+            self.last_update_y = self._io.read_u1()
+            self._debug['last_update_y']['end'] = self._io.pos()
+            self._debug['last_update_m']['start'] = self._io.pos()
+            self.last_update_m = self._io.read_u1()
+            self._debug['last_update_m']['end'] = self._io.pos()
+            self._debug['last_update_d']['start'] = self._io.pos()
+            self.last_update_d = self._io.read_u1()
+            self._debug['last_update_d']['end'] = self._io.pos()
+            self._debug['num_records']['start'] = self._io.pos()
+            self.num_records = self._io.read_u4le()
+            self._debug['num_records']['end'] = self._io.pos()
+            self._debug['len_header']['start'] = self._io.pos()
+            self.len_header = self._io.read_u2le()
+            self._debug['len_header']['end'] = self._io.pos()
+            self._debug['len_record']['start'] = self._io.pos()
+            self.len_record = self._io.read_u2le()
+            self._debug['len_record']['end'] = self._io.pos()
+
+        @property
+        def dbase_level(self):
+            if hasattr(self, '_m_dbase_level'):
+                return self._m_dbase_level if hasattr(self, '_m_dbase_level') else None
+
+            self._m_dbase_level = (self.version & 7)
+            return self._m_dbase_level if hasattr(self, '_m_dbase_level') else None
+
+
+    class HeaderDbase3(KaitaiStruct):
+        SEQ_FIELDS = ["reserved1", "reserved2", "reserved3"]
+        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['reserved1']['start'] = self._io.pos()
+            self.reserved1 = self._io.read_bytes(3)
+            self._debug['reserved1']['end'] = self._io.pos()
+            self._debug['reserved2']['start'] = self._io.pos()
+            self.reserved2 = self._io.read_bytes(13)
+            self._debug['reserved2']['end'] = self._io.pos()
+            self._debug['reserved3']['start'] = self._io.pos()
+            self.reserved3 = self._io.read_bytes(4)
+            self._debug['reserved3']['end'] = self._io.pos()
+
+
+    class HeaderDbase7(KaitaiStruct):
+        SEQ_FIELDS = ["reserved1", "has_incomplete_transaction", "dbase_iv_encryption", "reserved2", "production_mdx", "language_driver_id", "reserved3", "language_driver_name", "reserved4"]
+        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['reserved1']['start'] = self._io.pos()
+            self.reserved1 = self._io.read_bytes(2)
+            self._debug['reserved1']['end'] = self._io.pos()
+            if not self.reserved1 == b"\x00\x00":
+                raise kaitaistruct.ValidationNotEqualError(b"\x00\x00", self.reserved1, self._io, u"/types/header_dbase_7/seq/0")
+            self._debug['has_incomplete_transaction']['start'] = self._io.pos()
+            self.has_incomplete_transaction = self._io.read_u1()
+            self._debug['has_incomplete_transaction']['end'] = self._io.pos()
+            self._debug['dbase_iv_encryption']['start'] = self._io.pos()
+            self.dbase_iv_encryption = self._io.read_u1()
+            self._debug['dbase_iv_encryption']['end'] = self._io.pos()
+            self._debug['reserved2']['start'] = self._io.pos()
+            self.reserved2 = self._io.read_bytes(12)
+            self._debug['reserved2']['end'] = self._io.pos()
+            self._debug['production_mdx']['start'] = self._io.pos()
+            self.production_mdx = self._io.read_u1()
+            self._debug['production_mdx']['end'] = self._io.pos()
+            self._debug['language_driver_id']['start'] = self._io.pos()
+            self.language_driver_id = self._io.read_u1()
+            self._debug['language_driver_id']['end'] = self._io.pos()
+            self._debug['reserved3']['start'] = self._io.pos()
+            self.reserved3 = self._io.read_bytes(2)
+            self._debug['reserved3']['end'] = self._io.pos()
+            if not self.reserved3 == b"\x00\x00":
+                raise kaitaistruct.ValidationNotEqualError(b"\x00\x00", self.reserved3, self._io, u"/types/header_dbase_7/seq/6")
+            self._debug['language_driver_name']['start'] = self._io.pos()
+            self.language_driver_name = self._io.read_bytes(32)
+            self._debug['language_driver_name']['end'] = self._io.pos()
+            self._debug['reserved4']['start'] = self._io.pos()
+            self.reserved4 = self._io.read_bytes(4)
+            self._debug['reserved4']['end'] = self._io.pos()
+
+
+    class Record(KaitaiStruct):
+        SEQ_FIELDS = ["deleted", "record_fields"]
+        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['deleted']['start'] = self._io.pos()
+            self.deleted = KaitaiStream.resolve_enum(Dbf.DeleteState, self._io.read_u1())
+            self._debug['deleted']['end'] = self._io.pos()
+            self._debug['record_fields']['start'] = self._io.pos()
+            self.record_fields = [None] * (len(self._root.header2.fields))
+            for i in range(len(self._root.header2.fields)):
+                if not 'arr' in self._debug['record_fields']:
+                    self._debug['record_fields']['arr'] = []
+                self._debug['record_fields']['arr'].append({'start': self._io.pos()})
+                self.record_fields[i] = self._io.read_bytes(self._root.header2.fields[i].length)
+                self._debug['record_fields']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['record_fields']['end'] = self._io.pos()
+
+
+