polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/id3v1_1.py

@@ -0,0 +1,220 @@
+# 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 Id3v11(KaitaiStruct):
+    """ID3v1.1 tag is a method to store simple metadata in .mp3 files. The
+    tag is appended to the end of file and spans exactly 128 bytes.
+    
+    This type is supposed to be used on full .mp3 files, seeking to
+    proper position automatically. If you're interesting in parsing only
+    the tag itself, please use `id3v1_1::id3_v1_1_tag` subtype.
+    
+    .. seealso::
+       Source - https://id3.org/ID3v1
+    """
+    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
+
+    class Id3V11Tag(KaitaiStruct):
+        """ID3v1.1 tag itself, a fixed size 128 byte structure. Contains
+        several metadata fields as fixed-size strings.
+        
+        Note that string encoding is not specified by standard, so real
+        encoding used would vary a lot from one implementation to
+        another. Most Windows-based applications tend to use "ANSI"
+        (i.e. locale-dependent encoding, usually one byte per
+        character). Some embedded applications allow selection of
+        charset.
+        """
+
+        class GenreEnum(Enum):
+            blues = 0
+            classic_rock = 1
+            country = 2
+            dance = 3
+            disco = 4
+            funk = 5
+            grunge = 6
+            hip_hop = 7
+            jazz = 8
+            metal = 9
+            new_age = 10
+            oldies = 11
+            other = 12
+            pop = 13
+            rnb = 14
+            rap = 15
+            reggae = 16
+            rock = 17
+            techno = 18
+            industrial = 19
+            alternative = 20
+            ska = 21
+            death_metal = 22
+            pranks = 23
+            soundtrack = 24
+            euro_techno = 25
+            ambient = 26
+            trip_hop = 27
+            vocal = 28
+            jazz_funk = 29
+            fusion = 30
+            trance = 31
+            classical = 32
+            instrumental = 33
+            acid = 34
+            house = 35
+            game = 36
+            sound_clip = 37
+            gospel = 38
+            noise = 39
+            alternrock = 40
+            bass = 41
+            soul = 42
+            punk = 43
+            space = 44
+            meditative = 45
+            instrumental_pop = 46
+            instrumental_rock = 47
+            ethnic = 48
+            gothic = 49
+            darkwave = 50
+            techno_industrial = 51
+            electronic = 52
+            pop_folk = 53
+            eurodance = 54
+            dream = 55
+            southern_rock = 56
+            comedy = 57
+            cult = 58
+            gangsta = 59
+            top_40 = 60
+            christian_rap = 61
+            pop_funk = 62
+            jungle = 63
+            native_american = 64
+            cabaret = 65
+            new_wave = 66
+            psychadelic = 67
+            rave = 68
+            showtunes = 69
+            trailer = 70
+            lo_fi = 71
+            tribal = 72
+            acid_punk = 73
+            acid_jazz = 74
+            polka = 75
+            retro = 76
+            musical = 77
+            rock_n_roll = 78
+            hard_rock = 79
+            folk = 80
+            folk_rock = 81
+            national_folk = 82
+            swing = 83
+            fast_fusion = 84
+            bebob = 85
+            latin = 86
+            revival = 87
+            celtic = 88
+            bluegrass = 89
+            avantgarde = 90
+            gothic_rock = 91
+            progressive_rock = 92
+            psychedelic_rock = 93
+            symphonic_rock = 94
+            slow_rock = 95
+            big_band = 96
+            chorus = 97
+            easy_listening = 98
+            acoustic = 99
+            humour = 100
+            speech = 101
+            chanson = 102
+            opera = 103
+            chamber_music = 104
+            sonata = 105
+            symphony = 106
+            booty_bass = 107
+            primus = 108
+            porn_groove = 109
+            satire = 110
+            slow_jam = 111
+            club = 112
+            tango = 113
+            samba = 114
+            folklore = 115
+            ballad = 116
+            power_ballad = 117
+            rhythmic_soul = 118
+            freestyle = 119
+            duet = 120
+            punk_rock = 121
+            drum_solo = 122
+            a_capella = 123
+            euro_house = 124
+            dance_hall = 125
+        SEQ_FIELDS = ["magic", "title", "artist", "album", "year", "comment", "genre"]
+        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(3)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x54\x41\x47":
+                raise kaitaistruct.ValidationNotEqualError(b"\x54\x41\x47", self.magic, self._io, u"/types/id3_v1_1_tag/seq/0")
+            self._debug['title']['start'] = self._io.pos()
+            self.title = self._io.read_bytes(30)
+            self._debug['title']['end'] = self._io.pos()
+            self._debug['artist']['start'] = self._io.pos()
+            self.artist = self._io.read_bytes(30)
+            self._debug['artist']['end'] = self._io.pos()
+            self._debug['album']['start'] = self._io.pos()
+            self.album = self._io.read_bytes(30)
+            self._debug['album']['end'] = self._io.pos()
+            self._debug['year']['start'] = self._io.pos()
+            self.year = (self._io.read_bytes(4)).decode(u"ASCII")
+            self._debug['year']['end'] = self._io.pos()
+            self._debug['comment']['start'] = self._io.pos()
+            self.comment = self._io.read_bytes(30)
+            self._debug['comment']['end'] = self._io.pos()
+            self._debug['genre']['start'] = self._io.pos()
+            self.genre = KaitaiStream.resolve_enum(Id3v11.Id3V11Tag.GenreEnum, self._io.read_u1())
+            self._debug['genre']['end'] = self._io.pos()
+
+
+    @property
+    def id3v1_tag(self):
+        if hasattr(self, '_m_id3v1_tag'):
+            return self._m_id3v1_tag if hasattr(self, '_m_id3v1_tag') else None
+
+        _pos = self._io.pos()
+        self._io.seek((self._io.size() - 128))
+        self._debug['_m_id3v1_tag']['start'] = self._io.pos()
+        self._m_id3v1_tag = Id3v11.Id3V11Tag(self._io, self, self._root)
+        self._m_id3v1_tag._read()
+        self._debug['_m_id3v1_tag']['end'] = self._io.pos()
+        self._io.seek(_pos)
+        return self._m_id3v1_tag if hasattr(self, '_m_id3v1_tag') else None
+
+

polyfile/kaitai/parsers/id3v2_3.py

@@ -0,0 +1,324 @@
+# 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 Id3v23(KaitaiStruct):
+    """
+    .. seealso::
+       Source - https://id3.org/id3v2.3.0
+    """
+    SEQ_FIELDS = ["tag"]
+    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['tag']['start'] = self._io.pos()
+        self.tag = Id3v23.Tag(self._io, self, self._root)
+        self.tag._read()
+        self._debug['tag']['end'] = self._io.pos()
+
+    class U1beSynchsafe(KaitaiStruct):
+        SEQ_FIELDS = ["padding", "value"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['padding']['start'] = self._io.pos()
+            self.padding = self._io.read_bits_int_be(1) != 0
+            self._debug['padding']['end'] = self._io.pos()
+            self._debug['value']['start'] = self._io.pos()
+            self.value = self._io.read_bits_int_be(7)
+            self._debug['value']['end'] = self._io.pos()
+
+
+    class U2beSynchsafe(KaitaiStruct):
+        SEQ_FIELDS = ["byte0", "byte1"]
+        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['byte0']['start'] = self._io.pos()
+            self.byte0 = Id3v23.U1beSynchsafe(self._io, self, self._root)
+            self.byte0._read()
+            self._debug['byte0']['end'] = self._io.pos()
+            self._debug['byte1']['start'] = self._io.pos()
+            self.byte1 = Id3v23.U1beSynchsafe(self._io, self, self._root)
+            self.byte1._read()
+            self._debug['byte1']['end'] = self._io.pos()
+
+        @property
+        def value(self):
+            if hasattr(self, '_m_value'):
+                return self._m_value if hasattr(self, '_m_value') else None
+
+            self._m_value = ((self.byte0.value << 7) | self.byte1.value)
+            return self._m_value if hasattr(self, '_m_value') else None
+
+
+    class Tag(KaitaiStruct):
+        """
+        .. seealso::
+           Section 3. ID3v2 overview
+        """
+        SEQ_FIELDS = ["header", "header_ex", "frames", "padding"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['header']['start'] = self._io.pos()
+            self.header = Id3v23.Header(self._io, self, self._root)
+            self.header._read()
+            self._debug['header']['end'] = self._io.pos()
+            if self.header.flags.flag_headerex:
+                self._debug['header_ex']['start'] = self._io.pos()
+                self.header_ex = Id3v23.HeaderEx(self._io, self, self._root)
+                self.header_ex._read()
+                self._debug['header_ex']['end'] = self._io.pos()
+
+            self._debug['frames']['start'] = self._io.pos()
+            self.frames = []
+            i = 0
+            while True:
+                if not 'arr' in self._debug['frames']:
+                    self._debug['frames']['arr'] = []
+                self._debug['frames']['arr'].append({'start': self._io.pos()})
+                _t_frames = Id3v23.Frame(self._io, self, self._root)
+                _t_frames._read()
+                _ = _t_frames
+                self.frames.append(_)
+                self._debug['frames']['arr'][len(self.frames) - 1]['end'] = self._io.pos()
+                if  (((self._io.pos() + _.size) > self.header.size.value) or (_.is_invalid)) :
+                    break
+                i += 1
+            self._debug['frames']['end'] = self._io.pos()
+            if self.header.flags.flag_headerex:
+                self._debug['padding']['start'] = self._io.pos()
+                self.padding = self._io.read_bytes((self.header_ex.padding_size - self._io.pos()))
+                self._debug['padding']['end'] = self._io.pos()
+
+
+
+    class U4beSynchsafe(KaitaiStruct):
+        SEQ_FIELDS = ["short0", "short1"]
+        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['short0']['start'] = self._io.pos()
+            self.short0 = Id3v23.U2beSynchsafe(self._io, self, self._root)
+            self.short0._read()
+            self._debug['short0']['end'] = self._io.pos()
+            self._debug['short1']['start'] = self._io.pos()
+            self.short1 = Id3v23.U2beSynchsafe(self._io, self, self._root)
+            self.short1._read()
+            self._debug['short1']['end'] = self._io.pos()
+
+        @property
+        def value(self):
+            if hasattr(self, '_m_value'):
+                return self._m_value if hasattr(self, '_m_value') else None
+
+            self._m_value = ((self.short0.value << 14) | self.short1.value)
+            return self._m_value if hasattr(self, '_m_value') else None
+
+
+    class Frame(KaitaiStruct):
+        """
+        .. seealso::
+           Section 3.3. ID3v2 frame overview
+        """
+        SEQ_FIELDS = ["id", "size", "flags", "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['id']['start'] = self._io.pos()
+            self.id = (self._io.read_bytes(4)).decode(u"ASCII")
+            self._debug['id']['end'] = self._io.pos()
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._io.read_u4be()
+            self._debug['size']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = Id3v23.Frame.Flags(self._io, self, self._root)
+            self.flags._read()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            self.data = self._io.read_bytes(self.size)
+            self._debug['data']['end'] = self._io.pos()
+
+        class Flags(KaitaiStruct):
+            SEQ_FIELDS = ["flag_discard_alter_tag", "flag_discard_alter_file", "flag_read_only", "reserved1", "flag_compressed", "flag_encrypted", "flag_grouping", "reserved2"]
+            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['flag_discard_alter_tag']['start'] = self._io.pos()
+                self.flag_discard_alter_tag = self._io.read_bits_int_be(1) != 0
+                self._debug['flag_discard_alter_tag']['end'] = self._io.pos()
+                self._debug['flag_discard_alter_file']['start'] = self._io.pos()
+                self.flag_discard_alter_file = self._io.read_bits_int_be(1) != 0
+                self._debug['flag_discard_alter_file']['end'] = self._io.pos()
+                self._debug['flag_read_only']['start'] = self._io.pos()
+                self.flag_read_only = self._io.read_bits_int_be(1) != 0
+                self._debug['flag_read_only']['end'] = self._io.pos()
+                self._debug['reserved1']['start'] = self._io.pos()
+                self.reserved1 = self._io.read_bits_int_be(5)
+                self._debug['reserved1']['end'] = self._io.pos()
+                self._debug['flag_compressed']['start'] = self._io.pos()
+                self.flag_compressed = self._io.read_bits_int_be(1) != 0
+                self._debug['flag_compressed']['end'] = self._io.pos()
+                self._debug['flag_encrypted']['start'] = self._io.pos()
+                self.flag_encrypted = self._io.read_bits_int_be(1) != 0
+                self._debug['flag_encrypted']['end'] = self._io.pos()
+                self._debug['flag_grouping']['start'] = self._io.pos()
+                self.flag_grouping = self._io.read_bits_int_be(1) != 0
+                self._debug['flag_grouping']['end'] = self._io.pos()
+                self._debug['reserved2']['start'] = self._io.pos()
+                self.reserved2 = self._io.read_bits_int_be(5)
+                self._debug['reserved2']['end'] = self._io.pos()
+
+
+        @property
+        def is_invalid(self):
+            if hasattr(self, '_m_is_invalid'):
+                return self._m_is_invalid if hasattr(self, '_m_is_invalid') else None
+
+            self._m_is_invalid = self.id == u"\000\000\000\000"
+            return self._m_is_invalid if hasattr(self, '_m_is_invalid') else None
+
+
+    class HeaderEx(KaitaiStruct):
+        """ID3v2 extended header.
+        
+        .. seealso::
+           Section 3.2. ID3v2 extended header
+        """
+        SEQ_FIELDS = ["size", "flags_ex", "padding_size", "crc"]
+        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['size']['start'] = self._io.pos()
+            self.size = self._io.read_u4be()
+            self._debug['size']['end'] = self._io.pos()
+            self._debug['flags_ex']['start'] = self._io.pos()
+            self.flags_ex = Id3v23.HeaderEx.FlagsEx(self._io, self, self._root)
+            self.flags_ex._read()
+            self._debug['flags_ex']['end'] = self._io.pos()
+            self._debug['padding_size']['start'] = self._io.pos()
+            self.padding_size = self._io.read_u4be()
+            self._debug['padding_size']['end'] = self._io.pos()
+            if self.flags_ex.flag_crc:
+                self._debug['crc']['start'] = self._io.pos()
+                self.crc = self._io.read_u4be()
+                self._debug['crc']['end'] = self._io.pos()
+
+
+        class FlagsEx(KaitaiStruct):
+            SEQ_FIELDS = ["flag_crc", "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['flag_crc']['start'] = self._io.pos()
+                self.flag_crc = self._io.read_bits_int_be(1) != 0
+                self._debug['flag_crc']['end'] = self._io.pos()
+                self._debug['reserved']['start'] = self._io.pos()
+                self.reserved = self._io.read_bits_int_be(15)
+                self._debug['reserved']['end'] = self._io.pos()
+
+
+
+    class Header(KaitaiStruct):
+        """ID3v2 fixed header.
+        
+        .. seealso::
+           Section 3.1. ID3v2 header
+        """
+        SEQ_FIELDS = ["magic", "version_major", "version_revision", "flags", "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['magic']['start'] = self._io.pos()
+            self.magic = self._io.read_bytes(3)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x49\x44\x33":
+                raise kaitaistruct.ValidationNotEqualError(b"\x49\x44\x33", self.magic, self._io, u"/types/header/seq/0")
+            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_revision']['start'] = self._io.pos()
+            self.version_revision = self._io.read_u1()
+            self._debug['version_revision']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = Id3v23.Header.Flags(self._io, self, self._root)
+            self.flags._read()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['size']['start'] = self._io.pos()
+            self.size = Id3v23.U4beSynchsafe(self._io, self, self._root)
+            self.size._read()
+            self._debug['size']['end'] = self._io.pos()
+
+        class Flags(KaitaiStruct):
+            SEQ_FIELDS = ["flag_unsynchronization", "flag_headerex", "flag_experimental", "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['flag_unsynchronization']['start'] = self._io.pos()
+                self.flag_unsynchronization = self._io.read_bits_int_be(1) != 0
+                self._debug['flag_unsynchronization']['end'] = self._io.pos()
+                self._debug['flag_headerex']['start'] = self._io.pos()
+                self.flag_headerex = self._io.read_bits_int_be(1) != 0
+                self._debug['flag_headerex']['end'] = self._io.pos()
+                self._debug['flag_experimental']['start'] = self._io.pos()
+                self.flag_experimental = self._io.read_bits_int_be(1) != 0
+                self._debug['flag_experimental']['end'] = self._io.pos()
+                self._debug['reserved']['start'] = self._io.pos()
+                self.reserved = self._io.read_bits_int_be(5)
+                self._debug['reserved']['end'] = self._io.pos()
+
+
+
+