Replace 'frontend' with 'context' in MPD protocol impl

mopidy/frontends/mpd/protocol/audio_output.py

@@ -2,7 +2,7 @@ from mopidy.frontends.mpd.protocol import handle_pattern
 from mopidy.frontends.mpd.exceptions import MpdNotImplemented
 
 @handle_pattern(r'^disableoutput "(?P<outputid>\d+)"$')
-def disableoutput(frontend, outputid):
+def disableoutput(context, outputid):
     """
     *musicpd.org, audio output section:*
 
@@ -13,7 +13,7 @@ def disableoutput(frontend, outputid):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^enableoutput "(?P<outputid>\d+)"$')
-def enableoutput(frontend, outputid):
+def enableoutput(context, outputid):
     """
     *musicpd.org, audio output section:*
 
@@ -24,7 +24,7 @@ def enableoutput(frontend, outputid):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^outputs$')
-def outputs(frontend):
+def outputs(context):
     """
     *musicpd.org, audio output section:*
 

mopidy/frontends/mpd/protocol/command_list.py

@@ -2,7 +2,7 @@ from mopidy.frontends.mpd.protocol import handle_pattern
 from mopidy.frontends.mpd.exceptions import MpdUnknownCommand
 
 @handle_pattern(r'^command_list_begin$')
-def command_list_begin(frontend):
+def command_list_begin(context):
     """
     *musicpd.org, command list section:*
 
@@ -18,21 +18,21 @@ def command_list_begin(frontend):
         returned. If ``command_list_ok_begin`` is used, ``list_OK`` is
         returned for each successful command executed in the command list.
     """
-    frontend.command_list = []
+    context.command_list = []
-    frontend.command_list_ok = False
+    context.command_list_ok = False
 
 @handle_pattern(r'^command_list_end$')
-def command_list_end(frontend):
+def command_list_end(context):
     """See :meth:`command_list_begin()`."""
-    if frontend.command_list is False:
+    if context.command_list is False:
         # Test for False exactly, and not e.g. empty list
         raise MpdUnknownCommand(command='command_list_end')
-    (command_list, frontend.command_list) = (frontend.command_list, False)
+    (command_list, context.command_list) = (context.command_list, False)
-    (command_list_ok, frontend.command_list_ok) = (
+    (command_list_ok, context.command_list_ok) = (
-        frontend.command_list_ok, False)
+        context.command_list_ok, False)
     result = []
     for i, command in enumerate(command_list):
-        response = frontend.handle_request(command, command_list_index=i)
+        response = context.handle_request(command, command_list_index=i)
         if response is not None:
             result.append(response)
         if response and response[-1].startswith(u'ACK'):
@@ -42,7 +42,7 @@ def command_list_end(frontend):
     return result
 
 @handle_pattern(r'^command_list_ok_begin$')
-def command_list_ok_begin(frontend):
+def command_list_ok_begin(context):
     """See :meth:`command_list_begin()`."""
-    frontend.command_list = []
+    context.command_list = []
-    frontend.command_list_ok = True
+    context.command_list_ok = True

mopidy/frontends/mpd/protocol/connection.py

@@ -3,7 +3,7 @@ from mopidy.frontends.mpd.protocol import handle_pattern
 from mopidy.frontends.mpd.exceptions import MpdPasswordError
 
 @handle_pattern(r'^close$')
-def close(frontend):
+def close(context):
     """
     *musicpd.org, connection section:*
 
@@ -14,7 +14,7 @@ def close(frontend):
     pass # TODO
 
 @handle_pattern(r'^kill$')
-def kill(frontend):
+def kill(context):
     """
     *musicpd.org, connection section:*
 
@@ -25,7 +25,7 @@ def kill(frontend):
     pass # TODO
 
 @handle_pattern(r'^password "(?P<password>[^"]+)"$')
-def password_(frontend, password):
+def password_(context, password):
     """
     *musicpd.org, connection section:*
 
@@ -41,7 +41,7 @@ def password_(frontend, password):
         raise MpdPasswordError(u'incorrect password', command=u'password')
 
 @handle_pattern(r'^ping$')
-def ping(frontend):
+def ping(context):
     """
     *musicpd.org, connection section:*
 

mopidy/frontends/mpd/protocol/current_playlist.py

@@ -4,7 +4,7 @@ from mopidy.frontends.mpd.protocol import handle_pattern
 from mopidy.frontends.mpd.translator import tracks_to_mpd_format
 
 @handle_pattern(r'^add "(?P<uri>[^"]*)"$')
-def add(frontend, uri):
+def add(context, uri):
     """
     *musicpd.org, current playlist section:*
 
@@ -19,17 +19,17 @@ def add(frontend, uri):
     """
     if not uri:
         return
-    for handler_prefix in frontend.backend.uri_handlers.get():
+    for handler_prefix in context.backend.uri_handlers.get():
         if uri.startswith(handler_prefix):
-            track = frontend.backend.library.lookup(uri).get()
+            track = context.backend.library.lookup(uri).get()
             if track is not None:
-                frontend.backend.current_playlist.add(track)
+                context.backend.current_playlist.add(track)
                 return
     raise MpdNoExistError(
         u'directory or file not found', command=u'add')
 
 @handle_pattern(r'^addid "(?P<uri>[^"]*)"( "(?P<songpos>\d+)")*$')
-def addid(frontend, uri, songpos=None):
+def addid(context, uri, songpos=None):
     """
     *musicpd.org, current playlist section:*
 
@@ -51,18 +51,18 @@ def addid(frontend, uri, songpos=None):
         raise MpdNoExistError(u'No such song', command=u'addid')
     if songpos is not None:
         songpos = int(songpos)
-    track = frontend.backend.library.lookup(uri).get()
+    track = context.backend.library.lookup(uri).get()
     if track is None:
         raise MpdNoExistError(u'No such song', command=u'addid')
     if songpos and songpos > len(
-            frontend.backend.current_playlist.tracks.get()):
+            context.backend.current_playlist.tracks.get()):
         raise MpdArgError(u'Bad song index', command=u'addid')
-    cp_track = frontend.backend.current_playlist.add(track,
+    cp_track = context.backend.current_playlist.add(track,
         at_position=songpos).get()
     return ('Id', cp_track[0])
 
 @handle_pattern(r'^delete "(?P<start>\d+):(?P<end>\d+)*"$')
-def delete_range(frontend, start, end=None):
+def delete_range(context, start, end=None):
     """
     *musicpd.org, current playlist section:*
 
@@ -74,25 +74,25 @@ def delete_range(frontend, start, end=None):
     if end is not None:
         end = int(end)
     else:
-        end = len(frontend.backend.current_playlist.tracks.get())
+        end = len(context.backend.current_playlist.tracks.get())
-    cp_tracks = frontend.backend.current_playlist.cp_tracks.get()[start:end]
+    cp_tracks = context.backend.current_playlist.cp_tracks.get()[start:end]
     if not cp_tracks:
         raise MpdArgError(u'Bad song index', command=u'delete')
     for (cpid, _) in cp_tracks:
-        frontend.backend.current_playlist.remove(cpid=cpid)
+        context.backend.current_playlist.remove(cpid=cpid)
 
 @handle_pattern(r'^delete "(?P<songpos>\d+)"$')
-def delete_songpos(frontend, songpos):
+def delete_songpos(context, songpos):
     """See :meth:`delete_range`"""
     try:
         songpos = int(songpos)
-        (cpid, _) = frontend.backend.current_playlist.cp_tracks.get()[songpos]
+        (cpid, _) = context.backend.current_playlist.cp_tracks.get()[songpos]
-        frontend.backend.current_playlist.remove(cpid=cpid)
+        context.backend.current_playlist.remove(cpid=cpid)
     except IndexError:
         raise MpdArgError(u'Bad song index', command=u'delete')
 
 @handle_pattern(r'^deleteid "(?P<cpid>\d+)"$')
-def deleteid(frontend, cpid):
+def deleteid(context, cpid):
     """
     *musicpd.org, current playlist section:*
 
@@ -102,14 +102,14 @@ def deleteid(frontend, cpid):
     """
     try:
         cpid = int(cpid)
-        if frontend.backend.playback.current_cpid.get() == cpid:
+        if context.backend.playback.current_cpid.get() == cpid:
-            frontend.backend.playback.next()
+            context.backend.playback.next()
-        return frontend.backend.current_playlist.remove(cpid=cpid).get()
+        return context.backend.current_playlist.remove(cpid=cpid).get()
     except LookupError:
         raise MpdNoExistError(u'No such song', command=u'deleteid')
 
 @handle_pattern(r'^clear$')
-def clear(frontend):
+def clear(context):
     """
     *musicpd.org, current playlist section:*
 
@@ -117,10 +117,10 @@ def clear(frontend):
 
         Clears the current playlist.
     """
-    frontend.backend.current_playlist.clear()
+    context.backend.current_playlist.clear()
 
 @handle_pattern(r'^move "(?P<start>\d+):(?P<end>\d+)*" "(?P<to>\d+)"$')
-def move_range(frontend, start, to, end=None):
+def move_range(context, start, to, end=None):
     """
     *musicpd.org, current playlist section:*
 
@@ -130,21 +130,21 @@ def move_range(frontend, start, to, end=None):
         ``TO`` in the playlist.
     """
     if end is None:
-        end = len(frontend.backend.current_playlist.tracks.get())
+        end = len(context.backend.current_playlist.tracks.get())
     start = int(start)
     end = int(end)
     to = int(to)
-    frontend.backend.current_playlist.move(start, end, to)
+    context.backend.current_playlist.move(start, end, to)
 
 @handle_pattern(r'^move "(?P<songpos>\d+)" "(?P<to>\d+)"$')
-def move_songpos(frontend, songpos, to):
+def move_songpos(context, songpos, to):
     """See :meth:`move_range`."""
     songpos = int(songpos)
     to = int(to)
-    frontend.backend.current_playlist.move(songpos, songpos + 1, to)
+    context.backend.current_playlist.move(songpos, songpos + 1, to)
 
 @handle_pattern(r'^moveid "(?P<cpid>\d+)" "(?P<to>\d+)"$')
-def moveid(frontend, cpid, to):
+def moveid(context, cpid, to):
     """
     *musicpd.org, current playlist section:*
 
@@ -156,13 +156,13 @@ def moveid(frontend, cpid, to):
     """
     cpid = int(cpid)
     to = int(to)
-    cp_track = frontend.backend.current_playlist.get(cpid=cpid).get()
+    cp_track = context.backend.current_playlist.get(cpid=cpid).get()
-    position = frontend.backend.current_playlist.cp_tracks.get().index(
+    position = context.backend.current_playlist.cp_tracks.get().index(
         cp_track)
-    frontend.backend.current_playlist.move(position, position + 1, to)
+    context.backend.current_playlist.move(position, position + 1, to)
 
 @handle_pattern(r'^playlist$')
-def playlist(frontend):
+def playlist(context):
     """
     *musicpd.org, current playlist section:*
 
@@ -174,11 +174,11 @@ def playlist(frontend):
 
             Do not use this, instead use ``playlistinfo``.
     """
-    return playlistinfo(frontend)
+    return playlistinfo(context)
 
 @handle_pattern(r'^playlistfind (?P<tag>[^"]+) "(?P<needle>[^"]+)"$')
 @handle_pattern(r'^playlistfind "(?P<tag>[^"]+)" "(?P<needle>[^"]+)"$')
-def playlistfind(frontend, tag, needle):
+def playlistfind(context, tag, needle):
     """
     *musicpd.org, current playlist section:*
 
@@ -192,9 +192,9 @@ def playlistfind(frontend, tag, needle):
     """
     if tag == 'filename':
         try:
-            cp_track = frontend.backend.current_playlist.get(uri=needle).get()
+            cp_track = context.backend.current_playlist.get(uri=needle).get()
             (cpid, track) = cp_track
-            position = frontend.backend.current_playlist.cp_tracks.get().index(
+            position = context.backend.current_playlist.cp_tracks.get().index(
                 cp_track)
             return track.mpd_format(cpid=cpid, position=position)
         except LookupError:
@@ -202,7 +202,7 @@ def playlistfind(frontend, tag, needle):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^playlistid( "(?P<cpid>\d+)")*$')
-def playlistid(frontend, cpid=None):
+def playlistid(context, cpid=None):
     """
     *musicpd.org, current playlist section:*
 
@@ -214,22 +214,22 @@ def playlistid(frontend, cpid=None):
     if cpid is not None:
         try:
             cpid = int(cpid)
-            cp_track = frontend.backend.current_playlist.get(cpid=cpid).get()
+            cp_track = context.backend.current_playlist.get(cpid=cpid).get()
-            position = frontend.backend.current_playlist.cp_tracks.get().index(
+            position = context.backend.current_playlist.cp_tracks.get().index(
                 cp_track)
             return cp_track[1].mpd_format(position=position, cpid=cpid)
         except LookupError:
             raise MpdNoExistError(u'No such song', command=u'playlistid')
     else:
         cpids = [ct[0] for ct in
-            frontend.backend.current_playlist.cp_tracks.get()]
+            context.backend.current_playlist.cp_tracks.get()]
         return tracks_to_mpd_format(
-            frontend.backend.current_playlist.tracks.get(), cpids=cpids)
+            context.backend.current_playlist.tracks.get(), cpids=cpids)
 
 @handle_pattern(r'^playlistinfo$')
 @handle_pattern(r'^playlistinfo "(?P<songpos>-?\d+)"$')
 @handle_pattern(r'^playlistinfo "(?P<start>\d+):(?P<end>\d+)*"$')
-def playlistinfo(frontend, songpos=None,
+def playlistinfo(context, songpos=None,
         start=None, end=None):
     """
     *musicpd.org, current playlist section:*
@@ -255,30 +255,30 @@ def playlistinfo(frontend, songpos=None,
         if start == -1:
             end = None
         cpids = [ct[0] for ct in
-            frontend.backend.current_playlist.cp_tracks.get()]
+            context.backend.current_playlist.cp_tracks.get()]
         return tracks_to_mpd_format(
-            frontend.backend.current_playlist.tracks.get(),
+            context.backend.current_playlist.tracks.get(),
             start, end, cpids=cpids)
     else:
         if start is None:
             start = 0
         start = int(start)
         if not (0 <= start <= len(
-                frontend.backend.current_playlist.tracks.get())):
+                context.backend.current_playlist.tracks.get())):
             raise MpdArgError(u'Bad song index', command=u'playlistinfo')
         if end is not None:
             end = int(end)
-            if end > len(frontend.backend.current_playlist.tracks.get()):
+            if end > len(context.backend.current_playlist.tracks.get()):
                 end = None
         cpids = [ct[0] for ct in
-            frontend.backend.current_playlist.cp_tracks.get()]
+            context.backend.current_playlist.cp_tracks.get()]
         return tracks_to_mpd_format(
-            frontend.backend.current_playlist.tracks.get(),
+            context.backend.current_playlist.tracks.get(),
             start, end, cpids=cpids)
 
 @handle_pattern(r'^playlistsearch "(?P<tag>[^"]+)" "(?P<needle>[^"]+)"$')
 @handle_pattern(r'^playlistsearch (?P<tag>\S+) "(?P<needle>[^"]+)"$')
-def playlistsearch(frontend, tag, needle):
+def playlistsearch(context, tag, needle):
     """
     *musicpd.org, current playlist section:*
 
@@ -296,7 +296,7 @@ def playlistsearch(frontend, tag, needle):
 
 @handle_pattern(r'^plchanges (?P<version>-?\d+)$')
 @handle_pattern(r'^plchanges "(?P<version>-?\d+)"$')
-def plchanges(frontend, version):
+def plchanges(context, version):
     """
     *musicpd.org, current playlist section:*
 
@@ -312,14 +312,14 @@ def plchanges(frontend, version):
     - Calls ``plchanges "-1"`` two times per second to get the entire playlist.
     """
     # XXX Naive implementation that returns all tracks as changed
-    if int(version) < frontend.backend.current_playlist.version:
+    if int(version) < context.backend.current_playlist.version:
         cpids = [ct[0] for ct in
-            frontend.backend.current_playlist.cp_tracks.get()]
+            context.backend.current_playlist.cp_tracks.get()]
         return tracks_to_mpd_format(
-            frontend.backend.current_playlist.tracks.get(), cpids=cpids)
+            context.backend.current_playlist.tracks.get(), cpids=cpids)
 
 @handle_pattern(r'^plchangesposid "(?P<version>\d+)"$')
-def plchangesposid(frontend, version):
+def plchangesposid(context, version):
     """
     *musicpd.org, current playlist section:*
 
@@ -333,17 +333,17 @@ def plchangesposid(frontend, version):
         ``playlistlength`` returned by status command.
     """
     # XXX Naive implementation that returns all tracks as changed
-    if int(version) != frontend.backend.current_playlist.version.get():
+    if int(version) != context.backend.current_playlist.version.get():
         result = []
         for (position, (cpid, _)) in enumerate(
-                frontend.backend.current_playlist.cp_tracks.get()):
+                context.backend.current_playlist.cp_tracks.get()):
             result.append((u'cpos', position))
             result.append((u'Id', cpid))
         return result
 
 @handle_pattern(r'^shuffle$')
 @handle_pattern(r'^shuffle "(?P<start>\d+):(?P<end>\d+)*"$')
-def shuffle(frontend, start=None, end=None):
+def shuffle(context, start=None, end=None):
     """
     *musicpd.org, current playlist section:*
 
@@ -356,10 +356,10 @@ def shuffle(frontend, start=None, end=None):
         start = int(start)
     if end is not None:
         end = int(end)
-    frontend.backend.current_playlist.shuffle(start, end)
+    context.backend.current_playlist.shuffle(start, end)
 
 @handle_pattern(r'^swap "(?P<songpos1>\d+)" "(?P<songpos2>\d+)"$')
-def swap(frontend, songpos1, songpos2):
+def swap(context, songpos1, songpos2):
     """
     *musicpd.org, current playlist section:*
 
@@ -369,18 +369,18 @@ def swap(frontend, songpos1, songpos2):
     """
     songpos1 = int(songpos1)
     songpos2 = int(songpos2)
-    tracks = frontend.backend.current_playlist.tracks.get()
+    tracks = context.backend.current_playlist.tracks.get()
     song1 = tracks[songpos1]
     song2 = tracks[songpos2]
     del tracks[songpos1]
     tracks.insert(songpos1, song2)
     del tracks[songpos2]
     tracks.insert(songpos2, song1)
-    frontend.backend.current_playlist.clear()
+    context.backend.current_playlist.clear()
-    frontend.backend.current_playlist.append(tracks)
+    context.backend.current_playlist.append(tracks)
 
 @handle_pattern(r'^swapid "(?P<cpid1>\d+)" "(?P<cpid2>\d+)"$')
-def swapid(frontend, cpid1, cpid2):
+def swapid(context, cpid1, cpid2):
     """
     *musicpd.org, current playlist section:*
 
@@ -390,9 +390,9 @@ def swapid(frontend, cpid1, cpid2):
     """
     cpid1 = int(cpid1)
     cpid2 = int(cpid2)
-    cp_track1 = frontend.backend.current_playlist.get(cpid=cpid1).get()
+    cp_track1 = context.backend.current_playlist.get(cpid=cpid1).get()
-    cp_track2 = frontend.backend.current_playlist.get(cpid=cpid2).get()
+    cp_track2 = context.backend.current_playlist.get(cpid=cpid2).get()
-    cp_tracks = frontend.backend.current_playlist.cp_tracks.get()
+    cp_tracks = context.backend.current_playlist.cp_tracks.get()
     position1 = cp_tracks.index(cp_track1)
     position2 = cp_tracks.index(cp_track2)
-    swap(frontend, position1, position2)
+    swap(context, position1, position2)

mopidy/frontends/mpd/protocol/empty.py

@@ -1,6 +1,6 @@
 from mopidy.frontends.mpd.protocol import handle_pattern
 
 @handle_pattern(r'^$')
-def empty(frontend):
+def empty(context):
     """The original MPD server returns ``OK`` on an empty request."""
     pass

mopidy/frontends/mpd/protocol/music_db.py

@@ -29,7 +29,7 @@ def _build_query(mpd_query):
     return query
 
 @handle_pattern(r'^count "(?P<tag>[^"]+)" "(?P<needle>[^"]*)"$')
-def count(frontend, tag, needle):
+def count(context, tag, needle):
     """
     *musicpd.org, music database section:*
 
@@ -43,7 +43,7 @@ def count(frontend, tag, needle):
 @handle_pattern(r'^find '
      r'(?P<mpd_query>("?([Aa]lbum|[Aa]rtist|[Dd]ate|[Ff]ilename|'
      r'[Tt]itle|[Aa]ny)"? "[^"]+"\s?)+)$')
-def find(frontend, mpd_query):
+def find(context, mpd_query):
     """
     *musicpd.org, music database section:*
 
@@ -68,12 +68,12 @@ def find(frontend, mpd_query):
     - also uses the search type "date".
     """
     query = _build_query(mpd_query)
-    return frontend.backend.library.find_exact(**query).get().mpd_format()
+    return context.backend.library.find_exact(**query).get().mpd_format()
 
 @handle_pattern(r'^findadd '
      r'(?P<query>("?([Aa]lbum|[Aa]rtist|[Ff]ilename|[Tt]itle|[Aa]ny)"? '
      '"[^"]+"\s?)+)$')
-def findadd(frontend, query):
+def findadd(context, query):
     """
     *musicpd.org, music database section:*
 
@@ -84,11 +84,11 @@ def findadd(frontend, query):
         ``WHAT`` is what to find.
     """
     # TODO Add result to current playlist
-    #result = frontend.find(query)
+    #result = context.find(query)
 
 @handle_pattern(r'^list "?(?P<field>([Aa]rtist|[Aa]lbum|[Dd]ate|[Gg]enre))"?'
     '( (?P<mpd_query>.*))?$')
-def list_(frontend, field, mpd_query=None):
+def list_(context, field, mpd_query=None):
     """
     *musicpd.org, music database section:*
 
@@ -175,11 +175,11 @@ def list_(frontend, field, mpd_query=None):
     field = field.lower()
     query = _list_build_query(field, mpd_query)
     if field == u'artist':
-        return _list_artist(frontend, query)
+        return _list_artist(context, query)
     elif field == u'album':
-        return _list_album(frontend, query)
+        return _list_album(context, query)
     elif field == u'date':
-        return _list_date(frontend, query)
+        return _list_date(context, query)
     elif field == u'genre':
         pass # TODO We don't have genre in our internal data structures yet
 
@@ -213,32 +213,32 @@ def _list_build_query(field, mpd_query):
     else:
         raise MpdArgError(u'not able to parse args', command=u'list')
 
-def _list_artist(frontend, query):
+def _list_artist(context, query):
     artists = set()
-    playlist = frontend.backend.library.find_exact(**query).get()
+    playlist = context.backend.library.find_exact(**query).get()
     for track in playlist.tracks:
         for artist in track.artists:
             artists.add((u'Artist', artist.name))
     return artists
 
-def _list_album(frontend, query):
+def _list_album(context, query):
     albums = set()
-    playlist = frontend.backend.library.find_exact(**query).get()
+    playlist = context.backend.library.find_exact(**query).get()
     for track in playlist.tracks:
         if track.album is not None:
             albums.add((u'Album', track.album.name))
     return albums
 
-def _list_date(frontend, query):
+def _list_date(context, query):
     dates = set()
-    playlist = frontend.backend.library.find_exact(**query).get()
+    playlist = context.backend.library.find_exact(**query).get()
     for track in playlist.tracks:
         if track.date is not None:
             dates.add((u'Date', track.date.strftime('%Y-%m-%d')))
     return dates
 
 @handle_pattern(r'^listall "(?P<uri>[^"]+)"')
-def listall(frontend, uri):
+def listall(context, uri):
     """
     *musicpd.org, music database section:*
 
@@ -249,7 +249,7 @@ def listall(frontend, uri):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^listallinfo "(?P<uri>[^"]+)"')
-def listallinfo(frontend, uri):
+def listallinfo(context, uri):
     """
     *musicpd.org, music database section:*
 
@@ -262,7 +262,7 @@ def listallinfo(frontend, uri):
 
 @handle_pattern(r'^lsinfo$')
 @handle_pattern(r'^lsinfo "(?P<uri>[^"]*)"$')
-def lsinfo(frontend, uri=None):
+def lsinfo(context, uri=None):
     """
     *musicpd.org, music database section:*
 
@@ -279,11 +279,11 @@ def lsinfo(frontend, uri=None):
     ""``, and ``lsinfo "/"``.
     """
     if uri is None or uri == u'/' or uri == u'':
-        return stored_playlists.listplaylists(frontend)
+        return stored_playlists.listplaylists(context)
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^rescan( "(?P<uri>[^"]+)")*$')
-def rescan(frontend, uri=None):
+def rescan(context, uri=None):
     """
     *musicpd.org, music database section:*
 
@@ -291,12 +291,12 @@ def rescan(frontend, uri=None):
 
         Same as ``update``, but also rescans unmodified files.
     """
-    return update(frontend, uri, rescan_unmodified_files=True)
+    return update(context, uri, rescan_unmodified_files=True)
 
 @handle_pattern(r'^search '
      r'(?P<mpd_query>("?([Aa]lbum|[Aa]rtist|[Dd]ate|[Ff]ilename|'
      r'[Tt]itle|[Aa]ny)"? "[^"]+"\s?)+)$')
-def search(frontend, mpd_query):
+def search(context, mpd_query):
     """
     *musicpd.org, music database section:*
 
@@ -324,10 +324,10 @@ def search(frontend, mpd_query):
     - also uses the search type "date".
     """
     query = _build_query(mpd_query)
-    return frontend.backend.library.search(**query).get().mpd_format()
+    return context.backend.library.search(**query).get().mpd_format()
 
 @handle_pattern(r'^update( "(?P<uri>[^"]+)")*$')
-def update(frontend, uri=None, rescan_unmodified_files=False):
+def update(context, uri=None, rescan_unmodified_files=False):
     """
     *musicpd.org, music database section:*
 

mopidy/frontends/mpd/protocol/playback.py

@@ -5,7 +5,7 @@ from mopidy.frontends.mpd.exceptions import (MpdArgError, MpdNoExistError,
 
 @handle_pattern(r'^consume (?P<state>[01])$')
 @handle_pattern(r'^consume "(?P<state>[01])"$')
-def consume(frontend, state):
+def consume(context, state):
     """
     *musicpd.org, playback section:*
 
@@ -16,12 +16,12 @@ def consume(frontend, state):
         playlist.
     """
     if int(state):
-        frontend.backend.playback.consume = True
+        context.backend.playback.consume = True
     else:
-        frontend.backend.playback.consume = False
+        context.backend.playback.consume = False
 
 @handle_pattern(r'^crossfade "(?P<seconds>\d+)"$')
-def crossfade(frontend, seconds):
+def crossfade(context, seconds):
     """
     *musicpd.org, playback section:*
 
@@ -33,7 +33,7 @@ def crossfade(frontend, seconds):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^next$')
-def next_(frontend):
+def next_(context):
     """
     *musicpd.org, playback section:*
 
@@ -87,11 +87,11 @@ def next_(frontend):
           order as the first time.
 
     """
-    return frontend.backend.playback.next().get()
+    return context.backend.playback.next().get()
 
 @handle_pattern(r'^pause$')
 @handle_pattern(r'^pause "(?P<state>[01])"$')
-def pause(frontend, state=None):
+def pause(context, state=None):
     """
     *musicpd.org, playback section:*
 
@@ -104,28 +104,28 @@ def pause(frontend, state=None):
     - Calls ``pause`` without any arguments to toogle pause.
     """
     if state is None:
-        if (frontend.backend.playback.state.get() ==
+        if (context.backend.playback.state.get() ==
                 PlaybackController.PLAYING):
-            frontend.backend.playback.pause()
+            context.backend.playback.pause()
-        elif (frontend.backend.playback.state.get() ==
+        elif (context.backend.playback.state.get() ==
                 PlaybackController.PAUSED):
-            frontend.backend.playback.resume()
+            context.backend.playback.resume()
     elif int(state):
-        frontend.backend.playback.pause()
+        context.backend.playback.pause()
     else:
-        frontend.backend.playback.resume()
+        context.backend.playback.resume()
 
 @handle_pattern(r'^play$')
-def play(frontend):
+def play(context):
     """
     The original MPD server resumes from the paused state on ``play``
     without arguments.
     """
-    return frontend.backend.playback.play().get()
+    return context.backend.playback.play().get()
 
 @handle_pattern(r'^playid "(?P<cpid>\d+)"$')
 @handle_pattern(r'^playid "(?P<cpid>-1)"$')
-def playid(frontend, cpid):
+def playid(context, cpid):
     """
     *musicpd.org, playback section:*
 
@@ -144,16 +144,16 @@ def playid(frontend, cpid):
     """
     cpid = int(cpid)
     if cpid == -1:
-        return _play_minus_one(frontend)
+        return _play_minus_one(context)
     try:
-        cp_track = frontend.backend.current_playlist.get(cpid=cpid).get()
+        cp_track = context.backend.current_playlist.get(cpid=cpid).get()
-        return frontend.backend.playback.play(cp_track).get()
+        return context.backend.playback.play(cp_track).get()
     except LookupError:
         raise MpdNoExistError(u'No such song', command=u'playid')
 
 @handle_pattern(r'^play (?P<songpos>-?\d+)$')
 @handle_pattern(r'^play "(?P<songpos>-?\d+)"$')
-def playpos(frontend, songpos):
+def playpos(context, songpos):
     """
     *musicpd.org, playback section:*
 
@@ -176,29 +176,29 @@ def playpos(frontend, songpos):
     """
     songpos = int(songpos)
     if songpos == -1:
-        return _play_minus_one(frontend)
+        return _play_minus_one(context)
     try:
-        cp_track = frontend.backend.current_playlist.cp_tracks.get()[songpos]
+        cp_track = context.backend.current_playlist.cp_tracks.get()[songpos]
-        return frontend.backend.playback.play(cp_track).get()
+        return context.backend.playback.play(cp_track).get()
     except IndexError:
         raise MpdArgError(u'Bad song index', command=u'play')
 
-def _play_minus_one(frontend):
+def _play_minus_one(context):
-    if (frontend.backend.playback.state.get() == PlaybackController.PLAYING):
+    if (context.backend.playback.state.get() == PlaybackController.PLAYING):
         return # Nothing to do
-    elif (frontend.backend.playback.state.get() == PlaybackController.PAUSED):
+    elif (context.backend.playback.state.get() == PlaybackController.PAUSED):
-        return frontend.backend.playback.resume().get()
+        return context.backend.playback.resume().get()
-    elif frontend.backend.playback.current_cp_track.get() is not None:
+    elif context.backend.playback.current_cp_track.get() is not None:
-        cp_track = frontend.backend.playback.current_cp_track.get()
+        cp_track = context.backend.playback.current_cp_track.get()
-        return frontend.backend.playback.play(cp_track).get()
+        return context.backend.playback.play(cp_track).get()
-    elif frontend.backend.current_playlist.cp_tracks.get():
+    elif context.backend.current_playlist.cp_tracks.get():
-        cp_track = frontend.backend.current_playlist.cp_tracks.get()[0]
+        cp_track = context.backend.current_playlist.cp_tracks.get()[0]
-        return frontend.backend.playback.play(cp_track).get()
+        return context.backend.playback.play(cp_track).get()
     else:
         return # Fail silently
 
 @handle_pattern(r'^previous$')
-def previous(frontend):
+def previous(context):
     """
     *musicpd.org, playback section:*
 
@@ -241,11 +241,11 @@ def previous(frontend):
           ``previous`` should do a seek to time position 0.
 
     """
-    return frontend.backend.playback.previous().get()
+    return context.backend.playback.previous().get()
 
 @handle_pattern(r'^random (?P<state>[01])$')
 @handle_pattern(r'^random "(?P<state>[01])"$')
-def random(frontend, state):
+def random(context, state):
     """
     *musicpd.org, playback section:*
 
@@ -254,13 +254,13 @@ def random(frontend, state):
         Sets random state to ``STATE``, ``STATE`` should be 0 or 1.
     """
     if int(state):
-        frontend.backend.playback.random = True
+        context.backend.playback.random = True
     else:
-        frontend.backend.playback.random = False
+        context.backend.playback.random = False
 
 @handle_pattern(r'^repeat (?P<state>[01])$')
 @handle_pattern(r'^repeat "(?P<state>[01])"$')
-def repeat(frontend, state):
+def repeat(context, state):
     """
     *musicpd.org, playback section:*
 
@@ -269,12 +269,12 @@ def repeat(frontend, state):
         Sets repeat state to ``STATE``, ``STATE`` should be 0 or 1.
     """
     if int(state):
-        frontend.backend.playback.repeat = True
+        context.backend.playback.repeat = True
     else:
-        frontend.backend.playback.repeat = False
+        context.backend.playback.repeat = False
 
 @handle_pattern(r'^replay_gain_mode "(?P<mode>(off|track|album))"$')
-def replay_gain_mode(frontend, mode):
+def replay_gain_mode(context, mode):
     """
     *musicpd.org, playback section:*
 
@@ -290,7 +290,7 @@ def replay_gain_mode(frontend, mode):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^replay_gain_status$')
-def replay_gain_status(frontend):
+def replay_gain_status(context):
     """
     *musicpd.org, playback section:*
 
@@ -303,7 +303,7 @@ def replay_gain_status(frontend):
 
 @handle_pattern(r'^seek (?P<songpos>\d+) (?P<seconds>\d+)$')
 @handle_pattern(r'^seek "(?P<songpos>\d+)" "(?P<seconds>\d+)"$')
-def seek(frontend, songpos, seconds):
+def seek(context, songpos, seconds):
     """
     *musicpd.org, playback section:*
 
@@ -316,12 +316,12 @@ def seek(frontend, songpos, seconds):
 
     - issues ``seek 1 120`` without quotes around the arguments.
     """
-    if frontend.backend.playback.current_playlist_position != songpos:
+    if context.backend.playback.current_playlist_position != songpos:
-        playpos(frontend, songpos)
+        playpos(context, songpos)
-    frontend.backend.playback.seek(int(seconds) * 1000)
+    context.backend.playback.seek(int(seconds) * 1000)
 
 @handle_pattern(r'^seekid "(?P<cpid>\d+)" "(?P<seconds>\d+)"$')
-def seekid(frontend, cpid, seconds):
+def seekid(context, cpid, seconds):
     """
     *musicpd.org, playback section:*
 
@@ -329,13 +329,13 @@ def seekid(frontend, cpid, seconds):
 
         Seeks to the position ``TIME`` (in seconds) of song ``SONGID``.
     """
-    if frontend.backend.playback.current_cpid != cpid:
+    if context.backend.playback.current_cpid != cpid:
-        playid(frontend, cpid)
+        playid(context, cpid)
-    frontend.backend.playback.seek(int(seconds) * 1000)
+    context.backend.playback.seek(int(seconds) * 1000)
 
 @handle_pattern(r'^setvol (?P<volume>[-+]*\d+)$')
 @handle_pattern(r'^setvol "(?P<volume>[-+]*\d+)"$')
-def setvol(frontend, volume):
+def setvol(context, volume):
     """
     *musicpd.org, playback section:*
 
@@ -352,11 +352,11 @@ def setvol(frontend, volume):
         volume = 0
     if volume > 100:
         volume = 100
-    frontend.mixer.volume = volume
+    context.mixer.volume = volume
 
 @handle_pattern(r'^single (?P<state>[01])$')
 @handle_pattern(r'^single "(?P<state>[01])"$')
-def single(frontend, state):
+def single(context, state):
     """
     *musicpd.org, playback section:*
 
@@ -367,12 +367,12 @@ def single(frontend, state):
         song is repeated if the ``repeat`` mode is enabled.
     """
     if int(state):
-        frontend.backend.playback.single = True
+        context.backend.playback.single = True
     else:
-        frontend.backend.playback.single = False
+        context.backend.playback.single = False
 
 @handle_pattern(r'^stop$')
-def stop(frontend):
+def stop(context):
     """
     *musicpd.org, playback section:*
 
@@ -380,4 +380,4 @@ def stop(frontend):
 
         Stops playing.
     """
-    frontend.backend.playback.stop()
+    context.backend.playback.stop()

mopidy/frontends/mpd/protocol/reflection.py

@@ -2,7 +2,7 @@ from mopidy.frontends.mpd.protocol import handle_pattern, mpd_commands
 from mopidy.frontends.mpd.exceptions import MpdNotImplemented
 
 @handle_pattern(r'^commands$')
-def commands(frontend):
+def commands(context):
     """
     *musicpd.org, reflection section:*
 
@@ -28,7 +28,7 @@ def commands(frontend):
     return [('command', c) for c in sorted_commands]
 
 @handle_pattern(r'^decoders$')
-def decoders(frontend):
+def decoders(context):
     """
     *musicpd.org, reflection section:*
 
@@ -47,7 +47,7 @@ def decoders(frontend):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^notcommands$')
-def notcommands(frontend):
+def notcommands(context):
     """
     *musicpd.org, reflection section:*
 
@@ -62,7 +62,7 @@ def notcommands(frontend):
     pass
 
 @handle_pattern(r'^tagtypes$')
-def tagtypes(frontend):
+def tagtypes(context):
     """
     *musicpd.org, reflection section:*
 
@@ -73,7 +73,7 @@ def tagtypes(frontend):
     pass # TODO
 
 @handle_pattern(r'^urlhandlers$')
-def urlhandlers(frontend):
+def urlhandlers(context):
     """
     *musicpd.org, reflection section:*
 
@@ -81,4 +81,4 @@ def urlhandlers(frontend):
 
         Gets a list of available URL handlers.
     """
-    return [(u'handler', uri) for uri in frontend.backend.uri_handlers.get()]
+    return [(u'handler', uri) for uri in context.backend.uri_handlers.get()]

mopidy/frontends/mpd/protocol/status.py

@@ -3,7 +3,7 @@ from mopidy.frontends.mpd.protocol import handle_pattern
 from mopidy.frontends.mpd.exceptions import MpdNotImplemented
 
 @handle_pattern(r'^clearerror$')
-def clearerror(frontend):
+def clearerror(context):
     """
     *musicpd.org, status section:*
 
@@ -15,7 +15,7 @@ def clearerror(frontend):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^currentsong$')
-def currentsong(frontend):
+def currentsong(context):
     """
     *musicpd.org, status section:*
 
@@ -24,15 +24,15 @@ def currentsong(frontend):
         Displays the song info of the current song (same song that is
         identified in status).
     """
-    current_cp_track = frontend.backend.playback.current_cp_track.get()
+    current_cp_track = context.backend.playback.current_cp_track.get()
     if current_cp_track is not None:
         return current_cp_track[1].mpd_format(
-            position=frontend.backend.playback.current_playlist_position.get(),
+            position=context.backend.playback.current_playlist_position.get(),
             cpid=current_cp_track[0])
 
 @handle_pattern(r'^idle$')
 @handle_pattern(r'^idle (?P<subsystems>.+)$')
-def idle(frontend, subsystems=None):
+def idle(context, subsystems=None):
     """
     *musicpd.org, status section:*
 
@@ -68,12 +68,12 @@ def idle(frontend, subsystems=None):
     pass # TODO
 
 @handle_pattern(r'^noidle$')
-def noidle(frontend):
+def noidle(context):
     """See :meth:`_status_idle`."""
     pass # TODO
 
 @handle_pattern(r'^stats$')
-def stats(frontend):
+def stats(context):
     """
     *musicpd.org, status section:*
 
@@ -99,7 +99,7 @@ def stats(frontend):
     }
 
 @handle_pattern(r'^status$')
-def status(frontend):
+def status(context):
     """
     *musicpd.org, status section:*
 
@@ -131,64 +131,64 @@ def status(frontend):
         - ``error``: if there is an error, returns message here
     """
     result = [
-        ('volume', _status_volume(frontend)),
+        ('volume', _status_volume(context)),
-        ('repeat', _status_repeat(frontend)),
+        ('repeat', _status_repeat(context)),
-        ('random', _status_random(frontend)),
+        ('random', _status_random(context)),
-        ('single', _status_single(frontend)),
+        ('single', _status_single(context)),
-        ('consume', _status_consume(frontend)),
+        ('consume', _status_consume(context)),
-        ('playlist', _status_playlist_version(frontend)),
+        ('playlist', _status_playlist_version(context)),
-        ('playlistlength', _status_playlist_length(frontend)),
+        ('playlistlength', _status_playlist_length(context)),
-        ('xfade', _status_xfade(frontend)),
+        ('xfade', _status_xfade(context)),
-        ('state', _status_state(frontend)),
+        ('state', _status_state(context)),
     ]
-    if frontend.backend.playback.current_track.get() is not None:
+    if context.backend.playback.current_track.get() is not None:
-        result.append(('song', _status_songpos(frontend)))
+        result.append(('song', _status_songpos(context)))
-        result.append(('songid', _status_songid(frontend)))
+        result.append(('songid', _status_songid(context)))
-    if frontend.backend.playback.state.get() in (PlaybackController.PLAYING,
+    if context.backend.playback.state.get() in (PlaybackController.PLAYING,
             PlaybackController.PAUSED):
-        result.append(('time', _status_time(frontend)))
+        result.append(('time', _status_time(context)))
-        result.append(('elapsed', _status_time_elapsed(frontend)))
+        result.append(('elapsed', _status_time_elapsed(context)))
-        result.append(('bitrate', _status_bitrate(frontend)))
+        result.append(('bitrate', _status_bitrate(context)))
     return result
 
-def _status_bitrate(frontend):
+def _status_bitrate(context):
-    current_track = frontend.backend.playback.current_track.get()
+    current_track = context.backend.playback.current_track.get()
     if current_track is not None:
         return current_track.bitrate
 
-def _status_consume(frontend):
+def _status_consume(context):
-    if frontend.backend.playback.consume.get():
+    if context.backend.playback.consume.get():
         return 1
     else:
         return 0
 
-def _status_playlist_length(frontend):
+def _status_playlist_length(context):
-    return len(frontend.backend.current_playlist.tracks.get())
+    return len(context.backend.current_playlist.tracks.get())
 
-def _status_playlist_version(frontend):
+def _status_playlist_version(context):
-    return frontend.backend.current_playlist.version.get()
+    return context.backend.current_playlist.version.get()
 
-def _status_random(frontend):
+def _status_random(context):
-    return int(frontend.backend.playback.random.get())
+    return int(context.backend.playback.random.get())
 
-def _status_repeat(frontend):
+def _status_repeat(context):
-    return int(frontend.backend.playback.repeat.get())
+    return int(context.backend.playback.repeat.get())
 
-def _status_single(frontend):
+def _status_single(context):
-    return int(frontend.backend.playback.single.get())
+    return int(context.backend.playback.single.get())
 
-def _status_songid(frontend):
+def _status_songid(context):
-    current_cpid = frontend.backend.playback.current_cpid.get()
+    current_cpid = context.backend.playback.current_cpid.get()
     if current_cpid is not None:
         return current_cpid
     else:
-        return _status_songpos(frontend)
+        return _status_songpos(context)
 
-def _status_songpos(frontend):
+def _status_songpos(context):
-    return frontend.backend.playback.current_playlist_position.get()
+    return context.backend.playback.current_playlist_position.get()
 
-def _status_state(frontend):
+def _status_state(context):
-    state = frontend.backend.playback.state.get()
+    state = context.backend.playback.state.get()
     if state == PlaybackController.PLAYING:
         return u'play'
     elif state == PlaybackController.STOPPED:
@@ -196,15 +196,15 @@ def _status_state(frontend):
     elif state == PlaybackController.PAUSED:
         return u'pause'
 
-def _status_time(frontend):
+def _status_time(context):
-    return u'%s:%s' % (_status_time_elapsed(frontend) // 1000,
+    return u'%s:%s' % (_status_time_elapsed(context) // 1000,
-        _status_time_total(frontend) // 1000)
+        _status_time_total(context) // 1000)
 
-def _status_time_elapsed(frontend):
+def _status_time_elapsed(context):
-    return frontend.backend.playback.time_position.get()
+    return context.backend.playback.time_position.get()
 
-def _status_time_total(frontend):
+def _status_time_total(context):
-    current_track = frontend.backend.playback.current_track.get()
+    current_track = context.backend.playback.current_track.get()
     if current_track is None:
         return 0
     elif current_track.length is None:
@@ -212,12 +212,12 @@ def _status_time_total(frontend):
     else:
         return current_track.length
 
-def _status_volume(frontend):
+def _status_volume(context):
-    volume = frontend.mixer.volume.get()
+    volume = context.mixer.volume.get()
     if volume is not None:
         return volume
     else:
         return 0
 
-def _status_xfade(frontend):
+def _status_xfade(context):
     return 0 # TODO

mopidy/frontends/mpd/protocol/stickers.py

@@ -3,7 +3,7 @@ from mopidy.frontends.mpd.exceptions import MpdNotImplemented
 
 @handle_pattern(r'^sticker delete "(?P<field>[^"]+)" '
     r'"(?P<uri>[^"]+)"( "(?P<name>[^"]+)")*$')
-def sticker_delete(frontend, field, uri, name=None):
+def sticker_delete(context, field, uri, name=None):
     """
     *musicpd.org, sticker section:*
 
@@ -16,7 +16,7 @@ def sticker_delete(frontend, field, uri, name=None):
 
 @handle_pattern(r'^sticker find "(?P<field>[^"]+)" "(?P<uri>[^"]+)" '
     r'"(?P<name>[^"]+)"$')
-def sticker_find(frontend, field, uri, name):
+def sticker_find(context, field, uri, name):
     """
     *musicpd.org, sticker section:*
 
@@ -30,7 +30,7 @@ def sticker_find(frontend, field, uri, name):
 
 @handle_pattern(r'^sticker get "(?P<field>[^"]+)" "(?P<uri>[^"]+)" '
     r'"(?P<name>[^"]+)"$')
-def sticker_get(frontend, field, uri, name):
+def sticker_get(context, field, uri, name):
     """
     *musicpd.org, sticker section:*
 
@@ -41,7 +41,7 @@ def sticker_get(frontend, field, uri, name):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^sticker list "(?P<field>[^"]+)" "(?P<uri>[^"]+)"$')
-def sticker_list(frontend, field, uri):
+def sticker_list(context, field, uri):
     """
     *musicpd.org, sticker section:*
 
@@ -53,7 +53,7 @@ def sticker_list(frontend, field, uri):
 
 @handle_pattern(r'^sticker set "(?P<field>[^"]+)" "(?P<uri>[^"]+)" '
     r'"(?P<name>[^"]+)" "(?P<value>[^"]+)"$')
-def sticker_set(frontend, field, uri, name, value):
+def sticker_set(context, field, uri, name, value):
     """
     *musicpd.org, sticker section:*
 

mopidy/frontends/mpd/protocol/stored_playlists.py

@@ -4,7 +4,7 @@ from mopidy.frontends.mpd.protocol import handle_pattern
 from mopidy.frontends.mpd.exceptions import MpdNoExistError, MpdNotImplemented
 
 @handle_pattern(r'^listplaylist "(?P<name>[^"]+)"$')
-def listplaylist(frontend, name):
+def listplaylist(context, name):
     """
     *musicpd.org, stored playlists section:*
 
@@ -19,13 +19,13 @@ def listplaylist(frontend, name):
         file: relative/path/to/file3.mp3
     """
     try:
-        playlist = frontend.backend.stored_playlists.get(name=name).get()
+        playlist = context.backend.stored_playlists.get(name=name).get()
         return ['file: %s' % t.uri for t in playlist.tracks]
     except LookupError:
         raise MpdNoExistError(u'No such playlist', command=u'listplaylist')
 
 @handle_pattern(r'^listplaylistinfo "(?P<name>[^"]+)"$')
-def listplaylistinfo(frontend, name):
+def listplaylistinfo(context, name):
     """
     *musicpd.org, stored playlists section:*
 
@@ -39,14 +39,14 @@ def listplaylistinfo(frontend, name):
         Album, Artist, Track
     """
     try:
-        playlist = frontend.backend.stored_playlists.get(name=name).get()
+        playlist = context.backend.stored_playlists.get(name=name).get()
         return playlist.mpd_format()
     except LookupError:
         raise MpdNoExistError(
             u'No such playlist', command=u'listplaylistinfo')
 
 @handle_pattern(r'^listplaylists$')
-def listplaylists(frontend):
+def listplaylists(context):
     """
     *musicpd.org, stored playlists section:*
 
@@ -67,7 +67,7 @@ def listplaylists(frontend):
         Last-Modified: 2010-02-06T02:11:08Z
     """
     result = []
-    for playlist in frontend.backend.stored_playlists.playlists.get():
+    for playlist in context.backend.stored_playlists.playlists.get():
         result.append((u'playlist', playlist.name))
         last_modified = (playlist.last_modified or
             dt.datetime.now()).isoformat()
@@ -80,7 +80,7 @@ def listplaylists(frontend):
     return result
 
 @handle_pattern(r'^load "(?P<name>[^"]+)"$')
-def load(frontend, name):
+def load(context, name):
     """
     *musicpd.org, stored playlists section:*
 
@@ -93,13 +93,13 @@ def load(frontend, name):
     - ``load`` appends the given playlist to the current playlist.
     """
     try:
-        playlist = frontend.backend.stored_playlists.get(name=name).get()
+        playlist = context.backend.stored_playlists.get(name=name).get()
-        frontend.backend.current_playlist.append(playlist.tracks)
+        context.backend.current_playlist.append(playlist.tracks)
     except LookupError:
         raise MpdNoExistError(u'No such playlist', command=u'load')
 
 @handle_pattern(r'^playlistadd "(?P<name>[^"]+)" "(?P<uri>[^"]+)"$')
-def playlistadd(frontend, name, uri):
+def playlistadd(context, name, uri):
     """
     *musicpd.org, stored playlists section:*
 
@@ -112,7 +112,7 @@ def playlistadd(frontend, name, uri):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^playlistclear "(?P<name>[^"]+)"$')
-def playlistclear(frontend, name):
+def playlistclear(context, name):
     """
     *musicpd.org, stored playlists section:*
 
@@ -123,7 +123,7 @@ def playlistclear(frontend, name):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^playlistdelete "(?P<name>[^"]+)" "(?P<songpos>\d+)"$')
-def playlistdelete(frontend, name, songpos):
+def playlistdelete(context, name, songpos):
     """
     *musicpd.org, stored playlists section:*
 
@@ -135,7 +135,7 @@ def playlistdelete(frontend, name, songpos):
 
 @handle_pattern(r'^playlistmove "(?P<name>[^"]+)" '
     r'"(?P<from_pos>\d+)" "(?P<to_pos>\d+)"$')
-def playlistmove(frontend, name, from_pos, to_pos):
+def playlistmove(context, name, from_pos, to_pos):
     """
     *musicpd.org, stored playlists section:*
 
@@ -153,7 +153,7 @@ def playlistmove(frontend, name, from_pos, to_pos):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^rename "(?P<old_name>[^"]+)" "(?P<new_name>[^"]+)"$')
-def rename(frontend, old_name, new_name):
+def rename(context, old_name, new_name):
     """
     *musicpd.org, stored playlists section:*
 
@@ -164,7 +164,7 @@ def rename(frontend, old_name, new_name):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^rm "(?P<name>[^"]+)"$')
-def rm(frontend, name):
+def rm(context, name):
     """
     *musicpd.org, stored playlists section:*
 
@@ -175,7 +175,7 @@ def rm(frontend, name):
     raise MpdNotImplemented # TODO
 
 @handle_pattern(r'^save "(?P<name>[^"]+)"$')
-def save(frontend, name):
+def save(context, name):
     """
     *musicpd.org, stored playlists section:*