3721085587

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%)

25 existing lines in 4 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

68.36

/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:
                    image_url = Metaguru.from_html(html).image
                except (KeyError, AttributeError, ValueError):
                    self._info("Unexpected parsing error fetching album art")
                else:
                    if image_url:
                        yield self._candidate(
                            url=image_url, match=fetchart.Candidate.MATCH_EXACT
                        )


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())

        if self.config["art"]:
            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."""
        for plugin in plugins.find_plugins():
            if isinstance(plugin, fetchart.FetchArtPlugin):
                fetchart.ART_SOURCES[self.data_source] = BandcampAlbumArt
                fetchart.SOURCE_NAMES[BandcampAlbumArt] = self.data_source
                fetchart.SOURCES_ALL.append(self.data_source)
                bandcamp_fetchart = BandcampAlbumArt(self._log, self.config)
                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

        m = re.match(r"Visit (https:[\w/.-]+com)", item.comments)
        urlified_name = urlify(name)
        if m and urlified_name:
            label = m.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 = {"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 = {"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:
            m = ALBUM_URL_IN_TRACK.search(html)
            if m:
                url = re.sub(r"/track/.*", m.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")
    parser.add_argument(
        "-o",
        "--open",
        action="store",
        dest="index",
        type=int,
        help="Open search result indexed by INDEX in the browser",
    )
    if not args:
        parser.print_help()
        parser.exit()
    return parser.parse_args(args=args)


def main() -> None:
    import json
    import sys

    args = get_args(sys.argv[1:])

    search_vars = vars(args)
    index = search_vars.pop("index", None)
    if search_vars.get("query"):
        result = search_bandcamp(**search_vars)
    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")

    if index:
        try:
            url = result[index - 1]["url"]
        except IndexError as e:
            raise Exception("Specified index could not be found") from e

        import webbrowser

        print(f"Opening search result number {index}: {url}")
        webbrowser.open(url)
    else:
        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."""	12✔
18	from __future__ import absolute_import, division, print_function, unicode_literals	12✔
19
20	import logging	12✔
21	import re	12✔
22	from functools import partial	12✔
23	from html import unescape	12✔
24	from operator import itemgetter, truth	12✔
25	from typing import Any, Dict, Iterable, List, Optional, Sequence, Union	12✔
26
27	import requests	12✔
28	from beets import IncludeLazyConfig, __version__, config, library, plugins	12✔
29	from beets.autotag.hooks import AlbumInfo, TrackInfo	12✔
30
31	from beetsplug import fetchart # type: ignore[attr-defined]	12✔
32
33	from ._metaguru import Metaguru	12✔
34	from ._search import search_bandcamp	12✔
35
36	JSONDict = Dict[str, Any]	12✔
37
38	DEFAULT_CONFIG: JSONDict = {	12✔
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="([^"]+)')	12✔
53	USER_AGENT = f"beets/{__version__} +http://beets.radbox.org/"	12✔
54
55
56	class BandcampRequestsHandler:	12✔
57	"""A class that provides an ability to make requests and handles failures."""
58
59	_log: logging.Logger	12✔
60
61	def _exc(self, msg_template: str, *args: Sequence[str]) -> None:	12✔
62	self._log.log(logging.WARNING, msg_template, *args, exc_info=True)	×
63
64	def _info(self, msg_template: str, *args: Sequence[str]) -> None:	12✔
65	self._log.log(logging.DEBUG, msg_template, *args, exc_info=False)	12✔
66
67	def _get(self, url: str) -> str:	12✔
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:	12✔
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))	12✔
88
89
90	class BandcampAlbumArt(BandcampRequestsHandler, fetchart.RemoteArtSource):	12✔
91	NAME = "Bandcamp"	12✔
92
93	def get(self, album, plugin, paths):	12✔
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	12✔
99	if not _from_bandcamp(url):	12✔
100	self._info("Not fetching art for a non-bandcamp album URL")	12✔
101	else:
102	html = self._get(url)	12✔
103	if not html:	12✔
104	self._info("Could not connect to the URL")	12✔
105	else:
106	try:	12✔
107	image_url = Metaguru.from_html(html).image	12✔
108	except (KeyError, AttributeError, ValueError):	12✔
109	self._info("Unexpected parsing error fetching album art")	12✔
110	else:
111	if image_url:	12✔
112	yield self._candidate(	12✔
113	url=image_url, match=fetchart.Candidate.MATCH_EXACT
114	)
115
116
117	def urlify(pretty_string: str) -> str:	12✔
118	"""Transform a string into bandcamp url."""
119	name = pretty_string.lower().replace("'", "").replace(".", "")	12✔
120	return re.sub("--+", "-", re.sub(r"\W", "-", name, flags=re.ASCII)).strip("-")	12✔
121
122
123	class BandcampPlugin(BandcampRequestsHandler, plugins.BeetsPlugin):	12✔
124	_gurucache: Dict[str, Metaguru]	12✔
125	beets_config: IncludeLazyConfig	12✔
126
127	def __init__(self) -> None:	12✔
128	super().__init__()	12✔
129	self.beets_config = config	12✔
130	self.config.add(DEFAULT_CONFIG.copy())	12✔
131
132	if self.config["art"]:	12!
133	self.register_listener("pluginload", self.loaded)	×
134	self._gurucache = {}	12✔
135
136	@property	12✔
137	def data_source(self) -> str:	12✔
138	return "bandcamp"	12✔
139
140	def guru(self, url: str, html: Optional[str] = None) -> Optional[Metaguru]:	12✔
141	"""Return cached guru. If there isn't one, fetch the url if html isn't
142	already given, initialise guru and add it to the cache. This way they
143	can be re-used by separate import stages.
144	"""
145	if url in self._gurucache:	12!
146	return self._gurucache[url]	×
147	if not html:	12✔
148	html = self._get(url)	12✔
149	if html:	12!
150	self._gurucache[url] = Metaguru.from_html(html, self.config.flatten())	12✔
151	return self._gurucache.get(url)	12✔
152
153	def loaded(self) -> None:	12✔
154	"""Add our own artsource to the fetchart plugin."""
155	for plugin in plugins.find_plugins():	×
156	if isinstance(plugin, fetchart.FetchArtPlugin):	×
157	fetchart.ART_SOURCES[self.data_source] = BandcampAlbumArt	×
158	fetchart.SOURCE_NAMES[BandcampAlbumArt] = self.data_source	×
159	fetchart.SOURCES_ALL.append(self.data_source)	×
160	bandcamp_fetchart = BandcampAlbumArt(self._log, self.config)	×
161	plugin.sources = [bandcamp_fetchart, *plugin.sources]	×
162	break	×
163
164	def _find_url(self, item: library.Item, name: str, _type: str) -> str:	12✔
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", "")	12✔
181	if _from_bandcamp(url):	12✔
182	self._info("Fetching the URL attached to the first item, {}", url)	12✔
183	return url	12✔
184
185	m = re.match(r"Visit (https:[\w/.-]+com)", item.comments)	12✔
186	urlified_name = urlify(name)	12✔
187	if m and urlified_name:	12✔
188	label = m.expand(r"\1")	12✔
189	url = "/".join([label, _type, urlified_name])	12✔
190	self._info("Trying our guess {} before searching", url)	12✔
191	return url	12✔
192	return ""	12✔
193
194	def candidates(self, items, artist, album, va_likely, extra_tags=None):	12✔
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 = ""	12✔
200	if items and album == items[0].album and artist == items[0].albumartist:	12!
201	label = items[0].label	12✔
202	url = self._find_url(items[0], album, "album")	12✔
203	if url:	12!
204	initial_guess = self.get_album_info(url)	12✔
205	if initial_guess:	12!
206	yield from initial_guess	12✔
207	return	12✔
208
209	if "various" in artist.lower():	×
210	artist = ""	×
211
212	search = {"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)):	×
215	yield from res or [None]	×
216
217	def item_candidates(self, item, artist, title):	12✔
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")	12✔
225	label = ""	12✔
226	if item and title == item.title and artist == item.artist:	12!
227	label = item.label	12✔
228	initial_guess = self.get_track_info(url) if url else None	12✔
229	if initial_guess:	12!
230	yield initial_guess	12✔
231	return	12✔
232
233	search = {"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]:	12✔
238	"""Fetch an album by its bandcamp ID."""
239	if not _from_bandcamp(album_id):	12✔
240	self._info("Not a bandcamp URL, skipping")	12✔
241	return None	12✔
242
243	albums = self.get_album_info(album_id)	12✔
244	if not albums:	12✔
245	return None	12✔
246
247	if len(albums) > 1:	12!
248	# get the preferred media
249	preferred = self.beets_config["match"]["preferred"]["media"].get()	12✔
250	pref_to_idx = dict(zip(preferred, range(len(preferred))))	12✔
251	albums = sorted(albums, key=lambda x: pref_to_idx.get(x.media, 100))	12✔
252	return albums[0]	12✔
253
254	def track_for_id(self, track_id: str) -> Optional[TrackInfo]:	12✔
255	"""Fetch a track by its bandcamp ID."""
256	if _from_bandcamp(track_id):	12!
257	return self.get_track_info(track_id)	×
258
259	self._info("Not a bandcamp URL, skipping")	12✔
260	return None	12✔
261
262	def handle_guru(self, attr, url, html=None):	12✔
263	# type: (str, str, Optional[str]) -> Optional[Union[TrackInfo, List[AlbumInfo]]]
264	try:	12✔
265	return getattr(self.guru(url, html=html), attr)	12✔
266	except (KeyError, ValueError, AttributeError, IndexError):	12!
267	self._info("Failed obtaining {}", url)	12✔
268	except Exception: # pylint: disable=broad-except	×
269	i_url = "https://github.com/snejus/beetcamp/issues/new"	×
270	self._exc("Unexpected error obtaining {}, please report at {}", url, i_url)	×
271	return None	12✔
272
273	def get_album_info(self, url: str) -> Optional[List[AlbumInfo]]:	12✔
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)	12✔
278	if "/track/" in url:	12!
NEW 279	m = ALBUM_URL_IN_TRACK.search(html)	×
NEW 280	if m:	×
NEW 281	url = re.sub(r"/track/.*", m.expand(r"\1"), url)	×
UNCOV 282	return self.handle_guru("albums", url)	×
283	return self.handle_guru("albums", url, html)	12✔
284
285	def get_track_info(self, url: str) -> Optional[TrackInfo]:	12✔
286	"""Returns a TrackInfo object for a bandcamp track page."""
287	return self.handle_guru("singleton", url)	12✔
288
289	def _search(self, data: JSONDict) -> Iterable[JSONDict]:	12✔
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:	12✔
298	from argparse import Action, ArgumentParser	12✔
299
300	parser = ArgumentParser(	12✔
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):	12✔
311	def __call__(self, parser, namespace, values, option_string=None):	12✔
312	val = values	12✔
313	if val:	12✔
314	if val.startswith("https://"):	12✔
315	target = "release_url"	12✔
316	else:
317	target = "query"	12✔
318	del namespace.release_url	12✔
319	setattr(namespace, target, val)	12✔
320
321	exclusive = parser.add_mutually_exclusive_group()	12✔
322	exclusive.add_argument(	12✔
323	"release_url",
324	action=UrlOrQueryAction,
325	nargs="?",
326	help="Release URL, starting with https:// OR",
327	)
328	exclusive.add_argument(	12✔
329	"query", action=UrlOrQueryAction, default="", nargs="?", help="Search query"
330	)
331
332	store_const = partial(	12✔
333	parser.add_argument, dest="search_type", action="store_const", default=""
334	)
335	store_const("-a", "--album", const="a", help="Search albums")	12✔
336	store_const("-l", "--label", const="b", help="Search labels and artists")	12✔
337	store_const("-t", "--track", const="t", help="Search tracks")	12✔
338	parser.add_argument(	12✔
339	"-o",
340	"--open",
341	action="store",
342	dest="index",
343	type=int,
344	help="Open search result indexed by INDEX in the browser",
345	)
346	if not args:	12✔
347	parser.print_help()	12✔
348	parser.exit()	12✔
349	return parser.parse_args(args=args)	12✔
350
351
352	def main() -> None:	12✔
353	import json	×
354	import sys	×
355
356	args = get_args(sys.argv[1:])	×
357
358	search_vars = vars(args)	×
359	index = search_vars.pop("index", None)	×
360	if search_vars.get("query"):	×
361	result = search_bandcamp(**search_vars)	×
362	else:
363	pl = BandcampPlugin()	×
364	result = pl.album_for_id(args.release_url) or pl.track_for_id(args.release_url)	×
365	if not result:	×
366	raise AssertionError("Failed to find a release under the given url")
367
368	if index:	×
369	try:	×
370	url = result[index - 1]["url"]	×
371	except IndexError as e:	×
372	raise Exception("Specified index could not be found") from e	×
373
374	import webbrowser	×
375
376	print(f"Opening search result number {index}: {url}")	×
377	webbrowser.open(url)	×
378	else:
379	print(json.dumps(result))	×
380
381
382	if __name__ == "__main__":	12!
383	main()	×

snejus / beetcamp / 3721085587

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