trackparse 0.2.0__py3-none-any.whl

trackparse/_data.py

@@ -0,0 +1,513 @@
+# GENERATED from spec/data — do not edit. Run `python scripts/gen_data.py` to regenerate.
+"""Word lists compiled from spec/data (see SPEC.md). Generated; never edit by hand."""
+
+from __future__ import annotations
+
+from typing import Any
+
+SPEC_VERSION = "0.2.0"  # x-release-please-version
+
+# spec/data/descriptors.json
+DESCRIPTORS_DATA: dict[str, Any] = {
+    "descriptors": [
+        "radio",
+        "extended",
+        "club",
+        "original",
+        "instrumental",
+        "dub",
+        "vip",
+        "acoustic",
+        "live",
+        "demo",
+        "vocal",
+        "clean",
+        "dirty",
+        "explicit",
+        "short",
+        "long",
+        "full",
+        "album",
+        "single",
+        "alternate",
+        "alt",
+        "alternative",
+        "main",
+        "special",
+        "bonus",
+        "deluxe",
+        "mono",
+        "stereo",
+        "new",
+        "official",
+        "orchestral",
+        "piano",
+        "unplugged",
+        "12\"",
+        "7\"",
+        "12''",
+        "7''",
+        "12 inch",
+        "7 inch",
+        "re",
+        "final",
+        "second",
+        "2nd",
+        "3rd",
+    ],
+}
+
+# spec/data/extensions.json
+EXTENSIONS_DATA: dict[str, Any] = {
+    "extensions": [
+        "mp3",
+        "flac",
+        "wav",
+        "m4a",
+        "ogg",
+        "opus",
+        "aac",
+        "aiff",
+        "aif",
+        "wma",
+        "alac",
+        "mp4",
+        "webm",
+        "mkv",
+    ],
+}
+
+# spec/data/feat-markers.json
+FEAT_MARKERS_DATA: dict[str, Any] = {
+    "markers": [
+        "feat.",
+        "feat",
+        "ft.",
+        "ft",
+        "featuring",
+        "feat:",
+        "ft:",
+    ],
+    "bracketOnly": [
+        "with",
+        "w/",
+    ],
+    "producer": [
+        "prod.",
+        "prod",
+        "produced",
+        "prod.by",
+        "prod:",
+    ],
+    "titleMarkers": [
+        "feat.",
+        "ft.",
+        "featuring",
+    ],
+    "titleProducer": [
+        "prod.",
+        "prod. by",
+        "produced by",
+        "prod.by",
+    ],
+    "producerBy": "by",
+}
+
+# spec/data/genres.json
+GENRES_DATA: dict[str, Any] = {
+    "genres": [
+        "d'n'b",
+        "dnb",
+        "d&b",
+        "d & b",
+        "drum & bass",
+        "drum&bass",
+        "drum and bass",
+        "drum n bass",
+        "drum 'n' bass",
+        "drum'n'bass",
+        "neurofunk",
+        "neuro",
+        "liquid",
+        "liquid funk",
+        "jump up",
+        "jump-up",
+        "jungle",
+        "halftime",
+        "dancefloor",
+        "dubstep",
+        "riddim",
+        "brostep",
+        "trap",
+        "future bass",
+        "house",
+        "deep house",
+        "tech house",
+        "progressive house",
+        "electro house",
+        "techno",
+        "trance",
+        "psytrance",
+        "psy",
+        "hardstyle",
+        "hardcore",
+        "breaks",
+        "breakbeat",
+        "garage",
+        "uk garage",
+        "ukg",
+        "2step",
+        "2-step",
+        "grime",
+        "bass",
+        "bass house",
+        "edm",
+        "electronic",
+        "idm",
+        "synthwave",
+        "phonk",
+        "hip hop",
+        "hip-hop",
+        "rap",
+        "pop",
+        "rock",
+        "metal",
+        "ambient",
+        "chillout",
+        "lofi",
+        "lo-fi",
+    ],
+}
+
+# spec/data/joiners.json
+JOINERS_DATA: dict[str, Any] = {
+    "spaced": [
+        {
+            "raw": "&",
+            "canonical": "&",
+        },
+        {
+            "raw": "and",
+            "canonical": "&",
+            "kind": "and",
+        },
+        {
+            "raw": "x",
+            "canonical": "x",
+            "caseSensitive": True,
+        },
+        {
+            "raw": "×",
+            "canonical": "x",
+        },
+        {
+            "raw": "vs.",
+            "canonical": "vs.",
+        },
+        {
+            "raw": "vs",
+            "canonical": "vs.",
+        },
+        {
+            "raw": "versus",
+            "canonical": "vs.",
+        },
+        {
+            "raw": "/",
+            "canonical": "/",
+        },
+        {
+            "raw": "+",
+            "canonical": "+",
+        },
+        {
+            "raw": "with",
+            "canonical": "with",
+        },
+        {
+            "raw": "meets",
+            "canonical": "meets",
+        },
+        {
+            "raw": "pres.",
+            "canonical": "pres.",
+        },
+        {
+            "raw": "presents",
+            "canonical": "pres.",
+        },
+        {
+            "raw": "b2b",
+            "canonical": "b2b",
+        },
+    ],
+    "tight": [
+        {
+            "raw": ",",
+            "canonical": ",",
+        },
+        {
+            "raw": ";",
+            "canonical": ",",
+        },
+    ],
+    "featCanonical": "feat.",
+}
+
+# spec/data/junk.json
+JUNK_DATA: dict[str, Any] = {
+    "phrases": {
+        "official video": "video",
+        "official music video": "video",
+        "music video": "video",
+        "official video clip": "video",
+        "video clip": "video",
+        "official clip": "video",
+        "clip officiel": "video",
+        "official hd video": "video",
+        "official 4k video": "video",
+        "official mv": "video",
+        "mv": "video",
+        "m/v": "video",
+        "video": "video",
+        "official visualizer": "video",
+        "official visualiser": "video",
+        "visualizer": "video",
+        "visualiser": "video",
+        "audio visualizer": "video",
+        "official animated video": "video",
+        "animated video": "video",
+        "live video": "video",
+        "official live video": "video",
+        "performance video": "video",
+        "official performance video": "video",
+        "official audio": "audio",
+        "audio": "audio",
+        "audio only": "audio",
+        "full audio": "audio",
+        "official lyric video": "lyrics",
+        "official lyrics video": "lyrics",
+        "lyric video": "lyrics",
+        "lyrics video": "lyrics",
+        "lyrics": "lyrics",
+        "lyric": "lyrics",
+        "with lyrics": "lyrics",
+        "lyrics on screen": "lyrics",
+        "letra": "lyrics",
+        "hd": "quality",
+        "hq": "quality",
+        "uhd": "quality",
+        "4k": "quality",
+        "8k": "quality",
+        "1080p": "quality",
+        "720p": "quality",
+        "480p": "quality",
+        "high quality": "quality",
+        "full hd": "quality",
+        "free download": "promo",
+        "free dl": "promo",
+        "out now": "promo",
+        "premiere": "promo",
+        "exclusive": "promo",
+        "preview": "promo",
+        "teaser": "promo",
+        "snippet": "promo",
+        "new song": "promo",
+        "available now": "promo",
+        "ncs release": "label",
+        "monstercat release": "label",
+        "official": "other",
+    },
+    "connectors": [
+        "-",
+        "|",
+        "/",
+        "&",
+        "+",
+        ",",
+    ],
+    "labelSuffixes": [
+        "release",
+        "records",
+        "recordings",
+    ],
+}
+
+# spec/data/no-split-before.json
+NO_SPLIT_BEFORE_DATA: dict[str, Any] = {
+    "words": [
+        "sons",
+        "daughters",
+        "friends",
+        "co",
+        "co.",
+        "company",
+        "his",
+        "her",
+        "their",
+        "orchestra",
+    ],
+}
+
+# spec/data/platform-suffixes.json
+PLATFORM_SUFFIXES_DATA: dict[str, Any] = {
+    "suffixes": [
+        " - YouTube Music",
+        " - YouTube",
+        " | Free Listening on SoundCloud",
+        " - SoundCloud",
+        " | SoundCloud",
+        " - Topic",
+        " | Bandcamp",
+        " - Bandcamp",
+    ],
+}
+
+# spec/data/stopwords.json
+STOPWORDS_DATA: dict[str, Any] = {
+    "words": [
+        "you",
+        "me",
+        "him",
+        "her",
+        "us",
+        "them",
+        "it",
+        "i",
+        "love",
+        "my",
+        "your",
+        "our",
+        "the",
+        "a",
+        "an",
+        "this",
+        "that",
+        "myself",
+        "yourself",
+        "everyone",
+        "everybody",
+        "somebody",
+        "someone",
+        "nobody",
+        "nothing",
+        "all",
+        "night",
+        "side",
+        "day",
+    ],
+}
+
+# spec/data/unknown-tokens.json
+UNKNOWN_TOKENS_DATA: dict[str, Any] = {
+    "caseSensitive": [
+        "ID",
+        "IDs",
+        "ID?",
+    ],
+    "caseInsensitive": [
+        "unknown",
+        "unknown artist",
+        "unknown title",
+        "untitled",
+        "?",
+        "??",
+        "???",
+    ],
+}
+
+# spec/data/version-keywords.json
+VERSION_KEYWORDS_DATA: dict[str, Any] = {
+    "heads": {
+        "remix": "remix",
+        "rmx": "remix",
+        "mix": "mix",
+        "bootleg": "bootleg",
+        "vip": "vip",
+        "edit": "edit",
+        "re-edit": "edit",
+        "reedit": "edit",
+        "flip": "flip",
+        "refix": "refix",
+        "rework": "rework",
+        "re-work": "rework",
+        "mashup": "mashup",
+        "mash-up": "mashup",
+        "mash up": "mashup",
+        "blend": "blend",
+        "dub": "dub",
+        "version": "version",
+        "ver": "version",
+        "remaster": "remaster",
+        "remastered": "remaster",
+        "cover": "cover",
+        "reprise": "reprise",
+    },
+    "genericHeads": [
+        "mix",
+        "edit",
+        "version",
+    ],
+    "typeCapableModifiers": {
+        "radio": "radio",
+        "extended": "extended",
+        "club": "club",
+        "original": "original",
+        "instrumental": "instrumental",
+        "dub": "dub",
+        "vip": "vip",
+        "acoustic": "acoustic",
+        "live": "live",
+        "acapella": "acapella",
+        "a cappella": "acapella",
+        "a capella": "acapella",
+        "acappella": "acapella",
+        "demo": "demo",
+    },
+    "prefixForms": {
+        "live": "live",
+        "remastered": "remaster",
+        "remaster": "remaster",
+        "acoustic": "acoustic",
+        "instrumental": "instrumental",
+        "acapella": "acapella",
+        "a cappella": "acapella",
+        "demo": "demo",
+        "sped up": "spedUp",
+        "speed up": "spedUp",
+        "slowed + reverb": "slowed",
+        "slowed & reverb": "slowed",
+        "slowed and reverb": "slowed",
+        "slowed": "slowed",
+        "nightcore": "nightcore",
+    },
+    "types": [
+        "remix",
+        "bootleg",
+        "vip",
+        "edit",
+        "flip",
+        "refix",
+        "rework",
+        "mashup",
+        "blend",
+        "dub",
+        "mix",
+        "extended",
+        "radio",
+        "club",
+        "original",
+        "instrumental",
+        "acapella",
+        "live",
+        "acoustic",
+        "remaster",
+        "demo",
+        "reprise",
+        "cover",
+        "version",
+        "spedUp",
+        "slowed",
+        "nightcore",
+    ],
+}

trackparse/_format.py

@@ -0,0 +1,149 @@
+"""R11: render a ParsedTrack back to a string."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import NamedTuple, Optional
+
+from ._assemble import render_version
+from ._tables import Tables, get_default_tables
+from ._words import dedup_key, word_matches
+from .types import Artist, ParsedTrack
+
+
+class _Resolved(NamedTuple):
+    feat: object
+    feat_marker: Optional[str]
+    canonical: bool
+    versions: bool
+    producers: object
+    position: object
+
+
+def _is_feat_marker(raw: str, t: Tables) -> bool:
+    return (
+        t.feat_markers.match_at([raw], 0) is not None
+        or t.bracket_only_feat.match_at([raw], 0) is not None
+    )
+
+
+def _canonical_joiner(raw: str, t: Tables, feat_lead: bool = False) -> str:
+    """R11.5: map a raw joiner to its canonical form through data/joiners.json; feat markers
+    become ``featCanonical``. A featured list's lead marker is always a feat marker (``with`` →
+    ``feat.``), while between names the joiner table wins (``Sigala with Ella Eyre`` keeps
+    ``with``)."""
+    if feat_lead and _is_feat_marker(raw, t):
+        return t.feat_canonical
+    tight = t.tight_joiners.get(raw)
+    if tight is not None:
+        return tight
+    for j in t.spaced_joiners:
+        if (raw == j.raw) if j.case_sensitive else word_matches(raw, j.raw):
+            return j.canonical
+    return t.feat_canonical if _is_feat_marker(raw, t) else raw
+
+
+def _join_sep(joiner: Optional[str], o: _Resolved, t: Tables) -> str:
+    """R11.1: ``" " + joiner + " "``; tight joiners as the raw char + ``" "``; a missing joiner
+    as ``&``."""
+    if joiner is None:
+        j = "&"
+    elif o.canonical:
+        j = _canonical_joiner(joiner, t)
+    else:
+        j = joiner
+    return f"{j} " if j in t.tight_joiners else f" {j} "
+
+
+def _join_names(lst: Sequence[Artist], o: _Resolved, t: Tables) -> str:
+    """Names of one credit list joined by their own joiners (the first joiner is not
+    rendered)."""
+    return "".join(
+        a.name if i == 0 else _join_sep(a.joiner, o, t) + a.name for i, a in enumerate(lst)
+    )
+
+
+def _lead_marker(first: Artist, o: _Resolved, t: Tables, fallback: str) -> str:
+    """The marker in front of a featured list."""
+    if o.feat_marker is not None:
+        return o.feat_marker
+    raw = first.joiner if first.joiner is not None else fallback
+    return _canonical_joiner(raw, t, True) if o.canonical else raw
+
+
+def format_track(
+    track: ParsedTrack,
+    *,
+    feat: str = "source",
+    feat_marker: Optional[str] = None,
+    joiners: str = "original",
+    versions: str = "all",
+    producers: bool = True,
+    position: bool = False,
+) -> str:
+    """R11: render ``track`` as ``Artists - Title (versions) (prod. ...)``."""
+    t = get_default_tables()
+    o = _Resolved(
+        feat="source" if feat is None else feat,
+        feat_marker=feat_marker,
+        canonical=joiners == "canonical",
+        versions=("all" if versions is None else versions) == "all",
+        producers=True if producers is None else producers,
+        position=False if position is None else position,
+    )
+    artists = list(track.artists)
+    primaries = [a for a in artists if a.role == "primary"]
+    featured = [a for a in artists if a.role == "featured"]
+    producer_list = [a for a in artists if a.role == "producer"]
+
+    artist_feat: list[Artist] = []
+    title_feat: list[Artist] = []
+    if o.feat == "source":
+        artist_feat = [a for a in featured if a.source == "artist"]
+        title_feat = [a for a in featured if a.source != "artist"]
+    elif o.feat == "artist":
+        artist_feat = featured
+    elif o.feat == "title":
+        title_feat = featured
+
+    # R11.1 / R11.2
+    artist_part = _join_names(primaries, o, t)
+    if artist_feat:
+        lead = _lead_marker(artist_feat[0], o, t, t.feat_canonical)
+        names = _join_names(artist_feat, o, t)
+        artist_part = f"{artist_part} {lead} {names}" if artist_part else f"{lead} {names}"
+
+    # R11.3
+    pieces: list[str] = []
+    if track.title:
+        pieces.append(track.title)
+    if title_feat:
+        lead = _lead_marker(title_feat[0], o, t, t.feat_canonical)
+        pieces.append(f"({lead} {_join_names(title_feat, o, t)})")
+    if o.versions:
+        for v in track.versions:
+            pieces.append(render_version(v.raw, v.delimiter))
+    if o.producers and producer_list:
+        first = producer_list[0]
+        marker = first.joiner if first.joiner is not None else "prod."
+        pieces.append(f"({marker} {_join_names(producer_list, o, t)})")
+    title_part = " ".join(pieces)
+
+    # R11.4
+    result = f"{artist_part} - {title_part}" if artist_part else title_part
+    if o.position and track.position is not None:
+        result = f"{track.position.raw}. {result}"
+    return result
+
+
+def all_artists(track: ParsedTrack) -> list[Artist]:
+    """All credited names: track artists plus every version's remixers, deduped by R0.4 key."""
+    seen = set()
+    out: list[Artist] = []
+    for a in [*track.artists, *(x for v in track.versions for x in v.artists)]:
+        key = dedup_key(a.name)
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(a)
+    return out