3721080998

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #39 from snejus/dev

Run Details

301 of 362 branches covered (83.15%)

Branch coverage included in aggregate %.

137 of 145 new or added lines in 5 files covered. (94.48%)

2 existing lines in 2 files now uncovered.

905 of 996 relevant lines covered (90.86%)

10.79 hits per line

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

95.54

/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 = 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([*[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["name"]

    @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["@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)
        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", "")
        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") 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:
        if self.official_album_name:
            return self.official_album_name

        album = self.parsed_album_name or self.album_name
        artists = [*self.tracks.full_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 {
            "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 = Helpers.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: 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 = [self.meta.get("description")]	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"))	12✔
88	sep = 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["name"]	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["@id"]	12✔
144
145	@cached_property	12✔
146	def artist_id(self) -> str:	12✔
147	try:	12✔
148	return self.meta["byArtist"]["@id"]	12✔
149	except KeyError:	12✔
150	return self.meta["publisher"]["@id"]	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", "")	12✔
187	return image[0] if isinstance(image, list) else image	12✔
188
189	@cached_property	12✔
190	def release_date(self) -> Optional[date]:	12✔
191	"""Parse the datestring that takes the format like below and return date object.
192	{"datePublished": "17 Jul 2020 00:00:00 GMT"}
193
194	If the field is not found, return None.
195	"""
196	rel = self.meta.get("datePublished") or self.meta.get("dateModified")	12✔
197	if rel:	12✔
198	return datetime.strptime(re.sub(r" \d{2}:.+", "", rel), "%d %b %Y").date()	12✔
199	return rel	12✔
200
201	@cached_property	12✔
202	def albumstatus(self) -> str:	12✔
203	reldate = self.release_date	12✔
204	return "Official" if reldate and reldate <= date.today() else "Promotional"	12✔
205
206	@property	12✔
207	def disctitle(self) -> str:	12✔
208	"""Return medium's disc title if found."""
209	return "" if self.media.name == DIGI_MEDIA else self.media.title	12✔
210
211	@property	12✔
212	def mediums(self) -> int:	12✔
213	return self.get_vinyl_count(self.disctitle) if self.media.name == "Vinyl" else 1	12✔
214
215	@cached_property	12✔
216	def general_catalognum(self) -> str:	12✔
217	"""Find catalog number in the media-agnostic release metadata and cache it."""
218	return self._tracks.single_catalognum or self.parse_catalognum(	12✔
219	album=self.meta["name"],
220	description=self.comments,
221	label=self.label if not self._singleton else "",
222	artistitles=self._tracks.artistitles,
223	)
224
225	@property	12✔
226	def catalognum(self) -> str:	12✔
227	"""Find catalog number in the media-specific release metadata or return
228	the cached media-agnostic one.
229	"""
230	return (	12✔
231	self.parse_catalognum(
232	disctitle=self.disctitle,
233	description=self.media.description,
234	label=self.label if not self._singleton else "",
235	artistitles=self._tracks.artistitles,
236	)
237	or self.general_catalognum
238	)
239
240	@cached_property	12✔
241	def country(self) -> str:	12✔
242	try:	12✔
243	loc = self.meta["publisher"]["foundingLocation"]["name"].rpartition(", ")[	12✔
244	-1
245	]
246	name = normalize("NFKD", loc).encode("ascii", "ignore").decode()	12✔
247	return (	12✔
248	COUNTRY_OVERRIDES.get(name)
249	or getattr(countries.get(name=name, default=object), "alpha_2", None)
250	or subdivisions.lookup(name).country_code
251	)
252	except (ValueError, LookupError):	12✔
253	return WORLDWIDE	12✔
254
255	@cached_property	12✔
256	def tracks(self) -> Tracks:	12✔
257	self._tracks.adjust_artists(self.bandcamp_albumartist)	12✔
258	return self._tracks	12✔
259
260	@cached_property	12✔
261	def unique_artists(self) -> List[str]:	12✔
262	return self.split_artists(self._tracks.artists)	12✔
263
264	@cached_property	12✔
265	def albumartist(self) -> str:	12✔
266	"""Take into account the release contents and return the actual albumartist.
267	* 'Various Artists' (or `va_name` configuration option) for a compilation release
268	"""
269	if self.va:	12✔
270	return self.va_name	12✔
271
272	if len(self._tracks) == 1:	12!
273	return self.tracks.first.artist	×
274
275	aartist = self.original_albumartist	12✔
276	if self.unique_artists:	12!
277	aartist = ", ".join(sorted(self.unique_artists))	12✔
278
279	return aartist	12✔
280
281	@cached_property	12✔
282	def vinyl_disctitles(self) -> str:	12✔
283	return " ".join([m.title for m in self.media_formats if m.name == "Vinyl"])	12✔
284
285	def _search_albumtype(self, word: str) -> bool:	12✔
286	"""Return whether the given word (ep or lp) matches the release albumtype.
287	True when one of the following conditions is met:
288	* if {word}[0-9] is found in the catalognum
289	* if it's found in the original album name or any vinyl disctitle
290	* if it's found in the same sentence as 'this' or '{album_name}', where
291	sentences are read from release and media descriptions.
292	"""
293	sentences = re.split(r"[.]\s+\|\n", self.all_media_comments)	12✔
294	word_pat = re.compile(rf"\b{word}\b", re.I)	12✔
295	catnum_pat = re.compile(rf"{word}\d", re.I)	12✔
296	name_pat = re.compile(rf"\b(this\|{re.escape(self.clean_album_name)})\b", re.I)	12✔
297	return bool(	12✔
298	catnum_pat.search(self.catalognum)
299	or word_pat.search(self.album_name + " " + self.vinyl_disctitles)
300	or any(word_pat.search(s) and name_pat.search(s) for s in sentences)
301	)
302
303	@cached_property	12✔
304	def is_single_album(self) -> bool:	12✔
305	return (	8✔
306	self._singleton
307	or len({t.main_title for t in self.tracks}) == 1
308	or len(self._tracks.raw_names) == 1
309	)
310
311	@cached_property	12✔
312	def is_lp(self) -> bool:	12✔
313	"""Return whether the release is an LP."""
314	return self._search_albumtype("lp")	12✔
315
316	@cached_property	12✔
317	def is_ep(self) -> bool:	12✔
318	"""Return whether the release is an EP."""
319	return self._search_albumtype("ep")	12✔
320
321	def check_albumtype_in_descriptions(self) -> str:	12✔
322	"""Count 'lp', 'album' and 'ep' words in the release and media descriptions
323	and return the albumtype that represents the word matching the most times.
324	"""
325	matches = re.findall(r"\b(album\|ep\|lp)\b", self.all_media_comments.lower())	12✔
326	if matches:	12✔
327	counts = Counter(x.replace("lp", "album") for x in matches)	12✔
328	# if equal, we assume it's an EP since it's more likely that an EP is
329	# referred to as an "album" rather than the other way around
330	if counts["ep"] >= counts["album"]:	12!
331	return "ep"	×
332	return "album"	12✔
333
334	@cached_property	12✔
335	def is_comp(self) -> bool:	12✔
336	"""Return whether the release is a compilation."""
337
338	def first_one(artist: str) -> str:	12✔
339	return PATTERNS["split_artists"].split(artist.replace(" & ", ", "))[0]	12✔
340
341	truly_unique = set(map(first_one, self.tracks.artists))	12✔
342	return (	12✔
343	bool(re.search(r"compilation\|best of\|anniversary", self.album_name, re.I))
344	or self._search_albumtype("compilation")
345	or (len(truly_unique) > 3 and len(self.tracks) > 4)
346	)
347
348	@cached_property	12✔
349	def albumtype(self) -> str:	12✔
350	if self._singleton:	12✔
351	return "single"	8✔
352	if self.is_ep:	12✔
353	return "ep"	12✔
354	if self.is_lp:	12✔
355	return "album"	12✔
356
357	atype = self.check_albumtype_in_descriptions()	12✔
358	if atype == "ep":	12!
359	return "ep"	×
360	# otherwise, it's an album, but we firstly need to check if it's a compilation
361	if self.is_comp:	12✔
362	return "compilation"	12✔
363
364	return "album"	12✔
365
366	@cached_property	12✔
367	def albumtypes(self) -> str:	12✔
368	albumtypes = {self.albumtype}	8✔
369	if self.is_comp:	8✔
370	if self.albumtype == "ep":	8!
371	albumtypes.add("compilation")	×
372	else:
373	albumtypes.add("album")	8✔
374	if self.is_lp:	8✔
375	albumtypes.add("lp")	8✔
376	if self.is_single_album:	8✔
377	albumtypes.add("single")	8✔
378	for word in ["remix", "rmx", "edits", "live", "soundtrack"]:	8✔
379	if word in self.album_name.lower():	8✔
380	albumtypes.add(word.replace("rmx", "remix").replace("edits", "remix"))	8✔
381	if len(self.tracks.remixers) == len(self.tracks):	8!
UNCOV 382	albumtypes.add("remix")	×
383
384	return "; ".join(sorted(albumtypes))	8✔
385
386	@cached_property	12✔
387	def va(self) -> bool:	12✔
388	return len(self.unique_artists) > 3	12✔
389
390	@cached_property	12✔
391	def style(self) -> Optional[str]:	12✔
392	"""Extract bandcamp genre tag from the metadata."""
393	# expecting the following form: https://bandcamp.com/tag/folk
394	tag_url = self.meta.get("publisher", {}).get("genre") or ""	12✔
395	style = None	12✔
396	if tag_url:	12✔
397	style = tag_url.split("/")[-1]	12✔
398	if self.config["genre"]["capitalize"]:	12✔
399	style = style.capitalize()	12✔
400	return style	12✔
401
402	@cached_property	12✔
403	def genre(self) -> Optional[str]:	12✔
404	kws: Iterable[str] = map(str.lower, self.meta["keywords"])	12✔
405	if self.style:	12✔
406	exclude_style = partial(op.ne, self.style.lower())	12✔
407	kws = filter(exclude_style, kws)	12✔
408
409	genre_cfg = self.config["genre"]	12✔
410	genres = self.get_genre(kws, genre_cfg, self.label)	12✔
411	if genre_cfg["capitalize"]:	12✔
412	genres = map(str.capitalize, genres)	12✔
413	if genre_cfg["maximum"]:	12✔
414	genres = it.islice(genres, genre_cfg["maximum"])	12✔
415
416	return ", ".join(sorted(genres)).strip() or None	12✔
417
418	@cached_property	12✔
419	def eplp_album_comments(self) -> str:	12✔
420	"""Parse comments looking for an indication of an album in the following format
421	(Capital-case Album Name) (EP or LP)
422	and return the matching album name if found.
423	"""
424	m = re.search(r"((?!The\|This)\b[A-Z][^ \n]+\b )+[EL]P", self.all_media_comments)	12✔
425	return m.group() if m else ""	12✔
426
427	@cached_property	12✔
428	def clean_album_name(self) -> str:	12✔
429	if self.official_album_name:	12✔
430	return self.official_album_name	12✔
431
432	album = self.parsed_album_name or self.album_name	12✔
433	artists = [self.tracks.full_artists, self.tracks.artists]	12✔
434	artists.sort(key=len, reverse=True)	12✔
435	album = self.clean_album(album, self.catalognum, *artists, label=self.label)	12✔
436
437	if album.startswith("("):	12!
438	album = self.album_name	×
439	return album or self.eplp_album_comments or self.catalognum or self.album_name	12✔
440
441	@property	12✔
442	def _common(self) -> JSONDict:	12✔
443	return {	12✔
444	"data_source": DATA_SOURCE,
445	"media": self.media.name,
446	"data_url": self.album_id,
447	"artist_id": self.artist_id,
448	}
449
450	def get_fields(self, fields: Iterable[str], src: object = None) -> JSONDict:	12✔
451	"""Return a mapping between unexcluded fields and their values."""
452	fields = list(set(fields) - self.excluded_fields)	12✔
453	if len(fields) == 1:	12✔
454	field = fields.pop()	12✔
455	return {field: getattr(self, field)}	12✔
456	return dict(zip(fields, iter(op.attrgetter(*fields)(src or self))))	12✔
457
458	@property	12✔
459	def _common_album(self) -> JSONDict:	12✔
460	common_data: JSONDict = {"album": self.clean_album_name}	12✔
461	fields = ["label", "catalognum", "albumtype", "country"]	12✔
462	if NEW_BEETS:	12✔
463	fields.extend(["genre", "style", "comments", "albumtypes"])	8✔
464	common_data.update(self.get_fields(fields))	12✔
465	reldate = self.release_date	12✔
466	if reldate:	12✔
467	common_data.update(self.get_fields(["year", "month", "day"], reldate))	12✔
468
469	return common_data	12✔
470
471	def _trackinfo(self, track: Track, **kwargs: Any) -> TrackInfo:	12✔
472	data = track.info	12✔
473	data.update(self._common, kwargs)	12✔
474	# if track-level catalognum is not found or if it is the same as album's, then
475	# remove it. Otherwise, keep it attached to the track
476	if not data["catalognum"] or data["catalognum"] == self.catalognum:	12!
477	data.pop("catalognum", None)	12✔
478	if not data["lyrics"]:	12✔
479	data.pop("lyrics", None)	12✔
480	if not NEW_BEETS:	12✔
481	data.pop("catalognum", None)	4✔
482	data.pop("lyrics", None)	4✔
483	for field in set(data.keys()) & self.excluded_fields:	12!
484	data.pop(field)	×
485
486	return TrackInfo(**data)	12✔
487
488	@cached_property	12✔
489	def singleton(self) -> TrackInfo:	12✔
490	self._singleton = True	12✔
491	self.media = self.media_formats[0]	12✔
492	track = self._trackinfo(self.tracks.first)	12✔
493	if NEW_BEETS:	12✔
494	track.update(self._common_album)	8✔
495	track.pop("album", None)	8✔
496	track.track_id = track.data_url	12✔
497	return track	12✔
498
499	def _album(self, media: MediaInfo) -> AlbumInfo:	12✔
500	"""Return album for the appropriate release format."""
501	self.media = media	12✔
502	include_digi = self.config.get("include_digital_only_tracks")	12✔
503
504	tracks = list(self.tracks)	12✔
505	if not include_digi and self.media.name != DIGI_MEDIA:	12✔
506	tracks = [t for t in self.tracks if not t.digi_only]	12✔
507
508	get_trackinfo = partial(	12✔
509	self._trackinfo,
510	medium=1,
511	disctitle=self.disctitle or None,
512	medium_total=len(self.tracks),
513	)
514	album_info = AlbumInfo(	12✔
515	**self._common,
516	**self._common_album,
517	artist=self.albumartist,
518	album_id=self.album_id,
519	mediums=self.mediums,
520	albumstatus=self.albumstatus,
521	tracks=list(map(get_trackinfo, tracks)),
522	)
523	for key, val in self.get_fields(["va"]).items():	12✔
524	setattr(album_info, key, val)	12✔
525	album_info.album_id = self.media.album_id	12✔
526	if self.media.name == "Vinyl":	12✔
527	album_info = self.add_track_alts(album_info, self.comments)	12✔
528	return album_info	12✔
529
530	@cached_property	12✔
531	def albums(self) -> Iterable[AlbumInfo]:	12✔
532	"""Return album for the appropriate release format."""
533	return list(map(self._album, self.media_formats))	12✔

snejus / beetcamp / 3721080998

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