index = dmxBase + offset - 1

                ret[(dev, outputAttr)] = (output, index)

                log.debug('    map %s to %s,%s', outputAttr, output, index)

    return ret

class Collector(Generic[ClientType, ClientSessionType]):

    def __init__(self, graph, outputs, listeners=None, clientTimeoutSec=10):

        # type: (Graph, List[Output], float) -> None

        self.graph = graph

        self.outputs = outputs

        self.listeners = listeners

        self.clientTimeoutSec = clientTimeoutSec

        self.graph.addHandler(self.rebuildOutputMap)

        # client : (session, time, {(dev,devattr): latestValue})

        self.lastRequest = {} # type: Dict[ClientType, Tuple[ClientSessionType, float, Dict[Tuple[URIRef, URIRef], float]]]

        # (dev, devAttr): value to use instead of 0

        self.stickyAttrs = {} # type: Dict[Tuple[URIRef, URIRef], float] 

    def rebuildOutputMap(self):

        self.outputMap = outputMap(self.graph, self.outputs) # (device, outputattr) : (output, index)

        self.deviceType = {} # uri: type that's a subclass of Device

        self.remapOut = {} # (device, deviceAttr) : (start, end)

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

            for dev in self.graph.subjects(RDF.type, dc):

                self.deviceType[dev] = dc

                for remap in self.graph.objects(dev, L9['outputAttrRange']):

                    attr = self.graph.value(remap, L9['outputAttr'])

                    start = float(self.graph.value(remap, L9['start']))

                    end = float(self.graph.value(remap, L9['end']))

                    self.remapOut[(dev, attr)] = start, end

    def _forgetStaleClients(self, now):

        # type: (float) -> None

        staleClients = []

        for c, (_, t, _2) in self.lastRequest.iteritems():

    def resolvedSettingsDict(self, settingsList):

        # type: (List[Tuple[URIRef, URIRef, float]]) -> Dict[Tuple[URIRef, URIRef], float]

        out = {} # type: Dict[Tuple[URIRef, URIRef], float]

        for d, da, v in settingsList:

            if (d, da) in out:

                out[(d, da)] = resolve(d, da, [out[(d, da)], v])

            else:

                out[(d, da)] = v

        return out

    def _warnOnLateRequests(self, client, now, sendTime):

        requestLag = now - sendTime

            log.warn('collector.setAttrs from %s is running %.1fms after the request was made',

                     client, requestLag * 1000)

    def setAttrs(self, client, clientSession, settings, sendTime):

        """

        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/Output.flush to send the

        new outputs.

        Call with settings=[] to ping us that your session isn't dead.

        """

                # not going to 0.

                if deviceAttr in [L9['rx'], L9['ry'], L9['zoom'], L9['focus']]:

                    self.stickyAttrs[(device, deviceAttr)] = value

        # e.g. don't let an unspecified rotation go to 0

        for (d, da), v in self.stickyAttrs.iteritems():

            daDict = deviceAttrs.setdefault(d, {})

            if da not in daDict:

                daDict[da] = v

        outputAttrs = {} # device: {outputAttr: value}

            try:

                devType = self.deviceType[d]

            except KeyError:

                log.warn("request for output to unconfigured device %s" % d)

                continue

            if self.listeners:

                self.listeners.outputAttrsSet(d, outputAttrs[d], self.outputMap)

        pendingOut = {} # output : values

        for out in self.outputs:

            pendingOut[out] = [0] * out.numChannels

        for device, attrs in outputAttrs.iteritems():

            for outputAttr, value in attrs.iteritems():

                self.setAttr(device, outputAttr, value, pendingOut)

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

                              [127, 0, 0, 0], 'flush',

                              [102, 0, 0, 0], 'flush'],

                             self.dmx0.updates)

    def testClientUpdatesAreNotMerged(self):

        # second call to setAttrs forgets the first

        c = Collector(self.config, outputs=[self.dmx0, self.udmx])

        t0 = time.time()

        c.setAttrs('client1', 'sess1', [(DEV['inst1'], L9['brightness'], .5)], t0)

        c.setAttrs('client1', 'sess1', [(DEV['inst1'], L9['brightness'], 1)], t0)

        c.setAttrs('client1', 'sess1', [(DEV['colorStrip'], L9['color'], '#00ff00')], t0)

                          [215, 0, 255, 0], 'flush'],

                         self.udmx.updates)

        self.assertEqual([[127, 0, 0, 0], 'flush',

                          [255, 0, 0, 0], 'flush',

                          [0, 0, 0, 0], 'flush'],

                         self.dmx0.updates)

    def testRepeatedAttributesInOneRequestGetResolved(self):

        c = Collector(self.config, outputs=[self.dmx0, self.udmx])

        c.setAttrs('client1', 'sess1', [

            (DEV['inst1'], L9['brightness'], .5),

            </tr>

          </template>

      </template>

      <script>

       HTMLImports.whenReady(function () {

           Polymer({

               is: "light9-collector-device",

               properties: {

                   graph: {type: Object, notify: true},

                   uri: {type: String, notify: true},

                   label: {type: String, notify: true},

               },

               observers: [

                   "setLabel(graph, uri)",

                   "initUpdates(updates)",

               ],

               initUpdates: function(updates) {

                   updates.addListener(function(msg) {

                       if (msg.outputAttrsSet && msg.outputAttrsSet.dev == this.uri) {

                           this.attrs.forEach(function(row) {

                               row.valClass = row.val == 255 ? 'full' : (row.val ? 'nonzero' : '');

                           });

                       }

                   }.bind(this));

               },

               setLabel: function(graph, uri) {

                   this.label = uri.replace(/.*\//, '');

                   graph.runHandler(function() {

                       this.label = graph.stringValue(uri, graph.Uri('rdfs:label'));

                   }.bind(this), 'setLabel');

               }

           });

       });

      </script>

    </dom-module>

    <dom-module id="light9-collector-ui">