def bumpto(self, sub, lev):

        now = time.time()

        self.levs[sub] = lev * self.mag.get()

        self.master.after_idle(self.output)

    def output(self):

        dmxclient.outputlevels(dmx, clientid="bumppad")

root = tk.Tk()

root.tk_setPalette("maroon4")

root.wm_title("bumppad")

them, and sends output attrs to hardware. The combining part has

custom code for some attributes.

Input can be over http or zmq.

"""

from run_local import log

from rdflib import URIRef, Literal

from twisted.internet import reactor, utils

from txzmq import ZmqEndpoint, ZmqFactory, ZmqPullConnection

import json

todo: curveview should preserve more objects, for speed maybe

"""

import sys

import imp

sys.path.append('/usr/lib/python2.7/dist-packages')  # For gtk

from twisted.internet import gtk3reactor

gtk3reactor.install()

from twisted.internet import reactor

    def makeStatusLines(self, master):

        """various labels that listen for dispatcher signals"""

        for row, (signame, textfilter) in enumerate([

            ('input time', lambda t: "%.2fs" % t),

            ('output levels', lambda levels: textwrap.fill(

                "; ".join([

                ]), 70)),

            ('update period', lambda t: "%.1fms" % (t * 1000)),

            ('update status', lambda x: str(x)),

        ]):

            key = Gtk.Label("%s:" % signame)

            value = Gtk.Label("")

todo:

  save dmx on quit and restore on restart

  if parport fails, run in dummy mode (and make an option for that too)

"""

from twisted.internet import reactor

from twisted.web import xmlrpc, server

import sys, time, os

from optparse import OptionParser

import run_local

import txosc.dispatch, txosc. async

                    cl = max(0, min(1, clientlist[chan]))

                    x = max(x, cl)

            self.combinedlevels.append(x)

    def printlevels(self):

        """write all the levels to stdout"""

    def printstats(self):

        """print the clock, freq, etc, with a \r at the end"""

        sys.stdout.write("dmxserver up at %s, [polls %s] " % (

            time.strftime("%H:%M:%S"),

#!bin/python

from run_local import log

from twisted.internet import reactor

from twisted.internet.defer import inlineCallbacks, returnValue

import cyclone.web, cyclone.websocket, cyclone.httpclient

import sys, optparse, logging, subprocess, json, itertools

from rdflib import URIRef, Literal

#!bin/python

from run_local import log

import cgi, time, logging

from optparse import OptionParser

import webcolors, colorsys

from louie import dispatcher

from twisted.internet import reactor, tksupport

    def unhighlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'black'

    def get_levels(self):

    def get_output_settings(self, _graph=None):

        _graph = _graph or self.graph

        outputSettings = []

        for setting in _graph.objects(self.session, L9['subSetting']):

            effect = _graph.value(setting, L9['sub'])

#!bin/python

import run_local

import sys, logging

sys.path.append("lib")

import qt4reactor

qt4reactor.install()

#!bin/python

from run_local import log

import json

from twisted.internet import reactor

from light9.greplin_cyclone import StatsForCyclone

from rdfdb.syncedgraph import SyncedGraph

from light9 import networking, showconfig

        OneLevel widget

          UI edits are caught here and go all the way back to currentSub

"""

from run_local import log

import time, logging

log.setLevel(logging.DEBUG)

from optparse import OptionParser

        self.graph.patch(Patch(addQuads=[], delQuads=delQuads))

    def setupSubChoiceLinks(self):

        graph = self.graph

        def ann():

        @graph.addHandler

        def graphChanged():

            # some bug where SC is making tons of graph edits and many

            # are failing. this calms things down.

            log.warn('skip graphChanged')

#!/usr/bin/python

import sys

sys.path.append("../../editor/pour")

sys.path.append("../light8")

from Submaster import Submaster

from skim.zooming import Zooming, Pair

import time

import logging

from rdflib import Literal

from light9.namespaces import L9, RDF

from light9.collector.output import setListElem

from light9.collector.device import toOutputAttrs, resolve

from light9 import networking

from light9.effect.settings import DeviceSettings

from twisted.internet import defer

from txzmq import ZmqEndpoint, ZmqFactory, ZmqPushConnection

import json, time, logging

import treq

import logging

import math

from light9.namespaces import L9, RDF, DEV

from rdflib import Literal

from webcolors import hex_to_rgb, rgb_to_hex

from colormath.color_objects import sRGBColor, CMYColor

from rdflib import URIRef

import sys

import time

import usb.core

import logging

from twisted.internet import task, threads, reactor

def sendLiveInputPoint(curve, value):

    f = cyclone.httpclient.fetch(networking.curveCalc.path('liveInputPoint'),

                                 method='POST',

                                 timeout=1,

                                 postdata=urllib.parse.urlencode({

                                 }))

    @f.addCallback

    def cb(result):

        if result.code // 100 != 2:

            raise ValueError("curveCalc said %s: %s", result.code, result.body)

import glob, time, logging, ast, os

from bisect import bisect_left, bisect

import louie as dispatcher

from twisted.internet import reactor

from rdflib import Literal

from light9 import showconfig

import math, logging, traceback

from gi.repository import Gtk

from gi.repository import Gdk

from gi.repository import GooCanvas

import louie as dispatcher

from rdflib import Literal

            value = self.curve.eval(self.current_time())

        self.curve.insert_pt((self.current_time(), value))

    def print_state(self, msg=""):

        if 0:

    def select_points(self, pts):

        """set selection to the given point values (tuples, not indices)"""

        idxs = []

        for p in pts:

            idxs.append(self.curve.points.index(p))

from gi.repository import Gtk

from gi.repository import GObject

from gi.repository import GooCanvas

import louie as dispatcher

from light9.curvecalc import cursors

from lib.goocanvas_compat import Points, polyline_new_line

from rdflib import URIRef, Literal

from light9.namespaces import L9, RDF, DEV

from webcolors import rgb_to_hex, hex_to_rgb

from colorsys import hsv_to_rgb

from decimal import Decimal

import math

from rdflib import Literal

from decimal import Decimal

from webcolors import rgb_to_hex, hex_to_rgb

def scale(value, strength):

'''

copies from effectloop.py, which this should replace

'''

from louie import dispatcher

from rdflib import URIRef

from twisted.internet import reactor

from twisted.internet import defer

from twisted.internet.inotify import INotify

from twisted.python.filepath import FilePath

"""

Data structure and convertors for a table of (device,attr,value)

rows. These might be effect attrs ('strength'), device attrs ('rx'),

or output attrs (dmx channel).

"""

import decimal

import traceback

from light9.namespaces import L9, RDF

from light9.effect.scale import scale

class SimpleOutputs(object):

import time, json, logging, traceback

import numpy

import serial

from twisted.internet import reactor, threads

from twisted.internet.defer import inlineCallbacks, returnValue, succeed

from twisted.internet.error import TimeoutError

                if msg != self.lastLogMsg:

                    log.info(msg)

                    self.lastLogMsg = msg

                self.lastLogTime = now

    def logMessage(self, out):

Z = numpy.zeros((50, 3), dtype=numpy.float16)

class ControlBoard(object):

import sys

class BaseIO(object):

    def __init__(self):

import logging

import usb.core

from usb.util import CTRL_TYPE_VENDOR, CTRL_RECIPIENT_DEVICE, CTRL_OUT

log = logging.getLogger('udmx')

"""

from light9.namespaces import RDF, L9, DEV

from PIL import Image

import numpy

import scipy.misc, scipy.ndimage, scipy.optimize

import cairo

import logging

import os, gtk, shutil, logging, time

from bisect import bisect_left

from decimal import Decimal

log = logging.getLogger()

framerate = 15