@@ -1,53 +1,103 @@

 from __future__ import print_function

-import collections

+import itertools

 from twisted.internet import defer

 from twisted.internet import protocol

 from twisted.internet import reactor

+from twisted.internet import task

 from twisted.protocols import basic

 from responsedict import ResponseDict

+import os

+import sys

+def get_client(host='', port=6600):

+    '''returns a deferred'''

+    if host is '':

+        host = os.getenv('MPD_HOST', 'localhost')

+        #print("Using default config: %(host)s:%(port)s" % dict(host=host, port=port), file=sys.stderr)

+    ccreator = protocol.ClientCreator(reactor, MPDProtocol)

+    return ccreator.connectTCP(host, port)

+

+

 class MPDProtocol(basic.LineReceiver):

     delimiter = '\x0a'

     def __init__(self, *a, **kw):

         #basic.LineReceiver.__init__(self, *a, **kw)

         self.commands = []

+        self.notifications = []

         self.serverinfo=None

+        #self.lineReceived = self.noidlereceive

+        self.listeners = {}

+        self._idle = False

     def fallback(self, data):

         print(data.as_list())

-    def lineReceived(self, line):

+    def check_servername(self, line):

         if self.serverinfo is None and line.startswith('OK'):

             self.serverinfo = line.split()

+            return True

+    set_servname = check_servername

+

+    def lineReceived(self, line):

+        if self.check_servername(line): pass

         else:

+            #print('line received:', repr(line))

             if line.strip() == 'OK':

+                self.reset_idle()

                 method, deferred, data = self.commands.pop(0)

                 d = reactor.callLater(0, deferred.callback, (method, data))

+                for listener in self.listeners.get(method,[]):

+                    listener.notify(self, line)

             else:

                 self.commands[0][2].add_line(line.rstrip())

-    def sendCommand(self, command):

-        self.commands.append((command, defer.Deferred(), ResponseDict()))

+    def add_listener(self, listener, command):

+        self.listeners.setdefault(command, []).append(listener)

+        return listener

+

+    def reset_idle(self): self._idle = False

+    def idle(self, subsystems=None, listener=None):

+        if subsystems is None:subsystems = []

+        result = self.sendCommand('idle', *subsystems)

+        self._idle = True

+        if listener is not None:

+            self.add_listener(listener, 'idle')

+        return result

+

+    def sendCommand(self, command, *args):

+        result = None

+        if self._idle and command not in {'idle', 'noidle'}:

+            if self.commands[0][0] == 'idle': self.commands.pop(0)

+            self.sendCommand('noidle')

+        if args:

+            command = ' '.join(itertools.chain([command], args))

         self.transport.write('%s\n' % command)

-        return self.commands[-1][1]

+        self.commands.append((command, defer.Deferred(), ResponseDict()))

+        result = self.commands[-1][1]

+        return result

-def handle(result, mpdClient):

-    method,data = result

-    print(data.as_list())

-    return reactor.callLater(0, run, mpdClient)

+import pprint

+import traceback, inspect

+@defer.inlineCallbacks

 def run(mpdClient):

-    mpdClient.sendCommand(raw_input('command? ')).addCallback(handle, mpdClient),

+    #NOTE: remember, idleHandler not used!

+    method, result = yield mpdClient.idle(['playlist'])

+    print(method, result)

+    method, result = yield mpdClient.sendCommand('playlistinfo')

+    print(result.as_list())

+    import time

+    time.sleep(1)

+    run(mpdClient)

 def fail(*a, **kw):

     print(*a, **kw)

 if __name__ == '__main__':

-    ccreator = protocol.ClientCreator(reactor, MPDProtocol)

-    ccreator.connectTCP('localhost', 6600).addCallback(run).addErrback(fail)

+    get_client().addCallbacks(run,fail)

     reactor.run()

@@ -19,9 +19,10 @@ class ResponseDict(collections.Mapping):

     def add_line(self, line):

         k,_,v = line.strip().partition(':')

-        if k in self.data[-1]: self.data.append({})

-        self.data[-1][k] = v.strip()

-        return (k,self.data[-1][k])

+        if k in self.data[-1] and k.lower() == 'file':

+            self.data.append({})

+        self.data[-1].setdefault(k, []).append(v.strip())

+        return (k,self.data[-1][k][-1])

     def __getitem__(self,it):

         return self.data[-1][it]

@@ -33,7 +34,12 @@ class ResponseDict(collections.Mapping):

         return len(self.data[-1])

     def as_list(self):

-        return self.data

+        out = []

+        for datum in self.data:

+            out.append({})

+            for k in datum:

+                out[-1].setdefault(k,[]).extend(item for item in datum[k])

+        return out

     def as_table(self):

         keys = set()

@@ -42,7 +48,7 @@ class ResponseDict(collections.Mapping):

             keys.update(dct)

         for dct in self.data:

             for key in keys:

-                out.setdefault(key, []).append(dct.get(key,''))

+                out.setdefault(key, []).append(dct.get(key,['']))

         return out

new file mode 100644

@@ -0,0 +1,43 @@

+<html>

+<head>

+  <title>{{ title }}</title>

+  <STYLE type="text/css">

+  .album {

+    max-width: 15em;

+  }

+  .artist {

+    max-width: 20em;

+  }

+  .title {

+    max-width: 25em;

+  }

+  .genre {

+    max-width: 5em;

+  }

+

+  li > span {

+    display: table-cell;

+    vertical-align: middle;

+  }

+  tr:nth-child(even){

+    background: hsl(120,30%,90%);

+  }

+  table {

+    border-collapse: collapse;

+  }

+  tr + tr {

+    border-top: solid thin grey;

+

+  }

+  </STYLE>

+</head>

+<body>

+  <table class="playlist">

+    {% for item in playlist %}

+      <tr>{% for (class,texts) in item %}

+        {% for text in texts %}<td class="{{class}}">{{text.decode('utf-8')}}</td>{%endfor%}

+      {%endfor%}</tr>

+    {% endfor %}

+  </table>

+</body>

+</html>

new file mode 100644

@@ -0,0 +1,67 @@

+import mpdprotocol

+import responsedict

+import urwid

+import itertools

+from twisted.internet import defer

+

+class SelectableText(urwid.Text):

+    def keypress(self, __, key): return key

+    def selectable(self): return True

+

+class Playlist(urwid.WidgetWrap):

+    def __init__(self, columns, plylst):

+        self.playlist = plylst

+        self.columns = columns

+        self.texts = self.get_texts(self.playlist.as_table(), cols)

+

+        self.titles = urwid.Columns([('weight',w,SelectableText(c)) for w,c,_ in cols],1)

+        self.header = urwid.Pile([self.titles, urwid.Divider('-')])

+        widget = self.make_playlist()

+        widget = urwid.Frame(widget, self.header)

+        urwid.WidgetWrap.__init__(self, widget)

+

+    def get_texts(self, choices, columns):

+        texts = []

+        for weight,col,transform in columns:

+            texts.append([(weight,transform(x[0])) for x in choices.get(col)])

+        return texts

+

+    def make_playlist(self):

+        body = []

+        for x in itertools.izip_longest(*self.texts):

+            new_widg = [('weight',wgt,SelectableText(it,wrap='clip')) for wgt,it in x]

+            new_widg = urwid.Columns(new_widg, 1)

+            new_widg = urwid.AttrMap(new_widg, 'unselected', 'selected')

+            body.append(new_widg)

+        list_walker = urwid.SimpleFocusListWalker(body)

+        return urwid.ListBox(urwid.SimpleFocusListWalker(body[:]))

+

+def exit_on_q(key):

+    if key in ('q', 'Q'):

+        try: raise urwid.ExitMainLoop()

+        finally: reactor.stop()

+

+cols = [

+    (1,'Pos', lambda x: str(int(x)+1)),

+    (4,'Album', lambda x:x),

+    (3,'Artist', lambda x:x),

+    (5,'Title', lambda x:x)

+]

+

+@defer.inlineCallbacks

+def get_playlist():

+    client = yield mpdprotocol.get_client()

+    res = yield client.sendCommand('playlistinfo')

+    method, data = res

+    loop.widget = Playlist(cols, data)

+    loop.draw_screen()

+

+from twisted.internet import reactor

+palette = [

+    ('selected', 'white', 'black'),

+    ('selected', 'black', 'white'),

+]

+loop = urwid.MainLoop(urwid.SolidFill(), palette, event_loop=urwid.TwistedEventLoop(), unhandled_input=exit_on_q)

+reactor.callWhenRunning(get_playlist)

+loop.run()

+

new file mode 100644

@@ -0,0 +1,65 @@

+# -*- coding: utf-8 -*-

+from twisted.web import server, resource 

+from twisted.internet import reactor

+from twisted.internet import task

+

+import mpdprotocol

+import jinja2

+import json

+

+class MPDResource(resource.Resource):

+    isLeaf = True

+    jinja2env = jinja2.Environment(loader=jinja2.FileSystemLoader('templates'))

+

+    def do(self, mpc, request):

+        d = mpc.sendCommand('playlistinfo')

+

+        cb = self.render_playlist

+        if 'json' in request.args:

+            if 'table' in request.args:

+                cb = self.render_as_table_json

+            else:

+                cb = self.render_as_json

+        d.addCallback(cb, request)

+        return d

+

+    def render_as_table_json(self, result, request):

+        method, data = result

+        request.setHeader('Content-Type', 'application/json')

+        request.write(json.dumps(data.as_table()));

+        request.finish()

+

+    def render_as_json(self, result, request):

+        method, data = result

+        request.setHeader('Content-Type', 'application/json')

+        request.write(json.dumps(data.as_list()));

+        request.finish()

+

+    def render_playlist(self, result, request):

+        print('rendering playlist!')

+        method, data = result

+        template = self.jinja2env.get_template('playlist.html')

+        tdata = []

+        for datum in data.as_list():

+            tdata.append([])

+            tdata[-1].append(('pos', datum['Pos']))

+            tdata[-1].append(('title', datum['Title']))

+            tdata[-1].append(('artist', datum['Artist']))

+            tdata[-1].append(('album', datum['Album']))

+            tdata[-1].append(('genre', datum['Genre']))

+        request.write(template.render(playlist=tdata).encode('utf-8'))

+        request.finish()

+

+    def failed(self, failure, request):

+       print "whjat should I do here?"

+       print self, failure, request 

+       failure.printTraceback()

+       failure.raiseException()

+

+    def render_GET(self, request):

+        print('ello world!')

+        d = mpdprotocol.get_client().addCallback(self.do, request)

+        d.addErrback(self.failed, request)

+        return server.NOT_DONE_YET

+

+resource = MPDResource()