them, and sends output attrs to hardware. The combining part has

custom code for some attributes.

Input can be over http or zmq.

"""

import functools

import traceback

from typing import List

from light9 import networking

from light9.collector.collector import Collector

from light9.collector.output import ArtnetDmx, DummyOutput, Output  # noqa

        client, clientSession, settings, sendTime = parseJsonMessage(await request.body())

        collector.setAttrs(client, clientSession, settings, sendTime)

        return Response('', status_code=202)

def main():

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

    try:

        # todo: drive outputs with config files

        rate = 30

        outputs: List[Output] = [

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

        reactor.callLater(.1, go)

class Sequencer(object):

    def __init__(self,

                 graph: SyncedGraph,

                 sendToCollector: Callable[[DeviceSettings], Coroutine[None ,None,None]],

                 fps=40,

                 ):

        self.graph = graph

            except Exception:

                log.warn(f"failed to build Note {note} - skipping")

                anyErrors = True

                continue

            self.notes[song].append(n)

        if not anyErrors:

    async def updateLoop(self):

        while True:

            frameStart = time.time()

            try:

                sec = await self.update()

import time

from light9 import networking

from light9.collector.collector_client_asyncio import sendToCollector

from light9.effect.sequencer.sequencer import StateUpdate, Sequencer

from light9.effect.settings import DeviceSettings

from light9.run_local import log

from louie import dispatcher

from rdfdb.syncedgraph.syncedgraph import SyncedGraph

from sse_starlette.sse import EventSourceResponse

from starlette.applications import Starlette

from starlette.routing import Route

def main():

    session = 'effectSequencer'

    graph = SyncedGraph(networking.rdfdb.url, "effectSequencer")

    logging.getLogger('autodepgraphapi').setLevel(logging.INFO)

    logging.getLogger('sse_starlette.sse').setLevel(logging.INFO)

    async def send(settings: DeviceSettings):

        await sendToCollector('effectSequencer', session, settings)

    seq = Sequencer(graph, send)

      this.graph.runHandler(this.configure.bind(this), `config ${this.uri.value}`);

      this.graph.runHandler(this.valueSync.bind(this), `valueSync ${this.uri.value}`);

    });

  }

  configure() {

    const U = this.graph.U();

    this.column = this.graph.stringValue(this.uri, U(":column"));

    this.effect = this.graph.uriValue(this.uri, U(":effectClass"));

    this.effectAttr = this.graph.uriValue(this.uri, U(":effectAttr"));

  }

valueSync() {

    this.value = this.graph.floatValue(this.uri, this.graph.Uri(":value"));

}

  onSliderInput(ev: CustomEvent) {

    this.value = (ev.target as any).valueAsNumber;

    this.graph.patchObject(this.uri, this.graph.Uri(":value"), this.graph.LiteralRoundedFloat(this.value), this.ctx);

  }

  onEffectChange(ev: CustomEvent) {

    const { newValue } = ev.detail;