mopidy-spotify 5.0.0__py3-none-any.whl

mopidy_spotify/__init__.py

@@ -0,0 +1,70 @@
+import pathlib
+from importlib.metadata import version
+from typing import override
+
+import cyclopts
+from mopidy import config, ext
+
+__version__ = version("mopidy-spotify")
+
+
+class Extension(ext.Extension):
+    dist_name = "mopidy-spotify"
+    ext_name = "spotify"
+    version = __version__
+
+    @override
+    def get_default_config(self) -> str:
+        return config.read(pathlib.Path(__file__).parent / "ext.conf")
+
+    @override
+    def get_config_schema(self) -> config.ConfigSchema:
+        schema = super().get_config_schema()
+
+        schema["username"] = config.Deprecated()  # since 5.0
+        schema["password"] = config.Deprecated()  # since 5.0
+
+        schema["client_id"] = config.String()
+        schema["client_secret"] = config.Secret()
+
+        schema["bitrate"] = config.Integer(choices=(96, 160, 320))
+        schema["volume_normalization"] = config.Boolean()
+        schema["private_session"] = config.Deprecated()  # since 5.0
+
+        schema["timeout"] = config.Integer(minimum=0)
+
+        schema["cache_dir"] = config.Deprecated()  # since 2.0
+        schema["settings_dir"] = config.Deprecated()  # since 2.0
+
+        schema["allow_cache"] = config.Boolean()
+        schema["cache_size"] = config.Integer(minimum=0)
+
+        schema["allow_network"] = config.Deprecated()  # since 5.0
+        schema["allow_playlists"] = config.Boolean()
+
+        schema["search_album_count"] = config.Integer(minimum=0, maximum=200)
+        schema["search_artist_count"] = config.Integer(minimum=0, maximum=200)
+        schema["search_track_count"] = config.Integer(minimum=0, maximum=200)
+
+        schema["toplist_countries"] = config.Deprecated()  # since 5.0
+
+        return schema
+
+    @override
+    def setup(self, registry: ext.Registry) -> None:
+        from mopidy_spotify.backend import SpotifyBackend  # noqa: PLC0415
+
+        registry.add("backend", SpotifyBackend)
+
+    @override
+    def get_command(self) -> cyclopts.App:
+        from .commands import app  # noqa: PLC0415
+
+        return app
+
+    @classmethod
+    def get_credentials_dir(cls, config: config.Config) -> pathlib.Path:
+        data_dir = cls.get_data_dir(config)
+        credentials_dir = data_dir / "credentials-cache"
+        credentials_dir.mkdir(mode=0o700, exist_ok=True)
+        return credentials_dir

mopidy_spotify/backend.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, cast, override
+
+import pykka
+from mopidy import backend
+from mopidy.types import UriScheme
+
+from mopidy_spotify import Extension, library, playlists, web
+
+if TYPE_CHECKING:
+    from mopidy.audio import AudioProxy
+    from mopidy.config import Config
+
+    from mopidy_spotify.types import SpotifyConfig
+
+
+class SpotifyBackend(pykka.ThreadingActor, backend.Backend):
+    uri_schemes: ClassVar[list[UriScheme]] = [UriScheme("spotify")]
+
+    def __init__(self, *, config: Config, audio: AudioProxy) -> None:
+        super().__init__()
+
+        self._config = config
+        self._audio = audio
+        self._bitrate = config["spotify"]["bitrate"]
+        self._web_client = None
+
+        self.library = library.SpotifyLibraryProvider(backend=self)
+        self.playback = SpotifyPlaybackProvider(audio=audio, backend=self)
+        if config["spotify"]["allow_playlists"]:
+            self.playlists = playlists.SpotifyPlaylistsProvider(backend=self)
+        else:
+            self.playlists = None
+
+    def on_start(self) -> None:
+        self._web_client = web.SpotifyOAuthClient(
+            client_id=self._config["spotify"]["client_id"],
+            client_secret=self._config["spotify"]["client_secret"],
+            proxy_config=self._config["proxy"],
+        )
+        self._web_client.login()
+
+        if self.playlists is not None:
+            self.playlists.refresh()
+
+
+class SpotifyPlaybackProvider(backend.PlaybackProvider):
+    backend: SpotifyBackend
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._cache_location = Extension().get_cache_dir(self.backend._config)
+        self._credentials_dir = Extension().get_credentials_dir(self.backend._config)
+        self._config = cast("SpotifyConfig", self.backend._config["spotify"])
+
+    @override
+    def on_source_setup(
+        self,
+        source: Any,  # Gst.Element, but want to avoid Gst imports here
+    ) -> None:
+        assert self.backend._web_client  # noqa: S101
+        source.set_property("bitrate", str(self._config["bitrate"]))
+        source.set_property("cache-credentials", self._credentials_dir)
+        source.set_property("access-token", self.backend._web_client.token())
+        if self._config["allow_cache"]:
+            source.set_property("cache-files", self._cache_location)
+            source.set_property("cache-max-size", self._config["cache_size"] * 1048576)

mopidy_spotify/browse.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from mopidy.models import Ref
+from mopidy.types import Uri
+
+from mopidy_spotify import playlists, translator
+from mopidy_spotify.utils import flatten
+from mopidy_spotify.web import WebLink
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from mopidy_spotify.types import SpotifyConfig
+    from mopidy_spotify.web import SpotifyOAuthClient
+
+logger = logging.getLogger(__name__)
+
+ROOT_DIR = Ref.directory(uri=Uri("spotify:directory"), name="Spotify")
+
+_TOP_LIST_DIR = Ref.directory(uri=Uri("spotify:top"), name="Top lists")
+_YOUR_MUSIC_DIR = Ref.directory(uri=Uri("spotify:your"), name="Your music")
+_PLAYLISTS_DIR = Ref.directory(uri=Uri("spotify:playlists"), name="Playlists")
+
+_ROOT_DIR_CONTENTS = [
+    _TOP_LIST_DIR,
+    _YOUR_MUSIC_DIR,
+    _PLAYLISTS_DIR,
+]
+
+_TOP_LIST_DIR_CONTENTS = [
+    Ref.directory(uri=Uri("spotify:top:tracks"), name="Top tracks"),
+    Ref.directory(uri=Uri("spotify:top:artists"), name="Top artists"),
+]
+
+_YOUR_MUSIC_DIR_CONTENTS = [
+    Ref.directory(uri=Uri("spotify:your:tracks"), name="Your tracks"),
+    Ref.directory(uri=Uri("spotify:your:albums"), name="Your albums"),
+]
+
+_PLAYLISTS_DIR_CONTENTS = [
+    Ref.directory(uri=Uri("spotify:playlists:featured"), name="Featured"),
+]
+
+
+BROWSE_DIR_URIS = {
+    directory.uri
+    for directory in [
+        ROOT_DIR,
+        *_ROOT_DIR_CONTENTS,
+        *_TOP_LIST_DIR_CONTENTS,
+        *_YOUR_MUSIC_DIR_CONTENTS,
+        *_PLAYLISTS_DIR_CONTENTS,
+    ]
+}
+
+
+def browse(  # noqa: C901, PLR0911, PLR0912
+    *,
+    config: SpotifyConfig,  # noqa: ARG001
+    web_client: SpotifyOAuthClient,
+    uri: Uri,
+) -> list[Ref]:
+    if uri == ROOT_DIR.uri:
+        return _ROOT_DIR_CONTENTS
+    if uri == _TOP_LIST_DIR.uri:
+        return _TOP_LIST_DIR_CONTENTS
+    if uri == _YOUR_MUSIC_DIR.uri:
+        return _YOUR_MUSIC_DIR_CONTENTS
+    if uri == _PLAYLISTS_DIR.uri:
+        return _PLAYLISTS_DIR_CONTENTS
+
+    if not web_client.logged_in:
+        return []
+
+    # TODO: Support for category browsing.
+    if uri.startswith(("spotify:user:", "spotify:playlist:")):
+        return _browse_playlist(web_client, uri)
+    if uri.startswith("spotify:album:"):
+        return _browse_album(web_client, uri)
+    if uri.startswith("spotify:artist:"):
+        return _browse_artist(web_client, uri)
+    if uri.startswith("spotify:top:"):
+        parts = uri.replace("spotify:top:", "").split(":")
+        if len(parts) != 1:
+            logger.info(f"Failed to browse {uri!r}: Toplist URI parsing failed")
+            return []
+        return _browse_toplist_user(web_client, variant=parts[0])
+    if uri.startswith("spotify:your:"):
+        parts = uri.replace("spotify:your:", "").split(":")
+        if len(parts) == 1:
+            return _browse_your_music(web_client, variant=parts[0])
+    if uri.startswith("spotify:playlists:"):
+        parts = uri.replace("spotify:playlists:", "").split(":")
+        if len(parts) == 1:
+            return _browse_playlists(web_client, variant=parts[0])
+
+    logger.info(f"Failed to browse {uri!r}: Unknown URI type")
+    return []
+
+
+def _browse_playlist(
+    web_client: SpotifyOAuthClient,
+    uri: Uri,
+) -> list[Ref]:
+    playlist_items = playlists.playlist_lookup(
+        web_client,
+        uri,
+        bitrate=None,
+        as_items=True,
+    )
+    return playlist_items if playlist_items is not None else []
+
+
+def _browse_album(web_client: SpotifyOAuthClient, uri: Uri) -> list[Ref]:
+    try:
+        link = WebLink.from_uri(uri)
+    except ValueError as exc:
+        logger.info(f"Failed to browse {uri!r}: {exc}")
+        return []
+
+    for web_album in web_client.get_albums([link]):
+        web_tracks = web_album.get("tracks", {}).get("items", [])
+        return list(translator.web_to_track_refs(web_tracks))
+    return []
+
+
+def _browse_artist(web_client: SpotifyOAuthClient, uri: Uri) -> list[Ref]:
+    try:
+        link = WebLink.from_uri(uri)
+    except ValueError as exc:
+        logger.info(f"Failed to browse {uri!r}: {exc}")
+        return []
+
+    web_top_tracks = web_client.get_artist_top_tracks(link)
+    top_tracks = list(translator.web_to_track_refs(web_top_tracks))
+
+    web_albums = web_client.get_artist_albums(link, all_tracks=False)
+    albums = list(translator.web_to_album_refs(web_albums))
+
+    return top_tracks + albums
+
+
+def _browse_toplist_user(web_client: SpotifyOAuthClient, variant: str) -> list[Ref]:
+    if not web_client.logged_in:
+        return []
+
+    if variant in ("tracks", "artists"):
+        items = flatten(
+            [
+                page.get("items", [])
+                for page in web_client.get_all(
+                    f"me/top/{variant}",
+                    params={"limit": 50},
+                )
+                if page
+            ]
+        )
+        match variant:
+            case "tracks":
+                return list(translator.web_to_track_refs(items, check_playable=False))
+            case "artists":
+                return list(translator.web_to_artist_refs(items))
+    else:
+        return []
+
+
+def _load_your_music(web_client: SpotifyOAuthClient, variant: str) -> Iterator[Any]:
+    if not web_client.logged_in:
+        return
+
+    if variant not in ("tracks", "albums"):
+        return
+
+    results = web_client.get_all(
+        f"me/{variant}",
+        params={"market": "from_token", "limit": 50},
+    )
+    for page in results:
+        if not page:
+            continue
+        items = page.get("items", [])
+        yield from items
+
+
+def _browse_your_music(web_client: SpotifyOAuthClient, variant: str) -> list[Ref]:
+    items = _load_your_music(web_client, variant)
+    match variant:
+        case "tracks":
+            return list(translator.web_to_track_refs(items))
+        case "albums":
+            return list(translator.web_to_album_refs(items))
+        case _:
+            return []
+
+
+def _browse_playlists(web_client: SpotifyOAuthClient, variant: str) -> list[Ref]:
+    if not web_client.logged_in:
+        return []
+
+    if variant != "featured":
+        return []
+
+    items = flatten(
+        [
+            page.get("playlists", {}).get("items", [])
+            for page in web_client.get_all(
+                "browse/featured-playlists",
+                params={"limit": 50},
+            )
+            if page
+        ]
+    )
+    return list(translator.to_playlist_refs(items))

mopidy_spotify/commands.py

@@ -0,0 +1,35 @@
+import logging
+import os
+from pathlib import Path
+
+import cyclopts
+from mopidy.config import Config
+
+from mopidy_spotify import Extension
+
+logger = logging.getLogger(__name__)
+
+
+app = cyclopts.App(help="Spotify extension commands.")
+
+
+@app.command(help="Logout from Spotify account.")
+def logout() -> None:
+    config = Config.get_global()
+    credentials_dir = Extension().get_credentials_dir(config)
+    try:
+        for root, dirs, files in os.walk(credentials_dir, topdown=False):
+            root_path = Path(root)
+            for name in files:
+                file_path = root_path / name
+                file_path.unlink()
+                logger.debug(f"Removed file {file_path}")
+            for name in dirs:
+                dir_path = root_path / name
+                dir_path.rmdir()
+                logger.debug(f"Removed directory {dir_path}")
+        credentials_dir.rmdir()
+    except Exception as error:  # noqa: BLE001
+        logger.warning(f"Failed to logout from Spotify: {error}")
+    else:
+        logger.info("Logged out from Spotify")

mopidy_spotify/distinct.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from mopidy_spotify import search
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    from mopidy.models import SearchResult, Track
+    from mopidy.types import DistinctField, Query, SearchField
+
+    from mopidy_spotify.playlists import SpotifyPlaylistsProvider
+    from mopidy_spotify.types import SpotifyConfig
+    from mopidy_spotify.web import SpotifyOAuthClient
+
+logger = logging.getLogger(__name__)
+
+
+def get_distinct(
+    config: SpotifyConfig,
+    playlists: SpotifyPlaylistsProvider,
+    web_client: SpotifyOAuthClient,
+    field: DistinctField,
+    query: Query[SearchField] | None = None,
+) -> set[str]:
+    # To make the returned data as interesting as possible, we limit
+    # ourselves to data extracted from the user's playlists when no search
+    # query is included.
+    # TODO: Perhaps should use tracks from My Music instead?
+    if not web_client.logged_in:
+        return set()
+
+    match field:
+        case "artist":
+            result = _get_distinct_artists(config, playlists, web_client, query)
+        case "albumartist":
+            result = _get_distinct_albumartists(config, playlists, web_client, query)
+        case "album":
+            result = _get_distinct_albums(config, playlists, web_client, query)
+        case "date":
+            result = _get_distinct_dates(config, playlists, web_client, query)
+        case _:
+            result = set()
+
+    return {x for x in result if isinstance(x, str)}
+
+
+def _get_distinct_artists(
+    config: SpotifyConfig,
+    playlists: SpotifyPlaylistsProvider,
+    web_client: SpotifyOAuthClient,
+    query: Query[SearchField] | None,
+) -> set[str]:
+    logger.debug(f"Getting distinct artists: {query}")
+
+    if query:
+        search_result = _get_search(config, web_client, query, artist=True)
+        return {
+            artist.name for artist in search_result.artists if artist.name is not None
+        }
+
+    return {
+        artist.name
+        for track in _get_playlist_tracks(config, playlists, web_client)
+        for artist in track.artists
+        if artist.name is not None
+    }
+
+
+def _get_distinct_albumartists(
+    config: SpotifyConfig,
+    playlists: SpotifyPlaylistsProvider,
+    web_client: SpotifyOAuthClient,
+    query: Query[SearchField] | None,
+) -> set[str]:
+    logger.debug(f"Getting distinct albumartists: {query}")
+
+    if query:
+        search_result = _get_search(config, web_client, query, album=True)
+        return {
+            artist.name
+            for album in search_result.albums
+            for artist in album.artists
+            if artist.name is not None
+        }
+
+    return {
+        artist.name
+        for track in _get_playlist_tracks(config, playlists, web_client)
+        if track.album and track.album.artists
+        for artist in track.album.artists
+        if artist.name is not None
+    }
+
+
+def _get_distinct_albums(
+    config: SpotifyConfig,
+    playlists: SpotifyPlaylistsProvider,
+    web_client: SpotifyOAuthClient,
+    query: Query[SearchField] | None,
+) -> set[str]:
+    logger.debug(f"Getting distinct albums: {query}")
+
+    if query:
+        search_result = _get_search(config, web_client, query, album=True)
+        return {album.name for album in search_result.albums if album.name is not None}
+
+    return {
+        track.album.name
+        for track in _get_playlist_tracks(config, playlists, web_client)
+        if track.album and track.album.name is not None
+    }
+
+
+def _get_distinct_dates(
+    config: SpotifyConfig,
+    playlists: SpotifyPlaylistsProvider,
+    web_client: SpotifyOAuthClient,
+    query: Query[SearchField] | None,
+) -> set[str]:
+    logger.debug(f"Getting distinct album years: {query}")
+
+    if query:
+        search_result = _get_search(config, web_client, query, album=True)
+        return {
+            album.date
+            for album in search_result.albums
+            if album.date not in (None, "0")
+        }
+
+    return {
+        f"{track.album.date}"
+        for track in _get_playlist_tracks(config, playlists, web_client)
+        if track.album and track.album.date not in (None, 0)
+    }
+
+
+def _get_search(  # noqa: PLR0913
+    config: SpotifyConfig,
+    web_client: SpotifyOAuthClient,
+    query: Query[SearchField],
+    *,
+    album: bool = False,
+    artist: bool = False,
+    track: bool = False,
+) -> SearchResult:
+    types = []
+    if album:
+        types.append("album")
+    if artist:
+        types.append("artist")
+    if track:
+        types.append("track")
+
+    return search.search(
+        config,
+        web_client,
+        query=query,
+        types=types,
+    )
+
+
+def _get_playlist_tracks(
+    config: SpotifyConfig,
+    playlists: SpotifyPlaylistsProvider,
+    web_client: SpotifyOAuthClient,  # noqa: ARG001
+) -> Generator[Track]:
+    if not config["allow_playlists"]:
+        return
+
+    for playlist_ref in playlists.as_list():
+        playlist = playlists.lookup(playlist_ref.uri)
+        if playlist:
+            yield from playlist.tracks

mopidy_spotify/ext.conf

@@ -0,0 +1,13 @@
+[spotify]
+enabled = true
+client_id =
+client_secret =
+bitrate = 160
+volume_normalization = true
+timeout = 10
+allow_cache = true
+cache_size = 8192
+allow_playlists = true
+search_album_count = 20
+search_artist_count = 10
+search_track_count = 50

mopidy_spotify/images.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from mopidy_spotify.browse import BROWSE_DIR_URIS
+from mopidy_spotify.translator import web_to_image
+from mopidy_spotify.utils import group_by_type
+from mopidy_spotify.web import LinkType, WebLink
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from mopidy.models import Image
+    from mopidy.types import Uri
+
+    from mopidy_spotify.web import SpotifyOAuthClient
+
+SUPPORTED_TYPES = (
+    LinkType.TRACK,
+    LinkType.ALBUM,
+    LinkType.ARTIST,
+    LinkType.PLAYLIST,
+)
+
+_cache = {}  # (type, id) -> [Image(), ...]
+
+logger = logging.getLogger(__name__)
+
+
+def get_images(
+    web_client: SpotifyOAuthClient,
+    uris: Iterable[Uri],
+) -> dict[Uri, list[Image]]:
+    result: dict[Uri, list[Image]] = {}
+    links = (_parse_uri(u) for u in uris)
+    for link_type, link_group in group_by_type(links):
+        batch = []
+        for link in link_group:
+            key = _make_cache_key(link)
+            if key in _cache:
+                result[link.uri] = _cache[key]
+            elif link_type == LinkType.PLAYLIST:
+                result.update(_process_one(web_client, link))
+            else:
+                batch.append(link)
+        result.update(_process_many(web_client, link_type, batch))
+    return result
+
+
+def _make_cache_key(link: WebLink) -> tuple[LinkType, str | None]:
+    return (link.type, link.id)
+
+
+def _parse_uri(uri: Uri) -> WebLink | None:
+    if uri in BROWSE_DIR_URIS:
+        return None  # These are internal to the extension.
+    try:
+        link = WebLink.from_uri(uri)
+        if link.type not in SUPPORTED_TYPES:
+            msg = f"Unsupported image type '{link.type}' in {uri!r}"
+            raise ValueError(msg)  # noqa: TRY301
+        if not link.id:
+            msg = "ID missing"
+            raise ValueError(msg)  # noqa: TRY301
+    except Exception as e:
+        logger.exception(f"Could not parse {uri!r} as a Spotify URI ({e!s})")  # noqa: TRY401
+        return None
+
+    return link
+
+
+def _process_one(
+    web_client: SpotifyOAuthClient,
+    link: WebLink,
+) -> dict[Uri, list[Image]]:
+    data = web_client.get(f"{link.type}s/{link.id}")
+    key = _make_cache_key(link)
+    _cache[key] = [web_to_image(i) for i in data.get("images") or []]
+    return {link.uri: _cache[key]}
+
+
+def _process_many(
+    web_client: SpotifyOAuthClient,
+    link_type: LinkType,
+    links: list[WebLink],
+) -> dict[Uri, list[Image]]:
+    result: dict[Uri, list[Image]] = {}
+    if not links:
+        return result
+
+    for link, item in web_client.get_batch(link_type, links):
+        key = _make_cache_key(link)
+        if link_type == LinkType.TRACK:
+            if not (album_item := item.get("album")):
+                continue
+            if not (album_link := _parse_uri(album_item.get("uri"))):
+                continue
+            album_key = _make_cache_key(album_link)
+            if album_key not in _cache:
+                _cache[album_key] = [
+                    web_to_image(i) for i in album_item.get("images") or []
+                ]
+            _cache[key] = _cache[album_key]
+        else:
+            _cache[key] = [web_to_image(i) for i in item.get("images") or []]
+        result[link.uri] = _cache[key]
+
+    return result