effectFunction = typedValue(EffectFunction, self.graph, self.uri, L9['effectFunction'])

            effSets = []

            devSettings = None

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

                attr = typedValue(EffectAttr, self.graph, s, L9['effectAttr'])

                if attr == L9['deviceSettings']:

                    value = typedValue(Node, self.graph, s, L9['value'])

                    rows = []

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

                        d = typedValue(DeviceUri, self.graph, ds, L9['device'])

                        da = typedValue(DeviceAttr, self.graph, ds, L9['deviceAttr'])

                        v = typedValue(VTUnion, self.graph, ds, L9['value'])

                        rows.append((d, da, v))

                    devSettings = DeviceSettings(self.graph, rows)

                else:

                    value = typedValue(VTUnion, self.graph, s, L9['value'])

                    effSets.append((self.uri, attr, value))

            esettings = EffectSettings(self.graph, effSets)

            try:

                effectFunction = typedValue(EffectFunction, self.graph, self.uri, L9['effectFunction'])

            except ValueError:

                raise ValueError(f'{self.uri} has no :effectFunction')

            func = self.lib.getFunc(effectFunction)

            # This should be in EffectFunctionLibrary

            funcArgs = list(inspect.signature(func).parameters.values())

            self.config = Config(effectFunction, esettings, devSettings, func, funcArgs)

        except Exception:

            log.error(f"while compiling {self.uri}")

            traceback.print_exc()

    def compute(self, songTime: float, inputs: EffectSettings) -> DeviceSettings:

        """

        calls our function using inputs (publishedAttr attrs, e.g. :strength)

        and effect-level settings including a special attr called :deviceSettings

        with DeviceSettings as its value

        """

        if self.config is None:

            return DeviceSettings(self.graph, [])

        c = self.config

        kw = {}

        for arg in c.funcArgs:

            if arg.annotation == DeviceSettings:

                v = c.devSettings

            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:

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

        except KeyError:

            pass

        return self.lib.getDefaultValue(c.effectFunction, attr)