0xcd

README.txt

@@ -0,0 +1,3 @@
+on os x run: ./bin/0xcd
+run ./bin/0xcd -h for a list of options
+

bin/0xcd

@@ -0,0 +1,24 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+# vi:si:et:sw=4:sts=4:ts=4
+
+import os
+import sys
+from optparse import OptionParser
+
+root = os.path.join(os.path.abspath(os.path.dirname(__file__)), '..')
+if os.path.exists(os.path.join(root, 'oxcd')):
+    sys.path.insert(0, root)
+
+import oxcd
+
+if __name__ == '__main__':
+    parser = OptionParser()
+    parser.add_option('-p', '--port', dest='port', help='port', default=2681)
+    parser.add_option('-i', '--itunes', dest='itunes', help='iTunes xml', default=oxcd.itunes_path())
+    (opts, args) = parser.parse_args()
+
+    if None in (opts.port, opts.itunes):
+        parser.print_help()
+        sys.exit()
+    oxcd.main(opts.port, opts.itunes)

oxcd/__init__.py

@@ -0,0 +1,35 @@
+# encoding: utf-8
+# vi:si:et:sw=4:sts=4:ts=4
+import os
+import sys
+import webbrowser
+
+from twisted.internet import glib2reactor
+
+from twisted.web.server import Site
+from twisted.internet import reactor
+
+from itunes import iTunes
+from server import Server
+import api
+
+from version import __version__
+
+def itunes_path():
+    if sys.platform == 'darwin':
+        path = os.path.expanduser('~/Music/iTunes/iTunes Library.xml')
+    elif sys.platform == 'win32':
+        path = os.path.expanduser('~\\Music\\iTunes\\iTunes Library.xml')
+    else:
+        path = None
+    return path
+
+def main(port, itunes):
+    base = os.path.abspath(os.path.dirname(__file__))
+    backend = iTunes(itunes)
+    root = Server(base, backend)
+    site = Site(root)
+    reactor.listenTCP(port, site)
+    reactor.callLater(1, lambda: webbrowser.open_new_tab('http://127.0.0.1:%s/' % port))
+    print 'opening browser at http://127.0.0.1:%s/ ...' % port
+    reactor.run()

oxcd/api.py

@@ -0,0 +1,15 @@
+# encoding: utf-8
+# vi:si:et:sw=4:sts=4:ts=4
+import os
+
+from server import actions, json_response
+
+def init(backend, site, data):
+    response = {}
+    return json_response(response)
+actions.register(init, cache=False)
+
+def library(backend, site, data):
+    response = backend.library
+    return json_response(response)
+actions.register(library, cache=True)

oxcd/itunes.py

@@ -0,0 +1,23 @@
+# encoding: utf-8
+# vi:si:et:sw=4:sts=4:ts=4
+from __future__ import with_statement, division
+
+import os
+from urllib import unquote
+
+from plistlib import readPlist
+
+class iTunes(object):
+    def __init__(self, xml):
+        self.library = readPlist(xml)
+        for id in self.library['Tracks']:
+            self.library['Tracks'][id]['Location'] = unquote(self.library['Tracks'][id]['Location'].replace('file://localhost/', '/'))
+            if self.library['Tracks'][id]['Location'].startswith('//'):
+                self.library['Tracks'][id]['Location'] = self.library['Tracks'][id]['Location'][1:]
+
+        self.library['Music Folder'] = unquote(self.library['Music Folder'].replace('file://localhost/', '/'))
+        if self.library['Music Folder'].startswith('//'):
+            self.library['Music Folder'] = self.library['Music Folder'][1:]
+        self.xml = xml
+        self.root = self.library['Music Folder']
+

oxcd/plistlib.py

@@ -0,0 +1,454 @@
+r"""plistlib.py -- a tool to generate and parse MacOSX .plist files.
+
+The property list (.plist) file format is a simple XML pickle supporting
+basic object types, like dictionaries, lists, numbers and strings.
+Usually the top level object is a dictionary.
+
+To write out a plist file, use the writePlist(rootObject, pathOrFile)
+function. 'rootObject' is the top level object, 'pathOrFile' is a
+filename or a (writable) file object.
+
+To parse a plist from a file, use the readPlist(pathOrFile) function,
+with a file name or a (readable) file object as the only argument. It
+returns the top level object (again, usually a dictionary).
+
+To work with plist data in bytes objects, you can use readPlistFromBytes()
+and writePlistToBytes().
+
+Values can be strings, integers, floats, booleans, tuples, lists,
+dictionaries (but only with string keys), Data or datetime.datetime objects.
+String values (including dictionary keys) have to be unicode strings -- they
+will be written out as UTF-8.
+
+The <data> plist type is supported through the Data class. This is a
+thin wrapper around a Python bytes object. Use 'Data' if your strings
+contain control characters.
+
+Generate Plist example:
+
+    pl = dict(
+        aString = "Doodah",
+        aList = ["A", "B", 12, 32.1, [1, 2, 3]],
+        aFloat = 0.1,
+        anInt = 728,
+        aDict = dict(
+            anotherString = "<hello & hi there!>",
+            aUnicodeValue = "M\xe4ssig, Ma\xdf",
+            aTrueValue = True,
+            aFalseValue = False,
+        ),
+        someData = Data(b"<binary gunk>"),
+        someMoreData = Data(b"<lots of binary gunk>" * 10),
+        aDate = datetime.datetime.fromtimestamp(time.mktime(time.gmtime())),
+    )
+    writePlist(pl, fileName)
+
+Parse Plist example:
+
+    pl = readPlist(pathOrFile)
+    print pl["aKey"]
+"""
+
+
+__all__ = [
+    "readPlist", "writePlist", "readPlistFromBytes", "writePlistToBytes",
+    "Plist", "Data", "Dict"
+]
+# Note: the Plist and Dict classes have been deprecated.
+
+import binascii
+import datetime
+from io import BytesIO
+import re
+
+
+def readPlist(pathOrFile):
+    """Read a .plist file. 'pathOrFile' may either be a file name or a
+    (readable) file object. Return the unpacked root object (which
+    usually is a dictionary).
+    """
+    didOpen = False
+    try:
+        if isinstance(pathOrFile, str):
+            pathOrFile = open(pathOrFile, 'rb')
+            didOpen = True
+        p = PlistParser()
+        rootObject = p.parse(pathOrFile)
+    finally:
+        if didOpen:
+            pathOrFile.close()
+    return rootObject
+
+
+def writePlist(rootObject, pathOrFile):
+    """Write 'rootObject' to a .plist file. 'pathOrFile' may either be a
+    file name or a (writable) file object.
+    """
+    didOpen = False
+    try:
+        if isinstance(pathOrFile, str):
+            pathOrFile = open(pathOrFile, 'wb')
+            didOpen = True
+        writer = PlistWriter(pathOrFile)
+        writer.writeln("<plist version=\"1.0\">")
+        writer.writeValue(rootObject)
+        writer.writeln("</plist>")
+    finally:
+        if didOpen:
+            pathOrFile.close()
+
+
+def readPlistFromBytes(data):
+    """Read a plist data from a bytes object. Return the root object.
+    """
+    return readPlist(BytesIO(data))
+
+
+def writePlistToBytes(rootObject):
+    """Return 'rootObject' as a plist-formatted bytes object.
+    """
+    f = BytesIO()
+    writePlist(rootObject, f)
+    return f.getvalue()
+
+
+class DumbXMLWriter:
+    def __init__(self, file, indentLevel=0, indent="\t"):
+        self.file = file
+        self.stack = []
+        self.indentLevel = indentLevel
+        self.indent = indent
+
+    def beginElement(self, element):
+        self.stack.append(element)
+        self.writeln("<%s>" % element)
+        self.indentLevel += 1
+
+    def endElement(self, element):
+        assert self.indentLevel > 0
+        assert self.stack.pop() == element
+        self.indentLevel -= 1
+        self.writeln("</%s>" % element)
+
+    def simpleElement(self, element, value=None):
+        if value is not None:
+            value = _escape(value)
+            self.writeln("<%s>%s</%s>" % (element, value, element))
+        else:
+            self.writeln("<%s/>" % element)
+
+    def writeln(self, line):
+        if line:
+            # plist has fixed encoding of utf-8
+            if isinstance(line, str):
+                line = line.encode('utf-8')
+            self.file.write(self.indentLevel * self.indent)
+            self.file.write(line)
+        self.file.write(b'\n')
+
+
+# Contents should conform to a subset of ISO 8601
+# (in particular, YYYY '-' MM '-' DD 'T' HH ':' MM ':' SS 'Z'.  Smaller units may be omitted with
+#  a loss of precision)
+_dateParser = re.compile(r"(?P<year>\d\d\d\d)(?:-(?P<month>\d\d)(?:-(?P<day>\d\d)(?:T(?P<hour>\d\d)(?::(?P<minute>\d\d)(?::(?P<second>\d\d))?)?)?)?)?Z")
+
+def _dateFromString(s):
+    order = ('year', 'month', 'day', 'hour', 'minute', 'second')
+    gd = _dateParser.match(s).groupdict()
+    lst = []
+    for key in order:
+        val = gd[key]
+        if val is None:
+            break
+        lst.append(int(val))
+    return datetime.datetime(*lst)
+
+def _dateToString(d):
+    return '%04d-%02d-%02dT%02d:%02d:%02dZ' % (
+        d.year, d.month, d.day,
+        d.hour, d.minute, d.second
+    )
+
+
+# Regex to find any control chars, except for \t \n and \r
+_controlCharPat = re.compile(
+    r"[\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f"
+    r"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f]")
+
+def _escape(text):
+    m = _controlCharPat.search(text)
+    if m is not None:
+        raise ValueError("strings can't contains control characters; "
+                         "use plistlib.Data instead")
+    text = text.replace("\r\n", "\n")       # convert DOS line endings
+    text = text.replace("\r", "\n")         # convert Mac line endings
+    text = text.replace("&", "&amp;")       # escape '&'
+    text = text.replace("<", "&lt;")        # escape '<'
+    text = text.replace(">", "&gt;")        # escape '>'
+    return text
+
+
+PLISTHEADER = b"""\
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+"""
+
+class PlistWriter(DumbXMLWriter):
+
+    def __init__(self, file, indentLevel=0, indent=b"\t", writeHeader=1):
+        if writeHeader:
+            file.write(PLISTHEADER)
+        DumbXMLWriter.__init__(self, file, indentLevel, indent)
+
+    def writeValue(self, value):
+        if isinstance(value, str):
+            self.simpleElement("string", value)
+        elif isinstance(value, bool):
+            # must switch for bool before int, as bool is a
+            # subclass of int...
+            if value:
+                self.simpleElement("true")
+            else:
+                self.simpleElement("false")
+        elif isinstance(value, int):
+            self.simpleElement("integer", "%d" % value)
+        elif isinstance(value, float):
+            self.simpleElement("real", repr(value))
+        elif isinstance(value, dict):
+            self.writeDict(value)
+        elif isinstance(value, Data):
+            self.writeData(value)
+        elif isinstance(value, datetime.datetime):
+            self.simpleElement("date", _dateToString(value))
+        elif isinstance(value, (tuple, list)):
+            self.writeArray(value)
+        else:
+            raise TypeError("unsupported type: %s" % type(value))
+
+    def writeData(self, data):
+        self.beginElement("data")
+        self.indentLevel -= 1
+        maxlinelength = 76 - len(self.indent.replace(b"\t", b" " * 8) *
+                                 self.indentLevel)
+        for line in data.asBase64(maxlinelength).split(b"\n"):
+            if line:
+                self.writeln(line)
+        self.indentLevel += 1
+        self.endElement("data")
+
+    def writeDict(self, d):
+        if d:
+            self.beginElement("dict")
+            items = sorted(d.items())
+            for key, value in items:
+                if not isinstance(key, str):
+                    raise TypeError("keys must be strings")
+                self.simpleElement("key", key)
+                self.writeValue(value)
+            self.endElement("dict")
+        else:
+            self.simpleElement("dict")
+
+    def writeArray(self, array):
+        if array:
+            self.beginElement("array")
+            for value in array:
+                self.writeValue(value)
+            self.endElement("array")
+        else:
+            self.simpleElement("array")
+
+
+class _InternalDict(dict):
+
+    # This class is needed while Dict is scheduled for deprecation:
+    # we only need to warn when a *user* instantiates Dict or when
+    # the "attribute notation for dict keys" is used.
+
+    def __getattr__(self, attr):
+        try:
+            value = self[attr]
+        except KeyError:
+            raise AttributeError(attr)
+        from warnings import warn
+        warn("Attribute access from plist dicts is deprecated, use d[key] "
+             "notation instead", DeprecationWarning, 2)
+        return value
+
+    def __setattr__(self, attr, value):
+        from warnings import warn
+        warn("Attribute access from plist dicts is deprecated, use d[key] "
+             "notation instead", DeprecationWarning, 2)
+        self[attr] = value
+
+    def __delattr__(self, attr):
+        try:
+            del self[attr]
+        except KeyError:
+            raise AttributeError(attr)
+        from warnings import warn
+        warn("Attribute access from plist dicts is deprecated, use d[key] "
+             "notation instead", DeprecationWarning, 2)
+
+class Dict(_InternalDict):
+
+    def __init__(self, **kwargs):
+        from warnings import warn
+        warn("The plistlib.Dict class is deprecated, use builtin dict instead",
+             DeprecationWarning, 2)
+        super().__init__(**kwargs)
+
+
+class Plist(_InternalDict):
+
+    """This class has been deprecated. Use readPlist() and writePlist()
+    functions instead, together with regular dict objects.
+    """
+
+    def __init__(self, **kwargs):
+        from warnings import warn
+        warn("The Plist class is deprecated, use the readPlist() and "
+             "writePlist() functions instead", DeprecationWarning, 2)
+        super().__init__(**kwargs)
+
+    def fromFile(cls, pathOrFile):
+        """Deprecated. Use the readPlist() function instead."""
+        rootObject = readPlist(pathOrFile)
+        plist = cls()
+        plist.update(rootObject)
+        return plist
+    fromFile = classmethod(fromFile)
+
+    def write(self, pathOrFile):
+        """Deprecated. Use the writePlist() function instead."""
+        writePlist(self, pathOrFile)
+
+
+def _encodeBase64(s, maxlinelength=76):
+    # copied from base64.encodebytes(), with added maxlinelength argument
+    maxbinsize = (maxlinelength//4)*3
+    pieces = []
+    for i in range(0, len(s), maxbinsize):
+        chunk = s[i : i + maxbinsize]
+        pieces.append(binascii.b2a_base64(chunk))
+    return b''.join(pieces)
+
+class Data:
+
+    """Wrapper for binary data."""
+
+    def __init__(self, data):
+        if not isinstance(data, bytes):
+            raise TypeError("data must be as bytes")
+        self.data = data
+
+    @classmethod
+    def fromBase64(cls, data):
+        # base64.decodebytes just calls binascii.a2b_base64;
+        # it seems overkill to use both base64 and binascii.
+        return cls(binascii.a2b_base64(data))
+
+    def asBase64(self, maxlinelength=76):
+        return _encodeBase64(self.data, maxlinelength)
+
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            return self.data == other.data
+        elif isinstance(other, str):
+            return self.data == other
+        else:
+            return id(self) == id(other)
+
+    def __repr__(self):
+        return "%s(%s)" % (self.__class__.__name__, repr(self.data))
+
+class PlistParser:
+
+    def __init__(self):
+        self.stack = []
+        self.currentKey = None
+        self.root = None
+
+    def parse(self, fileobj):
+        from xml.parsers.expat import ParserCreate
+        self.parser = ParserCreate()
+        self.parser.StartElementHandler = self.handleBeginElement
+        self.parser.EndElementHandler = self.handleEndElement
+        self.parser.CharacterDataHandler = self.handleData
+        self.parser.ParseFile(fileobj)
+        return self.root
+
+    def handleBeginElement(self, element, attrs):
+        self.data = []
+        handler = getattr(self, "begin_" + element, None)
+        if handler is not None:
+            handler(attrs)
+
+    def handleEndElement(self, element):
+        handler = getattr(self, "end_" + element, None)
+        if handler is not None:
+            handler()
+
+    def handleData(self, data):
+        self.data.append(data)
+
+    def addObject(self, value):
+        if self.currentKey is not None:
+            if not isinstance(self.stack[-1], type({})):
+                raise ValueError("unexpected element at line %d" %
+                                 self.parser.CurrentLineNumber)
+            self.stack[-1][self.currentKey] = value
+            self.currentKey = None
+        elif not self.stack:
+            # this is the root object
+            self.root = value
+        else:
+            if not isinstance(self.stack[-1], type([])):
+                raise ValueError("unexpected element at line %d" %
+                                 self.parser.CurrentLineNumber)
+            self.stack[-1].append(value)
+
+    def getData(self):
+        data = ''.join(self.data)
+        self.data = []
+        return data
+
+    # element handlers
+
+    def begin_dict(self, attrs):
+        d = _InternalDict()
+        self.addObject(d)
+        self.stack.append(d)
+    def end_dict(self):
+        if self.currentKey:
+            raise ValueError("missing value for key '%s' at line %d" %
+                             (self.currentKey,self.parser.CurrentLineNumber))
+        self.stack.pop()
+
+    def end_key(self):
+        if self.currentKey or not isinstance(self.stack[-1], type({})):
+            raise ValueError("unexpected key at line %d" %
+                             self.parser.CurrentLineNumber)
+        self.currentKey = self.getData()
+
+    def begin_array(self, attrs):
+        a = []
+        self.addObject(a)
+        self.stack.append(a)
+    def end_array(self):
+        self.stack.pop()
+
+    def end_true(self):
+        self.addObject(True)
+    def end_false(self):
+        self.addObject(False)
+    def end_integer(self):
+        self.addObject(int(self.getData()))
+    def end_real(self):
+        self.addObject(float(self.getData()))
+    def end_string(self):
+        self.addObject(self.getData())
+    def end_data(self):
+        self.addObject(Data.fromBase64(self.getData().encode("utf-8")))
+    def end_date(self):
+        self.addObject(_dateFromString(self.getData()))

oxcd/server.py

@@ -0,0 +1,202 @@
+# encoding: utf-8
+# vi:si:et:sw=4:sts=4:ts=4
+from __future__ import with_statement, division
+
+import sys
+import inspect
+import os
+import json
+from urlparse import urlparse
+import datetime
+
+from twisted.web.resource import Resource
+from twisted.web.static import File
+from twisted.web.util import Redirect
+from twisted.web.error import NoResource
+
+from version import __version__
+
+def trim(docstring):
+    if not docstring:
+        return ''
+    # Convert tabs to spaces (following the normal Python rules)
+    # and split into a list of lines:
+    lines = docstring.expandtabs().splitlines()
+    # Determine minimum indentation (first line doesn't count):
+    indent = sys.maxint
+    for line in lines[1:]:
+        stripped = line.lstrip()
+        if stripped:
+            indent = min(indent, len(line) - len(stripped))
+    # Remove indentation (first line is special):
+    trimmed = [lines[0].strip()]
+    if indent < sys.maxint:
+        for line in lines[1:]:
+            trimmed.append(line[indent:].rstrip())
+    # Strip off trailing and leading blank lines:
+    while trimmed and not trimmed[-1]:
+        trimmed.pop()
+    while trimmed and not trimmed[0]:
+        trimmed.pop(0)
+    # Return a single string:
+    return '\n'.join(trimmed)
+
+def _to_json(python_object):
+    if isinstance(python_object, datetime.datetime):          
+        return python_object.strftime('%Y-%m-%dT%H:%M:%SZ')
+    raise TypeError(u'%s %s is not JSON serializable' % (repr(python_object), type(python_object)))
+
+def json_response(data=None, status=200, text='ok'):
+    if not data:
+        data = {}
+    return {'status': {'code': status, 'text': text}, 'data': data}
+
+class ApiActions(dict):
+    properties = {}
+    def __init__(self):
+
+        def api(backend, site, data):
+            '''
+                returns list of all known api actions
+                param data {
+                    docs: bool
+                }
+                if docs is true, action properties contain docstrings
+                return {
+                    status: {'code': int, 'text': string},
+                    data: {
+                        actions: {
+                            'api': {
+                                cache: true,
+                                doc: 'recursion'
+                            },
+                            'hello': {
+                                cache: true,
+                                ..
+                            }
+                            ...
+                        }
+                    }
+                }
+            '''
+            docs = data.get('docs', False)
+            code = data.get('code', False)
+            _actions = self.keys()
+            _actions.sort()
+            actions = {}
+            for a in _actions:
+                actions[a] = self.properties[a]
+                if docs:
+                    actions[a]['doc'] = self.doc(a)
+                if code:
+                    actions[a]['code'] = self.code(a)
+            response = json_response({'actions': actions})
+            return response
+        self.register(api)
+
+    def doc(self, f):
+        return trim(self[f].__doc__)
+
+    def code(self, name):
+        f = self[name]
+        if name != 'api' and hasattr(f, 'func_closure') and f.func_closure:
+            f = f.func_closure[0].cell_contents 
+        info = f.func_code.co_firstlineno
+        return info, trim(inspect.getsource(f))
+
+    def register(self, method, action=None, cache=True):
+        if not action:
+            action = method.func_name
+        self[action] = method
+        self.properties[action] = {'cache': cache}
+
+    def unregister(self, action):
+        if action in self:
+            del self[action]
+
+    def render(self, backend, site, action, data):
+        if action in self:
+            result = self[action](backend, site, data)
+        else:
+            result = json_response(status=404, text='not found')
+        #print result
+        return json.dumps(result, default=_to_json)
+
+actions = ApiActions()
+
+
+class Server(Resource):
+
+    def __init__(self, base, backend):
+        self.base = base
+        self.backend = backend
+        Resource.__init__(self)
+
+    def static_path(self, path):
+        return os.path.join(self.base, 'static', path)
+
+    def get_site(self, request):
+        headers = request.getAllHeaders()
+        #print headers
+        if 'origin' in headers:
+            request.headers['Access-Control-Allow-Origin'] = headers['origin']
+            site = headers['origin']
+        elif 'referer' in headers:
+            u = urlparse(headers['referer'])
+            site = u.scheme + '://' + u.hostname
+        else:
+            site = 'http://' + headers['host']
+        return site
+
+    def getChild(self, name, request):
+        if name in ('icon.png', 'favicon.ico'):
+            f = File(self.static_path('png/icon16.png'))
+            f.isLeaf = True
+            return f
+        if request.path == '/api/':
+            return self
+        if request.path.startswith('/track/'):
+            track_id = request.path.split('/')[-1].split('.')[0]
+            track = self.backend.library['Tracks'].get(track_id)
+            if track:
+                path = track['Location']
+                if os.path.exists(path):
+                    request.headers['Access-Control-Allow-Origin'] = '*'
+                    f = File(path, 'audio/mpeg')
+                    f.isLeaf = True
+                    return f
+            return NoResource()
+        path = request.path
+        path = path[1:]
+        if not path:
+            path = 'index.html'
+        path = self.static_path(path)
+        f = File(path)
+        if not os.path.isdir(path):
+            f.isLeaf = True
+        return f
+
+    def render_POST(self, request):
+        request.headers['Server'] = 'oxcd/%s' % __version__
+        site = self.get_site(request)
+        #print "POST", request.args
+        if 'action' in request.args:
+            if 'data' in request.args:
+                data = json.loads(request.args['data'][0])
+            else:
+                data = {}
+            action = request.args['action'][0]
+            return actions.render(self.backend, site, action, data)
+
+    def render_GET(self, request):
+        request.headers['Server'] = 'oxcd/%s' % __version__
+        if request.path.startswith('/api'):
+            path = self.static_path('api.html')
+        else:
+            path = self.static_path('index.html')
+        with open(path) as f:
+            data = f.read()
+        request.headers['Content-Type'] = 'text/html'
+        site = self.get_site(request)
+        data = data.replace('$name', site)
+        return data

oxcd/static/api.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>0xcd API</title>
+        <link rel="shortcut icon" type="image/png" href="/png/icon16.png"/>
+        <script type="text/javascript" src="/oxjs/build/Ox.js"></script> 
+        <script type="text/javascript" src="/js/api/api.js"></script>
+    </head>
+    <body>
+    </body>
+</html>

oxcd/static/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>0xcd</title>
+        <link rel="shortcut icon" type="image/png" href="/png/icon16.png"/>
+        <script type="text/javascript" src="/oxjs/build/Ox.js"></script> 
+        <script type="text/javascript" src="/js/site.js"></script>
+    </head>
+    <body>
+    </body>
+</html>

oxcd/static/js/api/api.js

@@ -0,0 +1,170 @@
+/***
+    Pandora API
+***/
+Ox.load('UI', {
+    hideScreen: false,
+    showScreen: true,
+    theme: 'classic'
+}, function() {
+
+var app = new Ox.App({
+    url: '/api/',
+    init: 'init',
+}).bindEvent('load', function(data) {
+    app.site = data.site;
+    app.user = data.user;
+    app.site = app.site || {site: {name: ''}};
+    app.site.default_info = '<div class="OxSelectable"><h2>Pan.do/ra API Overview</h2>use this api in the browser with <a href="/static/oxjs/demos/doc2/index.html#Ox.App">Ox.app</a> or use <a href="http://code.0x2620.org/pandora_client">pandora_client</a> it in python. Further description of the api can be found <a href="https://wiki.0x2620.org/wiki/pandora/API">on the wiki</a></div>';
+    app.$body = $('body');
+    app.$document = $(document);
+    app.$window = $(window);
+    //app.$body.html('');
+    Ox.UI.hideLoadingScreen();
+
+    app.$ui = {};
+    app.$ui.actionList = constructList();
+    app.$ui.actionInfo = Ox.Container().css({padding: '16px'}).html(app.site.default_info);
+
+    app.api.api({docs: true, code: true}, function(results) {
+        app.actions = results.data.actions;
+        if (document.location.hash) {
+            app.$ui.actionList.triggerEvent('select', {
+                ids: document.location.hash.substring(1).split(',')
+            });
+        }
+    });
+
+    var $left = new Ox.SplitPanel({
+        elements: [
+            {
+                element: new Ox.Element().append(new Ox.Element()
+                .html(app.site.site.name + ' API').css({
+                    'padding': '4px',
+                })).css({
+                    'background-color': '#ddd',
+                    'font-weight': 'bold',
+                }),
+                size: 24
+            },
+            {
+                element: app.$ui.actionList
+            }
+        ],
+        orientation: 'vertical'
+    });
+    var $main = new Ox.SplitPanel({
+        elements: [
+            {
+                element: $left,
+                size: 160
+            },
+            {
+                element: app.$ui.actionInfo,
+            }
+        ],
+        orientation: 'horizontal'
+    });
+
+    $main.appendTo(app.$body);
+});
+
+function constructList() {
+    return new Ox.TableList({
+        columns: [
+            {
+                align: "left",
+                id: "name",
+                operator: "+",
+                title: "Name",
+                visible: true,
+                width: 140
+            },
+        ],
+        columnsMovable: false,
+        columnsRemovable: false,
+        id: 'actionList',
+        items: function(data, callback) {
+            function _sort(a, b) {
+                return a.name > b.name ? 1 : a.name == b.name ? 0 : -1;
+            }
+            if (!data.keys) {
+                app.api.api(function(results) {
+                    var items = [];
+                    Ox.forEach(results.data.actions, function(v, k) {
+                        items.push({'name':  k})
+                    });
+                    items.sort(_sort);
+                    var result = {'data': {'items': items.length}};
+                    callback(result);
+                });
+            } else {
+                app.api.api(function(results) {
+                    var items = [];
+                    Ox.forEach(results.data.actions, function(v, k) {
+                        items.push({'name':  k})
+                    });
+                    items.sort(_sort);
+                    var result = {'data': {'items': items}};
+                    callback(result);
+                });
+            }
+        },
+        scrollbarVisible: true,
+        sort: [{key: "name", operator: "+"}],
+        unique: 'name'
+    }).bindEvent({
+       select: function(data) {
+           var info = $('<div>').addClass('OxSelectable'),
+               hash = '#';
+           if (data.ids.length)
+              data.ids.forEach(function(id) {
+                info.append(
+                    $('<h2>')
+                        .html(id)
+                        .css({
+                            marginBottom: '8px'
+                        })
+                );
+                var code = app.actions[id].code[1],
+                    f = app.actions[id].code[0],
+                    line = Math.round(Ox.last(f.split(':')) || 0),
+                    doc = app.actions[id].doc.replace('/\n/<br>\n/g'),
+                    $code, $doc;
+
+                $doc = Ox.SyntaxHighlighter({
+                        source: doc,
+                    })
+                    .appendTo(info);
+
+                Ox.Button({
+                        title: 'View Source (' + f + ')',
+                    }).bindEvent({
+                        click: function() {
+                            $code.toggle();
+                        }
+                    })
+                    .css({
+                        margin: '4px'
+                    })
+                    .appendTo(info);
+                $code = Ox.SyntaxHighlighter({
+                    showLineNumbers: true,
+                    source: code,
+                    offset: line
+                })
+                .css({
+                    borderWidth: '1px',
+                }).appendTo(info).hide();
+                Ox.print(code);
+                hash += id + ','
+              });
+            else
+              info.html(app.site.default_info);
+
+            document.location.hash = hash.slice(0, -1);
+            app.$ui.actionInfo.html(info);
+       }
+    });
+}
+});
+

oxcd/static/js/site.js

@@ -0,0 +1,18 @@
+Ox.load('UI', function() {
+    window.oxcd = Ox.App({
+        name: 'oxcd',
+        url: '/api/'
+    }).bindEvent({
+        load: function(data) {
+            oxcd.api.library(function(result) {
+                var items = Ox.values(result.data.Tracks),
+                    element = Ox.Element();
+                items.forEach(function(item) {
+                    element.append($('<div>').html('<a href="/track/'+item['Track ID']+'.mp3">'+item['Track ID'] + ': '+item.Name+'</a>'))
+                    console.log('<a href="/track/'+item['Track ID']+'.mp3">'+item['Track ID'] + ':'+item.Name+'</a>');
+                });
+                Ox.UI.$body.append(element);
+            })
+        }
+    });
+});

oxcd/version.py

@@ -0,0 +1 @@
+__version__ = 0.1

update.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+oxcd_repos=http://code.0x2620.org/oxcd/
+oxjs_repos=http://code.0x2620.org/oxjs/
+cd `dirname $0`
+base=`pwd`
+current=`bzr revno`
+bzr pull $pandora_repos
+new=`bzr revno`
+cd $base
+if [ -e oxcd/static/oxjs ]; then
+  cd oxcd/static/oxjs
+  current=$current`bzr revno`
+  bzr pull $oxjs_repos
+  new=$new`bzr revno`
+else
+  cd oxcd/static
+  bzr branch $oxjs_repos
+  cd oxjs
+  new=$new`bzr revno`
+fi
+if [ $current -ne $new ]; then
+    cd $base/oxcd/static/oxjs
+    if [ -e build/Ox.Geo/json/Ox.Geo.json ]; then
+        ./tools/build/build.py -nogeo >/dev/null
+    else
+        ./tools/build/build.py >/dev/null
+    fi
+fi