class _Sender:

    def __init__(self):

        self.context = zmq.asyncio.Context()

        self.socket = self.context.socket(zmq.PUB)

        self.socket.connect('tcp://127.0.0.1:9203')  #todo: tie to :collectorZmq in graph

        # old version used: 'tcp://%s:%s' % (service.host, service.port)

    async def send(self, client: str, session: str, settings: DeviceSettings):

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

        await self.socket.send_multipart([b'setAttr', msg])

_sender = _Sender()

sendToCollector = _sender.send

async def zmqListener(collector):

    try:

        ctx = zmq.asyncio.Context()

        sock = ctx.socket(zmq.SUB)

        sock.bind('tcp://127.0.0.1:9203')

        sock.subscribe(b'setAttr')

        while True:

            [topic, msg] = await sock.recv_multipart()

            if topic != b'setAttr':

                raise ValueError(topic)

            client, clientSession, settings, sendTime = parseJsonMessage(collector.graph, msg)

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

    except:

        traceback.print_exc()

        raise

def main():

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

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

    logging.getLogger('output.allDmx').setLevel(logging.WARNING)

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

from starlette_exporter import PrometheusMiddleware, handle_metrics

from lib.background_loop import loop_forever

from light9 import networking

from light9.collector.collector_client_asyncio import sendToCollector

from light9.effect.sequencer.eval_faders import FaderEval

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

from light9.run_local import log

RATE = 20

async def changes():

    state = {}

    q = asyncio.Queue()

    def onBroadcast(update):

        state.update(update)

        q.put_nowait(None)

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

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

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

    # seq = Sequencer(graph, send)  # per-song timed notes

    faders = FaderEval(graph)  # bin/fade's untimed effects

    #@metrics('computeAndSend').time() # needs rework with async

    async def update(first_run):

        ds = faders.computeOutput()

        await sendToCollector('effectSequencer', session='0', settings=ds)

    app = Starlette(

        debug=True,

        routes=[

            Route('/updates', endpoint=send_page_updates),

        ],

    )

    app.add_middleware(PrometheusMiddleware)

    app.add_route("/metrics", handle_metrics)

    return app