position = yield response.json()

            # this is meant to be the time when the server gave me its

            # report, and I don't know if that's closer to the

            # beginning of my request or the end of it (or some

            # fraction of the way through)

            self.positionFetchTime = time.time()

            self.position = position

            self.onChange(position)

        def eb(err):

            log.warn("talking to ascoltami: %s", err.getErrorMessage())

        d = treq.get(networking.musicPlayer.path("time").toPython())

        d.addCallback(cb)

        d.addErrback(eb)  # note this includes errors in cb()

    def sendTime(self, t):

        """request that the player go to this time"""

        treq.post(

            networking.musicPlayer.path('time'),

            data=json.dumps({

                "t": time

            }).encode('utf8'),

class timeStreamResource(cyclone.websocket.WebSocketHandler):

    def connectionMade(self, *args, **kwargs) -> None:

        self.lastSent = None

        self.lastSentTime = 0.

        self.loop()

    def loop(self):

        now = time.time()

        msg = currentState(self.settings.app.graph, self.settings.app.player)

        if msg != self.lastSent or now > self.lastSentTime + 2:

            self.lastSent = msg

            self.lastSentTime = now

        if self.transport.connected:

    def connectionLost(self, reason):

        log.info("bye ws client %r: %s", self, reason)

class songs(PrettyErrorHandler, cyclone.web.RequestHandler):

    def get(self):

        graph = cast(Graph, self.settings.app.graph)

        songs = getSongsFromShow(graph, self.settings.app.show)

    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

    def resolvedSettingsDict(self, settingsList: List[DeviceSetting]) -> Dict[Tuple[DeviceUri, DeviceAttr], VTUnion]:

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

            else:

        return out

    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.warn('collector.setAttrs from %s is running %.1fms after the request was made', client, requestLag * 1000)

    def _merge(self, lastRequests):

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

        for _, lastSettings in lastRequests:

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

        """

        settings is a list of (device, attr, value). These attrs are

        device attrs. We resolve conflicting values, process them into

        output attrs, and call Output.update to send the new outputs.

        client is a string naming the type of client. (client,

        clientSession) is a unique client instance.

        Each client session's last settings will be forgotten after

        clientTimeoutSec.

        """

        # todo: cleanup session code if we really don't want to be able to run multiple sessions of one client

        now = UnixTime(time.time())

        self._warnOnLateRequests(client, now, sendTime)

        self._forgetStaleClients(now)

        self._acceptNewClientSessionSettings(client, clientSession, settings, now)

        deviceAttrs = self._merge(iter(self.lastRequest.values()))

        outputAttrs = cast(Dict[DeviceUri, Dict[OutputAttr, OutputValue]], {})

        for d in self.allDevices:

            try:

import logging

from typing import Dict, List, Any, TypeVar, cast

from light9.namespaces import L9

from rdflib import Literal, URIRef

from webcolors import hex_to_rgb, rgb_to_hex

from colormath.color_objects import sRGBColor, CMYColor

import colormath.color_conversions

log = logging.getLogger('device')

class Device(object):

    pass

class ChauvetColorStrip(Device):

    """

     device attrs:

       color

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

        raise TypeError(repr(f))

    return clamp255(int(f * 255))

def _maxColor(values: List[HexColor]) -> HexColor:

    rgbs = [hex_to_rgb(v) for v in values]

    maxes = [max(component) for component in zip(*rgbs)]

    return cast(HexColor, rgb_to_hex(tuple(maxes)))

def resolve(

        deviceAttr: DeviceAttr,

        values: List[VTUnion]) -> VTUnion:  # todo: return should be VT

    """

    return one value to use for this attr, given a set of them that

    have come in simultaneously. len(values) >= 1.

    bug: some callers are passing a device instance for 1st arg

    """

    if len(values) == 1:

        return values[0]

    if deviceAttr == DeviceAttr(L9['color']):

        return _maxColor(cast(List[HexColor], values))

            if isinstance(v, Literal):

                floatVals.append(float(v.toPython()))

            elif isinstance(v, (int, float)):

                floatVals.append(float(v))

            else:

                raise TypeError(repr(v))

        # averaging with zeros? not so good

        return sum(floatVals) / len(floatVals)

    return max(values)

    return dict((OutputAttr(u), OutputValue(v)) for u, v in untype_toOutputAttrs(deviceType, deviceAttrSettings).items())

def untype_toOutputAttrs(deviceType, deviceAttrSettings) -> Dict[URIRef, int]:

    """

    Given device attr settings like {L9['color']: Literal('#ff0000')},

    return a similar dict where the keys are output attrs (like

    L9['red']) and the values are suitable for Collector.setAttr

    :outputAttrRange happens before we get here.

    """

import unittest

from rdflib import Literal

from light9.namespaces import L9

from light9.collector.device import toOutputAttrs, resolve

class TestUnknownDevice(unittest.TestCase):

    def testFails(self):

        self.assertRaises(NotImplementedError, toOutputAttrs, L9['bogus'], {})

class TestColorStrip(unittest.TestCase):

    def testConvertDeviceToOutputAttrs(self):

class TestDimmer(unittest.TestCase):

    def testConvert(self):

class TestMini15(unittest.TestCase):

    def testConvertColor(self):

    def testConvertRotation(self):

class TestResolve(unittest.TestCase):

    def testMaxes1Color(self):

        # do not delete - this one catches a bug in the rgb_to_hex(...) lines

    def testMaxes2Colors(self):

    def testMaxes3Colors(self):

#####################

# DMX USB controller

#####################

class OpenDmxUsb():

    def __init__(self):

        self.baud_rate = 250000

        self.data_bits = 8

        self.stop_bits = 2

        self.parity = 'N'

        self.flow_ctrl = ''

        self._init_dmx()

    #Initialize the controller

    def _init_dmx(self):

        self.ftdi = ftdi.Ftdi()

        self.ftdi.open(vendor, product, 0)

        self.ftdi.set_baudrate(self.baud_rate)

        self.ftdi.set_line_property(self.data_bits,

                                    self.stop_bits,

                                    self.parity,

        self.ftdi.set_flowctrl(self.flow_ctrl)

        self.ftdi.purge_rx_buffer()

        self.ftdi.purge_tx_buffer()

        self.ftdi.set_rts(self.rts_state)

    #Send DMX data

    def send_dmx(self, channelVals):

        assert self.ftdi.write_data(channelVals) == 513

        # Need to generate two bits for break

        self.ftdi.set_line_property(self.data_bits,

                                    self.stop_bits,

                                    self.parity,

        self.ftdi.set_line_property(self.data_bits,

                                    self.stop_bits,

                                    self.parity,

        self.ftdi.set_line_property(self.data_bits,

                                    self.stop_bits,

                                    self.parity,

if __name__ == "__main__":

    dmxUsb = OpenDmxUsb()

    channelVals = bytearray([0] * 513)

    channelVals[0] = 0  # dummy channel 0

    while (True):

        for x in range(1, 468 + 1):

            channelVals[x] = 255

        dmxUsb.send_dmx(channelVals)

from rdflib import URIRef

import socket

import struct

import time

import usb.core

import logging

from twisted.internet import threads, reactor, task

from light9.metrics import metrics

log = logging.getLogger('output')

logAllDmx = logging.getLogger('output.allDmx')

class Output(object):

    """

    send a binary buffer of values to some output device. Call update

    as often as you want- the result will be sent as soon as possible,

    and with repeats as needed to outlast hardware timeouts.

            log.debug(msg)

            self._lastLoggedMsg = msg

    def _write(self, buf: bytes) -> None:

        """

        write buffer to output hardware (may be throttled if updates are

        too fast, or repeated if they are too slow)

        """

        pass

    def crash(self):

        log.error('unrecoverable- exiting')

class DummyOutput(Output):

    def __init__(self, uri, **kw):

        super().__init__(uri)

    def update(self, buf: bytes):

        log.info(f'dummy update {list(map(int,buf[:80]))}')

class BackgroundLoopOutput(Output):

    def __init__(self, uri, rate=22):

        super().__init__(uri)

        self.rate = rate

        self._currentBuffer = b''

        self._loop()

    def _loop(self):

        start = time.time()

        sendingBuffer = self._currentBuffer

        def done(worked):

        def err(e):

            log.error(e)

        d = threads.deferToThread(self._write, sendingBuffer)

        d.addCallbacks(done, err)

class FtdiDmx(BackgroundLoopOutput):

    def __init__(self, uri, lastDmxChannel, rate=22):

        super().__init__(uri)

        self.lastDmxChannel = lastDmxChannel

        from .dmx_controller_output import OpenDmxUsb

        self.dmx = OpenDmxUsb()

                    logAllDmx.debug('%s: empty buf- no output', self.shortId())

                    return

                # ok to truncate the last channels if they just went

                # to 0? No it is not. DMX receivers don't add implicit

                # zeros there.

                buf = buf[:self.lastDmxChannel]

                if logAllDmx.isEnabledFor(logging.DEBUG):

                    # for testing fps, smooth fades, etc

                    logAllDmx.debug('%s: %s...' % (self.shortId(), ' '.join(map(str, buf[:32]))))

                if sent != len(buf):

                    raise ValueError("incomplete send")

            except ValueError:

                self.reconnect()

                raise

            except usb.core.USBError as e:

                # not in main thread

                if e.errno == 75:

                    metrics('write_overflow', output=self.shortId()).inc()

                    return

                if e.errno == 5:  # i/o err