self.settings.listeners.delClient(self)

    def messageReceived(self, message):

        json.loads(message)

)

class Attrs(PrettyErrorHandler, cyclone.web.RequestHandler):

    def put(self):

def launch(graph, doLoadTest=False):

    try:

        # todo: drive outputs with config files

        outputs = [

            DummyOutput(L9['output/dmxB/']),

        ]

    except Exception:

        log.error("setting up outputs:")

        traceback.print_exc()

        raise

            scales.PmfStat('sendOutput'),

            scales.IntStat('errors'),

        )

    def launch(self, *args):

        self.seq = Sequencer(

                # This seems to be safe here (and lets us get from

                # 20fpx to 40fpx), even though it leads to big stalls

                # if I use it on KC.

                useZmq=True))

        self.cycloneApp = cyclone.web.Application(handlers=[

from rdfdb.syncedgraph import SyncedGraph

import time, logging

from light9 import networking, showconfig

from light9.namespaces import L9

class BusyClient:

    def __init__(self, subj, rate):

        self.subj = subj

        self.rate = rate

        self.graph = SyncedGraph(networking.rdfdb.url, "collector")

        self.graph.initiallySynced.addCallback(self.go)

    def go(self, _):

        task.LoopingCall(self.loop).start(1 / self.rate)

    def loop(self):

        self.graph.patchObject(showconfig.showUri() + '/loadTestContext',

                               subject=self.subj,

def main():

    log.setLevel(logging.INFO)

    clients = [BusyClient(L9['loadTest_%d' % i], 20) for i in range(10)]

    reactor.run()

if __name__ == "__main__":

    main()

_zmqClient = None

stats = scales.collection(

    '/collectorClient/',

    scales.PmfStat('send'),

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) -> str:

    assert isinstance(settings, DeviceSettings)

    return json.dumps({

        'settings': settings.asList(),

        'client': client,

        'clientSession': session,

    if _zmqClient is None:

        _zmqClient = TwistedZmqClient(networking.collectorZmq)

    _zmqClient.send(msg)

    return defer.succeed(0.0)

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

    sendTime = time.time()

    msg = toCollectorJson(client, session, settings).encode('utf8')

    if useZmq:

        d = sendToCollectorZmq(msg)

    if deviceAttr == DeviceAttr(L9['color']):

        rgbs = [hex_to_rgb(v) for v in values]

        return rgb_to_hex([max(*component) for component in zip(*rgbs)])

    # incomplete. how-to-resolve should be on the DeviceAttr defs in the graph.

    if deviceAttr in map(

            DeviceAttr,

        floatVals = []

        for v in values:

            if isinstance(v, Literal):

                floatVals.append(float(v.toPython()))

            elif isinstance(v, (int, float)):

                floatVals.append(float(v))

        if deviceAttrSettings.get(attr) == L9['g2']:

            return 10

        return 0

    if deviceType == L9['ChauvetColorStrip']:

        r, g, b = rgbAttr(L9['color'])

    elif deviceType == L9['Bar612601']:

        r, g, b = rgbAttr(L9['color'])

        return {L9['red']: r, L9['green']: g, L9['blue']: b}

    elif deviceType == L9['LedPar90']:

        r, g, b = rgbAttr(L9['color'])

    elif deviceType == L9['LedPar54']:

        r, g, b = rgbAttr(L9['color'])

    elif deviceType == L9['SimpleDimmer']:

        return {L9['level']: _8bit(floatAttr(L9['brightness']))}

    elif deviceType == L9['Mini15']:

        out = {

            L9['rotationSpeed']: 0,  # seems to have no effect

            L9['dimmer']: 255,

            self._lastLoggedMsg = msg

    _writeSucceed = scales.IntStat('write/succeed')

    _writeFail = scales.IntStat('write/fail')

    _writeCall = scales.PmfStat('write/call')

    _writeFps = scales.RecentFpsStat('write/fps')

    def _write(self, buf: bytes) -> None:

        """

        write buffer to output hardware (may be throttled if updates are

        too fast, or repeated if they are too slow)

        """

        pass

from rdfdb.syncedgraph import SyncedGraph

from greplin import scales

import imp

log = logging.getLogger('sequencer')

updateStats = scales.collection(

    '/update/',

    scales.PmfStat('s0_getMusic'),

    scales.PmfStat('s2_sendToWeb'),

    scales.PmfStat('s3_send'),

    scales.PmfStat('sendPhase'),

    scales.PmfStat('updateLoopLatency'),

    scales.DoubleStat('updateLoopLatencyGoal'),

    scales.RecentFpsStat('updateFps'),

    scales.DoubleStat('goalFps'),

compileStats = scales.collection(

    '/compile/',

    scales.PmfStat('graph'),

    scales.PmfStat('song'),

class Note(object):

        g = self.graph = graph

        self.uri = uri

        self.effectEval = effectevalModule.EffectEval(

            graph, g.value(uri, L9['effectClass']), simpleOutputs)

        self.baseEffectSettings: Dict[URIRef, Any] = {}  # {effectAttr: value}

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

        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

        """

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

        """

        report = {

            'note': str(self.uri),

            'effectClass': self.effectEval.effect,

        }

        effectSettings: Dict[DeviceAttr, Union[float, str]] = dict(

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

        def prettyFormat(x: Union[float, str]):

            if isinstance(x, float):

                return round(x, 4)

            return x

        report['effectSettings'] = dict(

        report['nonZero'] = cast(float, effectSettings[L9['strength']]) > 0

        out, evalReport = self.effectEval.outputFromEffect(

            list(effectSettings.items()),

            songTime=t,

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

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

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

        reactor.callLater(.1, go)

class Sequencer(object):

        self.graph = graph

        self.fps = fps

        updateStats.goalFps = self.fps

        updateStats.updateLoopLatencyGoal = 1 / self.fps

        self.sendToCollector = sendToCollector

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

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

    @compileStats.graph.time()

    def compileGraph(self) -> None:

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

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

            def compileSong(song: Song = cast(Song, song)) -> None:

                self.compileSong(song)

            self.graph.addHandler(compileSong)

    @compileStats.song.time()

    def compileSong(self, song: Song) -> None:

        self.notes[song] = []

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

    def updateLoop(self) -> None:

        frameStart = time.time()

        d = self.update()

        sendStarted = time.time()

        def done(sec: float):

            took = time.time() - frameStart

            delay = max(0, 1 / self.fps - took)

            updateStats.updateLoopLatency = took

            # time to send to collector, reported by collector_client

                updateStats.s3_send = sec

            # time to send to collector, measured in this function,

            # from after sendToCollector returned its deferred until

            # when the deferred was called.

            updateStats.sendPhase = time.time() - sendStarted

            reactor.callLater(delay, self.updateLoop)

        def err(e):

            log.warn('updateLoop: %r', e)

            reactor.callLater(2, self.updateLoop)

        d.addCallbacks(done, err)

    @updateStats.updateFps.rate()

    def update(self) -> defer.Deferred:

        try:

            with updateStats.s0_getMusic.time():

                musicState = self.music.getLatest()

                    return defer.succeed(0.0)

                song = Song(URIRef(musicState['song']))

            with updateStats.s1_eval.time():

                settings = []

                noteReports = []

                for note in songNotes:

                    s, report = note.outputSettings(musicState['t'])

                    noteReports.append(report)

                    settings.append(s)

                devSettings = DeviceSettings.fromList(self.graph, settings)

            with updateStats.s2_sendToWeb.time():

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

            return self.sendToCollector(devSettings)

        except Exception:

            traceback.print_exc()

            raise

        try:

            with self.graph.currentState() as g:

                outputSettings = self.get_output_settings(_graph=g)

        except Exception:

            traceback.print_exc()

            return

            value = Literal(value)

        settings.append((URIRef(device), URIRef(attr), value))

    return body['client'], body['clientSession'], settings, body['sendTime']

def startZmq(port, collector):

    )

    zf = ZmqFactory()

    addr = 'tcp://*:%s' % port

    log.info('creating zmq endpoint at %r', addr)

    e = ZmqEndpoint('bind', addr)