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.slider_var.get())

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

    def get_output_settings(self, _graph=None):

        _graph = _graph or 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()

        return DeviceSettings.fromList(_graph, outputSettings)

    def save_current_stage(self, subname):

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

        with 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),

            ])

        graph.suggestPrefixes(ctx, {'eff': effect + '/'})

        graph.patch(Patch(addQuads=stmts, delQuads=[]))

        self.sub_name.delete(0, tk.END)

    def send_frequent_updates(self):

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

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

            self.send_levels()

            self.after(10, self.send_frequent_updates)

    def alltozero(self):

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

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

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

# move to web lib

def postArgGetter(request):

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

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

    support for repeated args."""

    # this is something nevow normally does for me

    request.content.seek(0)

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

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

    def getArg(n):

        try:

            return request.args[n][0]

        except KeyError:

            return fields[n].value

    return getArg

from decimal import Decimal

import math

import traceback

from noise import pnoise1

import logging

import time

from light9.effect.settings import DeviceSettings

from light9.effect.scale import scale

log = logging.getLogger('effecteval')

def literalColor(rnorm, gnorm, bnorm):

    return Literal(rgb_to_hex([int(rnorm * 255), int(gnorm * 255), int(bnorm * 255)]))

def literalColorHsv(h, s, v):

    return literalColor(*hsv_to_rgb(h, s, v))

def nsin(x): return (math.sin(x * (2 * math.pi)) + 1) / 2

def ncos(x): return (math.cos(x * (2 * math.pi)) + 1) / 2

def nsquare(t, on=.5):

    return (t % 1.0) < on

def lerp(a, b, t):

    return a + (b - a) * t

def noise(t):

    return pnoise1(t % 1000.0, 2)

class EffectEval(object):

    """

    runs one effect's code to turn effect attr settings into output

    device settings. No state; suitable for reload().

    """

    def __init__(self, graph, effect, simpleOutputs):

        self.graph = graph

        self.effect = effect

        self.simpleOutputs = simpleOutputs

    def outputFromEffect(self, effectSettings, songTime, noteTime):

        """

        From effect attr settings, like strength=0.75, to output device

        settings like light1/bright=0.72;light2/bright=0.78. This runs

        the effect code.

        """

        # both callers need to apply note overrides

        effectSettings = dict(effectSettings) # we should make everything into nice float and Color objects too

        strength = float(effectSettings[L9['strength']])

        if strength <= 0:

        out = {} # (dev, attr): value

        out.update(self.simpleOutputs.values(

            self.effect, strength, effectSettings.get(L9['colorScale'], None)))

        if self.effect.startswith(L9['effect/']):

            tail = 'effect_' + self.effect[len(L9['effect/']):]

            try:

                func = globals()[tail]

            except KeyError:

            else:

                out.update(func(effectSettings, strength, songTime, noteTime))

        outList = [(d, a, v) for (d, a), v in out.iteritems()]

def effect_Curtain(effectSettings, strength, songTime, noteTime):

    return {

        (L9['device/lowPattern%s' % n], L9['color']):

        literalColor(strength, strength, strength)

        for n in range(301,308+1)

        }

def effect_animRainbow(effectSettings, strength, songTime, noteTime):

    out = {}

    tint = effectSettings.get(L9['tint'], '#ffffff')

    tintStrength = float(effectSettings.get(L9['tintStrength'], 0))

    tr, tg, tb = hex_to_rgb(tint)

    for n in range(1, 5+1):

        scl = strength * nsin(songTime + n * .3)**3

        col = literalColor(

            scl * lerp(nsin(songTime + n * .2), tr/255, tintStrength),

            scl * lerp(nsin(songTime + n * .2 + .3), tg/255, tintStrength),

            scl * lerp(nsin(songTime + n * .3 + .6), tb/255, tintStrength))

        dev = L9['device/aura%s' % n]

        out.update({

            (dev, L9['color']): col,

            (dev, L9['zoom']): .9,

            })

        ang = songTime * 4

        out.update({

        (dev, L9['rx']): lerp(.27, .7, (n-1)/4) + .2 * math.sin(ang+n),

        (dev, L9['ry']): lerp(.46, .52, (n-1)/4) + .5 * math.cos(ang+n),

            })

    return out

def effect_auraSparkles(effectSettings, strength, songTime, noteTime):

    out = {}

    tint = effectSettings.get(L9['tint'], '#ffffff')

    tintStrength = float(effectSettings.get(L9['tintStrength'], 0))

    print effectSettings

    tr, tg, tb = hex_to_rgb(tint)

    for n in range(1, 5+1):

        scl = strength * ((int(songTime * 10) % n) < 1)

        col = scale('#ffffff', scl)

        print n, 'scl', col

        dev = L9['device/aura%s' % n]

        out.update({

            (dev, L9['color']): col,

            (dev, L9['zoom']): .95,

<!doctype html>

<html>

  <head>

    <title>effect sequencer</title>

    <meta charset="utf-8" />

    <script src="/node_modules/@webcomponents/webcomponentsjs/webcomponents-lite.js"></script>

    <link rel="import" href="/lib/polymer/polymer.html">

    <link rel="import" href="/lib/iron-ajax/iron-ajax.html">

    <link rel="import" href="../rdfdb-synced-graph.html">

    <link rel="import" href="../resource-display.html">

    <script src="/node_modules/n3/n3-browser.js"></script> 

    <script src="/lib/async/dist/async.js"></script>

    <script src="/lib/underscore/underscore-min.js"></script>

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

  </head>

  <body>

      <template>

        <style>

         :host {

             display: block;

         }

         }

         }

         }

        </style>

          <tr>

          </tr>

            </tr>

          </template>

      </template>

      <script>

       HTMLImports.whenReady(function () {

       });

      </script>

    </dom-module>

  </body>

</html>

'''

copies from effectloop.py, which this should replace

'''

from __future__ import division

from twisted.internet import reactor, defer

from twisted.internet.inotify import INotify

from twisted.python.filepath import FilePath

from light9 import networking

from light9.namespaces import L9, RDF

from light9.vidref.musictime import MusicTime

from light9.effect import effecteval

from light9.effect.settings import DeviceSettings

from light9.effect.simple_outputs import SimpleOutputs

from greplin import scales

from txzmq import ZmqEndpoint, ZmqFactory, ZmqPushConnection

log = logging.getLogger('sequencer')

stats = scales.collection('/sequencer/',

                          scales.PmfStat('update'),

                          scales.PmfStat('compileGraph'),

                          scales.PmfStat('compileSong'),

                          scales.DoubleStat('recentFps'),

)

_zmqClient=None

class TwistedZmqClient(object):

    def __init__(self, service):

        zf = ZmqFactory()

        e = ZmqEndpoint('connect', 'tcp://%s:%s' % (service.host, service.port))

        self.conn = ZmqPushConnection(zf, e)

    def send(self, msg):

        self.conn.push(msg)

def toCollectorJson(client, session, settings):

    assert isinstance(settings, DeviceSettings)

    return json.dumps({'settings': settings.asList(),

                       'client': client,

                       'clientSession': session,

                       'sendTime': time.time(),

                  })

def sendToCollectorZmq(msg):

    global _zmqClient

    if _zmqClient is None:

        _zmqClient = TwistedZmqClient(networking.collectorZmq)

    _zmqClient.send(msg)

    return defer.succeed(0)

def sendToCollector(client, session, settings, useZmq=True):

    """deferred to the time in seconds it took to get a response from collector"""

    sendTime = time.time()

        self.baseEffectSettings = {}  # {effectAttr: value}

        for s in g.objects(uri, L9['setting']):

            settingValues = dict(g.predicate_objects(s))

            ea = settingValues[L9['effectAttr']]

            self.baseEffectSettings[ea] = settingValues[L9['value']]

        floatVal = lambda s, p: float(g.value(s, p).toPython())

        originTime = floatVal(uri, L9['originTime'])

        self.points = []

        for curve in g.objects(uri, L9['curve']):

            self.points.extend(

                self.getCurvePoints(curve, L9['strength'], originTime))

        self.points.sort()

    def getCurvePoints(self, curve, attr, originTime):

        points = []

        po = list(self.graph.predicate_objects(curve))

        if dict(po).get(L9['attr'], None) != attr:

            return []

        for point in [row[1] for row in po if row[0] == L9['point']]:

            po2 = dict(self.graph.predicate_objects(point))

            points.append((

                originTime + float(po2[L9['time']]),

                float(po2[L9['value']])))

        return points

    def activeAt(self, t):

        return self.points[0][0] <= t <= self.points[-1][0]

    def evalCurve(self, t):

        i = bisect.bisect_left(self.points, (t, None)) - 1

        if i == -1:

            return self.points[0][1]

        if self.points[i][0] > t:

            return self.points[i][1]

        if i >= len(self.points) - 1:

            return self.points[i][1]

        p1, p2 = self.points[i], self.points[i + 1]

        frac = (t - p1[0]) / (p2[0] - p1[0])

        y = p1[1] + (p2[1] - p1[1]) * frac

        return y

    def outputSettings(self, t):

        """

        list of (device, attr, value), and a report for web

        """

        effectSettings = self.baseEffectSettings.copy()

        effectSettings[L9['strength']] = self.evalCurve(t)

        report['effectSettings'] = dict(

            (str(k), str(v))

            for k,v in sorted(effectSettings.items()))

            effectSettings.items(),

            songTime=t,

            # note: not using origin here since it's going away

            noteTime=t - self.points[0][0])

        return out, report

class CodeWatcher(object):

    def __init__(self, onChange):

        self.onChange = onChange

        self.notifier = INotify()

        self.notifier.startReading()

        self.notifier.watch(

            FilePath(effecteval.__file__.replace('.pyc', '.py')),

            callbacks=[self.codeChange])

    def codeChange(self, watch, path, mask):

        def go():

            log.info("reload effecteval")

            reload(effecteval)

            self.onChange()

        # in case we got an event at the start of the write

        reactor.callLater(.1, go) 

class Sequencer(object):

    def __init__(self, graph, sendToCollector, fps=40):

        self.graph = graph

        self.fps = fps

        self.sendToCollector = sendToCollector

        self.music = MusicTime(period=.2, pollCurvecalc=False)

        self.recentUpdateTimes = []

        self.lastStatLog = 0

        self._compileGraphCall = None

        self.notes = {} # song: [notes]

        self.simpleOutputs = SimpleOutputs(self.graph)

        self.graph.addHandler(self.compileGraph)

        self.update()

        self.codeWatcher = CodeWatcher(

            onChange=lambda: self.graph.addHandler(self.compileGraph))

    @stats.compileGraph.time()

    def compileGraph(self):

        """rebuild our data from the graph"""

        t1 = time.time()

        g = self.graph

        for song in g.subjects(RDF.type, L9['Song']):

            self.graph.addHandler(lambda song=song: self.compileSong(song))

        log.info('compileGraph took %.2f ms', 1000 * (time.time() - t1))

    @stats.compileSong.time()

    def compileSong(self, song):

        t1 = time.time()

        self.notes[song] = []

        for note in self.graph.objects(song, L9['note']):

            self.notes[song].append(Note(self.graph, note, effecteval,

                                         self.simpleOutputs))

        log.info('  compile %s took %.2f ms', song, 1000 * (time.time() - t1))

    @stats.update.time()

    def update(self):

        now = time.time()

        stats.recentFps = len(self.recentUpdateTimes) / (self.recentUpdateTimes[-1] - self.recentUpdateTimes[0] + .0001)

            self.lastStatLog = now

        reactor.callLater(1 / self.fps, self.update)

        musicState = self.music.getLatest()

        song = URIRef(musicState['song']) if musicState.get('song') else None

        if 't' not in musicState:

            return

        t = musicState['t']

        settings = []

        noteReports = []

        for note in songNotes:

            s, report = note.outputSettings(t)

            noteReports.append(report)

            settings.append(s)

        dispatcher.send('state', update={'songNotes': noteReports})

        self.sendToCollector(DeviceSettings.fromList(self.graph, settings))

class Updates(cyclone.sse.SSEHandler):

    def __init__(self, application, request, **kwargs):

        cyclone.sse.SSEHandler.__init__(self, application, request,

                                        **kwargs)

        self.state = {}

        dispatcher.connect(self.updateState, 'state')

        self.numConnected = 0

    def updateState(self, update):

        self.state.update(update)

    def bind(self):

        self.numConnected += 1

        if self.numConnected == 1:

            self.loop()

    def loop(self):

        if self.numConnected == 0:

            return

        self.sendEvent(self.state)

    def unbind(self):

        self.numConnected -= 1