Remove snippet and kaitai plugin. Note their individual links.

1 files changed, 0 insertions, 491 deletions

diff --git a/python/examples/kaitai/wav.py b/python/examples/kaitai/wav.py
deleted file mode 100644
index f05f958f..00000000
--- a/python/examples/kaitai/wav.py
+++ /dev/null
@@ -1,491 +0,0 @@
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from .kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-from enum import Enum
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class Wav(KaitaiStruct):
-    """The WAVE file format is a subset of Microsoft's RIFF specification for the
-    storage of multimedia files. A RIFF file starts out with a file header
-    followed by a sequence of data chunks. A WAVE file is often just a RIFF
-    file with a single "WAVE" chunk which consists of two sub-chunks --
-    a "fmt " chunk specifying the data format and a "data" chunk containing
-    the actual sample data.
-    
-    This Kaitai implementation was written by John Byrd of Gigantic Software
-    (jbyrd@giganticsoftware.com), and it is likely to contain bugs.
-    
-    .. seealso::
-       Source - https://www.loc.gov/preservation/digital/formats/fdd/fdd000001.shtml
-    """
-
-    class WFormatTagType(Enum):
-        unknown = 0
-        pcm = 1
-        adpcm = 2
-        ieee_float = 3
-        alaw = 6
-        mulaw = 7
-        dvi_adpcm = 17
-        dolby_ac3_spdif = 146
-        extensible = 65534
-        development = 65535
-
-    class ChunkType(Enum):
-        fmt = 544501094
-        bext = 1650817140
-        cue = 1668637984
-        data = 1684108385
-        minf = 1835626086
-        regn = 1919248238
-        umid = 1970104676
-    SEQ_FIELDS = ["riff_id", "file_size", "wave_id", "chunks"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['riff_id']['start'] = self._io.pos()
-        self.riff_id = self._io.ensure_fixed_contents(b"\x52\x49\x46\x46")
-        self._debug['riff_id']['end'] = self._io.pos()
-        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['wave_id']['start'] = self._io.pos()
-        self.wave_id = self._io.ensure_fixed_contents(b"\x57\x41\x56\x45")
-        self._debug['wave_id']['end'] = self._io.pos()
-        self._debug['chunks']['start'] = self._io.pos()
-        self._raw_chunks = self._io.read_bytes((self.file_size - 5))
-        io = KaitaiStream(BytesIO(self._raw_chunks))
-        self.chunks = self._root.ChunksType(io, self, self._root)
-        self.chunks._read()
-        self._debug['chunks']['end'] = self._io.pos()
-
-    class SampleType(KaitaiStruct):
-        SEQ_FIELDS = ["sample"]
-        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']['start'] = self._io.pos()
-            self.sample = self._io.read_u2le()
-            self._debug['sample']['end'] = self._io.pos()
-
-
-    class FormatChunkType(KaitaiStruct):
-        SEQ_FIELDS = ["w_format_tag", "n_channels", "n_samples_per_sec", "n_avg_bytes_per_sec", "n_block_align", "w_bits_per_sample", "cb_size", "w_valid_bits_per_sample", "channel_mask_and_subformat"]
-        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['w_format_tag']['start'] = self._io.pos()
-            self.w_format_tag = KaitaiStream.resolve_enum(self._root.WFormatTagType, self._io.read_u2le())
-            self._debug['w_format_tag']['end'] = self._io.pos()
-            self._debug['n_channels']['start'] = self._io.pos()
-            self.n_channels = self._io.read_u2le()
-            self._debug['n_channels']['end'] = self._io.pos()
-            self._debug['n_samples_per_sec']['start'] = self._io.pos()
-            self.n_samples_per_sec = self._io.read_u4le()
-            self._debug['n_samples_per_sec']['end'] = self._io.pos()
-            self._debug['n_avg_bytes_per_sec']['start'] = self._io.pos()
-            self.n_avg_bytes_per_sec = self._io.read_u4le()
-            self._debug['n_avg_bytes_per_sec']['end'] = self._io.pos()
-            self._debug['n_block_align']['start'] = self._io.pos()
-            self.n_block_align = self._io.read_u2le()
-            self._debug['n_block_align']['end'] = self._io.pos()
-            self._debug['w_bits_per_sample']['start'] = self._io.pos()
-            self.w_bits_per_sample = self._io.read_u2le()
-            self._debug['w_bits_per_sample']['end'] = self._io.pos()
-            if not (self.is_basic_pcm):
-                self._debug['cb_size']['start'] = self._io.pos()
-                self.cb_size = self._io.read_u2le()
-                self._debug['cb_size']['end'] = self._io.pos()
-
-            if self.is_cb_size_meaningful:
-                self._debug['w_valid_bits_per_sample']['start'] = self._io.pos()
-                self.w_valid_bits_per_sample = self._io.read_u2le()
-                self._debug['w_valid_bits_per_sample']['end'] = self._io.pos()
-
-            if self.is_extensible:
-                self._debug['channel_mask_and_subformat']['start'] = self._io.pos()
-                self.channel_mask_and_subformat = self._root.ChannelMaskAndSubformatType(self._io, self, self._root)
-                self.channel_mask_and_subformat._read()
-                self._debug['channel_mask_and_subformat']['end'] = self._io.pos()
-
-
-        @property
-        def is_extensible(self):
-            if hasattr(self, '_m_is_extensible'):
-                return self._m_is_extensible if hasattr(self, '_m_is_extensible') else None
-
-            self._m_is_extensible = self.w_format_tag == self._root.WFormatTagType.extensible
-            return self._m_is_extensible if hasattr(self, '_m_is_extensible') else None
-
-        @property
-        def is_basic_pcm(self):
-            if hasattr(self, '_m_is_basic_pcm'):
-                return self._m_is_basic_pcm if hasattr(self, '_m_is_basic_pcm') else None
-
-            self._m_is_basic_pcm = self.w_format_tag == self._root.WFormatTagType.pcm
-            return self._m_is_basic_pcm if hasattr(self, '_m_is_basic_pcm') else None
-
-        @property
-        def is_basic_float(self):
-            if hasattr(self, '_m_is_basic_float'):
-                return self._m_is_basic_float if hasattr(self, '_m_is_basic_float') else None
-
-            self._m_is_basic_float = self.w_format_tag == self._root.WFormatTagType.ieee_float
-            return self._m_is_basic_float if hasattr(self, '_m_is_basic_float') else None
-
-        @property
-        def is_cb_size_meaningful(self):
-            if hasattr(self, '_m_is_cb_size_meaningful'):
-                return self._m_is_cb_size_meaningful if hasattr(self, '_m_is_cb_size_meaningful') else None
-
-            self._m_is_cb_size_meaningful =  ((not (self.is_basic_pcm)) and (self.cb_size != 0)) 
-            return self._m_is_cb_size_meaningful if hasattr(self, '_m_is_cb_size_meaningful') else None
-
-
-    class GuidType(KaitaiStruct):
-        SEQ_FIELDS = ["data1", "data2", "data3", "data4", "data4a"]
-        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['data1']['start'] = self._io.pos()
-            self.data1 = self._io.read_u4le()
-            self._debug['data1']['end'] = self._io.pos()
-            self._debug['data2']['start'] = self._io.pos()
-            self.data2 = self._io.read_u2le()
-            self._debug['data2']['end'] = self._io.pos()
-            self._debug['data3']['start'] = self._io.pos()
-            self.data3 = self._io.read_u2le()
-            self._debug['data3']['end'] = self._io.pos()
-            self._debug['data4']['start'] = self._io.pos()
-            self.data4 = self._io.read_u4be()
-            self._debug['data4']['end'] = self._io.pos()
-            self._debug['data4a']['start'] = self._io.pos()
-            self.data4a = self._io.read_u4be()
-            self._debug['data4a']['end'] = self._io.pos()
-
-
-    class CuePointType(KaitaiStruct):
-        SEQ_FIELDS = ["dw_name", "dw_position", "fcc_chunk", "dw_chunk_start", "dw_block_start", "dw_sample_offset"]
-        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['dw_name']['start'] = self._io.pos()
-            self.dw_name = self._io.read_u4le()
-            self._debug['dw_name']['end'] = self._io.pos()
-            self._debug['dw_position']['start'] = self._io.pos()
-            self.dw_position = self._io.read_u4le()
-            self._debug['dw_position']['end'] = self._io.pos()
-            self._debug['fcc_chunk']['start'] = self._io.pos()
-            self.fcc_chunk = self._io.read_u4le()
-            self._debug['fcc_chunk']['end'] = self._io.pos()
-            self._debug['dw_chunk_start']['start'] = self._io.pos()
-            self.dw_chunk_start = self._io.read_u4le()
-            self._debug['dw_chunk_start']['end'] = self._io.pos()
-            self._debug['dw_block_start']['start'] = self._io.pos()
-            self.dw_block_start = self._io.read_u4le()
-            self._debug['dw_block_start']['end'] = self._io.pos()
-            self._debug['dw_sample_offset']['start'] = self._io.pos()
-            self.dw_sample_offset = self._io.read_u4le()
-            self._debug['dw_sample_offset']['end'] = self._io.pos()
-
-
-    class DataChunkType(KaitaiStruct):
-        SEQ_FIELDS = ["data"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['data']['start'] = self._io.pos()
-            self.data = self._io.read_bytes_full()
-            self._debug['data']['end'] = self._io.pos()
-
-
-    class SamplesType(KaitaiStruct):
-        SEQ_FIELDS = ["samples"]
-        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['samples']['start'] = self._io.pos()
-            self.samples = self._io.read_u4le()
-            self._debug['samples']['end'] = self._io.pos()
-
-
-    class ChannelMaskAndSubformatType(KaitaiStruct):
-        SEQ_FIELDS = ["dw_channel_mask", "subformat"]
-        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['dw_channel_mask']['start'] = self._io.pos()
-            self.dw_channel_mask = self._root.ChannelMaskType(self._io, self, self._root)
-            self.dw_channel_mask._read()
-            self._debug['dw_channel_mask']['end'] = self._io.pos()
-            self._debug['subformat']['start'] = self._io.pos()
-            self.subformat = self._root.GuidType(self._io, self, self._root)
-            self.subformat._read()
-            self._debug['subformat']['end'] = self._io.pos()
-
-
-    class ChunksType(KaitaiStruct):
-        SEQ_FIELDS = ["chunk"]
-        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['chunk']['start'] = self._io.pos()
-            self.chunk = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['chunk']:
-                    self._debug['chunk']['arr'] = []
-                self._debug['chunk']['arr'].append({'start': self._io.pos()})
-                _t_chunk = self._root.ChunkType(self._io, self, self._root)
-                _t_chunk._read()
-                self.chunk.append(_t_chunk)
-                self._debug['chunk']['arr'][len(self.chunk) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['chunk']['end'] = self._io.pos()
-
-
-    class CueChunkType(KaitaiStruct):
-        SEQ_FIELDS = ["dw_cue_points", "cue_points"]
-        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['dw_cue_points']['start'] = self._io.pos()
-            self.dw_cue_points = self._io.read_u4le()
-            self._debug['dw_cue_points']['end'] = self._io.pos()
-            if self.dw_cue_points != 0:
-                self._debug['cue_points']['start'] = self._io.pos()
-                self.cue_points = [None] * (self.dw_cue_points)
-                for i in range(self.dw_cue_points):
-                    if not 'arr' in self._debug['cue_points']:
-                        self._debug['cue_points']['arr'] = []
-                    self._debug['cue_points']['arr'].append({'start': self._io.pos()})
-                    _t_cue_points = self._root.CuePointType(self._io, self, self._root)
-                    _t_cue_points._read()
-                    self.cue_points[i] = _t_cue_points
-                    self._debug['cue_points']['arr'][i]['end'] = self._io.pos()
-
-                self._debug['cue_points']['end'] = self._io.pos()
-
-
-
-    class ChannelMaskType(KaitaiStruct):
-        SEQ_FIELDS = ["front_right_of_center", "front_left_of_center", "back_right", "back_left", "low_frequency", "front_center", "front_right", "front_left", "top_center", "side_right", "side_left", "back_center", "top_back_left", "top_front_right", "top_front_center", "top_front_left", "unused1", "top_back_right", "top_back_center", "unused2"]
-        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['front_right_of_center']['start'] = self._io.pos()
-            self.front_right_of_center = self._io.read_bits_int(1) != 0
-            self._debug['front_right_of_center']['end'] = self._io.pos()
-            self._debug['front_left_of_center']['start'] = self._io.pos()
-            self.front_left_of_center = self._io.read_bits_int(1) != 0
-            self._debug['front_left_of_center']['end'] = self._io.pos()
-            self._debug['back_right']['start'] = self._io.pos()
-            self.back_right = self._io.read_bits_int(1) != 0
-            self._debug['back_right']['end'] = self._io.pos()
-            self._debug['back_left']['start'] = self._io.pos()
-            self.back_left = self._io.read_bits_int(1) != 0
-            self._debug['back_left']['end'] = self._io.pos()
-            self._debug['low_frequency']['start'] = self._io.pos()
-            self.low_frequency = self._io.read_bits_int(1) != 0
-            self._debug['low_frequency']['end'] = self._io.pos()
-            self._debug['front_center']['start'] = self._io.pos()
-            self.front_center = self._io.read_bits_int(1) != 0
-            self._debug['front_center']['end'] = self._io.pos()
-            self._debug['front_right']['start'] = self._io.pos()
-            self.front_right = self._io.read_bits_int(1) != 0
-            self._debug['front_right']['end'] = self._io.pos()
-            self._debug['front_left']['start'] = self._io.pos()
-            self.front_left = self._io.read_bits_int(1) != 0
-            self._debug['front_left']['end'] = self._io.pos()
-            self._debug['top_center']['start'] = self._io.pos()
-            self.top_center = self._io.read_bits_int(1) != 0
-            self._debug['top_center']['end'] = self._io.pos()
-            self._debug['side_right']['start'] = self._io.pos()
-            self.side_right = self._io.read_bits_int(1) != 0
-            self._debug['side_right']['end'] = self._io.pos()
-            self._debug['side_left']['start'] = self._io.pos()
-            self.side_left = self._io.read_bits_int(1) != 0
-            self._debug['side_left']['end'] = self._io.pos()
-            self._debug['back_center']['start'] = self._io.pos()
-            self.back_center = self._io.read_bits_int(1) != 0
-            self._debug['back_center']['end'] = self._io.pos()
-            self._debug['top_back_left']['start'] = self._io.pos()
-            self.top_back_left = self._io.read_bits_int(1) != 0
-            self._debug['top_back_left']['end'] = self._io.pos()
-            self._debug['top_front_right']['start'] = self._io.pos()
-            self.top_front_right = self._io.read_bits_int(1) != 0
-            self._debug['top_front_right']['end'] = self._io.pos()
-            self._debug['top_front_center']['start'] = self._io.pos()
-            self.top_front_center = self._io.read_bits_int(1) != 0
-            self._debug['top_front_center']['end'] = self._io.pos()
-            self._debug['top_front_left']['start'] = self._io.pos()
-            self.top_front_left = self._io.read_bits_int(1) != 0
-            self._debug['top_front_left']['end'] = self._io.pos()
-            self._debug['unused1']['start'] = self._io.pos()
-            self.unused1 = self._io.read_bits_int(6)
-            self._debug['unused1']['end'] = self._io.pos()
-            self._debug['top_back_right']['start'] = self._io.pos()
-            self.top_back_right = self._io.read_bits_int(1) != 0
-            self._debug['top_back_right']['end'] = self._io.pos()
-            self._debug['top_back_center']['start'] = self._io.pos()
-            self.top_back_center = self._io.read_bits_int(1) != 0
-            self._debug['top_back_center']['end'] = self._io.pos()
-            self._debug['unused2']['start'] = self._io.pos()
-            self.unused2 = self._io.read_bits_int(8)
-            self._debug['unused2']['end'] = self._io.pos()
-
-
-    class ChunkType(KaitaiStruct):
-        SEQ_FIELDS = ["chunk_id", "len", "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['chunk_id']['start'] = self._io.pos()
-            self.chunk_id = self._io.read_u4be()
-            self._debug['chunk_id']['end'] = self._io.pos()
-            self._debug['len']['start'] = self._io.pos()
-            self.len = self._io.read_u4le()
-            self._debug['len']['end'] = self._io.pos()
-            self._debug['data']['start'] = self._io.pos()
-            _on = self.chunk_id
-            if _on == 1684108385:
-                self._raw_data = self._io.read_bytes(self.len)
-                io = KaitaiStream(BytesIO(self._raw_data))
-                self.data = self._root.DataChunkType(io, self, self._root)
-                self.data._read()
-            elif _on == 1668637984:
-                self._raw_data = self._io.read_bytes(self.len)
-                io = KaitaiStream(BytesIO(self._raw_data))
-                self.data = self._root.CueChunkType(io, self, self._root)
-                self.data._read()
-            elif _on == 1650817140:
-                self._raw_data = self._io.read_bytes(self.len)
-                io = KaitaiStream(BytesIO(self._raw_data))
-                self.data = self._root.BextChunkType(io, self, self._root)
-                self.data._read()
-            elif _on == 1718449184:
-                self._raw_data = self._io.read_bytes(self.len)
-                io = KaitaiStream(BytesIO(self._raw_data))
-                self.data = self._root.FormatChunkType(io, self, self._root)
-                self.data._read()
-            else:
-                self.data = self._io.read_bytes(self.len)
-            self._debug['data']['end'] = self._io.pos()
-
-
-    class BextChunkType(KaitaiStruct):
-        SEQ_FIELDS = ["description", "originator", "originator_reference", "origination_date", "origination_time", "time_reference_low", "time_reference_high", "version", "umid", "loudness_value", "loudness_range", "max_true_peak_level", "max_momentary_loudness", "max_short_term_loudness"]
-        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['description']['start'] = self._io.pos()
-            self.description = (self._io.read_bytes(256)).decode(u"ASCII")
-            self._debug['description']['end'] = self._io.pos()
-            self._debug['originator']['start'] = self._io.pos()
-            self.originator = (self._io.read_bytes(32)).decode(u"ASCII")
-            self._debug['originator']['end'] = self._io.pos()
-            self._debug['originator_reference']['start'] = self._io.pos()
-            self.originator_reference = (self._io.read_bytes(32)).decode(u"ASCII")
-            self._debug['originator_reference']['end'] = self._io.pos()
-            self._debug['origination_date']['start'] = self._io.pos()
-            self.origination_date = (self._io.read_bytes(10)).decode(u"ASCII")
-            self._debug['origination_date']['end'] = self._io.pos()
-            self._debug['origination_time']['start'] = self._io.pos()
-            self.origination_time = (self._io.read_bytes(8)).decode(u"ASCII")
-            self._debug['origination_time']['end'] = self._io.pos()
-            self._debug['time_reference_low']['start'] = self._io.pos()
-            self.time_reference_low = self._io.read_u4le()
-            self._debug['time_reference_low']['end'] = self._io.pos()
-            self._debug['time_reference_high']['start'] = self._io.pos()
-            self.time_reference_high = self._io.read_u4le()
-            self._debug['time_reference_high']['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['umid']['start'] = self._io.pos()
-            self.umid = self._io.read_bytes(64)
-            self._debug['umid']['end'] = self._io.pos()
-            self._debug['loudness_value']['start'] = self._io.pos()
-            self.loudness_value = self._io.read_u2le()
-            self._debug['loudness_value']['end'] = self._io.pos()
-            self._debug['loudness_range']['start'] = self._io.pos()
-            self.loudness_range = self._io.read_u2le()
-            self._debug['loudness_range']['end'] = self._io.pos()
-            self._debug['max_true_peak_level']['start'] = self._io.pos()
-            self.max_true_peak_level = self._io.read_u2le()
-            self._debug['max_true_peak_level']['end'] = self._io.pos()
-            self._debug['max_momentary_loudness']['start'] = self._io.pos()
-            self.max_momentary_loudness = self._io.read_u2le()
-            self._debug['max_momentary_loudness']['end'] = self._io.pos()
-            self._debug['max_short_term_loudness']['start'] = self._io.pos()
-            self.max_short_term_loudness = self._io.read_u2le()
-            self._debug['max_short_term_loudness']['end'] = self._io.pos()
-
-
-    @property
-    def format_chunk(self):
-        if hasattr(self, '_m_format_chunk'):
-            return self._m_format_chunk if hasattr(self, '_m_format_chunk') else None
-
-        self._m_format_chunk = self.chunks.chunk[0].data
-        return self._m_format_chunk if hasattr(self, '_m_format_chunk') else None
-
-