2023393267

Build # 2023393267

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #25 from snejus/dev

Run Details

171 of 244 branches covered (70.08%)

Branch coverage included in aggregate %.

280 of 338 new or added lines in 3 files covered. (82.84%)

40 existing lines in 1 file now uncovered.

563 of 710 relevant lines covered (79.3%)

11.83 hits per line

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

23.5

/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 difflib import SequenceMatcher
from html import unescape
from operator import truth
from typing import Any, Dict, Iterable, List, Optional, Sequence

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

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

from ._metaguru import DATA_SOURCE, DIGI_MEDIA, Metaguru, urlify

JSONDict = Dict[str, Any]

DEFAULT_CONFIG: JSONDict = {
    "preferred_media": DIGI_MEDIA,
    "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",
}

SEARCH_URL = "https://bandcamp.com/search?q={}&item_type={}"
ALBUM_URL_IN_TRACK = re.compile(r"inAlbum.+(https://[^/]+/album/[\w-]+)")
USER_AGENT = f"beets/{__version__} +http://beets.radbox.org/"
ALBUM_SEARCH = "album"
TRACK_SEARCH = "track"


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)


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).
        """
        # TODO: Make this configurable
        if hasattr(album, "art_source") and album.art_source == DATA_SOURCE:
            url = album.mb_albumid
            if isinstance(url, six.string_types) and DATA_SOURCE in url:
                html = self._get(url)
                if html:
                    try:
                        yield self._candidate(
                            url=self.guru(html).image,
                            match=fetchart.Candidate.MATCH_EXACT,
                        )
                    except (KeyError, AttributeError, ValueError):
                        self._info("Unexpected parsing error fetching album art")
                else:
                    self._info("Could not connect to the URL")
            else:
                self._info("Not fetching art for a non-bandcamp album")
        else:
            self._info("Art cover is already present")


def _from_bandcamp(clue: str) -> bool:
    return ".bandcamp." in clue or (
        clue.startswith("http") and ("/album/" in clue or "/track/" in clue)
    )


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

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

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

    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[DATA_SOURCE] = BandcampAlbumArt
            fetchart.SOURCE_NAMES[BandcampAlbumArt] = 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 _cheat_mode(self, item: library.Item, name: str, _type: str) -> str:
        url: str = getattr(item, f"mb_{_type}id", "")
        if "bandcamp" in url:
            self._info("Fetching the URL attached to the first item, {}", url)
            return url

        if item.comments.startswith("Visit"):
            match = re.search(r"https:[\w/.-]+com", item.comments)
            if match:
                url = f"{match.group()}/{_type}/{urlify(name)}"
                self._info("Trying our guess {} before searching", url)
                return url
        return ""

    def candidates(self, items, artist, album, *_, **__):
        # type: (List[library.Item], str, str, Any, Any) -> Iterable[AlbumInfo]
        """Return a sequence of AlbumInfo objects that match the
        album whose items are provided.
        """
        if items:
            url = self._cheat_mode(items[0], album, ALBUM_SEARCH)
            initial_guess = self.get_album_info(url) if url else None
            if initial_guess:
                return iter([initial_guess])

        results = map(lambda x: x["url"], self._search(album, ALBUM_SEARCH, artist))
        return filter(truth, map(self.get_album_info, results))

    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._cheat_mode(item, title, TRACK_SEARCH)
        initial_guess = self.get_track_info(url) if url else None
        if initial_guess:
            return iter([initial_guess])

        query = title or item.album

        results = map(lambda x: x["url"], self._search(query, TRACK_SEARCH, artist))
        return 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 _from_bandcamp(album_id):
            return self.get_album_info(album_id)

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

    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(self, guru: Metaguru, attr: str, _id: str) -> Any:
        try:
            return getattr(guru, attr)
        except (KeyError, ValueError, AttributeError, IndexError):
            self._info("Failed obtaining {}", _id)
        except Exception:  # pylint: disable=broad-except
            url = "https://github.com/snejus/beetcamp/issues/new"
            self._exc("Unexpected error obtaining {}, please report at {}", _id, url)
        return None

    def get_album_info(self, url: str) -> Optional[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)
                html = self._get(url)
        guru = self.guru(url, html=html)
        return self.handle(guru, "album", url) if guru else None

    def get_track_info(self, url: str) -> Optional[TrackInfo]:
        """Returns a TrackInfo object for a bandcamp track page."""
        guru = self.guru(url)
        return self.handle(guru, "singleton", url) if guru else None

    @staticmethod
    def _parse_and_sort_results(html: str, release: str, artist: str) -> List[JSONDict]:
        """Given the html string, find release URLs and artists and sort them
        by similarity.
        similarity = length(longest match between query and result) / length(query)
        When both release name and artist are given, we use the average.
        """
        pat = r"""
(?P<url>https://[^/]+/(album|track)/[\w-]+)[^>]+>
\s*(?P<release>[^\n]+)
.+?\ by\ (?P<artist>[^\n]+)
"""
        pattern = re.compile(pat, re.DOTALL + re.VERBOSE)

        def get_similarity(a: str, b: str) -> float:
            return SequenceMatcher(a=a, b=b).find_longest_match().size / len(a)

        results: List[JSONDict] = []
        for block in html.split('class="heading"'):
            match = pattern.search(block)
            if match:
                res = match.groupdict()
                similarity = get_similarity(release, res["release"])
                if artist:
                    similarity += get_similarity(artist.lower(), res["artist"].lower())
                    similarity /= 2
                res["similarity"] = similarity
                results.append(res)
        return sorted(results, key=lambda x: x["similarity"], reverse=True)

    def _search(
        self,
        query: str,
        search_type: str = ALBUM_SEARCH,
        artist: str = "",
        search_max: int = 0,
    ) -> Iterable[JSONDict]:
        """Return an iterator for item URLs of type search_type matching the query.
        Bandcamp search may be unpredictable, therefore the search results get sorted
        regarding their similarity to what's being queried.
        """
        url = SEARCH_URL.format(query, search_type[0])
        self._info("Searching {}s for {}, URL: {}", search_type, query, url)
        html = self._get(url)

        results = self._parse_and_sort_results(html, query, artist)
        search_max = search_max or self.config["search_max"].as_number()
        return results[:search_max]


def main():
    import json
    import sys

    try:
        url = sys.argv[1]
    except IndexError as exc:
        raise IndexError("bandcamp url is required") from exc
    pl = BandcampPlugin()
    album = pl.album_for_id(url) or pl.track_for_id(url)
    if not album:
        raise AssertionError("Failed to find a release under the given url")

    print(json.dumps(album))


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 difflib import SequenceMatcher	15✔
23	from html import unescape	15✔
24	from operator import truth	15✔
25	from typing import Any, Dict, Iterable, List, Optional, Sequence	15✔
26
27	import requests	15✔
28	import six	15✔
29	from beets import __version__, library, plugins	15✔
30	from beets.autotag.hooks import AlbumInfo, TrackInfo	15✔
31
32	from beetsplug import fetchart # type: ignore[attr-defined]	15✔
33
34	from ._metaguru import DATA_SOURCE, DIGI_MEDIA, Metaguru, urlify	15✔
35
36	JSONDict = Dict[str, Any]	15✔
37
38	DEFAULT_CONFIG: JSONDict = {	15✔
39	"preferred_media": DIGI_MEDIA,
40	"include_digital_only_tracks": True,
41	"search_max": 2,
42	"art": False,
43	"exclude_extra_fields": [],
44	"genre": {
45	"capitalize": False,
46	"maximum": 0,
47	"mode": "progressive",
48	"always_include": [],
49	},
50	"comments_separator": "\n---\n",
51	}
52
53	SEARCH_URL = "https://bandcamp.com/search?q={}&item_type={}"	15✔
54	ALBUM_URL_IN_TRACK = re.compile(r"inAlbum.+(https://[^/]+/album/[\w-]+)")	15✔
55	USER_AGENT = f"beets/{__version__} +http://beets.radbox.org/"	15✔
56	ALBUM_SEARCH = "album"	15✔
57	TRACK_SEARCH = "track"	15✔
58
59
60	class BandcampRequestsHandler:	15✔
61	"""A class that provides an ability to make requests and handles failures."""
62
63	_log: logging.Logger	15✔
64
65	def _exc(self, msg_template: str, *args: Sequence[str]) -> None:	15✔
66	self._log.log(logging.WARNING, msg_template, *args, exc_info=True)	×
67
68	def _info(self, msg_template: str, *args: Sequence[str]) -> None:	15✔
UNCOV 69	self._log.log(logging.DEBUG, msg_template, *args, exc_info=False)	×
70
71	def _get(self, url: str) -> str:	15✔
72	"""Return text contents of the url response."""
UNCOV 73	headers = {"User-Agent": USER_AGENT}	×
UNCOV 74	try:	×
UNCOV 75	response = requests.get(url, headers=headers)	×
UNCOV 76	response.raise_for_status()	×
UNCOV 77	except requests.exceptions.RequestException:	×
UNCOV 78	self._info("Error while fetching URL: {}", url)	×
UNCOV 79	return ""	×
UNCOV 80	return unescape(response.text)	×
81
82
83	class BandcampAlbumArt(BandcampRequestsHandler, fetchart.RemoteArtSource):	15✔
84	NAME = "Bandcamp"	15✔
85
86	def get(self, album, plugin, paths):	15✔
87	# type: (AlbumInfo, plugins.BeetsPlugin, List) -> Iterable[fetchart.Candidate] # noqa
88	"""Return the url for the cover from the bandcamp album page.
89	This only returns cover art urls for bandcamp albums (by id).
90	"""
91	# TODO: Make this configurable
92	if hasattr(album, "art_source") and album.art_source == DATA_SOURCE:	×
93	url = album.mb_albumid	×
94	if isinstance(url, six.string_types) and DATA_SOURCE in url:	×
95	html = self._get(url)	×
96	if html:	×
97	try:	×
98	yield self._candidate(	×
99	url=self.guru(html).image,
100	match=fetchart.Candidate.MATCH_EXACT,
101	)
102	except (KeyError, AttributeError, ValueError):	×
103	self._info("Unexpected parsing error fetching album art")	×
104	else:
105	self._info("Could not connect to the URL")	×
106	else:
107	self._info("Not fetching art for a non-bandcamp album")	×
108	else:
109	self._info("Art cover is already present")	×
110
111
112	def _from_bandcamp(clue: str) -> bool:	15✔
UNCOV 113	return ".bandcamp." in clue or (	×
114	clue.startswith("http") and ("/album/" in clue or "/track/" in clue)
115	)
116
117
118	class BandcampPlugin(BandcampRequestsHandler, plugins.BeetsPlugin):	15✔
119	_gurucache: Dict[str, Metaguru]	15✔
120
121	def __init__(self) -> None:	15✔
UNCOV 122	super().__init__()	×
UNCOV 123	self.config.add(DEFAULT_CONFIG.copy())	×
124
UNCOV 125	self.register_listener("pluginload", self.loaded)	×
UNCOV 126	self._gurucache = {}	×
127
128	def guru(self, url: str, html: Optional[str] = None) -> Optional[Metaguru]:	15✔
129	"""Return cached guru. If there isn't one, fetch the url if html isn't
130	already given, initialise guru and add it to the cache. This way they
131	can be re-used by separate import stages.
132	"""
UNCOV 133	if url in self._gurucache:	×
134	return self._gurucache[url]	×
UNCOV 135	if not html:	×
UNCOV 136	html = self._get(url)	×
UNCOV 137	if html:	×
UNCOV 138	self._gurucache[url] = Metaguru.from_html(html, self.config.flatten())	×
UNCOV 139	return self._gurucache.get(url)	×
140
141	def loaded(self) -> None:	15✔
142	"""Add our own artsource to the fetchart plugin."""
143	# TODO: This is ugly, but i didn't find another way to extend fetchart
144	# without declaring a new plugin.
145	if self.config["art"]:	×
146	fetchart.ART_SOURCES[DATA_SOURCE] = BandcampAlbumArt	×
147	fetchart.SOURCE_NAMES[BandcampAlbumArt] = DATA_SOURCE	×
148	bandcamp_fetchart = BandcampAlbumArt(self._log, self.config)	×
149
150	for plugin in plugins.find_plugins():	×
151	if isinstance(plugin, fetchart.FetchArtPlugin):	×
152	plugin.sources = [bandcamp_fetchart, *plugin.sources]	×
153	break	×
154
155	def _cheat_mode(self, item: library.Item, name: str, _type: str) -> str:	15✔
NEW 156	url: str = getattr(item, f"mb_{_type}id", "")	×
NEW 157	if "bandcamp" in url:	×
NEW 158	self._info("Fetching the URL attached to the first item, {}", url)	×
NEW 159	return url	×
160
UNCOV 161	if item.comments.startswith("Visit"):	×
NEW 162	match = re.search(r"https:[\w/.-]+com", item.comments)	×
UNCOV 163	if match:	×
UNCOV 164	url = f"{match.group()}/{_type}/{urlify(name)}"	×
UNCOV 165	self._info("Trying our guess {} before searching", url)	×
UNCOV 166	return url	×
UNCOV 167	return ""	×
168
169	def candidates(self, items, artist, album, _, *__):	15✔
170	# type: (List[library.Item], str, str, Any, Any) -> Iterable[AlbumInfo]
171	"""Return a sequence of AlbumInfo objects that match the
172	album whose items are provided.
173	"""
UNCOV 174	if items:	×
NEW 175	url = self._cheat_mode(items[0], album, ALBUM_SEARCH)	×
NEW 176	initial_guess = self.get_album_info(url) if url else None	×
177	if initial_guess:	×
178	return iter([initial_guess])	×
179
NEW 180	results = map(lambda x: x["url"], self._search(album, ALBUM_SEARCH, artist))	×
NEW 181	return filter(truth, map(self.get_album_info, results))	×
182
183	def item_candidates(self, item, artist, title):	15✔
184	# type: (library.Item, str, str) -> Iterable[TrackInfo]
185	"""Return a sequence of TrackInfo objects that match the provided item.
186	If the track was downloaded directly from bandcamp, it should contain
187	a comment saying 'Visit <label-url>' - we look at this first by converting
188	title into the format that Bandcamp use.
189	"""
NEW 190	url = self._cheat_mode(item, title, TRACK_SEARCH)	×
NEW 191	initial_guess = self.get_track_info(url) if url else None	×
UNCOV 192	if initial_guess:	×
UNCOV 193	return iter([initial_guess])	×
194
NEW 195	query = title or item.album	×
196
NEW 197	results = map(lambda x: x["url"], self._search(query, TRACK_SEARCH, artist))	×
NEW 198	return filter(truth, map(self.get_track_info, results))	×
199
200	def album_for_id(self, album_id: str) -> Optional[AlbumInfo]:	15✔
201	"""Fetch an album by its bandcamp ID."""
UNCOV 202	if _from_bandcamp(album_id):	×
203	return self.get_album_info(album_id)	×
204
UNCOV 205	self._info("Not a bandcamp URL, skipping")	×
UNCOV 206	return None	×
207
208	def track_for_id(self, track_id: str) -> Optional[TrackInfo]:	15✔
209	"""Fetch a track by its bandcamp ID."""
UNCOV 210	if _from_bandcamp(track_id):	×
211	return self.get_track_info(track_id)	×
212
UNCOV 213	self._info("Not a bandcamp URL, skipping")	×
UNCOV 214	return None	×
215
216	def handle(self, guru: Metaguru, attr: str, _id: str) -> Any:	15✔
UNCOV 217	try:	×
UNCOV 218	return getattr(guru, attr)	×
219	except (KeyError, ValueError, AttributeError, IndexError):	×
220	self._info("Failed obtaining {}", _id)	×
221	except Exception: # pylint: disable=broad-except	×
222	url = "https://github.com/snejus/beetcamp/issues/new"	×
223	self._exc("Unexpected error obtaining {}, please report at {}", _id, url)	×
NEW 224	return None	×
225
226	def get_album_info(self, url: str) -> Optional[AlbumInfo]:	15✔
227	"""Return an AlbumInfo object for a bandcamp album page.
228	If track url is given by mistake, find and fetch the album url instead.
229	"""
NEW 230	html = self._get(url)	×
NEW 231	if "/track/" in url:	×
NEW 232	match = ALBUM_URL_IN_TRACK.search(html)	×
NEW 233	if match:	×
NEW 234	url = re.sub(r"/track/.*", match.expand(r"\1"), url)	×
NEW 235	html = self._get(url)	×
NEW 236	guru = self.guru(url, html=html)	×
UNCOV 237	return self.handle(guru, "album", url) if guru else None	×
238
239	def get_track_info(self, url: str) -> Optional[TrackInfo]:	15✔
240	"""Returns a TrackInfo object for a bandcamp track page."""
UNCOV 241	guru = self.guru(url)	×
UNCOV 242	return self.handle(guru, "singleton", url) if guru else None	×
243
244	@staticmethod	15✔
245	def _parse_and_sort_results(html: str, release: str, artist: str) -> List[JSONDict]:	15✔
246	"""Given the html string, find release URLs and artists and sort them
247	by similarity.
248	similarity = length(longest match between query and result) / length(query)
249	When both release name and artist are given, we use the average.
250	"""
NEW 251	pat = r"""	×
252	(?P<url>https://[^/]+/(album\|track)/[\w-]+)[^>]+>
253	\s*(?P<release>[^\n]+)
254	.+?\ by\ (?P<artist>[^\n]+)
255	"""
NEW 256	pattern = re.compile(pat, re.DOTALL + re.VERBOSE)	×
257
NEW 258	def get_similarity(a: str, b: str) -> float:	×
NEW 259	return SequenceMatcher(a=a, b=b).find_longest_match().size / len(a)	×
260
NEW 261	results: List[JSONDict] = []	×
NEW 262	for block in html.split('class="heading"'):	×
NEW 263	match = pattern.search(block)	×
NEW 264	if match:	×
NEW 265	res = match.groupdict()	×
NEW 266	similarity = get_similarity(release, res["release"])	×
NEW 267	if artist:	×
NEW 268	similarity += get_similarity(artist.lower(), res["artist"].lower())	×
NEW 269	similarity /= 2	×
NEW 270	res["similarity"] = similarity	×
NEW 271	results.append(res)	×
NEW 272	return sorted(results, key=lambda x: x["similarity"], reverse=True)	×
273
274	def _search(	15✔
275	self,
276	query: str,
277	search_type: str = ALBUM_SEARCH,
278	artist: str = "",
279	search_max: int = 0,
280	) -> Iterable[JSONDict]:
281	"""Return an iterator for item URLs of type search_type matching the query.
282	Bandcamp search may be unpredictable, therefore the search results get sorted
283	regarding their similarity to what's being queried.
284	"""
NEW 285	url = SEARCH_URL.format(query, search_type[0])	×
NEW 286	self._info("Searching {}s for {}, URL: {}", search_type, query, url)	×
NEW 287	html = self._get(url)	×
288
NEW 289	results = self._parse_and_sort_results(html, query, artist)	×
NEW 290	search_max = search_max or self.config["search_max"].as_number()	×
NEW 291	return results[:search_max]	×
292
293
294	def main():	15✔
295	import json	×
296	import sys	×
297
298	try:	×
299	url = sys.argv[1]	×
300	except IndexError as exc:	×
301	raise IndexError("bandcamp url is required") from exc	×
302	pl = BandcampPlugin()	×
303	album = pl.album_for_id(url) or pl.track_for_id(url)	×
304	if not album:	×
305	raise AssertionError("Failed to find a release under the given url")
306
307	print(json.dumps(album))	×
308
309
310	if __name__ == "__main__":	15!
311	main()	×

snejus / beetcamp / 2023393267

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