dt1 = time.time() - now

        self._updateOutputs(pendingOut)

        dt2 = time.time() - dt1

        if dt1 > .030 or dt2 > .030:

            log.warning("slow setAttrs: prepare %.1fms -> updateOutputs %.1fms" % (dt1 * 1000, dt2 * 1000))

    def _warnOnLateRequests(self, client, now, sendTime):

        requestLag = now - sendTime

        if requestLag > .1 and now > self._initTime + 10 and getattr(self, '_lastWarnTime', 0) < now - 3:

            self._lastWarnTime = now

            log.warning('collector.setAttrs from %s is running %.1fms after the request was made', client, requestLag * 1000)

    def _forgetStaleClients(self, now):

        staleClientSessions = []

        for clientSession, (reqTime, _) in self.lastRequest.items():

            if reqTime < now - self.clientTimeoutSec:

                staleClientSessions.append(clientSession)

        for clientSession in staleClientSessions:

            log.info('forgetting stale client %r', clientSession)

            del self.lastRequest[clientSession]

    # todo: move to settings.py

        out: Dict[Tuple[DeviceUri, DeviceAttr], VTUnion] = {}

            if (devUri, devAttr) in out:

                existingVal = out[(devUri, devAttr)]

                out[(devUri, devAttr)] = resolve(self._deviceType[devUri], devAttr, [existingVal, val])

            else:

                out[(devUri, devAttr)] = val

        return out

    def _merge(self, lastRequests):

        deviceAttrs: Dict[DeviceUri, Dict[DeviceAttr, VTUnion]] = {}  # device: {deviceAttr: value}

        for _, lastSettings in lastRequests:

            for (device, deviceAttr), value in lastSettings.items():

                if (device, deviceAttr) in self.remapOut:

                    start, end = self.remapOut[(device, deviceAttr)]

                    value = start + float(value) * (end - start)

                attrs = deviceAttrs.setdefault(device, {})

                if deviceAttr in attrs:

                    value = resolve(device, deviceAttr, [attrs[deviceAttr], value])

                attrs[deviceAttr] = value

                # list should come from the graph. these are attrs

                # that should default to holding the last position,

                # not going to 0.

                if deviceAttr in [L9['rx'], L9['ry'], L9['zoom'], L9['focus']]:

                    self.stickyAttrs[(device, deviceAttr)] = cast(float, value)

    def __init__(self, listeners, scope: Scope, receive: Receive, send: Send) -> None:

        super().__init__(scope, receive, send)

        self.listeners = listeners

    async def on_connect(self, websocket: WebSocket):

        await websocket.accept()

        log.info('socket connect %s', self.scope['client'])

        self.websocket = websocket

        self.listeners.addClient(self)

    async def sendMessage(self, msgText):

        await self.websocket.send_text(msgText)

    # async def on_receive(self, websocket, data):

    #     json.loads(data)

    async def on_disconnect(self, websocket: WebSocket, close_code: int):

        self.listeners.delClient(self)

    pass

async def PutAttrs(collector: Collector, request):

    with STAT_SETATTR.time():

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

        return Response('', status_code=202)

def main():

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

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

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

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

    try:

        # todo: drive outputs with config files

        rate = 30

        outputs: List[Output] = [

            # ArtnetDmx(L9['output/dmxA/'],

            #           host='127.0.0.1',

            #           port=6445,

            #           rate=rate),

            #sudo chmod a+rw /dev/bus/usb/003/021

            Udmx(L9['output/dmxA/'], bus=3, address=21, lastDmxChannel=100),

        ]

    except Exception:

        log.error("setting up outputs:")

import logging

import math

import random

from colorsys import hsv_to_rgb

from dataclasses import dataclass

from typing import Dict, Tuple

from noise import pnoise1

from PIL import Image

from rdfdb.syncedgraph.syncedgraph import SyncedGraph

from rdflib import Literal, Namespace

from webcolors import hex_to_rgb, rgb_to_hex

from light9.effect.scale import scale

from light9.effect.simple_outputs import SimpleOutputs

from light9.namespaces import DEV, L9

from light9.newtypes import (DeviceAttr, DeviceUri, EffectAttr, EffectClass, VTUnion)

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

    return Literal(rgb_to_hex((

        int(rnorm * 255),  #

        int(gnorm * 255),  #

        int(bnorm * 255))))

def literalColorHsv(h, s, v):

    return literalColor(*hsv_to_rgb(h, s, v))

def nsin(x):

def clamp(lo, hi, x):

    return max(lo, min(hi, x))

def clamp255(x):

    return min(255, max(0, x))

def _8bit(f):

    if not isinstance(f, (int, float)):

        raise TypeError(repr(f))

    return clamp255(int(f * 255))

@dataclass

class EffectEval:

    """

    runs one effect's code to turn effect attr settings into output

    device settings. No state; suitable for reload().

    """

    graph: SyncedGraph

    effect: EffectClass

    simpleOutputs: SimpleOutputs

        """

        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.s[EffectAttr(L9['strength'])])

        if strength <= 0:

        report = {}

        out.update(self.simpleOutputs.values(self.effect, strength, effectSettings.s.get(EffectAttr(L9['colorScale']), None)))

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

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

    return {(L9['device/lowPattern%s' % n], L9['color']): literalColor(strength, strength, strength) for n in range(301, 308 + 1)}

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

        col = literalColor(scl * lerp(nsin(songTime + n * .2), tr / 255, tintStrength), scl * lerp(nsin(songTime + n * .2 + .3), tg / 255, tintStrength),

                           scl * lerp(nsin(songTime + n * .3 + .6), tb / 255, tintStrength))

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

        out.update({

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

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

        })

        ang = songTime * 4

        out.update({

            (dev, L9['rx']): lerp(.27, .7, (n - 1) / 4) + .2 * math.sin(ang + n),