polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/au.py

@@ -0,0 +1,138 @@
+# 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 Au(KaitaiStruct):
+    """The NeXT/Sun audio file format.
+    
+    Sample files:
+    
+    * <https://github.com/python/cpython/tree/b8a7daf077da/Lib/test/sndhdrdata>
+    * <ftp://ftp-ccrma.stanford.edu/pub/Lisp/sf.tar.gz>
+    * <https://www.mmsp.ece.mcgill.ca/Documents/AudioFormats/AU/Samples.html>
+    
+    .. seealso::
+       Source - https://www.mmsp.ece.mcgill.ca/Documents/AudioFormats/AU/AU.html
+    
+    
+    .. seealso::
+       Source - http://soundfile.sapp.org/doc/NextFormat/
+    
+    
+    .. seealso::
+       Source - http://soundfile.sapp.org/doc/NextFormat/soundstruct.h
+    
+    
+    .. seealso::
+       Source - https://github.com/andreiw/polaris/blob/deb47cb/usr/src/head/audio/au.h#L87-L112
+    
+    
+    .. seealso::
+       Source - https://github.com/libsndfile/libsndfile/blob/86c9f9eb/src/au.c#L39-L74
+    
+    
+    .. seealso::
+       Source - https://github.com/chirlu/sox/blob/dd8b63bd/src/au.c#L34-L49
+    
+    
+    .. seealso::
+       Source - https://github.com/mpruett/audiofile/blob/b62c902/libaudiofile/NeXT.cpp#L65-L96
+    """
+
+    class Encodings(Enum):
+        mulaw_8 = 1
+        linear_8 = 2
+        linear_16 = 3
+        linear_24 = 4
+        linear_32 = 5
+        float = 6
+        double = 7
+        fragmented = 8
+        nested = 9
+        dsp_core = 10
+        fixed_point_8 = 11
+        fixed_point_16 = 12
+        fixed_point_24 = 13
+        fixed_point_32 = 14
+        display = 16
+        mulaw_squelch = 17
+        emphasized = 18
+        compressed = 19
+        compressed_emphasized = 20
+        dsp_commands = 21
+        dsp_commands_samples = 22
+        adpcm_g721 = 23
+        adpcm_g722 = 24
+        adpcm_g723_3 = 25
+        adpcm_g723_5 = 26
+        alaw_8 = 27
+        aes = 28
+        delta_mulaw_8 = 29
+    SEQ_FIELDS = ["magic", "ofs_data", "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['magic']['start'] = self._io.pos()
+        self.magic = self._io.read_bytes(4)
+        self._debug['magic']['end'] = self._io.pos()
+        if not self.magic == b"\x2E\x73\x6E\x64":
+            raise kaitaistruct.ValidationNotEqualError(b"\x2E\x73\x6E\x64", self.magic, self._io, u"/seq/0")
+        self._debug['ofs_data']['start'] = self._io.pos()
+        self.ofs_data = self._io.read_u4be()
+        self._debug['ofs_data']['end'] = self._io.pos()
+        self._debug['header']['start'] = self._io.pos()
+        self._raw_header = self._io.read_bytes(((self.ofs_data - 4) - 4))
+        _io__raw_header = KaitaiStream(BytesIO(self._raw_header))
+        self.header = Au.Header(_io__raw_header, self, self._root)
+        self.header._read()
+        self._debug['header']['end'] = self._io.pos()
+
+    class Header(KaitaiStruct):
+        SEQ_FIELDS = ["data_size", "encoding", "sample_rate", "num_channels", "comment"]
+        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_size']['start'] = self._io.pos()
+            self.data_size = self._io.read_u4be()
+            self._debug['data_size']['end'] = self._io.pos()
+            self._debug['encoding']['start'] = self._io.pos()
+            self.encoding = KaitaiStream.resolve_enum(Au.Encodings, self._io.read_u4be())
+            self._debug['encoding']['end'] = self._io.pos()
+            self._debug['sample_rate']['start'] = self._io.pos()
+            self.sample_rate = self._io.read_u4be()
+            self._debug['sample_rate']['end'] = self._io.pos()
+            self._debug['num_channels']['start'] = self._io.pos()
+            self.num_channels = self._io.read_u4be()
+            self._debug['num_channels']['end'] = self._io.pos()
+            if not self.num_channels >= 1:
+                raise kaitaistruct.ValidationLessThanError(1, self.num_channels, self._io, u"/types/header/seq/3")
+            self._debug['comment']['start'] = self._io.pos()
+            self.comment = (KaitaiStream.bytes_terminate(self._io.read_bytes_full(), 0, False)).decode(u"ASCII")
+            self._debug['comment']['end'] = self._io.pos()
+
+
+    @property
+    def len_data(self):
+        if hasattr(self, '_m_len_data'):
+            return self._m_len_data if hasattr(self, '_m_len_data') else None
+
+        self._m_len_data = ((self._io.size() - self.ofs_data) if self.header.data_size == 4294967295 else self.header.data_size)
+        return self._m_len_data if hasattr(self, '_m_len_data') else None
+
+

polyfile/kaitai/parsers/avantes_roh60.py

@@ -0,0 +1,112 @@
+# 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 AvantesRoh60(KaitaiStruct):
+    """Avantes USB spectrometers are supplied with a Windows binary which
+    generates one ROH and one RCM file when the user clicks "Save
+    experiment". In the version of 6.0, the ROH file contains a header
+    of 22 four-byte floats, then the spectrum as a float array and a
+    footer of 3 floats. The first and last pixel numbers are specified in the
+    header and determine the (length+1) of the spectral data. In the tested
+    files, the length is (2032-211-1)=1820 pixels, but Kaitai determines this
+    automatically anyway.
+    
+    The wavelength calibration is stored as a polynomial with coefficients
+    of 'wlintercept', 'wlx1', ... 'wlx4', the argument of which is the
+    (pixel number + 1), as found out by comparing with the original
+    Avantes converted data files. There is no intensity calibration saved,
+    but it is recommended to do it in your program - the CCD in the spectrometer
+    is so uneven that one should prepare exact pixel-to-pixel calibration curves
+    to get reasonable spectral results.
+    
+    The rest of the header floats is not known to the author. Note that the
+    newer version of Avantes software has a different format, see also
+    <https://www.mathworks.com/matlabcentral/fileexchange/37103-avantes-to-matlab>
+    
+    The RCM file contains the user-specified comment, so it may be useful
+    for automatic conversion of data. You may wish to divide the spectra by
+    the integration time before comparing them.
+    
+    Written and tested by Filip Dominec, 2017-2018
+    """
+    SEQ_FIELDS = ["unknown1", "wlintercept", "wlx1", "wlx2", "wlx3", "wlx4", "unknown2", "ipixfirst", "ipixlast", "unknown3", "spectrum", "integration_ms", "averaging", "pixel_smoothing"]
+    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['unknown1']['start'] = self._io.pos()
+        self.unknown1 = self._io.read_f4le()
+        self._debug['unknown1']['end'] = self._io.pos()
+        self._debug['wlintercept']['start'] = self._io.pos()
+        self.wlintercept = self._io.read_f4le()
+        self._debug['wlintercept']['end'] = self._io.pos()
+        self._debug['wlx1']['start'] = self._io.pos()
+        self.wlx1 = self._io.read_f4le()
+        self._debug['wlx1']['end'] = self._io.pos()
+        self._debug['wlx2']['start'] = self._io.pos()
+        self.wlx2 = self._io.read_f4le()
+        self._debug['wlx2']['end'] = self._io.pos()
+        self._debug['wlx3']['start'] = self._io.pos()
+        self.wlx3 = self._io.read_f4le()
+        self._debug['wlx3']['end'] = self._io.pos()
+        self._debug['wlx4']['start'] = self._io.pos()
+        self.wlx4 = self._io.read_f4le()
+        self._debug['wlx4']['end'] = self._io.pos()
+        self._debug['unknown2']['start'] = self._io.pos()
+        self.unknown2 = [None] * (9)
+        for i in range(9):
+            if not 'arr' in self._debug['unknown2']:
+                self._debug['unknown2']['arr'] = []
+            self._debug['unknown2']['arr'].append({'start': self._io.pos()})
+            self.unknown2[i] = self._io.read_f4le()
+            self._debug['unknown2']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['unknown2']['end'] = self._io.pos()
+        self._debug['ipixfirst']['start'] = self._io.pos()
+        self.ipixfirst = self._io.read_f4le()
+        self._debug['ipixfirst']['end'] = self._io.pos()
+        self._debug['ipixlast']['start'] = self._io.pos()
+        self.ipixlast = self._io.read_f4le()
+        self._debug['ipixlast']['end'] = self._io.pos()
+        self._debug['unknown3']['start'] = self._io.pos()
+        self.unknown3 = [None] * (4)
+        for i in range(4):
+            if not 'arr' in self._debug['unknown3']:
+                self._debug['unknown3']['arr'] = []
+            self._debug['unknown3']['arr'].append({'start': self._io.pos()})
+            self.unknown3[i] = self._io.read_f4le()
+            self._debug['unknown3']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['unknown3']['end'] = self._io.pos()
+        self._debug['spectrum']['start'] = self._io.pos()
+        self.spectrum = [None] * (((int(self.ipixlast) - int(self.ipixfirst)) - 1))
+        for i in range(((int(self.ipixlast) - int(self.ipixfirst)) - 1)):
+            if not 'arr' in self._debug['spectrum']:
+                self._debug['spectrum']['arr'] = []
+            self._debug['spectrum']['arr'].append({'start': self._io.pos()})
+            self.spectrum[i] = self._io.read_f4le()
+            self._debug['spectrum']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['spectrum']['end'] = self._io.pos()
+        self._debug['integration_ms']['start'] = self._io.pos()
+        self.integration_ms = self._io.read_f4le()
+        self._debug['integration_ms']['end'] = self._io.pos()
+        self._debug['averaging']['start'] = self._io.pos()
+        self.averaging = self._io.read_f4le()
+        self._debug['averaging']['end'] = self._io.pos()
+        self._debug['pixel_smoothing']['start'] = self._io.pos()
+        self.pixel_smoothing = self._io.read_f4le()
+        self._debug['pixel_smoothing']['end'] = self._io.pos()
+
+

polyfile/kaitai/parsers/avi.py

@@ -0,0 +1,296 @@
+# 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 Avi(KaitaiStruct):
+    """
+    .. seealso::
+       Source - https://learn.microsoft.com/en-us/previous-versions/ms779636(v=vs.85)
+    """
+
+    class ChunkType(Enum):
+        idx1 = 829973609
+        junk = 1263424842
+        info = 1330007625
+        isft = 1413894985
+        list = 1414744396
+        strf = 1718776947
+        avih = 1751742049
+        strh = 1752331379
+        movi = 1769369453
+        hdrl = 1819436136
+        strl = 1819440243
+
+    class StreamType(Enum):
+        mids = 1935960429
+        vids = 1935960438
+        auds = 1935963489
+        txts = 1937012852
+
+    class HandlerType(Enum):
+        mp3 = 85
+        ac3 = 8192
+        dts = 8193
+        cvid = 1684633187
+        xvid = 1684633208
+    SEQ_FIELDS = ["magic1", "file_size", "magic2", "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['magic1']['start'] = self._io.pos()
+        self.magic1 = self._io.read_bytes(4)
+        self._debug['magic1']['end'] = self._io.pos()
+        if not self.magic1 == b"\x52\x49\x46\x46":
+            raise kaitaistruct.ValidationNotEqualError(b"\x52\x49\x46\x46", self.magic1, self._io, u"/seq/0")
+        self._debug['file_size']['start'] = self._io.pos()
+        self.file_size = self._io.read_u4le()
+        self._debug['file_size']['end'] = self._io.pos()
+        self._debug['magic2']['start'] = self._io.pos()
+        self.magic2 = self._io.read_bytes(4)
+        self._debug['magic2']['end'] = self._io.pos()
+        if not self.magic2 == b"\x41\x56\x49\x20":
+            raise kaitaistruct.ValidationNotEqualError(b"\x41\x56\x49\x20", self.magic2, self._io, u"/seq/2")
+        self._debug['data']['start'] = self._io.pos()
+        self._raw_data = self._io.read_bytes((self.file_size - 4))
+        _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+        self.data = Avi.Blocks(_io__raw_data, self, self._root)
+        self.data._read()
+        self._debug['data']['end'] = self._io.pos()
+
+    class ListBody(KaitaiStruct):
+        SEQ_FIELDS = ["list_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['list_type']['start'] = self._io.pos()
+            self.list_type = KaitaiStream.resolve_enum(Avi.ChunkType, self._io.read_u4le())
+            self._debug['list_type']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            self.data = Avi.Blocks(self._io, self, self._root)
+            self.data._read()
+            self._debug['data']['end'] = self._io.pos()
+
+
+    class Rect(KaitaiStruct):
+        SEQ_FIELDS = ["left", "top", "right", "bottom"]
+        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['left']['start'] = self._io.pos()
+            self.left = self._io.read_s2le()
+            self._debug['left']['end'] = self._io.pos()
+            self._debug['top']['start'] = self._io.pos()
+            self.top = self._io.read_s2le()
+            self._debug['top']['end'] = self._io.pos()
+            self._debug['right']['start'] = self._io.pos()
+            self.right = self._io.read_s2le()
+            self._debug['right']['end'] = self._io.pos()
+            self._debug['bottom']['start'] = self._io.pos()
+            self.bottom = self._io.read_s2le()
+            self._debug['bottom']['end'] = self._io.pos()
+
+
+    class Blocks(KaitaiStruct):
+        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 = Avi.Block(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 AvihBody(KaitaiStruct):
+        """Main header of an AVI file, defined as AVIMAINHEADER structure.
+        
+        .. seealso::
+           Source - https://learn.microsoft.com/en-us/previous-versions/ms779632(v=vs.85)
+        """
+        SEQ_FIELDS = ["micro_sec_per_frame", "max_bytes_per_sec", "padding_granularity", "flags", "total_frames", "initial_frames", "streams", "suggested_buffer_size", "width", "height", "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['micro_sec_per_frame']['start'] = self._io.pos()
+            self.micro_sec_per_frame = self._io.read_u4le()
+            self._debug['micro_sec_per_frame']['end'] = self._io.pos()
+            self._debug['max_bytes_per_sec']['start'] = self._io.pos()
+            self.max_bytes_per_sec = self._io.read_u4le()
+            self._debug['max_bytes_per_sec']['end'] = self._io.pos()
+            self._debug['padding_granularity']['start'] = self._io.pos()
+            self.padding_granularity = self._io.read_u4le()
+            self._debug['padding_granularity']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._io.read_u4le()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['total_frames']['start'] = self._io.pos()
+            self.total_frames = self._io.read_u4le()
+            self._debug['total_frames']['end'] = self._io.pos()
+            self._debug['initial_frames']['start'] = self._io.pos()
+            self.initial_frames = self._io.read_u4le()
+            self._debug['initial_frames']['end'] = self._io.pos()
+            self._debug['streams']['start'] = self._io.pos()
+            self.streams = self._io.read_u4le()
+            self._debug['streams']['end'] = self._io.pos()
+            self._debug['suggested_buffer_size']['start'] = self._io.pos()
+            self.suggested_buffer_size = self._io.read_u4le()
+            self._debug['suggested_buffer_size']['end'] = self._io.pos()
+            self._debug['width']['start'] = self._io.pos()
+            self.width = self._io.read_u4le()
+            self._debug['width']['end'] = self._io.pos()
+            self._debug['height']['start'] = self._io.pos()
+            self.height = self._io.read_u4le()
+            self._debug['height']['end'] = self._io.pos()
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_bytes(16)
+            self._debug['reserved']['end'] = self._io.pos()
+
+
+    class Block(KaitaiStruct):
+        SEQ_FIELDS = ["four_cc", "block_size", "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['four_cc']['start'] = self._io.pos()
+            self.four_cc = KaitaiStream.resolve_enum(Avi.ChunkType, self._io.read_u4le())
+            self._debug['four_cc']['end'] = self._io.pos()
+            self._debug['block_size']['start'] = self._io.pos()
+            self.block_size = self._io.read_u4le()
+            self._debug['block_size']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            _on = self.four_cc
+            if _on == Avi.ChunkType.list:
+                self._raw_data = self._io.read_bytes(self.block_size)
+                _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+                self.data = Avi.ListBody(_io__raw_data, self, self._root)
+                self.data._read()
+            elif _on == Avi.ChunkType.avih:
+                self._raw_data = self._io.read_bytes(self.block_size)
+                _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+                self.data = Avi.AvihBody(_io__raw_data, self, self._root)
+                self.data._read()
+            elif _on == Avi.ChunkType.strh:
+                self._raw_data = self._io.read_bytes(self.block_size)
+                _io__raw_data = KaitaiStream(BytesIO(self._raw_data))
+                self.data = Avi.StrhBody(_io__raw_data, self, self._root)
+                self.data._read()
+            else:
+                self.data = self._io.read_bytes(self.block_size)
+            self._debug['data']['end'] = self._io.pos()
+
+
+    class StrhBody(KaitaiStruct):
+        """Stream header (one header per stream), defined as AVISTREAMHEADER structure.
+        
+        .. seealso::
+           Source - https://learn.microsoft.com/en-us/previous-versions/ms779638(v=vs.85)
+        """
+        SEQ_FIELDS = ["fcc_type", "fcc_handler", "flags", "priority", "language", "initial_frames", "scale", "rate", "start", "length", "suggested_buffer_size", "quality", "sample_size", "frame"]
+        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['fcc_type']['start'] = self._io.pos()
+            self.fcc_type = KaitaiStream.resolve_enum(Avi.StreamType, self._io.read_u4le())
+            self._debug['fcc_type']['end'] = self._io.pos()
+            self._debug['fcc_handler']['start'] = self._io.pos()
+            self.fcc_handler = KaitaiStream.resolve_enum(Avi.HandlerType, self._io.read_u4le())
+            self._debug['fcc_handler']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._io.read_u4le()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['priority']['start'] = self._io.pos()
+            self.priority = self._io.read_u2le()
+            self._debug['priority']['end'] = self._io.pos()
+            self._debug['language']['start'] = self._io.pos()
+            self.language = self._io.read_u2le()
+            self._debug['language']['end'] = self._io.pos()
+            self._debug['initial_frames']['start'] = self._io.pos()
+            self.initial_frames = self._io.read_u4le()
+            self._debug['initial_frames']['end'] = self._io.pos()
+            self._debug['scale']['start'] = self._io.pos()
+            self.scale = self._io.read_u4le()
+            self._debug['scale']['end'] = self._io.pos()
+            self._debug['rate']['start'] = self._io.pos()
+            self.rate = self._io.read_u4le()
+            self._debug['rate']['end'] = self._io.pos()
+            self._debug['start']['start'] = self._io.pos()
+            self.start = self._io.read_u4le()
+            self._debug['start']['end'] = self._io.pos()
+            self._debug['length']['start'] = self._io.pos()
+            self.length = self._io.read_u4le()
+            self._debug['length']['end'] = self._io.pos()
+            self._debug['suggested_buffer_size']['start'] = self._io.pos()
+            self.suggested_buffer_size = self._io.read_u4le()
+            self._debug['suggested_buffer_size']['end'] = self._io.pos()
+            self._debug['quality']['start'] = self._io.pos()
+            self.quality = self._io.read_u4le()
+            self._debug['quality']['end'] = self._io.pos()
+            self._debug['sample_size']['start'] = self._io.pos()
+            self.sample_size = self._io.read_u4le()
+            self._debug['sample_size']['end'] = self._io.pos()
+            self._debug['frame']['start'] = self._io.pos()
+            self.frame = Avi.Rect(self._io, self, self._root)
+            self.frame._read()
+            self._debug['frame']['end'] = self._io.pos()
+
+
+    class StrfBody(KaitaiStruct):
+        """Stream format description."""
+        SEQ_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):
+            pass
+
+
+

polyfile/kaitai/parsers/bcd.py

@@ -0,0 +1,111 @@
+# 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 Bcd(KaitaiStruct):
+    """BCD (Binary Coded Decimals) is a common way to encode integer
+    numbers in a way that makes human-readable output somewhat
+    simpler. In this encoding scheme, every decimal digit is encoded as
+    either a single byte (8 bits), or a nibble (half of a byte, 4
+    bits). This obviously wastes a lot of bits, but it makes translation
+    into human-readable string much easier than traditional
+    binary-to-decimal conversion process, which includes lots of
+    divisions by 10.
+    
+    For example, encoding integer 31337 in 8-digit, 8 bits per digit,
+    big endian order of digits BCD format yields
+    
+    ```
+    00 00 00 03 01 03 03 07
+    ```
+    
+    Encoding the same integer as 8-digit, 4 bits per digit, little
+    endian order BCD format would yield:
+    
+    ```
+    73 31 30 00
+    ```
+    
+    Using this type of encoding in Kaitai Struct is pretty
+    straightforward: one calls for this type, specifying desired
+    encoding parameters, and gets result using either `as_int` or
+    `as_str` attributes.
+    """
+    SEQ_FIELDS = ["digits"]
+    def __init__(self, num_digits, bits_per_digit, is_le, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self.num_digits = num_digits
+        self.bits_per_digit = bits_per_digit
+        self.is_le = is_le
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['digits']['start'] = self._io.pos()
+        self.digits = [None] * (self.num_digits)
+        for i in range(self.num_digits):
+            if not 'arr' in self._debug['digits']:
+                self._debug['digits']['arr'] = []
+            self._debug['digits']['arr'].append({'start': self._io.pos()})
+            _on = self.bits_per_digit
+            if _on == 4:
+                if not 'arr' in self._debug['digits']:
+                    self._debug['digits']['arr'] = []
+                self._debug['digits']['arr'].append({'start': self._io.pos()})
+                self.digits[i] = self._io.read_bits_int_be(4)
+                self._debug['digits']['arr'][i]['end'] = self._io.pos()
+            elif _on == 8:
+                if not 'arr' in self._debug['digits']:
+                    self._debug['digits']['arr'] = []
+                self._debug['digits']['arr'].append({'start': self._io.pos()})
+                self.digits[i] = self._io.read_u1()
+                self._debug['digits']['arr'][i]['end'] = self._io.pos()
+            self._debug['digits']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['digits']['end'] = self._io.pos()
+
+    @property
+    def as_int(self):
+        """Value of this BCD number as integer. Endianness would be selected based on `is_le` parameter given."""
+        if hasattr(self, '_m_as_int'):
+            return self._m_as_int if hasattr(self, '_m_as_int') else None
+
+        self._m_as_int = (self.as_int_le if self.is_le else self.as_int_be)
+        return self._m_as_int if hasattr(self, '_m_as_int') else None
+
+    @property
+    def as_int_le(self):
+        """Value of this BCD number as integer (treating digit order as little-endian)."""
+        if hasattr(self, '_m_as_int_le'):
+            return self._m_as_int_le if hasattr(self, '_m_as_int_le') else None
+
+        self._m_as_int_le = (self.digits[0] + (0 if self.num_digits < 2 else ((self.digits[1] * 10) + (0 if self.num_digits < 3 else ((self.digits[2] * 100) + (0 if self.num_digits < 4 else ((self.digits[3] * 1000) + (0 if self.num_digits < 5 else ((self.digits[4] * 10000) + (0 if self.num_digits < 6 else ((self.digits[5] * 100000) + (0 if self.num_digits < 7 else ((self.digits[6] * 1000000) + (0 if self.num_digits < 8 else (self.digits[7] * 10000000)))))))))))))))
+        return self._m_as_int_le if hasattr(self, '_m_as_int_le') else None
+
+    @property
+    def last_idx(self):
+        """Index of last digit (0-based)."""
+        if hasattr(self, '_m_last_idx'):
+            return self._m_last_idx if hasattr(self, '_m_last_idx') else None
+
+        self._m_last_idx = (self.num_digits - 1)
+        return self._m_last_idx if hasattr(self, '_m_last_idx') else None
+
+    @property
+    def as_int_be(self):
+        """Value of this BCD number as integer (treating digit order as big-endian)."""
+        if hasattr(self, '_m_as_int_be'):
+            return self._m_as_int_be if hasattr(self, '_m_as_int_be') else None
+
+        self._m_as_int_be = (self.digits[self.last_idx] + (0 if self.num_digits < 2 else ((self.digits[(self.last_idx - 1)] * 10) + (0 if self.num_digits < 3 else ((self.digits[(self.last_idx - 2)] * 100) + (0 if self.num_digits < 4 else ((self.digits[(self.last_idx - 3)] * 1000) + (0 if self.num_digits < 5 else ((self.digits[(self.last_idx - 4)] * 10000) + (0 if self.num_digits < 6 else ((self.digits[(self.last_idx - 5)] * 100000) + (0 if self.num_digits < 7 else ((self.digits[(self.last_idx - 6)] * 1000000) + (0 if self.num_digits < 8 else (self.digits[(self.last_idx - 7)] * 10000000)))))))))))))))
+        return self._m_as_int_be if hasattr(self, '_m_as_int_be') else None
+
+