tocparser 0.1.0__py3-none-any.whl

tocparser/serializer.py

@@ -0,0 +1,243 @@
+"""Render :class:`~tocparser.models.Toc` objects back to TOC file text.
+
+The layout follows the files cdrdao itself writes: two-space nesting inside
+``CD_TEXT``, binary CD-TEXT arrays wrapped at twelve values per line, and both
+of the comments cdrdao generates -- a ``// Track N`` header before each track
+and a ``// length in bytes:`` annotation on data lengths. Comments written by
+hand are not preserved, so serializing is meaning-preserving rather than
+byte-exact. Text is written as UTF-8, as cdrdao 1.2.5 and later write it.
+"""
+
+from __future__ import annotations
+
+import re
+from os import PathLike
+from pathlib import Path
+
+from tocparser.errors import TocValidationError
+from tocparser.models import (
+    CdText,
+    CdTextValue,
+    DataFile,
+    Fifo,
+    File,
+    Silence,
+    Start,
+    Toc,
+    Track,
+    TrackMode,
+    TrackStatement,
+    Zero,
+)
+from tocparser.times import Msf, Time
+
+__all__ = ["dump", "dumps"]
+
+_INDENT = "  "
+_BINARY_VALUES_PER_LINE = 12
+_BINARY_CONTINUATION_INDENT = " " * 15
+
+# A backslash before three digits, any other backslash, and a quote.
+_TO_ESCAPE_RE = re.compile(r'(\\(?=[0-9]{3}))|(\\)|(")')
+
+
+def escape(text: str) -> str:
+    """Escape *text* so cdrdao reads it back unchanged.
+
+    A quote and a backslash are escaped with a backslash, except a backslash
+    followed by three digits: cdrdao reads that as an octal escape even when
+    the backslash was itself escaped, so it is written as ``\\134``, the octal
+    escape for a backslash. cdrdao rejects octal escapes in text holding
+    non-ASCII characters, so such text cannot be written at all.
+    """
+
+    def replace(match: re.Match[str]) -> str:
+        if match[1] is not None:
+            if not text.isascii():
+                raise TocValidationError(
+                    f"Cannot write {text!r}: a backslash followed by three digits "
+                    "needs an octal escape, which cdrdao rejects in non-ASCII text."
+                )
+            return "\\134"
+        return "\\" + match[0]
+
+    return _TO_ESCAPE_RE.sub(replace, text)
+
+
+def _quote(text: str) -> str:
+    return f'"{escape(text)}"'
+
+
+def _binary(name: str, values: list[int], indent: str) -> list[str]:
+    if not values:
+        return [f"{indent}{name} {{}}"]
+    lines: list[str] = []
+    for offset in range(0, len(values), _BINARY_VALUES_PER_LINE):
+        chunk = values[offset : offset + _BINARY_VALUES_PER_LINE]
+        if offset == 0:
+            # The opening brace supplies the padding of the first value, so
+            # cdrdao writes that one bare and pads the rest to two columns.
+            rendered = str(chunk[0]) + "".join(f", {value:2d}" for value in chunk[1:])
+            prefix = f"{indent}{name} {{ "
+        else:
+            # On a continued line every value is padded, the first included,
+            # which only shows once a line begins with more than one digit.
+            rendered = ", ".join(f"{value:2d}" for value in chunk)
+            prefix = _BINARY_CONTINUATION_INDENT
+        suffix = "," if offset + _BINARY_VALUES_PER_LINE < len(values) else "}"
+        lines.append(f"{prefix}{rendered}{suffix}")
+    return lines
+
+
+def _cd_text_value(name: str, value: CdTextValue, indent: str) -> list[str]:
+    if isinstance(value, str):
+        return [f"{indent}{name} {_quote(value)}"]
+    return _binary(name, value, indent)
+
+
+def _cd_text(cd_text: CdText) -> list[str]:
+    lines = ["CD_TEXT {"]
+    if cd_text.language_map:
+        lines.append(f"{_INDENT}LANGUAGE_MAP {{")
+        for number, code in cd_text.language_map.items():
+            lines.append(f"{_INDENT * 2}{number}: {code}")
+        lines.append(f"{_INDENT}}}")
+    for number, block in cd_text.blocks.items():
+        lines.append(f"{_INDENT}LANGUAGE {number} {{")
+        if block.encoding is not None:
+            lines.append(f"{_INDENT * 2}{block.encoding.value}")
+        for name, value in block.items.items():
+            lines.extend(_cd_text_value(name.value, value, _INDENT * 2))
+        lines.append(f"{_INDENT}}}")
+    lines.append("}")
+    return lines
+
+
+def _byte_length(length: Time, track: Track) -> int:
+    """The count cdrdao annotates a data length with.
+
+    On an audio track cdrdao counts samples rather than bytes while still
+    labeling the comment "length in bytes"; that quirk is reproduced here so
+    the output matches.
+    """
+    if not isinstance(length, Msf):
+        return length
+    if track.mode is TrackMode.AUDIO:
+        return length.to_samples()
+    return length.to_bytes(track.block_size)
+
+
+def _length_comment(length: Time, track: Track) -> str:
+    return f" // length in bytes: {_byte_length(length, track)}"
+
+
+def _statement(statement: TrackStatement, track: Track) -> str:
+    if isinstance(statement, File):
+        parts = [
+            "AUDIOFILE" if statement.audiofile else "FILE",
+            _quote(statement.filename),
+        ]
+        if statement.swap:
+            parts.append("SWAP")
+        if statement.offset is not None:
+            parts.append(f"#{statement.offset}")
+        parts.append(str(statement.start))
+        if statement.length is not None:
+            parts.append(str(statement.length))
+        return " ".join(parts)
+
+    if isinstance(statement, DataFile):
+        parts = ["DATAFILE", _quote(statement.filename)]
+        if statement.offset is not None:
+            parts.append(f"#{statement.offset}")
+        if statement.length is None:
+            return " ".join(parts)
+        parts.append(str(statement.length))
+        line = " ".join(parts)
+        # cdrdao annotates data lengths, but not ones it wrote as FILE.
+        if track.mode is not TrackMode.AUDIO:
+            line += _length_comment(statement.length, track)
+        return line
+
+    if isinstance(statement, Fifo):
+        line = f"FIFO {_quote(statement.filename)} {statement.length}"
+        # cdrdao only annotates a FIFO whose length lands on a block boundary,
+        # which is exactly when it writes the length as MSF.
+        if isinstance(statement.length, Msf):
+            line += _length_comment(statement.length, track)
+        return line
+
+    if isinstance(statement, Silence):
+        return f"SILENCE {statement.length}"
+
+    if isinstance(statement, Zero):
+        parts = ["ZERO"]
+        if statement.data_mode is not None:
+            parts.append(statement.data_mode.value)
+        if statement.sub_channel_mode is not None:
+            parts.append(statement.sub_channel_mode.value)
+        parts.append(str(statement.length))
+        return " ".join(parts)
+
+    if isinstance(statement, Start):
+        return "START" if statement.position is None else f"START {statement.position}"
+
+    # Every other statement returned above, so this is an End.
+    return "END" if statement.position is None else f"END {statement.position}"
+
+
+def _track(track: Track) -> list[str]:
+    header = f"TRACK {track.mode.value}"
+    if track.sub_channel_mode is not None:
+        header += f" {track.sub_channel_mode.value}"
+    lines = [header]
+
+    if track.copy_permitted is not None:
+        lines.append("COPY" if track.copy_permitted else "NO COPY")
+    if track.pre_emphasis is not None:
+        lines.append("PRE_EMPHASIS" if track.pre_emphasis else "NO PRE_EMPHASIS")
+    if track.channels is not None:
+        lines.append(
+            "FOUR_CHANNEL_AUDIO" if track.channels == 4 else "TWO_CHANNEL_AUDIO"
+        )
+    if track.isrc is not None:
+        lines.append(f"ISRC {_quote(track.isrc)}")
+    if track.cd_text is not None:
+        lines.extend(_cd_text(track.cd_text))
+    if track.pregap is not None:
+        lines.append(f"PREGAP {track.pregap}")
+
+    lines.extend(_statement(statement, track) for statement in track.statements)
+    lines.extend(f"INDEX {index}" for index in track.indexes)
+    return lines
+
+
+def dumps(toc: Toc) -> str:
+    """Render *toc* as TOC file text.
+
+    Models can be changed after they are built, so *toc* is validated again
+    first: an invalid one raises instead of producing a file cdrdao rejects.
+    """
+    toc = Toc.model_validate(toc.model_dump())
+    lines = [flag.value for flag in toc.superseded_disc_types]
+    lines += [toc.disc_type.value, ""]
+    if toc.catalog is not None:
+        lines.append(f"CATALOG {_quote(toc.catalog)}")
+    if toc.first_track_number is not None:
+        lines.append(f"FIRST_TRACK_NO {toc.first_track_number}")
+    if toc.cd_text is not None:
+        lines.extend(_cd_text(toc.cd_text))
+
+    number = toc.first_track_number if toc.first_track_number is not None else 1
+    for offset, track in enumerate(toc.tracks):
+        lines.append("")
+        lines.append(f"// Track {number + offset}")
+        lines.extend(_track(track))
+        lines.append("")
+
+    return "\n".join(lines) + "\n"
+
+
+def dump(toc: Toc, path: str | PathLike[str], *, encoding: str = "utf-8") -> None:
+    """Write *toc* to the file at *path*."""
+    Path(path).write_text(dumps(toc), encoding=encoding)

tocparser/times.py

@@ -0,0 +1,92 @@
+"""Time values used in TOC files.
+
+A position or a length is written either as an ``MM:SS:FF`` triple counting
+frames (also called blocks) at 75 frames per second, or as a bare integer.
+A bare integer means *samples* for audio tracks and *bytes* for data tracks,
+so the two forms are not interchangeable: a sample count that is not frame
+aligned has no MSF representation. Both forms are therefore preserved as
+written, and :data:`Time` is the union of the two.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import TypeAlias
+
+from tocparser.errors import TocValidationError
+
+__all__ = [
+    "FRAMES_PER_SECOND",
+    "SAMPLES_PER_FRAME",
+    "SECONDS_PER_MINUTE",
+    "Msf",
+    "Time",
+]
+
+FRAMES_PER_SECOND = 75
+SECONDS_PER_MINUTE = 60
+#: 44100 Hz / 75 frames per second.
+SAMPLES_PER_FRAME = 588
+
+_MSF_RE = re.compile(r"\A([0-9]+):([0-9]+):([0-9]+)\Z")
+
+
+@dataclass(frozen=True, order=True)
+class Msf:
+    """A position or length expressed as minutes, seconds and frames."""
+
+    minutes: int
+    seconds: int
+    frames: int
+
+    def __post_init__(self) -> None:
+        for field in (self.minutes, self.seconds, self.frames):
+            if isinstance(field, bool) or not isinstance(field, int):
+                raise TypeError(f"MSF fields must be integers, not {field!r}")
+        if self.minutes < 0:
+            raise TocValidationError(f"Illegal minute field: {self.minutes}")
+        if not 0 <= self.seconds < SECONDS_PER_MINUTE:
+            raise TocValidationError(f"Illegal second field: {self.seconds}")
+        if not 0 <= self.frames < FRAMES_PER_SECOND:
+            raise TocValidationError(f"Illegal fraction field: {self.frames}")
+
+    @property
+    def total_frames(self) -> int:
+        """The value as a plain frame (block) count."""
+        return (
+            self.minutes * SECONDS_PER_MINUTE + self.seconds
+        ) * FRAMES_PER_SECOND + self.frames
+
+    @classmethod
+    def from_frames(cls, frames: int) -> Msf:
+        """Build an :class:`Msf` from a frame count."""
+        if frames < 0:
+            raise TocValidationError(f"Illegal frame count: {frames}")
+        minutes, rest = divmod(frames, FRAMES_PER_SECOND * SECONDS_PER_MINUTE)
+        seconds, remaining_frames = divmod(rest, FRAMES_PER_SECOND)
+        return cls(minutes, seconds, remaining_frames)
+
+    @classmethod
+    def parse(cls, text: str) -> Msf:
+        """Parse an ``MM:SS:FF`` string."""
+        match = _MSF_RE.match(text)
+        if match is None:
+            raise TocValidationError(f"Illegal MSF value: {text}")
+        return cls(int(match[1]), int(match[2]), int(match[3]))
+
+    def to_samples(self) -> int:
+        """The value as a count of 16-bit stereo samples."""
+        return self.total_frames * SAMPLES_PER_FRAME
+
+    def to_bytes(self, block_size: int) -> int:
+        """The value as a byte count, given a track's block size."""
+        return self.total_frames * block_size
+
+    def __str__(self) -> str:
+        return f"{self.minutes:02d}:{self.seconds:02d}:{self.frames:02d}"
+
+
+#: A position or length, either frame-based (:class:`Msf`) or a raw
+#: sample/byte count.
+Time: TypeAlias = Msf | int

tocparser-0.1.0.dist-info/METADATA

@@ -0,0 +1,205 @@
+Metadata-Version: 2.4
+Name: tocparser
+Version: 0.1.0
+Summary: Parse, validate, and write cdrdao CD TOC files
+Keywords: audio,cd,cd-text,cdrdao,parser,toc
+Author: Jean-Marc Fontaine
+Author-email: Jean-Marc Fontaine <jm@jmfontaine.net>
+License-Expression: Apache-2.0
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: Python :: 3.15
+Classifier: Topic :: Multimedia :: Sound/Audio :: CD Audio
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: lark>=1.2
+Requires-Dist: pydantic>=2.9
+Requires-Dist: pydantic>=2.14.0b1,<2.15 ; python_full_version == '3.15.*'
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# tocparser
+
+tocparser parses cdrdao's TOC files into Pydantic models and writes them back out.
+
+- It supports the full TOC format. Older files mostly parse the same, with two
+  exceptions described below.
+- It validates files like cdrdao, matching its error messages and line numbers. See
+  Limits for exceptions.
+- Writing preserves every value. Unedited files usually serialize byte for byte
+  identically, though hand-written comments are dropped and some formatting is
+  normalized. See What Is Written Back for details.
+- It is fully typed and depends only on `lark` and `pydantic`.
+
+## Install
+
+```
+uv add tocparser
+```
+
+Requires Python 3.10 or newer.
+
+## Usage
+
+```python
+from tocparser import dump, parse_file
+
+toc = parse_file("the_downward_spiral.toc")
+
+toc.disc_type                    # <DiscType.CD_DA: 'CD_DA'>
+toc.catalog                      # '0602498647295'
+toc.cd_text[0].title             # 'The Downward Spiral - Deluxe Edition [ Disc 1 ] '
+toc.cd_text[0].performer         # 'Nine Inch Nails'
+
+track = toc.tracks[4]
+track.mode                       # <TrackMode.AUDIO: 'AUDIO'>
+track.isrc                       # 'USIR19400529'
+track.cd_text[0].title           # 'Closer'
+track.content[0].start           # Msf(minutes=15, seconds=47, frames=32)
+track.content[0].length          # Msf(minutes=6, seconds=13, frames=23)
+
+# "The Becoming" starts with a 00:02:30 pre-gap: 2 seconds and 30 frames.
+toc.tracks[6].start              # Start(kind='start', position=Msf(minutes=0, seconds=2, frames=30))
+```
+
+Models are ordinary Pydantic models, so `model_dump()`, `model_dump_json()` and
+`Toc.model_validate_json()` all work and preserve the parsed values.
+
+### Times
+
+A position or length can be written as `MM:SS:FF`, where frames are counted at 75 per
+second, or as a bare integer representing samples on an audio track and bytes on a data
+track. These formats are not interchangeable. If a sample count is not frame-aligned, it
+has no `MM:SS:FF` equivalent, so tocparser preserves the format in which it was written.
+Frame-based values become `Msf`, while bare integers remain `int`.
+
+```python
+from tocparser import Msf
+
+position = Msf(15, 47, 32)       # where "Closer" starts
+position.total_frames            # 71057
+position.to_samples()            # 41781516
+position.to_bytes(2352)          # 167126064
+str(position)                    # '15:47:32'
+Msf.from_frames(71057)           # Msf(minutes=15, seconds=47, frames=32)
+```
+
+`Msf` is ordered and hashable, so positions sort and can be used as keys.
+
+### CD-TEXT
+
+CD-TEXT values are `str`, or `list[int]` for binary packs. Each language block uses
+ISO-8859-1 unless the disc's `CD_TEXT` specifies an `ENCODING_*` value. Track blocks
+follow the disc block with the same number, as they do in cdrdao.
+`toc.cd_text_encoding(n)` returns the encoding used for block `n`.
+
+Strings follow cdrdao's rules. Non-ASCII text is UTF-8 and must fit the block's
+encoding: `TITLE "日本"` requires `ENCODING_MS_JIS`, because ISO-8859-1 cannot represent
+Japanese. Plain ASCII strings may contain `\NNN` octal escapes, which represent bytes in
+the block's encoding. For example, `"caf\351"` decodes to `'café'`, and under
+`ENCODING_MS_JIS`, `"\223\372\226\173"` decodes to `'日本'`.
+
+cdrdao treats `UPC_EAN` and `ISRC` as the same pack, as well as `RESERVED4` and
+`CLOSED`. A block retains the spelling written last, and `block.upc_ean` and
+`block.isrc` both access it.
+
+### Errors
+
+```python
+from tocparser import TocParseError, TocValidationError, parse
+
+parse(
+    'CD_DA\nCATALOG "0602498647"\nTRACK AUDIO\nFILE "hurt.wav" 0\n',
+    filename="the_downward_spiral.toc",
+)
+# TocValidationError: the_downward_spiral.toc:2: Illegal catalog number: 0602498647.
+```
+
+`TocParseError` covers syntax errors and `TocValidationError` covers input that parses
+but breaks a rule cdrdao enforces. Both derive from `TocError` and carry `line`, and
+`TocParseError` also carries `column`. `parse_file` reads files as UTF-8 and raises
+`TocParseError` for bytes that do not decode; pass `encoding=` for other encodings.
+
+The models enforce the same rules, so building one by hand that cdrdao would reject
+raises `TocValidationError`, whose `loc` locates the problem inside that model, e.g.
+`("statements", 2)`. A value cdrdao's syntax cannot express, such as a value of the
+wrong type or a negative number, raises Pydantic's `ValidationError` instead. Models can
+be changed after they are built, so `dumps` validates its argument again before writing
+it.
+
+## What Is Written Back
+
+Serializing preserves meaning, though not always the exact bytes. In practice, the
+output is usually byte-for-byte identical. Differences are limited to the following:
+
+- Hand-written comments are dropped. cdrdao-generated comments—the `// Track N` headers
+  and the `// length in bytes:` annotations on data lengths—are regenerated.
+- `MM:SS:FF` values are zero-padded: `0:10:0` becomes `00:10:00`. Bare integers remain
+  unchanged.
+- When a CD-TEXT item appears more than once, only its last instance is written. An
+  empty string does not replace an earlier value because cdrdao drops it. Repeated
+  LANGUAGE blocks are merged into the first, as in cdrdao's output.
+- Text is written as UTF-8, so `\NNN` escapes are replaced by the characters they
+  represent. A backslash followed by three digits is written as `\134`, because cdrdao
+  would interpret even an escaped backslash as an octal escape. cdrdao does not accept
+  escapes in non-ASCII text, so such text cannot contain that sequence; `dumps` raises
+  an error if it does.
+- Unwritten flags are not added. A track without a `COPY` line keeps
+  `copy_permitted is None` and has no `COPY` line in the output. The effective values
+  are available through `is_copy_permitted`, `has_pre_emphasis`, and `channel_count`.
+
+## Limits
+
+tocparser follows cdrdao 1.2.6, but some checks require the audio and data files
+referenced by a TOC file. Because tocparser reads only the TOC file, it cannot check the
+four-second minimum track length, an `INDEX` beyond the track end, `START` or `END` past
+the track end, an `END` within the pre-gap, or a requested length that exceeds the file.
+It also skips the CD-TEXT completeness checks that cdrdao performs only before writing a
+disc. tocparser checks everything else that `cdrdao show-toc` checks, with these
+differences:
+
+- If a file contains several errors, tocparser raises one, but not necessarily the one
+  cdrdao reports first.
+- For two syntax errors—a `PREGAP` after track data and a `LANGUAGE_MAP` inside a
+  track's `CD_TEXT`—cdrdao's parser stops at a different token than tocparser does.
+- cdrdao reports a `FIFO` that mixes audio and data on line 0; tocparser reports the
+  `FIFO`'s own line.
+- tocparser rejects `\NNN` bytes that are not text in their block's encoding—for
+  example, a lone CP932 lead byte or a byte above 127 in an `ENCODING_ASCII` block.
+  cdrdao keeps these bytes, at most issuing a warning, but could not read back the text
+  it would write for them.
+- cdrdao drops CD-TEXT items with empty strings. tocparser preserves an empty item when
+  no other value is provided and writes it back. Like cdrdao, it also allows a track to
+  contain an empty item that is valid only at the disc level.
+- Escapes in file names are decoded like CD-TEXT (as ISO-8859-1) and written back as
+  UTF-8.
+
+## TOC Files from Older cdrdao
+
+Files written by cdrdao 1.2.2 through 1.2.4 are mostly read the same way, with two
+exceptions that also apply to later releases. Releases before 1.2.2 were not checked.
+
+- cdrdao 1.2.2 through 1.2.4 wrote backslashes in strings unchanged. Since 1.2.5, a
+  backslash must begin an escape, so `"AC\DC"` is rejected with `Illegal token: \`, and
+  `"C:\\x"` now reads as `C:\x`, with one backslash rather than two. This applies to all
+  strings, including file names.
+- cdrdao 1.2.2 through 1.2.4 wrote bytes above 127 as octal escapes, at least under the
+  default C locale, and omitted `ENCODING_*`, so the text is read as ISO-8859-1. Latin
+  text remains intact, but text in another encoding, such as Japanese, does not.
+
+## Contributing
+
+Contributions are welcome. See CONTRIBUTING.md for development setup, test comparisons
+between tocparser and cdrdao, and the pull request process.
+
+## License
+
+tocparser is licensed under the Apache License 2.0.

tocparser-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+tocparser/__init__.py,sha256=Lfkz-I8Uw1zm_dPEw70Q3sueITHaSv-cywUQrfOjyAk,1507
+tocparser/errors.py,sha256=0BytexY4nto_T_xQtK7OznGDuBUXRAMXDic2_H4tayU,2018
+tocparser/grammar.lark,sha256=r2oZBBw5m3MMdvEwp-Ze5zeq8HuX2q7UUTq83OxamDo,3378
+tocparser/models.py,sha256=DBMXRS8ukNiuROmYKKRP94xm-5mwl-v_04la5cEUPDY,24044
+tocparser/parser.py,sha256=nUplKjFmSf_hir1l5iQ518GK4Kwqw8gLQ38EquQwDtE,25154
+tocparser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tocparser/serializer.py,sha256=qBGJHsYYrK4Ki_un-xmZN3HWjTZ2G6IvnEK2KwbJQfY,8922
+tocparser/times.py,sha256=fW74lwKNKswwHIIhTjuYiNTl8g34Lm7uWIoPK965Sao,3174
+tocparser-0.1.0.dist-info/licenses/LICENSE.txt,sha256=ZoQz6-YuMRvk-tumxl2wKZptFZmNbfSXfIKx3nUz4Rs,11347
+tocparser-0.1.0.dist-info/WHEEL,sha256=e4_1dyBeezi8ZjfxrZ3bnVOxFDa3ksqVqH0jTHkUZ3k,81
+tocparser-0.1.0.dist-info/METADATA,sha256=6fzCg5ZC5kt_kuPVcLNkWwqLBb3ZPequpQbVZbPEat4,9478
+tocparser-0.1.0.dist-info/RECORD,,

tocparser-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.19
+Root-Is-Purelib: true
+Tag: py3-none-any