self.write('')

    @inlineCallbacks

    def post(self):

        self.wideOpenCors()

        dropped = URIRef(self.get_argument('drop'))

        try:

            song = URIRef(self.get_argument('uri'))

        except Exception: # which?

            song = yield currentSong()

        log.info("adding to %s", song)

        p = yield songEffectPatch(self.settings.graph, dropped, song, event, ctx=song)

        self.settings.graph.patch(p)

class SongEffectsUpdates(cyclone.websocket.WebSocketHandler):

    def connectionMade(self, *args, **kwargs):

        self.graph = self.settings.graph

        self.graph.addHandler(self.updateClient)

    def updateClient(self):

def clamp(x, lo, hi):

    return max(lo, min(hi, x))

@inlineCallbacks

def getMusicStatus():

    returnValue(json.loads((yield cyclone.httpclient.fetch(

        networking.musicPlayer.path('time'), timeout=.5)).body))

@inlineCallbacks

def songEffectPatch(graph, dropped, song, event, ctx):

    with graph.currentState(

            tripleFilter=(dropped, None, None)) as g:

        droppedTypes = list(g.objects(dropped, RDF.type))

        droppedLabel = g.label(dropped)

        droppedCodes = list(g.objects(dropped, L9['code']))

    quads = []

    fade = 2 if event == 'default' else 0

    if _songHasEffect(graph, song, dropped):

        # bump the existing curve

        pass

import logging, traceback, time, itertools

from rdflib import ConjunctiveGraph

from light9.rdfdb.rdflibpatch import contextsForStatement as rp_contextsForStatement

log = logging.getLogger("currentstate")

class ReadOnlyConjunctiveGraph(object):

    """similar to rdflib's ReadOnlyGraphAggregate but takes one CJ in, instead

    of a bunch of Graphs"""

    def __init__(self, graph):

        self.graph = graph

    def __getattr__(self, attr):

            return getattr(self.graph, attr)

        raise TypeError("can't access %r of read-only graph" % attr)

class CurrentStateGraphApi(object):

    """

    mixin for SyncedGraph, separated here because these methods work together

    """

    def currentState(self, context=None, tripleFilter=(None, None, None)):

        """

        a graph you can read without being in an addHandler

                       addQuads=p.addQuads,

                       perfect=True)

        except ValueError as e:

            log.error(e)

            self.sendFailed(None)

            return

        log.debug('runDepsOnNewPatch')

        self.runDepsOnNewPatch(p)

        log.debug('sendPatch')

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

        log.debug('patch is done %s', debugKey)

    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

        """

        log.warn("sendFailed")

        self.resync()

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

        #do a resync here,

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

    ]

model = new Model()

model.addToCurrentSong = (e) ->

  $.ajax({

    type: 'POST'

    url: '/effectEval/songEffects'

    data: {drop: e.uri}

  })

reconnectingWebSocket "../effectsUpdates", (msg) ->

  model.chases(msg.chases) if msg.chases?

  model.classes(msg.classes) if msg.classes?

# this sort of works to stop clicks in <input> from following the

# submaster hyperlink, but it may make certain clicks act wrong

$(document).on('click', 'a', (ev) ->

  return false if ev.target.tagName == 'INPUT'

)

ko.applyBindings(model)

        a(data-bind="attr: {href: uri}, text: label")

        ul(data-bind="foreach: $parent.subtermExprs($data)")

          li: a.resource(data-bind="attr: {href: $root.subtermLink($parent.label, $data)}, text: $data")

    div(data-bind="foreach: classes")

      div.resource.effectClass

        h2

          | Effect class

          | 

          a(data-bind="attr: {href: uri}, text: label")

          button(data-bind="click: $root.addToCurrentSong") Add to current song

        div

          code(data-bind="text: code")

    #status

    script(src="/lib/jquery/dist/jquery.min.js")

    script(src="/lib/knockout/dist/knockout.js")

    script(src="/websocket.js")

    script(src="effects.js")

@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

show:dance2017 :musicRoot "show/dance2016/music/pad";

:spectrogramUrlRoot "/show/dance2016/spectrogram" .

show:dance2017 :playList (

  sh:song1  sh:song2  sh:song3  sh:song4  sh:song5

  sh:song6  sh:song7  sh:song8  sh:song9  sh:song10

  sh:song11 sh:song12 sh:song13 sh:song14 sh:song15

  sh:song16 sh:song17 sh:song18

) .