2331766763

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #30 from snejus/dev

Run Details

261 of 337 branches covered (77.45%)

Branch coverage included in aggregate %.

393 of 482 new or added lines in 5 files covered. (81.54%)

1 existing line in 1 file now uncovered.

782 of 928 relevant lines covered (84.27%)

12.48 hits per line

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

95.5

/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 config as beets_config
from beets.autotag.hooks import AlbumInfo, TrackInfo
from ordered_set import OrderedSet as ordset  # type: ignore[import]
from pkg_resources import get_distribution, parse_version
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 = get_distribution("beets").parsed_version >= parse_version("1.5.0")

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 = Helpers.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: 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 = [self.meta.get("description")]
        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"))
        sep = self.config["comments_separator"]
        return sep.join(filter(op.truth, parts)).replace("\r", "")

    @cached_property
    def all_media_comments(self) -> str:
        return (
            "\n".join(map(op.attrgetter("description"), 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. See whether all track names contain {album name} EP or LP
        2. EP or LP is in the release name, deduce the album name from there
        3. Check whether the release name has it wrapped in quotes
        """
        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, text in [
            (r"(((&|#?\b(?!Double|VA|Various)(\w|[^\w| -])+) )+[EL]P)", album),
            (r"((['\"])([^'\"]+)\2( VA\d+)*)( |$)", album),
        ]:
            m = re.search(pat, text)
            if m:
                album = m.group(1).strip()
                if album[0] in "'\"" and album[-1] in "'\"":
                    return album.strip("\"'")
                return album
        return ""

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

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

        try:
            return self.meta["albumRelease"][0]["recordLabel"]["name"]
        except (KeyError, IndexError):
            return self.meta["publisher"]["name"]

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

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

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

    @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.album_name.split(" - ")
            if len(split) > 1:
                aartist = split[0]

        aartists = Helpers.split_artists([aartist])
        remixers_str = " ".join(self._tracks.other_artists)

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

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

    @cached_property
    def image(self) -> str:
        image = self.meta.get("image", "")
        return image[0] if isinstance(image, list) else 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")
        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."""
        cats = [t.catalognum for t in self._tracks if t.catalognum]
        artists = ordset([self.original_albumartist])
        if not self._singleton or len(self._tracks.artists) > 1:
            artists.update(self._tracks.artists)
            artists.update(self._tracks.other_artists)

        catnum = self.parse_catalognum(
            album=self.meta["name"],
            description=self.comments,
            label=self.label if not self._singleton else "",
            tracks=tuple(self._tracks.raw_names),
            artists=tuple(artists),
        )
        if len(cats) == len(self._tracks) and len(set(cats)) == 1:
            return list(cats)[0]
        return catnum

    @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 "",
                tracks=tuple(self._tracks.raw_names),
            )
            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, self._singleton)
        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

        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(fr"\b{word}\b", re.I)
        catnum_pat = re.compile(fr"{word}\d", re.I)
        name_pat = re.compile(fr"\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(map(lambda s: word_pat.search(s) and name_pat.search(s), 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(map(lambda x: x.replace("lp", "album"), 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"))
        rmxers = [t.remixer for t in self.tracks if t.remixer and t.remixer != "Original"]
        if len(rmxers) == 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)
        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:
        m = re.search(r"[:-] ?([A-Z][\w ]+ ((?!an )[EL]P))", self.all_media_comments)
        return m.group(1) if m else ""

    @cached_property
    def clean_album_name(self) -> str:
        if self.official_album_name:
            return self.official_album_name

        album = self.parsed_album_name or self.album_name
        artists = [*self.tracks.raw_artists, *self.tracks.artists]
        artists.sort(key=len, reverse=True)
        album = self.clean_album(album, self.catalognum, *artists, label=self.label)

        if album.startswith("("):
            album = self.album_name
        return album or self.eplp_album_comments or self.catalognum or self.album_name

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

snejus / beetcamp / 2331766763

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