8850257506

Committed 26 Apr 2024 02:59PM UTC coverage: 89.417% (-0.006%) from 89.423%

Build # 8850257506

Build Type

push

github

Committed by

snejus

Commit Message

label: obtain for single releases

Run Details

499 of 566 branches covered (88.16%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

18 existing lines in 1 file now uncovered.

988 of 1097 relevant lines covered (90.06%)

13.4 hits per line

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

69.4

/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 annotations

import logging
import re
from contextlib import contextmanager
from functools import lru_cache, partial
from html import unescape
from itertools import chain
from operator import itemgetter
from typing import TYPE_CHECKING, Any, Dict, Iterable, Iterator, List, Literal, Sequence

import requests
from beets import IncludeLazyConfig, __version__, config, library, plugins

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

from .metaguru import Metaguru
from .search import search_bandcamp

if TYPE_CHECKING:
    from beets.autotag.hooks import AlbumInfo, TrackInfo

JSONDict = Dict[str, Any]
CandidateType = Literal["album", "track"]

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="([^"]+)')
LABEL_URL_IN_COMMENT = re.compile(r"Visit (https:[\w/.-]+com)")
USER_AGENT = f"beets/{__version__} +http://beets.radbox.org/"


@lru_cache(maxsize=None)
def get_response(url: str) -> requests.Response:
    return requests.get(url, headers={"User-Agent": USER_AGENT})


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

    _log: logging.Logger
    config: IncludeLazyConfig

    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."""
        response = get_response(url)
        try:
            response.raise_for_status()
        except requests.HTTPError:
            self._info("URL Not found: {}", url)
            return ""
        return unescape(response.text)

    def guru(self, url: str) -> Metaguru:
        return Metaguru.from_html(self._get(url), config=self.config.flatten())

    @contextmanager
    def handle_error(self, url: str) -> Iterator[Any]:
        """Return Metaguru for the given URL."""
        try:
            yield
        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)


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 __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)
        self.config = self._config

    def get(self, album: AlbumInfo, *_: Any) -> Iterable[fetchart.Candidate]:
        """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:
            with self.handle_error(url):
                if image := self.guru(url).image:
                    yield self._candidate(
                        url=image, 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):
    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)

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

    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_in_item(
        self, item: library.Item, name: str, _type: CandidateType
    ) -> str:
        """Try to extract release URL from the library item.

        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

        if (m := LABEL_URL_IN_COMMENT.match(item.comments)) and (
            urlified_name := urlify(name)
        ):
            label = m.group(1)
            url = f"{label}/{_type}/{urlified_name}"
            self._info("Trying our guess {} before searching", url)
            return url
        return ""

    def candidates(
        self, items: List[library.Item], artist: str, album: str, *_: Any, **__: Any
    ) -> Iterable[AlbumInfo]:
        """Return a sequence of album candidates matching given artist and album."""
        label = ""
        if items and album == items[0].album and artist == items[0].albumartist:
            label = items[0].label
            url = self._find_url_in_item(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))
        yield from chain.from_iterable(filter(None, map(self.get_album_info, results)))

    def item_candidates(
        self, item: library.Item, artist: str, title: str
    ) -> Iterable[TrackInfo]:
        """Return a sequence of singleton candidates matching given artist and title."""
        url = self._find_url_in_item(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(None, map(self.get_track_info, results))

    def album_for_id(self, album_id: str) -> AlbumInfo | None:
        """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) -> TrackInfo | None:
        """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 get_album_info(self, url: str) -> List[AlbumInfo] | None:
        """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 html and "/track/" in url:
            m = ALBUM_URL_IN_TRACK.search(html)
            if m:
                url = re.sub(r"/track/.*", m.expand(r"\1"), url)

        with self.handle_error(url):
            return self.guru(url).albums

    def get_track_info(self, url: str) -> TrackInfo | None:
        """Return a TrackInfo object for a bandcamp track page."""
        with self.handle_error(url):
            return self.guru(url).singleton

    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() -> Any:
    from argparse import Action, ArgumentParser

    if TYPE_CHECKING:
        from argparse import Namespace

    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: ArgumentParser,
            namespace: Namespace,
            values: Any,
            option_string: str | None = None,
        ) -> None:
            if values:
                if values.startswith("https://"):
                    target = "release_url"
                else:
                    target = "query"
                    del namespace.release_url
                setattr(namespace, target, values)

    exclusive = parser.add_mutually_exclusive_group(required=True)
    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",
    )

    return parser.parse_args()


def main() -> None:
    import json

    args = get_args()

    search_vars = vars(args)
    index = search_vars.pop("index", None)
    if search_vars.get("query"):
        search_results = search_bandcamp(**search_vars)

        if index:
            try:
                url = search_results[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(search_results))
    else:
        pl = BandcampPlugin()
        pl._log.setLevel(10)
        url = args.release_url
        result = pl.get_album_info(args.release_url) or pl.get_track_info(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
19	from __future__ import annotations	15✔
20
21	import logging	15✔
22	import re	15✔
23	from contextlib import contextmanager	15✔
24	from functools import lru_cache, partial	15✔
25	from html import unescape	15✔
26	from itertools import chain	15✔
27	from operator import itemgetter	15✔
28	from typing import TYPE_CHECKING, Any, Dict, Iterable, Iterator, List, Literal, Sequence	15✔
29
30	import requests	15✔
31	from beets import IncludeLazyConfig, __version__, config, library, plugins	15✔
32
33	from beetsplug import fetchart # type: ignore[attr-defined]	15✔
34
35	from .metaguru import Metaguru	15✔
36	from .search import search_bandcamp	15✔
37
38	if TYPE_CHECKING:
39	from beets.autotag.hooks import AlbumInfo, TrackInfo
40
41	JSONDict = Dict[str, Any]	15✔
42	CandidateType = Literal["album", "track"]	15✔
43
44	DEFAULT_CONFIG: JSONDict = {	15✔
45	"include_digital_only_tracks": True,
46	"search_max": 2,
47	"art": False,
48	"exclude_extra_fields": [],
49	"genre": {
50	"capitalize": False,
51	"maximum": 0,
52	"mode": "progressive",
53	"always_include": [],
54	},
55	"comments_separator": "\n---\n",
56	}
57
58	ALBUM_URL_IN_TRACK = re.compile(r'<a id="buyAlbumLink" href="([^"]+)')	15✔
59	LABEL_URL_IN_COMMENT = re.compile(r"Visit (https:[\w/.-]+com)")	15✔
60	USER_AGENT = f"beets/{__version__} +http://beets.radbox.org/"	15✔
61
62
63	@lru_cache(maxsize=None)	15✔
64	def get_response(url: str) -> requests.Response:	15✔
65	return requests.get(url, headers={"User-Agent": USER_AGENT})	×
66
67
68	class BandcampRequestsHandler:	15✔
69	"""A class that provides an ability to make requests and handles failures."""
70
71	_log: logging.Logger	15✔
72	config: IncludeLazyConfig	15✔
73
74	def _exc(self, msg_template: str, *args: Sequence[str]) -> None:	15✔
75	self._log.log(logging.WARNING, msg_template, *args, exc_info=True)	×
76
77	def _info(self, msg_template: str, *args: Sequence[str]) -> None:	15✔
78	self._log.log(logging.DEBUG, msg_template, *args, exc_info=False)	15✔
79
80	def _get(self, url: str) -> str:	15✔
81	"""Return text contents of the url response."""
82	response = get_response(url)	×
83	try:	×
84	response.raise_for_status()	×
85	except requests.HTTPError:	×
86	self._info("URL Not found: {}", url)	×
87	return ""	×
88	return unescape(response.text)	×
89
90	def guru(self, url: str) -> Metaguru:	15✔
91	return Metaguru.from_html(self._get(url), config=self.config.flatten())	15✔
92
93	@contextmanager	15✔
94	def handle_error(self, url: str) -> Iterator[Any]:	15✔
95	"""Return Metaguru for the given URL."""
96	try:	15✔
97	yield	15✔
98	except (KeyError, ValueError, AttributeError, IndexError):	15!
99	self._info("Failed obtaining {}", url)	15✔
100	except Exception: # pylint: disable=broad-except	×
101	i_url = "https://github.com/snejus/beetcamp/issues/new"	×
102	self._exc("Unexpected error obtaining {}, please report at {}", url, i_url)	×
103
104
105	def _from_bandcamp(clue: str) -> bool:	15✔
106	"""Check if the clue is likely to be a bandcamp url.
107
108	We could check whether 'bandcamp' is found in the url, however, we would be ignoring
109	cases where the publisher uses their own domain (for example https://eaux.ro) which
110	in reality points to their Bandcamp page. Historically, we found that regardless
111	of the domain, the rest of the url stays the same, therefore '/album/' or '/track/'
112	is what we are looking for in a valid url here.
113	"""
114	return bool(re.match(r"http[^ ]+/(album\|track)/", clue))	15✔
115
116
117	class BandcampAlbumArt(BandcampRequestsHandler, fetchart.RemoteArtSource):	15✔
118	NAME = "Bandcamp"	15✔
119
120	def __init__(self, args: Any, *kwargs: Any) -> None:	15✔
121	super().__init__(args, *kwargs)	15✔
122	self.config = self._config	15✔
123
124	def get(self, album: AlbumInfo, *_: Any) -> Iterable[fetchart.Candidate]:	15✔
125	"""Return the url for the cover from the bandcamp album page.
126
127	This only returns cover art urls for bandcamp albums (by id).
128	"""
129	url = album.mb_albumid	15✔
130	if not _from_bandcamp(url):	15✔
131	self._info("Not fetching art for a non-bandcamp album URL")	15✔
132	else:
133	with self.handle_error(url):	15✔
134	if image := self.guru(url).image:	15✔
135	yield self._candidate(	3✔
136	url=image, match=fetchart.Candidate.MATCH_EXACT
137	)
138
139
140	def urlify(pretty_string: str) -> str:	15✔
141	"""Transform a string into bandcamp url."""
142	name = pretty_string.lower().replace("'", "").replace(".", "")	15✔
143	return re.sub("--+", "-", re.sub(r"\W", "-", name, flags=re.ASCII)).strip("-")	15✔
144
145
146	class BandcampPlugin(BandcampRequestsHandler, plugins.BeetsPlugin):	15✔
147	beets_config: IncludeLazyConfig	15✔
148
149	def __init__(self) -> None:	15✔
150	super().__init__()	15✔
151	self.beets_config = config	15✔
152	self.config.add(DEFAULT_CONFIG.copy())	15✔
153
154	if self.config["art"]:	15!
UNCOV 155	self.register_listener("pluginload", self.loaded)	×
156
157	@property	15✔
158	def data_source(self) -> str:	15✔
159	return "bandcamp"	15✔
160
161	def loaded(self) -> None:	15✔
162	"""Add our own artsource to the fetchart plugin."""
UNCOV 163	for plugin in plugins.find_plugins():	×
164	if isinstance(plugin, fetchart.FetchArtPlugin):	×
165	fetchart.ART_SOURCES[self.data_source] = BandcampAlbumArt	×
166	fetchart.SOURCE_NAMES[BandcampAlbumArt] = self.data_source	×
167	fetchart.SOURCES_ALL.append(self.data_source)	×
168	bandcamp_fetchart = BandcampAlbumArt(self._log, self.config)	×
169	plugin.sources = [bandcamp_fetchart, *plugin.sources]	×
170	break	×
171
172	def _find_url_in_item(	15✔
173	self, item: library.Item, name: str, _type: CandidateType
174	) -> str:
175	"""Try to extract release URL from the library item.
176
177	If the item has previously been imported, `mb_albumid` (or `mb_trackid`
178	for singletons) contains the release url.
179
180	As of 2022 April, Bandcamp purchases (at least in FLAC format) contain string
181	Visit {label_url} in the `comments` field, therefore we try our luck here.
182
183	If it is found, then the album/track name is converted into a valid url
184	representation and appended to the `label_url`. This ends up being the correct
185	url except when:
186	* album name has been updated on Bandcamp but the file contains the old one
187	* album name does not contain a single ascii alphanumeric character
188	- in reality, this becomes '--{num}' in the url, where `num` depends on
189	the number of previous releases that also did not have any valid
190	alphanums. Therefore, we cannot make a reliable guess here.
191	"""
192	url = getattr(item, f"mb_{_type}id", "")	15✔
193	if _from_bandcamp(url):	15✔
194	self._info("Fetching the URL attached to the first item, {}", url)	15✔
195	return url	15✔
196
197	if (m := LABEL_URL_IN_COMMENT.match(item.comments)) and (	15✔
198	urlified_name := urlify(name)
199	):
200	label = m.group(1)	15✔
201	url = f"{label}/{_type}/{urlified_name}"	15✔
202	self._info("Trying our guess {} before searching", url)	15✔
203	return url	15✔
204	return ""	15✔
205
206	def candidates(	15✔
207	self, items: List[library.Item], artist: str, album: str, _: Any, *__: Any
208	) -> Iterable[AlbumInfo]:
209	"""Return a sequence of album candidates matching given artist and album."""
210	label = ""	15✔
211	if items and album == items[0].album and artist == items[0].albumartist:	15!
212	label = items[0].label	15✔
213	url = self._find_url_in_item(items[0], album, "album")	15✔
214	if url:	15!
215	initial_guess = self.get_album_info(url)	15✔
216	if initial_guess:	15!
217	yield from initial_guess	15✔
218	return	15✔
219
UNCOV 220	if "various" in artist.lower():	×
221	artist = ""	×
222
UNCOV 223	search = {"query": album, "artist": artist, "label": label, "search_type": "a"}	×
224	results = map(itemgetter("url"), self._search(search))	×
225	yield from chain.from_iterable(filter(None, map(self.get_album_info, results)))	×
226
227	def item_candidates(	15✔
228	self, item: library.Item, artist: str, title: str
229	) -> Iterable[TrackInfo]:
230	"""Return a sequence of singleton candidates matching given artist and title."""
231	url = self._find_url_in_item(item, title, "track")	15✔
232	label = ""	15✔
233	if item and title == item.title and artist == item.artist:	15!
234	label = item.label	15✔
235	initial_guess = self.get_track_info(url) if url else None	15✔
236	if initial_guess:	15!
237	yield initial_guess	15✔
238	return	15✔
239
UNCOV 240	search = {"query": title, "artist": artist, "label": label, "search_type": "t"}	×
241	results = map(itemgetter("url"), self._search(search))	×
242	yield from filter(None, map(self.get_track_info, results))	×
243
244	def album_for_id(self, album_id: str) -> AlbumInfo \| None:	15✔
245	"""Fetch an album by its bandcamp ID."""
246	if not _from_bandcamp(album_id):	15✔
247	self._info("Not a bandcamp URL, skipping")	15✔
248	return None	15✔
249
250	albums = self.get_album_info(album_id)	15✔
251	if not albums:	15✔
252	return None	15✔
253
254	if len(albums) > 1:	15!
255	# get the preferred media
256	preferred = self.beets_config["match"]["preferred"]["media"].get()	15✔
257	pref_to_idx = dict(zip(preferred, range(len(preferred))))	15✔
258	albums = sorted(albums, key=lambda x: pref_to_idx.get(x.media, 100))	15✔
259	return albums[0]	15✔
260
261	def track_for_id(self, track_id: str) -> TrackInfo \| None:	15✔
262	"""Fetch a track by its bandcamp ID."""
263	if _from_bandcamp(track_id):	15!
UNCOV 264	return self.get_track_info(track_id)	×
265
266	self._info("Not a bandcamp URL, skipping")	15✔
267	return None	15✔
268
269	def get_album_info(self, url: str) -> List[AlbumInfo] \| None:	15✔
270	"""Return an AlbumInfo object for a bandcamp album page.
271
272	If track url is given by mistake, find and fetch the album url instead.
273	"""
274	html = self._get(url)	15✔
275	if html and "/track/" in url:	15!
UNCOV 276	m = ALBUM_URL_IN_TRACK.search(html)	×
277	if m:	×
278	url = re.sub(r"/track/.*", m.expand(r"\1"), url)	×
279
280	with self.handle_error(url):	15✔
281	return self.guru(url).albums	15✔
282
283	def get_track_info(self, url: str) -> TrackInfo \| None:	15✔
284	"""Return a TrackInfo object for a bandcamp track page."""
285	with self.handle_error(url):	15✔
286	return self.guru(url).singleton	15✔
287
288	def _search(self, data: JSONDict) -> Iterable[JSONDict]:	15✔
289	"""Return a list of track/album URLs of type search_type matching the query."""
UNCOV 290	msg = "Searching {}s for {} using {}"	×
291	self._info(msg, data["search_type"], data["query"], str(data))	×
292	results = search_bandcamp(**data, get=self._get)	×
293	return results[: self.config["search_max"].as_number()]	×
294
295
296	def get_args() -> Any:	15✔
297	from argparse import Action, ArgumentParser	15✔
298
299	if TYPE_CHECKING:
300	from argparse import Namespace
301
302	parser = ArgumentParser(	15✔
303	description="""Get bandcamp release metadata from the given <release-url>
304	or perform bandcamp search with <query>. Anything that does not start with https://
305	will be assumed to be a query.
306
307	Search type flags: -a for albums, -l for labels and artists, -t for tracks.
308	By default, all types are searched.
309	"""
310	)
311
312	class UrlOrQueryAction(Action):	15✔
313	def __call__(	15✔
314	self,
315	parser: ArgumentParser,
316	namespace: Namespace,
317	values: Any,
318	option_string: str \| None = None,
319	) -> None:
320	if values:	15✔
321	if values.startswith("https://"):	15✔
322	target = "release_url"	15✔
323	else:
324	target = "query"	15✔
325	del namespace.release_url	15✔
326	setattr(namespace, target, values)	15✔
327
328	exclusive = parser.add_mutually_exclusive_group(required=True)	15✔
329	exclusive.add_argument(	15✔
330	"release_url",
331	action=UrlOrQueryAction,
332	nargs="?",
333	help="Release URL, starting with https:// OR",
334	)
335	exclusive.add_argument(	15✔
336	"query", action=UrlOrQueryAction, default="", nargs="?", help="Search query"
337	)
338
339	store_const = partial(	15✔
340	parser.add_argument, dest="search_type", action="store_const", default=""
341	)
342	store_const("-a", "--album", const="a", help="Search albums")	15✔
343	store_const("-l", "--label", const="b", help="Search labels and artists")	15✔
344	store_const("-t", "--track", const="t", help="Search tracks")	15✔
345	parser.add_argument(	15✔
346	"-o",
347	"--open",
348	action="store",
349	dest="index",
350	type=int,
351	help="Open search result indexed by INDEX in the browser",
352	)
353
354	return parser.parse_args()	15✔
355
356
357	def main() -> None:	15✔
UNCOV 358	import json	×
359
UNCOV 360	args = get_args()	×
361
UNCOV 362	search_vars = vars(args)	×
363	index = search_vars.pop("index", None)	×
364	if search_vars.get("query"):	×
365	search_results = search_bandcamp(**search_vars)	×
366
UNCOV 367	if index:	×
368	try:	×
369	url = search_results[index - 1]["url"]	×
370	except IndexError as e:	×
371	raise Exception("Specified index could not be found") from e	×
372
UNCOV 373	import webbrowser	×
374
UNCOV 375	print(f"Opening search result number {index}: {url}")	×
376	webbrowser.open(url)	×
377	else:
UNCOV 378	print(json.dumps(search_results))	×
379	else:
UNCOV 380	pl = BandcampPlugin()	×
381	pl._log.setLevel(10)	×
382	url = args.release_url	×
383	result = pl.get_album_info(args.release_url) or pl.get_track_info(url)	×
384	if not result:	×
385	raise AssertionError("Failed to find a release under the given url")
386
UNCOV 387	print(json.dumps(result))	×
388
389
390	if __name__ == "__main__":	15!
UNCOV 391	main()	×

snejus / beetcamp / 8850257506

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