4161518410

Build Type

push

github

Committed by Šarūnas Nejus

Commit Message

album: escape label during cleanup

Run Details

298 of 362 branches covered (82.32%)

Branch coverage included in aggregate %.

5 of 5 new or added lines in 1 file covered. (100.0%)

16 existing lines in 2 files now uncovered.

908 of 1004 relevant lines covered (90.44%)

10.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.19

/beetsplug/bandcamp/_metaguru.py

"""Module for parsing bandcamp metadata."""
import itertools as it
import json
import operator as op
import re
import sys
from collections import Counter
from datetime import date, datetime
from functools import partial
from typing import Any, Dict, Iterable, List, Optional, Set
from unicodedata import normalize

from beets import __version__ as beets_version
from beets import config as beets_config
from beets.autotag.hooks import AlbumInfo, TrackInfo
from pycountry import countries, subdivisions

from ._helpers import PATTERNS, Helpers, MediaInfo
from ._tracks import Track, Tracks

if sys.version_info.minor > 7:
    from functools import cached_property  # pylint: disable=ungrouped-imports
else:
    from cached_property import cached_property  # type: ignore # pylint: disable=import-error # noqa

NEW_BEETS = int(beets_version.split(".")[1]) > 4

JSONDict = Dict[str, Any]

COUNTRY_OVERRIDES = {
    "Russia": "RU",  # pycountry: Russian Federation
    "The Netherlands": "NL",  # pycountry: Netherlands
    "UK": "GB",  # pycountry: Great Britain
    "D.C.": "US",
    "South Korea": "KR",  # pycountry: Korea, Republic of
}
DATA_SOURCE = "bandcamp"
WORLDWIDE = "XW"
DIGI_MEDIA = "Digital Media"
VA = "Various Artists"


class Metaguru(Helpers):
    _singleton = False
    va_name = VA
    media = MediaInfo("", "", "", "")

    meta: JSONDict
    config: JSONDict
    media_formats: List[MediaInfo]
    _tracks: Tracks

    def __init__(self, meta: JSONDict, config: Optional[JSONDict] = None) -> None:
        self.meta = meta
        self.media_formats = self.get_media_formats(
            (meta.get("inAlbum") or meta).get("albumRelease") or []
        )
        if self.media_formats:
            self.media = self.media_formats[0]
        self.config = config or {}
        self.va_name = beets_config["va_name"].as_str() or self.va_name
        self._tracks = Tracks.from_json(meta)

    @classmethod
    def from_html(cls, html: str, config: Optional[JSONDict] = None) -> "Metaguru":
        try:
            meta = re.search(PATTERNS["meta"], html).group()  # type: ignore[union-attr]
        except AttributeError as exc:
            raise AttributeError("Could not find release metadata JSON") from exc
        else:
            return cls(json.loads(meta), config)

    @cached_property
    def excluded_fields(self) -> Set[str]:
        return set(self.config.get("excluded_fields") or [])

    @property
    def comments(self) -> str:
        """Return release, media descriptions and credits separated by
        the configured separator string.
        """
        parts: List[str] = [self.meta.get("description") or ""]
        media_desc = self.media.description
        if media_desc and not media_desc.startswith("Includes high-quality"):
            parts.append(media_desc)

        parts.append(self.meta.get("creditText") or "")
        sep: str = self.config["comments_separator"]
        return sep.join(filter(op.truth, parts)).replace("\r", "")

    @cached_property
    def all_media_comments(self) -> str:
        return "\n".join([*[m.description for m in self.media_formats], self.comments])

    @cached_property
    def official_album_name(self) -> str:
        """Check description for the album name header and return whatever follows it
        if found.
        """
        m = re.search(r"(Title: ?|Album(:|/Single) )([^\n]+)", self.all_media_comments)
        if m:
            return m.group(3).strip()
        return ""

    @cached_property
    def parsed_album_name(self) -> str:
        """
        Search for the album name in the following order and return the first match:
        1. Album name is found in *all* track names
        2. When 'EP' or 'LP' is in the release name, album name is what precedes it.
        3. If some words are enclosed in quotes in the release name, it is assumed
           to be the album name. Remove the quotes in such case.
        """
        album_in_tracks = {t.album for t in self._tracks if t.album}
        if len(album_in_tracks) == 1:
            return list(album_in_tracks)[0]

        album = self.album_name
        for pat in [
            r"(((&|#?\b(?!Double|VA|Various)(\w|[^\w| -])+) )+[EL]P)",
            r"((['\"])([^'\"]+)\2( VA\d+)*)( |$)",
        ]:
            m = re.search(pat, album)
            if m:
                album = m.group(1).strip()
                return re.sub(r"^['\"](.+)['\"]$", r"\1", album)
        return album

    @cached_property
    def album_name(self) -> str:
        return self.meta.get("name") or ""

    @cached_property
    def label(self) -> str:
        m = re.search(r"Label:([^/,\n]+)", self.all_media_comments)
        if m:
            return m.expand(r"\1").strip(" '\"")

        return self.get_label(self.meta)

    @cached_property
    def album_id(self) -> str:
        return self.meta.get("@id") or ""

    @cached_property
    def artist_id(self) -> str:
        try:
            return self.meta["byArtist"]["@id"]  # type: ignore [no-any-return]
        except KeyError:
            return self.meta["publisher"]["@id"]  # type: ignore [no-any-return]

    @cached_property
    def original_albumartist(self) -> str:
        m = re.search(r"Artists?:([^\n]+)", self.all_media_comments)
        aartist = m.group(1).strip() if m else self.meta["byArtist"]["name"]
        return re.sub(r" +// +", ", ", aartist)

    @cached_property
    def bandcamp_albumartist(self) -> str:
        """Return the official release albumartist.
        It is correct in half of the cases. In others, we usually find the label name.
        """
        aartist = self.original_albumartist
        if self.label == aartist:
            split = self.clean_album(self.album_name, self.catalognum).split(" - ")
            if len(split) > 1:
                aartist = split[0]

        aartists = Helpers.split_artists([aartist])
        if len(aartists) == 1:
            return aartist

        remixers_str = " ".join(self._tracks.other_artists).lower()

        def not_remixer(x: str) -> bool:
            splits = {x, *x.split(" & ")}
            return not any(y.lower() in remixers_str for y in splits)

        valid = list(filter(not_remixer, aartists))
        if len(valid) == len(aartists) and len(self._tracks.artists) <= 4:
            return aartist
        return ", ".join(valid)

    @cached_property
    def image(self) -> str:
        image = self.meta.get("image") or ""
        if isinstance(image, list) and isinstance(image[0], str):
            return image[0]
        return image

    @cached_property
    def release_date(self) -> Optional[date]:
        """Parse the datestring that takes the format like below and return date object.
        {"datePublished": "17 Jul 2020 00:00:00 GMT"}

        If the field is not found, return None.
        """
        rel = self.meta.get("datePublished") or self.meta.get("dateModified")
        if rel:
            return datetime.strptime(re.sub(r" \d{2}:.+", "", rel), "%d %b %Y").date()
        return rel

    @cached_property
    def albumstatus(self) -> str:
        reldate = self.release_date
        return "Official" if reldate and reldate <= date.today() else "Promotional"

    @property
    def disctitle(self) -> str:
        """Return medium's disc title if found."""
        return "" if self.media.name == DIGI_MEDIA else self.media.title

    @property
    def mediums(self) -> int:
        return self.get_vinyl_count(self.disctitle) if self.media.name == "Vinyl" else 1

    @cached_property
    def general_catalognum(self) -> str:
        """Find catalog number in the media-agnostic release metadata and cache it."""
        return self._tracks.single_catalognum or self.parse_catalognum(
            album=self.meta["name"],
            description=self.comments,
            label=self.label if not self._singleton else "",
            artistitles=self._tracks.artistitles,
        )

    @property
    def catalognum(self) -> str:
        """Find catalog number in the media-specific release metadata or return
        the cached media-agnostic one.
        """
        return (
            self.parse_catalognum(
                disctitle=self.disctitle,
                description=self.media.description,
                label=self.label if not self._singleton else "",
                artistitles=self._tracks.artistitles,
            )
            or self.general_catalognum
        )

    @cached_property
    def country(self) -> str:
        try:
            loc = self.meta["publisher"]["foundingLocation"]["name"].rpartition(", ")[
                -1
            ]
            name = normalize("NFKD", loc).encode("ascii", "ignore").decode()
            return (
                COUNTRY_OVERRIDES.get(name)
                or getattr(countries.get(name=name, default=object), "alpha_2", None)
                or subdivisions.lookup(name).country_code
            )
        except (ValueError, LookupError):
            return WORLDWIDE

    @cached_property
    def tracks(self) -> Tracks:
        self._tracks.adjust_artists(self.bandcamp_albumartist)
        return self._tracks

    @cached_property
    def unique_artists(self) -> List[str]:
        return self.split_artists(self._tracks.artists)

    @cached_property
    def albumartist(self) -> str:
        """Take into account the release contents and return the actual albumartist.
        * 'Various Artists' (or `va_name` configuration option) for a compilation release
        """
        if self.va:
            return self.va_name

        if len(self._tracks) == 1:
            return self.tracks.first.artist

        aartist = self.original_albumartist
        if self.unique_artists:
            aartist = ", ".join(sorted(self.unique_artists))

        return aartist

    @cached_property
    def vinyl_disctitles(self) -> str:
        return " ".join([m.title for m in self.media_formats if m.name == "Vinyl"])

    def _search_albumtype(self, word: str) -> bool:
        """Return whether the given word (ep or lp) matches the release albumtype.
        True when one of the following conditions is met:
        * if {word}[0-9] is found in the catalognum
        * if it's found in the original album name or any vinyl disctitle
        * if it's found in the same sentence as 'this' or '{album_name}', where
        sentences are read from release and media descriptions.
        """
        sentences = re.split(r"[.]\s+|\n", self.all_media_comments)
        word_pat = re.compile(rf"\b{word}\b", re.I)
        catnum_pat = re.compile(rf"{word}\d", re.I)
        name_pat = re.compile(rf"\b(this|{re.escape(self.clean_album_name)})\b", re.I)
        return bool(
            catnum_pat.search(self.catalognum)
            or word_pat.search(self.album_name + " " + self.vinyl_disctitles)
            or any(word_pat.search(s) and name_pat.search(s) for s in sentences)
        )

    @cached_property
    def is_single_album(self) -> bool:
        return (
            self._singleton
            or len({t.main_title for t in self.tracks}) == 1
            or len(self._tracks.raw_names) == 1
        )

    @cached_property
    def is_lp(self) -> bool:
        """Return whether the release is an LP."""
        return self._search_albumtype("lp")

    @cached_property
    def is_ep(self) -> bool:
        """Return whether the release is an EP."""
        return self._search_albumtype("ep")

    def check_albumtype_in_descriptions(self) -> str:
        """Count 'lp', 'album' and 'ep' words in the release and media descriptions
        and return the albumtype that represents the word matching the most times.
        """
        matches = re.findall(r"\b(album|ep|lp)\b", self.all_media_comments.lower())
        if matches:
            counts = Counter(x.replace("lp", "album") for x in matches)
            # if equal, we assume it's an EP since it's more likely that an EP is
            # referred to as an "album" rather than the other way around
            if counts["ep"] >= counts["album"]:
                return "ep"
        return "album"

    @cached_property
    def is_comp(self) -> bool:
        """Return whether the release is a compilation."""

        def first_one(artist: str) -> str:
            return PATTERNS["split_artists"].split(artist.replace(" & ", ", "))[0]

        truly_unique = set(map(first_one, self.tracks.artists))
        return (
            bool(re.search(r"compilation|best of|anniversary", self.album_name, re.I))
            or self._search_albumtype("compilation")
            or (len(truly_unique) > 3 and len(self.tracks) > 4)
        )

    @cached_property
    def albumtype(self) -> str:
        if self._singleton:
            return "single"
        if self.is_ep:
            return "ep"
        if self.is_lp:
            return "album"

        atype = self.check_albumtype_in_descriptions()
        if atype == "ep":
            return "ep"
        # otherwise, it's an album, but we firstly need to check if it's a compilation
        if self.is_comp:
            return "compilation"

        return "album"

    @cached_property
    def albumtypes(self) -> str:
        albumtypes = {self.albumtype}
        if self.is_comp:
            if self.albumtype == "ep":
                albumtypes.add("compilation")
            else:
                albumtypes.add("album")
        if self.is_lp:
            albumtypes.add("lp")
        if self.is_single_album:
            albumtypes.add("single")
        for word in ["remix", "rmx", "edits", "live", "soundtrack"]:
            if word in self.album_name.lower():
                albumtypes.add(word.replace("rmx", "remix").replace("edits", "remix"))
        if len(self.tracks.remixers) == len(self.tracks):
            albumtypes.add("remix")

        return "; ".join(sorted(albumtypes))

    @cached_property
    def va(self) -> bool:
        return len(self.unique_artists) > 3

    @cached_property
    def style(self) -> Optional[str]:
        """Extract bandcamp genre tag from the metadata."""
        # expecting the following form: https://bandcamp.com/tag/folk
        tag_url = self.meta.get("publisher", {}).get("genre") or ""
        style = None
        if tag_url:
            style = tag_url.split("/")[-1]
            if self.config["genre"]["capitalize"]:
                style = style.capitalize()
        return style

    @cached_property
    def genre(self) -> Optional[str]:
        kws: Iterable[str] = map(str.lower, self.meta["keywords"])
        if self.style:
            exclude_style = partial(op.ne, self.style.lower())
            kws = filter(exclude_style, kws)

        genre_cfg = self.config["genre"]
        genres = self.get_genre(kws, genre_cfg, self.label)
        if genre_cfg["capitalize"]:
            genres = map(str.capitalize, genres)
        if genre_cfg["maximum"]:
            genres = it.islice(genres, genre_cfg["maximum"])

        return ", ".join(sorted(genres)).strip() or None

    @cached_property
    def eplp_album_comments(self) -> str:
        """Parse comments looking for an indication of an album in the following format
        (Capital-case Album Name) (EP or LP)
        and return the matching album name if found.
        """
        m = re.search(r"((?!The|This)\b[A-Z][^ \n]+\b )+[EL]P", self.all_media_comments)
        return m.group() if m else ""

    @cached_property
    def clean_album_name(self) -> str:
        to_clean = {self.catalognum}
        if self.official_album_name:
            album = self.official_album_name
        else:
            album = self.parsed_album_name or self.album_name
            to_clean |= set(self.tracks.full_artists)
            to_clean |= set(self.tracks.artists)

        part = ""
        m = re.search(r"\W+(part [\w-]+)", self.album_name, re.I)
        if m:
            album = album.replace(m.group(), "")
            part = f" ({m.group(1)})"
        album = self.clean_album(album, *to_clean, label=self.label)

        if album.startswith("("):
            album = self.album_name

        album = album or self.eplp_album_comments or self.catalognum or self.album_name
        if part:
            album += part

        return album

    @property
    def _common(self) -> JSONDict:
        return {
            "data_source": DATA_SOURCE,
            "media": self.media.name,
            "data_url": self.album_id,
            "artist_id": self.artist_id,
        }

    def get_fields(self, fields: Iterable[str], src: object = None) -> JSONDict:
        """Return a mapping between unexcluded fields and their values."""
        fields = list(set(fields) - self.excluded_fields)
        if len(fields) == 1:
            field = fields.pop()
            return {field: getattr(self, field)}
        return dict(zip(fields, iter(op.attrgetter(*fields)(src or self))))

    @property
    def _common_album(self) -> JSONDict:
        common_data: JSONDict = {"album": self.clean_album_name}
        fields = ["label", "catalognum", "albumtype", "country"]
        if NEW_BEETS:
            fields.extend(["genre", "style", "comments", "albumtypes"])
        common_data.update(self.get_fields(fields))
        reldate = self.release_date
        if reldate:
            common_data.update(self.get_fields(["year", "month", "day"], reldate))

        return common_data

    def _trackinfo(self, track: Track, **kwargs: Any) -> TrackInfo:
        data = track.info
        data.update(**self._common, **kwargs)
        # if track-level catalognum is not found or if it is the same as album's, then
        # remove it. Otherwise, keep it attached to the track
        if not data["catalognum"] or data["catalognum"] == self.catalognum:
            data.pop("catalognum", None)
        if not data["lyrics"]:
            data.pop("lyrics", None)
        if not NEW_BEETS:
            data.pop("catalognum", None)
            data.pop("lyrics", None)
        for field in set(data.keys()) & self.excluded_fields:
            data.pop(field)

        return TrackInfo(**data)

    @cached_property
    def singleton(self) -> TrackInfo:
        self._singleton = True
        self.media = self.media_formats[0]
        track = self._trackinfo(self.tracks.first)
        if NEW_BEETS:
            track.update(self._common_album)
            track.pop("album", None)
        track.track_id = track.data_url
        return track

    def _album(self, media: MediaInfo) -> AlbumInfo:
        """Return album for the appropriate release format."""
        self.media = media
        include_digi = self.config.get("include_digital_only_tracks")

        tracks = list(self.tracks)
        if not include_digi and self.media.name != DIGI_MEDIA:
            tracks = [t for t in self.tracks if not t.digi_only]

        get_trackinfo = partial(
            self._trackinfo,
            medium=1,
            disctitle=self.disctitle or None,
            medium_total=len(self.tracks),
        )
        album_info = AlbumInfo(
            **self._common,
            **self._common_album,
            artist=self.albumartist,
            album_id=self.album_id,
            mediums=self.mediums,
            albumstatus=self.albumstatus,
            tracks=list(map(get_trackinfo, tracks)),
        )
        for key, val in self.get_fields(["va"]).items():
            setattr(album_info, key, val)
        album_info.album_id = self.media.album_id
        if self.media.name == "Vinyl":
            album_info = self.add_track_alts(album_info, self.comments)
        return album_info

    @cached_property
    def albums(self) -> Iterable[AlbumInfo]:
        """Return album for the appropriate release format."""
        return list(map(self._album, self.media_formats))

1	"""Module for parsing bandcamp metadata."""
2	import itertools as it	12✔
3	import json	12✔
4	import operator as op	12✔
5	import re	12✔
6	import sys	12✔
7	from collections import Counter	12✔
8	from datetime import date, datetime	12✔
9	from functools import partial	12✔
10	from typing import Any, Dict, Iterable, List, Optional, Set	12✔
11	from unicodedata import normalize	12✔
12
13	from beets import __version__ as beets_version	12✔
14	from beets import config as beets_config	12✔
15	from beets.autotag.hooks import AlbumInfo, TrackInfo	12✔
16	from pycountry import countries, subdivisions	12✔
17
18	from ._helpers import PATTERNS, Helpers, MediaInfo	12✔
19	from ._tracks import Track, Tracks	12✔
20
21	if sys.version_info.minor > 7:	12✔
22	from functools import cached_property # pylint: disable=ungrouped-imports	9✔
23	else:
24	from cached_property import cached_property # type: ignore # pylint: disable=import-error # noqa	3✔
25
26	NEW_BEETS = int(beets_version.split(".")[1]) > 4	12✔
27
28	JSONDict = Dict[str, Any]	12✔
29
30	COUNTRY_OVERRIDES = {	12✔
31	"Russia": "RU", # pycountry: Russian Federation
32	"The Netherlands": "NL", # pycountry: Netherlands
33	"UK": "GB", # pycountry: Great Britain
34	"D.C.": "US",
35	"South Korea": "KR", # pycountry: Korea, Republic of
36	}
37	DATA_SOURCE = "bandcamp"	12✔
38	WORLDWIDE = "XW"	12✔
39	DIGI_MEDIA = "Digital Media"	12✔
40	VA = "Various Artists"	12✔
41
42
43	class Metaguru(Helpers):	12✔
44	_singleton = False	12✔
45	va_name = VA	12✔
46	media = MediaInfo("", "", "", "")	12✔
47
48	meta: JSONDict	12✔
49	config: JSONDict	12✔
50	media_formats: List[MediaInfo]	12✔
51	_tracks: Tracks	12✔
52
53	def __init__(self, meta: JSONDict, config: Optional[JSONDict] = None) -> None:	12✔
54	self.meta = meta	12✔
55	self.media_formats = self.get_media_formats(	12✔
56	(meta.get("inAlbum") or meta).get("albumRelease") or []
57	)
58	if self.media_formats:	12✔
59	self.media = self.media_formats[0]	12✔
60	self.config = config or {}	12✔
61	self.va_name = beets_config["va_name"].as_str() or self.va_name	12✔
62	self._tracks = Tracks.from_json(meta)	12✔
63
64	@classmethod	12✔
65	def from_html(cls, html: str, config: Optional[JSONDict] = None) -> "Metaguru":	12✔
66	try:	12✔
67	meta = re.search(PATTERNS["meta"], html).group() # type: ignore[union-attr]	12✔
68	except AttributeError as exc:	12✔
69	raise AttributeError("Could not find release metadata JSON") from exc	12✔
70	else:
71	return cls(json.loads(meta), config)	12✔
72
73	@cached_property	12✔
74	def excluded_fields(self) -> Set[str]:	12✔
75	return set(self.config.get("excluded_fields") or [])	12✔
76
77	@property	12✔
78	def comments(self) -> str:	12✔
79	"""Return release, media descriptions and credits separated by
80	the configured separator string.
81	"""
82	parts: List[str] = [self.meta.get("description") or ""]	12✔
83	media_desc = self.media.description	12✔
84	if media_desc and not media_desc.startswith("Includes high-quality"):	12✔
85	parts.append(media_desc)	12✔
86
87	parts.append(self.meta.get("creditText") or "")	12✔
88	sep: str = self.config["comments_separator"]	12✔
89	return sep.join(filter(op.truth, parts)).replace("\r", "")	12✔
90
91	@cached_property	12✔
92	def all_media_comments(self) -> str:	12✔
93	return "\n".join([*[m.description for m in self.media_formats], self.comments])	12✔
94
95	@cached_property	12✔
96	def official_album_name(self) -> str:	12✔
97	"""Check description for the album name header and return whatever follows it
98	if found.
99	"""
100	m = re.search(r"(Title: ?\|Album(:\|/Single) )([^\n]+)", self.all_media_comments)	12✔
101	if m:	12✔
102	return m.group(3).strip()	12✔
103	return ""	12✔
104
105	@cached_property	12✔
106	def parsed_album_name(self) -> str:	12✔
107	"""
108	Search for the album name in the following order and return the first match:
109	1. Album name is found in all track names
110	2. When 'EP' or 'LP' is in the release name, album name is what precedes it.
111	3. If some words are enclosed in quotes in the release name, it is assumed
112	to be the album name. Remove the quotes in such case.
113	"""
114	album_in_tracks = {t.album for t in self._tracks if t.album}	12✔
115	if len(album_in_tracks) == 1:	12!
116	return list(album_in_tracks)[0]	×
117
118	album = self.album_name	12✔
119	for pat in [	12✔
120	r"(((&\|#?\b(?!Double\|VA\|Various)(\w\|[^\w\| -])+) )+[EL]P)",
121	r"((['\"])([^'\"]+)\2( VA\d+)*)( \|$)",
122	]:
123	m = re.search(pat, album)	12✔
124	if m:	12✔
125	album = m.group(1).strip()	12✔
126	return re.sub(r"^['\"](.+)['\"]$", r"\1", album)	12✔
127	return album	12✔
128
129	@cached_property	12✔
130	def album_name(self) -> str:	12✔
131	return self.meta.get("name") or ""	12✔
132
133	@cached_property	12✔
134	def label(self) -> str:	12✔
135	m = re.search(r"Label:([^/,\n]+)", self.all_media_comments)	12✔
136	if m:	12✔
137	return m.expand(r"\1").strip(" '\"")	12✔
138
139	return self.get_label(self.meta)	12✔
140
141	@cached_property	12✔
142	def album_id(self) -> str:	12✔
143	return self.meta.get("@id") or ""	12✔
144
145	@cached_property	12✔
146	def artist_id(self) -> str:	12✔
147	try:	12✔
148	return self.meta["byArtist"]["@id"] # type: ignore [no-any-return]	12✔
149	except KeyError:	12✔
150	return self.meta["publisher"]["@id"] # type: ignore [no-any-return]	12✔
151
152	@cached_property	12✔
153	def original_albumartist(self) -> str:	12✔
154	m = re.search(r"Artists?:([^\n]+)", self.all_media_comments)	12✔
155	aartist = m.group(1).strip() if m else self.meta["byArtist"]["name"]	12✔
156	return re.sub(r" +// +", ", ", aartist)	12✔
157
158	@cached_property	12✔
159	def bandcamp_albumartist(self) -> str:	12✔
160	"""Return the official release albumartist.
161	It is correct in half of the cases. In others, we usually find the label name.
162	"""
163	aartist = self.original_albumartist	12✔
164	if self.label == aartist:	12✔
165	split = self.clean_album(self.album_name, self.catalognum).split(" - ")	12✔
166	if len(split) > 1:	12✔
167	aartist = split[0]	12✔
168
169	aartists = Helpers.split_artists([aartist])	12✔
170	if len(aartists) == 1:	12✔
171	return aartist	12✔
172
173	remixers_str = " ".join(self._tracks.other_artists).lower()	12✔
174
175	def not_remixer(x: str) -> bool:	12✔
176	splits = {x, *x.split(" & ")}	12✔
177	return not any(y.lower() in remixers_str for y in splits)	12✔
178
179	valid = list(filter(not_remixer, aartists))	12✔
180	if len(valid) == len(aartists) and len(self._tracks.artists) <= 4:	12!
181	return aartist	12✔
182	return ", ".join(valid)	×
183
184	@cached_property	12✔
185	def image(self) -> str:	12✔
186	image = self.meta.get("image") or ""	12✔
187	if isinstance(image, list) and isinstance(image[0], str):	12!
188	return image[0]	×
189	return image	12✔
190
191	@cached_property	12✔
192	def release_date(self) -> Optional[date]:	12✔
193	"""Parse the datestring that takes the format like below and return date object.
194	{"datePublished": "17 Jul 2020 00:00:00 GMT"}
195
196	If the field is not found, return None.
197	"""
198	rel = self.meta.get("datePublished") or self.meta.get("dateModified")	12✔
199	if rel:	12✔
200	return datetime.strptime(re.sub(r" \d{2}:.+", "", rel), "%d %b %Y").date()	12✔
201	return rel	12✔
202
203	@cached_property	12✔
204	def albumstatus(self) -> str:	12✔
205	reldate = self.release_date	12✔
206	return "Official" if reldate and reldate <= date.today() else "Promotional"	12✔
207
208	@property	12✔
209	def disctitle(self) -> str:	12✔
210	"""Return medium's disc title if found."""
211	return "" if self.media.name == DIGI_MEDIA else self.media.title	12✔
212
213	@property	12✔
214	def mediums(self) -> int:	12✔
215	return self.get_vinyl_count(self.disctitle) if self.media.name == "Vinyl" else 1	12✔
216
217	@cached_property	12✔
218	def general_catalognum(self) -> str:	12✔
219	"""Find catalog number in the media-agnostic release metadata and cache it."""
220	return self._tracks.single_catalognum or self.parse_catalognum(	12✔
221	album=self.meta["name"],
222	description=self.comments,
223	label=self.label if not self._singleton else "",
224	artistitles=self._tracks.artistitles,
225	)
226
227	@property	12✔
228	def catalognum(self) -> str:	12✔
229	"""Find catalog number in the media-specific release metadata or return
230	the cached media-agnostic one.
231	"""
232	return (	12✔
233	self.parse_catalognum(
234	disctitle=self.disctitle,
235	description=self.media.description,
236	label=self.label if not self._singleton else "",
237	artistitles=self._tracks.artistitles,
238	)
239	or self.general_catalognum
240	)
241
242	@cached_property	12✔
243	def country(self) -> str:	12✔
244	try:	12✔
245	loc = self.meta["publisher"]["foundingLocation"]["name"].rpartition(", ")[	12✔
246	-1
247	]
248	name = normalize("NFKD", loc).encode("ascii", "ignore").decode()	12✔
249	return (	12✔
250	COUNTRY_OVERRIDES.get(name)
251	or getattr(countries.get(name=name, default=object), "alpha_2", None)
252	or subdivisions.lookup(name).country_code
253	)
254	except (ValueError, LookupError):	12✔
255	return WORLDWIDE	12✔
256
257	@cached_property	12✔
258	def tracks(self) -> Tracks:	12✔
259	self._tracks.adjust_artists(self.bandcamp_albumartist)	12✔
260	return self._tracks	12✔
261
262	@cached_property	12✔
263	def unique_artists(self) -> List[str]:	12✔
264	return self.split_artists(self._tracks.artists)	12✔
265
266	@cached_property	12✔
267	def albumartist(self) -> str:	12✔
268	"""Take into account the release contents and return the actual albumartist.
269	* 'Various Artists' (or `va_name` configuration option) for a compilation release
270	"""
271	if self.va:	12✔
272	return self.va_name	12✔
273
274	if len(self._tracks) == 1:	12!
275	return self.tracks.first.artist	×
276
277	aartist = self.original_albumartist	12✔
278	if self.unique_artists:	12!
279	aartist = ", ".join(sorted(self.unique_artists))	12✔
280
281	return aartist	12✔
282
283	@cached_property	12✔
284	def vinyl_disctitles(self) -> str:	12✔
285	return " ".join([m.title for m in self.media_formats if m.name == "Vinyl"])	12✔
286
287	def _search_albumtype(self, word: str) -> bool:	12✔
288	"""Return whether the given word (ep or lp) matches the release albumtype.
289	True when one of the following conditions is met:
290	* if {word}[0-9] is found in the catalognum
291	* if it's found in the original album name or any vinyl disctitle
292	* if it's found in the same sentence as 'this' or '{album_name}', where
293	sentences are read from release and media descriptions.
294	"""
295	sentences = re.split(r"[.]\s+\|\n", self.all_media_comments)	12✔
296	word_pat = re.compile(rf"\b{word}\b", re.I)	12✔
297	catnum_pat = re.compile(rf"{word}\d", re.I)	12✔
298	name_pat = re.compile(rf"\b(this\|{re.escape(self.clean_album_name)})\b", re.I)	12✔
299	return bool(	12✔
300	catnum_pat.search(self.catalognum)
301	or word_pat.search(self.album_name + " " + self.vinyl_disctitles)
302	or any(word_pat.search(s) and name_pat.search(s) for s in sentences)
303	)
304
305	@cached_property	12✔
306	def is_single_album(self) -> bool:	12✔
307	return (	8✔
308	self._singleton
309	or len({t.main_title for t in self.tracks}) == 1
310	or len(self._tracks.raw_names) == 1
311	)
312
313	@cached_property	12✔
314	def is_lp(self) -> bool:	12✔
315	"""Return whether the release is an LP."""
316	return self._search_albumtype("lp")	12✔
317
318	@cached_property	12✔
319	def is_ep(self) -> bool:	12✔
320	"""Return whether the release is an EP."""
321	return self._search_albumtype("ep")	12✔
322
323	def check_albumtype_in_descriptions(self) -> str:	12✔
324	"""Count 'lp', 'album' and 'ep' words in the release and media descriptions
325	and return the albumtype that represents the word matching the most times.
326	"""
327	matches = re.findall(r"\b(album\|ep\|lp)\b", self.all_media_comments.lower())	12✔
328	if matches:	12✔
329	counts = Counter(x.replace("lp", "album") for x in matches)	12✔
330	# if equal, we assume it's an EP since it's more likely that an EP is
331	# referred to as an "album" rather than the other way around
332	if counts["ep"] >= counts["album"]:	12!
333	return "ep"	×
334	return "album"	12✔
335
336	@cached_property	12✔
337	def is_comp(self) -> bool:	12✔
338	"""Return whether the release is a compilation."""
339
340	def first_one(artist: str) -> str:	12✔
341	return PATTERNS["split_artists"].split(artist.replace(" & ", ", "))[0]	12✔
342
343	truly_unique = set(map(first_one, self.tracks.artists))	12✔
344	return (	12✔
345	bool(re.search(r"compilation\|best of\|anniversary", self.album_name, re.I))
346	or self._search_albumtype("compilation")
347	or (len(truly_unique) > 3 and len(self.tracks) > 4)
348	)
349
350	@cached_property	12✔
351	def albumtype(self) -> str:	12✔
352	if self._singleton:	12✔
353	return "single"	8✔
354	if self.is_ep:	12✔
355	return "ep"	12✔
356	if self.is_lp:	12✔
357	return "album"	12✔
358
359	atype = self.check_albumtype_in_descriptions()	12✔
360	if atype == "ep":	12!
361	return "ep"	×
362	# otherwise, it's an album, but we firstly need to check if it's a compilation
363	if self.is_comp:	12✔
364	return "compilation"	12✔
365
366	return "album"	12✔
367
368	@cached_property	12✔
369	def albumtypes(self) -> str:	12✔
370	albumtypes = {self.albumtype}	8✔
371	if self.is_comp:	8✔
372	if self.albumtype == "ep":	8!
373	albumtypes.add("compilation")	×
374	else:
375	albumtypes.add("album")	8✔
376	if self.is_lp:	8✔
377	albumtypes.add("lp")	8✔
378	if self.is_single_album:	8✔
379	albumtypes.add("single")	8✔
380	for word in ["remix", "rmx", "edits", "live", "soundtrack"]:	8✔
381	if word in self.album_name.lower():	8✔
382	albumtypes.add(word.replace("rmx", "remix").replace("edits", "remix"))	8✔
383	if len(self.tracks.remixers) == len(self.tracks):	8!
384	albumtypes.add("remix")	×
385
386	return "; ".join(sorted(albumtypes))	8✔
387
388	@cached_property	12✔
389	def va(self) -> bool:	12✔
390	return len(self.unique_artists) > 3	12✔
391
392	@cached_property	12✔
393	def style(self) -> Optional[str]:	12✔
394	"""Extract bandcamp genre tag from the metadata."""
395	# expecting the following form: https://bandcamp.com/tag/folk
396	tag_url = self.meta.get("publisher", {}).get("genre") or ""	12✔
397	style = None	12✔
398	if tag_url:	12✔
399	style = tag_url.split("/")[-1]	12✔
400	if self.config["genre"]["capitalize"]:	12✔
401	style = style.capitalize()	12✔
402	return style	12✔
403
404	@cached_property	12✔
405	def genre(self) -> Optional[str]:	12✔
406	kws: Iterable[str] = map(str.lower, self.meta["keywords"])	12✔
407	if self.style:	12✔
408	exclude_style = partial(op.ne, self.style.lower())	12✔
409	kws = filter(exclude_style, kws)	12✔
410
411	genre_cfg = self.config["genre"]	12✔
412	genres = self.get_genre(kws, genre_cfg, self.label)	12✔
413	if genre_cfg["capitalize"]:	12✔
414	genres = map(str.capitalize, genres)	12✔
415	if genre_cfg["maximum"]:	12✔
416	genres = it.islice(genres, genre_cfg["maximum"])	12✔
417
418	return ", ".join(sorted(genres)).strip() or None	12✔
419
420	@cached_property	12✔
421	def eplp_album_comments(self) -> str:	12✔
422	"""Parse comments looking for an indication of an album in the following format
423	(Capital-case Album Name) (EP or LP)
424	and return the matching album name if found.
425	"""
426	m = re.search(r"((?!The\|This)\b[A-Z][^ \n]+\b )+[EL]P", self.all_media_comments)	12✔
427	return m.group() if m else ""	12✔
428
429	@cached_property	12✔
430	def clean_album_name(self) -> str:	12✔
431	to_clean = {self.catalognum}	12✔
432	if self.official_album_name:	12✔
433	album = self.official_album_name	12✔
434	else:
435	album = self.parsed_album_name or self.album_name	12✔
436	to_clean \|= set(self.tracks.full_artists)	12✔
437	to_clean \|= set(self.tracks.artists)	12✔
438
439	part = ""	12✔
440	m = re.search(r"\W+(part [\w-]+)", self.album_name, re.I)	12✔
441	if m:	12!
UNCOV 442	album = album.replace(m.group(), "")	×
UNCOV 443	part = f" ({m.group(1)})"	×
444	album = self.clean_album(album, *to_clean, label=self.label)	12✔
445
446	if album.startswith("("):	12!
UNCOV 447	album = self.album_name	×
448
449	album = album or self.eplp_album_comments or self.catalognum or self.album_name	12✔
450	if part:	12!
UNCOV 451	album += part	×
452
453	return album	12✔
454
455	@property	12✔
456	def _common(self) -> JSONDict:	12✔
457	return {	12✔
458	"data_source": DATA_SOURCE,
459	"media": self.media.name,
460	"data_url": self.album_id,
461	"artist_id": self.artist_id,
462	}
463
464	def get_fields(self, fields: Iterable[str], src: object = None) -> JSONDict:	12✔
465	"""Return a mapping between unexcluded fields and their values."""
466	fields = list(set(fields) - self.excluded_fields)	12✔
467	if len(fields) == 1:	12✔
468	field = fields.pop()	12✔
469	return {field: getattr(self, field)}	12✔
470	return dict(zip(fields, iter(op.attrgetter(*fields)(src or self))))	12✔
471
472	@property	12✔
473	def _common_album(self) -> JSONDict:	12✔
474	common_data: JSONDict = {"album": self.clean_album_name}	12✔
475	fields = ["label", "catalognum", "albumtype", "country"]	12✔
476	if NEW_BEETS:	12✔
477	fields.extend(["genre", "style", "comments", "albumtypes"])	8✔
478	common_data.update(self.get_fields(fields))	12✔
479	reldate = self.release_date	12✔
480	if reldate:	12✔
481	common_data.update(self.get_fields(["year", "month", "day"], reldate))	12✔
482
483	return common_data	12✔
484
485	def _trackinfo(self, track: Track, **kwargs: Any) -> TrackInfo:	12✔
486	data = track.info	12✔
487	data.update(self._common, kwargs)	12✔
488	# if track-level catalognum is not found or if it is the same as album's, then
489	# remove it. Otherwise, keep it attached to the track
490	if not data["catalognum"] or data["catalognum"] == self.catalognum:	12!
491	data.pop("catalognum", None)	12✔
492	if not data["lyrics"]:	12✔
493	data.pop("lyrics", None)	12✔
494	if not NEW_BEETS:	12✔
495	data.pop("catalognum", None)	4✔
496	data.pop("lyrics", None)	4✔
497	for field in set(data.keys()) & self.excluded_fields:	12!
UNCOV 498	data.pop(field)	×
499
500	return TrackInfo(**data)	12✔
501
502	@cached_property	12✔
503	def singleton(self) -> TrackInfo:	12✔
504	self._singleton = True	12✔
505	self.media = self.media_formats[0]	12✔
506	track = self._trackinfo(self.tracks.first)	12✔
507	if NEW_BEETS:	12✔
508	track.update(self._common_album)	8✔
509	track.pop("album", None)	8✔
510	track.track_id = track.data_url	12✔
511	return track	12✔
512
513	def _album(self, media: MediaInfo) -> AlbumInfo:	12✔
514	"""Return album for the appropriate release format."""
515	self.media = media	12✔
516	include_digi = self.config.get("include_digital_only_tracks")	12✔
517
518	tracks = list(self.tracks)	12✔
519	if not include_digi and self.media.name != DIGI_MEDIA:	12✔
520	tracks = [t for t in self.tracks if not t.digi_only]	12✔
521
522	get_trackinfo = partial(	12✔
523	self._trackinfo,
524	medium=1,
525	disctitle=self.disctitle or None,
526	medium_total=len(self.tracks),
527	)
528	album_info = AlbumInfo(	12✔
529	**self._common,
530	**self._common_album,
531	artist=self.albumartist,
532	album_id=self.album_id,
533	mediums=self.mediums,
534	albumstatus=self.albumstatus,
535	tracks=list(map(get_trackinfo, tracks)),
536	)
537	for key, val in self.get_fields(["va"]).items():	12✔
538	setattr(album_info, key, val)	12✔
539	album_info.album_id = self.media.album_id	12✔
540	if self.media.name == "Vinyl":	12✔
541	album_info = self.add_track_alts(album_info, self.comments)	12✔
542	return album_info	12✔
543
544	@cached_property	12✔
545	def albums(self) -> Iterable[AlbumInfo]:	12✔
546	"""Return album for the appropriate release format."""
547	return list(map(self._album, self.media_formats))	12✔

snejus / beetcamp / 4161518410

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous