--- a/.pdm.toml	Thu Jun 08 15:05:59 2023 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2 +0,0 @@
-[python]
-path = "/usr/bin/python3.10"

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/bcf_puppet_demo	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,17 @@
+#!/usr/bin/python
+"""
+tiny bcf2000 controller demo
+"""
+from bcf2000 import BCF2000
+from twisted.internet import reactor
+
+
+class PuppetSliders(BCF2000):
+
+    def valueIn(self, name, value):
+        if name == 'slider1':
+            self.valueOut('slider5', value)
+
+
+b = PuppetSliders()
+reactor.run()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/bumppad	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,89 @@
+#!bin/python
+
+import sys, time, math
+import tkinter as tk
+
+import run_local
+import light9.dmxclient as dmxclient
+from light9.TLUtility import make_attributes_from_args
+
+from light9.Submaster import Submaster, sub_maxes
+
+
+class pad(tk.Frame):
+    levs = None  # Submaster : level
+
+    def __init__(self, master, root, mag):
+        make_attributes_from_args('master', 'mag')
+        tk.Frame.__init__(self, master)
+        self.levs = {}
+        for xy, key, subname in [
+            ((1, 1), 'KP_Up', 'centered'),
+            ((1, 3), "KP_Down", 'third-c'),
+            ((0, 2), 'KP_Left', 'scoop-l'),
+            ((2, 2), 'KP_Right', 'scoop-r'),
+            ((1, 0), 'KP_Divide', 'cyc'),
+            ((0, 3), "KP_End", 'hottest'),
+            ((2, 3), 'KP_Next', 'deepblues'),
+            ((0, 4), 'KP_Insert', "zip_red"),
+            ((2, 4), 'KP_Delete', "zip_orange"),
+            ((3, 1), 'KP_Add', 'strobedim'),
+            ((3, 3), 'KP_Enter', 'zip_blue'),
+            ((1, 2), 'KP_Begin', 'scoop-c'),
+        ]:
+
+            sub = Submaster(subname)
+            self.levs[sub] = 0
+
+            l = tk.Label(self,
+                         font="arial 12 bold",
+                         anchor='w',
+                         height=2,
+                         relief='groove',
+                         bd=5,
+                         text="%s\n%s" % (key.replace('KP_', ''), sub.name))
+            l.grid(column=xy[0], row=xy[1], sticky='news')
+
+            root.bind(
+                "<KeyPress-%s>" % key, lambda ev, sub=sub: self.bumpto(sub, 1))
+            root.bind("<KeyRelease-%s>" % key,
+                      lambda ev, sub=sub: self.bumpto(sub, 0))
+
+    def bumpto(self, sub, lev):
+        now = time.time()
+        self.levs[sub] = lev * self.mag.get()
+        self.master.after_idle(self.output)
+
+    def output(self):
+        dmx = sub_maxes(*[s * l
+                          for s, l in list(self.levs.items())]).get_dmx_list()
+        dmxclient.outputlevels(dmx, clientid="bumppad")
+
+
+root = tk.Tk()
+root.tk_setPalette("maroon4")
+root.wm_title("bumppad")
+mag = tk.DoubleVar()
+
+tk.Label(root,
+         text="Keypad press/release activate sub; 1..5 set mag",
+         font="Helvetica -12 italic",
+         anchor='w').pack(side='bottom', fill='x')
+
+pad(root, root, mag).pack(side='left', fill='both', exp=1)
+
+magscl = tk.Scale(root,
+                  orient='vertical',
+                  from_=1,
+                  to=0,
+                  res=.01,
+                  showval=1,
+                  variable=mag,
+                  label='mag',
+                  relief='raised',
+                  bd=1)
+for i in range(1, 6):
+    root.bind("<Key-%s>" % i, lambda ev, i=i: mag.set(math.sqrt((i) / 5)))
+magscl.pack(side='left', fill='y')
+
+root.mainloop()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/captureDevice	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,199 @@
+#!bin/python
+"""
+Operate a motorized light and take pictures of it in every position.
+"""
+from rdflib import URIRef
+from twisted.internet import reactor
+from twisted.internet.defer import inlineCallbacks, Deferred
+
+import logging
+import optparse
+import os
+import time
+import treq
+import cyclone.web, cyclone.websocket, cyclone.httpclient
+from light9.metrics import metrics, metricsRoute
+from run_local import log
+from cycloneerr import PrettyErrorHandler
+
+from light9.namespaces import L9, RDF
+from light9 import networking, showconfig
+from rdfdb.syncedgraph import SyncedGraph
+from light9.paint.capture import writeCaptureDescription
+from light9.effect.settings import DeviceSettings
+from light9.collector.collector_client import sendToCollector
+from rdfdb.patch import Patch
+from light9.zmqtransport import parseJsonMessage
+
+
+
+class Camera(object):
+
+    def __init__(self, imageUrl):
+        self.imageUrl = imageUrl
+
+    def takePic(self, uri, writePath):
+        log.info('takePic %s', uri)
+        return treq.get(
+            self.imageUrl).addCallbacks(lambda r: self._done(writePath, r),
+                                        log.error)
+
+    @inlineCallbacks
+    def _done(self, writePath, response):
+        jpg = yield response.content()
+        try:
+            os.makedirs(os.path.dirname(writePath))
+        except OSError:
+            pass
+        with open(writePath, 'w') as out:
+            out.write(jpg)
+        log.info('wrote %s', writePath)
+
+
+def deferSleep(sec):
+    d = Deferred()
+    reactor.callLater(sec, d.callback, None)
+    return d
+
+
+class Capture(object):
+    firstMoveTime = 3
+    settleTime = .5
+
+    def __init__(self, graph, dev):
+        self.graph = graph
+        self.dev = dev
+
+        def steps(a, b, n):
+            return [round(a + (b - a) * i / n, 5) for i in range(n)]
+
+        startTime = time.time()
+        self.captureId = 'cap%s' % (int(startTime) - 1495170000)
+        self.toGather = []
+
+        #quantum
+        rxSteps = steps(.06, .952, 10)
+        rySteps = steps(0.1, .77, 5)
+        zoomSteps = steps(.12, .85, 3)
+        # aura
+        rxSteps = steps(0.15, .95, 10)
+        rySteps = steps(0, .9, 5)
+        zoomSteps = steps(.6, .9, 3)
+
+        row = 0
+        for ry in rySteps:
+            xSteps = rxSteps[:]
+            if row % 2:
+                xSteps.reverse()
+            row += 1
+            for rx in xSteps:
+                for zoom in zoomSteps:
+                    self.toGather.append(
+                        DeviceSettings(
+                            graph,
+                            [
+                                (dev, L9['rx'], rx),
+                                (dev, L9['ry'], ry),
+                                (dev, L9['color'], '#ffffff'),
+                                (dev, L9['zoom'], zoom),
+                                #(dev, L9['focus'], 0.13),
+                            ]))
+
+        self.devTail = dev.rsplit('/')[-1]
+        self.session = URIRef('/'.join(
+            [showconfig.showUri(), 'capture', self.devTail, self.captureId]))
+        self.ctx = URIRef(self.session + '/index')
+
+        self.graph.patch(
+            Patch(addQuads=[
+                (self.session, RDF.type, L9['CaptureSession'], self.ctx),
+            ]))
+
+        self.numPics = 0
+        self.settingsCache = set()
+        self.step().addErrback(log.error)
+
+    def off(self):
+        return sendToCollector(client='captureDevice',
+                               session='main',
+                               settings=DeviceSettings(self.graph, []))
+
+    @inlineCallbacks
+    def step(self):
+        if not self.toGather:
+            yield self.off()
+            yield deferSleep(1)
+            reactor.stop()
+            return
+        settings = self.toGather.pop()
+
+        log.info('[%s left] move to %r', len(self.toGather), settings)
+        yield sendToCollector(client='captureDevice',
+                              session='main',
+                              settings=settings)
+
+        yield deferSleep(self.firstMoveTime if self.numPics ==
+                         0 else self.settleTime)
+
+        picId = 'pic%s' % self.numPics
+        path = '/'.join(['capture', self.devTail, self.captureId, picId
+                        ]) + '.jpg'
+        uri = URIRef(self.session + '/' + picId)
+
+        yield camera.takePic(uri, os.path.join(showconfig.root(), path))
+        self.numPics += 1
+
+        writeCaptureDescription(self.graph, self.ctx, self.session, uri,
+                                self.dev, path, self.settingsCache, settings)
+
+        reactor.callLater(0, self.step)
+
+
+camera = Camera(
+    'http://plus:8200/picamserve/pic?res=1080&resize=800&iso=800&redgain=1.6&bluegain=1.6&shutter=60000&x=0&w=1&y=0&h=.952'
+)
+
+
+class Attrs(PrettyErrorHandler, cyclone.web.RequestHandler):
+
+    @metrics('set_attr').time()
+    def put(self):
+        client, clientSession, settings, sendTime = parseJsonMessage(
+            self.request.body)
+        self.set_status(202)
+
+
+def launch(graph):
+
+    cap = Capture(graph, dev=L9['device/aura5'])
+    reactor.listenTCP(networking.captureDevice.port,
+                      cyclone.web.Application(handlers=[
+                          (r'/()', cyclone.web.StaticFileHandler, {
+                              "path": "light9/web",
+                              "default_filename": "captureDevice.html"
+                          }),
+                          metricsRoute(),
+                      ]),
+                      interface='::',
+                      cap=cap)
+    log.info('serving http on %s', networking.captureDevice.port)
+
+
+def main():
+    parser = optparse.OptionParser()
+    parser.add_option("-v",
+                      "--verbose",
+                      action="store_true",
+                      help="logging.DEBUG")
+    (options, args) = parser.parse_args()
+    log.setLevel(logging.DEBUG if options.verbose else logging.INFO)
+
+    graph = SyncedGraph(networking.rdfdb.url, "captureDevice")
+
+    graph.initiallySynced.addCallback(lambda _: launch(graph)).addErrback(
+        log.error)
+    reactor.run()
+
+
+if __name__ == '__main__':
+    main()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/curvecalc	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,574 @@
+#!bin/python
+"""
+now launches like this:
+% bin/curvecalc http://light9.bigasterisk.com/show/dance2007/song1
+
+
+
+todo: curveview should preserve more objects, for speed maybe
+
+"""
+
+import sys
+import imp
+sys.path.append('/usr/lib/python2.7/dist-packages')  # For gtk
+from twisted.internet import gtk3reactor
+gtk3reactor.install()
+from twisted.internet import reactor
+
+import time, textwrap, os, optparse, linecache, signal, traceback, json
+import gi
+from gi.repository import Gtk
+from gi.repository import GObject
+from gi.repository import Gdk
+
+from urllib.parse import parse_qsl
+import louie as dispatcher
+from rdflib import URIRef, Literal, RDF, RDFS
+import logging
+
+from run_local import log
+from light9 import showconfig, networking
+from light9.curvecalc import curveview
+from light9.curvecalc.curve import Curveset
+from light9.curvecalc.curveedit import serveCurveEdit
+from light9.curvecalc.musicaccess import Music
+from light9.curvecalc.output import Output
+from light9.curvecalc.subterm import Subterm
+from light9.curvecalc.subtermview import add_one_subterm
+from light9.editchoicegtk import EditChoice, Local
+from light9.gtkpyconsole import togglePyConsole
+from light9.namespaces import L9
+from light9.observable import Observable
+from light9 import clientsession
+from rdfdb.patch import Patch
+from rdfdb.syncedgraph import SyncedGraph
+from light9.wavelength import wavelength
+
+
+class SubtermExists(ValueError):
+    pass
+
+
+class Main(object):
+
+    def __init__(self, graph, opts, session, curveset, music):
+        self.graph, self.opts, self.session = graph, opts, session
+        self.curveset, self.music = curveset, music
+        self.lastSeenInputTime = 0
+        self.currentSubterms = [
+        ]  # Subterm objects that are synced to the graph
+
+        self.setTheme()
+        wtree = self.wtree = Gtk.Builder()
+        wtree.add_from_file("light9/curvecalc/curvecalc.glade")
+        mainwin = wtree.get_object("MainWindow")
+
+        mainwin.connect("destroy", self.onQuit)
+        wtree.connect_signals(self)
+
+        mainwin.show_all()
+
+        mainwin.connect("delete-event", lambda *args: reactor.crash())
+
+        def updateTitle():
+            mainwin.set_title(
+                "curvecalc - %s" %
+                graph.label(graph.value(session, L9['currentSong'])))
+
+        graph.addHandler(updateTitle)
+
+        songChoice = Observable(None)  # to be connected with the session song
+
+        self.registerGraphToSongChoice(wtree, session, graph, songChoice)
+        self.registerSongChoiceToGraph(session, graph, songChoice)
+        self.registerCurrentPlayerSongToUi(wtree, graph, songChoice)
+
+        ec = EditChoice(graph, songChoice, label="Editing song:")
+        wtree.get_object("currentSongEditChoice").add(ec)
+        ec.show()
+
+        wtree.get_object("subterms").connect("add", self.onSubtermChildAdded)
+
+        self.refreshCurveView()
+
+        self.makeStatusLines(wtree.get_object("status"))
+        self.setupNewSubZone()
+        self.acceptDragsOnCurveViews()
+
+        # may not work
+        wtree.get_object("paned1").set_position(600)
+
+    def registerGraphToSongChoice(self, wtree, session, graph, songChoice):
+
+        def setSong():
+            current = graph.value(session, L9['currentSong'])
+            if not wtree.get_object("followPlayerSongChoice").get_active():
+                songChoice(current)
+                dispatcher.send("song_has_changed")
+
+        graph.addHandler(setSong)
+
+    def registerSongChoiceToGraph(self, session, graph, songChoice):
+        self.muteSongChoiceUntil = 0
+
+        def songChoiceToGraph(newSong):
+            if newSong is Local:
+                raise NotImplementedError('what do i patch')
+            log.debug('songChoiceToGraph is going to set to %r', newSong)
+
+            # I get bogus newSong values in here sometimes. This
+            # workaround may not even be helping.
+            now = time.time()
+            if now < self.muteSongChoiceUntil:
+                log.debug('muted')
+                return
+            self.muteSongChoiceUntil = now + 1
+
+            graph.patchObject(context=session,
+                              subject=session,
+                              predicate=L9['currentSong'],
+                              newObject=newSong)
+
+        songChoice.subscribe(songChoiceToGraph)
+
+    def registerCurrentPlayerSongToUi(self, wtree, graph, songChoice):
+        """current_player_song 'song' param -> playerSong ui
+        and
+        current_player_song 'song' param -> songChoice, if you're in autofollow
+        """
+
+        def current_player_song(song):
+            # (this is run on every frame)
+            ps = wtree.get_object("playerSong")
+            if URIRef(ps.get_uri()) != song:
+                log.debug("update playerSong to %s", ps.get_uri())
+
+                def setLabel():
+                    ps.set_label(graph.label(song))
+
+                graph.addHandler(setLabel)
+                ps.set_uri(song)
+            if song != songChoice():
+                if wtree.get_object("followPlayerSongChoice").get_active():
+                    log.debug('followPlayerSongChoice is on')
+                    songChoice(song)
+
+        dispatcher.connect(current_player_song, "current_player_song")
+        self.current_player_song = current_player_song
+
+    def setupNewSubZone(self):
+        self.wtree.get_object("newSubZone").drag_dest_set(
+            flags=Gtk.DestDefaults.ALL,
+            targets=[Gtk.TargetEntry('text/uri-list', 0, 0)],
+            actions=Gdk.DragAction.COPY)
+
+    def acceptDragsOnCurveViews(self):
+        w = self.wtree.get_object("curves")
+        w.drag_dest_set(flags=Gtk.DestDefaults.ALL,
+                        targets=[Gtk.TargetEntry('text/uri-list', 0, 0)],
+                        actions=Gdk.DragAction.COPY)
+
+        def recv(widget, context, x, y, selection, targetType, time):
+            subUri = URIRef(selection.data.strip())
+            print("into curves", subUri)
+            with self.graph.currentState(tripleFilter=(subUri, RDFS.label,
+                                                       None)) as current:
+                subName = current.label(subUri)
+
+            if '?' in subUri:
+                subName = self.handleSubtermDrop(subUri)
+            else:
+                try:
+                    self.makeSubterm(subName,
+                                     withCurve=True,
+                                     sub=subUri,
+                                     expr="%s(t)" % subName)
+                except SubtermExists:
+                    # we're not making sure the expression/etc are
+                    # correct-- user mihgt need to fix things
+                    pass
+            curveView = self.curvesetView.row(subName).curveView
+            t = self.lastSeenInputTime  # curveView.current_time() # new curve hasn't heard the time yet. this has gotten too messy- everyone just needs to be able to reach the time source
+            print("time", t)
+            curveView.add_points([(t - .5, 0), (t, 1)])
+
+        w.connect("drag-data-received", recv)
+
+    def onDragDataInNewSubZone(self, widget, context, x, y, selection,
+                               targetType, time):
+        data = URIRef(selection.data.strip())
+        if '?' in data:
+            self.handleSubtermDrop(data)
+            return
+        with self.graph.currentState(tripleFilter=(data, None,
+                                                   None)) as current:
+            subName = current.label(data)
+        self.makeSubterm(newname=subName,
+                         withCurve=True,
+                         sub=data,
+                         expr="%s(t)" % subName)
+
+    def handleSubtermDrop(self, data):
+        params = parse_qsl(data.split('?')[1])
+        flattened = dict(params)
+        self.makeSubterm(Literal(flattened['subtermName']),
+                         expr=flattened['subtermExpr'])
+
+        for cmd, name in params:
+            if cmd == 'curve':
+                self.curveset.new_curve(name)
+        return name
+
+    def onNewCurve(self, *args):
+        dialog = self.wtree.get_object("newCurve")
+        entry = self.wtree.get_object("newCurveName")
+        # if you don't have songx, that should be the suggested name
+        entry.set_text("")
+        if dialog.run() == 1:
+            self.curveset.new_curve(entry.get_text())
+        dialog.hide()
+
+    def onRedrawCurves(self, *args):
+        dispatcher.send("all curves rebuild")
+
+    def onSubtermsMap(self, *args):
+        # if this was called too soon, like in __init__, the gtktable
+        # would get its children but it wouldn't lay anything out that
+        # I can see, and I'm not sure why. Waiting for map event is
+        # just a wild guess.
+        self.graph.addHandler(self.set_subterms_from_graph)
+
+    def onNewSubterm(self, *args):
+        self.makeSubterm(Literal(""), withCurve=False)
+        return
+
+        # pretty sure i don't want this back, but not completely sure
+        # what the UX should be to get the new curve.
+
+        dialog = self.wtree.get_object("newSubterm")
+        # the plan is to autocomplete this on existing subterm names
+        # (but let you make one up, too)
+        entry = self.wtree.get_object("newSubtermName").get_children()[0]
+        entry.set_text("")
+        entry.grab_focus()
+        if dialog.run() == 1:
+            newname = entry.get_text()
+            wc = self.wtree.get_object("newSubtermMakeCurve").get_active()
+            self.makeSubterm(newname, withCurve=wc)
+        dialog.hide()
+
+    def currentSong(self):
+
+        with self.graph.currentState(tripleFilter=(self.session,
+                                                   L9['currentSong'],
+                                                   None)) as current:
+            return current.value(self.session, L9['currentSong'])
+
+    def songSubtermsContext(self):
+        return self.currentSong()
+
+    def makeSubterm(self, newname, withCurve=False, expr=None, sub=None):
+        """
+        raises SubtermExists if we had a subterm with a sub with the given
+        name. what about a no-sub term with the same label? who knows
+        """
+        assert isinstance(newname, Literal), repr(newname)
+        if withCurve:
+            self.curveset.new_curve(newname)
+        if newname in self.all_subterm_labels():
+            raise SubtermExists("have a subterm who sub is named %r" % newname)
+        with self.graph.currentState() as current:
+            song = self.currentSong()
+            for i in range(1000):
+                uri = song + "/subterm/%d" % i
+                if (uri, None, None) not in current:
+                    break
+            else:
+                raise ValueError("can't pick a name for the new subterm")
+
+        ctx = self.songSubtermsContext()
+        quads = [
+            (uri, RDF.type, L9.Subterm, ctx),
+            (uri, RDFS.label, Literal(newname), ctx),
+            (self.currentSong(), L9['subterm'], uri, ctx),
+        ]
+        if sub is not None:
+            quads.append((uri, L9['sub'], sub, ctx))
+        if expr is not None:
+            quads.append((uri, L9['expression'], Literal(expr), ctx))
+        self.graph.patch(Patch(addQuads=quads))
+
+        return uri
+
+    def all_subterm_labels(self):
+        """
+        Literal labels of subs in subterms. doesn't currently include labels of the
+        subterm resources. I'm not sure what I'm going to do with
+        those.
+        """
+        labels = []
+        with self.graph.currentState() as current:
+            for st in current.objects(
+                    current.value(self.session, L9['currentSong']),
+                    L9['subterm']):
+                sub = current.value(st, L9['sub'])
+                if sub is not None:
+                    labels.append(current.label(sub))
+        return labels
+
+    def set_subterms_from_graph(self):
+        """rebuild all the gtktable 'subterms' widgets and the
+        self.currentSubterms list"""
+        song = self.graph.value(self.session, L9['currentSong'])
+
+        newList = []
+        for st in set(self.graph.objects(song, L9['subterm'])):
+            log.debug("song %s has subterm %s", song, st)
+            term = Subterm(self.graph, st, self.songSubtermsContext(),
+                           self.curveset)
+            newList.append(term)
+        self.currentSubterms[:] = newList
+
+        master = self.wtree.get_object("subterms")
+        log.debug("removing subterm widgets")
+        [master.remove(c) for c in master.get_children()]
+        for term in self.currentSubterms:
+            add_one_subterm(term, self.curveset, master)
+        master.show_all()
+        log.debug("%s table children showing" % len(master.get_children()))
+
+    def setTheme(self):
+        settings = Gtk.Settings.get_default()
+        settings.set_property("gtk-application-prefer-dark-theme", True)
+
+        providers = []
+        providers.append(Gtk.CssProvider())
+        providers[-1].load_from_path("theme/Just-Dark/gtk-3.0/gtk.css")
+        providers.append(Gtk.CssProvider())
+        providers[-1].load_from_data('''
+          * { font-size: 92%; }
+          .button:link { font-size: 7px }
+        ''')
+
+        screen = Gdk.Display.get_default_screen(Gdk.Display.get_default())
+        for p in providers:
+            Gtk.StyleContext.add_provider_for_screen(
+                screen, p, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
+
+    def onSubtermChildAdded(self, subtermsTable, *args):
+        # this would probably work, but isn't getting called
+        log.info("onSubtermChildAdded")
+        v = subtermsTable.get_parent().props.vadjustment
+        v.props.value = v.props.upper
+
+    def onQuit(self, *args):
+        reactor.crash()
+        # there's a hang after this, maybe in sem_wait in two
+        # threads. I don't know whose they are.
+        # This fix affects profilers who want to write output at the end.
+        os.kill(os.getpid(), signal.SIGKILL)
+
+    def onCollapseAll(self, *args):
+        self.curvesetView.collapseAll()
+
+    def onCollapseNone(self, *args):
+        self.curvesetView.collapseNone()
+
+    def onDelete(self, *args):
+        self.curvesetView.onDelete()
+
+    def onPythonConsole(self, item):
+        ns = dict()
+        ns.update(globals())
+        ns.update(self.__dict__)
+        togglePyConsole(self, item, ns)
+
+    def onSeeCurrentTime(self, item):
+        dispatcher.send("see time")
+
+    def onSeeTimeUntilEnd(self, item):
+        dispatcher.send("see time until end")
+
+    def onZoomAll(self, item):
+        dispatcher.send("show all")
+
+    def onPlayPause(self, item):
+        # since the X coord in a curveview affects the handling, one
+        # of them may be able to pick this up
+        results = dispatcher.send("onPlayPause")
+        times = [t for listener, t in results if t is not None]
+        self.music.playOrPause(t=times[0] if times else None)
+
+    def onSave(self, *args):
+        # only doing curves still. I hope to eliminate all this.
+        log.info("saving curves")
+        self.curveset.save()
+        log.info("saved")
+
+    def makeStatusLines(self, master):
+        """various labels that listen for dispatcher signals"""
+        for row, (signame, textfilter) in enumerate([
+            ('input time', lambda t: "%.2fs" % t),
+            ('output levels', lambda levels: textwrap.fill(
+                "; ".join([
+                    "%s:%.2f" % (n, v) for n, v in list(levels.items())[:2] if v
+                    > 0
+                ]), 70)),
+            ('update period', lambda t: "%.1fms" % (t * 1000)),
+            ('update status', lambda x: str(x)),
+        ]):
+            key = Gtk.Label("%s:" % signame)
+            value = Gtk.Label("")
+            master.resize(row + 1, 2)
+            master.attach(key, 0, 1, row, row + 1)
+            master.attach(value, 1, 2, row, row + 1)
+            key.set_alignment(1, 0)
+            value.set_alignment(0, 0)
+
+            dispatcher.connect(lambda val, value=value, tf=textfilter: value.
+                               set_text(tf(val)),
+                               signame,
+                               weak=False)
+        dispatcher.connect(lambda val: setattr(self, 'lastSeenInputTime', val),
+                           'input time',
+                           weak=False)
+        master.show_all()
+
+    def refreshCurveView(self):
+        wtree = self.wtree
+        mtimes = [
+            os.path.getmtime(f) for f in [
+                'light9/curvecalc/curveview.py',
+                'light9/curvecalc/zoomcontrol.py',
+            ]
+        ]
+
+        if (not hasattr(self, 'curvesetView') or
+                self.curvesetView._mtimes != mtimes):
+            print("reload curveview.py")
+            curvesVBox = wtree.get_object("curves")
+            zoomControlBox = wtree.get_object("zoomControlBox")
+            [curvesVBox.remove(c) for c in curvesVBox.get_children()]
+            [zoomControlBox.remove(c) for c in zoomControlBox.get_children()]
+            try:
+                linecache.clearcache()
+                imp.reload(curveview)
+
+                # old ones are not getting deleted right
+                if hasattr(self, 'curvesetView'):
+                    self.curvesetView.live = False
+
+                # mem problem somewhere; need to hold a ref to this
+                self.curvesetView = curveview.Curvesetview(
+                    self.graph, curvesVBox, zoomControlBox, self.curveset)
+                self.curvesetView._mtimes = mtimes
+
+                # this is scheduled after some tk shuffling, to
+                # try to minimize the number of times we redraw
+                # the curve at startup. If tk is very slow, it's
+                # ok. You'll just get some wasted redraws.
+                self.curvesetView.goLive()
+            except Exception:
+                print("reload failed:")
+                traceback.print_exc()
+        if self.opts.reload:
+            reactor.callLater(1, self.refreshCurveView)
+
+
+class MaxTime(object):
+    """
+    looks up the time in seconds for the session's current song
+    """
+
+    def __init__(self, graph, session):
+        self.graph, self.session = graph, session
+        graph.addHandler(self.update)
+
+    def update(self):
+        song = self.graph.value(self.session, L9['currentSong'])
+        if song is None:
+            self.maxtime = 0
+            return
+        musicfilename = showconfig.songOnDisk(song)
+        self.maxtime = wavelength(musicfilename)
+        log.info("new max time %r", self.maxtime)
+        dispatcher.send("max time", maxtime=self.maxtime)
+
+    def get(self):
+        return self.maxtime
+
+
+def launch(args, graph, session, opts, startTime, music):
+
+    try:
+        song = URIRef(args[0])
+        graph.patchObject(context=session,
+                          subject=session,
+                          predicate=L9['currentSong'],
+                          newObject=song)
+    except IndexError:
+        pass
+
+    curveset = Curveset(graph=graph, session=session)
+
+    log.debug("startup: output %s", time.time() - startTime)
+
+    mt = MaxTime(graph, session)
+    dispatcher.connect(lambda: mt.get(), "get max time", weak=False)
+
+    start = Main(graph, opts, session, curveset, music)
+    out = Output(graph, session, music, curveset, start.currentSubterms)
+
+    dispatcher.send("show all")
+
+    if opts.startup_only:
+        log.debug("quitting now because of --startup-only")
+        return
+
+    def hoverTimeResponse(requestHandler):
+        results = dispatcher.send("onPlayPause")
+        times = [t for listener, t in results if t is not None]
+        if not times:
+            requestHandler.set_status(404)
+            requestHandler.write("not hovering over any time")
+            return
+        with graph.currentState(tripleFilter=(session, L9['currentSong'],
+                                              None)) as g:
+            song = g.value(session, L9['currentSong'])
+            json.dump({"song": song, "hoverTime": times[0]}, requestHandler)
+
+    serveCurveEdit(networking.curveCalc.port, hoverTimeResponse, start.curveset)
+
+
+def main():
+    startTime = time.time()
+    parser = optparse.OptionParser()
+    parser.set_usage("%prog [opts] [songURI]")
+    parser.add_option("--debug", action="store_true", help="log at DEBUG")
+    parser.add_option("--reload",
+                      action="store_true",
+                      help="live reload of themes and code")
+    parser.add_option("--startup-only",
+                      action='store_true',
+                      help="quit after loading everything (for timing tests)")
+    parser.add_option("--profile", help='"hotshot" or "stat"')
+    clientsession.add_option(parser)
+    opts, args = parser.parse_args()
+
+    log.setLevel(logging.DEBUG if opts.debug else logging.INFO)
+
+    log.debug("startup: music %s", time.time() - startTime)
+
+    session = clientsession.getUri('curvecalc', opts)
+
+    music = Music()
+    graph = SyncedGraph(networking.rdfdb.url, "curvecalc")
+
+    graph.initiallySynced.addCallback(lambda _: launch(args, graph, session,
+                                                       opts, startTime, music))
+    from light9 import prof
+    prof.run(reactor.run, profile=opts.profile)
+
+
+main()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/curvecalc_all_subterms	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,6 @@
+#!/bin/zsh
+echo broken: use a plain shell loop
+exit 1
+
+
+for x (`ls $LIGHT9_SHOW/subterms`) { bin/curvecalc $x }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/dmx_color_test.py	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,20 @@
+#!bin/python
+from run_local import log
+import colorsys, time, logging
+from light9 import dmxclient
+from twisted.internet import reactor, task
+
+log.setLevel(logging.INFO)
+firstDmxChannel = 10
+
+
+def step():
+    hue = (time.time() * .2) % 1.0
+    r, g, b = colorsys.hsv_to_rgb(hue, 1, 1)
+    chans = [r, g, b]
+    log.info(chans)
+    dmxclient.outputlevels([0] * (firstDmxChannel - 1) + chans, twisted=True)
+
+
+task.LoopingCall(step).start(.05)
+reactor.run()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/dmxserver	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,280 @@
+#!bin/python
+"""
+Replaced by bin/collector
+
+
+this is the only process to talk to the dmx hardware. other clients
+can connect to this server and present dmx output, and this server
+will max ('pile-on') all the client requests.
+
+this server has a level display which is the final set of values that
+goes to the hardware.
+
+clients shall connect to the xmlrpc server and send:
+
+  their PID (or some other cookie)
+
+  a length-n list of 0..1 levels which will represent the channel
+    values for the n first dmx channels.
+
+server is port 8030; xmlrpc method is called outputlevels(pid,levellist).
+
+todo:
+  save dmx on quit and restore on restart
+  if parport fails, run in dummy mode (and make an option for that too)
+"""
+
+from twisted.internet import reactor
+from twisted.web import xmlrpc, server
+import sys, time, os
+from optparse import OptionParser
+import run_local
+import txosc.dispatch, txosc. async
+from light9.io import ParportDMX, UsbDMX
+
+from light9.updatefreq import Updatefreq
+from light9 import networking
+
+from txzmq import ZmqEndpoint, ZmqFactory, ZmqPullConnection, ZmqRequestTimeoutError
+import json
+
+
+def startZmq(port, outputlevels):
+    zf = ZmqFactory()
+    e = ZmqEndpoint('bind', 'tcp://*:%s' % port)
+    s = ZmqPullConnection(zf, e)
+
+    def onPull(message):
+        msg = json.loads(message[0])
+        outputlevels(msg['clientid'], msg['levellist'])
+
+    s.onPull = onPull
+
+
+class ReceiverApplication(object):
+    """
+    receive UDP OSC messages. address is /dmx/1 for dmx channel 1,
+    arguments are 0-1 floats for that channel and any number of
+    following channels.
+    """
+
+    def __init__(self, port, lightServer):
+        self.port = port
+        self.lightServer = lightServer
+        self.receiver = txosc.dispatch.Receiver()
+        self.receiver.addCallback("/dmx/*", self.pixel_handler)
+        self._server_port = reactor.listenUDP(
+            self.port,
+            txosc. async .DatagramServerProtocol(self.receiver),
+            interface='0.0.0.0')
+        print("Listening OSC on udp port %s" % (self.port))
+
+    def pixel_handler(self, message, address):
+        # this is already 1-based though I don't know why
+        startChannel = int(message.address.split('/')[2])
+        levels = [a.value for a in message.arguments]
+        allLevels = [0] * (startChannel - 1) + levels
+        self.lightServer.xmlrpc_outputlevels("osc@%s" % startChannel, allLevels)
+
+
+class XMLRPCServe(xmlrpc.XMLRPC):
+
+    def __init__(self, options):
+
+        xmlrpc.XMLRPC.__init__(self)
+
+        self.clientlevels = {}  # clientID : list of levels
+        self.lastseen = {}  # clientID : time last seen
+        self.clientfreq = {}  # clientID : updatefreq
+
+        self.combinedlevels = []  # list of levels, after max'ing the clients
+        self.clientschanged = 1  # have clients sent anything since the last send?
+        self.options = options
+        self.lastupdate = 0  # time of last dmx send
+        self.laststatsprint = 0  # time
+
+        # desired seconds between sendlevels() calls
+        self.calldelay = 1 / options.updates_per_sec
+
+        print("starting parport connection")
+        self.parportdmx = UsbDMX(dimmers=90, port=options.dmx_device)
+        if os.environ.get('DMXDUMMY', 0):
+            self.parportdmx.godummy()
+        else:
+            self.parportdmx.golive()
+
+        self.updatefreq = Updatefreq()  # freq of actual dmx sends
+        self.num_unshown_updates = None
+        self.lastshownlevels = None
+        # start the loop
+        self.sendlevels()
+
+        # the other loop
+        self.purgeclients()
+
+    def purgeclients(self):
+        """forget about any clients who haven't sent levels in a while.
+        this runs in a loop"""
+
+        purge_age = 10  # seconds
+
+        reactor.callLater(1, self.purgeclients)
+
+        now = time.time()
+        cids = list(self.lastseen.keys())
+        for cid in cids:
+            lastseen = self.lastseen[cid]
+            if lastseen < now - purge_age:
+                print(("forgetting client %s (no activity for %s sec)" %
+                       (cid, purge_age)))
+                try:
+                    del self.clientlevels[cid]
+                except KeyError:
+                    pass
+                del self.clientfreq[cid]
+                del self.lastseen[cid]
+
+    def sendlevels(self):
+        """sends to dmx if levels have changed, or if we havent sent
+        in a while"""
+
+        reactor.callLater(self.calldelay, self.sendlevels)
+
+        if self.clientschanged:
+            # recalc levels
+
+            self.calclevels()
+
+            if (self.num_unshown_updates is None or  # first time
+                    self.options.fast_updates or  # show always
+                (
+                    self.combinedlevels != self.lastshownlevels and  # changed
+                    self.num_unshown_updates > 5)):  # not too frequent
+                self.num_unshown_updates = 0
+                self.printlevels()
+                self.lastshownlevels = self.combinedlevels[:]
+            else:
+                self.num_unshown_updates += 1
+
+        if time.time() > self.laststatsprint + 2:
+            self.laststatsprint = time.time()
+            self.printstats()
+
+        # used to be a fixed 1 in here, for the max delay between
+        # calls, instead of calldelay
+        if self.clientschanged or time.time(
+        ) > self.lastupdate + self.calldelay:
+            self.lastupdate = time.time()
+            self.sendlevels_dmx()
+
+        self.clientschanged = 0  # clear the flag
+
+    def calclevels(self):
+        """combine all the known client levels into self.combinedlevels"""
+        self.combinedlevels = []
+        for chan in range(0, self.parportdmx.dimmers):
+            x = 0
+            for clientlist in list(self.clientlevels.values()):
+                if len(clientlist) > chan:
+                    # clamp client levels to 0..1
+                    cl = max(0, min(1, clientlist[chan]))
+                    x = max(x, cl)
+            self.combinedlevels.append(x)
+
+    def printlevels(self):
+        """write all the levels to stdout"""
+        print("Levels:",
+              "".join(["% 2d " % (x * 100) for x in self.combinedlevels]))
+
+    def printstats(self):
+        """print the clock, freq, etc, with a \r at the end"""
+
+        sys.stdout.write("dmxserver up at %s, [polls %s] " % (
+            time.strftime("%H:%M:%S"),
+            str(self.updatefreq),
+        ))
+        for cid, freq in list(self.clientfreq.items()):
+            sys.stdout.write("[%s %s] " % (cid, str(freq)))
+        sys.stdout.write("\r")
+        sys.stdout.flush()
+
+    def sendlevels_dmx(self):
+        """output self.combinedlevels to dmx, and keep the updates/sec stats"""
+        # they'll get divided by 100
+        if self.parportdmx:
+            self.parportdmx.sendlevels([l * 100 for l in self.combinedlevels])
+        self.updatefreq.update()
+
+    def xmlrpc_echo(self, x):
+        return x
+
+    def xmlrpc_outputlevels(self, cid, levellist):
+        """send a unique id for your client (name+pid maybe), then
+        the variable-length dmx levellist (scaled 0..1)"""
+        if levellist != self.clientlevels.get(cid, None):
+            self.clientlevels[cid] = levellist
+            self.clientschanged = 1
+        self.trackClientFreq(cid)
+        return "ok"
+
+    def xmlrpc_currentlevels(self, cid):
+        """get a list of levels we're currently sending out. All
+        channels beyond the list you get back, they're at zero."""
+        # if this is still too slow, it might help to return a single
+        # pickled string
+        self.trackClientFreq(cid)
+        trunc = self.combinedlevels[:]
+        i = len(trunc) - 1
+        if i < 0:
+            return []
+        while trunc[i] == 0 and i >= 0:
+            i -= 1
+        if i < 0:
+            return []
+        trunc = trunc[:i + 1]
+        return trunc
+
+    def trackClientFreq(self, cid):
+        if cid not in self.lastseen:
+            print("hello new client %s" % cid)
+            self.clientfreq[cid] = Updatefreq()
+        self.lastseen[cid] = time.time()
+        self.clientfreq[cid].update()
+
+
+parser = OptionParser()
+parser.add_option("-f",
+                  "--fast-updates",
+                  action='store_true',
+                  help=('display all dmx output to stdout instead '
+                        'of the usual reduced output'))
+parser.add_option("-r",
+                  "--updates-per-sec",
+                  type='float',
+                  default=20,
+                  help=('dmx output frequency'))
+parser.add_option("-d",
+                  "--dmx-device",
+                  default='/dev/dmx0',
+                  help='dmx device name')
+parser.add_option("-n",
+                  "--dummy",
+                  action="store_true",
+                  help="dummy mode, same as DMXDUMMY=1 env variable")
+(options, songfiles) = parser.parse_args()
+
+print(options)
+
+if options.dummy:
+    os.environ['DMXDUMMY'] = "1"
+
+port = networking.dmxServer.port
+print("starting xmlrpc server on port %s" % port)
+xmlrpcServe = XMLRPCServe(options)
+reactor.listenTCP(port, server.Site(xmlrpcServe))
+
+startZmq(networking.dmxServerZmq.port, xmlrpcServe.xmlrpc_outputlevels)
+
+oscApp = ReceiverApplication(9051, xmlrpcServe)
+
+reactor.run()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/effectListing	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,4 @@
+#!/bin/sh
+pnpm exec vite -c light9/effect/listing/web/vite.config.ts &
+wait
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/effectSequencer	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,5 @@
+#!/bin/zsh
+pnpm exec vite -c light9/effect/sequencer/web/vite.config.ts &
+pdm run uvicorn light9.effect.sequencer.service:app --host 0.0.0.0 --port 8213 --no-access-log 
+wait
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/effecteval	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,283 @@
+#!bin/python
+
+from run_local import log
+from twisted.internet import reactor
+from twisted.internet.defer import inlineCallbacks, returnValue
+import cyclone.web, cyclone.websocket, cyclone.httpclient
+import sys, optparse, logging, json, itertools
+from rdflib import URIRef, Literal
+
+from light9 import networking, showconfig
+from light9.effecteval.effect import EffectNode
+from light9.effect.edit import getMusicStatus, songNotePatch
+from light9.effecteval.effectloop import makeEffectLoop
+from light9.metrics import metrics, metricsRoute
+from light9.namespaces import L9
+from rdfdb.patch import Patch
+from rdfdb.syncedgraph import SyncedGraph
+
+from cycloneerr import PrettyErrorHandler
+from light9.coffee import StaticCoffee
+
+
+
+class EffectEdit(PrettyErrorHandler, cyclone.web.RequestHandler):
+
+    def get(self):
+        self.set_header('Content-Type', 'text/html')
+        self.write(open("light9/effecteval/effect.html").read())
+
+    def delete(self):
+        graph = self.settings.graph
+        uri = URIRef(self.get_argument('uri'))
+        with graph.currentState(tripleFilter=(None, L9['effect'], uri)) as g:
+            song = ctx = list(g.subjects(L9['effect'], uri))[0]
+        self.settings.graph.patch(
+            Patch(delQuads=[
+                (song, L9['effect'], uri, ctx),
+            ]))
+
+
+@inlineCallbacks
+def currentSong():
+    s = (yield getMusicStatus())['song']
+    if s is None:
+        raise ValueError("no current song")
+    returnValue(URIRef(s))
+
+
+class SongEffects(PrettyErrorHandler, cyclone.web.RequestHandler):
+
+    def wideOpenCors(self):
+        self.set_header('Access-Control-Allow-Origin', '*')
+        self.set_header('Access-Control-Allow-Methods',
+                        'GET, PUT, POST, DELETE, OPTIONS')
+        self.set_header('Access-Control-Max-Age', '1000')
+        self.set_header('Access-Control-Allow-Headers',
+                        'Content-Type, Authorization, X-Requested-With')
+
+    def options(self):
+        self.wideOpenCors()
+        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()
+
+        event = self.get_argument('event', default='default')
+
+        note = self.get_argument('note', default=None)
+        if note is not None:
+            note = URIRef(note)
+
+        log.info("adding to %s", song)
+        note, p = yield songNotePatch(self.settings.graph,
+                                      dropped,
+                                      song,
+                                      event,
+                                      ctx=song,
+                                      note=note)
+
+        self.settings.graph.patch(p)
+        self.settings.graph.suggestPrefixes(song, {'song': URIRef(song + '/')})
+        self.write(json.dumps({'note': note}))
+
+
+class SongEffectsUpdates(cyclone.websocket.WebSocketHandler):
+
+    def connectionMade(self, *args, **kwargs):
+        self.graph = self.settings.graph
+        self.graph.addHandler(self.updateClient)
+
+    def updateClient(self):
+        # todo: abort if client is gone
+        playlist = self.graph.value(showconfig.showUri(), L9['playList'])
+        songs = list(self.graph.items(playlist))
+        out = []
+        for s in songs:
+            out.append({'uri': s, 'label': self.graph.label(s), 'effects': []})
+            seen = set()
+            for n in self.graph.objects(s, L9['note']):
+                for uri in self.graph.objects(n, L9['effectClass']):
+                    if uri in seen:
+                        continue
+                    seen.add(uri)
+                    out[-1]['effects'].append({
+                        'uri': uri,
+                        'label': self.graph.label(uri)
+                    })
+            out[-1]['effects'].sort(key=lambda e: e['uri'])
+
+        self.sendMessage({'songs': out})
+
+
+class EffectUpdates(cyclone.websocket.WebSocketHandler):
+    """
+    stays alive for the life of the effect page
+    """
+
+    def connectionMade(self, *args, **kwargs):
+        log.info("websocket opened")
+        self.uri = URIRef(self.get_argument('uri'))
+        self.sendMessage({'hello': repr(self)})
+
+        self.graph = self.settings.graph
+        self.graph.addHandler(self.updateClient)
+
+    def updateClient(self):
+        # todo: if client has dropped, abort and don't get any more
+        # graph updates
+
+        # EffectNode knows how to put them in order. Somehow this is
+        # not triggering an update when the order changes.
+        en = EffectNode(self.graph, self.uri)
+        codeLines = [c.code for c in en.codes]
+        self.sendMessage({'codeLines': codeLines})
+
+    def connectionLost(self, reason):
+        log.info("websocket closed")
+
+    def messageReceived(self, message):
+        log.info("got message %s" % message)
+        # write a patch back to the graph
+
+
+def replaceObjects(graph, c, s, p, newObjs):
+    patch = graph.getObjectPatch(context=c,
+                                 subject=s,
+                                 predicate=p,
+                                 newObject=newObjs[0])
+
+    moreAdds = []
+    for line in newObjs[1:]:
+        moreAdds.append((s, p, line, c))
+    fullPatch = Patch(delQuads=patch.delQuads,
+                      addQuads=patch.addQuads + moreAdds)
+    graph.patch(fullPatch)
+
+
+class Code(PrettyErrorHandler, cyclone.web.RequestHandler):
+
+    def put(self):
+        effect = URIRef(self.get_argument('uri'))
+        codeLines = []
+        for i in itertools.count(0):
+            k = 'codeLines[%s][text]' % i
+            v = self.get_argument(k, None)
+            if v is not None:
+                codeLines.append(Literal(v))
+            else:
+                break
+        if not codeLines:
+            log.info("no codelines received on PUT /code")
+            return
+        with self.settings.graph.currentState(tripleFilter=(None, L9['effect'],
+                                                            effect)) as g:
+            song = next(g.subjects(L9['effect'], effect))
+
+        replaceObjects(self.settings.graph, song, effect, L9['code'], codeLines)
+
+        # right here we could tell if the code has a python error and return it
+        self.send_error(202)
+
+
+class EffectEval(PrettyErrorHandler, cyclone.web.RequestHandler):
+
+    @inlineCallbacks
+    def get(self):
+        # return dmx list for that effect
+        uri = URIRef(self.get_argument('uri'))
+        response = yield cyclone.httpclient.fetch(
+            networking.musicPlayer.path('time'))
+        songTime = json.loads(response.body)['t']
+
+        node = EffectNode(self.settings.graph, uri)
+        outSub = node.eval(songTime)
+        self.write(json.dumps(outSub.get_dmx_list()))
+
+
+# Completely not sure where the effect background loop should
+# go. Another process could own it, and get this request repeatedly:
+class SongEffectsEval(PrettyErrorHandler, cyclone.web.RequestHandler):
+
+    def get(self):
+        song = URIRef(self.get_argument('song'))
+        effects = effectsForSong(self.settings.graph, song)  # noqa
+        raise NotImplementedError
+        self.write(maxDict(effectDmxDict(e) for e in effects))  # noqa
+        # return dmx dict for all effects in the song, already combined
+
+
+class App(object):
+
+    def __init__(self, show, outputWhere):
+        self.show = show
+        self.outputWhere = outputWhere
+        self.graph = SyncedGraph(networking.rdfdb.url, "effectEval")
+        self.graph.initiallySynced.addCallback(self.launch).addErrback(
+            log.error)
+
+    def launch(self, *args):
+        log.info('launch')
+        if self.outputWhere:
+            self.loop = makeEffectLoop(self.graph, self.outputWhere)
+            self.loop.startLoop()
+
+        SFH = cyclone.web.StaticFileHandler
+        self.cycloneApp = cyclone.web.Application(handlers=[
+            (r'/()', SFH, {
+                'path': 'light9/effecteval',
+                'default_filename': 'index.html'
+            }),
+            (r'/effect', EffectEdit),
+            (r'/effect\.js', StaticCoffee, {
+                'src': 'light9/effecteval/effect.coffee'
+            }),
+            (r'/(effect-components\.html)', SFH, {
+                'path': 'light9/effecteval'
+            }),
+            (r'/effectUpdates', EffectUpdates),
+            (r'/code', Code),
+            (r'/songEffectsUpdates', SongEffectsUpdates),
+            (r'/effect/eval', EffectEval),
+            (r'/songEffects', SongEffects),
+            (r'/songEffects/eval', SongEffectsEval),
+            metricsRoute(),
+        ],
+                                                  debug=True,
+                                                  graph=self.graph)
+        reactor.listenTCP(networking.effectEval.port, self.cycloneApp)
+        log.info("listening on %s" % networking.effectEval.port)
+
+
+if __name__ == "__main__":
+    parser = optparse.OptionParser()
+    parser.add_option(
+        '--show',
+        help='show URI, like http://light9.bigasterisk.com/show/dance2008',
+        default=showconfig.showUri())
+    parser.add_option("-v",
+                      "--verbose",
+                      action="store_true",
+                      help="logging.DEBUG")
+    parser.add_option("--twistedlog",
+                      action="store_true",
+                      help="twisted logging")
+    parser.add_option("--output", metavar="WHERE", help="dmx or leds")
+    (options, args) = parser.parse_args()
+    log.setLevel(logging.DEBUG if options.verbose else logging.INFO)
+
+    if not options.show:
+        raise ValueError("missing --show http://...")
+
+    app = App(URIRef(options.show), options.output)
+    if options.twistedlog:
+        from twisted.python import log as twlog
+        twlog.startLogging(sys.stderr)
+    reactor.run()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/fade	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,4 @@
+#!/bin/sh
+exec pnpm exec vite -c light9/fade/vite.config.ts
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/gobutton	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,3 @@
+#!/bin/sh
+# uri should be set from $LIGHT9_SHOW/config.n3
+exec curl --silent -d '' http://localhost:8040/go

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/gtk_dnd_demo.py	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,20 @@
+#!bin/python
+import run_local
+import gtk
+import sys
+sys.path.append(".")
+from rdflib import URIRef
+from light9 import networking
+from light9.editchoicegtk import EditChoice, Local
+from light9.observable import Observable
+from rdfdb.syncedgraph import SyncedGraph
+
+win = gtk.Window()
+
+graph = SyncedGraph(networking.rdfdb.url, "gtkdnddemo")
+
+r1 = URIRef("http://example.com/interestingThing")
+v = Observable(r1)
+win.add(EditChoice(graph, v))
+win.show_all()
+gtk.main()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/inputdemo	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,65 @@
+#!bin/python
+import sys
+sys.path.append('/usr/lib/python2.7/dist-packages')  # For gtk
+from twisted.internet import gtk3reactor
+gtk3reactor.install()
+from twisted.internet import reactor
+from rdflib import URIRef
+import optparse, logging, time
+from gi.repository import Gtk
+from run_local import log
+from light9 import networking
+from light9 import clientsession
+from rdfdb.syncedgraph import SyncedGraph
+from light9.curvecalc.client import sendLiveInputPoint
+
+
+class App(object):
+
+    def __init__(self):
+        parser = optparse.OptionParser()
+        parser.set_usage("%prog [opts] [curve uri]")
+        parser.add_option("--debug", action="store_true", help="log at DEBUG")
+        clientsession.add_option(parser)
+        opts, args = parser.parse_args()
+
+        log.setLevel(logging.DEBUG if opts.debug else logging.INFO)
+
+        self.session = clientsession.getUri('inputdemo', opts)
+        self.graph = SyncedGraph(networking.rdfdb.url, "inputdemo")
+
+        self.graph.initiallySynced.addCallback(lambda _: self.launch())
+
+        self.curve = args[0] if args else URIRef(
+            'http://light9.bigasterisk.com/show/dance2014/song1/curve/c-1401259747.675542'
+        )
+        print("sending points on curve %s" % self.curve)
+
+        reactor.run()
+
+    def launch(self):
+        win = Gtk.Window()
+
+        slider = Gtk.Scale.new_with_range(orientation=Gtk.Orientation.VERTICAL,
+                                          min=0,
+                                          max=1,
+                                          step=.001)
+        slider.props.inverted = True
+        slider.connect('value-changed', self.onChanged)
+
+        win.add(slider)
+        win.parse_geometry('50x250')
+        win.connect("delete-event", lambda *a: reactor.crash())
+        win.connect("destroy", lambda *a: reactor.crash())
+        win.show_all()
+
+    def onChanged(self, scale):
+        t1 = time.time()
+        d = sendLiveInputPoint(self.curve, scale.get_value())
+
+        @d.addCallback
+        def done(result):
+            print("posted in %.1f ms" % (1000 * (time.time() - t1)))
+
+
+App()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/inputquneo	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,115 @@
+#!bin/python
+"""
+read Quneo midi events, write to curvecalc and maybe to effects
+"""
+
+from run_local import log
+import logging, urllib.request, urllib.parse, urllib.error
+import cyclone.web, cyclone.httpclient
+from rdflib import URIRef
+from twisted.internet import reactor, task
+from light9.curvecalc.client import sendLiveInputPoint
+from light9.namespaces import L9, RDF
+from rdfdb.syncedgraph import SyncedGraph
+from light9 import networking
+
+import sys
+sys.path.append('/usr/lib/python2.7/dist-packages')  # For pygame
+import pygame.midi
+
+curves = {
+    23: URIRef('http://light9.bigasterisk.com/show/dance2014/song1/curve/c-2'),
+    24: URIRef('http://light9.bigasterisk.com/show/dance2014/song1/curve/c-3'),
+    25: URIRef('http://light9.bigasterisk.com/show/dance2014/song1/curve/c-4'),
+    6: URIRef('http://light9.bigasterisk.com/show/dance2014/song1/curve/c-5'),
+    18: URIRef('http://light9.bigasterisk.com/show/dance2014/song1/curve/c-6'),
+}
+
+
+class WatchMidi:
+
+    def __init__(self, graph):
+        self.graph = graph
+        pygame.midi.init()
+
+        dev = self.findQuneo()
+        self.inp = pygame.midi.Input(dev)
+        task.LoopingCall(self.step).start(.05)
+
+        self.noteIsOn = {}
+
+        self.effectMap = {}  # note: effect class uri
+        self.graph.addHandler(self.setupNotes)
+
+    def setupNotes(self):
+        for e in self.graph.subjects(RDF.type, L9['EffectClass']):
+            qn = self.graph.value(e, L9['quneoNote'])
+            if qn:
+                self.effectMap[int(qn)] = e
+        log.info("setup with %s effects", len(self.effectMap))
+
+    def findQuneo(self):
+        for dev in range(pygame.midi.get_count()):
+            interf, name, isInput, isOutput, opened = pygame.midi.get_device_info(
+                dev)
+            if 'QUNEO' in name and isInput:
+                return dev
+        raise ValueError("didn't find quneo input device")
+
+    def step(self):
+        if not self.inp.poll():
+            return
+        NOTEON, NOTEOFF = 144, 128
+        for ev in self.inp.read(999):
+            (status, d1, d2, _), _ = ev
+            if status in [NOTEON, NOTEOFF]:
+                print(status, d1, d2)
+
+            if status == NOTEON:
+                if not self.noteIsOn.get(d1):
+                    self.noteIsOn[d1] = True
+                    try:
+                        e = self.effectMap[d1]
+                        cyclone.httpclient.fetch(
+                            url=networking.effectEval.path('songEffects'),
+                            method='POST',
+                            headers={
+                                'Content-Type':
+                                ['application/x-www-form-urlencoded']
+                            },
+                            postdata=urllib.parse.urlencode([('drop', e)]),
+                        )
+                    except KeyError:
+                        pass
+
+            if status == NOTEOFF:
+                self.noteIsOn[d1] = False
+
+            if 0:
+                # curve editing mode, not done yet
+                for group in [(23, 24, 25), (6, 18)]:
+                    if d1 in group:
+                        if not self.noteIsOn.get(group):
+                            print("start zero")
+
+                            for d in group:
+                                sendLiveInputPoint(curves[d], 0)
+                            self.noteIsOn[group] = True
+                        else:  # miss first update
+                            sendLiveInputPoint(curves[d1], d2 / 127)
+
+                    if status == 128:  #noteoff
+                        for d in group:
+                            sendLiveInputPoint(curves[d], 0)
+                        self.noteIsOn[group] = False
+
+
+def main():
+    log.setLevel(logging.DEBUG)
+    graph = SyncedGraph(networking.rdfdb.url, "inputQuneo")
+    wm = WatchMidi(graph)
+    reactor.run()
+    del wm
+
+
+main()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/kcclient	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+"""send KeyboardComposer a fade request, for use from the shell"""
+
+import sys
+import run_local
+from restclient import Resource
+from light9 import networking
+
+subname = sys.argv[1]
+level = sys.argv[2]
+fadesecs = '0'
+if len(sys.argv) > 3:
+    fadesecs = sys.argv[3]
+
+levelServer = Resource(networking.keyboardComposer.url)
+levelServer.post('fadesub', subname=subname, level=level, secs=fadesecs)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/attic/keyboardcomposer	Sun May 12 19:02:10 2024 -0700
@@ -0,0 +1,712 @@
+#!bin/python
+
+from run_local import log
+
+from optparse import OptionParser
+from typing import Any, Dict, Tuple, List
+import cgi, time, logging
+import imp
+import tkinter.tix as tk
+
+from louie import dispatcher
+from rdflib import URIRef, Literal
+from twisted.internet import reactor, tksupport
+from twisted.web import resource
+import webcolors, colorsys
+
+from bcf2000 import BCF2000
+from light9 import clientsession
+from light9 import showconfig, networking, prof
+from light9.Fadable import Fadable
+from light9.effect.sequencer import CodeWatcher
+from light9.effect.settings import DeviceSettings
+from light9.effect.simple_outputs import SimpleOutputs
+from light9.namespaces import L9, RDF, RDFS
+from light9.subclient import SubClient
+from light9.tkdnd import initTkdnd, dragSourceRegister, dropTargetRegister
+from light9.uihelpers import toplevelat
+from rdfdb.patch import Patch
+from rdfdb.syncedgraph import SyncedGraph
+import light9.effect.effecteval
+
+nudge_keys = {'up': list('qwertyui'), 'down': list('asdfghjk')}
+
+
+class DummySliders:
+
+    def valueOut(self, name, value):
+        pass
+
+    def close(self):
+        pass
+
+    def reopen(self):
+        pass
+
+
+class SubScale(tk.Scale, Fadable):
+
+    def __init__(self, master, *args, **kw):
+        self.scale_var = kw.get('variable') or tk.DoubleVar()
+        kw.update({
+            'variable': self.scale_var,
+            'from': 1.,
+            'to': 0.,
+            'showvalue': 0,
+            'sliderlength': 15,
+            'res': 0.001,
+            'width': 40,
+            'troughcolor': 'black',
+            'bg': 'grey40',
+            'highlightthickness': 1,
+            'bd': 1,
+            'highlightcolor': 'red',
+            'highlightbackground': 'black',
+            'activebackground': 'red'
+        })
+        tk.Scale.__init__(self, master, *args, **kw)
+        Fadable.__init__(self, var=self.scale_var, wheel_step=0.05)
+        self.draw_indicator_colors()
+
+    def draw_indicator_colors(self):
+        if self.scale_var.get() == 0:
+            self['troughcolor'] = 'black'
+        else:
+            self['troughcolor'] = 'blue'
+
+
+class SubmasterBox(tk.Frame):
+    """
+    this object owns the level of the submaster (the rdf graph is the
+    real authority)
+
+    This leaks handlers or DoubleVars or something and tries to just
+    skip the obsolete ones. It'll get slower and bigger over
+    time. todo: make aa web version.
+    """
+
+    def __init__(self, master, graph, sub, session, col, row):
+        self.graph = graph
+        self.sub = sub
+        self.session = session
+        self.col, self.row = col, row
+        bg = self.graph.value(sub, L9['color'], default='#000000')
+        rgb = webcolors.hex_to_rgb(bg)
+        hsv = colorsys.rgb_to_hsv(*[x / 255 for x in rgb])
+        darkBg = webcolors.rgb_to_hex(
+            tuple([
+                int(x * 255) for x in colorsys.hsv_to_rgb(hsv[0], hsv[1], .2)
+            ]))
+        tk.Frame.__init__(self, master, bd=1, relief='raised', bg=bg)
+        self.name = self.graph.label(sub)
+        self._val = 0.0
+        self.slider_var = tk.DoubleVar()
+        self.pauseTrace = False
+        self.scale = SubScale(self, variable=self.slider_var, width=20)
+        self.dead = False
+
+        self.namelabel = tk.Label(self,
+                                  font="Arial 9",
+                                  bg=darkBg,
+                                  fg='white',
+                                  pady=0)
+        self.graph.addHandler(self.updateName)
+
+        self.namelabel.pack(side=tk.TOP)
+        self.levellabel = tk.Label(self,
+                                   textvariable=self.slider_var,
+                                   font="Arial 6",
+                                   bg='black',
+                                   fg='white',
+                                   pady=0)
+        self.levellabel.pack(side=tk.TOP)
+        self.scale.pack(side=tk.BOTTOM, expand=1, fill=tk.BOTH)
+
+        for w in [self, self.namelabel, self.levellabel]:
+            dragSourceRegister(w, 'copy', 'text/uri-list', sub)
+
+        self._slider_var_trace = self.slider_var.trace('w', self.slider_changed)
+
+        self.graph.addHandler(self.updateLevelFromGraph)
+
+        # initial position
+        # stil need? dispatcher.send("send_to_hw", sub=sub.uri, hwCol=col + 1)
+
+    def getVal(self) -> float:
+        return self._val
+
+    def setVal(self, newVal: float) -> None:
+        if self.dead:
+            return
+        try:
+            self.scale.set(newVal)
+            self.levellabel.config(text=str(newVal))
+        except Exception:
+            log.warning("disabling handlers on broken subbox")
+            self.dead = True
+
+    def cleanup(self):
+        self.slider_var.trace_vdelete('w', self._slider_var_trace)
+
+    def slider_changed(self, *args):
+        self._val = self.scale.get()
+        self.scale.draw_indicator_colors()
+
+        if self.pauseTrace:
+            return
+        self.updateGraphWithLevel(self.sub, self.getVal())
+
+        # needs fixing: plan is to use dispatcher or a method call to tell a hardware-mapping object who changed, and then it can make io if that's a current hw slider
+        dispatcher.send("send_to_hw",
+                        sub=self.sub,
+                        hwCol=self.col + 1,
+                        boxRow=self.row)
+
+    def updateGraphWithLevel(self, uri, level):
+        """in our per-session graph, we maintain SubSetting objects like this:
+
+           ?session :subSetting [a :SubSetting; :sub ?s; :level ?l]
+        """
+        # move to syncedgraph patchMapping
+
+        self.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))
+
+    def updateLevelFromGraph(self):
+        """read rdf level, write it to subbox.slider_var"""
+        # move this to syncedgraph readMapping
+        graph = self.graph
+
+        for setting in graph.objects(self.session, L9['subSetting']):
+            if graph.value(setting, L9['sub']) == self.sub:
+                self.pauseTrace = True  # don't bounce this update back to server
+                try:
+                    self.setVal(graph.value(setting, L9['level']).toPython())
+                finally:
+                    self.pauseTrace = False
+
+    def updateName(self):
+        if self.scale is None:
+            return
+
+        def shortUri(u):
+            return '.../' + u.split('/')[-1]
+
+        try:
+            self.namelabel.config(
+                text=self.graph.label(self.sub) or shortUri(self.sub))
+        except Exception:
+            log.warn("disabling handlers on broken subbox")
+            self.scale = None
+
+
+class KeyboardComposer(tk.Frame, SubClient):
+
+    def __init__(self,
+                 root: tk.Tk,
+                 graph: SyncedGraph,
+                 session: URIRef,
+                 hw_sliders=True):
+        tk.Frame.__init__(self, root, bg='black')
+        SubClient.__init__(self)
+        self.graph = graph
+        self.session = session
+
+        self.subbox: Dict[URIRef, SubmasterBox] = {}  # sub uri : SubmasterBox
+        self.slider_table: Dict[Tuple[int, int], SubmasterBox] = {
+        }  # coords : SubmasterBox
+        self.rows: List[tk.Frame] = []  # this holds Tk Frames for each row
+
+        self.current_row = 0  # should come from session graph
+
+        self.use_hw_sliders = hw_sliders
+        self.connect_to_hw(hw_sliders)
+
+        self.make_key_hints()
+        self.make_buttons()
+
+        self.graph.addHandler(self.redraw_sliders)
+
+        self.codeWatcher = CodeWatcher(
+            onChange=lambda: self.graph.addHandler(self.redraw_sliders))
+
+        self.send_levels_loop(periodSec=.05)
+        self.graph.addHandler(self.rowFromGraph)
+
+    def make_buttons(self):
+        self.buttonframe = tk.Frame(self, bg='black')
+        self.buttonframe.pack(side=tk.BOTTOM)
+
+        self.sliders_status_var = tk.IntVar()
+        self.sliders_status_var.set(self.use_hw_sliders)
+        self.sliders_checkbutton = tk.Checkbutton(
+            self.buttonframe,
+            text="Sliders",
+            variable=self.sliders_status_var,
+            command=lambda: self.toggle_slider_connectedness(),
+            bg='black',
+            fg='white')
+        self.sliders_checkbutton.pack(side=tk.LEFT)
+
+        self.alltozerobutton = tk.Button(self.buttonframe,
+                                         text="All to Zero",
+                                         command=self.alltozero,
+                                         bg='black',
+                                         fg='white')
+        self.alltozerobutton.pack(side='left')
+
+        self.save_stage_button = tk.Button(
+            self.buttonframe,
+            text="Save",
+            command=lambda: self.save_current_stage(self.sub_name.get()),
+            bg='black',
+            fg='white')
+        self.save_stage_button.pack(side=tk.LEFT)
+        self.sub_name = tk.Entry(self.buttonframe, bg='black', fg='white')
+        self.sub_name.pack(side=tk.LEFT)
+
+    def redraw_sliders(self) -> None:
+        self.draw_sliders()
+        if len(self.rows):
+            self.change_row(self.current_row)
+            self.rows[self.current_row].focus()
+
+        self.stop_frequent_update_time = 0
+
+    def draw_sliders(self):
+        for r in self.rows:
+            r.destroy()
+        self.rows = []
+        for b in list(self.subbox.values()):
+            b.cleanup()
+        self.subbox.clear()
+        self.slider_table.clear()
+
+        self.tk_focusFollowsMouse()
+
+        rowcount = -1
+        col = 0
+        last_group = None
+
+        withgroups = []
+        for effect in self.graph.subjects(RDF.type, L9['Effect']):
+            withgroups.append((self.graph.value(effect, L9['group']),
+                               self.graph.value(effect, L9['order']),
+                               self.graph.label(effect), effect))
+        withgroups.sort()
+
+        log.debug("withgroups %s", withgroups)
+
+        self.effectEval: Dict[URIRef, light9.effect.effecteval.EffectEval] = {}
+        imp.reload(light9.effect.effecteval)
+        simpleOutputs = SimpleOutputs(self.graph)
+        for group, order, sortLabel, effect in withgroups:
+            if col == 0 or group != last_group:
+                row = self.make_row(group)
+                rowcount += 1
+                col = 0
+
+            subbox = SubmasterBox(row, self.graph, effect, self.session, col,
+                                  rowcount)
+            subbox.place(relx=col / 8, rely=0, relwidth=1 / 8, relheight=1)
+            self.subbox[effect] = self.slider_table[(rowcount, col)] = subbox
+
+            self.setup_key_nudgers(subbox.scale)
+
+            self.effectEval[effect] = light9.effect.effecteval.EffectEval(
+                self.graph, effect, simpleOutputs)
+
+            col = (col + 1) % 8
+            last_group = group
+
+    def toggle_slider_connectedness(self):
+        self.use_hw_sliders = not self.use_hw_sliders
+        if self.use_hw_sliders:
+            self.sliders.reopen()
+        else:
+            self.sliders.close()
+        self.change_row(self.current_row)
+        self.rows[self.current_row].focus()
+
+    def connect_to_hw(self, hw_sliders):
+        log.info('connect_to_hw')
+        if hw_sliders:
+            try:
+                self.sliders = Sliders(self)
+                log.info("connected to sliders")
+            except IOError as e:
+                log.info("no hardware sliders %r", e)
+                self.sliders = DummySliders()
+                self.use_hw_sliders = False
+            dispatcher.connect(self.send_to_hw, 'send_to_hw')
+        else:
+            self.sliders = DummySliders()
+
+    def make_key_hints(self):
+        keyhintrow = tk.Frame(self)
+
+        col = 0
+        for upkey, downkey in zip(nudge_keys['up'], nudge_keys['down']):
+            # what a hack!
+            downkey = downkey.replace('semicolon', ';')
+            upkey, downkey = (upkey.upper(), downkey.upper())
+
+            # another what a hack!
+            keylabel = tk.Label(keyhintrow,
+                                text='%s\n%s' % (upkey, downkey),
+                                width=1,
+                                font=('Arial', 10),
+                                bg='red',
+                                fg='white',
+                                anchor='c')
+            keylabel.pack(side=tk.LEFT, expand=1, fill=tk.X)
+            col += 1
+
+        keyhintrow.pack(fill=tk.X, expand=0)
+        self.keyhints = keyhintrow
+
+    def setup_key_nudgers(self, tkobject):
+        for d, keys in list(nudge_keys.items()):
+            for key in keys:
+                # lowercase makes full=0
+                keysym = "<KeyPress-%s>" % key
+                tkobject.bind(keysym,
+                              lambda evt, num=keys.index(key), d=d: self.
+                              got_nudger(num, d))
+
+                # uppercase makes full=1
+                keysym = "<KeyPress-%s>" % key.upper()
+                keysym = keysym.replace('SEMICOLON', 'colon')
+                tkobject.bind(keysym,
+                              lambda evt, num=keys.index(key), d=d: self.
+                              got_nudger(num, d, full=1))
+
+        # Row changing:
+        # Page dn, C-n, and ] do down
+        # Page up, C-p, and ' do up
+        for key in '<Prior> <Next> <Control-n> <Control-p> ' \
+                   '<Key-bracketright> <Key-apostrophe>'.split():
+            tkobject.bind(key, self.change_row_cb)
+
+    def change_row_cb(self, event):
+        diff = 1
+        if event.keysym in ('Prior', 'p', 'bracketright'):
+            diff = -1
+        self.change_row(self.current_row + diff)
+
+    def rowFromGraph(self):
+        self.change_row(int(
+            self.graph.value(self.session, L9['currentRow'], default=0)),
+                        fromGraph=True)
+
+    def change_row(self, row: int, fromGraph=False) -> None:
+        old_row = self.current_row
+        self.current_row = row
+        self.current_row = max(0, self.current_row)
+        self.current_row = min(len(self.rows) - 1, self.current_row)
+        try:
+            row = self.rows[self.current_row]
+        except IndexError:
+            # if we're mid-load, this row might still appear soon. If
+            # we changed interactively, the user is out of bounds and
+            # needs to be brought back in
+            if fromGraph:
+                return
+            raise
+
+        self.unhighlight_row(old_row)
+        self.highlight_row(self.current_row)
+        self.keyhints.pack_configure(before=row)
+
+        if not fromGraph:
+            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(sub=subbox.sub, hwCol=col, boxRow=self.current_row)
+
+    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
+
+        if hasattr(self, 'pendingHwSet'):
+            import twisted.internet.error
+            try:
+                self.pendingHwSet.cancel()
+            except twisted.internet.error.AlreadyCalled:
+                pass
+        self.pendingHwSet = reactor.callLater(.01, subbox.setVal, value)
+
+    def send_to_hw(self, sub, hwCol, boxRow):
+        if isinstance(self.sliders, DummySliders):
+            return
+
+        assert isinstance(sub, URIRef), repr(sub)
+
+        if boxRow != self.current_row:
+            return
+
+        try:
+            level = self.get_levels()[sub]
+        except KeyError:
+            log.warn("%r not in %r", sub, self.get_levels())
+            raise
+        v = round(127 * level)
+        chan = "slider%s" % hwCol
+
+        # 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, group):
+        """group is a URI or None"""
+        row = tk.Frame(self, bd=2, bg='black')
+        row.subGroup = group
+
+        def onDrop(ev):
+            self.change_group(sub=URIRef(ev.data), row=row)
+            return "link"
+
+        dropTargetRegister(row,
+                           onDrop=onDrop,
+                           typeList=['*'],
+                           hoverStyle=dict(background="#555500"))
+
+        row.pack(expand=1, fill=tk.BOTH)
+        self.setup_key_nudgers(row)
+        self.rows.append(row)
+        return row
+
+    def change_group(self, sub, row):
+        """update this sub's group, and maybe other sub groups as needed, so
+        this sub displays in this row"""
+        group = row.subGroup
+        self.graph.patchObject(context=self.session,
+                               subject=sub,
+                               predicate=L9['group'],
+                               newObject=group)
+
+    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.getVal()) for uri, box in list(self.subbox.items())
+        ])
+
+    def get_output_settings(self, _graph=None):
+        _graph = _graph or self.graph
+        outputSettings = []
+        for setting in _graph.objects(self.session, L9['subSetting']):
+            effect = _graph.value(setting, L9['sub'])
+            strength = _graph.value(setting, L9['level'])
+            if strength:
+                now = time.time()
+                out, report = self.effectEval[effect].outputFromEffect(
+                    [(L9['strength'], strength)],
+                    songTime=now,
+                    # should be counting from when you bumped up from 0
+                    noteTime=now)
+                outputSettings.append(out)
+
+        return DeviceSettings.fromList(_graph, outputSettings)
+
+    def save_current_stage(self, subname):
+        log.info("saving current levels as %s", subname)
+        with self.graph.currentState() as g:
+            ds = self.get_output_settings(_graph=g)
+        effect = L9['effect/%s' % subname]
+        ctx = URIRef(showconfig.showUri() + '/effect/' + subname)
+        stmts = ds.statements(effect, ctx, effect + '/', set())
+        stmts.extend([
+            (effect, RDF.type, L9['Effect'], ctx),
+            (effect, RDFS.label, Literal(subname), ctx),
+            (effect, L9['publishAttr'], L9['strength'], ctx),
+        ])
+
+        self.graph.suggestPrefixes(ctx, {'eff': effect + '/'})
+        self.graph.patch(Patch(addQuads=stmts, delQuads=[]))
+
+        self.sub_name.delete(0, tk.END)
+
+    def alltozero(self):
+        for uri, subbox in list(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/midiC3D0', '/dev/snd/midiC2D0', '/dev/snd/midiC1D0'
+        ]
+        for dev in devices:
+            try:
+                log.info('try sliders on %s', dev)
+                BCF2000.__init__(self, dev=dev)
+            except IOError:
+                if dev is devices[-1]:
+                    raise
+            else:
+                break
+
+        self.kc = kc
+        log.info('found sliders on %s', dev)
+
+    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
+
+            if tkslider.getVal() == 1.0:
+                tkslider.setVal(0.0)
+            else:
+                tkslider.setVal(1.0)
+        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)
+
+
+def launch(opts: Any, root: tk.Tk, graph: SyncedGraph, session: URIRef):
+    tl = toplevelat("Keyboard Composer - %s" % opts.session,
+                    existingtoplevel=root,
+                    graph=graph,
+                    session=session)
+
+    kc = KeyboardComposer(tl, graph, session, hw_sliders=not opts.no_sliders)
+    kc.pack(fill=tk.BOTH, expand=1)
+
+    for helpline in ["Bindings: B3 mute"]:
+        tk.Label(root, text=helpline, font="Helvetica -12 italic",
+                 anchor='w').pack(side='top', fill='x')
+
+
+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()
+
+    log.setLevel(logging.DEBUG if opts.v else logging.INFO)
+    logging.getLogger('colormath').setLevel(logging.INFO)
+
+    graph = SyncedGraph(networking.rdfdb.url, "keyboardcomposer")
+
+    # i think this also needs delayed start (like subcomposer has), to have a valid graph
+    # before setting any stuff from the ui
+
+    root = tk.Tk()
+    initTkdnd(root.tk, 'tkdnd/trunk/')
+
+    session = clientsession.getUri('keyboardcomposer', opts)
+
+    graph.initiallySynced.addCallback(lambda _: launch(opts, root, graph,
+                                                       session))
+
+    root.protocol('WM_DELETE_WINDOW', reactor.stop)
+
+    tksupport.install(root, ms=20)
+    prof.run(reactor.run, profile=None)