### Navigation

- index
- modules |
- previous |
- Mopidy 1.0.2 documentation »
- Module reference »

# `mopidy.mpd` – MPD server

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

## MPD tokenizer

`mopidy.mpd.tokenize.``split`(line)

  Splits a line into tokens using same rules as MPD.

  - Lines may not start with whitespace
  - Tokens are split by arbitrary amount of spaces or tabs
  - First token must match [a-z][a-z0-9_]*
  - Remaining tokens can be unquoted or quoted tokens.
  - Unquoted tokens consist of all printable characters except double quotes, single quotes, spaces and tabs.
  - Quoted tokens are surrounded by a matching pair of double quotes.
  - The closing quote must be followed by space, tab or end of line.
  - Any value is allowed inside a quoted token. Including double quotes, assuming it is correctly escaped.
  - Backslash inside a quoted token is used to escape the following character.

  For examples see the tests for this function.

## MPD dispatcher

class `mopidy.mpd.dispatcher.``MpdContext`(dispatcher, session=None, config=None, core=None, uri_map=None)

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

  `browse`(path, recursive=True, lookup=True)

    Browse the contents of a given directory path.

    Returns a sequence of two-tuples `(path, data)`.

    If `recursive` is true, it returns results for all entries in the given path.

    If `lookup` is true and the `path` is to a track, the returned `data` is a future which will contain the `mopidy.models.Track` model. If `lookup` is false and the `path` is to a track, the returned `data` will be a `mopidy.models.Ref` for the track.

    For all entries that are not tracks, the returned `data` will be `None`.

  `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_name_from_uri`(uri)

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

  `lookup_playlist_uri_from_name`(name)

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

  `password` = None

    The MPD password

  `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, uri_map=None)

  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)

    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.``BOOL`(value)

  Convert the values 0 and 1 into booleans.

class `mopidy.mpd.protocol.``Commands`

  Collection of MPD commands to expose to users.

  Normally used through the global instance which command handlers have been installed into.

  `add`(name, auth_required=True, list_command=True, **validators)

    Create a decorator that registers a handler and validation rules.

    Additional keyword arguments are treated as converters/validators to apply to tokens converting them to proper Python types.

    Requirements for valid handlers:

    - must accept a context argument as the first arg.
    - may not use variable keyword arguments, `**kwargs`.
    - may use variable arguments `*args` or a mix of required and optional arguments.

    Decorator returns the unwrapped function so that tests etc can use the functions with values with correct python types instead of strings.

    Parameters: | name (string) – Name of the command being registered. auth_required (bool) – If authorization is required. list_command (bool) – If command should be listed in reflection.

  `call`(tokens, context=None)

    Find and run the handler registered for the given command.

    If the handler was registered with any converters/validators they will be run before calling the real handler.

    Parameters: | tokens (list) – List of tokens to process context (`MpdContext`) – MPD context.

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

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

`mopidy.mpd.protocol.``INT`(value)

  Converts a value that matches [+-]?d+ into and integer.

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

  The MPD protocol uses `\n` as line terminator.

`mopidy.mpd.protocol.``RANGE`(value)

  Convert a single integer or range spec into a slice

  `n` should become `slice(n, n+1)` `n:` should become `slice(n, None)` `n:m` should become `slice(n, m)` and `m > n` must hold

`mopidy.mpd.protocol.``UINT`(value)

  Converts a value that matches d+ into an integer.

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

  The MPD protocol version is 0.17.0.

`mopidy.mpd.protocol.``commands` = <mopidy.mpd.protocol.Commands object at 0x7fc622fed7d0>

  Global instance to install commands into

`mopidy.mpd.protocol.``load_protocol_modules`()

  The protocol modules must be imported to get them registered in `commands`.

### Audio output

`mopidy.mpd.protocol.audio_output.``disableoutput`(context, outputid)

  musicpd.org, audio output section:

  > `disableoutput`

  > Turns an output off.

`mopidy.mpd.protocol.audio_output.``enableoutput`(context, outputid)

  musicpd.org, audio output section:

  > `enableoutput`

  > Turns an output on.

`mopidy.mpd.protocol.audio_output.``outputs`(context)

  musicpd.org, audio output section:

  > `outputs`

  > Shows information about all outputs.

`mopidy.mpd.protocol.audio_output.``toggleoutput`(context, outputid)

  musicpd.org, audio output section:

  > `toggleoutput {ID}`

  > Turns an output on or off, depending on the current state.

### Channels

`mopidy.mpd.protocol.channels.``channels`(context)

  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)

  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)

  musicpd.org, client to client section:

  > `sendmessage {CHANNEL} {TEXT}`

  > Send a message to the specified channel.

`mopidy.mpd.protocol.channels.``subscribe`(context, channel)

  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)

  musicpd.org, client to client section:

  > `unsubscribe {NAME}`

  > Unsubscribe from a channel.

### Command list

`mopidy.mpd.protocol.command_list.``command_list_begin`(context)

  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)

  See `command_list_begin()`.

`mopidy.mpd.protocol.command_list.``command_list_ok_begin`(context)

  See `command_list_begin()`.

### Connection

`mopidy.mpd.protocol.connection.``close`(context)

  musicpd.org, connection section:

  > `close`

  > Closes the connection to MPD.

`mopidy.mpd.protocol.connection.``kill`(context)

  musicpd.org, connection section:

  > `kill`

  > Kills MPD.

`mopidy.mpd.protocol.connection.``password`(context, 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)

  musicpd.org, connection section:

  > `ping`

  > Does nothing but return `OK`.

### Current playlist

`mopidy.mpd.protocol.current_playlist.``add`(context, 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)

  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.``addtagid`(context, tlid, tag, value)

  musicpd.org, current playlist section:

  > `addtagid {SONGID} {TAG} {VALUE}`

  > Adds a tag to the specified song. Editing song tags is only possible for remote songs. This change is volatile: it may be overwritten by tags received from the server, and the data is gone when the song gets removed from the queue.

`mopidy.mpd.protocol.current_playlist.``clear`(context)

  musicpd.org, current playlist section:

  > `clear`

  > Clears the current playlist.

`mopidy.mpd.protocol.current_playlist.``cleartagid`(context, tlid, tag)

  musicpd.org, current playlist section:

  > `cleartagid {SONGID} [TAG]`

  > Removes tags from the specified song. If TAG is not specified, then all tag values will be removed. Editing song tags is only possible for remote songs.

`mopidy.mpd.protocol.current_playlist.``delete`(context, position)

  musicpd.org, current playlist section:

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

  > Deletes a song from the playlist.

`mopidy.mpd.protocol.current_playlist.``deleteid`(context, tlid)

  musicpd.org, current playlist section:

  > `deleteid {SONGID}`

  > Deletes the song `SONGID` from the playlist

`mopidy.mpd.protocol.current_playlist.``move_range`(context, position, to)

  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.``moveid`(context, tlid, to)

  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)

  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)

  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)

  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, parameter=None)

  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)

  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)

  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)

  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.``prio`(context, priority, position)

  musicpd.org, current playlist section:

  > `prio {PRIORITY} {START:END...}`

  > Set the priority of the specified songs. A higher priority means that it will be played first when “random” mode is enabled.

  > A priority is an integer between 0 and 255. The default priority of new songs is 0.

`mopidy.mpd.protocol.current_playlist.``prioid`(context, *args)

  musicpd.org, current playlist section:

  > `prioid {PRIORITY} {ID...}`

  > Same as prio, but address the songs with their id.

`mopidy.mpd.protocol.current_playlist.``shuffle`(context, position=None)

  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)

  musicpd.org, current playlist section:

  > `swap {SONG1} {SONG2}`

  > Swaps the positions of `SONG1` and `SONG2`.

`mopidy.mpd.protocol.current_playlist.``swapid`(context, tlid1, tlid2)

  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, *args)

  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, *args)

  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, *args)

  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, *args)

  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)

  musicpd.org, music database section:

  > `listall [URI]`

  > Lists all songs and directories in `URI`.

  > Do not use this command. Do not manage a client-side copy of MPD’s database. That is fragile and adds huge overhead. It will break with large databases. Instead, query MPD whenever you need something.

  Warning

  This command is disabled by default in Mopidy installs.

`mopidy.mpd.protocol.music_db.``listallinfo`(context, uri=None)

  musicpd.org, music database section:

  > `listallinfo [URI]`

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

  > Do not use this command. Do not manage a client-side copy of MPD’s database. That is fragile and adds huge overhead. It will break with large databases. Instead, query MPD whenever you need something.

  Warning

  This command is disabled by default in Mopidy installs.

`mopidy.mpd.protocol.music_db.``lsinfo`(context, uri=None)

  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.``readcomments`(context, uri)

  musicpd.org, music database section:

  > `readcomments [URI]`

  > Read “comments” (i.e. key-value pairs) from the file specified by “URI”. This “URI” can be a path relative to the music directory or a URL in the form “file:///foo/bar.ogg”.

  > This command may be used to list metadata of remote files (e.g. URI beginning with “http://” or “smb://”).

  > The response consists of lines in the form “KEY: VALUE”. Comments with suspicious characters (e.g. newlines) are ignored silently.

  > The meaning of these depends on the codec, and not all decoder plugins support it. For example, on Ogg files, this lists the Vorbis comments.

`mopidy.mpd.protocol.music_db.``rescan`(context, uri=None)

  musicpd.org, music database section:

  > `rescan [URI]`

  > Same as `update`, but also rescans unmodified files.

`mopidy.mpd.protocol.music_db.``search`(context, *args)

  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, *args)

  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, *args)

  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)

  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)

  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)

  musicpd.org, playback section:

  > `crossfade {SECONDS}`

  > Sets crossfading between songs.

`mopidy.mpd.protocol.playback.``mixrampdb`(context, decibels)

  musicpd.org, playback section:

  > `mixrampdb {deciBels}`

  Sets the threshold at which songs will be overlapped. Like crossfading but doesn’t fade the track volume, just overlaps. The songs need to have MixRamp tags added by an external tool. 0dB is the normalized maximum volume so use negative values, I prefer -17dB. In the absence of mixramp tags crossfading will be used. See http://sourceforge.net/projects/mixramp

`mopidy.mpd.protocol.playback.``mixrampdelay`(context, seconds)

  musicpd.org, playback section:

  > `mixrampdelay {SECONDS}`

  > Additional time subtracted from the overlap calculated by mixrampdb. A value of “nan” disables MixRamp overlapping and falls back to crossfading.

`mopidy.mpd.protocol.playback.``next_`(context)

  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)

  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, tlid=None)

  musicpd.org, playback section:

  > `play [SONGPOS]`

  > Begins playing the playlist at song number `SONGPOS`.

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

  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)

  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)

  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)

  musicpd.org, playback section:

  > `random {STATE}`

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

`mopidy.mpd.protocol.playback.``repeat`(context, state)

  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)

  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)

  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, tlid, seconds)

  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, time)

  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)

  musicpd.org, playback section:

  > `seekid {SONGID} {TIME}`

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

`mopidy.mpd.protocol.playback.``setvol`(context, volume)

  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)

  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)

  musicpd.org, playback section:

  > `stop`

  > Stops playing.

### Reflection

`mopidy.mpd.protocol.reflection.``commands`(context)

  musicpd.org, reflection section:

  > `commands`

  > Shows which commands the current user has access to.

`mopidy.mpd.protocol.reflection.``config`(context)

  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)

  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)

  musicpd.org, reflection section:

  > `notcommands`

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

`mopidy.mpd.protocol.reflection.``tagtypes`(context)

  musicpd.org, reflection section:

  > `tagtypes`

  > Shows a list of available song metadata.

`mopidy.mpd.protocol.reflection.``urlhandlers`(context)

  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)

  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)

  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)

  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)

  See `_status_idle()`.

`mopidy.mpd.protocol.status.``stats`(context)

  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)

  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`(context, action, field, uri, name=None, value=None)

  musicpd.org, sticker section:

  > `sticker list {TYPE} {URI}`

  > Lists the stickers for the specified object.

  > `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.

  > `sticker get {TYPE} {URI} {NAME}`

  > Reads a sticker value for the specified object.

  > `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.

  > `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.

### Stored playlists

`mopidy.mpd.protocol.stored_playlists.``listplaylist`(context, name)

  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)

  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)

  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, playlist_slice=slice(0, None, None))

  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)

  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)

  musicpd.org, stored playlists section:

  > `playlistclear {NAME}`

  > Clears the playlist `NAME.m3u`.

`mopidy.mpd.protocol.stored_playlists.``playlistdelete`(context, name, songpos)

  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)

  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)

  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)

  musicpd.org, stored playlists section:

  > `rm {NAME}`

  > Removes the playlist `NAME.m3u` from the playlist directory.

`mopidy.mpd.protocol.stored_playlists.``save`(context, name)

  musicpd.org, stored playlists section:

  > `save {NAME}`

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

### Navigation

- index
- modules |
- previous |
- Mopidy 1.0.2 documentation »
- Module reference »