json.loads(message)

)

    try:

        # todo: drive outputs with config files

        outputs = [

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

        ]

    except Exception:

    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.

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()

stats = scales.collection(

    '/collectorClient/',

    scales.PmfStat('send'),

class TwistedZmqClient(object):

    def send(self, msg):

        self.conn.push(msg)

def toCollectorJson(client, session, settings) -> str:

    assert isinstance(settings, DeviceSettings)

    return json.dumps({

    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')

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

    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']:

    _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

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(

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

        return y

        """

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

        """

            '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()),

class Sequencer(object):

        self.graph = graph

        self.fps = fps

        updateStats.goalFps = self.fps

    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()

        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,

        def err(e):

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

            reactor.callLater(2, self.updateLoop)

        d.addCallbacks(done, err)

    @updateStats.updateFps.rate()

        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'])

            with updateStats.s2_sendToWeb.time():

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

            return self.sendToCollector(devSettings)

        except Exception:

            traceback.print_exc()

        except Exception:

            traceback.print_exc()

            return

def startZmq(port, collector):

    )

    zf = ZmqFactory()