PyPI - tinytag - Versions diffs - 2.1.1__tar.gz → 2.2.0__tar.gz - Mend

tinytag 2.1.1tar.gz → 2.2.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of tinytag might be problematic. Click here for more details.

Files changed (8) hide show

{tinytag-2.1.1 → tinytag-2.2.0}/PKG-INFO +36 -4
{tinytag-2.1.1 → tinytag-2.2.0}/README.md +32 -3
{tinytag-2.1.1 → tinytag-2.2.0}/pyproject.toml +15 -2
{tinytag-2.1.1 → tinytag-2.2.0}/tinytag/__init__.py +2 -0
{tinytag-2.1.1 → tinytag-2.2.0}/tinytag/tinytag.py +324 -182
{tinytag-2.1.1 → tinytag-2.2.0}/LICENSE +0 -0
{tinytag-2.1.1 → tinytag-2.2.0}/tinytag/__main__.py +0 -0
{tinytag-2.1.1 → tinytag-2.2.0}/tinytag/py.typed +0 -0

{tinytag-2.1.1 → tinytag-2.2.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinytag
-Version: 2.1.1
+Version: 2.2.0
 Summary: Read audio file metadata
 Keywords: metadata,audio,music,mp3,m4a,wav,ogg,opus,flac,wma,aiff
 Author: Tom Wallroth, Mat (mathiascode)
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment
@@ -28,8 +29,10 @@ Classifier: Typing :: Typed
 License-File: LICENSE
 Requires-Dist: coverage ; extra == "tests"
 Requires-Dist: mypy ; extra == "tests"
+Requires-Dist: mypy<1.19.0 ; extra == "tests" and ( platform_python_implementation == 'PyPy')
 Requires-Dist: pycodestyle ; extra == "tests"
 Requires-Dist: pylint ; extra == "tests"
+Requires-Dist: pyright ; extra == "tests"
 Project-URL: Homepage, https://github.com/tinytag/tinytag
 Provides-Extra: tests
@@ -44,8 +47,6 @@ tinytag is a Python library for reading audio file metadata
 [![Build Status](https://img.shields.io/github/actions/workflow/status/tinytag/tinytag/tests.yml
 )](https://github.com/tinytag/tinytag/actions?query=workflow:%22Tests%22)
-[![Coverage Status](https://img.shields.io/coverallsCoverage/github/tinytag/tinytag
-)](https://coveralls.io/r/tinytag/tinytag)
 [![PyPI Version](https://img.shields.io/pypi/v/tinytag
 )](https://pypi.org/project/tinytag/)
 [![PyPI Downloads](https://img.shields.io/pypi/dm/tinytag
@@ -183,7 +184,7 @@ These are helpful when you need quick access to common metadata.
 ### Additional Metadata
-For additional values of the same field type, non-common metadata fields, or
+For additional values of the same field type, uncommon metadata fields, or
 metadata specific to certain file formats, use `other`:
     tag.other         # a dictionary of additional fields
@@ -203,6 +204,7 @@ present when files provide such metadata:
     director
     encoded_by
     encoder_settings
+    grouping
     initial_key
     isrc
     language
@@ -210,9 +212,14 @@ present when files provide such metadata:
     lyricist
     lyrics
     media
+    movement
+    movement_name
+    movement_total
     publisher
     set_subtitle
+    show_movement
     url
+    work
 Additional `other` field names not documented above may be present, but are
 format-specific and may change or disappear in future tinytag releases. If
@@ -422,6 +429,31 @@ TinyTag.get(file_obj=your_file_obj)
 ## Changelog
+### 2.2.0  (2025-12-15)
+- Add support for movement, work and grouping fields
+- ID3: Make synced lyrics available in 'other.lyrics' (LRC format)
+- ID3: Continue reading after encountering empty frame
+- ID3: Fix frame reading when image parsing is disabled
+- ID3: Exclude more frames containing binary data
+- ID3: Avoid unnecessary string decoding
+- M4A: Support extended atom sizes
+- M4A: Ensure all field names are lowercase
+- OGG: Stop reading after reaching EOS page
+- Vorbis: Map UNSYNCEDLYRICS field to other.lyrics
+### 2.1.2  (2025-08-14)
+- M4A: Add a few missing additional metadata fields
+- M4A: Support '©com' composer atom
+- M4A: Fix reading of multi-value custom fields
+- M4A: Use correct encoding when reading data names
+- ID3: Don't read entire file to determine duration
+- ID3: Skip stray null byte before image data
+- Add missing `__version__` attribute
+- Avoid some unnecessary work in hot code paths
+- Improve a few incomplete type hints
 ### 2.1.1  (2025-04-23)
 - ID3: Stop removing 'b' character from strings

{tinytag-2.1.1 → tinytag-2.2.0}/README.md RENAMED Viewed

@@ -9,8 +9,6 @@ tinytag is a Python library for reading audio file metadata
 [![Build Status](https://img.shields.io/github/actions/workflow/status/tinytag/tinytag/tests.yml
 )](https://github.com/tinytag/tinytag/actions?query=workflow:%22Tests%22)
-[![Coverage Status](https://img.shields.io/coverallsCoverage/github/tinytag/tinytag
-)](https://coveralls.io/r/tinytag/tinytag)
 [![PyPI Version](https://img.shields.io/pypi/v/tinytag
 )](https://pypi.org/project/tinytag/)
 [![PyPI Downloads](https://img.shields.io/pypi/dm/tinytag
@@ -148,7 +146,7 @@ These are helpful when you need quick access to common metadata.
 ### Additional Metadata
-For additional values of the same field type, non-common metadata fields, or
+For additional values of the same field type, uncommon metadata fields, or
 metadata specific to certain file formats, use `other`:
     tag.other         # a dictionary of additional fields
@@ -168,6 +166,7 @@ present when files provide such metadata:
     director
     encoded_by
     encoder_settings
+    grouping
     initial_key
     isrc
     language
@@ -175,9 +174,14 @@ present when files provide such metadata:
     lyricist
     lyrics
     media
+    movement
+    movement_name
+    movement_total
     publisher
     set_subtitle
+    show_movement
     url
+    work
 Additional `other` field names not documented above may be present, but are
 format-specific and may change or disappear in future tinytag releases. If
@@ -387,6 +391,31 @@ TinyTag.get(file_obj=your_file_obj)
 ## Changelog
+### 2.2.0  (2025-12-15)
+- Add support for movement, work and grouping fields
+- ID3: Make synced lyrics available in 'other.lyrics' (LRC format)
+- ID3: Continue reading after encountering empty frame
+- ID3: Fix frame reading when image parsing is disabled
+- ID3: Exclude more frames containing binary data
+- ID3: Avoid unnecessary string decoding
+- M4A: Support extended atom sizes
+- M4A: Ensure all field names are lowercase
+- OGG: Stop reading after reaching EOS page
+- Vorbis: Map UNSYNCEDLYRICS field to other.lyrics
+### 2.1.2  (2025-08-14)
+- M4A: Add a few missing additional metadata fields
+- M4A: Support '©com' composer atom
+- M4A: Fix reading of multi-value custom fields
+- M4A: Use correct encoding when reading data names
+- ID3: Don't read entire file to determine duration
+- ID3: Skip stray null byte before image data
+- Add missing `__version__` attribute
+- Avoid some unnecessary work in hot code paths
+- Improve a few incomplete type hints
 ### 2.1.1  (2025-04-23)
 - ID3: Stop removing 'b' character from strings

{tinytag-2.1.1 → tinytag-2.2.0}/pyproject.toml RENAMED Viewed

@@ -7,7 +7,6 @@ build-backend = "flit_core.buildapi"
 [project]
 name = "tinytag"
-version = "2.1.1"
 description = "Read audio file metadata"
 authors = [
     {name = "Tom Wallroth"},
@@ -36,6 +35,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "License :: OSI Approved :: MIT License",
     "Development Status :: 5 - Production/Stable",
     "Environment :: Web Environment",
@@ -50,6 +50,7 @@ classifiers = [
 license = {file = "LICENSE"}
 readme = "README.md"
 requires-python = ">=3.7"
+dynamic = ["version"]
 [project.urls]
 Homepage = "https://github.com/tinytag/tinytag"
@@ -58,8 +59,10 @@ Homepage = "https://github.com/tinytag/tinytag"
 tests = [
     "coverage",
     "mypy",
+    "mypy<1.19.0; platform_python_implementation == 'PyPy'",
     "pycodestyle",
-    "pylint"
+    "pylint",
+    "pyright"
 ]
 [tool.flit.sdist]
@@ -114,3 +117,13 @@ py-version = "3.7"
 [tool.mypy]
 strict = true
+[tool.coverage.report]
+exclude_lines = [
+    "if TYPE_CHECKING:"
+]
+precision = 2
+show_missing = true
+[tool.coverage.run]
+relative_files = true

{tinytag-2.1.1 → tinytag-2.2.0}/tinytag/__init__.py RENAMED Viewed

@@ -3,6 +3,8 @@
 """Audio file metadata reader."""
+__version__ = '2.2.0'
 from .tinytag import (
     TinyTag, Image, Images, OtherFields, OtherImages,
     TinyTagException, ParseError, UnsupportedFormatError

{tinytag-2.1.1 → tinytag-2.2.0}/tinytag/tinytag.py RENAMED Viewed

@@ -34,15 +34,19 @@ from io import BytesIO
 from os import PathLike, SEEK_CUR, SEEK_END, environ, fsdecode
 from struct import unpack
+TYPE_CHECKING = False
 # Lazy imports for type checking
-if False:  # pylint: disable=using-constant-test
+if TYPE_CHECKING:
     from collections.abc import Callable, Iterator  # pylint: disable-all
-    from typing import Any, BinaryIO, Dict, List
+    from typing import Any, BinaryIO, Dict, List, Union
     _StringListDict = Dict[str, List[str]]
     _ImageListDict = Dict[str, List["Image"]]
+    _DataTreeDict = Dict[
+        bytes, Union['_DataTreeDict', Callable[..., Dict[str, Any]]]]
 else:
-    _StringListDict = _ImageListDict = dict
+    _StringListDict = _ImageListDict = _DataTreeDict = dict
 # some of the parsers can print debug info
 _DEBUG = bool(environ.get('TINYTAG_DEBUG'))
@@ -105,7 +109,7 @@ class TinyTag:
         self._parse_tags = True
         self._load_image = False
         self._tags_parsed = False
-        self.__dict__: dict[str, str | float | Images | OtherFields]
+        self.__dict__: dict[str, str | float | Images | OtherFields | None]
     @classmethod
     def get(cls,
@@ -257,7 +261,7 @@ class TinyTag:
         self._parse_duration = duration
         self._load_image = image
         if self._filehandler is None:
-            return
+            raise ValueError("File handle is required")
         if tags:
             self._parse_tag(self._filehandler)
         if duration:
@@ -271,14 +275,11 @@ class TinyTag:
             fieldname = fieldname[len(self._OTHER_PREFIX):]
             if check_conflict and fieldname in self.__dict__:
                 fieldname = '_' + fieldname
-            other_values = self.other.get(fieldname, [])
-            if not isinstance(value, str) or value in other_values:
-                return
-            other_values.append(value)
+            if fieldname not in self.other:
+                self.other[fieldname] = []
+            self.other[fieldname].append(str(value))
             if _DEBUG:
-                print(
-                    f'Setting other field "{fieldname}" to "{other_values!r}"')
-            self.other[fieldname] = other_values
+                print(f'Adding value "{value} to field "{fieldname}"')
             return
         old_value = self.__dict__.get(fieldname)
         new_value = value
@@ -367,7 +368,7 @@ class Images:
         self.media: Image | None = None
         self.other: _ImageListDict = OtherImages()
-        self.__dict__: dict[str, Image | OtherImages]
+        self.__dict__: dict[str, Image | OtherImages | None]
     @property
     def any(self) -> Image | None:
@@ -486,9 +487,10 @@ class _MP4(TinyTag):
     }
     _VERSIONED_ATOMS = {b'meta', b'stsd'}  # those have an extra 4 byte header
     _FLAGGED_ATOMS = {b'stsd'}  # these also have an extra 4 byte header
+    _ILST_PATH = [b'ftyp', b'moov', b'udta', b'meta', b'ilst']
-    _audio_data_tree: dict[bytes, Any] | None = None
-    _meta_data_tree: dict[bytes, Any] | None = None
+    _audio_data_tree: _DataTreeDict | None = None
+    _meta_data_tree: _DataTreeDict | None = None
     def _determine_duration(self, fh: BinaryIO) -> None:
         # https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html
@@ -516,24 +518,32 @@ class _MP4(TinyTag):
                 b'\xa9ART': {b'data': _MP4._data_parser('artist')},
                 b'\xa9alb': {b'data': _MP4._data_parser('album')},
                 b'\xa9cmt': {b'data': _MP4._data_parser('comment')},
+                b'\xa9com': {b'data': _MP4._data_parser('composer')},
                 b'\xa9con': {b'data': _MP4._data_parser('other.conductor')},
-                # need test-data for this
-                # b'cpil':  {b'data': _MP4._data_parser('other.compilation')},
                 b'\xa9day': {b'data': _MP4._data_parser('year')},
                 b'\xa9des': {b'data': _MP4._data_parser('other.description')},
                 b'\xa9dir': {b'data': _MP4._data_parser('other.director')},
                 b'\xa9gen': {b'data': _MP4._data_parser('genre')},
+                b'\xa9grp': {b'data': _MP4._data_parser('other.grouping')},
                 b'\xa9lyr': {b'data': _MP4._data_parser('other.lyrics')},
-                b'\xa9mvn': {b'data': _MP4._data_parser('movement')},
+                b'\xa9mvc': {
+                    b'data': _MP4._data_parser('other.movement_total')
+                },
+                b'\xa9mvi': {b'data': _MP4._data_parser('other.movement')},
+                b'\xa9mvn': {
+                    b'data': _MP4._data_parser('other.movement_name')
+                },
                 b'\xa9nam': {b'data': _MP4._data_parser('title')},
                 b'\xa9pub': {b'data': _MP4._data_parser('other.publisher')},
                 b'\xa9too': {b'data': _MP4._data_parser('other.encoded_by')},
+                b'\xa9wrk': {b'data': _MP4._data_parser('other.work')},
                 b'\xa9wrt': {b'data': _MP4._data_parser('composer')},
                 b'aART': {b'data': _MP4._data_parser('albumartist')},
                 b'cprt': {b'data': _MP4._data_parser('other.copyright')},
                 b'desc': {b'data': _MP4._data_parser('other.description')},
                 b'disk': {b'data': _MP4._nums_parser('disc', 'disc_total')},
                 b'gnre': {b'data': _MP4._parse_id3v1_genre},
+                b'shwm': {b'data': _MP4._data_parser('other.show_movement')},
                 b'trkn': {b'data': _MP4._nums_parser('track', 'track_total')},
                 b'tmpo': {b'data': _MP4._data_parser('other.bpm')},
                 b'covr': {b'data': _MP4._parse_cover_image},
@@ -543,16 +553,21 @@ class _MP4(TinyTag):
     def _traverse_atoms(self,
                         fh: BinaryIO,
-                        path: dict[bytes, Any],
+                        path: _DataTreeDict,
                         stop_pos: int | None = None,
                         curr_path: list[bytes] | None = None) -> None:
-        header_len = 8
+        header_len = ext_size_len = 8
         atom_header = fh.read(header_len)
         while len(atom_header) == header_len:
-            atom_size = unpack('>I', atom_header[:4])[0] - header_len
+            atom_size = unpack('>I', atom_header[:4])[0]
             atom_type = atom_header[4:]
             if curr_path is None:  # keep track how we traversed in the tree
                 curr_path = [atom_type]
+            if atom_size == 1:  # 64-bit size
+                ext_size_header = fh.read(ext_size_len)
+                if len(ext_size_header) == ext_size_len:
+                    atom_size = unpack('>Q', ext_size_header)[0] - ext_size_len
+            atom_size -= header_len
             if atom_size <= 0:  # empty atom, jump to next one
                 atom_header = fh.read(header_len)
                 continue
@@ -562,8 +577,10 @@ class _MP4(TinyTag):
                       f'atom: {atom_type!r} len: {atom_size + header_len}')
             if atom_type in self._VERSIONED_ATOMS:  # jump atom version for now
                 fh.seek(4, SEEK_CUR)
+                atom_size -= 4
             if atom_type in self._FLAGGED_ATOMS:  # jump atom flags for now
                 fh.seek(4, SEEK_CUR)
+                atom_size -= 4
             sub_path = path.get(atom_type, None)
             # if the path leaf is a dict, traverse deeper into the tree:
             if isinstance(sub_path, dict):
@@ -575,13 +592,27 @@ class _MP4(TinyTag):
                 for fieldname, value in sub_path(fh.read(atom_size)).items():
                     if _DEBUG:
                         print(' ' * 4 * len(curr_path), 'FIELD: ', fieldname)
-                    if fieldname.startswith('images.'):
+                    if isinstance(value, Image):
                         if self._load_image:
                             # pylint: disable=protected-access
                             self.images._set_field(
                                 fieldname[len('images.'):], value)
-                    elif fieldname:
+                    elif isinstance(value, list):
+                        for subval in value:
+                            self._set_field(fieldname, subval)
+                    else:
                         self._set_field(fieldname, value)
+            # unknown data atom, try to parse it
+            elif curr_path == self._ILST_PATH:
+                atom_end_pos = fh.tell() + atom_size
+                field_name = (
+                    self._OTHER_PREFIX + atom_type.decode('latin-1').lower()
+                )
+                fh.seek(-header_len, SEEK_CUR)
+                self._traverse_atoms(
+                    fh,
+                    path={atom_type: {b'data': self._data_parser(field_name)}},
+                    stop_pos=atom_end_pos, curr_path=curr_path + [atom_type])
             # if no action was specified using dict or callable, jump over atom
             else:
                 fh.seek(atom_size, SEEK_CUR)
@@ -591,12 +622,8 @@ class _MP4(TinyTag):
             atom_header = fh.read(header_len)  # read next atom
     @classmethod
-    def _data_parser(
-        cls, fieldname: str
-    ) -> Callable[[bytes], dict[str, int | str | bytes | None]]:
-        def _parse_data_atom(
-            data_atom: bytes
-        ) -> dict[str, int | str | bytes | None]:
+    def _data_parser(cls, fieldname: str) -> Callable[[bytes], dict[str, str]]:
+        def _parse_data_atom(data_atom: bytes) -> dict[str, str]:
             data_type = unpack('>I', data_atom[:4])[0]
             data = data_atom[8:]
             value = None
@@ -607,7 +634,9 @@ class _MP4(TinyTag):
                 data_len = len(data)
                 if data_len in fmts:
                     value = str(unpack(fmts[data_len], data)[0])
-            return {fieldname: value}
+            if value:
+                return {fieldname: value}
+            return {}
         return _parse_data_atom
     @classmethod
@@ -645,13 +674,11 @@ class _MP4(TinyTag):
                 break
     @classmethod
-    def _parse_custom_field(
-        cls, data: bytes
-    ) -> dict[str, int | str | bytes | None]:
+    def _parse_custom_field(cls, data: bytes) -> dict[str, list[str]]:
         fh = BytesIO(data)
         header_len = 8
         field_name = None
-        data_atom = b''
+        values = []
         atom_header = fh.read(header_len)
         while len(atom_header) == header_len:
             atom_size = unpack('>I', atom_header[:4])[0] - header_len
@@ -662,15 +689,18 @@ class _MP4(TinyTag):
                 # pylint: disable=protected-access
                 field_name = cls._CUSTOM_FIELD_NAME_MAPPING.get(
                     field_name, TinyTag._OTHER_PREFIX + field_name)
-            elif atom_type == b'data':
+            elif atom_type == b'data' and field_name:
                 data_atom = fh.read(atom_size)
+                parser = cls._data_parser(field_name)
+                atom_values = parser(data_atom)
+                if field_name in atom_values:
+                    values.append(atom_values[field_name])
             else:
                 fh.seek(atom_size, SEEK_CUR)
             atom_header = fh.read(header_len)  # read next atom
-        if len(data_atom) < 8 or field_name is None:
-            return {}
-        parser = cls._data_parser(field_name)
-        return parser(data_atom)
+        if field_name and values:
+            return {field_name: values}
+        return {}
     @classmethod
     def _parse_audio_sample_entry_mp4a(cls, data: bytes) -> dict[str, int]:
@@ -727,31 +757,35 @@ class _ID3(TinyTag):
     _ID3_MAPPING = {
         # Mapping from Frame ID to a field of the TinyTag
         # https://exiftool.org/TagNames/ID3.html
-        'COMM': 'comment', 'COM': 'comment',
-        'TRCK': 'track', 'TRK': 'track',
-        'TYER': 'year', 'TYE': 'year', 'TDRC': 'year',
-        'TALB': 'album', 'TAL': 'album',
-        'TPE1': 'artist', 'TP1': 'artist',
-        'TIT2': 'title', 'TT2': 'title',
-        'TCON': 'genre', 'TCO': 'genre',
-        'TPOS': 'disc', 'TPA': 'disc',
-        'TPE2': 'albumartist', 'TP2': 'albumartist',
-        'TCOM': 'composer', 'TCM': 'composer',
-        'WOAR': 'other.url', 'WAR': 'other.url',
-        'TSRC': 'other.isrc', 'TRC': 'other.isrc',
-        'TCOP': 'other.copyright', 'TCR': 'other.copyright',
-        'TBPM': 'other.bpm', 'TBP': 'other.bpm',
-        'TKEY': 'other.initial_key', 'TKE': 'other.initial_key',
-        'TLAN': 'other.language', 'TLA': 'other.language',
-        'TPUB': 'other.publisher', 'TPB': 'other.publisher',
-        'USLT': 'other.lyrics', 'ULT': 'other.lyrics',
-        'TPE3': 'other.conductor', 'TP3': 'other.conductor',
-        'TEXT': 'other.lyricist', 'TXT': 'other.lyricist',
-        'TSST': 'other.set_subtitle',
-        'TENC': 'other.encoded_by', 'TEN': 'other.encoded_by',
-        'TSSE': 'other.encoder_settings', 'TSS': 'other.encoder_settings',
-        'TMED': 'other.media', 'TMT': 'other.media',
-        'WCOP': 'other.license',
+        b'COMM': 'comment', b'COM': 'comment',
+        b'TRCK': 'track', b'TRK': 'track',
+        b'TYER': 'year', b'TYE': 'year', b'TDRC': 'year',
+        b'TALB': 'album', b'TAL': 'album',
+        b'TPE1': 'artist', b'TP1': 'artist',
+        b'TIT2': 'title', b'TT2': 'title',
+        b'TCON': 'genre', b'TCO': 'genre',
+        b'TPOS': 'disc', b'TPA': 'disc',
+        b'TPE2': 'albumartist', b'TP2': 'albumartist',
+        b'TCOM': 'composer', b'TCM': 'composer',
+        b'WOAR': 'other.url', b'WAR': 'other.url',
+        b'TSRC': 'other.isrc', b'TRC': 'other.isrc',
+        b'TCOP': 'other.copyright', b'TCR': 'other.copyright',
+        b'TBPM': 'other.bpm', b'TBP': 'other.bpm',
+        b'TKEY': 'other.initial_key', b'TKE': 'other.initial_key',
+        b'TLAN': 'other.language', b'TLA': 'other.language',
+        b'TPUB': 'other.publisher', b'TPB': 'other.publisher',
+        b'USLT': 'other.lyrics', b'ULT': 'other.lyrics',
+        b'TPE3': 'other.conductor', b'TP3': 'other.conductor',
+        b'TEXT': 'other.lyricist', b'TXT': 'other.lyricist',
+        b'TSST': 'other.set_subtitle',
+        b'TENC': 'other.encoded_by', b'TEN': 'other.encoded_by',
+        b'TSSE': 'other.encoder_settings', b'TSS': 'other.encoder_settings',
+        b'TMED': 'other.media', b'TMT': 'other.media',
+        b'WCOP': 'other.license',
+        b'MVNM': 'other.movement_name',
+        b'MVIN': 'other.movement',
+        b'GRP1': 'modern_grouping', b'GP1': 'modern_grouping',
+        b'TIT1': 'legacy_grouping', b'TT1': 'legacy_grouping',
     }
     _ID3_MAPPING_CUSTOM = {
         'artists': 'artist',
@@ -759,23 +793,40 @@ class _ID3(TinyTag):
         'license': 'other.license',
         'barcode': 'other.barcode',
         'catalognumber': 'other.catalog_number',
+        'showmovement': 'other.show_movement'
     }
-    _IMAGE_FRAME_IDS = {'APIC', 'PIC'}
-    _CUSTOM_FRAME_IDS = {'TXXX', 'TXX'}
+    _EMPTY_FRAME_IDS = {b'\x00\x00\x00\x00', b'\x00\x00\x00'}
+    _IMAGE_FRAME_IDS = {b'APIC', b'PIC'}
+    _CUSTOM_FRAME_IDS = {b'TXXX', b'TXX'}
+    _SYNCED_LYRICS_FRAME_IDS = {b'SYLT', b'SLT'}
     _IGNORED_FRAME_IDS = {
-        'AENC', 'CRA',
-        'ATXT',
-        'CHAP',
-        'COMR',
-        'CRM',
-        'CTOC',
-        'ENCR',
-        'GEOB', 'GEO',
-        'GRID',
-        'MCDI', 'MCI',
-        'PRIV',
-        'RGAD',
-        'STC', 'SYTC'
+        b'AENC', b'CRA',
+        b'APIC', b'PIC',
+        b'ASPI',
+        b'ATXT',
+        b'CHAP',
+        b'COMR',
+        b'CRM',
+        b'CTOC',
+        b'ENCR',
+        b'EQU2', b'EQU',
+        b'ETCO', b'ETC',
+        b'GEOB', b'GEO',
+        b'GRID',
+        b'LINK', b'LNK',
+        b'MCDI', b'MCI',
+        b'MLLT', b'MLL',
+        b'PCNT', b'CNT',
+        b'POPM', b'POP',
+        b'POSS',
+        b'PRIV',
+        b'RBUF', b'BUF',
+        b'RGAD',
+        b'RVA2', b'RVA',
+        b'RVRB', b'REV',
+        b'SEEK',
+        b'SIGN',
+        b'SYTC', b'STC',
     }
     _ID3V1_TAG_SIZE = 128
     _MAX_ESTIMATION_SEC = 30.0
@@ -825,9 +876,9 @@ class _ID3(TinyTag):
         'Psybient',
     )
     _ID3V2_2_IMAGE_FORMATS = {
-        'bmp': 'image/bmp',
-        'jpg': 'image/jpeg',
-        'png': 'image/png',
+        b'bmp': 'image/bmp',
+        b'jpg': 'image/jpeg',
+        b'png': 'image/png',
     }
     _IMAGE_TYPES = (
         'other.generic',
@@ -892,6 +943,8 @@ class _ID3(TinyTag):
         super().__init__()
         # save position after the ID3 tag for duration measurement speedup
         self._bytepos_after_id3v2 = -1
+        self._modern_grouping_values: list[str] = []
+        self._legacy_grouping_values: list[str] = []
     @staticmethod
     def _parse_xing_header(fh: BinaryIO) -> tuple[int, int]:
@@ -917,20 +970,17 @@ class _ID3(TinyTag):
         max_estimation_frames = (
             (self._MAX_ESTIMATION_SEC * 44100) // self._SAMPLES_PER_FRAME)
         frame_size_accu = 0
-        audio_offset = 0
+        audio_offset = self._bytepos_after_id3v2
         frames = 0  # count frames for determining mp3 duration
         bitrate_accu = 0    # add up bitrates to find average bitrate to detect
         last_bitrates = set()  # CBR mp3s (multiple frames with same bitrates)
         # seek to first position after id3 tag (speedup for large header)
         first_mpeg_id = None
         fh.seek(self._bytepos_after_id3v2)
-        file_offset = fh.tell()
-        walker = BytesIO(fh.read())
         while True:
             # reading through garbage until 11 '1' sync-bits are found
-            header = walker.read(4)
+            header = fh.read(4)
             header_len = len(header)
-            walker.seek(-header_len, SEEK_CUR)
             if header_len < 4:
                 if frames:
                     self.bitrate = bitrate_accu / frames
@@ -949,10 +999,12 @@ class _ID3(TinyTag):
                     or mpeg_id == 1):
                 # invalid frame, find next sync header
                 idx = header.find(b'\xFF', 1)
-                if idx == -1:
-                    # not found: jump over the current peek buffer
-                    idx = header_len
-                walker.seek(max(idx, 1), SEEK_CUR)
+                next_offset = header_len
+                if idx != -1:
+                    next_offset -= idx
+                    fh.seek(idx - header_len, SEEK_CUR)
+                if frames == 0:
+                    audio_offset += next_offset
                 continue
             if first_mpeg_id is None:
                 first_mpeg_id = mpeg_id
@@ -964,12 +1016,12 @@ class _ID3(TinyTag):
             # all the info we need, otherwise parse multiple frames to find the
             # accurate average bitrate
             if frames == 0 and self._USE_XING_HEADER:
-                walker_offset = walker.tell()
-                frame_content = walker.read(frame_length)
+                prev_offset = header_len + audio_offset
+                frame_content = fh.read(frame_length)
                 xing_header_offset = frame_content.find(b'Xing')
                 if xing_header_offset != -1:
-                    walker.seek(walker_offset + xing_header_offset)
-                    xframes, byte_count = self._parse_xing_header(walker)
+                    fh.seek(prev_offset + xing_header_offset)
+                    xframes, byte_count = self._parse_xing_header(fh)
                     if xframes > 0 and byte_count > 0:
                         # MPEG-2 Audio Layer III uses 576 samples per frame
                         samples_pf = self._SAMPLES_PER_FRAME
@@ -978,12 +1030,10 @@ class _ID3(TinyTag):
                         self.duration = dur = xframes * samples_pf / samplerate
                         self.bitrate = byte_count * 8 / dur / 1000
                         return
-                walker.seek(walker_offset)
+                fh.seek(prev_offset)
             frames += 1  # it's most probably a mp3 frame
             bitrate_accu += frame_br
-            if frames == 1:
-                audio_offset = file_offset + walker.tell()
             if frames <= self._CBR_DETECTION_FRAME_COUNT:
                 last_bitrates.add(frame_br)
@@ -1002,7 +1052,7 @@ class _ID3(TinyTag):
                 return
             if frame_length > 1:  # jump over current frame body
-                walker.seek(frame_length, SEEK_CUR)
+                fh.seek(frame_length - header_len, SEEK_CUR)
         if self.samplerate:
             self.duration = frames * self._SAMPLES_PER_FRAME / self.samplerate
@@ -1039,13 +1089,15 @@ class _ID3(TinyTag):
             fh.seek(extd_size - 6, SEEK_CUR)  # jump over extended_header
         while parsed_size < size:
             frame_size = self._parse_frame(fh, size, id3version=major)
-            if frame_size == 0:
+            if frame_size == -1:
                 break
             parsed_size += frame_size
         fh.seek(end_pos)
+        self._set_grouping_work_fields()
     def _parse_id3v1(self, fh: BinaryIO) -> None:
-        if fh.read(3) != b'TAG':  # check if this is an ID3 v1 tag
+        content = fh.read(3 + 30 + 30 + 30 + 4 + 30 + 1)
+        if content[:3] != b'TAG':  # check if this is an ID3 v1 tag
             return
         def asciidecode(x: bytes) -> str:
@@ -1053,24 +1105,23 @@ class _ID3(TinyTag):
                 x.decode(self._default_encoding or 'latin1', 'replace'))
         # Only set fields that were not set by ID3v2 tags, as ID3v1
         # tags are more likely to be outdated or have encoding issues
-        fields = fh.read(30 + 30 + 30 + 4 + 30 + 1)
         if not self.title:
-            value = asciidecode(fields[:30])
+            value = asciidecode(content[3:33])
             if value:
                 self._set_field('title', value)
         if not self.artist:
-            value = asciidecode(fields[30:60])
+            value = asciidecode(content[33:63])
             if value:
                 self._set_field('artist', value)
         if not self.album:
-            value = asciidecode(fields[60:90])
+            value = asciidecode(content[63:93])
             if value:
                 self._set_field('album', value)
         if not self.year:
-            value = asciidecode(fields[90:94])
+            value = asciidecode(content[93:97])
             if value:
                 self._set_field('year', value)
-        comment = fields[94:124]
+        comment = content[97:127]
         if b'\x00\x00' < comment[-2:] < b'\x01\x00':
             if self.track is None:
                 self._set_field('track', ord(comment[-1:]))
@@ -1080,11 +1131,11 @@ class _ID3(TinyTag):
             if value:
                 self._set_field('comment', value)
         if not self.genre:
-            genre_id = ord(fields[124:125])
+            genre_id = ord(content[127:128])
             if genre_id < len(self._ID3V1_GENRES):
                 self._set_field('genre', self._ID3V1_GENRES[genre_id])
-    def __parse_custom_field(self, content: str) -> bool:
+    def _parse_custom_field(self, content: str) -> bool:
         custom_field_name, separator, value = content.partition('\x00')
         custom_field_name_lower = custom_field_name.lower()
         value = value.lstrip('\ufeff')
@@ -1096,6 +1147,18 @@ class _ID3(TinyTag):
             return True
         return False
+    def _set_grouping_work_fields(self) -> None:
+        # iTunes 12.5.4.42 added a new GRP1 frame for 'grouping', and
+        # repurposed the TIT1 frame for 'work'. Handle this mess here.
+        if self._modern_grouping_values:
+            for value in self._modern_grouping_values:
+                self._set_field('other.grouping', value)
+            for value in self._legacy_grouping_values:
+                self._set_field('other.work', value)
+            return
+        for value in self._legacy_grouping_values:
+            self._set_field('other.grouping', value)
     @classmethod
     def _create_tag_image(cls,
                           data: bytes,
@@ -1115,6 +1178,75 @@ class _ID3(TinyTag):
             image.description = description
         return field_name, image
+    def _parse_image(self,
+                     frame_id: bytes,
+                     content: bytes) -> tuple[str, Image]:
+        # See section 4.14: http://id3.org/id3v2.4.0-frames
+        encoding = content[:1]
+        if frame_id == b'PIC':  # ID3 v2.2:
+            imgformat = content[1:4].lower()
+            mime_type = self._ID3V2_2_IMAGE_FORMATS.get(imgformat)
+            # skip encoding (1), imgformat (3), pictype(1)
+            desc_start_pos = 5
+        else:  # ID3 v2.3+
+            mime_start_pos = 1
+            mime_end_pos = self._find_string_end_pos(
+                content, start_pos=mime_start_pos)
+            mime_type = self._decode_string(
+                content[mime_start_pos:mime_end_pos]).lower()
+            # skip mtype, pictype(1)
+            desc_start_pos = mime_end_pos + 1
+        pic_type = content[desc_start_pos - 1]
+        desc_end_pos = self._find_string_end_pos(
+            content, encoding, desc_start_pos)
+        # skip stray null byte in broken file
+        if (desc_end_pos + 1 < len(content)
+                and content[desc_end_pos] == 0
+                and content[desc_end_pos + 1] != 0):
+            desc_end_pos += 1
+        desc = self._decode_string(
+            encoding + content[desc_start_pos:desc_end_pos])
+        return self._create_tag_image(
+            content[desc_end_pos:], pic_type, mime_type, desc)
+    @staticmethod
+    def _lrc_timestamp(seconds: float) -> str:
+        cs = int(seconds * 100)
+        minutes, cs = divmod(cs, 6000)
+        seconds, cs = divmod(cs, 100)
+        return f"{minutes:02d}:{seconds:02d}.{cs:02d}"
+    def _parse_synced_lyrics(self, content: bytes) -> str:
+        # Convert ID3 synced lyrics to LRC format
+        content_length = len(content)
+        encoding = content[:1]
+        # skip language (3)
+        timestamp_format = content[4:5]
+        # skip content type (1)
+        start_pos = 6
+        end_pos = self._find_string_end_pos(content, encoding, start_pos)
+        lyrics = ""
+        offset = end_pos
+        found_line = False
+        while offset < content_length:
+            end_pos = self._find_string_end_pos(content, encoding, offset)
+            value = self._decode_string(
+                encoding + content[offset:end_pos]).lstrip('\n')
+            offset = end_pos
+            time = unpack('>I', content[offset:offset + 4])[0]
+            offset += 4
+            if found_line:
+                lyrics += '\n'
+            found_line = True
+            if timestamp_format == b'\x02':
+                # time in milliseconds
+                timestamp = self._lrc_timestamp(time / 1000)
+            else:
+                lyrics += value
+                continue
+            lyrics += f'[{timestamp}]{value}'
+        return lyrics
     def _parse_frame(self,
                      fh: BinaryIO,
                      total_size: int,
@@ -1125,8 +1257,10 @@ class _ID3(TinyTag):
         is_synchsafe_int = id3version == 4
         header = fh.read(header_len)
         if len(header) != header_len:
-            return 0
-        frame_id = self._decode_string(header[:frame_size_bytes])
+            return -1
+        frame_id = header[:frame_size_bytes]
+        if frame_id in self._EMPTY_FRAME_IDS:
+            return -1
         frame_size: int
         if frame_size_bytes == 3:
             frame_size = unpack('>I', b'\x00' + header[3:6])[0]
@@ -1135,25 +1269,22 @@ class _ID3(TinyTag):
         else:
             frame_size = unpack('>I', header[4:8])[0]
         if _DEBUG:
-            print(f'Found id3 Frame {frame_id} at '
+            print(f'Found id3 Frame {frame_id!r} at '
                   f'{fh.tell()}-{fh.tell() + frame_size} of {self.filesize}')
         if frame_size > total_size:
             # invalid frame size, stop here
-            return 0
-        content = fh.read(frame_size)
-        fieldname = self._ID3_MAPPING.get(frame_id)
+            return -1
         should_set_field = True
-        if fieldname:
-            if not self._parse_tags:
-                return frame_size
+        if self._parse_tags and frame_id in self._ID3_MAPPING:
+            fieldname = self._ID3_MAPPING[frame_id]
             language = fieldname in {'comment', 'other.lyrics'}
-            value = self._decode_string(content, language)
+            value = self._decode_string(fh.read(frame_size), language)
             if not value:
                 return frame_size
             if fieldname == "comment":
                 # check if comment is a key-value pair (used by iTunes)
-                should_set_field = not self.__parse_custom_field(value)
-            elif fieldname in {'track', 'disc'}:
+                should_set_field = not self._parse_custom_field(value)
+            elif fieldname in {'track', 'disc', 'other.movement'}:
                 if '/' in value:
                     value, total = value.split('/')[:2]
                     if total.isdecimal():
@@ -1174,54 +1305,52 @@ class _ID3(TinyTag):
                         genre_id = int(parens_text)
                 if 0 <= genre_id < len(self._ID3V1_GENRES):
                     value = self._ID3V1_GENRES[genre_id]
+            elif fieldname == 'modern_grouping':
+                self._modern_grouping_values.append(value)
+                should_set_field = False
+            elif fieldname == 'legacy_grouping':
+                self._legacy_grouping_values.append(value)
+                should_set_field = False
             if should_set_field:
                 self._set_field(fieldname, value)
-        elif frame_id in self._CUSTOM_FRAME_IDS:
+        elif self._parse_tags and frame_id in self._SYNCED_LYRICS_FRAME_IDS:
+            lyrics = self._parse_synced_lyrics(fh.read(frame_size))
+            self._set_field('other.lyrics', lyrics)
+        elif self._parse_tags and frame_id in self._CUSTOM_FRAME_IDS:
             # custom fields
-            if self._parse_tags:
-                value = self._decode_string(content)
-                if value:
-                    self.__parse_custom_field(value)
-        elif frame_id in self._IMAGE_FRAME_IDS:
-            if self._load_image:
-                # See section 4.14: http://id3.org/id3v2.4.0-frames
-                encoding = content[:1]
-                if frame_id == 'PIC':  # ID3 v2.2:
-                    imgformat = self._decode_string(content[1:4]).lower()
-                    mime_type = self._ID3V2_2_IMAGE_FORMATS.get(imgformat)
-                    # skip encoding (1), imgformat (3), pictype(1)
-                    desc_start_pos = 5
-                else:  # ID3 v2.3+
-                    mime_end_pos = content.index(b'\x00', 1)
-                    mime_type = self._decode_string(
-                        content[1:mime_end_pos]).lower()
-                    # skip mtype, pictype(1)
-                    desc_start_pos = mime_end_pos + 2
-                pic_type = content[desc_start_pos - 1]
-                # latin1 and utf-8 are 1 byte
-                if encoding in {b'\x00', b'\x03'}:
-                    desc_end_pos = content.find(b'\x00', desc_start_pos) + 1
-                else:
-                    desc_end_pos = 0
-                    for i in range(desc_start_pos, len(content), 2):
-                        if content[i:i + 2] == b'\x00\x00':
-                            desc_end_pos = i + 2
-                            break
-                desc = self._decode_string(
-                    encoding + content[desc_start_pos:desc_end_pos])
-                field_name, image = self._create_tag_image(
-                    content[desc_end_pos:], pic_type, mime_type, desc)
-                # pylint: disable=protected-access
-                self.images._set_field(field_name, image)
-        elif frame_id not in self._IGNORED_FRAME_IDS:
+            value = self._decode_string(fh.read(frame_size))
+            if value:
+                self._parse_custom_field(value)
+        elif self._parse_tags and frame_id not in self._IGNORED_FRAME_IDS:
             # unknown, try to add to other dict
-            if self._parse_tags:
-                value = self._decode_string(content)
-                if value:
-                    self._set_field(
-                        self._OTHER_PREFIX + frame_id.lower(), value)
+            value = self._decode_string(fh.read(frame_size))
+            if value:
+                self._set_field(
+                    self._OTHER_PREFIX + frame_id.decode('latin-1').lower(),
+                    value)
+        elif self._load_image and frame_id in self._IMAGE_FRAME_IDS:
+            field_name, image = self._parse_image(
+                frame_id, fh.read(frame_size))
+            # pylint: disable=protected-access
+            self.images._set_field(field_name, image)
+        else:  # skip frame
+            fh.seek(frame_size, SEEK_CUR)
         return frame_size
+    @staticmethod
+    def _find_string_end_pos(content: bytes,
+                             encoding: bytes = b'\x00',
+                             start_pos: int = 0) -> int:
+        # latin1 and utf-8 are 1 byte
+        if encoding in {b'\x00', b'\x03'}:
+            return content.find(b'\x00', start_pos) + 1
+        end_pos = 0
+        for i in range(start_pos, len(content), 2):
+            if content[i:i + 2] == b'\x00\x00':
+                end_pos = i + 2
+                break
+        return end_pos
     def _decode_string(self, value: bytes, language: bool = False) -> str:
         default_encoding = 'ISO-8859-1'
         if self._default_encoding:
@@ -1294,6 +1423,7 @@ class _Ogg(TinyTag):
         'copyright': 'other.copyright',
         'isrc': 'other.isrc',
         'lyrics': 'other.lyrics',
+        'unsyncedlyrics': 'other.lyrics',
         'publisher': 'other.publisher',
         'language': 'other.language',
         'director': 'other.director',
@@ -1310,6 +1440,13 @@ class _Ogg(TinyTag):
         'license': 'other.license',
         'barcode': 'other.barcode',
         'catalognumber': 'other.catalog_number',
+        'movementname': 'other.movement_name',
+        'movement': 'other.movement',
+        'movementtotal': 'other.movement_total',
+        'showmovement': 'other.show_movement',
+        'grouping': 'other.grouping',
+        'contentgroup': 'other.grouping',
+        'work': 'other.work'
     }
     def __init__(self) -> None:
@@ -1450,7 +1587,7 @@ class _Ogg(TinyTag):
                     elif value:
                         self._set_field(fieldname, value)
-    def _parse_pages(self, fh: BinaryIO) -> Iterator[bytes]:
+    def _parse_pages(self, fh: BinaryIO) -> Iterator[bytearray]:
         # for the spec, see: https://wiki.xiph.org/Ogg
         packet_data = bytearray()
         current_serial = None
@@ -1500,6 +1637,8 @@ class _Ogg(TinyTag):
                 else:
                     self._audio_size += last_audio_size
                     last_audio_size = audio_size
+            if eos:
+                break
             page_header = fh.read(header_len)
@@ -1552,7 +1691,7 @@ class _Wave(TinyTag):
             subchunk_size = unpack('I', chunk_header[4:])[0]
             # IFF chunks are padded to an even number of bytes
             subchunk_size += subchunk_size % 2
-            if subchunk_id == b'fmt ' and self._parse_duration:
+            if self._parse_duration and subchunk_id == b'fmt ':
                 chunk = fh.read(subchunk_size)
                 _format_tag, channels, samplerate = unpack('<HHI', chunk[:8])
                 bitdepth = unpack('<H', chunk[14:16])[0]
@@ -1563,14 +1702,14 @@ class _Wave(TinyTag):
                 self.bitrate = samplerate * channels * bitdepth / 1000
                 self.channels, self.samplerate, self.bitdepth = (
                     channels, samplerate, bitdepth)
-            elif subchunk_id == b'data' and self._parse_duration:
+            elif self._parse_duration and subchunk_id == b'data':
                 if (self.channels is not None and self.samplerate is not None
                         and self.bitdepth is not None):
                     self.duration = (
                         subchunk_size / self.channels / self.samplerate
                         / (self.bitdepth / 8))
                 fh.seek(subchunk_size, SEEK_CUR)
-            elif subchunk_id == b'LIST' and self._parse_tags:
+            elif self._parse_tags and subchunk_id == b'LIST':
                 chunk = fh.read(subchunk_size)
                 if chunk.startswith(b'INFO'):
                     walker = BytesIO(chunk)
@@ -1582,8 +1721,8 @@ class _Wave(TinyTag):
                         data_length += data_length % 2
                         # strip zero-byte
                         data = walker.read(data_length).split(b'\x00', 1)[0]
-                        fieldname = self._RIFF_MAPPING.get(field)
-                        if fieldname:
+                        if field in self._RIFF_MAPPING:
+                            fieldname = self._RIFF_MAPPING[field]
                             value = data.decode('utf-8', 'replace')
                             if fieldname == 'track':
                                 if value.isdecimal():
@@ -1591,7 +1730,7 @@ class _Wave(TinyTag):
                             else:
                                 self._set_field(fieldname, value)
                         field = walker.read(4)
-            elif subchunk_id in {b'id3 ', b'ID3 '} and self._parse_tags:
+            elif self._parse_tags and subchunk_id in {b'id3 ', b'ID3 '}:
                 # pylint: disable=protected-access
                 id3 = _ID3()
                 id3._filehandler = fh
@@ -1635,7 +1774,7 @@ class _Flac(TinyTag):
             is_last_block = block_header[0] & 0x80
             size = unpack('>I', b'\x00' + block_header[1:])[0]
             # http://xiph.org/flac/format.html#metadata_block_streaminfo
-            if block_type == self._STREAMINFO and self._parse_duration:
+            if self._parse_duration and block_type == self._STREAMINFO:
                 head = fh.read(size)
                 if len(head) < 34:  # invalid streaminfo
                     break
@@ -1665,13 +1804,13 @@ class _Flac(TinyTag):
                 self.samplerate = sr
                 if duration > 0:
                     self.bitrate = self.filesize * 8 / duration / 1000
-            elif block_type == self._VORBIS_COMMENT and self._parse_tags:
+            elif self._parse_tags and block_type == self._VORBIS_COMMENT:
                 # pylint: disable=protected-access
                 walker = BytesIO(fh.read(size))
                 oggtag = _Ogg()
                 oggtag._parse_vorbis_comment(walker)
                 self._update(oggtag)
-            elif block_type == self._PICTURE and self._load_image:
+            elif self._load_image and block_type == self._PICTURE:
                 fieldname, value = self._parse_image(fh)
                 # pylint: disable=protected-access
                 self.images._set_field(fieldname, value)
@@ -1730,6 +1869,8 @@ class _Wma(TinyTag):
         'WM/Media': 'other.media',
         'WM/Barcode': 'other.barcode',
         'WM/CatalogNo': 'other.catalog_number',
+        'WM/ContentGroupDescription': 'other.grouping',
+        'WM/Work': 'other.work'
     }
     _UNPACK_FORMATS = {
         1: '<B',
@@ -1765,7 +1906,7 @@ class _Wma(TinyTag):
             if object_size == 0 or object_size > self.filesize:
                 break  # invalid object, stop parsing.
             object_id = object_header[:16]
-            if object_id == self._ASF_CONTENT_DESC and self._parse_tags:
+            if self._parse_tags and object_id == self._ASF_CONTENT_DESC:
                 walker = BytesIO(fh.read(object_size - header_len))
                 (title_length, author_length,
                  copyright_length, description_length,
@@ -1782,7 +1923,7 @@ class _Wma(TinyTag):
                         walker.read(length).decode('utf-16', 'replace'))
                     if not i_field_name.startswith('_') and value:
                         self._set_field(i_field_name, value)
-            elif object_id == self._ASF_EXT_CONTENT_DESC and self._parse_tags:
+            elif self._parse_tags and object_id == self._ASF_EXT_CONTENT_DESC:
                 # http://web.archive.org/web/20131203084402/http://msdn.microsoft.com/en-us/library/bb643323.aspx#_Toc509555195
                 walker = BytesIO(fh.read(object_size - header_len))
                 descriptor_count = unpack('<H', walker.read(2))[0]
@@ -1804,8 +1945,9 @@ class _Wma(TinyTag):
                         walker.seek(value_len, SEEK_CUR)  # skip other values
                         continue
                     # try to get normalized field name
-                    field_name = self._ASF_MAPPING.get(name)
-                    if field_name is None:  # custom field
+                    if name in self._ASF_MAPPING:
+                        field_name = self._ASF_MAPPING[name]
+                    else:  # custom field
                         if name.startswith('WM/'):
                             name = name[3:]
                         field_name = self._OTHER_PREFIX + name.lower()
@@ -1814,13 +1956,13 @@ class _Wma(TinyTag):
                             self._set_field(field_name, int(value))
                     elif value:
                         self._set_field(field_name, value)
-            elif object_id == self._ASF_FILE_PROP and self._parse_duration:
+            elif self._parse_duration and object_id == self._ASF_FILE_PROP:
                 data = fh.read(object_size - header_len)
                 play_duration = unpack('<Q', data[40:48])[0] / 10000000
                 preroll = unpack('<Q', data[56:64])[0] / 1000
                 # subtract the preroll to get the actual duration
                 self.duration = max(play_duration - preroll, 0.0)
-            elif object_id == self._ASF_STREAM_PROPS and self._parse_duration:
+            elif self._parse_duration and object_id == self._ASF_STREAM_PROPS:
                 data = fh.read(object_size - header_len)
                 stream_type = data[:16]
                 if stream_type == self._STREAM_TYPE_ASF_AUDIO_MEDIA:
@@ -1876,11 +2018,11 @@ class _Aiff(TinyTag):
             subchunk_size = unpack('>I', chunk_header[4:])[0]
             # IFF chunks are padded to an even number of bytes
             subchunk_size += subchunk_size % 2
-            if subchunk_id in self._AIFF_MAPPING and self._parse_tags:
+            if self._parse_tags and subchunk_id in self._AIFF_MAPPING:
                 value = self._unpad(
                     fh.read(subchunk_size).decode('utf-8', 'replace'))
                 self._set_field(self._AIFF_MAPPING[subchunk_id], value)
-            elif subchunk_id == b'COMM' and self._parse_duration:
+            elif self._parse_duration and subchunk_id == b'COMM':
                 chunk = fh.read(subchunk_size)
                 channels, num_frames, bitdepth = unpack('>hLh', chunk[:8])
                 self.channels, self.bitdepth = channels, bitdepth
@@ -1894,7 +2036,7 @@ class _Aiff(TinyTag):
                         sr, duration, bitrate)
                 except OverflowError:
                     pass
-            elif subchunk_id in {b'id3 ', b'ID3 '} and self._parse_tags:
+            elif self._parse_tags and subchunk_id in {b'id3 ', b'ID3 '}:
                 # pylint: disable=protected-access
                 id3 = _ID3()
                 id3._filehandler = fh

{tinytag-2.1.1 → tinytag-2.2.0}/LICENSE RENAMED Viewed

File without changes

{tinytag-2.1.1 → tinytag-2.2.0}/tinytag/__main__.py RENAMED Viewed

File without changes

{tinytag-2.1.1 → tinytag-2.2.0}/tinytag/py.typed RENAMED Viewed

File without changes

tinytag 2.1.1__tar.gz → 2.2.0__tar.gz

Potentially problematic release.

tinytag 2.1.1tar.gz → 2.2.0tar.gz