self.graph.patchObject(self.session, self.session, L9['currentRow'],

                                   Literal(self.current_row))

        for col in range(1, 9):

            try:

                subbox = self.slider_table[(self.current_row, col - 1)]

                self.sliders.valueOut("button-upper%d" % col, True)

            except KeyError:

                # unfilled bottom row has holes (plus rows with incomplete

                # groups

                self.sliders.valueOut("button-upper%d" % col, False)

                self.sliders.valueOut("slider%d" % col, 0)

                continue

            self.send_to_hw(subbox.name, col)

    def got_nudger(self, number, direction, full=0):

        try:

            subbox = self.slider_table[(self.current_row, number)]

        except KeyError:

            return

        if direction == 'up':

            if full:

                subbox.scale.fade(1)

            else:

                subbox.scale.increase()

        else:

            if full:

                subbox.scale.fade(0)

            else:

                subbox.scale.decrease()

    def hw_slider_moved(self, col, value):

        value = int(value * 100) / 100

        try:

            subbox = self.slider_table[(self.current_row, col)]

        except KeyError:

            return # no slider assigned at that column

        subbox.scale.set(value)

    def send_to_hw(self, subUri, hwNum):

        if isinstance(self.sliders, DummySliders):

            return

        v = round(127 * self.slider_vars[subUri].get())

        chan = "slider%s" % hwNum

        # workaround for some rounding issue, where we receive one

        # value and then decide to send back a value that's one step

        # lower.  -5 is a fallback for having no last value.  hopefully

        # we won't really see it

        if abs(v - self.sliders.lastValue.get(chan, -5)) <= 1:

            return

        self.sliders.valueOut(chan, v)

    def make_row(self):

        row = Frame(self, bd=2, bg='black')

        row.pack(expand=1, fill=BOTH)

        self.setup_key_nudgers(row)

        self.rows.append(row)

        return row

    def highlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'red'

    def unhighlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'black'

    def get_levels(self):

        return dict([(uri, box.slider_var.get()) 

            for uri, box in self.subbox.items()])

    def get_levels_as_sub(self):

        scaledsubs = [self.submasters.get_sub_by_uri(sub) * level

            for sub, level in self.get_levels().items() if level > 0.0]

        maxes = sub_maxes(*scaledsubs)

        return maxes

    def save_current_stage(self, subname):

        log.info("saving current levels as %s", subname)

        sub = self.get_levels_as_sub()

        sub.name = subname

        sub.temporary = 0

        sub.save()

    def send_frequent_updates(self):

        """called when we get a fade -- send events as quickly as possible"""

        if time.time() <= self.stop_frequent_update_time:

            self.send_levels()

            self.after(10, self.send_frequent_updates)

    def alltozero(self):

        for uri, subbox in self.subbox.items():

            if subbox.scale.scale_var.get() != 0:

                subbox.scale.fade(value=0.0, length=0)

# move to web lib

def postArgGetter(request):

    """return a function that takes arg names and returns string

    values. Supports args encoded in the url or in postdata. No

    support for repeated args."""

    # this is something nevow normally does for me

    request.content.seek(0)

    fields = cgi.FieldStorage(request.content, request.received_headers,

                              environ={'REQUEST_METHOD': 'POST'})

    def getArg(n):

        try:

            return request.args[n][0]

        except KeyError:

            return fields[n].value

    return getArg

class LevelServerHttp(resource.Resource):

    isLeaf = True

    def __init__(self,name_to_subbox):

        self.name_to_subbox = name_to_subbox

    def render_POST(self, request):

        arg = postArgGetter(request)

        if request.path == '/fadesub':

            # fadesub?subname=scoop&level=0&secs=.2

            self.name_to_subbox[arg('subname')].scale.fade(

                float(arg('level')),

                float(arg('secs')))

            return "set %s to %s" % (arg('subname'), arg('level'))

        else:

            raise NotImplementedError(repr(request))

class Sliders(BCF2000):

    def __init__(self, kc):

        devices = ['/dev/snd/midiC1D0', '/dev/snd/midiC2D0', '/dev/snd/midiC3D0']

        for dev in devices:

            try:

                BCF2000.__init__(self, dev=dev)

            except IOError, e:

                if dev is devices[-1]:

                    raise

            else:

                break

        self.kc = kc

    def valueIn(self, name, value):

        kc = self.kc

        if name.startswith("slider"):

            kc.hw_slider_moved(int(name[6:]) - 1, value / 127)

        elif name.startswith("button-upper"):

            kc.change_row(kc.current_row)

        elif name.startswith("button-lower"):

            col = int(name[12:]) - 1

            self.valueOut(name, 0)

            try:

                tkslider = kc.slider_table[(kc.current_row, col)]

            except KeyError:

                return

            slider_var = tkslider.slider_var

            if slider_var.get() == 1:

                slider_var.set(0)

            else:

                slider_var.set(1)

        elif name.startswith("button-corner"):

            button_num = int(name[13:]) - 1

            if button_num == 1:

                diff = -1

            elif button_num == 3:

                diff = 1

            else:

                return

            kc.change_row(kc.current_row + diff)

            self.valueOut(name, 0)

if __name__ == "__main__":

    parser = OptionParser()

    parser.add_option('--no-sliders', action='store_true',

                      help="don't attach to hardware sliders")

    clientsession.add_option(parser)

    parser.add_option('-v', action='store_true', help="log info level")

    opts, args = parser.parse_args()

    logging.basicConfig(level=logging.INFO if opts.v else logging.WARN)

    log = logging.getLogger('keyboardcomposer')

    graph = SyncedGraph("keyboardcomposer")

    root = Tk()

    initTkdnd(root.tk, 'tkdnd/trunk/')

    tl = toplevelat("Keyboard Composer - %s" % opts.session,

    kc = KeyboardComposer(tl, graph, session,

                          hw_sliders=not opts.no_sliders)

    kc.pack(fill=BOTH, expand=1)

    for helpline in ["Bindings: B3 mute; C-l edit levels in subcomposer"]:

        tk.Label(root,text=helpline, font="Helvetica -12 italic",

                 anchor='w').pack(side='top',fill='x')

    if 0: # needs fixing, or maybe it's obsolete because other progs can just patch the rdf graph

        import twisted.internet

        try:

            reactor.listenTCP(networking.keyboardComposer.port,

                              server.Site(LevelServerHttp(kc.name_to_subbox)))

        except twisted.internet.error.CannotListenError, e:

            log.warn("Can't (and won't!) start level server:")

            log.warn(e)

    root.protocol('WM_DELETE_WINDOW', reactor.stop)

    tksupport.install(root,ms=10)

#    prof.watchPoint("/usr/lib/python2.4/site-packages/rdflib-2.3.3-py2.4-linux-i686.egg/rdflib/Graph.py", 615)

    prof.run(reactor.run, profile=False)

#!bin/python

"""

other tools POST themselves to here as subscribers to the graph. They

are providing a URL we can PUT to with graph updates.

we immediately PUT them back all the contents of the graph as a bunch

of adds.

later we PUT them back with patches (del/add lists) when there are

changes.

If we fail to reach a registered caller, we forget about it for future

calls. We could PUT empty diffs as a heartbeat to notice disappearing

callers faster.

A caller can submit a patch which we'll persist and broadcast to every

other client.

Maybe some subgraphs are for transient data (e.g. current timecode,

mouse position in curvecalc) that only some listeners want to hear about.

Deletes are graph-specific, so callers may be surprised to delete a

stmt from one graph but then find that statement is still true.

Alternate plan: would it help to insist that every patch is within

only one subgraph? I think it's ok for them to span multiple ones.

Inserts can be made on any subgraphs, and each subgraph is saved in

its own file. The file might not be in a format that can express

graphs, so I'm just going to not store the subgraph URI in any file.

I don't support wildcard deletes, and there are race conditions where a

s-p could end up with unexpected multiple objects. Every client needs

to be ready for this.

We watch the files and push their own changes back to the clients.

Persist our client list, to survive restarts. In another rdf file? A

random json one? memcache? Also hold the recent changes. We're not

logging everything forever, though, since the output files and a VCS

shall be used for that

Bnodes: this rdfdb graph might be able to track bnodes correctly, and

they make for more compact n3 files. I'm not sure if it's going to be

hard to keep the client bnodes in sync though. File rereads would be

hard, if ever a bnode was used across graphs, so that probably should

not be allowed.

Our API:

GET /  ui

GET /graph    the whole graph, or a query from it (needed? just for ui browsing?)

PUT /patches  clients submit changes

GET /patches  (recent) patches from clients

POST /graphClients clientUpdate={uri} to subscribe

GET /graphClients  current clients

format:

json {"adds" : [[quads]...],

      "deletes": [[quads]],

      "senderUpdateUri" : tooluri,

      "created":tttt // maybe to help resolve some conflicts

     }

maybe use some http://json-ld.org/ in there.

proposed rule feature:

rdfdb should be able to watch a pair of (sourceFile, rulesFile) and

rerun the rules when either one changes. Should the sourceFile be able

to specify its own rules file?  That would be easier

configuration. How do edits work? Not allowed?  Patch the source only?

Also see the source graph loaded into a different ctx, and you can

edit that one and see the results in the output context?

Our web ui:

  sections

    registered clients

    recent patches, each one says what client it came from. You can reverse

    them here. We should be able to take patches that are close in time

    and keep updating the same data (e.g. a stream of changes as the user

    drags a slider) and collapse them into a single edit for clarity.

        Ways to display patches, using labels and creator/subj icons

        where possible:

          <creator> set <subj>'s <p> to <o>

          <creator> changed <subj>'s <pred> from <o1> to <o2>

          <creator> added <o> to <s> <p>

    raw messages for debugging this client

    ctx urls take you to->

    files, who's dirty, have we seen external changes, notice big

    files that are taking a long time to save

    graph contents. plain rdf browser like an outliner or

    something. clicking any resource from the other displays takes you

    to this, focused on that resource

"""

from twisted.internet import reactor

import twisted.internet.error

import sys, optparse, logging, json, os

import cyclone.web, cyclone.httpclient, cyclone.websocket

sys.path.append(".")

from light9 import networking, showconfig, prof

from rdflib import ConjunctiveGraph, URIRef, Graph

from light9.rdfdb.graphfile import GraphFile

from light9.rdfdb.patch import Patch, ALLSTMTS

from light9.rdfdb.rdflibpatch import patchQuads

from light9.rdfdb import syncedgraph

from twisted.internet.inotify import INotify

logging.basicConfig(level=logging.DEBUG)

log = logging.getLogger()

try:

    import sys

    sys.path.append("../homeauto/lib")

    from cycloneerr import PrettyErrorHandler

except ImportError:

    class PrettyErrorHandler(object):

        pass

class Client(object):

    """

    one of our syncedgraph clients

    """

    def __init__(self, updateUri, label, db):

        self.db = db

        self.label = label

        self.updateUri = updateUri

        self.sendAll()

    def __repr__(self):

        return "<%s client at %s>" % (self.label, self.updateUri)

    def sendAll(self):

        """send the client the whole graph contents"""

        log.info("sending all graphs to %s at %s" %

                 (self.label, self.updateUri))

        self.sendPatch(Patch(

            addQuads=self.db.graph.quads(ALLSTMTS),

            delQuads=[]))

    def sendPatch(self, p):

        return syncedgraph.sendPatch(self.updateUri, p)

class Db(object):

    """

    the master graph, all the connected clients, all the files we're watching

    """

    def __init__(self):

        # files from cwd become uris starting with this. *should* be

        # building uris from the show uri in $LIGHT9_SHOW/URI

        # instead. Who wants to keep their data in the same dir tree

        # as the source code?!

        self.topUri = URIRef("http://light9.bigasterisk.com/")

        self.clients = []

        self.graph = ConjunctiveGraph()

        self.notifier = INotify()

        self.notifier.startReading()

        self.graphFiles = {} # context uri : GraphFile

        self.findAndLoadFiles()

    def findAndLoadFiles(self):

        self.initialLoad = True

        try:

            dirs = [

                "show/dance2012/sessions",

                "show/dance2012/subs",

                "show/dance2012/subterms",

                ]

            for topdir in dirs:

                for dirpath, dirnames, filenames in os.walk(topdir):

                    for base in filenames:

                        self.watchFile(os.path.join(dirpath, base))

                # todo: also notice new files in this dir

            self.watchFile("show/dance2012/config.n3")

            self.watchFile("show/dance2012/patch.n3")

        finally:

            self.initialLoad = False

        self.summarizeToLog()

    def uriFromFile(self, filename):

        if filename.endswith('.n3'):

            # some legacy files don't end with n3. when we write them

            # back this might not go so well

            filename = filename[:-len('.n3')]

        return URIRef(self.topUri + filename)

    def fileForUri(self, ctx):

        if not ctx.startswith(self.topUri):

            raise ValueError("don't know what filename to use for %s" % ctx)

        return ctx[len(self.topUri):] + ".n3"

    def watchFile(self, inFile):

        ctx = self.uriFromFile(inFile)

        gf = GraphFile(self.notifier, inFile, ctx, self.patch, self.getSubgraph)

        self.graphFiles[ctx] = gf

        gf.reread()

from rdflib import ConjunctiveGraph, RDFS, RDF, Graph

import logging, cyclone.httpclient, traceback, urllib

log = logging.getLogger('syncedgraph')

from light9.rdfdb.patch import Patch, ALLSTMTS

from light9.rdfdb.rdflibpatch import patchQuads

def sendPatch(putUri, patch, **kw):

    """

    kwargs will become extra attributes in the toplevel json object

    """

    body = patch.makeJsonRepr(kw)

    log.debug("send body: %r", body)

    def ok(done):

        if not str(done.code).startswith('2'):

            raise ValueError("sendPatch request failed %s: %s" % (done.code, done.body))

        log.debug("sendPatch finished, response: %s" % done.body)

        return done

    return cyclone.httpclient.fetch(

        url=putUri,

        method='PUT',

        headers={'Content-Type': ['application/json']},

        postdata=body,

        ).addCallback(ok)

def makePatchEndpointPutMethod(cb):

    def put(self):

        try:

            p = Patch(jsonRepr=self.request.body)

            log.info("received patch -%d +%d" % (len(p.delGraph), len(p.addGraph)))

            cb(p)

        except:

            traceback.print_exc()

            raise

    return put

def makePatchEndpoint(cb):

    class Update(cyclone.web.RequestHandler):

        put = makePatchEndpointPutMethod(cb)

    return Update

class GraphWatchers(object):

    """

    store the current handlers that care about graph changes

    """

    def __init__(self):

        self._handlersSp = {} # (s,p): set(handlers)

        self._handlersPo = {} # (p,o): set(handlers)

    def addSubjPredWatcher(self, func, s, p):

        if func is None:

            return

        key = s, p

        try:

            self._handlersSp.setdefault(key, set()).add(func)

        except Exception:

            log.error("with key %r and func %r" % (key, func))

            raise

    def addPredObjWatcher(self, func, p, o):

        self._handlersPo.setdefault((p, o), set()).add(func)

    def whoCares(self, patch):

        """what handler functions would care about the changes in this patch?

        this removes the handlers that it gives you

        """

        #self.dependencies()

        affectedSubjPreds = set([(s, p) for s, p, o, c in patch.addQuads]+

                                [(s, p) for s, p, o, c in patch.delQuads])

        affectedPredObjs = set([(p, o) for s, p, o, c in patch.addQuads]+

                                [(p, o) for s, p, o, c in patch.delQuads])

        ret = set()

        for (s, p), funcs in self._handlersSp.iteritems():

            if (s, p) in affectedSubjPreds:

                ret.update(funcs)

                funcs.clear()

        for (p, o), funcs in self._handlersPo.iteritems():

            if (p, o) in affectedPredObjs:

                ret.update(funcs)

                funcs.clear()

        return ret

    def dependencies(self):

        """

        for debugging, make a list of all the active handlers and what

        data they depend on. This is meant for showing on the web ui

        for browsing.

        """

        log.info("whocares:")

        from pprint import pprint

        pprint(self._handlersSp)

class PatchSender(object):

    """

    SyncedGraph may generate patches faster than we can send

    them. This object buffers and may even collapse patches before

    they go the server

    """

    def __init__(self, target, myUpdateResource):

        self.target = target

        self.myUpdateResource = myUpdateResource

        self._patchesToSend = []

        self._currentSendPatchRequest = None

    def sendPatch(self, p):

        self._continueSending()

    def _continueSending(self):

        if not self._patchesToSend or self._currentSendPatchRequest:

            return

        if len(self._patchesToSend) > 1:

            log.info("%s patches left to send", len(self._patchesToSend))

            # this is where we could concatenate little patches into a

            # bigger one. Often, many statements will cancel each

            # other out. not working yet:

            if 0:

                p = self._patchesToSend[0].concat(self._patchesToSend[1:])

                print "concat down to"

                print 'dels'

                for q in p.delQuads: print q

                print 'adds'

                for q in p.addQuads: print q

                print "----"

            else:

        else:

        self._currentSendPatchRequest = sendPatch(

            self.target, p, senderUpdateUri=self.myUpdateResource)

        self._currentSendPatchRequest.addCallbacks(self._sendPatchDone,

                                                   self._sendPatchErr)

    def _sendPatchDone(self, result):

        self._currentSendPatchRequest = None

        self._continueSending()

    def _sendPatchErr(self, e):

        self._currentSendPatchRequest = None

        # we're probably out of sync with the master now, since

        # SyncedGraph.patch optimistically applied the patch to our

        # local graph already. What happens to this patch? What

        # happens to further pending patches? Some of the further

        # patches, especially, may be commutable with the bad one and

        # might still make sense to apply to the master graph.

        # if someday we are folding pending patches together, this

        # would be the time to UNDO that and attempt the original

        # separate patches again

        # this should screen for 409 conflict responses and raise a

        # special exception for that, so SyncedGraph.sendFailed can

        # screen for only that type

        # this code is going away; we're going to raise an exception that contains all the pending patches

        log.error("_sendPatchErr")

        log.error(e)

        self._continueSending()

class SyncedGraph(object):

    """

    graph for clients to use. Changes are synced with the master graph

    in the rdfdb process.

    This api is like rdflib.Graph but it can also call you back when

    there are graph changes to the parts you previously read.

    If we get out of sync, we abandon our local graph (even any

    pending local changes) and get the data again from the

    server.

    """

    def __init__(self, label):

        """

        label is a string that the server will display in association

        with your connection

        """

        _graph = self._graph = ConjunctiveGraph()

        self._watchers = GraphWatchers()

        def onPatch(p):

            """

            central server has sent us a patch

            """

            patchQuads(_graph, p.delQuads, p.addQuads, perfect=True)

            log.info("graph now has %s statements" % len(_graph))

            try:

                self.updateOnPatch(p)

            except Exception:

                # don't reflect this back to the server; we did

                # receive its patch correctly.

                traceback.print_exc()

        listen = reactor.listenTCP(0, cyclone.web.Application(handlers=[

            (r'/update', makePatchEndpoint(onPatch)),

        ]))

        port = listen._realPortNumber  # what's the right call for this?

        self.updateResource = 'http://localhost:%s/update' % port

        log.info("listening on %s" % port)

        self.register(label)

        self.currentFuncs = [] # stack of addHandler callers

        self._sender = PatchSender('http://localhost:8051/patches',

                                   self.updateResource)

    def resync(self):

        """

        get the whole graph again from the server (e.g. we had a

        conflict while applying a patch and want to return to the

        truth).

        To avoid too much churn, we remember our old graph and diff it

        against the replacement. This way, our callers only see the

        corrections.

        Edits you make during a resync will surely be lost, so I

        should just fail them. There should be a notification back to

        UIs who want to show that we're doing a resync.

        """

        return cyclone.httpclient.fetch(

            url="http://localhost:8051/graph",

            method="GET",

            headers={'Accept':'x-trig'},

            ).addCallback(self._resyncGraph)

    def _resyncGraph(self, response):

        pass

        #diff against old entire graph

        #broadcast that change

    def register(self, label):

        def done(x):

            log.debug("registered with rdfdb")

        cyclone.httpclient.fetch(

            url='http://localhost:8051/graphClients',

            method='POST',

            headers={'Content-Type': ['application/x-www-form-urlencoded']},

            postdata=urllib.urlencode([('clientUpdate', self.updateResource),

                                       ('label', label)]),

            ).addCallbacks(done, log.error)

        log.info("registering with rdfdb")

    def patch(self, p):

        """send this patch to the server and apply it to our local

        graph and run handlers"""

        # these could fail if we're out of sync. One approach:

        # Rerequest the full state from the server, try the patch

        # again after that, then give up.

        patchQuads(self._graph, p.delQuads, p.addQuads, perfect=True)

        self.updateOnPatch(p)

        self._sender.sendPatch(p).addErrback(self.sendFailed)

    def sendFailed(self, result):

        """

        we asked for a patch to be queued and sent to the master, and

        that ultimately failed because of a conflict

        """

        #i think we should receive back all the pending patches,

        #do a resysnc here,

        #then requeue all the pending patches (minus the failing one?) after that's done.

    def patchObject(self, context, subject, predicate, newObject):

        """send a patch which removes existing values for (s,p,*,c)

        and adds (s,p,newObject,c). Values in other graphs are not affected"""

        existing = []

        for spo in self._graph.triples((subject, predicate, None),

                                     context=context):

            existing.append(spo+(context,))

        # what layer is supposed to cull out no-op changes?

        self.patch(Patch(

            delQuads=existing,

            addQuads=[(subject, predicate, newObject, context)]))

    def patchMapping(self, context, subject, predicate, keyPred, valuePred, newKey, newValue):

        """

        proposed api for updating things like ?session :subSetting [

        :sub ?s; :level ?v ]. Keyboardcomposer has an implementation

        already. There should be a complementary readMapping that gets

        you a value since that's tricky too

        """

    def addHandler(self, func):

        """

        run this (idempotent) func, noting what graph values it

        uses. Run it again in the future if there are changes to those

        graph values. The func might use different values during that

        future call, and those will be what we watch for next.

        """

        # if we saw this func before, we need to forget the old

        # callbacks it wanted and replace with the new ones we see

        # now.

        # if one handler func calls another, does that break anything?

        # maybe not?

        # no plan for sparql queries yet. Hook into a lower layer that

        # reveals all their statement fetches? Just make them always

        # new? Cache their results, so if i make the query again and

        # it gives the same result, I don't call the handler?

        self.currentFuncs.append(func)

        try:

            func()

        finally:

            self.currentFuncs.pop()

    def updateOnPatch(self, p):

        """

        patch p just happened to the graph; call everyone back who

        might care, and then notice what data they depend on now

        """

        for func in self._watchers.whoCares(p):

            # todo: forget the old handlers for this func

            self.addHandler(func)

    def currentState(self, context=None):

        """

        a graph you can read without being in an addHandler

<?xml version="1.0" encoding="utf8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"

"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

  <head>

    <title>rdfdb</title>

    <link rel="stylesheet" type="text/css" href="style.css"/>

  </head>

  <body>

    <h1>rdfdb</h1>

    <p>status: <span id="status">starting...</span></p>

    <section>

      <h2>Edits</h2>

      <div id="patches"></div>

    </section>

    <p>Clients: <span id="clients"/></p>

    <fieldset>

      <legend>Messages</legend>

      <div id="out"></div>

    </fieldset>

    <script type="text/javascript" src="lib/jquery-1.7.2.min.js"></script>

    <script type="text/javascript" src="websocket.js"></script>

    <script type="text/javascript">

      // <![CDATA[

      $(function(){

          function onMessage(d) {

              if (d.clients !== undefined) {

                  $("#clients").empty().text(JSON.stringify(d.clients));

              }

              if (d.patch !== undefined) {

                  $("#patches").prepend(

                      $("<fieldset>").addClass("patch")

                          .append($("<legend>").text("Patch"))

                  );

              }

              $('#out').append($('<div>').text(JSON.stringify(d)));

          }

          reconnectingWebSocket("ws://localhost:8051/live", onMessage);

      });

      // ]]>

    </script>

  </body>

</html>

"""all the tiny tk helper functions"""

from __future__ import nested_scopes

windowlocations = {

    'sub' : '425x738+00+00',

    'console' : '168x24+848+000',

    'leveldisplay' : '144x340+870+400',

    'cuefader' : '314x212+546+741',