from gi.repository import GObject, Gst, Gtk

class App(object):

    def __init__(self, graph, show):

        self.graph = graph

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

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

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

from light9.Submaster import Submaster,sub_maxes

class pad(tk.Frame):

    levs = None # Submaster : level

    def __init__(self,master,root,mag):

        make_attributes_from_args('master','mag')

        tk.Frame.__init__(self,master)

            sub = Submaster(subname)

            self.levs[sub]=0

                         text="%s\n%s" % (key.replace('KP_',''),sub.name))

            l.grid(column=xy[0],row=xy[1],sticky='news')

            root.bind("<KeyRelease-%s>"%key,

                      lambda ev,sub=sub: self.bumpto(sub,0))

    def bumpto(self,sub,lev):

        now=time.time()

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

        self.master.after_idle(self.output)

    def output(self):

        dmx = sub_maxes(*[s*l for s,l in self.levs.items()]).get_dmx_list()

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

root=tk.Tk()

root.tk_setPalette("maroon4")

root.wm_title("bumppad")

mag = tk.DoubleVar()

pad(root,root,mag).pack(side='left',fill='both',exp=1)

for i in range(1,6):

    root.bind("<Key-%s>"%i,lambda ev,i=i: mag.set(math.sqrt((i )/5)))

magscl.pack(side='left',fill='y')

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):

            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

            row += 1

            for rx in xSteps:

                for zoom in zoomSteps:

                        (dev, L9['rx'], rx),

                        (dev, L9['ry'], ry),

                        (dev, L9['color'], '#ffffff'),

                    ]))

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

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

            (self.session, RDF.type, L9['CaptureSession'], self.ctx),

        ]))

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

    def off(self):

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

    @inlineCallbacks

        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():

                                 L9['clientdemo'])],

                      delQuads=[]))

    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.pendingMessageForDev = {} # dev: (attrs, outputmap)

        attrRows = []

        for attr, val in attrs.items():

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

                             'val': val,

        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

    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)

    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)

                     [DEV["down4"], L9["color"], "#ffffff"], 

                     [DEV["houseSide"], L9["level"], .8], 

                     [DEV["backlight5"], L9["uv"], 0.011]])

            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.callLater(offset+.5, done)

    reactor.run()

if __name__ == '__main__':

    loadTest()

#!bin/python

"""

now launches like this:

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

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

        mainwin.show_all()

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

        def updateTitle():

        graph.addHandler(updateTitle)

        songChoice = Observable(None) # to be connected with the session song

        wtree.get_object("paned1").set_position(600)

    def registerGraphToSongChoice(self, wtree, session, graph, songChoice):

        def setSong():

            current = graph.value(session, L9['currentSong'])

            if not wtree.get_object("followPlayerSongChoice").get_active():

                songChoice(current)

                dispatcher.send("song_has_changed")

        graph.addHandler(setSong)

    def registerSongChoiceToGraph(self, session, graph, songChoice):

        self.muteSongChoiceUntil = 0

        def songChoiceToGraph(newSong):

            if newSong is Local:

                raise NotImplementedError('what do i patch')

                return

            self.muteSongChoiceUntil = now + 1

        songChoice.subscribe(songChoiceToGraph)

        and

        current_player_song 'song' param -> songChoice, if you're in autofollow

        """

        def current_player_song(song):

            # (this is run on every frame)

            ps = wtree.get_object("playerSong")

            if URIRef(ps.get_uri()) != song:

                log.debug("update playerSong to %s", ps.get_uri())

                def setLabel():

                    ps.set_label(graph.label(song))

                graph.addHandler(setLabel)

                ps.set_uri(song)

            if song != songChoice():

        w.drag_dest_set(flags=Gtk.DestDefaults.ALL,

                        targets=[Gtk.TargetEntry('text/uri-list', 0, 0)],

                        actions=Gdk.DragAction.COPY)

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

            print "into curves", subUri

                subName = current.label(subUri)

            if '?' in subUri:

                subName = self.handleSubtermDrop(subUri)

            else:

                try:

                                     sub=subUri,

                                     expr="%s(t)" % subName)

                except SubtermExists:

            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

            print "time", t

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

    def onDragDataInNewSubZone(self, widget, context, x, y, selection,

        if '?' in data:

            self.handleSubtermDrop(data)

            return

            subName = current.label(data)

                         expr="%s(t)" % subName)

    def handleSubtermDrop(self, data):

    def currentSong(self):

            return current.value(self.session, L9['currentSong'])

    def songSubtermsContext(self):

        screen = Gdk.Display.get_default_screen(Gdk.Display.get_default())

        for p in providers:

            Gtk.StyleContext.add_provider_for_screen(

    def onSubtermChildAdded(self, subtermsTable, *args):

        # this would probably work, but isn't getting called

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

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

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

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

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

            ]):

            key.set_alignment(1, 0)

            value.set_alignment(0, 0)

        dispatcher.connect(lambda val: setattr(self, 'lastSeenInputTime', val),

        master.show_all()

    def refreshCurveView(self):

        wtree = self.wtree

            'light9/curvecalc/curveview.py',

            'light9/curvecalc/zoomcontrol.py',

        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()]

            try:

                linecache.clearcache()

                reload(curveview)

                    self.curvesetView.live = False

                # mem problem somewhere; need to hold a ref to this

                self.curvesetView._mtimes = mtimes

                # this is scheduled after some tk shuffling, to

    """

    looks up the time in seconds for the session's current song

    """

    def __init__(self, graph, session):

        self.graph, self.session = graph, session

        graph.addHandler(self.update)

    def get(self):

        return self.maxtime

def launch(args, graph, session, opts, startTime, music):

    try:

    start = Main(graph, opts, session, curveset, music)

    out = Output(graph, session, music, curveset, start.currentSubterms)

    dispatcher.send("show all")

    if opts.startup_only:

            requestHandler.set_status(404)

            requestHandler.write("not hovering over any time")

            return

            song = g.value(session, L9['currentSong'])

            json.dump({"song": song, "hoverTime" : times[0]}, requestHandler)

    serveCurveEdit(networking.curveCalc.port, hoverTimeResponse, start.curveset)

def main():

    startTime = time.time()

    parser = optparse.OptionParser()

    parser.set_usage("%prog [opts] [songURI]")

                      help="live reload of themes and code")

                      help="quit after loading everything (for timing tests)")

    parser.add_option("--profile", help='"hotshot" or "stat"')

    clientsession.add_option(parser)