self.sub.graph.patchMapping(context=self.session,

                                    subject=self.session,

                                    predicate=L9['subSetting'],

                                    nodeClass=L9['SubSetting'],

                                    keyPred=L9['sub'], newKey=uri,

                                    valuePred=L9['level'], newValue=Literal(level))

"""

subcomposer

  session

  observable(currentSub), a Submaster which tracks the graph

    EditChoice widget

      can change currentSub to another sub

    Levelbox widget

      watch observable(currentSub) for a new sub, and also watch currentSub for edits to push to the OneLevel widgets

        OneLevel widget

          UI edits are caught here and go all the way back to currentSub

"""

import time, logging

from light9 import dmxclient, Patch, Submaster, prof

        print "chg", newUri

    I'm not sure that Locals should even be PersistentSubmaster with

    uri and graph storage, but I think that way is making fewer

    special cases.

    Dependencies:

      graph (?session :currentSub ?s) -> self.currentSub

      self.currentSub -> graph

      self.currentSub -> self._currentChoice (which might be Local)

      self._currentChoice (which might be Local) -> self.currentSub

      inside the current sub:

      graph -> Submaster levels (handled in Submaster)

      Submaster levels -> OneLevel widget

      OneLevel widget -> Submaster.editLevel

      Submaster.editLevel -> graph (handled in Submaster)

        # this is a PersistentSubmaster (even for local) or None if we're not initialized

        self.currentSub = Observable(None)

        currentUri = Observable("http://curr")

            print "change viewed sub to", val

        EditChoice(self, self.graph, self._currentChoice).frame.pack(side='top')

    def setupSubChoiceLinks(self):

        def ann():

            print "currently: session=%s currentSub=%r _currentChoice=%r" % (

                self.session, self.currentSub(), self._currentChoice())

        @graph.addHandler

        def graphChanged():

            s = graph.value(self.session, L9['currentSub'])

            if s is None:

                s = self.makeLocal()

            self.currentSub(Submaster.PersistentSubmaster(graph, s))

        @self.currentSub.subscribe

        def subChanged(newSub):

            if newSub is None:

                graph.patchObject(self.session,

                                  self.session, L9['currentSub'], None)

                return

            self.sendupdate()

            graph.patchObject(self.session,

                              self.session, L9['currentSub'], newSub.uri)

            if newSub and 'local' in newSub.uri: # wrong- use rdf:type or something?

                self._currentChoice(Local)

            else:

                # i think right here is the point that the last local

                # becomes garbage, and we could clean it up. 

                self._currentChoice(newSub.uri)

        dispatcher.connect(self.levelsChanged, "sub levels changed")

        @self._currentChoice.subscribe

        def choiceChanged(newChoice):

            if newChoice is Local:

                newChoice = self.makeLocal()

            if newChoice is not None:

                self.currentSub(Submaster.PersistentSubmaster(

                    graph, newChoice))

    def levelsChanged(self, sub):

        if sub == self.currentSub():

            self.sendupdate()

    def makeLocal(self):

        # todo: put a type on this, so subChanged can identify it right

        # todo: where will these get stored, or are they local to this

        # subcomposer process and don't use PersistentSubmaster at all?

        return URIRef("http://local/%s" % time.time())

    def setupLevelboxUi(self):

        self.levelbox = Levelbox(self, graph, self.currentSub)

        self.levelbox.pack(side='top')

        tk.Button(self, text="All to zero",

             command=lambda *args: self.currentSub().clear()).pack(side='top')

        d = self.currentSub().get_dmx_list()

        dmxclient.outputlevels(d, twisted=True)

def launch(opts, args, root, graph, session):

    if not opts.no_geometry:

        toplevelat("subcomposer - %s" % opts.session, root, graph, session)

    sc = Subcomposer(root, graph, session)

    sc.pack()

    tk.Label(root,text="Bindings: B1 adjust level; B2 set full; B3 instant bump",

             font="Helvetica -12 italic",anchor='w').pack(side='top',fill='x')

    if len(args) == 1:

        # it might be a little too weird that cmdline arg to this

        # process changes anything else in the same session. But also

        # I'm not sure who would ever make 2 subcomposers of the same

        # session (except when quitting and restarting, to get the

        # same window pos), so maybe it doesn't matter. But still,

        # this tool should probably default to making new sessions

        # usually instead of loading the same one

        print "sub", self.cmd, subname

    task.LoopingCall(sc.sendupdate).start(10)

    parser = OptionParser(usage="%prog [suburi]")

    logging.basicConfig(level=logging.DEBUG)

    graph.initiallySynced.addCallback(lambda _: launch(opts, args, root, graph, session))

    """mapping of channels to levels"""

        if not isinstance(other, Submaster):

            return -1

                log.error("error trying to compute dmx levels for submaster %s"

                          % self.name)

        if uri is None:

            raise TypeError("uri must be URIRef")

            # dispatcher too? this would help subcomposer

            dispatcher.send("sub levels changed", sub=self)

            log.debug(" lightLevel %s %s", self.uri, lev)

                log.error("sub %r has channel %r with no name- "

                          "leaving out that channel" % (self.name, chan))

            if val is None:

                raise ValueError("sub %r has lightLevel %r with channel %r "

                                 "and level %r" % (self.uri, lev, chan, val))

            log.debug("   new val %r", val)

            try:

                self.levels[name] = float(val)

            except:

                log.error("name %r val %r" % (name, val))

                raise

    def saveContext(self):

        """the context in which we should save all the lightLevel triples for

        this sub"""

        with self.graph.currentState() as g:

            try:

                ctx = g.contextsForStatement(

                    (self.uri, RDF.type, L9['Submaster']))[0]

            except IndexError:

                raise ValueError(

                    "no context has %s rdf:type :Submaster, "

                    "so I don't know where to save this sub's data" % self.uri)

        return ctx

    def editLevel(self, chan, newLevel):

        self.graph.patchMapping(self.saveContext(),

                                subject=self.uri, predicate=L9['lightLevel'],

                                nodeClass=L9['ChannelSetting'],

                                keyPred=L9['channel'], newKey=chan,

                                valuePred=L9['level'],

                                newValue=Literal(newLevel))

    def clear(self):

        """set all levels to 0"""

        with self.graph.currentState() as g:

            levs = list(g.objects(self.uri, L9['lightLevel']))

        for lev in levs:

            self.graph.removeMappingNode(self.saveContext(), lev)

        raise NotImplementedError("obsolete?")

                log.error("saving dmx channels with no :Channel node "

                          "is not supported yet. Give channel %s a URI "

                          "for it to be saved. Omitting this channel "

                          "from the sub." % chan)

from rdflib import RDF, Literal

    and the level is like this:

       ?editor :currentSub ?sub .

       ?sub :lightLevel [:channel ?ch; :level ?level] .

    levels come in with self.setTo and go out by the onLevelChange

    callback. This object does not use the graph for level values,

    which I'm doing for what I think is efficiency. Unclear why I

    didn't use Observable for that API.

    def __init__(self, parent, graph, channelUri, onLevelChange):

        self.onLevelChange = onLevelChange

        self.currentLevel = 0 # the level we're displaying, 0..1

            self._start_lev=self.currentLevel

            self.setlevel(max(0, min(1, self._start_lev+delta*.005)))

        """UI received a level change, which we put in the graph"""

        self.onLevelChange(self.uri, newlev)

    def setTo(self, newLevel):

        """levelbox saw a change in the graph"""

        self.currentLevel = min(1, max(0, newLevel))

        newLevel = "%d" % (self.currentLevel * 100)

        if newLevel != olddisplay:

            self.level_lab.config(text=newLevel)

    """

    this also watches all the levels in the sub and sets the boxes when they change

    """

    def __init__(self, parent, graph, currentSub):

        """

        currentSub is an Observable(PersistentSubmaster)

        """

        self.currentSub = currentSub

        self.currentSub.subscribe(lambda _: graph.addHandler(self.updateLevelValues))

        self.levelFromUri = {} # channel : OneLevel

            f = Onelevel(columnFrames[i // rows], self.graph, channel,

                         self.onLevelChange)

            self.levelFromUri[channel] = f

            f.pack(side='top')

    def updateLevelValues(self):

        """set UI level from graph"""

        submaster = self.currentSub()

        if submaster is None:

            return

        sub = submaster.uri

        if sub is None:

            raise ValueError("currentSub is %r" % submaster)

        remaining = set(self.levelFromUri.keys())

        for ll in self.graph.objects(sub, L9['lightLevel']):

            chan = self.graph.value(ll, L9['channel'])

            lev = self.graph.value(ll, L9['level']).toPython()

            self.levelFromUri[chan].setTo(lev)

            remaining.remove(chan)

        for channel in remaining:

            self.levelFromUri[channel].setTo(0)

    def onLevelChange(self, chan, newLevel):

        """UI received a change which we put in the graph"""

        if self.currentSub() is None:

            raise ValueError("no currentSub in Levelbox")

        self.currentSub().editLevel(chan, newLevel)

import Tkinter as tk

from rdflib import URIRef

from light9.tkdnd import dragSourceRegister, dropTargetRegister

class Local(object):

    """placeholder for the local uri that EditChoice does not

    manage. Set resourceObservable to Local to indicate that you're

    unlinked"""

class EditChoice(tk.Frame):

    """

    Observable <-> linker UI

    widget for tying some UI to a shared resource for editing, or

    unlinking it (which means associating it with a local resource

    that's not named or shared). This object does not own the choice

    of resource; the caller does.

    UI actions:

    - drag a uri on here to make it the one we're editing

    - button to clear the currentSub (putting it back to

      sessionLocalSub, and also resetting sessionLocalSub to be empty

      again)

    - drag the sub uri off of here to send it to another receiver,

      but, if we're in local mode, the local sub should not be so

      easily addressable. Maybe you just can't drag it off.

    Todo:

    - filter by type so you can't drag a curve onto a subcomposer

    - 'save new' : make a new sub: transfers the current data (from a shared sub or

      from the local one) to the new sub. If you're on a local sub,

      the new sub is named automatically, ideally something brief,

      pretty distinct, readable, and based on the lights that are

      on. If you're on a named sub, the new one starts with a

      'namedsub 2' style name. The uri can also be with a '2' suffix,

      although maybe that will be stupid. If you change the name

      before anyone knows about this uri, we could update the current

      sub's uri to a slug of the new label.

    - rename this sub: not available if you're on a local sub. Sets

      the label of a named sub. Might update the uri of the named sub

      if it's new enough that no one else would have that uri. Not

      sure where we measure that 'new enough' value. Maybe track if

      the sub has 'never been dragged out of this subcomposer

      session'? But subs will also show up in other viewers and

      finders.

    - list of recent resources that this choice was set to

    """

    def __init__(self, parent, graph, resourceObservable):

        """

        getResource is called to get the URI of the currently

        """

        self.graph = graph

        self.frame = tk.Frame(parent, relief='raised', border=2)

        self.frame.pack(side='top')

        tk.Label(self.frame, text="Editing:").pack(side='left')

        self.currentLinkFrame = tk.Frame(self.frame)

        self.currentLinkFrame.pack(side='left')

        self.subIcon = tk.Label(self.currentLinkFrame, text="...",

                                borderwidth=2, relief='raised',

                                padx=10, pady=10)

        self.subIcon.pack()

        self.resourceObservable = resourceObservable

        resourceObservable.subscribe(self.uriChanged)

        # when the value is local, this should stop being a drag source

        dragSourceRegister(self.subIcon, 'copy', 'text/uri-list',

                           self.resourceObservable)

        def onEv(ev):

            self.resourceObservable(URIRef(ev.data))

            return "link"

        self.onEv = onEv

        b=tk.Button(self.frame, text="Unlink", command=self.switchToLocalSub)

        b.pack(side='left')

        # it would be nice if I didn't receive my own drags here, and

        # if the hover display wasn't per widget

        for target in ([self.frame, self.currentLinkFrame] +

                       self.frame.winfo_children() +

                       self.currentLinkFrame.winfo_children()):

            dropTargetRegister(target, typeList=["*"], onDrop=onEv,

                               hoverStyle=dict(background="#555500"))

    def uriChanged(self, newUri):

        # if this resource had a type icon or a thumbnail, those would be

        # cool to show in here too

        if newUri is Local:

            self.subIcon.config(text="(local)")

        else:

            self.graph.addHandler(self.updateLabel)

    def updateLabel(self):

        uri = self.resourceObservable()

        print "get label", repr(uri)

        label = self.graph.label(uri)

        self.subIcon.config(text=label or uri)

    def switchToLocalSub(self):

        self.resourceObservable(Local)

class _NoNewVal(object):

    pass

class Observable(object):

    """

    like knockout's observable. Hopefully this can be replaced by a

    better python one

    compare with:

    http://knockoutjs.com/documentation/observables.html

    https://github.com/drpancake/python-observable/blob/master/observable/observable.py

    """

    def __init__(self, val):

        self.val = val

        self.subscribers = set()

    def __call__(self, newVal=_NoNewVal):

        if newVal is _NoNewVal:

            return self.val

        if newVal == self.val:

            print "%r unchanged from %r" % (newVal, self.val)

            return

        self.val = newVal

        for s in self.subscribers:

            s(newVal)

    def subscribe(self, cb, callNow=True):

        """cb is called with new values, and also right now with the

        current value unless you opt out"""

        self.subscribers.add(cb)

        if callNow:

            cb(self.val)

            if self._addGraph is not None:

                self._addQuads = list(self._addGraph.quads(ALLSTMTS))

            else:

                raise

            if self._delGraph is not None:

                self._delQuads = list(self._delGraph.quads(ALLSTMTS))

            else:

                raise

from rdflib import ConjunctiveGraph, RDFS, RDF, URIRef

import logging, cyclone.httpclient, traceback, urllib, random

from itertools import chain

from light9.rdfdb.patch import Patch

from light9.rdfdb.rdflibpatch import patchQuads, contextsForStatement as rp_contextsForStatement

# everybody who writes literals needs to get this

from rdflibpatch_literal import patch

patch()

    You may want to attach to self.initiallySynced deferred so you

    don't attempt patches before we've heard the initial contents of

    the graph. It would be ok to accumulate some patches of new

    material, but usually you won't correctly remove the existing

    statements unless we have the correct graph.

        self.initiallySynced = defer.Deferred()

            if self.initiallySynced:

                self.initiallySynced.callback(None)

                self.initiallySynced = None

        log.info("%s add %s", [q[2] for q in p.delQuads], [q[2] for q in  p.addQuads])

        print "sendFailed"

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

        newObject can be None, which will remove all (subj,pred,*) statements.

        """

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