import web, thread, sys, optparse, logging

from rdflib import URIRef

sys.path.append(".")

import gi

gi.require_version('Gst', '1.0')

from gi.repository import GObject, Gst, Gtk

class App(object):

    def __init__(self, graph, show):

        self.graph = graph

        self.player = Player(onEOS=self.onEOS)

        try:

            nextSong = self.playlist.nextSong(thisSongUri)

            return

        self.player.setSong(songLocation(graph, nextSong), play=False)

if __name__ == "__main__":

    GObject.threads_init()

    Gst.init(None)

    parser = optparse.OptionParser()

                      help="logging.DEBUG")

                      help="twisted logging")

    (options, args) = parser.parse_args()

    if not options.show:

        raise ValueError("missing --show http://...")

    graph = showconfig.getGraph()

    app = App(graph, URIRef(options.show))

    if options.twistedlog:

from bcf2000 import BCF2000

from twisted.internet import reactor

class PuppetSliders(BCF2000):

    def valueIn(self, name, value):

        if name == 'slider1':

            self.valueOut('slider5', value)

b = PuppetSliders()

reactor.run()

#!bin/python

import sys, time, math

import Tkinter as tk

import light9.dmxclient as dmxclient

from light9.TLUtility import make_attributes_from_args

class pad(tk.Frame):

            sub = Submaster(subname)

        self.master.after_idle(self.output)

    def output(self):

root.tk_setPalette("maroon4")

root.wm_title("bumppad")

mag = tk.DoubleVar()

root.mainloop()

stats = scales.collection('/webServer', scales.PmfStat('setAttr'))

class Camera(object):

    def __init__(self, imageUrl):

        self.imageUrl = imageUrl

    def takePic(self, uri, writePath):

        log.info('takePic %s', uri)

    @inlineCallbacks

    def _done(self, writePath, response):

        jpg = yield response.content()

            out.write(jpg)

        log.info('wrote %s', writePath)

def deferSleep(sec):

    d = Deferred()

    reactor.callLater(sec, d.callback, None)

    return d

class Capture(object):

    firstMoveTime = 3

    settleTime = .5

    def __init__(self, graph, dev):

        self.graph = graph

        self.dev = dev

        def steps(a, b, n):

            return [round(a + (b - a) * i / n, 5) for i in range(n)]

        # aura

        rxSteps = steps(0.15, .95, 10)

        rySteps = steps(0, .9, 5)

        row = 0

        for ry in rySteps:

            xSteps = rxSteps[:]

            row += 1

            for rx in xSteps:

                for zoom in zoomSteps:

        self.devTail = dev.rsplit('/')[-1]

        self.ctx = URIRef(self.session + '/index')

        self.numPics = 0

        self.settingsCache = set()

        self.step().addErrback(log.error)

    def off(self):

                               settings=DeviceSettings(self.graph, []))

    @inlineCallbacks

    def step(self):

        if not self.toGather:

            reactor.stop()

            return

        settings = self.toGather.pop()

        log.info('[%s left] move to %r', len(self.toGather), settings)

                              settings=settings)

        picId = 'pic%s' % self.numPics

        uri = URIRef(self.session + '/' + picId)

        yield camera.takePic(uri, os.path.join(showconfig.root(), path))

        self.numPics += 1

        writeCaptureDescription(self.graph, self.ctx, self.session, uri,

        reactor.callLater(0, self.step)

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

    def put(self):

        with stats.setAttr.time():

            self.set_status(202)

def launch(graph):

    cap = Capture(graph, dev=L9['device/aura5'])

    reactor.listenTCP(networking.captureDevice.port,

                      cyclone.web.Application(handlers=[

                          (r'/stats', StatsForCyclone),

                      ]),

                      interface='::')

    log.info('serving http on %s', networking.captureDevice.port)

def main():

    parser = optparse.OptionParser()

                      help="logging.DEBUG")

    (options, args) = parser.parse_args()

    log.setLevel(logging.DEBUG if options.verbose else logging.INFO)

    graph = SyncedGraph(networking.rdfdb.url, "captureDevice")

    reactor.run()

if __name__ == '__main__':

    main()

    g = SyncedGraph(networking.rdfdb.url, "clientdemo")

    from light9.Submaster import PersistentSubmaster

    #get sub to show its updating name, then push that all the way into KC gui so we can see just names refresh in there

    def updateDemoValue():

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

        print "demo value is %r" % v

    g.addHandler(updateDemoValue)

    def adj():

    reactor.callLater(2, adj)

    reactor.run()

from rdfdb.syncedgraph import SyncedGraph

from light9.greplin_cyclone import StatsForCyclone

def parseJsonMessage(msg):

    body = json.loads(msg)

    settings = []

        settings.append((URIRef(device), URIRef(attr), value))

    return body['client'], body['clientSession'], settings, body['sendTime']

def startZmq(port, collector):

    zf = ZmqFactory()

    addr = 'tcp://*:%s' % port

    log.info('creating zmq endpoint at %r', addr)

    e = ZmqEndpoint('bind', addr)

    class Pull(ZmqPullConnection):

        #highWaterMark = 3

        def onPull(self, message):

                # todo: new compressed protocol where you send all URIs up

                # front and then use small ints to refer to devices and

                # attributes in subsequent requests.

                collector.setAttrs(client, clientSession, settings, sendTime)

    s = Pull(zf, e)

class WebListeners(object):

    def __init__(self):

        self.clients = []

        self.lastFlush = 0

    def addClient(self, client):

        log.info('added client %s %s', len(self.clients), client)

    def delClient(self, client):

        self.clients = [[c, t] for c, t in self.clients if c != client]

        log.info('delClient %s, %s left', client, len(self.clients))

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

        """called often- don't be slow"""

        while self.pendingMessageForDev:

            dev, (attrs, outputMap) = self.pendingMessageForDev.popitem()

            # this omits repeats, but can still send many

            # messages/sec. Not sure if piling up messages for the browser

            # could lead to slowdowns in the real dmx output.

        attrRows = []

        for attr, val in attrs.items():

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

        attrRows.sort(key=lambda r: r['chan'])

        for row in attrRows:

            row['chan'] = '%s %s' % (row['chan'][0], row['chan'][1])

        return msg

class Updates(cyclone.websocket.WebSocketHandler):

    def connectionMade(self, *args, **kwargs):

    def messageReceived(self, message):

        json.loads(message)

stats = scales.collection('/webServer', scales.PmfStat('setAttr'))

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

    def put(self):

        with stats.setAttr.time():

            self.set_status(202)

def launch(graph, doLoadTest=False):

    try:

        # todo: drive outputs with config files

        outputs = [

            # EnttecDmx(L9['output/dmxA/'], '/dev/dmx3', 80),

            #DummyOutput(L9['output/dmxA/'], 80),

            Udmx(L9['output/dmxB/'], bus=7, numChannels=500),

        ]

    c = Collector(graph, outputs, listeners)

    startZmq(networking.collectorZmq.port, c)

    reactor.listenTCP(networking.collector.port,

                      cyclone.web.Application(handlers=[

                          (r'/updates', Updates),

                          (r'/attrs', Attrs),

                          (r'/stats', StatsForCyclone),

                      interface='::')

    log.info('serving http on %s, zmq on %s', networking.collector.port,

             networking.collectorZmq.port)

        # requests when there's free time

        def afterWarmup():

            log.info('running collector_loadtest')

            def done(*a):

                log.info('loadtest done')

                reactor.stop()

            d.addCallback(done)

        reactor.callLater(2, afterWarmup)

def main():

    parser = optparse.OptionParser()

                      help="logging.DEBUG")

                      help="call myself with some synthetic load then exit")

    (options, args) = parser.parse_args()

    log.setLevel(logging.DEBUG if options.verbose else logging.INFO)

    logging.getLogger('colormath').setLevel(logging.INFO)

    graph = SyncedGraph(networking.rdfdb.url, "collector")

    reactor.run()

if __name__ == '__main__':

    main()

import time

import logging

log.setLevel(logging.DEBUG)

def loadTest():

    print "scheduling loadtest"

    n = 2500

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

    offset = 0

    for i in range(n):

        def send(i):

            if i % 100 == 0:

                log.info('sendToCollector %s', i)

            d = sendToCollector("http://localhost:999999/", session,

            def ontime(dt, i=i):

                times[i] = dt

            d.addCallback(ontime)

        reactor.callLater(offset, send, i)

        offset += .002

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

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

        reactor.stop()

    reactor.run()

if __name__ == '__main__':

    loadTest()

#!bin/python

"""

now launches like this:

% bin/curvecalc http://light9.bigasterisk.com/show/dance2007/song1

from __future__ import division

import sys

from twisted.internet import gtk3reactor

gtk3reactor.install()

from twisted.internet import reactor

from gi.repository import Gdk

from urlparse import parse_qsl

from rdflib import URIRef, Literal, RDF, RDFS

import logging

from run_local import log

from light9 import showconfig, networking

from light9.curvecalc.curve import Curveset

from light9.curvecalc.curveedit import serveCurveEdit

from light9.curvecalc.musicaccess import Music

from rdfdb.syncedgraph import SyncedGraph

from light9.wavelength import wavelength

class SubtermExists(ValueError):

    pass

class Main(object):

    def __init__(self, graph, opts, session, curveset, music):

        self.graph, self.opts, self.session = graph, opts, session

        self.curveset, self.music = curveset, music

        self.lastSeenInputTime = 0

        self.setTheme()

        wtree = self.wtree = Gtk.Builder()

        wtree.add_from_file("light9/curvecalc/curvecalc.glade")

        mainwin = wtree.get_object("MainWindow")

        mainwin.connect("destroy", self.onQuit)

        wtree.connect_signals(self)

        mainwin.show_all()

        mainwin.connect("delete-event", lambda *args: reactor.crash())

        def updateTitle():