new file mode 100644

@@ -0,0 +1,11 @@

+#!/usr/bin/env python

+

+from flask import Flask

+app = Flask(__name__)

+

+@app.route('/')

+def main():

+    return 'Coming Soone!'

+

+if __name__ == '__main__':

+    app.run()

new file mode 100644

@@ -0,0 +1,25 @@

+from __future__ import print_function

+from twisted.internet.protocol import Protocol, ClientFactory

+import sys

+

+class WelcomeMessage(Protocol):

+    def dataReceived(self, data):

+        sys.stdout.write(data)

+    def connectionMade(self):

+        self.transport.write('Hello server, I am the client!\n')

+

+class WelcomeMessageFactory(ClientFactory):

+    def startedConnecting(self, connector):

+        print('Started to connect.')

+    def buildProtocol(self, addr):

+        print('Connected.')

+        return WelcomeMessage()

+    def clientConnectionLost(self, connector, reason):

+        print('Lost connection. Reason:', reason)

+    def clientConnectionFailed(self, connector, reason):

+        print('Connection failed. Reason:', reason)

+

+

+from twisted.internet import reactor

+d = reactor.connectTCP("localhost", 8007, WelcomeMessageFactory())

+reactor.run()

@@ -12,32 +12,54 @@ class SelectableText(urwid.Text):

     def selectable(self): return True

 class Playlist(urwid.WidgetWrap):

-    def __init__(self, columns, plylst):

-        self.playlist = plylst

+    def __init__(self, columns, col_display, plylst=None):

+        if plylst == None:

+            plylst = responsedict.ResponseDict()

         self.columns = columns

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

+        self.display_pref = col_display

+        self.texts = self.get_texts(plylst.as_list())

+        self.body = urwid.SimpleFocusListWalker([])

+        self.make_playlist()

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

+        self.titles = self.make_columns()

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

-        widget = self.make_playlist()

+        widget = urwid.ListBox(self.body)

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

         urwid.WidgetWrap.__init__(self, widget)

-    def get_texts(self, choices, columns):

+    def make_columns(self):

+        return urwid.Columns([

+                ('weight',self.display_pref[c].weight,SelectableText(self.display_pref[c].dispname))

+                    for c in self.columns

+            ],1)

+

+    def get_texts(self, choices):

+        #TODO: re-work column info to separate data from presentation info

         texts = []

-        for weight,col,transform in columns:

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

+        for x in choices:

+            texts.append([])

+            for col in self.columns:

+                display = self.display_pref[col]

+                texts[-1].append((display.weight,display.transform(x.get(col,[""])[0])))

         return texts

-    def make_playlist(self):

-        body = []

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

+    def update_texts(self, choices):

+        self.texts = self.get_texts(choices.as_list())

+        self.update_playlist()

+

+    def make_body(self):

+        for x in 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[:]))

+            self.body.append(new_widg)

+

+    def update_playlist(self):

+        del self.body[:]

+        self.make_body()

+

+    def make_playlist(self):

+        self.make_body()

 def exit_on_q(key):

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

@@ -45,26 +67,73 @@ def exit_on_q(key):

         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)

+    'Pos',

+    'Date',

+    'Album',

+    'Artist',

+    'AlbumArtist',

+    'Title',

 ]

+import collections

+class DisplayDict(collections.Mapping):

+    def __init__(self, data):

+        self.row_class=collections.namedtuple('displaytuple', ['dispname','weight','transform'])

+        self.data = self.normalize(data)

+    def normalize(self, data):

+        out = {}

+        for key,val in data.iteritems():

+            dispname,weight,transform = None,1,lambda x:x

+            if hasattr(val, '__iter__'):

+                if len(val) == 3: dispname,weight,transform = val

+                if len(val) == 2: dispname,weight = val

+            if dispname is None:

+                dispname = key

+            out[key] = self.row_class(dispname, weight, transform)

+        return out

+    def __getitem__(self, key):

+        head, _, tail = key.partition('.')

+        if tail:

+            try:

+                return getattr(self.data[head], tail)

+            except AttributeError, e:

+                raise KeyError('Key not found: %s' % key)

+        else:

+            return self.data[head]

+    def __iter__(self):

+        return iter(self.data)

+    def __len__(self):

+        return len(self.data)

+

+

+col_display = DisplayDict(

+    dict(

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

+        Date=('Year', 4),

+        Album=(None,8),

+        Artist=(None,8),

+        AlbumArtist=('Album Artist',5),

+        Title=(None,13),

+))

+

 @defer.inlineCallbacks

 def get_playlist():

     client = yield mpdprotocol.get_client()

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

-    method, data = res

-    loop.widget = Playlist(cols, data)

+    method, data = yield client.sendCommand('playlistinfo')

+    loop.widget.update_texts(data)

     loop.draw_screen()

+    while True:

+        idle = yield client.idle(['playlist'])

+        method, data = yield client.sendCommand('playlistinfo')

+        loop.widget.update_texts(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)

+loop = urwid.MainLoop(Playlist(cols, col_display), 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()