833 lines
24 KiB
Python
833 lines
24 KiB
Python
import re
|
|
import threading
|
|
import time
|
|
from typing import Collection, Optional, Union
|
|
|
|
from platypush.plugins import action
|
|
from platypush.plugins.music import MusicPlugin
|
|
|
|
|
|
class MusicMpdPlugin(MusicPlugin):
|
|
"""
|
|
This plugin allows you to interact with an MPD/Mopidy music server.
|
|
|
|
`MPD <https://www.musicpd.org/>`_ is a flexible server-side
|
|
protocol/application for handling music collections and playing music,
|
|
mostly aimed to manage local libraries.
|
|
|
|
`Mopidy <https://www.mopidy.com/>`_ is an evolution of MPD, compatible with
|
|
the original protocol and with support for multiple music sources through
|
|
plugins (e.g. Spotify, TuneIn, Soundcloud, local files etc.).
|
|
|
|
.. note:: As of Mopidy 3.0 MPD is an optional interface provided by the
|
|
``mopidy-mpd`` extension. Make sure that you have the extension
|
|
installed and enabled on your instance to use this plugin with your
|
|
server.
|
|
|
|
"""
|
|
|
|
_client_lock = threading.RLock()
|
|
|
|
def __init__(self, host: str, port: int = 6600):
|
|
"""
|
|
:param host: MPD IP/hostname
|
|
:param port: MPD port (default: 6600)
|
|
"""
|
|
|
|
super().__init__()
|
|
self.host = host
|
|
self.port = port
|
|
self.client = None
|
|
|
|
def _connect(self, n_tries: int = 2):
|
|
import mpd
|
|
|
|
with self._client_lock:
|
|
if self.client:
|
|
return self.client
|
|
|
|
error = None
|
|
while n_tries > 0:
|
|
try:
|
|
n_tries -= 1
|
|
self.client = mpd.MPDClient()
|
|
self.client.connect(self.host, self.port)
|
|
return self.client
|
|
except Exception as e:
|
|
error = e
|
|
self.logger.warning(
|
|
'Connection exception: %s%s',
|
|
e,
|
|
(': Retrying' if n_tries > 0 else ''),
|
|
)
|
|
time.sleep(0.5)
|
|
|
|
self.client = None
|
|
if error:
|
|
raise error
|
|
|
|
return self.client
|
|
|
|
def _exec(self, method: str, *args, **kwargs):
|
|
error = None
|
|
n_tries = int(kwargs.pop('n_tries')) if 'n_tries' in kwargs else 2
|
|
return_status = (
|
|
kwargs.pop('return_status') if 'return_status' in kwargs else True
|
|
)
|
|
|
|
while n_tries > 0:
|
|
try:
|
|
self._connect()
|
|
n_tries -= 1
|
|
with self._client_lock:
|
|
response = getattr(self.client, method)(*args, **kwargs)
|
|
|
|
if return_status:
|
|
return self.status().output
|
|
return response
|
|
except Exception as e:
|
|
error = str(e)
|
|
self.logger.warning(
|
|
'Exception while executing MPD method %s: %s', method, error
|
|
)
|
|
self.client = None
|
|
|
|
return None, error
|
|
|
|
@action
|
|
def play(self, resource: Optional[str] = None, **__):
|
|
"""
|
|
Play a resource by path/URI.
|
|
|
|
:param resource: Resource path/URI
|
|
:type resource: str
|
|
"""
|
|
|
|
if resource:
|
|
self.add(resource, position=0)
|
|
return self.play_pos(0)
|
|
|
|
return self._exec('play')
|
|
|
|
@action
|
|
def play_pos(self, pos: int):
|
|
"""
|
|
Play a track in the current playlist by position number.
|
|
|
|
:param pos: Position number.
|
|
"""
|
|
|
|
return self._exec('play', pos)
|
|
|
|
@action
|
|
def pause(self, *_, **__):
|
|
"""Pause playback"""
|
|
|
|
status = self._status()['state']
|
|
return self._exec('pause') if status == 'play' else self._exec('play')
|
|
|
|
@action
|
|
def pause_if_playing(self):
|
|
"""Pause playback only if it's playing"""
|
|
status = self._status()['state']
|
|
return self._exec('pause') if status == 'play' else None
|
|
|
|
@action
|
|
def play_if_paused(self):
|
|
"""Play only if it's paused (resume)"""
|
|
status = self._status()['state']
|
|
return self._exec('play') if status == 'pause' else None
|
|
|
|
@action
|
|
def play_if_paused_or_stopped(self):
|
|
"""Play only if it's paused or stopped"""
|
|
status = self._status()['state']
|
|
return self._exec('play') if status in ('pause', 'stop') else None
|
|
|
|
@action
|
|
def stop(self, *_, **__):
|
|
"""Stop playback"""
|
|
return self._exec('stop')
|
|
|
|
@action
|
|
def play_or_stop(self):
|
|
"""Play or stop (play state toggle)"""
|
|
status = self._status()['state']
|
|
if status == 'play':
|
|
return self._exec('stop')
|
|
return self._exec('play')
|
|
|
|
@action
|
|
def playid(self, track_id: str):
|
|
"""
|
|
Play a track by ID.
|
|
|
|
:param track_id: Track ID.
|
|
"""
|
|
return self._exec('playid', track_id)
|
|
|
|
@action
|
|
def next(self, *_, **__):
|
|
"""Play the next track"""
|
|
return self._exec('next')
|
|
|
|
@action
|
|
def previous(self, **__):
|
|
"""Play the previous track"""
|
|
return self._exec('previous')
|
|
|
|
@action
|
|
def setvol(self, vol: int):
|
|
"""
|
|
Set the volume.
|
|
|
|
..warning :: **DEPRECATED**, use :meth:`.set_volume` instead.
|
|
|
|
:param vol: Volume value (range: 0-100).
|
|
"""
|
|
return self.set_volume(vol)
|
|
|
|
@action
|
|
def set_volume(self, volume: int, **__):
|
|
"""
|
|
Set the volume.
|
|
|
|
:param volume: Volume value (range: 0-100).
|
|
"""
|
|
return self._exec('setvol', str(volume))
|
|
|
|
@action
|
|
def volup(self, step: Optional[float] = None, **kwargs):
|
|
"""
|
|
Turn up the volume.
|
|
|
|
:param step: Volume up step (default: 5%).
|
|
"""
|
|
step = step or kwargs.get('delta') or 5
|
|
volume = int(self._status()['volume'])
|
|
new_volume = min(volume + step, 100)
|
|
return self.setvol(new_volume)
|
|
|
|
@action
|
|
def voldown(self, step: Optional[float] = None, **kwargs):
|
|
"""
|
|
Turn down the volume.
|
|
|
|
:param step: Volume down step (default: 5%).
|
|
"""
|
|
step = step or kwargs.get('delta') or 5
|
|
volume = int(self._status()['volume'])
|
|
new_volume = max(volume - step, 0)
|
|
return self.setvol(new_volume)
|
|
|
|
def _toggle(self, key: str, value: Optional[bool] = None):
|
|
if value is None:
|
|
value = bool(self._status()[key])
|
|
return self._exec(key, int(value))
|
|
|
|
@action
|
|
def random(self, value: Optional[bool] = None):
|
|
"""
|
|
Set random mode.
|
|
|
|
:param value: If set, set the random state this value (true/false).
|
|
Default: None (toggle current state).
|
|
"""
|
|
return self._toggle('random', value)
|
|
|
|
@action
|
|
def consume(self, value: Optional[bool] = None):
|
|
"""
|
|
Set consume mode.
|
|
|
|
:param value: If set, set the consume state this value (true/false).
|
|
Default: None (toggle current state)
|
|
"""
|
|
return self._toggle('consume', value)
|
|
|
|
@action
|
|
def single(self, value: Optional[bool] = None):
|
|
"""
|
|
Set single mode.
|
|
|
|
:param value: If set, set the consume state this value (true/false).
|
|
Default: None (toggle current state)
|
|
"""
|
|
return self._toggle('single', value)
|
|
|
|
@action
|
|
def repeat(self, value: Optional[bool] = None):
|
|
"""
|
|
Set repeat mode.
|
|
|
|
:param value: If set, set the repeat state this value (true/false).
|
|
Default: None (toggle current state)
|
|
"""
|
|
return self._toggle('repeat', value)
|
|
|
|
@action
|
|
def shuffle(self):
|
|
"""
|
|
Shuffles the current playlist.
|
|
"""
|
|
return self._exec('shuffle')
|
|
|
|
@action
|
|
def save(self, name: str):
|
|
"""
|
|
Save the current tracklist to a new playlist with the specified name.
|
|
|
|
:param name: Name of the playlist
|
|
"""
|
|
return self._exec('save', name)
|
|
|
|
@action
|
|
def add(self, resource: str, *_, position: Optional[int] = None, **__):
|
|
"""
|
|
Add a resource (track, album, artist, folder etc.) to the current
|
|
playlist.
|
|
|
|
:param resource: Resource path or URI.
|
|
:param position: Position where the track(s) will be inserted (default:
|
|
end of the playlist).
|
|
"""
|
|
|
|
if isinstance(resource, list):
|
|
for r in resource:
|
|
r = self._parse_resource(r)
|
|
try:
|
|
if position is None:
|
|
self._exec('add', r)
|
|
else:
|
|
self._exec('addid', r, position)
|
|
except Exception as e:
|
|
self.logger.warning('Could not add %s: %s', r, e)
|
|
|
|
return self.status().output
|
|
|
|
r = self._parse_resource(resource)
|
|
|
|
if position is None:
|
|
return self._exec('add', r)
|
|
return self._exec('addid', r, position)
|
|
|
|
@action
|
|
def delete(self, positions):
|
|
"""
|
|
Delete the playlist item(s) in the specified position(s).
|
|
|
|
:param positions: Positions of the tracks to be removed
|
|
:type positions: list[int]
|
|
|
|
:return: The modified playlist
|
|
"""
|
|
|
|
for pos in sorted(positions, key=int, reverse=True):
|
|
self._exec('delete', pos)
|
|
return self.playlistinfo()
|
|
|
|
@action
|
|
def rm(self, playlist):
|
|
"""
|
|
Permanently remove playlist(s) by name
|
|
|
|
:param playlist: Name or list of playlist names to remove
|
|
:type playlist: str or list[str]
|
|
"""
|
|
|
|
if isinstance(playlist, str):
|
|
playlist = [playlist]
|
|
elif not isinstance(playlist, list):
|
|
raise RuntimeError(f'Invalid type for playlist: {type(playlist)}')
|
|
|
|
for p in playlist:
|
|
self._exec('rm', p)
|
|
|
|
@action
|
|
def move(self, from_pos, to_pos):
|
|
"""
|
|
Move the playlist item in position <from_pos> to position <to_pos>
|
|
|
|
:param from_pos: Track current position
|
|
:type from_pos: int
|
|
|
|
:param to_pos: Track new position
|
|
:type to_pos: int
|
|
"""
|
|
return self._exec('move', from_pos, to_pos)
|
|
|
|
@classmethod
|
|
def _parse_resource(cls, resource):
|
|
if not resource:
|
|
return None
|
|
|
|
m = re.search(r'^https?://open\.spotify\.com/([^?]+)', resource)
|
|
if m:
|
|
resource = 'spotify:' + m.group(1).replace('/', ':')
|
|
|
|
if resource.startswith('spotify:'):
|
|
resource = resource.split('?')[0]
|
|
|
|
m = re.match(r'spotify:playlist:(.*)', resource)
|
|
if m:
|
|
# Old Spotify URI format, convert it to new
|
|
resource = 'spotify:user:spotify:playlist:' + m.group(1)
|
|
return resource
|
|
|
|
@action
|
|
def load(self, playlist, play=True):
|
|
"""
|
|
Load and play a playlist by name
|
|
|
|
:param playlist: Playlist name
|
|
:type playlist: str
|
|
|
|
:param play: Start playback after loading the playlist (default: True)
|
|
:type play: bool
|
|
"""
|
|
|
|
ret = self._exec('load', playlist)
|
|
if play:
|
|
self.play()
|
|
return ret
|
|
|
|
@action
|
|
def clear(self, **__):
|
|
"""Clear the current playlist"""
|
|
return self._exec('clear')
|
|
|
|
@action
|
|
def seekcur(self, value: float):
|
|
"""
|
|
Seek to the specified position (DEPRECATED, use :meth:`.seek` instead).
|
|
|
|
:param value: Seek position in seconds, or delta string (e.g. '+15' or
|
|
'-15') to indicate a seek relative to the current position
|
|
"""
|
|
return self.seek(value)
|
|
|
|
@action
|
|
def seek(self, position: float, **__):
|
|
"""
|
|
Seek to the specified position
|
|
|
|
:param position: Seek position in seconds, or delta string (e.g. '+15'
|
|
or '-15') to indicate a seek relative to the current position
|
|
"""
|
|
return self._exec('seekcur', position)
|
|
|
|
@action
|
|
def forward(self):
|
|
"""Go forward by 15 seconds"""
|
|
return self._exec('seekcur', '+15')
|
|
|
|
@action
|
|
def back(self):
|
|
"""Go backward by 15 seconds"""
|
|
return self._exec('seekcur', '-15')
|
|
|
|
def _status(self) -> dict:
|
|
n_tries = 2
|
|
error = None
|
|
|
|
while n_tries > 0:
|
|
try:
|
|
n_tries -= 1
|
|
self._connect()
|
|
if self.client:
|
|
return self.client.status() # type: ignore
|
|
except Exception as e:
|
|
error = e
|
|
self.logger.warning('Exception while getting MPD status: %s', e)
|
|
self.client = None
|
|
|
|
raise AssertionError(str(error))
|
|
|
|
@action
|
|
def status(self, *_, **__):
|
|
"""
|
|
:returns: The current state.
|
|
|
|
Example response::
|
|
|
|
output = {
|
|
"volume": "9",
|
|
"repeat": "0",
|
|
"random": "0",
|
|
"single": "0",
|
|
"consume": "0",
|
|
"playlist": "52",
|
|
"playlistlength": "14",
|
|
"xfade": "0",
|
|
"state": "play",
|
|
"song": "9",
|
|
"songid": "3061",
|
|
"nextsong": "10",
|
|
"nextsongid": "3062",
|
|
"time": "161:255",
|
|
"elapsed": "161.967",
|
|
"bitrate": "320"
|
|
}
|
|
|
|
"""
|
|
return self._status()
|
|
|
|
@action
|
|
def currentsong(self):
|
|
"""
|
|
Legacy alias for :meth:`.current_track`.
|
|
"""
|
|
return self.current_track()
|
|
|
|
@action
|
|
def current_track(self, *_, **__):
|
|
"""
|
|
:returns: The currently played track.
|
|
|
|
Example response::
|
|
|
|
output = {
|
|
"file": "spotify:track:7CO5ADlDN3DcR2pwlnB14P",
|
|
"time": "255",
|
|
"artist": "Elbow",
|
|
"album": "Little Fictions",
|
|
"title": "Kindling",
|
|
"date": "2017",
|
|
"track": "10",
|
|
"pos": "9",
|
|
"id": "3061",
|
|
"albumartist": "Elbow",
|
|
"x-albumuri": "spotify:album:6q5KhDhf9BZkoob7uAnq19"
|
|
}
|
|
"""
|
|
|
|
track = self._exec('currentsong', return_status=False)
|
|
if not isinstance(track, dict):
|
|
return None
|
|
|
|
if 'title' in track and (
|
|
'artist' not in track
|
|
or not track['artist']
|
|
or re.search('^https?://', track['file'])
|
|
or re.search('^tunein:', track['file'])
|
|
):
|
|
m = re.match(r'^\s*(.+?)\s+-\s+(.*)\s*$', track['title'])
|
|
if m and m.group(1) and m.group(2):
|
|
track['artist'] = m.group(1)
|
|
track['title'] = m.group(2)
|
|
|
|
return track
|
|
|
|
@action
|
|
def playlistinfo(self):
|
|
"""
|
|
:returns: The tracks in the current playlist as a list of dicts.
|
|
|
|
Example output::
|
|
|
|
output = [
|
|
{
|
|
"file": "spotify:track:79VtgIoznishPUDWO7Kafu",
|
|
"time": "355",
|
|
"artist": "Elbow",
|
|
"album": "Little Fictions",
|
|
"title": "Trust the Sun",
|
|
"date": "2017",
|
|
"track": "3",
|
|
"pos": "10",
|
|
"id": "3062",
|
|
"albumartist": "Elbow",
|
|
"x-albumuri": "spotify:album:6q5KhDhf9BZkoob7uAnq19"
|
|
},
|
|
{
|
|
"file": "spotify:track:3EzTre0pxmoMYRuhJKMHj6",
|
|
"time": "219",
|
|
"artist": "Elbow",
|
|
"album": "Little Fictions",
|
|
"title": "Gentle Storm",
|
|
"date": "2017",
|
|
"track": "2",
|
|
"pos": "11",
|
|
"id": "3063",
|
|
"albumartist": "Elbow",
|
|
"x-albumuri": "spotify:album:6q5KhDhf9BZkoob7uAnq19"
|
|
},
|
|
]
|
|
"""
|
|
|
|
return self._exec('playlistinfo', return_status=False)
|
|
|
|
@action
|
|
def get_playlists(self, *_, **__):
|
|
"""
|
|
:returns: The playlists available on the server as a list of dicts.
|
|
|
|
Example response::
|
|
|
|
output = [
|
|
{
|
|
"playlist": "Rock",
|
|
"last-modified": "2018-06-25T21:28:19Z"
|
|
},
|
|
{
|
|
"playlist": "Jazz",
|
|
"last-modified": "2018-06-24T22:28:29Z"
|
|
},
|
|
{
|
|
# ...
|
|
}
|
|
]
|
|
|
|
"""
|
|
playlists: list = self._exec( # type: ignore
|
|
'listplaylists', return_status=False
|
|
)
|
|
return sorted(playlists, key=lambda p: p['playlist'])
|
|
|
|
@action
|
|
def listplaylists(self):
|
|
"""
|
|
Deprecated alias for :meth:`.playlists`.
|
|
"""
|
|
return self.get_playlists()
|
|
|
|
@action
|
|
def get_playlist(self, playlist: str, *_, with_tracks: bool = False, **__):
|
|
"""
|
|
List the items in the specified playlist.
|
|
|
|
:param playlist: Name of the playlist
|
|
:param with_tracks: If True then the list of tracks in the playlist will
|
|
be returned as well (default: False).
|
|
"""
|
|
return self._exec(
|
|
'listplaylistinfo' if with_tracks else 'listplaylist',
|
|
playlist,
|
|
return_status=False,
|
|
)
|
|
|
|
@action
|
|
def listplaylist(self, name: str):
|
|
"""
|
|
Deprecated alias for :meth:`.playlist`.
|
|
"""
|
|
return self._exec('listplaylist', name, return_status=False)
|
|
|
|
@action
|
|
def listplaylistinfo(self, name: str):
|
|
"""
|
|
Deprecated alias for :meth:`.playlist` with ``with_tracks=True``.
|
|
"""
|
|
return self.get_playlist(name, with_tracks=True)
|
|
|
|
@action
|
|
def add_to_playlist(self, playlist: str, resources: Union[str, Collection[str]]):
|
|
"""
|
|
Add one or multiple resources to a playlist.
|
|
|
|
:param playlist: Playlist name
|
|
:param resources: URI or path of the resource(s) to be added
|
|
"""
|
|
|
|
if isinstance(resources, str):
|
|
resources = [resources]
|
|
|
|
for res in resources:
|
|
self._exec('playlistadd', playlist, res)
|
|
|
|
@action
|
|
def playlistadd(self, name: str, uri: str):
|
|
"""
|
|
Deprecated alias for :meth:`.add_to_playlist`.
|
|
"""
|
|
return self.add_to_playlist(name, uri)
|
|
|
|
@action
|
|
def remove_from_playlist(
|
|
self, playlist: str, resources: Union[int, Collection[int]], *_, **__
|
|
):
|
|
"""
|
|
Remove one or multiple tracks from a playlist.
|
|
|
|
:param playlist: Playlist name
|
|
:param resources: Position or list of positions to remove
|
|
"""
|
|
|
|
if isinstance(resources, str):
|
|
resources = int(resources)
|
|
if isinstance(resources, int):
|
|
resources = [resources]
|
|
|
|
for p in sorted(resources, reverse=True):
|
|
self._exec('playlistdelete', playlist, p)
|
|
|
|
@action
|
|
def playlist_move(self, playlist: str, from_pos: int, to_pos: int, *_, **__):
|
|
"""
|
|
Change the position of a track in the specified playlist.
|
|
|
|
:param playlist: Playlist name
|
|
:param from_pos: Original track position
|
|
:param to_pos: New track position
|
|
"""
|
|
self._exec('playlistmove', playlist, from_pos, to_pos)
|
|
|
|
@action
|
|
def playlistdelete(self, name: str, pos: int):
|
|
"""
|
|
Deprecated alias for :meth:`.remove_from_playlist`.
|
|
"""
|
|
return self.remove_from_playlist(name, pos)
|
|
|
|
@action
|
|
def playlistmove(self, name: str, from_pos: int, to_pos: int):
|
|
"""
|
|
Deprecated alias for :meth:`.playlist_move`.
|
|
"""
|
|
return self.playlist_move(name, from_pos=from_pos, to_pos=to_pos)
|
|
|
|
@action
|
|
def playlistclear(self, name: str):
|
|
"""
|
|
Clears all the elements from the specified playlist.
|
|
|
|
:param name: Playlist name.
|
|
"""
|
|
self._exec('playlistclear', name)
|
|
|
|
@action
|
|
def rename(self, name: str, new_name: str):
|
|
"""
|
|
Rename a playlist.
|
|
|
|
:param name: Original playlist name
|
|
:param new_name: New playlist name
|
|
"""
|
|
self._exec('rename', name, new_name)
|
|
|
|
@action
|
|
def lsinfo(self, uri: Optional[str] = None):
|
|
"""
|
|
Returns the list of playlists and directories on the server.
|
|
"""
|
|
|
|
return (
|
|
self._exec('lsinfo', uri, return_status=False)
|
|
if uri
|
|
else self._exec('lsinfo', return_status=False)
|
|
)
|
|
|
|
@action
|
|
def plchanges(self, version: int):
|
|
"""
|
|
Show what has changed on the current playlist since a specified playlist
|
|
version number.
|
|
|
|
:param version: Version number
|
|
:returns: A list of dicts representing the songs being added since the specified version
|
|
"""
|
|
return self._exec('plchanges', version, return_status=False)
|
|
|
|
@action
|
|
def searchaddplaylist(self, name: str):
|
|
"""
|
|
Search and add a playlist by (partial or full) name.
|
|
|
|
:param name: Playlist name, can be partial.
|
|
"""
|
|
|
|
resp: list = self._exec('listplaylists', return_status=False) # type: ignore
|
|
playlists = [
|
|
pl['playlist'] for pl in resp if name.lower() in pl['playlist'].lower()
|
|
]
|
|
|
|
if not playlists:
|
|
return None
|
|
|
|
self._exec('clear')
|
|
self._exec('load', playlists[0])
|
|
self._exec('play')
|
|
return {'playlist': playlists[0]}
|
|
|
|
@staticmethod
|
|
def _make_filter(f: dict) -> list:
|
|
ll = []
|
|
for k, v in f.items():
|
|
ll.extend([k, v])
|
|
return ll
|
|
|
|
@action
|
|
def find(self, filter: dict, *args, **kwargs): # pylint: disable=redefined-builtin
|
|
"""
|
|
Find in the database/library by filter.
|
|
|
|
:param filter: Search filter (e.g. ``{"artist": "Led Zeppelin", "album": "IV"}``)
|
|
:returns: list[dict]
|
|
"""
|
|
filter_list = self._make_filter(filter)
|
|
return self._exec('find', *filter_list, *args, return_status=False, **kwargs)
|
|
|
|
@action
|
|
def findadd(
|
|
self, filter: dict, *args, **kwargs # pylint: disable=redefined-builtin
|
|
):
|
|
"""
|
|
Find in the database/library by filter and add to the current playlist.
|
|
|
|
:param filter: Search filter (e.g. ``{"artist": "Led Zeppelin", "album": "IV"}``)
|
|
:returns: list[dict]
|
|
"""
|
|
filter_list = self._make_filter(filter)
|
|
return self._exec('findadd', *filter_list, *args, return_status=False, **kwargs)
|
|
|
|
@action
|
|
def search(
|
|
self,
|
|
*args,
|
|
query: Optional[Union[str, dict]] = None,
|
|
filter: Optional[dict] = None, # pylint: disable=redefined-builtin
|
|
**kwargs,
|
|
):
|
|
"""
|
|
Free search by filter.
|
|
|
|
:param query: Free-text query or search structured filter (e.g. ``{"artist": "Led Zeppelin", "album": "IV"}``).
|
|
:param filter: Structured search filter (e.g. ``{"artist": "Led Zeppelin", "album": "IV"}``) - same as
|
|
``query``, it's still here for back-compatibility reasons.
|
|
:returns: list[dict]
|
|
"""
|
|
assert query or filter, 'Specify either `query` or `filter`'
|
|
|
|
filt = filter
|
|
if isinstance(query, str):
|
|
filt = query
|
|
elif isinstance(query, dict):
|
|
filt = {**(filter or {}), **query}
|
|
|
|
filter_list = self._make_filter(filt) if isinstance(filt, dict) else [query]
|
|
|
|
items: list = self._exec( # type: ignore
|
|
'search', *filter_list, *args, return_status=False, **kwargs
|
|
)
|
|
|
|
# Spotify results first
|
|
return sorted(
|
|
items, key=lambda item: 0 if item['file'].startswith('spotify:') else 1
|
|
)
|
|
|
|
@action
|
|
def searchadd(self, filter: dict, *args, **kwargs):
|
|
"""
|
|
Free search by filter and add the results to the current playlist.
|
|
|
|
:param filter: Search filter (e.g. ``{"artist": "Led Zeppelin", "album": "IV"}``)
|
|
:returns: list[dict]
|
|
"""
|
|
filter_list = self._make_filter(filter)
|
|
return self._exec(
|
|
'searchadd', *filter_list, *args, return_status=False, **kwargs
|
|
)
|
|
|
|
|
|
# vim:sw=4:ts=4:et:
|