asyncio.create_task(self.flusher())

    def addClient(self, client: UiListener):

        self.clients.append((client, {}))  # seen = {dev: attrs}

        log.info('added client %s %s', len(self.clients), client)

        # todo: it would be nice to immediately fill in the client on the

        # latest settings, but I lost them so I can't.

    def delClient(self, client: UiListener):

        self.clients = [(c, t) for c, t in self.clients if c != client]

        log.info('delClient %s, %s left', client, len(self.clients))

        """called often- don't be slow"""

        self.pendingMessageForDev[dev] = (attrs, outputMap)

        # maybe put on a stack for flusher or something

    async def flusher(self):

        await asyncio.sleep(3)  # help startup faster?

        while True:

            await self._flush()

            await asyncio.sleep(.05)

    async def _flush(self):

        now = time.time()

from PIL import Image

import random

SKY = Namespace('http://light9.bigasterisk.com/theater/skyline/device/')

random.seed(0)

log = logging.getLogger('effecteval')

log.info("reload effecteval")

def literalColor(rnorm, gnorm, bnorm):

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 __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

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

        if strength <= 0:

            return DeviceSettings(self.graph, []), {'zero': True}

        report = {}

        out: Dict[Tuple[URIRef, URIRef], Any] = {}  # (dev, attr): value

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

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

            try:

                func = globals()[tail]

            except KeyError:

                report['error'] = 'effect code not found for %s' % self.effect

            else:

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

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

        return DeviceSettings(self.graph, outList), report

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

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

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

        out.update({

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

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

        })

        ang = songTime * 4

        out.update({

        })

    return out

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

    out = {}

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

    print(effectSettings)

    tr, tg, tb = hex_to_rgb(tint)

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

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

        col = literalColorHsv((songTime + (n / 5)) % 1, 1, scl)

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

        out.update({

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

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

        })

        ang = songTime * 4

        out.update({

        })

    return out

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

    dev = L9['device/q2']

    dur = 4

    return {

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

        (dev, L9['focus']): 0.589,

        (dev, L9['rx']): lerp(0.778, 0.291, clamp(0, 1, noteTime / dur)),

        (dev, L9['ry']): 0.5,

        (dev, L9['zoom']): 0.714,

    }

def effect_pulseRainbow(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

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

        out.update({

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

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

        })

        out.update({

            (dev, L9['rx']): lerp(.27, .7, (n - 1) / 4),

            (dev, L9['ry']): lerp(.46, .52, (n - 1) / 4),

        })

    return out

    period = float(effectSettings.get(L9['period'], 2))

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

    col = scale(col, effectSettings.get(L9['strength'], 1))

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

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

        out.update({

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

            (dev, L9['zoom']): effectSettings.get(L9['zoom'], .5),

        })

        out.update({

        })

    return out

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

    out = {}

    period = float(effectSettings.get(L9['period'], 2))

    colmap = {

        1: '#ff0000',

        2: '#998888',

        3: '#0050ff',

    }

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

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

        out.update({

        })

        out.update({

        })

    return out

chase1_members = [

    DEV['backlight1'],

    DEV['lip1'],

    DEV['backlight2'],

    DEV['down2'],

    DEV['lip2'],

    DEV['backlight3'],

    DEV['down3'],

        (dev, L9['rx']): lerp(.65, 1, nsin(songTime / 2.0)),

        (dev, L9['ry']): .6,

        (dev, L9['zoom']): 1,

    }

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

    rate = 2

    duty = .3

    offset = 0

    f = (((songTime + offset) * rate) % 1.0)

    c = (f < duty) * strength

    return {(L9['device/colorStrip'], L9['color']): Literal(col)}

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

    devs = [

    ]

    out = {}

    for i, dev in enumerate(devs):

        n = noise(songTime * 8 + i * 6.543)

        if n > .4:

            out[(dev, L9['color'])] = col

    return out

def sample8(img, x, y, repeat=False):

    if not (0 <= y < img.height):

        return (0, 0, 0)

    if 0 <= x < img.width:

        return img.getpixel((x, y))

        ('down6', 16),

        ('down7', 17),

    ]:

        color8 = sample8(img, x, y, effectSettings.get(L9['repeat'], True))

        color = map(lambda v: v / 255 * strength, color8)

        color = [v * cs / 255 for v, cs in zip(color, colorScale)]

        if dev in ['cyc1', 'cyc2', 'cyc3', 'cyc4']:

            column = dev[-1]

            out[(SKY[f'cycRed{column}'], L9['brightness'])] = color[0]

            out[(SKY[f'cycGreen{column}'], L9['brightness'])] = color[1]

            out[(SKY[f'cycBlue{column}'], L9['brightness'])] = color[2]

        else:

    return out

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

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

    r, g, b = map(lambda x: strength * x / 255, hex_to_rgb(colorScale))

    out = {

        (SKY['cycRed1'], L9['brightness']): r,

        (SKY['cycRed2'], L9['brightness']): r,

        (SKY['cycRed3'], L9['brightness']): r,

        (SKY['cycRed4'], L9['brightness']): r,

            })

    return out

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

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

    r, g, b = map(lambda x: x / 255, hex_to_rgb(colorScale))

    out = {}

    speed = 10

    gamma = .6

    for dev in [SKY['strip1'], SKY['strip2'], SKY['strip3']]:

        out[(dev, L9['color'])] = scale(

    return out

        self.notifier.watch(FilePath(effecteval.__file__.replace('.pyc',

                                                                 '.py')),

                            callbacks=[self.codeChange])

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

        def go():

            log.info("reload effecteval")

            imp.reload(effecteval)

            self.onChange()

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

class Sequencer(object):

    """Notes from the graph + current song playback -> sendToCollector"""

    def __init__(self,

                 graph: SyncedGraph,

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

                 fps=40,

                 ):

        self.graph = graph

        self.fps = fps

        metrics('update_loop_goal_fps').set(self.fps)

        metrics('update_loop_goal_latency').set(1 / self.fps)

        self.sendToCollector = sendToCollector

        self.recentUpdateTimes: List[float] = []

        self.lastStatLog = 0.0

        self._compileGraphCall = None

        self.notes: Dict[Song, List[Note]] = {}  # song: [notes]

        self.simpleOutputs = SimpleOutputs(self.graph)

        self.graph.addHandler(self.compileGraph)

        self.lastLoopSucceeded = False

        # self.codeWatcher = CodeWatcher(onChange=self.onCodeChange)

        asyncio.create_task(self.updateLoop())

                noteReports.append(report)

                settings.append(s)

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

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

        with metrics('update_s3_send').time():  # our measurement

            sendSecs = await self.sendToCollector(devSettings)

        # sendToCollector's own measurement.

        # (sometimes it's None, not sure why, and neither is mypy)

        #if isinstance(sendSecs, float):

        #    metrics('update_s3_send_client').observe(sendSecs)

"""

plays back effect notes from the timeline (and an untimed note from the faders)

"""

import asyncio

import json

import logging

import time

from light9 import networking

from light9.collector.collector_client_asyncio import sendToCollector

from light9.effect.settings import DeviceSettings

from light9.metrics import metrics

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

from starlette.types import Receive, Scope, Send

from starlette_exporter import PrometheusMiddleware, handle_metrics

import traceback

from light9.namespaces import L9, RDF

from light9.effect.scale import scale

from typing import Dict, List, Tuple, Any

from rdflib import URIRef

class SimpleOutputs(object):

    def __init__(self, graph):

        self.graph = graph

        # effect : [(dev, attr, value, isScaled)]

        self.graph.addHandler(self.updateEffectsFromGraph)

    def updateEffectsFromGraph(self):

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

            settings = []

            for setting in self.graph.objects(effect, L9['setting']):

                settingValues = dict(self.graph.predicate_objects(setting))

                try:

                    d = settingValues.get(L9['device'], None)

                    a = settingValues.get(L9['deviceAttr'], None)

                    v = settingValues.get(L9['value'], None)