trackparse 0.3.3__tar.gz → 0.5.0__tar.gz

{trackparse-0.3.3 → trackparse-0.5.0}/.gitignore

@@ -18,7 +18,6 @@ python/dist/
 
 # Rust
 target/
-rust/Cargo.lock
 
 # Editors / OS
 .DS_Store

{trackparse-0.3.3 → trackparse-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: trackparse
-Version: 0.3.3
+Version: 0.5.0
 Summary: Spec-driven parser for music track titles and tracklists: artists, feat, remixes, versions, junk, positions, times.
 Project-URL: Homepage, https://4matic.github.io/trackparse/
 Project-URL: Documentation, https://4matic.github.io/trackparse/start/getting-started/
@@ -54,7 +54,7 @@ doesn't recognise stays in the title, word for word.
 
 This is the Python port of [trackparse](https://github.com/4matic/trackparse). Its behaviour is
 defined by a [shared spec](https://github.com/4matic/trackparse/blob/main/spec/SPEC.md) and pinned
-by 12,965 fixtures. It passes all of them, and for every fixture input its output is byte-identical
+by 13,130 fixtures. It passes all of them, and for every fixture input its output is byte-identical
 to the JavaScript package.
 
 - Python 3.9 to 3.14
@@ -461,7 +461,7 @@ apply_edits(text, edits, *, <same options>) -> EditResult
 | Result | Fields |
 |---|---|
 | `Tracklist` | `spec_version`, `entries`, `warnings`, `stats` |
-| `TracklistEntry` | `line` (1-based), `kind` (`track`, `marker`, `header`, `link`, `note`, `blank`), `eol`, `raw`, `parts`, `time`, `track` (`ParsedTrack` or `None`) |
+| `TracklistEntry` | `line` (1-based), `kind` (`track`, `marker`, `header`, `link`, `note`, `blank`), `eol`, `raw`, `parts`, `time`, `track` (`ParsedTrack` or `None`), `layered` (the track text after any time starts with `w/`) |
 | `Parts` | `lead`, `time`, `gap`, `rest`, joined they give `raw` |
 | `TracklistWarning` | `code`, `line`, `severity` (`info` or `warning`), `suggestion` |
 | `TimeValue` | `raw`, `seconds` (`entry.time`, or `None` on untimed lines) |
@@ -469,6 +469,13 @@ apply_edits(text, edits, *, <same options>) -> EditResult
 | `Stats` | `lines`, `tracks`, `markers`, `timed`, `first_time`, `last_time` |
 | `EditResult` | `text`, `changed`, `warnings` (`EditWarning(code, edit, line)`) |
 
+Lists pasted with list bullets or Markdown emphasis (`* 14:21 Artist - Title`,
+`**[**14:21**] Artist - Title**`) read like plain lines; the decoration stays in `raw` and `parts`.
+A line whose track text (after any time) starts with `w/` is `layered`: a track played over the
+previous one
+([Markdown](https://4matic.github.io/trackparse/guides/tracklists/#markdown),
+[layered tracks](https://4matic.github.io/trackparse/guides/tracklists/#layered-tracks)).
+
 Warning codes: `time-missing`, `time-out-of-order`, `time-duplicate`, `no-start-at-zero`,
 `time-after-audio-end` (needs `audio_seconds`), `invalid-time`, `position-gap`,
 `position-duplicate`, `line-unparsed`. Edits: `set-time {line, seconds}`, `shift {seconds, lines? | from?}`

{trackparse-0.3.3 → trackparse-0.5.0}/README.md

@@ -21,7 +21,7 @@ doesn't recognise stays in the title, word for word.
 
 This is the Python port of [trackparse](https://github.com/4matic/trackparse). Its behaviour is
 defined by a [shared spec](https://github.com/4matic/trackparse/blob/main/spec/SPEC.md) and pinned
-by 12,965 fixtures. It passes all of them, and for every fixture input its output is byte-identical
+by 13,130 fixtures. It passes all of them, and for every fixture input its output is byte-identical
 to the JavaScript package.
 
 - Python 3.9 to 3.14
@@ -428,7 +428,7 @@ apply_edits(text, edits, *, <same options>) -> EditResult
 | Result | Fields |
 |---|---|
 | `Tracklist` | `spec_version`, `entries`, `warnings`, `stats` |
-| `TracklistEntry` | `line` (1-based), `kind` (`track`, `marker`, `header`, `link`, `note`, `blank`), `eol`, `raw`, `parts`, `time`, `track` (`ParsedTrack` or `None`) |
+| `TracklistEntry` | `line` (1-based), `kind` (`track`, `marker`, `header`, `link`, `note`, `blank`), `eol`, `raw`, `parts`, `time`, `track` (`ParsedTrack` or `None`), `layered` (the track text after any time starts with `w/`) |
 | `Parts` | `lead`, `time`, `gap`, `rest`, joined they give `raw` |
 | `TracklistWarning` | `code`, `line`, `severity` (`info` or `warning`), `suggestion` |
 | `TimeValue` | `raw`, `seconds` (`entry.time`, or `None` on untimed lines) |
@@ -436,6 +436,13 @@ apply_edits(text, edits, *, <same options>) -> EditResult
 | `Stats` | `lines`, `tracks`, `markers`, `timed`, `first_time`, `last_time` |
 | `EditResult` | `text`, `changed`, `warnings` (`EditWarning(code, edit, line)`) |
 
+Lists pasted with list bullets or Markdown emphasis (`* 14:21 Artist - Title`,
+`**[**14:21**] Artist - Title**`) read like plain lines; the decoration stays in `raw` and `parts`.
+A line whose track text (after any time) starts with `w/` is `layered`: a track played over the
+previous one
+([Markdown](https://4matic.github.io/trackparse/guides/tracklists/#markdown),
+[layered tracks](https://4matic.github.io/trackparse/guides/tracklists/#layered-tracks)).
+
 Warning codes: `time-missing`, `time-out-of-order`, `time-duplicate`, `no-start-at-zero`,
 `time-after-audio-end` (needs `audio_seconds`), `invalid-time`, `position-gap`,
 `position-duplicate`, `line-unparsed`. Edits: `set-time {line, seconds}`, `shift {seconds, lines? | from?}`

{trackparse-0.3.3 → trackparse-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trackparse"
-version = "0.3.3"
+version = "0.5.0"
 description = "Spec-driven parser for music track titles and tracklists: artists, feat, remixes, versions, junk, positions, times."
 readme = "README.md"
 requires-python = ">=3.9"

{trackparse-0.3.3 → trackparse-0.5.0}/src/trackparse/__init__.py

@@ -33,7 +33,7 @@ from .types import (
     Warning,
 )
 
-__version__ = "0.3.3"  # x-release-please-version
+__version__ = "0.5.0"  # x-release-please-version
 
 __all__ = [
     "SPEC_VERSION",

{trackparse-0.3.3 → trackparse-0.5.0}/src/trackparse/_data.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 from typing import Any
 
-SPEC_VERSION = "0.3.3"  # x-release-please-version
+SPEC_VERSION = "0.5.0"  # x-release-please-version
 
 # spec/data/descriptors.json
 DESCRIPTORS_DATA: dict[str, Any] = {
@@ -350,6 +350,13 @@ JUNK_DATA: dict[str, Any] = {
     ],
 }
 
+# spec/data/layered-words.json
+LAYERED_WORDS_DATA: dict[str, Any] = {
+    "words": [
+        "w/",
+    ],
+}
+
 # spec/data/marker-words.json
 MARKER_WORDS_DATA: dict[str, Any] = {
     "words": [

trackparse-0.5.0/src/trackparse/_tracklist_emphasis.py

@@ -0,0 +1,86 @@
+"""R13.12 Markdown emphasis markers in a tracklist line (js/src/tracklist/emphasis.ts)."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from ._words import char_at, is_whitespace
+
+
+def _run_length(s: str, at: int) -> int:
+    """Length of the maximal run of ``*`` or ``_`` at ``at`` (0 when there is none)."""
+    ch = char_at(s, at)
+    j = at
+    if ch == "*" or ch == "_":
+        n = len(s)
+        while j < n and s[j] == ch:
+            j += 1
+    return j - at
+
+
+def emphasis_run(s: str, at: int) -> int:
+    """R13.2.1 / R13.2.3: the length of an emphasis run at ``at`` (a maximal run of 1 or 2 ``*``
+    or ``_``), else 0. Used next to the time, where runs are read by position, not paired."""
+    n = _run_length(s, at)
+    return n if n <= 2 else 0
+
+
+def _is_outer(ch: Optional[str]) -> bool:
+    """R13.12.2 outer side: line edge, R0.2 whitespace, a bracket, or a ``*`` / ``_``."""
+    return ch is None or is_whitespace(ch) or ch in "[]()*_"
+
+
+def _is_inner(ch: Optional[str]) -> bool:
+    """R13.12.2 inner side: a character that is not R0.2 whitespace."""
+    return ch is not None and not is_whitespace(ch)
+
+
+def without_markers(raw: str, frm: int, open_run: Optional[str] = None) -> str:
+    """R13.12: ``raw[frm:]`` (the line's ``rest``) without its emphasis markers. A run of 1 or 2
+    ``*`` or ``_`` closes when the character before it is an inner side and the one after it an
+    outer side, and opens the other way round. A closer pairs with the nearest opener of the same
+    characters; that opener and every opener after it leave the stack. One stack per run keeps
+    this linear. Runs before ``frm`` (lead and gap) never pair, except that ``open_run``, a lead
+    run the gap left open (R13.12.4), pairs with a closing run of the same character at the end
+    of the line."""
+    n = len(raw)
+    marked = [False] * n
+    stacks: dict[str, list[int]] = {"*": [], "**": [], "_": [], "__": []}
+    i = frm
+    while i < n:
+        length = _run_length(raw, i) or 1
+        own = stacks.get(raw[i : i + length])
+        before = raw[i - 1] if i > 0 else None
+        after = char_at(raw, i + length)
+        at: Optional[int] = None
+        if own and _is_inner(before) and _is_outer(after):
+            at = own.pop()
+        if at is not None:
+            for m in range(length):
+                marked[at + m] = True
+                marked[i + m] = True
+            for st in stacks.values():
+                while st and st[-1] > at:
+                    st.pop()
+        elif own is not None and _is_outer(before) and _is_inner(after):
+            own.append(i)
+        i += length
+    # R13.12.4: the last run of the line, after which there is only R0.2 whitespace.
+    end = n
+    while end > frm and is_whitespace(raw[end - 1]):
+        end -= 1
+    start = end
+    while start > frm and raw[start - 1] == open_run:
+        start -= 1
+    if (
+        open_run is not None
+        and end - start <= 2
+        and start > frm
+        and raw[start - 1] != open_run
+        and _is_inner(raw[start - 1])
+    ):
+        m = start
+        while m < end and not marked[m]:
+            marked[m] = True
+            m += 1
+    return "".join(raw[k] for k in range(frm, n) if not marked[k])

{trackparse-0.3.3 → trackparse-0.5.0}/src/trackparse/_tracklist_kinds.py

@@ -4,12 +4,13 @@ from __future__ import annotations
 
 from typing import Optional
 
-from ._data import HEADER_WORDS_DATA, MARKER_WORDS_DATA
+from ._data import HEADER_WORDS_DATA, LAYERED_WORDS_DATA, MARKER_WORDS_DATA
 from ._tables import _str_list
 from ._words import PhraseTable, ascii_lower, in_vocab, is_whitespace, split_words
 from .types import ParsedTrack
 
 _HEADER_WORDS: frozenset[str] = frozenset(HEADER_WORDS_DATA["words"])
+_LAYERED_WORDS: frozenset[str] = frozenset(LAYERED_WORDS_DATA["words"])
 _default_markers: Optional[PhraseTable[bool]] = None
 
 
@@ -63,6 +64,24 @@ def marker_words(text: str) -> list[str]:
     return out
 
 
+def layered_prefix(text: str) -> int:
+    """R13.13: the length of a layered prefix at the start of the line text: R0.2 whitespace, a
+    word of ``data/layered-words.json`` (word key, R0.3), then R0.2 whitespace, with more text
+    after it. 0 when there is none."""
+    n = len(text)
+    i = 0
+    while i < n and is_whitespace(text[i]):
+        i += 1
+    j = i
+    while j < n and not is_whitespace(text[j]):
+        j += 1
+    if j in (i, n) or not in_vocab(text[i:j], _LAYERED_WORDS):
+        return 0
+    while j < n and is_whitespace(text[j]):
+        j += 1
+    return j if j < n else 0
+
+
 def is_blank(raw: str) -> bool:
     """R13.3.1"""
     return all(is_whitespace(c) for c in raw)

{trackparse-0.3.3 → trackparse-0.5.0}/src/trackparse/_tracklist_parse.py

@@ -13,6 +13,7 @@ from ._tracklist_kinds import (
     is_blank,
     is_header,
     is_link,
+    layered_prefix,
     marker_table,
 )
 from ._tracklist_options import ResolvedOptions
@@ -30,11 +31,13 @@ class _Row:
         "blank",
         "candidate",
         "dash",
+        "layered",
         "line",
         "marker",
         "probe",
         "scan",
         "separated",
+        "text",
         "track",
     )
 
@@ -42,6 +45,11 @@ class _Row:
         self.line = line
         self.scan = scan
         self.blank = blank
+        layered = 0 if blank else layered_prefix(scan.text)
+        #: R13.4.1 line text: rest without emphasis markers (R13.12) and a layered prefix (R13.13).
+        self.text = scan.text[layered:]
+        #: R13.13
+        self.layered = layered > 0
         #: R13.4.2
         self.candidate = False
         self.dash = False
@@ -68,11 +76,12 @@ def parse_tracklist_resolved(text: str, opts: ResolvedOptions) -> Tracklist:
         rows.append(row)
         if row.blank:
             continue
-        probe = lp.probe(scan.parts.rest)
+        probe = lp.probe(row.text)  # R13.4.1
         row.probe = probe
         row.dash = probe.spaced_dash
         row.candidate = scan.time is not None or row.dash
-        row.bare = bare_candidate(scan.parts.rest, probe.position)  # R13.5
+        # R13.5 / R13.13.3: a layered line never has a bare position.
+        row.bare = None if row.layered else bare_candidate(row.text, probe.position)
     candidates = 0
     dashes = 0
     for r in rows:
@@ -84,15 +93,16 @@ def parse_tracklist_resolved(text: str, opts: ResolvedOptions) -> Tracklist:
     list_context = candidates > 0 and 2 * dashes >= candidates
 
     # R13.5: confirmed bare positions are removed before parsing. R13.4.1: one parse per line.
-    confirmed = confirm_positions([r.bare for r in rows], [r.candidate for r in rows])
+    # R13.13.3: layered lines are not neighbours for the R13.5 search.
+    confirmed = confirm_positions(
+        [r.bare for r in rows], [r.candidate and not r.layered for r in rows]
+    )
     for i, r in enumerate(rows):
         if r.blank or r.probe is None:
             continue
         bare = r.bare if confirmed[i] else None
         probe = lp.probe(bare.stripped) if bare is not None else r.probe
-        r.marker = has_marker_word(
-            bare.stripped if bare is not None else r.scan.parts.rest, markers
-        )
+        r.marker = has_marker_word(bare.stripped if bare is not None else r.text, markers)
         # R13.4.2: the R6.10 tight dash only on timed lines without a marker word.
         track = probe.finish(list_context and r.scan.time is not None and not r.marker)
         if bare is not None:
@@ -114,6 +124,7 @@ def parse_tracklist_resolved(text: str, opts: ResolvedOptions) -> Tracklist:
                 parts=r.scan.parts,
                 time=r.scan.time,
                 track=r.track if keep else None,
+                layered=r.layered,
             )
         )
 
@@ -138,10 +149,9 @@ def _kind_of(r: _Row) -> EntryKind:
     marker = not r.separated and r.marker
     if r.scan.time is not None:
         return "marker" if marker else "track"
-    rest = r.scan.parts.rest
-    if is_link(rest):
+    if is_link(r.text):
         return "link"
-    if is_header(rest):
+    if is_header(r.text):
         return "header"
     if marker:
         return "marker"

{trackparse-0.3.3 → trackparse-0.5.0}/src/trackparse/_tracklist_times.py

@@ -6,6 +6,7 @@ import math
 from typing import NamedTuple, Optional
 
 from ._digits import digit_run
+from ._tracklist_emphasis import emphasis_run, without_markers
 from ._tracklist_types import Parts, TimeValue
 from ._words import char_at, is_digit, is_whitespace
 
@@ -33,6 +34,8 @@ class TimeScan(NamedTuple):
     style: Optional[TimeStyle]
     #: R13.2.4: a ``digits:digits`` shape after lead that fails R13.2.2.
     invalid: bool
+    #: R13.12: ``rest`` without its paired emphasis markers (the line text, before R13.13 / R13.5).
+    text: str
 
 
 def _is_gap_separator(ch: Optional[str]) -> bool:
@@ -49,7 +52,7 @@ def _skip_whitespace(s: str, frm: int) -> int:
 
 
 def _is_bullet(ch: Optional[str]) -> bool:
-    """R13.2.1 bullets of a line without a time."""
+    """R13.2.1 bullets (before a time, or alone on a line without one)."""
     return ch == "-" or ch == "–" or ch == "—" or ch == "*" or ch == "•"
 
 
@@ -61,7 +64,20 @@ def _untimed(raw: str, invalid: bool) -> TimeScan:
     lead_end = 0
     if _is_bullet(char_at(raw, at)) and is_whitespace(char_at(raw, at + 1)):
         lead_end = _skip_whitespace(raw, at + 1)
-    return TimeScan(Parts(raw[:lead_end], "", "", raw[lead_end:]), None, None, invalid)
+    return TimeScan(
+        Parts(raw[:lead_end], "", "", raw[lead_end:]),
+        None,
+        None,
+        invalid,
+        without_markers(raw, lead_end),
+    )
+
+
+def _closing_run(raw: str, at: int, open_ch: Optional[str]) -> int:
+    """R13.2.3: a closing run for an opening run of ``open_ch`` (same character, 1 or 2 long)."""
+    if open_ch is None or char_at(raw, at) != open_ch:
+        return at
+    return at + emphasis_run(raw, at)
 
 
 def seconds_of(whole: int, frac: str) -> float:
@@ -113,12 +129,28 @@ def shape_seconds(parts: list[str]) -> Optional[int]:
 
 def scan_time(raw: str) -> TimeScan:
     """R13.2: lead, time and gap at the start of ``raw``; the rest is everything after."""
-    # R13.2.1 lead: whitespace, then an optional `[` / `(`.
+    # R13.2.1 lead: whitespace, an optional bullet, an optional emphasis run, an optional `[` /
+    # `(`, then (after a bracket) another optional emphasis run. A run counts only when the next
+    # character is a bracket (first run) or a digit.
     i = _skip_whitespace(raw, 0)
+    if _is_bullet(char_at(raw, i)) and is_whitespace(char_at(raw, i + 1)):
+        i = _skip_whitespace(raw, i + 1)
+    outer_open: Optional[str] = None
+    n = emphasis_run(raw, i)
+    if n:
+        after = char_at(raw, i + n)
+        if after == "[" or after == "(" or is_digit(after):
+            outer_open = raw[i]
+            i += n
     first_ch = char_at(raw, i)
     closer = "]" if first_ch == "[" else ")" if first_ch == "(" else None
+    inner_open: Optional[str] = None
     if closer is not None:
         i += 1
+        n = emphasis_run(raw, i)
+        if n and is_digit(char_at(raw, i + n)):
+            inner_open = raw[i]
+            i += n
     lead_end = i
 
     # R13.2.2 time
@@ -141,13 +173,32 @@ def scan_time(raw: str) -> TimeScan:
             j += 1 + n
     time_end = j
 
-    # R13.2.3 gap
+    # R13.2.3 gap: closing runs for the lead's runs (same character), around the closing bracket.
+    def follows_time(at: int) -> bool:
+        return at >= len(raw) or is_whitespace(raw[at]) or _is_gap_separator(raw[at])
+
+    # R13.12.4: a lead run the gap leaves open may pair with a run at the end of the line.
+    open_run: Optional[str] = None
     if closer is not None:
+        k = _closing_run(raw, j, inner_open)
+        if k == j:
+            open_run = inner_open
+        j = k
         if char_at(raw, j) != closer:
             return _untimed(raw, False)
         j += 1
-    elif j < len(raw) and not is_whitespace(raw[j]) and not _is_gap_separator(raw[j]):
-        return _untimed(raw, False)
+        k = _closing_run(raw, j, outer_open)
+        if k > j and follows_time(k):
+            j = k
+        elif outer_open is not None:
+            open_run = outer_open
+    else:
+        k = _closing_run(raw, j, outer_open)
+        if k == j:
+            open_run = outer_open
+        j = k
+        if not follows_time(j):
+            return _untimed(raw, False)
     j = _skip_whitespace(raw, j)
     if _is_gap_separator(char_at(raw, j)):
         j = _skip_whitespace(raw, j + 1)
@@ -181,6 +232,7 @@ def scan_time(raw: str) -> TimeScan:
             frac_digits=len(frac),
         ),
         False,
+        without_markers(raw, j, open_run),
     )
 
 

{trackparse-0.3.3 → trackparse-0.5.0}/src/trackparse/_tracklist_types.py

@@ -77,6 +77,8 @@ class TracklistEntry:
     time: Optional[TimeValue]
     #: The line's ParsedTrack (``track`` and ``marker`` entries only).
     track: Optional[ParsedTrack]
+    #: R13.13: the line starts with ``w/``: played over the previous track.
+    layered: bool
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -87,6 +89,7 @@ class TracklistEntry:
             "parts": self.parts.to_dict(),
             "time": None if self.time is None else self.time.to_dict(),
             "track": None if self.track is None else self.track.to_dict(),
+            "layered": self.layered,
         }
 
 

{trackparse-0.3.3 → trackparse-0.5.0}/src/trackparse/_tracklist_warnings.py

@@ -181,7 +181,8 @@ def tracklist_warnings(
     timed = [i for i, e in enumerate(entries) if e.time is not None]
 
     for i, e in enumerate(entries):
-        if e.kind == "track" and e.time is None and len(timed) > 0:
+        # R13.13.3: an untimed layered line plays over the previous track, at its time.
+        if e.kind == "track" and e.time is None and not e.layered and len(timed) > 0:
             add(i, "time-missing")
         if invalid[i]:
             add(i, "invalid-time")