mopidy.mpd – MPD server

For details on how to use Mopidy’s MPD server, see Mopidy-MPD.

MPD dispatcher

class mopidy.mpd.dispatcher.MpdContext(dispatcher, session=None, config=None, core=None)[source]

This object is passed as the first argument to all MPD command handlers to give the command handlers access to important parts of Mopidy.

core = None

The Mopidy core API. An instance of mopidy.core.Core.

dispatcher = None

The current MpdDispatcher.

events = None

The active subsystems that have pending events.

lookup_playlist_from_name(name)[source]

Helper function to retrieve a playlist from its unique MPD name.

lookup_playlist_name_from_uri(uri)[source]

Helper function to retrieve the unique MPD playlist name from its uri.

password = None

The MPD password

refresh_playlists_mapping()[source]

Maintain map between playlists and unique playlist names to be used by MPD

session = None

The current mopidy.mpd.MpdSession.

subscriptions = None

The subsytems that we want to be notified about in idle mode.

class mopidy.mpd.dispatcher.MpdDispatcher(session=None, config=None, core=None)[source]

The MPD session feeds the MPD dispatcher with requests. The dispatcher finds the correct handler, processes the request and sends the response back to the MPD session.

handle_request(request, current_command_list_index=None)[source]

Dispatch incoming requests to the correct handler.

MPD protocol

rather incomplete with regards to data formats, both for requests and responses. Thus, we have had to talk a great deal with the the original MPD server using telnet to get the details we need to implement our own MPD server which is compatible with the numerous existing MPD clients.

mopidy.mpd.protocol.ENCODING = u'UTF-8'

The MPD protocol uses UTF-8 for encoding all data.

mopidy.mpd.protocol.LINE_TERMINATOR = u'\n'

The MPD protocol uses \n as line terminator.

class mopidy.mpd.protocol.MpdCommand

MpdCommand(name, auth_required)

auth_required

Alias for field number 1

name

Alias for field number 0

mopidy.mpd.protocol.VERSION = u'0.17.0'

The MPD protocol version is 0.17.0.

mopidy.mpd.protocol.handle_request(pattern, auth_required=True)[source]

Decorator for connecting command handlers to command requests.

If you use named groups in the pattern, the decorated method will get the groups as keyword arguments. If the group is optional, remember to give the argument a default value.

For example, if the command is do that thing the what argument will be this thing:

@handle_request('do\ (?P<what>.+)$')
def do(what):
    ...

Note that the patterns are compiled with the re.VERBOSE flag. Thus, you must escape any space characters you want to match, but you’re also free to add non-escaped whitespace to format the pattern for easier reading.

Parameters:pattern (string) – regexp pattern for matching commands
mopidy.mpd.protocol.load_protocol_modules()[source]

The protocol modules must be imported to get them registered in request_handlers and mpd_commands.

mopidy.mpd.protocol.mpd_commands = set([MpdCommand(name=u'stop', auth_required=True), MpdCommand(name=u'listall', auth_required=True), MpdCommand(name=u'noidle', auth_required=True), MpdCommand(name=u'plchangesposid', auth_required=True), MpdCommand(name=u'ping', auth_required=False), MpdCommand(name=u'listplaylists', auth_required=True), MpdCommand(name=u'playlistmove', auth_required=True), MpdCommand(name=u'findadd', auth_required=True), MpdCommand(name=u'pause', auth_required=True), MpdCommand(name=u'sendmessage', auth_required=True), MpdCommand(name=u'notcommands', auth_required=False), MpdCommand(name=u'moveid', auth_required=True), MpdCommand(name=u'playlistid', auth_required=True), MpdCommand(name=u'readmessages', auth_required=True), MpdCommand(name=u'listplaylistinfo', auth_required=True), MpdCommand(name=u'config', auth_required=False), MpdCommand(name=u'currentsong', auth_required=True), MpdCommand(name=u'consume', auth_required=True), MpdCommand(name=u'searchadd', auth_required=True), MpdCommand(name=u'single', auth_required=True), MpdCommand(name=u'previous', auth_required=True), MpdCommand(name=u'command_list_end', auth_required=True), MpdCommand(name=u'update', auth_required=True), MpdCommand(name=u'command_list_begin', auth_required=True), MpdCommand(name=u'replay_gain_mode', auth_required=True), MpdCommand(name=u'playlistdelete', auth_required=True), MpdCommand(name=u'repeat', auth_required=True), MpdCommand(name=u'rename', auth_required=True), MpdCommand(name=u'playlist', auth_required=True), MpdCommand(name=u'next', auth_required=True), MpdCommand(name=u'status', auth_required=True), MpdCommand(name=u'playlistclear', auth_required=True), MpdCommand(name=u'close', auth_required=False), MpdCommand(name=u'move', auth_required=True), MpdCommand(name=u'rm', auth_required=True), MpdCommand(name=u'clear', auth_required=True), MpdCommand(name=u'swap', auth_required=True), MpdCommand(name=u'replay_gain_status', auth_required=True), MpdCommand(name=u'shuffle', auth_required=True), MpdCommand(name=u'add', auth_required=True), MpdCommand(name=u'count', auth_required=True), MpdCommand(name=u'password', auth_required=False), MpdCommand(name=u'listallinfo', auth_required=True), MpdCommand(name=u'playid', auth_required=True), MpdCommand(name=u'swapid', auth_required=True), MpdCommand(name=u'outputs', auth_required=True), MpdCommand(name=u'unsubscribe', auth_required=True), MpdCommand(name=u'disableoutput', auth_required=True), MpdCommand(name=u'kill', auth_required=True), MpdCommand(name=u'subscribe', auth_required=True), MpdCommand(name=u'searchaddpl', auth_required=True), MpdCommand(name=u'addid', auth_required=True), MpdCommand(name=u'commands', auth_required=False), MpdCommand(name=u'command_list_ok_begin', auth_required=True), MpdCommand(name=u'play', auth_required=True), MpdCommand(name=u'rescan', auth_required=True), MpdCommand(name=u'playlistfind', auth_required=True), MpdCommand(name=u'stats', auth_required=True), MpdCommand(name=u'seekid', auth_required=True), MpdCommand(name=u'load', auth_required=True), MpdCommand(name=u'setvol', auth_required=True), MpdCommand(name=u'listplaylist', auth_required=True), MpdCommand(name=u'save', auth_required=True), MpdCommand(name=u'list', auth_required=True), MpdCommand(name=u'seekcur', auth_required=True), MpdCommand(name=u'urlhandlers', auth_required=True), MpdCommand(name=u'playlistadd', auth_required=True), MpdCommand(name=u'tagtypes', auth_required=True), MpdCommand(name=u'sticker', auth_required=True), MpdCommand(name=u'random', auth_required=True), MpdCommand(name=u'search', auth_required=True), MpdCommand(name=u'lsinfo', auth_required=True), MpdCommand(name=u'channels', auth_required=True), MpdCommand(name=u'find', auth_required=True), MpdCommand(name=u'plchanges', auth_required=True), MpdCommand(name=u'decoders', auth_required=True), MpdCommand(name=u'clearerror', auth_required=True), MpdCommand(name=u'enableoutput', auth_required=True), MpdCommand(name=u'seek', auth_required=True), MpdCommand(name=u'playlistinfo', auth_required=True), MpdCommand(name=u'crossfade', auth_required=True), MpdCommand(name=u'playlistsearch', auth_required=True), MpdCommand(name=u'deleteid', auth_required=True), MpdCommand(name=u'idle', auth_required=True), MpdCommand(name=u'delete', auth_required=True)])

Set of all available commands, represented as MpdCommand objects.

mopidy.mpd.protocol.request_handlers = {<_sre.SRE_Pattern object at 0x4112030>: <function clear at 0x4117050>, <_sre.SRE_Pattern object at 0x2b260a0>: <function seek at 0x43ec320>, <_sre.SRE_Pattern object at 0x3cbc0c0>: <function findadd at 0x4128320>, <_sre.SRE_Pattern object at 0x3e920d0>: <function sticker__list at 0x43f25f0>, <_sre.SRE_Pattern object at 0x410e128>: <function idle at 0x43ecb90>, <_sre.SRE_Pattern object at 0x38fc150>: <function swapid at 0x4117668>, <_sre.SRE_Pattern object at 0x3e98200>: <function deleteid at 0x42f4f50>, <_sre.SRE_Pattern object at 0x410e220>: <function rm at 0x4117ed8>, <_sre.SRE_Pattern object at 0x4352230>: <function playlist at 0x4117230>, <_sre.SRE_Pattern object at 0x28ca290>: <function enableoutput at 0x41d48c0>, <_sre.SRE_Pattern object at 0x41122a0>: <function pause at 0x4128e60>, <_sre.SRE_Pattern object at 0x3c142d0>: <function command_list_begin at 0x41d4c08>, <_sre.SRE_Pattern object at 0x2d922f0>: <function sticker__find at 0x43f2500>, <_sre.SRE_Pattern object at 0x3c0c310>: <function count at 0x4128230>, <_sre.SRE_Pattern object at 0x4352330>: <function previous at 0x43ec0c8>, <_sre.SRE_Pattern object at 0x2a445f0>: <function sendmessage at 0x41d4b90>, <_sre.SRE_Pattern object at 0x32c63c0>: <function load at 0x4117c08>, <_sre.SRE_Pattern object at 0x321a420>: <function playlistdelete at 0x4117d70>, <_sre.SRE_Pattern object at 0x2d94470>: <function sticker__delete at 0x43f2488>, <_sre.SRE_Pattern object at 0x32c44d0>: <function list_ at 0x4128398>, <_sre.SRE_Pattern object at 0x2ca6500>: <function search at 0x4128758>, <_sre.SRE_Pattern object at 0x4112510>: <function stats at 0x43ecc08>, <_sre.SRE_Pattern object at 0x28ca5b0>: <function playlistinfo at 0x4117488>, <_sre.SRE_Pattern object at 0x3ca05f0>: <function replay_gain_status at 0x43ec2a8>, <_sre.SRE_Pattern object at 0x4352630>: <function commands at 0x43ec668>, <_sre.SRE_Pattern object at 0x4352730>: <function decoders at 0x43ec6e0>, <_sre.SRE_Pattern object at 0x3ca07a0>: <function seekcur at 0x43ec488>, <_sre.SRE_Pattern object at 0x33fc7d0>: <function rename at 0x4117e60>, <_sre.SRE_Pattern object at 0x2890810>: <function subscribe at 0x41d49b0>, <_sre.SRE_Pattern object at 0x4352830>: <function tagtypes at 0x43ec7d0>, <_sre.SRE_Pattern object at 0x3872870>: <function seekcur at 0x43ec488>, <_sre.SRE_Pattern object at 0x3ef48b0>: <function urlhandlers at 0x43ec848>, <_sre.SRE_Pattern object at 0x3ee48c0>: <function password at 0x41d4e60>, <_sre.SRE_Pattern object at 0x36f28e0>: <function replay_gain_mode at 0x43ec230>, <_sre.SRE_Pattern object at 0x3ec08f0>: <function moveid at 0x41171b8>, <_sre.SRE_Pattern object at 0x411c930>: <function empty at 0x41176e0>, <_sre.SRE_Pattern object at 0x288e9b0>: <function shuffle at 0x41175f0>, <_sre.SRE_Pattern object at 0x2ca8a40>: <function consume at 0x4128c80>, <_sre.SRE_Pattern object at 0x2ef2a60>: <function pause at 0x4128e60>, <_sre.SRE_Pattern object at 0x2ca6ae0>: <function searchadd at 0x41289b0>, <_sre.SRE_Pattern object at 0x2b00b20>: <function add at 0x42f4d70>, <_sre.SRE_Pattern object at 0x3c14bb0>: <function playlistinfo at 0x4117488>, <_sre.SRE_Pattern object at 0x3e92c00>: <function sticker__get at 0x43f2578>, <_sre.SRE_Pattern object at 0x3cbcc40>: <function find at 0x41282a8>, <_sre.SRE_Pattern object at 0x3c52c60>: <function listall at 0x41287d0>, <_sre.SRE_Pattern object at 0x36acc70>: <function play__pos at 0x4128f50>, <_sre.SRE_Pattern object at 0x3d66cc0>: <function unsubscribe at 0x41d4a28>, <_sre.SRE_Pattern object at 0x387cd90>: <function playlistfind at 0x41172a8>, <_sre.SRE_Pattern object at 0x36acdd0>: <function random at 0x43ec140>, <_sre.SRE_Pattern object at 0x32c65b0>: <function playlistclear at 0x4117cf8>, <_sre.SRE_Pattern object at 0x3052e40>: <function outputs at 0x41d4938>, <_sre.SRE_Pattern object at 0x3d98e90>: <function move_songpos at 0x4117140>, <_sre.SRE_Pattern object at 0x3c0eeb0>: <function lsinfo at 0x41288c0>, <_sre.SRE_Pattern object at 0x38fcf90>: <function playlistid at 0x4117398>, <_sre.SRE_Pattern object at 0x3ce10e0>: <function playlistid at 0x4117398>, <_sre.SRE_Pattern object at 0x3d65130>: <function readmessages at 0x41d4b18>, <_sre.SRE_Pattern object at 0x3c0d170>: <function listallinfo at 0x4128848>, <_sre.SRE_Pattern object at 0x3ac5230>: <function channels at 0x41d4aa0>, <_sre.SRE_Pattern object at 0x3e652e0>: <function sticker__set at 0x43f2668>, <_sre.SRE_Pattern object at 0x4183330>: <function next_ at 0x4128d70>, <_sre.SRE_Pattern object at 0x3f6d3e0>: <function playlistsearch at 0x4117320>, <_sre.SRE_Pattern object at 0x41833f0>: <function play at 0x4128de8>, <_sre.SRE_Pattern object at 0x3bf1410>: <function delete_range at 0x42f4e60>, <_sre.SRE_Pattern object at 0x3e59420>: <function searchaddpl at 0x4128a28>, <_sre.SRE_Pattern object at 0x41834b0>: <function stop at 0x43ec578>, <_sre.SRE_Pattern object at 0x317b560>: <function update at 0x4128b18>, <_sre.SRE_Pattern object at 0x4183570>: <function idle at 0x43ecb90>, <_sre.SRE_Pattern object at 0x32c6e40>: <function playlistadd at 0x4117c80>, <_sre.SRE_Pattern object at 0x2f53630>: <function listplaylistinfo at 0x4117aa0>, <_sre.SRE_Pattern object at 0x2c7d650>: <function currentsong at 0x43ecaa0>, <_sre.SRE_Pattern object at 0x2aed690>: <function command_list_ok_begin at 0x41d4cf8>, <_sre.SRE_Pattern object at 0x3219700>: <function seekid at 0x43ec398>, <_sre.SRE_Pattern object at 0x2c50930>: <function addid at 0x42f4de8>, <_sre.SRE_Pattern object at 0x2ef17a0>: <function playid at 0x4128ed8>, <_sre.SRE_Pattern object at 0x32c57b0>: <function listallinfo at 0x4128848>, <_sre.SRE_Pattern object at 0x34037f0>: <function command_list_end at 0x41d4c80>, <_sre.SRE_Pattern object at 0x3aab810>: <function lsinfo at 0x41288c0>, <_sre.SRE_Pattern object at 0x34d9830>: <function listplaylists at 0x4117b18>, <_sre.SRE_Pattern object at 0x3bf18d0>: <function delete_songpos at 0x42f4ed8>, <_sre.SRE_Pattern object at 0x3255900>: <function playlistmove at 0x4117de8>, <_sre.SRE_Pattern object at 0x34d9990>: <function rescan at 0x4128938>, <_sre.SRE_Pattern object at 0x43ad990>: <function shuffle at 0x41175f0>, <_sre.SRE_Pattern object at 0x3aab9d0>: <function rescan at 0x4128938>, <_sre.SRE_Pattern object at 0x3f7f9f0>: <function kill at 0x41d4de8>, <_sre.SRE_Pattern object at 0x2c7da00>: <function clearerror at 0x43eca28>, <_sre.SRE_Pattern object at 0x28bda50>: <function plchangesposid at 0x4117500>, <_sre.SRE_Pattern object at 0x3aabab0>: <function update at 0x4128b18>, <_sre.SRE_Pattern object at 0x32c5ae0>: <function listplaylist at 0x4117a28>, <_sre.SRE_Pattern object at 0x3d63b00>: <function setvol at 0x43ec410>, <_sre.SRE_Pattern object at 0x3329b20>: <function notcommands at 0x43ec758>, <_sre.SRE_Pattern object at 0x3aabb90>: <function config at 0x43ec5f0>, <_sre.SRE_Pattern object at 0x317bbd0>: <function plchanges at 0x4117410>, <_sre.SRE_Pattern object at 0x3c0dbf0>: <function save at 0x4117f50>, <_sre.SRE_Pattern object at 0x2c59c00>: <function move_range at 0x41170c8>, <_sre.SRE_Pattern object at 0x28c9c20>: <function playlistinfo at 0x4117488>, <_sre.SRE_Pattern object at 0x41cfc60>: <function close at 0x41d4d70>, <_sre.SRE_Pattern object at 0x3aabc70>: <function noidle at 0x43ecb18>, <_sre.SRE_Pattern object at 0x3d63ca0>: <function single at 0x43ec500>, <_sre.SRE_Pattern object at 0x3c0dd10>: <function listall at 0x41287d0>, <_sre.SRE_Pattern object at 0x2ce3d20>: <function disableoutput at 0x41d4848>, <_sre.SRE_Pattern object at 0x3aabd50>: <function status at 0x43ecc80>, <_sre.SRE_Pattern object at 0x2d08eb0>: <function swap at 0x4117578>, <_sre.SRE_Pattern object at 0x3cbca60>: <function repeat at 0x43ec1b8>, <_sre.SRE_Pattern object at 0x3f7fe70>: <function ping at 0x41d4ed8>, <_sre.SRE_Pattern object at 0x3219ed0>: <function crossfade at 0x4128cf8>}

Map between request matchers and request handler functions.

Audio output

mopidy.mpd.protocol.audio_output.disableoutput(context, outputid)[source]

Pattern:

disableoutput\ "(?P<outputid>\d+)"$

musicpd.org, audio output section:

disableoutput

Turns an output off.

mopidy.mpd.protocol.audio_output.enableoutput(context, outputid)[source]

Pattern:

enableoutput\ "(?P<outputid>\d+)"$

musicpd.org, audio output section:

enableoutput

Turns an output on.

mopidy.mpd.protocol.audio_output.outputs(context)[source]

Pattern:

outputs$

musicpd.org, audio output section:

outputs

Shows information about all outputs.

Channels

mopidy.mpd.protocol.channels.channels(context)[source]

Pattern:

channels$

musicpd.org, client to client section:

channels

Obtain a list of all channels. The response is a list of “channel:” lines.

mopidy.mpd.protocol.channels.readmessages(context)[source]

Pattern:

readmessages$

musicpd.org, client to client section:

readmessages

Reads messages for this client. The response is a list of “channel:” and “message:” lines.

mopidy.mpd.protocol.channels.sendmessage(context, channel, text)[source]

Pattern:

sendmessage\ "(?P<channel>[A-Za-z0-9:._-]+)"\ "(?P<text>[^"]*)"$

musicpd.org, client to client section:

sendmessage {CHANNEL} {TEXT}

Send a message to the specified channel.

mopidy.mpd.protocol.channels.subscribe(context, channel)[source]

Pattern:

subscribe\ "(?P<channel>[A-Za-z0-9:._-]+)"$

musicpd.org, client to client section:

subscribe {NAME}

Subscribe to a channel. The channel is created if it does not exist already. The name may consist of alphanumeric ASCII characters plus underscore, dash, dot and colon.

mopidy.mpd.protocol.channels.unsubscribe(context, channel)[source]

Pattern:

unsubscribe\ "(?P<channel>[A-Za-z0-9:._-]+)"$

musicpd.org, client to client section:

unsubscribe {NAME}

Unsubscribe from a channel.

Command list

mopidy.mpd.protocol.command_list.command_list_begin(context)[source]

Pattern:

command_list_begin$

musicpd.org, command list section:

To facilitate faster adding of files etc. you can pass a list of commands all at once using a command list. The command list begins with command_list_begin or command_list_ok_begin and ends with command_list_end.

It does not execute any commands until the list has ended. The return value is whatever the return for a list of commands is. On success for all commands, OK is returned. If a command fails, no more commands are executed and the appropriate ACK error is returned. If command_list_ok_begin is used, list_OK is returned for each successful command executed in the command list.

mopidy.mpd.protocol.command_list.command_list_end(context)[source]

Pattern:

command_list_end$

See command_list_begin().

mopidy.mpd.protocol.command_list.command_list_ok_begin(context)[source]

Pattern:

command_list_ok_begin$

See command_list_begin().

Connection

mopidy.mpd.protocol.connection.close(context)[source]

Pattern:

close$

musicpd.org, connection section:

close

Closes the connection to MPD.

mopidy.mpd.protocol.connection.kill(context)[source]

Pattern:

kill$

musicpd.org, connection section:

kill

Kills MPD.

mopidy.mpd.protocol.connection.password(context, password)[source]

Pattern:

password\ "(?P<password>[^"]+)"$

musicpd.org, connection section:

password {PASSWORD}

This is used for authentication with the server. PASSWORD is simply the plaintext password.

mopidy.mpd.protocol.connection.ping(context)[source]

Pattern:

ping$

musicpd.org, connection section:

ping

Does nothing but return OK.

Current playlist

mopidy.mpd.protocol.current_playlist.add(context, uri)[source]

Pattern:

add\ "(?P<uri>[^"]*)"$

musicpd.org, current playlist section:

add {URI}

Adds the file URI to the playlist (directories add recursively). URI can also be a single file.

Clarifications:

  • add "" should add all tracks in the library to the current playlist.
mopidy.mpd.protocol.current_playlist.addid(context, uri, songpos=None)[source]

Pattern:

addid\ "(?P<uri>[^"]*)"(\ "(?P<songpos>\d+)")*$

musicpd.org, current playlist section:

addid {URI} [POSITION]

Adds a song to the playlist (non-recursive) and returns the song id.

URI is always a single file or URL. For example:

addid "foo.mp3"
Id: 999
OK

Clarifications:

  • addid "" should return an error.
mopidy.mpd.protocol.current_playlist.clear(context)[source]

Pattern:

clear$

musicpd.org, current playlist section:

clear

Clears the current playlist.

mopidy.mpd.protocol.current_playlist.delete_range(context, start, end=None)[source]

Pattern:

delete\ "(?P<start>\d+):(?P<end>\d+)*"$

musicpd.org, current playlist section:

delete [{POS} | {START:END}]

Deletes a song from the playlist.

mopidy.mpd.protocol.current_playlist.delete_songpos(context, songpos)[source]

Pattern:

delete\ "(?P<songpos>\d+)"$

See delete_range()

mopidy.mpd.protocol.current_playlist.deleteid(context, tlid)[source]

Pattern:

deleteid\ "(?P<tlid>\d+)"$

musicpd.org, current playlist section:

deleteid {SONGID}

Deletes the song SONGID from the playlist

mopidy.mpd.protocol.current_playlist.move_range(context, start, to, end=None)[source]

Pattern:

move\ "(?P<start>\d+):(?P<end>\d+)*"\ "(?P<to>\d+)"$

musicpd.org, current playlist section:

move [{FROM} | {START:END}] {TO}

Moves the song at FROM or range of songs at START:END to TO in the playlist.

mopidy.mpd.protocol.current_playlist.move_songpos(context, songpos, to)[source]

Pattern:

move\ "(?P<songpos>\d+)"\ "(?P<to>\d+)"$

See move_range().

mopidy.mpd.protocol.current_playlist.moveid(context, tlid, to)[source]

Pattern:

moveid\ "(?P<tlid>\d+)"\ "(?P<to>\d+)"$

musicpd.org, current playlist section:

moveid {FROM} {TO}

Moves the song with FROM (songid) to TO (playlist index) in the playlist. If TO is negative, it is relative to the current song in the playlist (if there is one).

mopidy.mpd.protocol.current_playlist.playlist(context)[source]

Pattern:

playlist$

musicpd.org, current playlist section:

playlist

Displays the current playlist.

Note

Do not use this, instead use playlistinfo.

mopidy.mpd.protocol.current_playlist.playlistfind(context, tag, needle)[source]

Pattern:

playlistfind\ ("?)(?P<tag>[^"]+)\1\ "(?P<needle>[^"]+)"$

musicpd.org, current playlist section:

playlistfind {TAG} {NEEDLE}

Finds songs in the current playlist with strict matching.

GMPC:

  • does not add quotes around the tag.
mopidy.mpd.protocol.current_playlist.playlistid(context, tlid=None)[source]

Pattern:

playlistid$

Pattern:

playlistid\ "(?P<tlid>\d+)"$

musicpd.org, current playlist section:

playlistid {SONGID}

Displays a list of songs in the playlist. SONGID is optional and specifies a single song to display info for.

mopidy.mpd.protocol.current_playlist.playlistinfo(context, songpos=None, start=None, end=None)[source]

Pattern:

playlistinfo$

Pattern:

playlistinfo\ "(?P<songpos>-?\d+)"$

Pattern:

playlistinfo\ "(?P<start>\d+):(?P<end>\d+)*"$

musicpd.org, current playlist section:

playlistinfo [[SONGPOS] | [START:END]]

Displays a list of all songs in the playlist, or if the optional argument is given, displays information only for the song SONGPOS or the range of songs START:END.

ncmpc and mpc:

  • uses negative indexes, like playlistinfo "-1", to request the entire playlist
mopidy.mpd.protocol.current_playlist.playlistsearch(context, tag, needle)[source]

Pattern:

playlistsearch\ ("?)(?P<tag>\w+)\1\ "(?P<needle>[^"]+)"$

musicpd.org, current playlist section:

playlistsearch {TAG} {NEEDLE}

Searches case-sensitively for partial matches in the current playlist.

GMPC:

  • does not add quotes around the tag
  • uses filename and any as tags
mopidy.mpd.protocol.current_playlist.plchanges(context, version)[source]

Pattern:

plchanges\ ("?)(?P<version>-?\d+)\1$

musicpd.org, current playlist section:

plchanges {VERSION}

Displays changed songs currently in the playlist since VERSION.

To detect songs that were deleted at the end of the playlist, use playlistlength returned by status command.

MPDroid:

  • Calls plchanges "-1" two times per second to get the entire playlist.
mopidy.mpd.protocol.current_playlist.plchangesposid(context, version)[source]

Pattern:

plchangesposid\ "(?P<version>\d+)"$

musicpd.org, current playlist section:

plchangesposid {VERSION}

Displays changed songs currently in the playlist since VERSION. This function only returns the position and the id of the changed song, not the complete metadata. This is more bandwidth efficient.

To detect songs that were deleted at the end of the playlist, use playlistlength returned by status command.

mopidy.mpd.protocol.current_playlist.shuffle(context, start=None, end=None)[source]

Pattern:

shuffle$

Pattern:

shuffle\ "(?P<start>\d+):(?P<end>\d+)*"$

musicpd.org, current playlist section:

shuffle [START:END]

Shuffles the current playlist. START:END is optional and specifies a range of songs.

mopidy.mpd.protocol.current_playlist.swap(context, songpos1, songpos2)[source]

Pattern:

swap\ "(?P<songpos1>\d+)"\ "(?P<songpos2>\d+)"$

musicpd.org, current playlist section:

swap {SONG1} {SONG2}

Swaps the positions of SONG1 and SONG2.

mopidy.mpd.protocol.current_playlist.swapid(context, tlid1, tlid2)[source]

Pattern:

swapid\ "(?P<tlid1>\d+)"\ "(?P<tlid2>\d+)"$

musicpd.org, current playlist section:

swapid {SONG1} {SONG2}

Swaps the positions of SONG1 and SONG2 (both song ids).

Music database

mopidy.mpd.protocol.music_db.count(context, mpd_query)[source]

Pattern:

count\ 
  (?P<mpd_query>
    (?:                 # Non-capturing group for repeating query pairs
      "?                # Optional quote around the field type
      (?:

    [Aa]lbum
  | [Aa]lbumartist
  | [Aa]ny
  | [Aa]rtist
  | [Cc]omment
  | [Cc]omposer
  | [Dd]ate
  | [Ff]ile
  | [Ff]ilename
  | [Gg]enre
  | [Pp]erformer
  | [Tt]itle
  | [Tt]rack

      )
      "?                # End of optional quote around the field type
      \                 # A single space
      "[^"]*"           # Matching a quoted search string
      \s?
    )+
  )
  $

musicpd.org, music database section:

count {TAG} {NEEDLE}

Counts the number of songs and their total playtime in the db matching TAG exactly.

GMPC:

  • does not add quotes around the tag argument.
  • use multiple tag-needle pairs to make more specific searches.
mopidy.mpd.protocol.music_db.find(context, mpd_query)[source]

Pattern:

find\ 
  (?P<mpd_query>
    (?:                 # Non-capturing group for repeating query pairs
      "?                # Optional quote around the field type
      (?:

    [Aa]lbum
  | [Aa]lbumartist
  | [Aa]ny
  | [Aa]rtist
  | [Cc]omment
  | [Cc]omposer
  | [Dd]ate
  | [Ff]ile
  | [Ff]ilename
  | [Gg]enre
  | [Pp]erformer
  | [Tt]itle
  | [Tt]rack

      )
      "?                # End of optional quote around the field type
      \                 # A single space
      "[^"]*"           # Matching a quoted search string
      \s?
    )+
  )
  $

musicpd.org, music database section:

find {TYPE} {WHAT}

Finds songs in the db that are exactly WHAT. TYPE can be any tag supported by MPD, or one of the two special parameters - file to search by full path (relative to database root), and any to match against all available tags. WHAT is what to find.

GMPC:

  • does not add quotes around the field argument.
  • also uses find album "[ALBUM]" artist "[ARTIST]" to list album tracks.

ncmpc:

  • does not add quotes around the field argument.
  • capitalizes the type argument.

ncmpcpp:

  • also uses the search type “date”.
  • uses “file” instead of “filename”.
mopidy.mpd.protocol.music_db.findadd(context, mpd_query)[source]

Pattern:

findadd\ 
  (?P<mpd_query>
    (?:                 # Non-capturing group for repeating query pairs
      "?                # Optional quote around the field type
      (?:

    [Aa]lbum
  | [Aa]lbumartist
  | [Aa]ny
  | [Aa]rtist
  | [Cc]omment
  | [Cc]omposer
  | [Dd]ate
  | [Ff]ile
  | [Ff]ilename
  | [Gg]enre
  | [Pp]erformer
  | [Tt]itle
  | [Tt]rack

      )
      "?                # End of optional quote around the field type
      \                 # A single space
      "[^"]*"           # Matching a quoted search string
      \s?
    )+
  )
  $

musicpd.org, music database section:

findadd {TYPE} {WHAT}

Finds songs in the db that are exactly WHAT and adds them to current playlist. Parameters have the same meaning as for find.

mopidy.mpd.protocol.music_db.list_(context, field, mpd_query=None)[source]

Pattern:

list\ 
  ("?)                  # Optional quote around the field type
  (?P<field>(           # Field to list in the response
      [Aa]lbum
    | [Aa]lbumartist
    | [Aa]rtist
    | [Cc]omposer
    | [Dd]ate
    | [Gg]enre
    | [Pp]erformer
  ))
  \1                    # End of optional quote around the field type
  (?:                   # Non-capturing group for optional search query
    \                   # A single space
    (?P<mpd_query>.*)
  )?
  $

musicpd.org, music database section:

list {TYPE} [ARTIST]

Lists all tags of the specified type. TYPE should be album, artist, albumartist, date, or genre.

ARTIST is an optional parameter when type is album, date, or genre. This filters the result list by an artist.

Clarifications:

The musicpd.org documentation for list is far from complete. The command also supports the following variant:

list {TYPE} {QUERY}

Where QUERY applies to all TYPE. QUERY is one or more pairs of a field name and a value. If the QUERY consists of more than one pair, the pairs are AND-ed together to find the result. Examples of valid queries and what they should return:

list "artist" "artist" "ABBA"

List artists where the artist name is “ABBA”. Response:

Artist: ABBA
OK
list "album" "artist" "ABBA"

Lists albums where the artist name is “ABBA”. Response:

Album: More ABBA Gold: More ABBA Hits
Album: Absolute More Christmas
Album: Gold: Greatest Hits
OK
list "artist" "album" "Gold: Greatest Hits"

Lists artists where the album name is “Gold: Greatest Hits”. Response:

Artist: ABBA
OK
list "artist" "artist" "ABBA" "artist" "TLC"

Lists artists where the artist name is “ABBA” and “TLC”. Should never match anything. Response:

OK
list "date" "artist" "ABBA"

Lists dates where artist name is “ABBA”. Response:

Date:
Date: 1992
Date: 1993
OK
list "date" "artist" "ABBA" "album" "Gold: Greatest Hits"

Lists dates where artist name is “ABBA” and album name is “Gold: Greatest Hits”. Response:

Date: 1992
OK
list "genre" "artist" "The Rolling Stones"

Lists genres where artist name is “The Rolling Stones”. Response:

Genre:
Genre: Rock
OK

GMPC:

  • does not add quotes around the field argument.

ncmpc:

  • does not add quotes around the field argument.
  • capitalizes the field argument.
mopidy.mpd.protocol.music_db.listall(context, uri=None)[source]

Pattern:

listall$

Pattern:

listall\ "(?P<uri>[^"]+)"$

musicpd.org, music database section:

listall [URI]

Lists all songs and directories in URI.

mopidy.mpd.protocol.music_db.listallinfo(context, uri=None)[source]

Pattern:

listallinfo$

Pattern:

listallinfo\ "(?P<uri>[^"]+)"$

musicpd.org, music database section:

listallinfo [URI]

Same as listall, except it also returns metadata info in the same format as lsinfo.

mopidy.mpd.protocol.music_db.lsinfo(context, uri=None)[source]

Pattern:

lsinfo$

Pattern:

lsinfo\ "(?P<uri>[^"]*)"$

musicpd.org, music database section:

lsinfo [URI]

Lists the contents of the directory URI.

When listing the root directory, this currently returns the list of stored playlists. This behavior is deprecated; use listplaylists instead.

MPD returns the same result, including both playlists and the files and directories located at the root level, for both lsinfo, lsinfo "", and lsinfo "/".

mopidy.mpd.protocol.music_db.rescan(context, uri=None)[source]

Pattern:

rescan$

Pattern:

rescan\ "(?P<uri>[^"]+)"$

musicpd.org, music database section:

rescan [URI]

Same as update, but also rescans unmodified files.

mopidy.mpd.protocol.music_db.search(context, mpd_query)[source]

Pattern:

search\ 
  (?P<mpd_query>
    (?:                 # Non-capturing group for repeating query pairs
      "?                # Optional quote around the field type
      (?:

    [Aa]lbum
  | [Aa]lbumartist
  | [Aa]ny
  | [Aa]rtist
  | [Cc]omment
  | [Cc]omposer
  | [Dd]ate
  | [Ff]ile
  | [Ff]ilename
  | [Gg]enre
  | [Pp]erformer
  | [Tt]itle
  | [Tt]rack

      )
      "?                # End of optional quote around the field type
      \                 # A single space
      "[^"]*"           # Matching a quoted search string
      \s?
    )+
  )
  $

musicpd.org, music database section:

search {TYPE} {WHAT} [...]

Searches for any song that contains WHAT. Parameters have the same meaning as for find, except that search is not case sensitive.

GMPC:

  • does not add quotes around the field argument.

  • uses the undocumented field any.

  • searches for multiple words like this:

    search any "foo" any "bar" any "baz"

ncmpc:

  • does not add quotes around the field argument.
  • capitalizes the field argument.

ncmpcpp:

  • also uses the search type “date”.
  • uses “file” instead of “filename”.
mopidy.mpd.protocol.music_db.searchadd(context, mpd_query)[source]

Pattern:

searchadd\ 
  (?P<mpd_query>
    (?:                 # Non-capturing group for repeating query pairs
      "?                # Optional quote around the field type
      (?:

    [Aa]lbum
  | [Aa]lbumartist
  | [Aa]ny
  | [Aa]rtist
  | [Cc]omment
  | [Cc]omposer
  | [Dd]ate
  | [Ff]ile
  | [Ff]ilename
  | [Gg]enre
  | [Pp]erformer
  | [Tt]itle
  | [Tt]rack

      )
      "?                # End of optional quote around the field type
      \                 # A single space
      "[^"]*"           # Matching a quoted search string
      \s?
    )+
  )
  $

musicpd.org, music database section:

searchadd {TYPE} {WHAT} [...]

Searches for any song that contains WHAT in tag TYPE and adds them to current playlist.

Parameters have the same meaning as for find, except that search is not case sensitive.

mopidy.mpd.protocol.music_db.searchaddpl(context, playlist_name, mpd_query)[source]

Pattern:

searchaddpl\ "(?P<playlist_name>[^"]+)"\ 
  (?P<mpd_query>
    (?:                 # Non-capturing group for repeating query pairs
      "?                # Optional quote around the field type
      (?:

    [Aa]lbum
  | [Aa]lbumartist
  | [Aa]ny
  | [Aa]rtist
  | [Cc]omment
  | [Cc]omposer
  | [Dd]ate
  | [Ff]ile
  | [Ff]ilename
  | [Gg]enre
  | [Pp]erformer
  | [Tt]itle
  | [Tt]rack

      )
      "?                # End of optional quote around the field type
      \                 # A single space
      "[^"]*"           # Matching a quoted search string
      \s?
    )+
  )
  $

musicpd.org, music database section:

searchaddpl {NAME} {TYPE} {WHAT} [...]

Searches for any song that contains WHAT in tag TYPE and adds them to the playlist named NAME.

If a playlist by that name doesn’t exist it is created.

Parameters have the same meaning as for find, except that search is not case sensitive.

mopidy.mpd.protocol.music_db.update(context, uri=None, rescan_unmodified_files=False)[source]

Pattern:

update$

Pattern:

update\ "(?P<uri>[^"]+)"$

musicpd.org, music database section:

update [URI]

Updates the music database: find new files, remove deleted files, update modified files.

URI is a particular directory or song/file to update. If you do not specify it, everything is updated.

Prints updating_db: JOBID where JOBID is a positive number identifying the update job. You can read the current job id in the status response.

Playback

mopidy.mpd.protocol.playback.consume(context, state)[source]

Pattern:

consume\ ("?)(?P<state>[01])\1$

musicpd.org, playback section:

consume {STATE}

Sets consume state to STATE, STATE should be 0 or 1. When consume is activated, each song played is removed from playlist.

mopidy.mpd.protocol.playback.crossfade(context, seconds)[source]

Pattern:

crossfade\ "(?P<seconds>\d+)"$

musicpd.org, playback section:

crossfade {SECONDS}

Sets crossfading between songs.

mopidy.mpd.protocol.playback.next_(context)[source]

Pattern:

next$

musicpd.org, playback section:

next

Plays next song in the playlist.

MPD’s behaviour when affected by repeat/random/single/consume:

Given a playlist of three tracks numbered 1, 2, 3, and a currently playing track c. next_track is defined at the track that will be played upon calls to next.

Tests performed on MPD 0.15.4-1ubuntu3.

     
repeat random single consume c = 1 c = 2 c = 3 Notes
T T T T 2 3 EOPL  
T T T . Rand Rand Rand [1]
T T . T Rand Rand Rand [4]
T T . . Rand Rand Rand [4]
T . T T 2 3 EOPL  
T . T . 2 3 1  
T . . T 3 3 EOPL  
T . . . 2 3 1  
. T T T Rand Rand Rand [3]
. T T . Rand Rand Rand [3]
. T . T Rand Rand Rand [2]
. T . . Rand Rand Rand [2]
. . T T 2 3 EOPL  
. . T . 2 3 EOPL  
. . . T 2 3 EOPL  
. . . . 2 3 EOPL  
  • When end of playlist (EOPL) is reached, the current track is unset.
  • [1] When random and single is combined, next selects a track randomly at each invocation, and not just the next track in an internal prerandomized playlist.
  • [2] When random is active, next will skip through all tracks in the playlist in random order, and finally EOPL is reached.
  • [3] single has no effect in combination with random alone, or random and consume.
  • [4] When random and repeat is active, EOPL is never reached, but the playlist is played again, in the same random order as the first time.
mopidy.mpd.protocol.playback.pause(context, state=None)[source]

Pattern:

pause$

Pattern:

pause\ "(?P<state>[01])"$

musicpd.org, playback section:

pause {PAUSE}

Toggles pause/resumes playing, PAUSE is 0 or 1.

MPDroid:

  • Calls pause without any arguments to toogle pause.
mopidy.mpd.protocol.playback.play(context)[source]

Pattern:

play$

The original MPD server resumes from the paused state on play without arguments.

mopidy.mpd.protocol.playback.play__pos(context, songpos)[source]

Pattern:

play\ ("?)(?P<songpos>-?\d+)\1$

musicpd.org, playback section:

play [SONGPOS]

Begins playing the playlist at song number SONGPOS.

Clarifications:

  • play "-1" when playing is ignored.
  • play "-1" when paused resumes playback.
  • play "-1" when stopped with a current track starts playback at the current track.
  • play "-1" when stopped without a current track, e.g. after playlist replacement, starts playback at the first track.

BitMPC:

  • issues play 6 without quotes around the argument.
mopidy.mpd.protocol.playback.playid(context, tlid)[source]

Pattern:

playid\ ("?)(?P<tlid>-?\d+)\1$

musicpd.org, playback section:

playid [SONGID]

Begins playing the playlist at song SONGID.

Clarifications:

  • playid "-1" when playing is ignored.
  • playid "-1" when paused resumes playback.
  • playid "-1" when stopped with a current track starts playback at the current track.
  • playid "-1" when stopped without a current track, e.g. after playlist replacement, starts playback at the first track.
mopidy.mpd.protocol.playback.previous(context)[source]

Pattern:

previous$

musicpd.org, playback section:

previous

Plays previous song in the playlist.

MPD’s behaviour when affected by repeat/random/single/consume:

Given a playlist of three tracks numbered 1, 2, 3, and a currently playing track c. previous_track is defined at the track that will be played upon previous calls.

Tests performed on MPD 0.15.4-1ubuntu3.

   
repeat random single consume c = 1 c = 2 c = 3
T T T T Rand? Rand? Rand?
T T T . 3 1 2
T T . T Rand? Rand? Rand?
T T . . 3 1 2
T . T T 3 1 2
T . T . 3 1 2
T . . T 3 1 2
T . . . 3 1 2
. T T T c c c
. T T . c c c
. T . T c c c
. T . . c c c
. . T T 1 1 2
. . T . 1 1 2
. . . T 1 1 2
. . . . 1 1 2
  • If time_position of the current track is 15s or more, previous should do a seek to time position 0.
mopidy.mpd.protocol.playback.random(context, state)[source]

Pattern:

random\ ("?)(?P<state>[01])\1$

musicpd.org, playback section:

random {STATE}

Sets random state to STATE, STATE should be 0 or 1.

mopidy.mpd.protocol.playback.repeat(context, state)[source]

Pattern:

repeat\ ("?)(?P<state>[01])\1$

musicpd.org, playback section:

repeat {STATE}

Sets repeat state to STATE, STATE should be 0 or 1.

mopidy.mpd.protocol.playback.replay_gain_mode(context, mode)[source]

Pattern:

replay_gain_mode\ "(?P<mode>(off|track|album))"$

musicpd.org, playback section:

replay_gain_mode {MODE}

Sets the replay gain mode. One of off, track, album.

Changing the mode during playback may take several seconds, because the new settings does not affect the buffered data.

This command triggers the options idle event.

mopidy.mpd.protocol.playback.replay_gain_status(context)[source]

Pattern:

replay_gain_status$

musicpd.org, playback section:

replay_gain_status

Prints replay gain options. Currently, only the variable replay_gain_mode is returned.

mopidy.mpd.protocol.playback.seek(context, songpos, seconds)[source]

Pattern:

seek\ ("?)(?P<songpos>\d+)\1\ ("?)(?P<seconds>\d+)\3$

musicpd.org, playback section:

seek {SONGPOS} {TIME}

Seeks to the position TIME (in seconds) of entry SONGPOS in the playlist.

Droid MPD:

  • issues seek 1 120 without quotes around the arguments.
mopidy.mpd.protocol.playback.seekcur(context, position=None, diff=None)[source]

Pattern:

seekcur\ "(?P<position>\d+)"$

Pattern:

seekcur\ "(?P<diff>[-+]\d+)"$

musicpd.org, playback section:

seekcur {TIME}

Seeks to the position TIME within the current song. If prefixed by ‘+’ or ‘-‘, then the time is relative to the current playing position.

mopidy.mpd.protocol.playback.seekid(context, tlid, seconds)[source]

Pattern:

seekid\ "(?P<tlid>\d+)"\ "(?P<seconds>\d+)"$

musicpd.org, playback section:

seekid {SONGID} {TIME}

Seeks to the position TIME (in seconds) of song SONGID.

mopidy.mpd.protocol.playback.setvol(context, volume)[source]

Pattern:

setvol\ ("?)(?P<volume>[-+]*\d+)\1$

musicpd.org, playback section:

setvol {VOL}

Sets volume to VOL, the range of volume is 0-100.

Droid MPD:

  • issues setvol 50 without quotes around the argument.
mopidy.mpd.protocol.playback.single(context, state)[source]

Pattern:

single\ ("?)(?P<state>[01])\1$

musicpd.org, playback section:

single {STATE}

Sets single state to STATE, STATE should be 0 or 1. When single is activated, playback is stopped after current song, or song is repeated if the repeat mode is enabled.

mopidy.mpd.protocol.playback.stop(context)[source]

Pattern:

stop$

musicpd.org, playback section:

stop

Stops playing.

Reflection

mopidy.mpd.protocol.reflection.commands(context)[source]

Pattern:

commands$

musicpd.org, reflection section:

commands

Shows which commands the current user has access to.

mopidy.mpd.protocol.reflection.config(context)[source]

Pattern:

config$

musicpd.org, reflection section:

config

Dumps configuration values that may be interesting for the client. This command is only permitted to “local” clients (connected via UNIX domain socket).

mopidy.mpd.protocol.reflection.decoders(context)[source]

Pattern:

decoders$

musicpd.org, reflection section:

decoders

Print a list of decoder plugins, followed by their supported suffixes and MIME types. Example response:

plugin: mad
suffix: mp3
suffix: mp2
mime_type: audio/mpeg
plugin: mpcdec
suffix: mpc

Clarifications:

  • ncmpcpp asks for decoders the first time you open the browse view. By returning nothing and OK instead of an not implemented error, we avoid “Not implemented” showing up in the ncmpcpp interface, and we get the list of playlists without having to enter the browse interface twice.
mopidy.mpd.protocol.reflection.notcommands(context)[source]

Pattern:

notcommands$

musicpd.org, reflection section:

notcommands

Shows which commands the current user does not have access to.

mopidy.mpd.protocol.reflection.tagtypes(context)[source]

Pattern:

tagtypes$

musicpd.org, reflection section:

tagtypes

Shows a list of available song metadata.

mopidy.mpd.protocol.reflection.urlhandlers(context)[source]

Pattern:

urlhandlers$

musicpd.org, reflection section:

urlhandlers

Gets a list of available URL handlers.

Status

mopidy.mpd.protocol.status.SUBSYSTEMS = [u'database', u'mixer', u'options', u'output', u'player', u'playlist', u'stored_playlist', u'update']

Subsystems that can be registered with idle command.

mopidy.mpd.protocol.status.clearerror(context)[source]

Pattern:

clearerror$

musicpd.org, status section:

clearerror

Clears the current error message in status (this is also accomplished by any command that starts playback).

mopidy.mpd.protocol.status.currentsong(context)[source]

Pattern:

currentsong$

musicpd.org, status section:

currentsong

Displays the song info of the current song (same song that is identified in status).

mopidy.mpd.protocol.status.idle(context, subsystems=None)[source]

Pattern:

idle$

Pattern:

idle\ (?P<subsystems>.+)$

musicpd.org, status section:

idle [SUBSYSTEMS...]

Waits until there is a noteworthy change in one or more of MPD’s subsystems. As soon as there is one, it lists all changed systems in a line in the format changed: SUBSYSTEM, where SUBSYSTEM is one of the following:

  • database: the song database has been modified after update.
  • update: a database update has started or finished. If the database was modified during the update, the database event is also emitted.
  • stored_playlist: a stored playlist has been modified, renamed, created or deleted
  • playlist: the current playlist has been modified
  • player: the player has been started, stopped or seeked
  • mixer: the volume has been changed
  • output: an audio output has been enabled or disabled
  • options: options like repeat, random, crossfade, replay gain

While a client is waiting for idle results, the server disables timeouts, allowing a client to wait for events as long as MPD runs. The idle command can be canceled by sending the command noidle (no other commands are allowed). MPD will then leave idle mode and print results immediately; might be empty at this time.

If the optional SUBSYSTEMS argument is used, MPD will only send notifications when something changed in one of the specified subsystems.

mopidy.mpd.protocol.status.noidle(context)[source]

Pattern:

noidle$

See _status_idle().

mopidy.mpd.protocol.status.stats(context)[source]

Pattern:

stats$

musicpd.org, status section:

stats

Displays statistics.

  • artists: number of artists
  • songs: number of albums
  • uptime: daemon uptime in seconds
  • db_playtime: sum of all song times in the db
  • db_update: last db update in UNIX time
  • playtime: time length of music played
mopidy.mpd.protocol.status.status(context)[source]

Pattern:

status$

musicpd.org, status section:

status

Reports the current status of the player and the volume level.

  • volume: 0-100 or -1
  • repeat: 0 or 1
  • single: 0 or 1
  • consume: 0 or 1
  • playlist: 31-bit unsigned integer, the playlist version number
  • playlistlength: integer, the length of the playlist
  • state: play, stop, or pause
  • song: playlist song number of the current song stopped on or playing
  • songid: playlist songid of the current song stopped on or playing
  • nextsong: playlist song number of the next song to be played
  • nextsongid: playlist songid of the next song to be played
  • time: total time elapsed (of current playing/paused song)
  • elapsed: Total time elapsed within the current song, but with higher resolution.
  • bitrate: instantaneous bitrate in kbps
  • xfade: crossfade in seconds
  • audio: sampleRate``:bits``:channels
  • updatings_db: job id
  • error: if there is an error, returns message here
Clarifications based on experience implementing
  • volume: can also be -1 if no output is set.
  • elapsed: Higher resolution means time in seconds with three decimal places for millisecond precision.

Stickers

mopidy.mpd.protocol.stickers.sticker__delete(context, field, uri, name=None)[source]

Pattern:

sticker\ delete\ "(?P<field>[^"]+)"\ "(?P<uri>[^"]+)"(\ "(?P<name>[^"]+)")*$

musicpd.org, sticker section:

sticker delete {TYPE} {URI} [NAME]

Deletes a sticker value from the specified object. If you do not specify a sticker name, all sticker values are deleted.

mopidy.mpd.protocol.stickers.sticker__find(context, field, uri, name)[source]

Pattern:

sticker\ find\ "(?P<field>[^"]+)"\ "(?P<uri>[^"]+)"\ "(?P<name>[^"]+)"$

musicpd.org, sticker section:

sticker find {TYPE} {URI} {NAME}

Searches the sticker database for stickers with the specified name, below the specified directory (URI). For each matching song, it prints the URI and that one sticker’s value.

mopidy.mpd.protocol.stickers.sticker__get(context, field, uri, name)[source]

Pattern:

sticker\ get\ "(?P<field>[^"]+)"\ "(?P<uri>[^"]+)"\ "(?P<name>[^"]+)"$

musicpd.org, sticker section:

sticker get {TYPE} {URI} {NAME}

Reads a sticker value for the specified object.

mopidy.mpd.protocol.stickers.sticker__list(context, field, uri)[source]

Pattern:

sticker\ list\ "(?P<field>[^"]+)"\ "(?P<uri>[^"]+)"$

musicpd.org, sticker section:

sticker list {TYPE} {URI}

Lists the stickers for the specified object.

mopidy.mpd.protocol.stickers.sticker__set(context, field, uri, name, value)[source]

Pattern:

sticker\ set\ "(?P<field>[^"]+)"\ "(?P<uri>[^"]+)"\ "(?P<name>[^"]+)"\ "(?P<value>[^"]+)"$

musicpd.org, sticker section:

sticker set {TYPE} {URI} {NAME} {VALUE}

Adds a sticker value to the specified object. If a sticker item with that name already exists, it is replaced.

Stored playlists

mopidy.mpd.protocol.stored_playlists.listplaylist(context, name)[source]

Pattern:

listplaylist\ ("?)(?P<name>[^"]+)\1$

musicpd.org, stored playlists section:

listplaylist {NAME}

Lists the files in the playlist NAME.m3u.

Output format:

file: relative/path/to/file1.flac
file: relative/path/to/file2.ogg
file: relative/path/to/file3.mp3
mopidy.mpd.protocol.stored_playlists.listplaylistinfo(context, name)[source]

Pattern:

listplaylistinfo\ ("?)(?P<name>[^"]+)\1$

musicpd.org, stored playlists section:

listplaylistinfo {NAME}

Lists songs in the playlist NAME.m3u.

Output format:

Standard track listing, with fields: file, Time, Title, Date, Album, Artist, Track
mopidy.mpd.protocol.stored_playlists.listplaylists(context)[source]

Pattern:

listplaylists$

musicpd.org, stored playlists section:

listplaylists

Prints a list of the playlist directory.

After each playlist name the server sends its last modification time as attribute Last-Modified in ISO 8601 format. To avoid problems due to clock differences between clients and the server, clients should not compare this value with their local clock.

Output format:

playlist: a
Last-Modified: 2010-02-06T02:10:25Z
playlist: b
Last-Modified: 2010-02-06T02:11:08Z

Clarifications:

  • ncmpcpp 0.5.10 segfaults if we return ‘playlist: ‘ on a line, so we must ignore playlists without names, which isn’t very useful anyway.
mopidy.mpd.protocol.stored_playlists.load(context, name, start=None, end=None)[source]

Pattern:

load\ "(?P<name>[^"]+)"(\ "(?P<start>\d+):(?P<end>\d+)*")*$

musicpd.org, stored playlists section:

load {NAME} [START:END]

Loads the playlist into the current queue. Playlist plugins are supported. A range may be specified to load only a part of the playlist.

Clarifications:

  • load appends the given playlist to the current playlist.
  • MPD 0.17.1 does not support open-ended ranges, i.e. without end specified, for the load command, even though MPD’s general range docs allows open-ended ranges.
  • MPD 0.17.1 does not fail if the specified range is outside the playlist, in either or both ends.
mopidy.mpd.protocol.stored_playlists.playlistadd(context, name, uri)[source]

Pattern:

playlistadd\ "(?P<name>[^"]+)"\ "(?P<uri>[^"]+)"$

musicpd.org, stored playlists section:

playlistadd {NAME} {URI}

Adds URI to the playlist NAME.m3u.

NAME.m3u will be created if it does not exist.

mopidy.mpd.protocol.stored_playlists.playlistclear(context, name)[source]

Pattern:

playlistclear\ "(?P<name>[^"]+)"$

musicpd.org, stored playlists section:

playlistclear {NAME}

Clears the playlist NAME.m3u.

mopidy.mpd.protocol.stored_playlists.playlistdelete(context, name, songpos)[source]

Pattern:

playlistdelete\ "(?P<name>[^"]+)"\ "(?P<songpos>\d+)"$

musicpd.org, stored playlists section:

playlistdelete {NAME} {SONGPOS}

Deletes SONGPOS from the playlist NAME.m3u.

mopidy.mpd.protocol.stored_playlists.playlistmove(context, name, from_pos, to_pos)[source]

Pattern:

playlistmove\ "(?P<name>[^"]+)"\ "(?P<from_pos>\d+)"\ "(?P<to_pos>\d+)"$

musicpd.org, stored playlists section:

playlistmove {NAME} {SONGID} {SONGPOS}

Moves SONGID in the playlist NAME.m3u to the position SONGPOS.

Clarifications:

  • The second argument is not a SONGID as used elsewhere in the protocol documentation, but just the SONGPOS to move from, i.e. playlistmove {NAME} {FROM_SONGPOS} {TO_SONGPOS}.
mopidy.mpd.protocol.stored_playlists.rename(context, old_name, new_name)[source]

Pattern:

rename\ "(?P<old_name>[^"]+)"\ "(?P<new_name>[^"]+)"$

musicpd.org, stored playlists section:

rename {NAME} {NEW_NAME}

Renames the playlist NAME.m3u to NEW_NAME.m3u.

mopidy.mpd.protocol.stored_playlists.rm(context, name)[source]

Pattern:

rm\ "(?P<name>[^"]+)"$

musicpd.org, stored playlists section:

rm {NAME}

Removes the playlist NAME.m3u from the playlist directory.

mopidy.mpd.protocol.stored_playlists.save(context, name)[source]

Pattern:

save\ "(?P<name>[^"]+)"$

musicpd.org, stored playlists section:

save {NAME}

Saves the current playlist to NAME.m3u in the playlist directory.