#!bin/python

from run_local import log

from twisted.internet import reactor

from rdflib import URIRef

sys.path.append(".")

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

#!bin/python

import sys, time, math

import run_local

import light9.dmxclient as dmxclient

        self.master.after_idle(self.output)

    def output(self):

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

#!bin/python

from rdflib import URIRef

from twisted.internet import reactor

from twisted.internet.defer import inlineCallbacks, Deferred

    def updateDemoValue():

        v = list(g.objects(L9['demo'], L9['is']))

    g.addHandler(updateDemoValue)

Input can be over http or zmq.

"""

from run_local import log

from rdflib import URIRef, Literal

    body = json.loads(msg)

    settings = []

    for device, attr, value in body['settings']:

            value = URIRef(value)

        else:

            value = Literal(value)

    def makeMsg(self, dev, attrs, outputMap):

        attrRows = []

            output, index = outputMap[(dev, attr)]

            attrRows.append({

                'attr': attr.rsplit('/')[-1],

def loadTest():

    n = 2500

    times = [None] * n

    session = "loadtest%s" % time.time()

        offset += .002

    def done():

        with open('/tmp/times', 'w') as f:

            f.write(''.join('%s\n' % t for t in times))

        reactor.stop()

todo: curveview should preserve more objects, for speed maybe

"""

import sys

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

from twisted.internet import gtk3reactor

gtk3reactor.install()

from gi.repository import GObject

from gi.repository import Gdk

import louie as dispatcher

from rdflib import URIRef, Literal, RDF, RDFS

import logging

        def recv(widget, context, x, y, selection, targetType, time):

            subUri = URIRef(selection.data.strip())

            with self.graph.currentState(tripleFilter=(subUri, RDFS.label,

                                                       None)) as current:

                subName = current.label(subUri)

                    pass

            curveView = self.curvesetView.row(subName).curveView

            t = self.lastSeenInputTime  # curveView.current_time() # new curve hasn't heard the time yet. this has gotten too messy- everyone just needs to be able to reach the time source

            curveView.add_points([(t - .5, 0), (t, 1)])

        w.connect("drag-data-received", recv)

            ('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)),

        if (not hasattr(self, 'curvesetView') or

                self.curvesetView._mtimes != mtimes):

            curvesVBox = wtree.get_object("curves")

            zoomControlBox = wtree.get_object("zoomControlBox")

            [curvesVBox.remove(c) for c in curvesVBox.get_children()]

            [zoomControlBox.remove(c) for c in zoomControlBox.get_children()]

            try:

                linecache.clearcache()

                # old ones are not getting deleted right

                if hasattr(self, 'curvesetView'):

                # ok. You'll just get some wasted redraws.

                self.curvesetView.goLive()

            except Exception:

                traceback.print_exc()

        if self.opts.reload:

            reactor.callLater(1, self.refreshCurveView)

  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

            self.port,

            txosc. async .DatagramServerProtocol(self.receiver),

            interface='0.0.0.0')

    def pixel_handler(self, message, address):

        # this is already 1-based though I don't know why

        # desired seconds between sendlevels() calls

        self.calldelay = 1 / options.updates_per_sec

        self.parportdmx = UsbDMX(dimmers=90, port=options.dmx_device)

        if os.environ.get('DMXDUMMY', 0):

            self.parportdmx.godummy()

        reactor.callLater(1, self.purgeclients)

        now = time.time()

        for cid in cids:

            lastseen = self.lastseen[cid]

            if lastseen < now - purge_age:

                try:

                    del self.clientlevels[cid]

                except KeyError:

        self.combinedlevels = []

        for chan in range(0, self.parportdmx.dimmers):

            x = 0

                if len(clientlist) > chan:

                    # clamp client levels to 0..1

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

    def printlevels(self):

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

    def printstats(self):

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

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

            str(self.updatefreq),

        ))

            sys.stdout.write("[%s %s] " % (cid, str(freq)))

        sys.stdout.write("\r")

        sys.stdout.flush()

    def trackClientFreq(self, cid):

        if cid not in self.lastseen:

            self.clientfreq[cid] = Updatefreq()

        self.lastseen[cid] = time.time()

        self.clientfreq[cid].update()

                  help="dummy mode, same as DMXDUMMY=1 env variable")

(options, songfiles) = parser.parse_args()

if options.dummy:

    os.environ['DMXDUMMY'] = "1"

port = networking.dmxServer.port

xmlrpcServe = XMLRPCServe(options)

reactor.listenTCP(port, server.Site(xmlrpcServe))

#!bin/python

from run_local import log

from twisted.internet import reactor

from twisted.internet.defer import inlineCallbacks, returnValue

            return

        with self.settings.graph.currentState(tripleFilter=(None, L9['effect'],

                                                            effect)) as g:

        replaceObjects(self.settings.graph, song, effect, L9['code'], codeLines)

"""

plays back effect notes from the timeline

"""

from run_local import log

from twisted.internet import reactor

from light9.greplin_cyclone import StatsForCyclone

from rdflib import RDF, URIRef

from light9 import networking, showconfig

from light9.namespaces import L9

from rdfdb.syncedgraph import SyncedGraph

from twisted.internet import reactor

webServer = graph.value(netHome, L9['webServer'])

if not webServer:

    raise ValueError('no %r :webServer' % netHome)

def location(path, server):

    location /%(path)s/ {

      # for websocket

      proxy_pass %(server)s;

      proxy_buffering off;

      rewrite /[^/]+/(.*) /$1 break;

for role, server in sorted(graph.predicate_objects(netHome)):

    location(path, server)

showPath = showconfig.showUri().split('/', 3)[-1]

    location /%(path)s {

      root %(root)s;

    }""" % {

    'path': showPath,

    'root': showconfig.root()[:-len(showPath)]

gtk3reactor.install()

from twisted.internet import reactor

from rdflib import URIRef

from gi.repository import Gtk

from run_local import log

from light9 import showconfig, networking

        self.curve = args[0] if args else URIRef(

            'http://light9.bigasterisk.com/show/dance2014/song1/curve/c-1401259747.675542'

        )

        reactor.run()

        @d.addCallback

        def done(result):

App()

"""

read Quneo midi events, write to curvecalc and maybe to effects

"""

from run_local import log

import cyclone.web, cyclone.httpclient

from rdflib import URIRef

from twisted.internet import reactor, task

        for ev in self.inp.read(999):

            (status, d1, d2, _), _ = ev

            if status in [NOTEON, NOTEOFF]:

            if status == NOTEON:

                if not self.noteIsOn.get(d1):

                                'Content-Type':

                                ['application/x-www-form-urlencoded']

                            },

                        )

                    except KeyError:

                        pass

                for group in [(23, 24, 25), (6, 18)]:

                    if d1 in group:

                        if not self.noteIsOn.get(group):

                            for d in group:

                                sendLiveInputPoint(curves[d], 0)

#!bin/python

from run_local import log

import cgi, time, logging

from optparse import OptionParser

from twisted.internet import reactor, tksupport

from twisted.web import resource

from rdflib import URIRef, Literal

from light9.Fadable import Fadable

from light9.subclient import SubClient

from light9.effect.simple_outputs import SimpleOutputs

from bcf2000 import BCF2000

nudge_keys = {'up': list('qwertyui'), 'down': list('asdfghjk')}

        for r in self.rows:

            r.destroy()

        self.rows = []

            b.cleanup()

        self.subbox.clear()

        self.slider_table.clear()

        log.info("withgroups %s", withgroups)

        self.effectEval = {}

        simpleOutputs = SimpleOutputs(self.graph)

        for group, order, sortLabel, effect in withgroups:

            if col == 0 or group != last_group:

        self.keyhints = keyhintrow

    def setup_key_nudgers(self, tkobject):

            for key in keys:

                # lowercase makes full=0

                keysym = "<KeyPress-%s>" % key

    def get_levels(self):

        return dict([

        ])

    def get_output_settings(self, _graph=None):

        self.sub_name.delete(0, tk.END)

    def alltozero(self):

            if subbox.scale.scale_var.get() != 0:

                subbox.scale.fade(value=0.0, length=0)

#!bin/python

import run_local

import sys, logging

def printSongs(result):

    with graph.currentState() as current:

        for song in current.subjects(RDF.type, L9['Song']):

    reactor.stop()

"""

start = time.time()

    time.sleep(.01)

import run_local

import light9.networking

import time

import restkit, jsonlib

            try:

                playtime = jsonlib.read(self.player.get("time").body_string(),

                                        use_float=True)['t']

                time.sleep(2)

        return playtime

        def print_time(evt, *args):

            self.timevar.set(self.get_music_time())

        self.timelabel.bind('<KeyPress>', print_time)

        self.timelabel.bind('<1>', print_time)

#!bin/python

from run_local import log

import json

from twisted.internet import reactor

import light9.paint.solve

from lib.cycloneerr import PrettyErrorHandler

from light9.namespaces import RDF, L9, DEV

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

            }))

    def reloadSolver(self):

        self.settings.solver = light9.paint.solve.Solver(self.settings.graph)

        self.settings.solver.loadSamples()

#!env_pi/bin/python

from run_local import log

import sys

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

from twisted.python.failure import Failure

try:

except ImportError:

    pass

else:

        else:

            Failure(val, exc, tb).printDetailedTraceback()

import coloredlogs, logging, time

try:

def setTerminalTitle(s):

    if os.environ.get('TERM', '') in ['xterm', 'rxvt', 'rxvt-unicode-256color']:

if 'listsongs' not in sys.argv[0] and 'homepageConfig' not in sys.argv[0]:

"""

push a dmx level forever

"""

import time, logging

from optparse import OptionParser

from twisted.internet import reactor, tksupport, task

from rdflib import URIRef, RDF, RDFS, Literal

"""

from run_local import log

import time, logging

log.setLevel(logging.DEBUG)

from optparse import OptionParser

import louie as dispatcher

from twisted.internet import reactor, tksupport, task

from rdflib import URIRef, RDF, RDFS, Literal

        """promote our local submaster into a non-local, named one"""

        uri = self.currentSub().uri

        newUri = showconfig.showUri() + ("/sub/%s" %

        with self.graph.currentState(tripleFilter=(uri, None, None)) as current:

            if (uri, RDF.type, L9['LocalSubmaster']) not in current:

                raise ValueError("%s is not a local submaster" % uri)

        graph = self.graph

        def ann():

        @graph.addHandler

        def graphChanged():

    def savenewsub(self, subname):

        leveldict = {}

            if lev != 0:

                leveldict[get_channel_name(i + 1)] = lev

#!bin/python

from run_local import log

from light9.tkdnd import initTkdnd, dropTargetRegister

from twisted.internet import reactor, tksupport

def onDrop(ev):

def enter(ev):

def leave(ev):

dropTargetRegister(label,

def prn():

b = tk.Button(root, text="coord", command=prn)

#!/usr/bin/python

import sys

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

import dmxclient

defaultfont = "arial 8"

            name = f.name()

            intens = f.calc(x, y)

            if intens > 0:

                active += 1

        if active > 0:

        self.dmxsend(x, y)

    def dmxsend(self, x, y):

        w2c = self.canvas.world2canvas

        # rings

            rad = f.getdistforintensity(intens)

            p1 = w2c(*(f.center() - Pair(rad, rad)))

            p2 = w2c(*(f.center() + Pair(rad, rad)))

            ev.x, ev.y)))

        def save(ev):

            self.fieldsetfile.save()

        master.bind("<Key-s>", save)

                              fill='white',

                              anchor=anc1 + anc2,

                              tags='cornercoords')

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