if arg.annotation == DeviceSettings:

                v = c.devSettings

                if v is None: # asked for ds but we have none

                    log.debug("%s asked for devs but we have none in config", self.uri)

                    return DeviceSettings(self.graph, [])

            elif arg.name == 'songTime':

                v = songTime

            else:

                eaForName = EffectAttr(L9[arg.name])

                v = self._getEffectAttrValue(eaForName, inputs)

            kw[arg.name] = v

        log.debug('calling %s with %s', c.func, kw)

        return c.func(**kw)

    def _getEffectAttrValue(self, attr: EffectAttr, inputs: EffectSettings) -> VTUnion:

        c = self.config

        if c is None:

            raise

        try:

            return inputs.getValue(self.uri, attr, defaultToZero=False)

        except KeyError:

            pass

        try:

import logging

import time

from dataclasses import dataclass

from typing import List, Optional, cast

from prometheus_client import Summary

from rdfdb import SyncedGraph

from rdflib import URIRef

from rdflib.term import Node

from light9.effect.effect_function_library import EffectFunctionLibrary

from light9.effect.effecteval2 import EffectEval2

from light9.effect.settings import DeviceSettings, EffectSettings

from light9.namespaces import L9, RDF

from light9.newtypes import EffectAttr, EffectUri, UnixTime

from light9.typedgraph import typedValue

log = logging.getLogger('seq.fader')

COMPILE = Summary('compile_graph_fader', '')

@dataclass

class Fader:

    graph: SyncedGraph

    lib: EffectFunctionLibrary

    uri: URIRef

    effect: EffectUri

    setEffectAttr: EffectAttr

    value: Optional[float] = None  # mutable

    def __post_init__(self):

                setting = typedValue(Node, self.graph, f.uri, L9['setting'])

            except ValueError:

                f.value = None

            else:

                f.value = typedValue(float, self.graph, setting, L9['value'])

    def _compileFader(self, fader: URIRef) -> Fader:

        effect = typedValue(EffectUri, self.graph, fader, L9['effect'])

        setting = typedValue(Node, self.graph, fader, L9['setting'])

        setAttr = typedValue(EffectAttr, self.graph, setting, L9['effectAttr'])

        return (Fader(self.graph, self.lib, cast(URIRef, fader), effect, setAttr))

    def computeOutput(self) -> DeviceSettings:

        faderEffectOutputs: List[DeviceSettings] = []

        now = UnixTime(time.time())

        for f in self.faders:

            try:

                if f.value is None:

                    log.warning(f'{f.value=}; should be set during _compile. Skipping {f.uri}')

                    continue

                effectSettings = EffectSettings(self.graph, [(f.effect, f.setEffectAttr, f.value)])

                ds = f.ee.compute(now, effectSettings)

                faderEffectOutputs.append(ds)

            except Exception:

                log.warning(f'on fader {f}')

                raise

        return DeviceSettings.merge(self.graph, faderEffectOutputs)

        if now > lastSend + .2:

            lastSend = now

            yield json.dumps(state)

async def send_page_updates(request):

    return EventSourceResponse(changes())

def main():

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

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

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

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

    lib = EffectFunctionLibrary(graph)

    faders = FaderEval(graph, lib)  # 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)

    faders_loop = loop_forever(func=update, metric_prefix='faders', sleep_period=1 / RATE)