dt1 = 1000 * (time.time() - now)

        self._updateOutputs(pendingOut)

        dt2 = 1000 * (time.time() - now) - dt1

        if dt1 > 30 or dt2 > 30:

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

    def _acceptNewClientSessionSettings(self, client, clientSession, settings, now):

        uniqueSettings = self.resolvedSettingsDict(settings)

        self.lastRequest[(client, clientSession)] = (now, uniqueSettings)

    def _flattenDmxOutput(self, outputAttrs: Dict[DeviceUri, Dict[OutputAttr, OutputValue]]) -> Dict[OutputUri, bytearray]:

        pendingOut = cast(Dict[OutputUri, bytearray], {})

        for outUri in self._outputByUri.keys():

            pendingOut[outUri] = bytearray(512)

        for device, attrs in outputAttrs.items():

            for outputAttr, value in attrs.items():

                outputUri, _index = self._outputMap[(device, outputAttr)]

                index = DmxMessageIndex(_index)

                outArray = pendingOut[outputUri]

                if outArray[index] != 0:

                    raise ValueError(f"someone already wrote to index {index}")

                outArray[index] = value

        return pendingOut

    def _updateOutputs(self, pendingOut: Dict[OutputUri, bytearray]):

        for uri, buf in pendingOut.items():

            self._outputByUri[uri].update(bytes(buf))

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

        return cls(graph, settingsList)

    @classmethod

    def fromVector(cls, graph, vector, deviceAttrFilter=None):

        compiled: Dict[DeviceSettings.EntityType, Dict[DeviceSettings.AttrType, VTUnion]] = {}

        i = 0

        for (d, a) in cls(graph, [])._vectorKeys(deviceAttrFilter):

            if a == L9['color']:

                v = toHex(vector[i:i + 3])

                i += 3

            else:

                v = vector[i]

                i += 1

            compiled.setdefault(d, {})[a] = v

        return cls._fromCompiled(graph, compiled)

    @classmethod

    def merge(cls, graph: SyncedGraph, others: List[DeviceSettings]) -> DeviceSettings:

        return cls.fromList(graph, cast(List[_Settings], others))

@dataclass

class BareEffectSettings:

    s: Dict[EffectAttr, VTUnion]

    def withStrength(self, strength: float) -> BareEffectSettings:

        out = self.s.copy()

        out[EffectAttr(L9['strength'])] = strength

        return BareEffectSettings(s=out)

class EffectSettings(_Settings):

    pass