lib: EffectFunctionLibrary

    uri: URIRef

    effect: EffectUri

    setEffectAttr: EffectAttr

    value: Optional[float] = None  # mutable

    def __post_init__(self):

        self.ee = EffectEval2(self.graph, self.effect, self.lib)

class FaderEval:

    """peer to Sequencer, but this one takes the current :Fader settings -> sendToCollector

    """

    def __init__(self, graph: SyncedGraph, lib: EffectFunctionLibrary):

        self.graph = graph

        self.lib = lib

        self.faders: List[Fader] = []

        self.grandMaster = 1.0

        self.graph.addHandler(self._compile)

        self.graph.addHandler(self._compileGm)

    @COMPILE.time()

    def _compile(self) -> None:

        """rebuild our data from the graph"""

        self.faders = []

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

            try:

                self.faders.append(self._compileFader(fader))

            except ValueError:

                pass

        # this could go in a second, smaller addHandler call to avoid rebuilding Fader objs constantly

        for f in self.faders:

            try:

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

            except ValueError:

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

    def _compileGm(self):

        try:

            self.grandMaster = typedValue(float, self.graph,

                                          L9.grandMaster,

                                          L9.value)

            print('got gm', self.grandMaster)

        except ValueError:

            return

    @COMPUTE_ALL_FADERS.time()

    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

                v = f.value

                v *= self.grandMaster

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

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