2522418687

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #32 from snejus/fix-album-id-search

Run Details

290 of 347 branches covered (83.57%)

Branch coverage included in aggregate %.

59 of 70 new or added lines in 5 files covered. (84.29%)

1 existing line in 1 file now uncovered.

860 of 941 relevant lines covered (91.39%)

13.55 hits per line

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

69.06

/beetsplug/bandcamp/__init__.py

# beetcamp, Copyright (C) 2021 Šarūnas Nejus. Licensed under the GPLv2 or later.
# Based on beets-bandcamp: Copyright (C) 2015 Ariel George: Original implementation
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; version 2.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
# for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

"""Adds bandcamp album search support to the autotagger."""
from __future__ import absolute_import, division, print_function, unicode_literals

import logging
import re
from functools import partial
from html import unescape
from operator import itemgetter, truth
from typing import Any, Dict, Iterable, List, Optional, Sequence, Union

import requests
from beets import IncludeLazyConfig, __version__, config, library, plugins
from beets.autotag.hooks import AlbumInfo, TrackInfo

from beetsplug import fetchart  # type: ignore[attr-defined]

from ._metaguru import Metaguru
from ._search import search_bandcamp

JSONDict = Dict[str, Any]

DEFAULT_CONFIG: JSONDict = {
    "include_digital_only_tracks": True,
    "search_max": 2,
    "art": False,
    "exclude_extra_fields": [],
    "genre": {
        "capitalize": False,
        "maximum": 0,
        "mode": "progressive",
        "always_include": [],
    },
    "comments_separator": "\n---\n",
}

ALBUM_URL_IN_TRACK = re.compile(r'<a id="buyAlbumLink" href="([^"]+)')
USER_AGENT = f"beets/{__version__} +http://beets.radbox.org/"


class BandcampRequestsHandler:
    """A class that provides an ability to make requests and handles failures."""

    _log: logging.Logger

    def _exc(self, msg_template: str, *args: Sequence[str]) -> None:
        self._log.log(logging.WARNING, msg_template, *args, exc_info=True)

    def _info(self, msg_template: str, *args: Sequence[str]) -> None:
        self._log.log(logging.DEBUG, msg_template, *args, exc_info=False)

    def _get(self, url: str) -> str:
        """Return text contents of the url response."""
        headers = {"User-Agent": USER_AGENT}
        try:
            response = requests.get(url, headers=headers)
            response.raise_for_status()
        except requests.exceptions.RequestException:
            self._info("Error while fetching URL: {}", url)
            return ""
        return unescape(response.text)


def _from_bandcamp(clue: str) -> bool:
    """Check if the clue is likely to be a bandcamp url.
    We could check whether 'bandcamp' is found in the url, however, we would be ignoring
    cases where the publisher uses their own domain (for example https://eaux.ro) which
    in reality points to their Bandcamp page. Historically, we found that regardless
    of the domain, the rest of the url stays the same, therefore '/album/' or '/track/'
    is what we are looking for in a valid url here.
    """
    return bool(re.match(r"http[^ ]+/(album|track)/", clue))


class BandcampAlbumArt(BandcampRequestsHandler, fetchart.RemoteArtSource):
    NAME = "Bandcamp"

    def get(self, album, plugin, paths):
        # type: (AlbumInfo, plugins.BeetsPlugin, List) -> Iterable[fetchart.Candidate]  # noqa
        """Return the url for the cover from the bandcamp album page.
        This only returns cover art urls for bandcamp albums (by id).
        """
        url = album.mb_albumid
        if not _from_bandcamp(url):
            self._info("Not fetching art for a non-bandcamp album URL")
        else:
            html = self._get(url)
            if not html:
                self._info("Could not connect to the URL")
            else:
                try:
                    yield self._candidate(
                        url=Metaguru.from_html(html).image,
                        match=fetchart.Candidate.MATCH_EXACT,
                    )
                except (KeyError, AttributeError, ValueError):
                    self._info("Unexpected parsing error fetching album art")


def urlify(pretty_string: str) -> str:
    """Transform a string into bandcamp url."""
    name = pretty_string.lower().replace("'", "").replace(".", "")
    return re.sub("--+", "-", re.sub(r"\W", "-", name, flags=re.ASCII)).strip("-")


class BandcampPlugin(BandcampRequestsHandler, plugins.BeetsPlugin):
    _gurucache: Dict[str, Metaguru]
    beets_config: IncludeLazyConfig

    def __init__(self) -> None:
        super().__init__()
        self.beets_config = config
        self.config.add(DEFAULT_CONFIG.copy())

        self.register_listener("pluginload", self.loaded)
        self._gurucache = {}

    @property
    def data_source(self) -> str:
        return "bandcamp"

    def guru(self, url: str, html: Optional[str] = None) -> Optional[Metaguru]:
        """Return cached guru. If there isn't one, fetch the url if html isn't
        already given, initialise guru and add it to the cache. This way they
        can be re-used by separate import stages.
        """
        if url in self._gurucache:
            return self._gurucache[url]
        if not html:
            html = self._get(url)
        if html:
            self._gurucache[url] = Metaguru.from_html(html, self.config.flatten())
        return self._gurucache.get(url)

    def loaded(self) -> None:
        """Add our own artsource to the fetchart plugin."""
        # TODO: This is ugly, but i didn't find another way to extend fetchart
        # without declaring a new plugin.
        if self.config["art"]:
            fetchart.ART_SOURCES[self.data_source] = BandcampAlbumArt
            fetchart.SOURCE_NAMES[BandcampAlbumArt] = self.data_source
            bandcamp_fetchart = BandcampAlbumArt(self._log, self.config)

            for plugin in plugins.find_plugins():
                if isinstance(plugin, fetchart.FetchArtPlugin):
                    plugin.sources = [bandcamp_fetchart, *plugin.sources]
                    break

    def _find_url(self, item: library.Item, name: str, _type: str) -> str:
        """If the item has previously been imported, `mb_albumid` (or `mb_trackid`
        for singletons) contains the release url.

        As of 2022 April, Bandcamp purchases (at least in FLAC format) contain string
        *Visit {label_url}* in the `comments` field, therefore we try our luck here.

        If it is found, then the album/track name is converted into a valid url
        representation and appended to the `label_url`. This ends up being the correct
        url except when:
            * album name has been updated on Bandcamp but the file contains the old one
            * album name does not contain a single ascii alphanumeric character
              - in reality, this becomes '--{num}' in the url, where `num` depends on
              the number of previous releases that also did not have any valid alphanums.
              Therefore, we cannot make a reliable guess here.
        """
        url = getattr(item, f"mb_{_type}id", "")
        if _from_bandcamp(url):
            self._info("Fetching the URL attached to the first item, {}", url)
            return url

        match = re.match(r"Visit (https:[\w/.-]+com)", item.comments)
        urlified_name = urlify(name)
        if match and urlified_name:
            label = match.expand(r"\1")
            url = "/".join([label, _type, urlified_name])
            self._info("Trying our guess {} before searching", url)
            return url
        return ""

    def candidates(self, items, artist, album, va_likely, extra_tags=None):
        # type: (List[library.Item], str, str, bool, Any) -> Iterable[AlbumInfo]
        """Return a sequence of AlbumInfo objects that match the
        album whose items are provided or are being searched.
        """
        label = ""
        if items and album == items[0].album and artist == items[0].albumartist:
            label = items[0].label
            url = self._find_url(items[0], album, "album")
            if url:
                initial_guess = self.get_album_info(url)
                if initial_guess:
                    yield from initial_guess
                    return

        if "various" in artist.lower():
            artist = ""

        search = dict(query=album, artist=artist, label=label, search_type="a")
        results = map(itemgetter("url"), self._search(search))
        for res in filter(truth, map(self.get_album_info, results)):
            yield from res or [None]

    def item_candidates(self, item, artist, title):
        # type: (library.Item, str, str) -> Iterable[TrackInfo]
        """Return a sequence of TrackInfo objects that match the provided item.
        If the track was downloaded directly from bandcamp, it should contain
        a comment saying 'Visit <label-url>' - we look at this first by converting
        title into the format that Bandcamp use.
        """
        url = self._find_url(item, title, "track")
        label = ""
        if item and title == item.title and artist == item.artist:
            label = item.label
            initial_guess = self.get_track_info(url) if url else None
            if initial_guess:
                yield initial_guess
                return

        search = dict(query=title, artist=artist, label=label, search_type="t")
        results = map(itemgetter("url"), self._search(search))
        yield from filter(truth, map(self.get_track_info, results))

    def album_for_id(self, album_id: str) -> Optional[AlbumInfo]:
        """Fetch an album by its bandcamp ID."""
        if not _from_bandcamp(album_id):
            self._info("Not a bandcamp URL, skipping")
            return None

        albums = self.get_album_info(album_id)
        if not albums:
            return None

        if len(albums) > 1:
            # get the preferred media
            preferred = self.beets_config["match"]["preferred"]["media"].get()
            pref_to_idx = dict(zip(preferred, range(len(preferred))))
            albums = sorted(albums, key=lambda x: pref_to_idx.get(x.media, 100))
        return albums[0]

    def track_for_id(self, track_id: str) -> Optional[TrackInfo]:
        """Fetch a track by its bandcamp ID."""
        if _from_bandcamp(track_id):
            return self.get_track_info(track_id)

        self._info("Not a bandcamp URL, skipping")
        return None

    def handle_guru(self, attr, url, html=None):
        # type: (str, str, Optional[str]) -> Optional[Union[TrackInfo, List[AlbumInfo]]]
        try:
            return getattr(self.guru(url, html=html), attr)
        except (KeyError, ValueError, AttributeError, IndexError):
            self._info("Failed obtaining {}", url)
        except Exception:  # pylint: disable=broad-except
            i_url = "https://github.com/snejus/beetcamp/issues/new"
            self._exc("Unexpected error obtaining {}, please report at {}", url, i_url)
        return None

    def get_album_info(self, url: str) -> Optional[List[AlbumInfo]]:
        """Return an AlbumInfo object for a bandcamp album page.
        If track url is given by mistake, find and fetch the album url instead.
        """
        html = self._get(url)
        if "/track/" in url:
            match = ALBUM_URL_IN_TRACK.search(html)
            if match:
                url = re.sub(r"/track/.*", match.expand(r"\1"), url)
                return self.handle_guru("albums", url)
        return self.handle_guru("albums", url, html)

    def get_track_info(self, url: str) -> Optional[TrackInfo]:
        """Returns a TrackInfo object for a bandcamp track page."""
        return self.handle_guru("singleton", url)

    def _search(self, data: JSONDict) -> Iterable[JSONDict]:
        """Return a list of track/album URLs of type search_type matching the query."""
        msg = "Searching {}s for {} using {}"
        self._info(msg, data["search_type"], data["query"], str(data))
        results = search_bandcamp(**data, get=self._get)
        return results[: self.config["search_max"].as_number()]


def get_args(args: List[str]) -> Any:
    from argparse import Action, ArgumentParser

    parser = ArgumentParser(
        description="""Get bandcamp release metadata from the given <release-url>
or perform bandcamp search with <query>. Anything that does not start with https://
will be assumed to be a query.

Search type flags: -a for albums, -l for labels and artists, -t for tracks.
By default, all types are searched.
"""
    )

    class UrlOrQueryAction(Action):
        def __call__(self, parser, namespace, values, option_string=None):
            val = values
            if val:
                if val.startswith("https://"):
                    target = "release_url"
                else:
                    target = "query"
                    del namespace.release_url
                setattr(namespace, target, val)

    exclusive = parser.add_mutually_exclusive_group()
    exclusive.add_argument(
        "release_url",
        action=UrlOrQueryAction,
        nargs="?",
        help="Release URL, starting with https:// OR",
    )
    exclusive.add_argument(
        "query", action=UrlOrQueryAction, default="", nargs="?", help="Search query"
    )

    store_const = partial(
        parser.add_argument, dest="search_type", action="store_const", default=""
    )
    store_const("-a", "--album", const="a", help="Search albums")
    store_const("-l", "--label", const="b", help="Search labels and artists")
    store_const("-t", "--track", const="t", help="Search tracks")
    if not args:
        parser.print_help()
        parser.exit()
    return parser.parse_args(args=args)


def main():
    import json
    import sys

    args = get_args(sys.argv[1:])
    if args.query:
        result = search_bandcamp(**vars(args))
    else:
        pl = BandcampPlugin()
        result = pl.album_for_id(args.release_url) or pl.track_for_id(args.release_url)
        if not result:
            raise AssertionError("Failed to find a release under the given url")

    print(json.dumps(result))


if __name__ == "__main__":
    main()

1	# beetcamp, Copyright (C) 2021 Šarūnas Nejus. Licensed under the GPLv2 or later.
2	# Based on beets-bandcamp: Copyright (C) 2015 Ariel George: Original implementation
3	#
4	# This program is free software; you can redistribute it and/or modify it
5	# under the terms of the GNU General Public License as published by the
6	# Free Software Foundation; version 2.
7	#
8	# This program is distributed in the hope that it will be useful, but
9	# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
10	# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
11	# for more details.
12	#
13	# You should have received a copy of the GNU General Public License along
14	# with this program; if not, write to the Free Software Foundation, Inc.,
15	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16
17	"""Adds bandcamp album search support to the autotagger."""	15✔
18	from __future__ import absolute_import, division, print_function, unicode_literals	15✔
19
20	import logging	15✔
21	import re	15✔
22	from functools import partial	15✔
23	from html import unescape	15✔
24	from operator import itemgetter, truth	15✔
25	from typing import Any, Dict, Iterable, List, Optional, Sequence, Union	15✔
26
27	import requests	15✔
28	from beets import IncludeLazyConfig, __version__, config, library, plugins	15✔
29	from beets.autotag.hooks import AlbumInfo, TrackInfo	15✔
30
31	from beetsplug import fetchart # type: ignore[attr-defined]	15✔
32
33	from ._metaguru import Metaguru	15✔
34	from ._search import search_bandcamp	15✔
35
36	JSONDict = Dict[str, Any]	15✔
37
38	DEFAULT_CONFIG: JSONDict = {	15✔
39	"include_digital_only_tracks": True,
40	"search_max": 2,
41	"art": False,
42	"exclude_extra_fields": [],
43	"genre": {
44	"capitalize": False,
45	"maximum": 0,
46	"mode": "progressive",
47	"always_include": [],
48	},
49	"comments_separator": "\n---\n",
50	}
51
52	ALBUM_URL_IN_TRACK = re.compile(r'<a id="buyAlbumLink" href="([^"]+)')	15✔
53	USER_AGENT = f"beets/{__version__} +http://beets.radbox.org/"	15✔
54
55
56	class BandcampRequestsHandler:	15✔
57	"""A class that provides an ability to make requests and handles failures."""
58
59	_log: logging.Logger	15✔
60
61	def _exc(self, msg_template: str, *args: Sequence[str]) -> None:	15✔
62	self._log.log(logging.WARNING, msg_template, *args, exc_info=True)	×
63
64	def _info(self, msg_template: str, *args: Sequence[str]) -> None:	15✔
65	self._log.log(logging.DEBUG, msg_template, *args, exc_info=False)	15✔
66
67	def _get(self, url: str) -> str:	15✔
68	"""Return text contents of the url response."""
69	headers = {"User-Agent": USER_AGENT}	×
70	try:	×
71	response = requests.get(url, headers=headers)	×
72	response.raise_for_status()	×
73	except requests.exceptions.RequestException:	×
74	self._info("Error while fetching URL: {}", url)	×
75	return ""	×
76	return unescape(response.text)	×
77
78
79	def _from_bandcamp(clue: str) -> bool:	15✔
80	"""Check if the clue is likely to be a bandcamp url.
81	We could check whether 'bandcamp' is found in the url, however, we would be ignoring
82	cases where the publisher uses their own domain (for example https://eaux.ro) which
83	in reality points to their Bandcamp page. Historically, we found that regardless
84	of the domain, the rest of the url stays the same, therefore '/album/' or '/track/'
85	is what we are looking for in a valid url here.
86	"""
87	return bool(re.match(r"http[^ ]+/(album\|track)/", clue))	15✔
88
89
90	class BandcampAlbumArt(BandcampRequestsHandler, fetchart.RemoteArtSource):	15✔
91	NAME = "Bandcamp"	15✔
92
93	def get(self, album, plugin, paths):	15✔
94	# type: (AlbumInfo, plugins.BeetsPlugin, List) -> Iterable[fetchart.Candidate] # noqa
95	"""Return the url for the cover from the bandcamp album page.
96	This only returns cover art urls for bandcamp albums (by id).
97	"""
98	url = album.mb_albumid	15✔
99	if not _from_bandcamp(url):	15!
100	self._info("Not fetching art for a non-bandcamp album URL")	×
101	else:
102	html = self._get(url)	15✔
103	if not html:	15!
104	self._info("Could not connect to the URL")	×
105	else:
106	try:	15✔
107	yield self._candidate(	15✔
108	url=Metaguru.from_html(html).image,
109	match=fetchart.Candidate.MATCH_EXACT,
110	)
111	except (KeyError, AttributeError, ValueError):	×
112	self._info("Unexpected parsing error fetching album art")	×
113
114
115	def urlify(pretty_string: str) -> str:	15✔
116	"""Transform a string into bandcamp url."""
117	name = pretty_string.lower().replace("'", "").replace(".", "")	15✔
118	return re.sub("--+", "-", re.sub(r"\W", "-", name, flags=re.ASCII)).strip("-")	15✔
119
120
121	class BandcampPlugin(BandcampRequestsHandler, plugins.BeetsPlugin):	15✔
122	_gurucache: Dict[str, Metaguru]	15✔
123	beets_config: IncludeLazyConfig	15✔
124
125	def __init__(self) -> None:	15✔
126	super().__init__()	15✔
127	self.beets_config = config	15✔
128	self.config.add(DEFAULT_CONFIG.copy())	15✔
129
130	self.register_listener("pluginload", self.loaded)	15✔
131	self._gurucache = {}	15✔
132
133	@property	15✔
134	def data_source(self) -> str:	15✔
NEW 135	return "bandcamp"	×
136
137	def guru(self, url: str, html: Optional[str] = None) -> Optional[Metaguru]:	15✔
138	"""Return cached guru. If there isn't one, fetch the url if html isn't
139	already given, initialise guru and add it to the cache. This way they
140	can be re-used by separate import stages.
141	"""
142	if url in self._gurucache:	15!
143	return self._gurucache[url]	×
144	if not html:	15✔
145	html = self._get(url)	15✔
146	if html:	15!
147	self._gurucache[url] = Metaguru.from_html(html, self.config.flatten())	15✔
148	return self._gurucache.get(url)	15✔
149
150	def loaded(self) -> None:	15✔
151	"""Add our own artsource to the fetchart plugin."""
152	# TODO: This is ugly, but i didn't find another way to extend fetchart
153	# without declaring a new plugin.
154	if self.config["art"]:	×
NEW 155	fetchart.ART_SOURCES[self.data_source] = BandcampAlbumArt	×
NEW 156	fetchart.SOURCE_NAMES[BandcampAlbumArt] = self.data_source	×
UNCOV 157	bandcamp_fetchart = BandcampAlbumArt(self._log, self.config)	×
158
159	for plugin in plugins.find_plugins():	×
160	if isinstance(plugin, fetchart.FetchArtPlugin):	×
161	plugin.sources = [bandcamp_fetchart, *plugin.sources]	×
162	break	×
163
164	def _find_url(self, item: library.Item, name: str, _type: str) -> str:	15✔
165	"""If the item has previously been imported, `mb_albumid` (or `mb_trackid`
166	for singletons) contains the release url.
167
168	As of 2022 April, Bandcamp purchases (at least in FLAC format) contain string
169	Visit {label_url} in the `comments` field, therefore we try our luck here.
170
171	If it is found, then the album/track name is converted into a valid url
172	representation and appended to the `label_url`. This ends up being the correct
173	url except when:
174	* album name has been updated on Bandcamp but the file contains the old one
175	* album name does not contain a single ascii alphanumeric character
176	- in reality, this becomes '--{num}' in the url, where `num` depends on
177	the number of previous releases that also did not have any valid alphanums.
178	Therefore, we cannot make a reliable guess here.
179	"""
180	url = getattr(item, f"mb_{_type}id", "")	15✔
181	if _from_bandcamp(url):	15✔
182	self._info("Fetching the URL attached to the first item, {}", url)	15✔
183	return url	15✔
184
185	match = re.match(r"Visit (https:[\w/.-]+com)", item.comments)	15✔
186	urlified_name = urlify(name)	15✔
187	if match and urlified_name:	15✔
188	label = match.expand(r"\1")	15✔
189	url = "/".join([label, _type, urlified_name])	15✔
190	self._info("Trying our guess {} before searching", url)	15✔
191	return url	15✔
192	return ""	15✔
193
194	def candidates(self, items, artist, album, va_likely, extra_tags=None):	15✔
195	# type: (List[library.Item], str, str, bool, Any) -> Iterable[AlbumInfo]
196	"""Return a sequence of AlbumInfo objects that match the
197	album whose items are provided or are being searched.
198	"""
199	label = ""	15✔
200	if items and album == items[0].album and artist == items[0].albumartist:	15!
201	label = items[0].label	15✔
202	url = self._find_url(items[0], album, "album")	15✔
203	if url:	15!
204	initial_guess = self.get_album_info(url)	15✔
205	if initial_guess:	15!
206	yield from initial_guess	15✔
207	return	15✔
208
209	if "various" in artist.lower():	×
210	artist = ""	×
211
212	search = dict(query=album, artist=artist, label=label, search_type="a")	×
213	results = map(itemgetter("url"), self._search(search))	×
214	for res in filter(truth, map(self.get_album_info, results)):	×
NEW 215	yield from res or [None]	×
216
217	def item_candidates(self, item, artist, title):	15✔
218	# type: (library.Item, str, str) -> Iterable[TrackInfo]
219	"""Return a sequence of TrackInfo objects that match the provided item.
220	If the track was downloaded directly from bandcamp, it should contain
221	a comment saying 'Visit <label-url>' - we look at this first by converting
222	title into the format that Bandcamp use.
223	"""
224	url = self._find_url(item, title, "track")	15✔
225	label = ""	15✔
226	if item and title == item.title and artist == item.artist:	15!
227	label = item.label	15✔
228	initial_guess = self.get_track_info(url) if url else None	15✔
229	if initial_guess:	15!
230	yield initial_guess	15✔
231	return	15✔
232
233	search = dict(query=title, artist=artist, label=label, search_type="t")	×
234	results = map(itemgetter("url"), self._search(search))	×
235	yield from filter(truth, map(self.get_track_info, results))	×
236
237	def album_for_id(self, album_id: str) -> Optional[AlbumInfo]:	15✔
238	"""Fetch an album by its bandcamp ID."""
239	if not _from_bandcamp(album_id):	15✔
240	self._info("Not a bandcamp URL, skipping")	15✔
241	return None	15✔
242
243	albums = self.get_album_info(album_id)	15✔
244	if not albums:	15✔
245	return None	15✔
246
247	if len(albums) > 1:	15!
248	# get the preferred media
249	preferred = self.beets_config["match"]["preferred"]["media"].get()	15✔
250	pref_to_idx = dict(zip(preferred, range(len(preferred))))	15✔
251	albums = sorted(albums, key=lambda x: pref_to_idx.get(x.media, 100))	15✔
252	return albums[0]	15✔
253
254	def track_for_id(self, track_id: str) -> Optional[TrackInfo]:	15✔
255	"""Fetch a track by its bandcamp ID."""
256	if _from_bandcamp(track_id):	15!
257	return self.get_track_info(track_id)	×
258
259	self._info("Not a bandcamp URL, skipping")	15✔
260	return None	15✔
261
262	def handle_guru(self, attr, url, html=None):	15✔
263	# type: (str, str, Optional[str]) -> Optional[Union[TrackInfo, List[AlbumInfo]]]
264	try:	15✔
265	return getattr(self.guru(url, html=html), attr)	15✔
266	except (KeyError, ValueError, AttributeError, IndexError):	15!
267	self._info("Failed obtaining {}", url)	15✔
268	except Exception: # pylint: disable=broad-except	×
NEW 269	i_url = "https://github.com/snejus/beetcamp/issues/new"	×
NEW 270	self._exc("Unexpected error obtaining {}, please report at {}", url, i_url)	×
271	return None	15✔
272
273	def get_album_info(self, url: str) -> Optional[List[AlbumInfo]]:	15✔
274	"""Return an AlbumInfo object for a bandcamp album page.
275	If track url is given by mistake, find and fetch the album url instead.
276	"""
277	html = self._get(url)	15✔
278	if "/track/" in url:	15!
279	match = ALBUM_URL_IN_TRACK.search(html)	×
280	if match:	×
281	url = re.sub(r"/track/.*", match.expand(r"\1"), url)	×
NEW 282	return self.handle_guru("albums", url)	×
283	return self.handle_guru("albums", url, html)	15✔
284
285	def get_track_info(self, url: str) -> Optional[TrackInfo]:	15✔
286	"""Returns a TrackInfo object for a bandcamp track page."""
287	return self.handle_guru("singleton", url)	15✔
288
289	def _search(self, data: JSONDict) -> Iterable[JSONDict]:	15✔
290	"""Return a list of track/album URLs of type search_type matching the query."""
291	msg = "Searching {}s for {} using {}"	×
292	self._info(msg, data["search_type"], data["query"], str(data))	×
293	results = search_bandcamp(**data, get=self._get)	×
294	return results[: self.config["search_max"].as_number()]	×
295
296
297	def get_args(args: List[str]) -> Any:	15✔
298	from argparse import Action, ArgumentParser	15✔
299
300	parser = ArgumentParser(	15✔
301	description="""Get bandcamp release metadata from the given <release-url>
302	or perform bandcamp search with <query>. Anything that does not start with https://
303	will be assumed to be a query.
304
305	Search type flags: -a for albums, -l for labels and artists, -t for tracks.
306	By default, all types are searched.
307	"""
308	)
309
310	class UrlOrQueryAction(Action):	15✔
311	def __call__(self, parser, namespace, values, option_string=None):	15✔
312	val = values	15✔
313	if val:	15✔
314	if val.startswith("https://"):	15✔
315	target = "release_url"	15✔
316	else:
317	target = "query"	15✔
318	del namespace.release_url	15✔
319	setattr(namespace, target, val)	15✔
320
321	exclusive = parser.add_mutually_exclusive_group()	15✔
322	exclusive.add_argument(	15✔
323	"release_url",
324	action=UrlOrQueryAction,
325	nargs="?",
326	help="Release URL, starting with https:// OR",
327	)
328	exclusive.add_argument(	15✔
329	"query", action=UrlOrQueryAction, default="", nargs="?", help="Search query"
330	)
331
332	store_const = partial(	15✔
333	parser.add_argument, dest="search_type", action="store_const", default=""
334	)
335	store_const("-a", "--album", const="a", help="Search albums")	15✔
336	store_const("-l", "--label", const="b", help="Search labels and artists")	15✔
337	store_const("-t", "--track", const="t", help="Search tracks")	15✔
338	if not args:	15✔
339	parser.print_help()	15✔
340	parser.exit()	15✔
341	return parser.parse_args(args=args)	15✔
342
343
344	def main():	15✔
345	import json	×
NEW 346	import sys	×
347
NEW 348	args = get_args(sys.argv[1:])	×
349	if args.query:	×
350	result = search_bandcamp(**vars(args))	×
351	else:
352	pl = BandcampPlugin()	×
353	result = pl.album_for_id(args.release_url) or pl.track_for_id(args.release_url)	×
354	if not result:	×
355	raise AssertionError("Failed to find a release under the given url")
356
357	print(json.dumps(result))	×
358
359
360	if __name__ == "__main__":	15!
361	main()	×

snejus / beetcamp / 2522418687

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