trackparse 0.2.0__py3-none-any.whl

trackparse/_tables.py

@@ -0,0 +1,228 @@
+"""Vocabulary tables compiled from spec/data, optionally extended by ``keywords`` (R12)."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Optional
+
+from ._data import (
+    DESCRIPTORS_DATA,
+    EXTENSIONS_DATA,
+    FEAT_MARKERS_DATA,
+    GENRES_DATA,
+    JOINERS_DATA,
+    JUNK_DATA,
+    NO_SPLIT_BEFORE_DATA,
+    PLATFORM_SUFFIXES_DATA,
+    STOPWORDS_DATA,
+    UNKNOWN_TOKENS_DATA,
+    VERSION_KEYWORDS_DATA,
+)
+from ._words import PhraseTable, ascii_lower, js_trim
+
+
+class SpacedJoiner:
+    __slots__ = ("canonical", "case_sensitive", "is_and", "raw")
+
+    def __init__(self, raw: str, canonical: str, is_and: bool, case_sensitive: bool) -> None:
+        self.raw = raw
+        self.canonical = canonical
+        self.is_and = is_and
+        self.case_sensitive = case_sensitive
+
+
+class RunInfo:
+    """Category of a word in the modifier run left of a version head (R5.7.2)."""
+
+    __slots__ = ("descriptor", "genre", "head", "type_capable")
+
+    def __init__(
+        self,
+        type_capable: Optional[str] = None,
+        descriptor: Optional[str] = None,
+        genre: bool = False,
+        head: Optional[str] = None,
+    ) -> None:
+        self.type_capable = type_capable
+        self.descriptor = descriptor
+        self.genre = genre
+        self.head = head
+
+
+class Tables:
+    __slots__ = (
+        "bracket_only_feat",
+        "extensions",
+        "feat_canonical",
+        "feat_markers",
+        "generic_head_types",
+        "heads",
+        "junk_connectors",
+        "junk_or_genre",
+        "junk_phrases",
+        "label_suffixes",
+        "no_split_before",
+        "platform_suffixes",
+        "prefix_forms",
+        "producer_markers",
+        "run_words",
+        "spaced_joiners",
+        "stopwords",
+        "tight_joiners",
+        "title_feat_markers",
+        "title_producer_markers",
+        "unknown_case_insensitive",
+        "unknown_case_sensitive",
+    )
+
+    feat_markers: PhraseTable[bool]
+    bracket_only_feat: PhraseTable[bool]
+    producer_markers: PhraseTable[bool]
+    #: R8.3: the only unbracketed feat markers on the title side (+ keywords feat_markers).
+    title_feat_markers: PhraseTable[bool]
+    #: R8.3: the only unbracketed producer markers on the title side.
+    title_producer_markers: PhraseTable[bool]
+    #: Junk phrases plus genres (kind ``genre``): the R5.1 tokenizer vocabulary.
+    junk_or_genre: PhraseTable[str]
+    #: Junk phrases only (R8.4).
+    junk_phrases: PhraseTable[str]
+    junk_connectors: frozenset[str]
+    label_suffixes: frozenset[str]
+    heads: PhraseTable[str]
+    generic_head_types: frozenset[str]
+    #: Everything allowed in the R5.7.2 modifier run, keyed by phrase.
+    run_words: PhraseTable[RunInfo]
+    prefix_forms: PhraseTable[str]
+    spaced_joiners: list[SpacedJoiner]
+    tight_joiners: dict[str, str]
+    feat_canonical: str
+    no_split_before: frozenset[str]
+    stopwords: frozenset[str]
+    unknown_case_sensitive: frozenset[str]
+    unknown_case_insensitive: frozenset[str]
+    extensions: frozenset[str]
+    platform_suffixes: list[str]
+
+
+def _is_array_index(key: str) -> bool:
+    if not key or len(key) > 10 or not all("0" <= c <= "9" for c in key):
+        return False
+    if len(key) > 1 and key[0] == "0":
+        return False
+    return int(key) <= 0xFFFFFFFE
+
+
+def js_entries(d: Mapping[str, Any]) -> list[tuple[str, Any]]:
+    """``Object.entries`` order: integer-like keys first (ascending), then insertion order."""
+    items = list(d.items())
+    ints = sorted((kv for kv in items if _is_array_index(kv[0])), key=lambda kv: int(kv[0]))
+    return ints + [kv for kv in items if not _is_array_index(kv[0])]
+
+
+def _str_list(value: Any) -> list[str]:
+    if not isinstance(value, (list, tuple)):
+        return []
+    return [s for s in value if isinstance(s, str)]
+
+
+def _str_map(value: Any) -> list[tuple[str, str]]:
+    if not isinstance(value, Mapping):
+        return []
+    return [(k, v) for k, v in js_entries(value) if isinstance(k, str) and isinstance(v, str)]
+
+
+def _lower_keys(value: Any) -> list[str]:
+    return [k for k in (js_trim(ascii_lower(s)) for s in _str_list(value)) if len(k) > 0]
+
+
+def build_tables(keywords: Optional[Mapping[str, Any]] = None) -> Tables:
+    kw: Mapping[str, Any] = keywords if isinstance(keywords, Mapping) else {}
+    t = Tables()
+    extra_feat = _lower_keys(kw.get("feat_markers"))
+    t.feat_markers = PhraseTable((m, True) for m in [*FEAT_MARKERS_DATA["markers"], *extra_feat])
+    t.bracket_only_feat = PhraseTable((m, True) for m in FEAT_MARKERS_DATA["bracketOnly"])
+    t.producer_markers = PhraseTable((m, True) for m in FEAT_MARKERS_DATA["producer"])
+    t.title_feat_markers = PhraseTable(
+        (m, True) for m in [*FEAT_MARKERS_DATA["titleMarkers"], *extra_feat]
+    )
+    t.title_producer_markers = PhraseTable((m, True) for m in FEAT_MARKERS_DATA["titleProducer"])
+
+    junk_entries: list[tuple[str, str]] = [
+        *js_entries(JUNK_DATA["phrases"]),
+        *_str_map(kw.get("junk")),
+    ]
+    genres: list[str] = [*GENRES_DATA["genres"], *_lower_keys(kw.get("genres"))]
+    t.junk_phrases = PhraseTable(junk_entries)
+    # Junk phrases are added first, so they win over an identical genre key.
+    t.junk_or_genre = PhraseTable([*junk_entries, *((g, "genre") for g in genres)])
+
+    head_entries: list[tuple[str, str]] = [
+        *js_entries(VERSION_KEYWORDS_DATA["heads"]),
+        *_str_map(kw.get("version_heads")),
+    ]
+    t.heads = PhraseTable(head_entries)
+
+    run_info: dict[str, RunInfo] = {}
+
+    def note(key: str, **patch: Any) -> None:
+        k = js_trim(ascii_lower(key))
+        info = run_info.get(k)
+        if info is None:
+            info = RunInfo()
+        merged = RunInfo(info.type_capable, info.descriptor, info.genre, info.head)
+        for name, value in patch.items():
+            setattr(merged, name, value)
+        run_info[k] = merged
+
+    for k, typ in js_entries(VERSION_KEYWORDS_DATA["typeCapableModifiers"]):
+        note(k, type_capable=typ)
+    for d in [*DESCRIPTORS_DATA["descriptors"], *_lower_keys(kw.get("descriptors"))]:
+        note(d, descriptor=js_trim(ascii_lower(d)))
+    for g in genres:
+        note(g, genre=True)
+    for k, typ in head_entries:
+        note(k, head=typ)
+
+    t.junk_connectors = frozenset(JUNK_DATA["connectors"])
+    t.label_suffixes = frozenset(JUNK_DATA["labelSuffixes"])
+    t.generic_head_types = frozenset(VERSION_KEYWORDS_DATA["genericHeads"])
+    t.run_words = PhraseTable(run_info.items())
+    t.prefix_forms = PhraseTable(js_entries(VERSION_KEYWORDS_DATA["prefixForms"]))
+    t.spaced_joiners = [
+        SpacedJoiner(
+            j["raw"],
+            j["canonical"],
+            j.get("kind") == "and",
+            j.get("caseSensitive") is True,
+        )
+        for j in JOINERS_DATA["spaced"]
+    ]
+    t.tight_joiners = {j["raw"]: j["canonical"] for j in JOINERS_DATA["tight"]}
+    t.feat_canonical = JOINERS_DATA["featCanonical"]
+    t.no_split_before = frozenset(NO_SPLIT_BEFORE_DATA["words"])
+    t.stopwords = frozenset(STOPWORDS_DATA["words"])
+    t.unknown_case_sensitive = frozenset(UNKNOWN_TOKENS_DATA["caseSensitive"])
+    t.unknown_case_insensitive = frozenset(UNKNOWN_TOKENS_DATA["caseInsensitive"])
+    t.extensions = frozenset(EXTENSIONS_DATA["extensions"])
+    # JS sorts by UTF-16 length; the suffixes are ASCII, so code-point length is the same.
+    t.platform_suffixes = sorted(PLATFORM_SUFFIXES_DATA["suffixes"], key=lambda s: -len(s))
+    return t
+
+
+_default_tables: Optional[Tables] = None
+
+
+def get_default_tables() -> Tables:
+    global _default_tables
+    if _default_tables is None:
+        _default_tables = build_tables()
+    return _default_tables
+
+
+def tables_for(keywords: Optional[Mapping[str, Any]]) -> Tables:
+    return build_tables(keywords) if keywords else get_default_tables()
+
+
+def is_unknown_token(text: str, t: Tables) -> bool:
+    """R7.5 / R8.6: an unknown placeholder name (``ID``, ``???``, ``Untitled``…)."""
+    return text in t.unknown_case_sensitive or ascii_lower(text) in t.unknown_case_insensitive

trackparse/_title.py

@@ -0,0 +1,246 @@
+"""R8: the title side."""
+
+from __future__ import annotations
+
+from typing import NamedTuple
+
+from ._classify import Feat, Flag, Junk, Producer, Site, VersionDraft, Versions, Year, classify
+from ._context import Ctx
+from ._credits import Credit, ListOptions, PositionedYear, split_credits
+from ._mode import PositionedJunk
+from ._scanner import (
+    PH,
+    Skel,
+    cut_skel,
+    groups_of,
+    remove_groups,
+    render_skel,
+    slice_skel,
+    split_at_spaced_dashes,
+    trim_skel,
+)
+from ._separator import Peeled, peel_suffixes
+from ._tables import is_unknown_token
+from ._words import char_at, collapse_spaces, word_spans
+
+
+class Extracted:
+    """Everything the title side (and R6.2 peeling) can extract."""
+
+    __slots__ = ("clean", "credits", "explicit", "junk", "unknown_artist", "versions", "years")
+
+    def __init__(self) -> None:
+        self.credits: list[Credit] = []
+        self.versions: list[VersionDraft] = []
+        self.junk: list[PositionedJunk] = []
+        self.years: list[PositionedYear] = []
+        self.explicit = False
+        self.clean = False
+        self.unknown_artist = False
+
+    def set_flag(self, flag: str) -> None:
+        if flag == "explicit":
+            self.explicit = True
+        else:
+            self.clean = True
+
+
+def add_peeled(out: Extracted, peeled: list[Peeled]) -> None:
+    """Record R6.2 / R8.2 peeled dash suffixes."""
+    for p in peeled:
+        c = p.cls
+        if isinstance(c, Versions):
+            out.versions.extend(c.versions)
+        elif isinstance(c, Junk):
+            out.junk.append(PositionedJunk(p.raw, c.junk_kind, p.pos))
+        elif isinstance(c, Flag):
+            out.set_flag(c.flag)
+        else:
+            out.years.append(PositionedYear(c.year, p.pos))
+
+
+class TitleSideResult(NamedTuple):
+    title: str
+    unknown_title: bool
+
+
+def parse_title_side(
+    skel: Skel, relaxed: bool, youtube: bool, out: Extracted, ctx: Ctx
+) -> TitleSideResult:
+    """``relaxed``: an artist side was split off (R8.2 peels without conditions)."""
+    removed = _extract_groups(skel, out, ctx)  # R8.1
+
+    # R8.2
+    segments = split_at_spaced_dashes(skel)
+    remaining, peeled = peel_suffixes(segments, relaxed, ctx)
+    add_peeled(out, peeled)
+    skel = slice_skel(skel, 0, remaining[-1].end)
+
+    skel = _extract_unbracketed_credits(skel, out, ctx)  # R8.3
+    skel = remove_groups(skel, removed)
+    if youtube:
+        skel = _strip_trailing_junk(skel, out, ctx)  # R8.4
+
+    title = cleanup_title(render_skel(skel))  # R8.5
+    return TitleSideResult(title, len(title) > 0 and is_unknown_token(title, ctx.t))  # R8.6
+
+
+def _extract_groups(skel: Skel, out: Extracted, ctx: Ctx) -> set[int]:
+    """R8.1: classify every group; returns the positions of the groups to remove."""
+    removed: set[int] = set()
+    for _, group in groups_of(skel):
+        c = classify(group.inner, Site("title", group.open, group.pos), ctx)
+        if isinstance(c, Versions):
+            out.versions.extend(c.versions)
+        elif isinstance(c, Junk):
+            out.junk.append(PositionedJunk(group.inner, c.junk_kind, group.pos))
+        elif isinstance(c, Flag):
+            out.set_flag(c.flag)
+        elif isinstance(c, Year):
+            out.years.append(PositionedYear(c.year, group.pos))
+        elif isinstance(c, (Feat, Producer)):
+            out.credits.extend(c.credits)
+            out.years.extend(c.years)
+            if c.unknown:
+                out.unknown_artist = True
+        else:
+            continue
+        removed.add(group.pos)
+    return removed
+
+
+class _MarkerHit(NamedTuple):
+    start: int
+    end: int
+    marker: str
+    role: str  # "featured" | "producer"
+
+
+def _title_markers(s: Skel, ctx: Ctx) -> list[_MarkerHit]:
+    """R8.3 markers, left to right, each with a space on both sides: feat markers from
+    ``#titleMarkers`` (``feat.``, ``ft.``, ``featuring``; undotted ``feat``/``ft`` stay text)
+    and producer markers from ``#titleProducer``."""
+    spans = word_spans(s.text)
+    words = [w.text for w in spans]
+    hits: list[_MarkerHit] = []
+    i = 0
+    while i < len(spans):
+        span = spans[i]
+        if char_at(s.text, span.start - 1) != " ":
+            i += 1
+            continue
+        role = "featured"
+        feat = ctx.t.title_feat_markers.match_at(words, i)
+        if feat is not None:
+            last_index = i + feat.length - 1
+        else:
+            prod = ctx.t.title_producer_markers.match_at(words, i)
+            if prod is None:
+                i += 1
+                continue
+            role = "producer"
+            last_index = i + prod.length - 1
+        last = spans[last_index]
+        if char_at(s.text, last.end) != " ":
+            i += 1
+            continue
+        hits.append(_MarkerHit(span.start, last.end, s.text[span.start : last.end], role))
+        i = last_index + 1
+    return hits
+
+
+def _extract_unbracketed_credits(inp: Skel, out: Extracted, ctx: Ctx) -> Skel:
+    """R8.3: ``Title feat. X``, ``Title prod. by Y`` → credits, removed from the title. A list
+    runs to the next placeholder, the next marker of the other kind, or the end; later feat
+    markers inside a featured list are joiners (R7.2)."""
+    markers = _title_markers(inp, ctx)
+    cuts: list[tuple[int, int]] = []
+    i = 0
+    while i < len(markers):
+        hit = markers[i]
+        list_end = inp.text.find(PH, hit.end)
+        if list_end < 0:
+            list_end = len(inp.text)
+        other = next(
+            (
+                m
+                for k, m in enumerate(markers)
+                if k > i and m.role != hit.role and m.start >= hit.end
+            ),
+            None,
+        )
+        if other is not None and other.start < list_end:
+            list_end = other.start
+        lst = trim_skel(slice_skel(inp, hit.end, list_end))
+        if len(lst.text) > 0:
+            r = split_credits(
+                lst,
+                ListOptions(hit.role, "title", hit.marker, False, hit.role == "featured"),
+                ctx,
+            )
+            out.credits.extend(r.credits)
+            out.years.extend(r.years)
+            if r.unknown:
+                out.unknown_artist = True
+            cuts.append((hit.start, list_end))
+        else:
+            list_end = hit.end
+        while i < len(markers) and markers[i].start < list_end:
+            i += 1
+    skel = inp
+    for start, end in reversed(cuts):
+        skel = cut_skel(skel, start, end)
+    return skel
+
+
+def _strip_trailing_junk(inp: Skel, out: Extracted, ctx: Ctx) -> Skel:
+    """R8.4: strip trailing unbracketed junk phrases (optionally after a lone ``-`` / ``|``).
+
+    Word spans are computed once and walked backwards, so repeated junk stays linear (R0.8).
+    """
+    skel = trim_skel(inp)
+    spans = word_spans(skel.text)
+    words = [span.text for span in spans]
+    end = len(spans)  # words still in the title
+    while True:
+        m = ctx.t.junk_phrases.match_ending(words, end)
+        if m is None:
+            break
+        first = end - m.length
+        keep = first
+        if keep > 0 and _is_lone_edge(words[keep - 1]):
+            keep -= 1
+        if keep == 0:
+            break  # never strip the whole title
+        start = spans[first].start
+        raw = collapse_spaces(skel.text[start : spans[end - 1].end])
+        pos = skel.pos[start] if start < len(skel.pos) else 0
+        out.junk.append(PositionedJunk(raw, m.entry.value, pos))
+        end = keep
+    if end == len(spans):
+        return skel
+    return trim_skel(slice_skel(skel, 0, spans[end - 1].end))
+
+
+def _is_lone_edge(word: str) -> bool:
+    return word == "-" or word == "|"
+
+
+def _strip_lone_edges(s: str) -> str:
+    words = s.split(" ")
+    a = 0
+    b = len(words)
+    while a < b and _is_lone_edge(words[a]):
+        a += 1
+    while b > a and _is_lone_edge(words[b - 1]):
+        b -= 1
+    return " ".join(words[a:b])
+
+
+def cleanup_title(raw: str) -> str:
+    """R8.5"""
+    title = _strip_lone_edges(collapse_spaces(raw))
+    q = title[:1]
+    if len(title) >= 2 and (q == '"' or q == "'") and title[-1] == q:
+        title = _strip_lone_edges(collapse_spaces(title[1:-1]))
+    return title