from light9.ascoltami.playlist import Playlist, NoSuchSong

from light9.ascoltami.webapp import makeWebApp, songUri, songLocation

from light9 import networking, showconfig

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.show = show

        self.playlist = Playlist.fromShow(graph, show)

            nextSong = self.playlist.nextSong(thisSongUri)

        except NoSuchSong: # we're at the end of the playlist

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

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

    if not options.show:

"""

tiny bcf2000 controller demo

"""

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

import run_local

import light9.dmxclient as dmxclient

from light9.TLUtility import make_attributes_from_args

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)

        self.levs={}

        for xy,key,subname in [

            ((1,1),'KP_Up','centered'),

            ((1,2),'KP_Begin','scoop-c'),                            

                        ]:

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

from light9.effect.settings import DeviceSettings

from light9.collector.collector_client import sendToCollector

from rdfdb.patch import Patch

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

        try:

            os.makedirs(os.path.dirname(writePath))

        except OSError:

            pass

        with open(writePath, 'w') as out:

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

            xSteps = rxSteps[:]

            if row % 2:

                xSteps.reverse()

            row += 1

            for rx in xSteps:

                for zoom in zoomSteps:

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

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

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

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

                        #(dev, L9['focus'], 0.13),

                    ]))

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

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

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

        ]))

        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:

            yield self.off()

            yield deferSleep(1)

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

    logging.basicConfig(level=logging.DEBUG)

    log = logging.getLogger()

    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 light9.collector.collector import Collector

from light9.namespaces import L9

from light9 import networking

from rdfdb.syncedgraph import SyncedGraph

from light9.greplin_cyclone import StatsForCyclone

def parseJsonMessage(msg):

    body = json.loads(msg)

    settings = []

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

        if isinstance(value, basestring) and value.startswith('http'):

            value = URIRef(value)

        else:

            value = Literal(value)

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

            with stats.setAttr.time():

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

        self.lastFlush = 0

    def addClient(self, client):

                client.sendMessage(msg)

    def makeMsg(self, 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):

        log.info('socket connect %s', self)

        self.settings.listeners.addClient(self)

    def connectionLost(self, reason):

        self.settings.listeners.delClient(self)

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

             Udmx(L9['output/dmxA/'], bus=5, numChannels=80),

    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)

    if doLoadTest:

        # in a subprocess since we don't want this client to be

        # cooperating with the main event loop and only sending

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

from light9.collector.collector_client import sendToCollector, sendToCollectorZmq

from light9.namespaces import L9, DEV

from twisted.internet import reactor

import time

import logging

log.setLevel(logging.DEBUG)

def loadTest():

    print "scheduling loadtest"

    n = 2500

    times = [None] * n

    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,

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

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

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

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

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

                     [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

    def done():

        print "loadtest done"

        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 light9.observable import Observable

from light9 import clientsession

from rdfdb.patch import Patch

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

        graph.addHandler(updateTitle)

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

        self.registerGraphToSongChoice(wtree, session, graph, songChoice)

        self.registerSongChoiceToGraph(session, graph, songChoice)

        self.acceptDragsOnCurveViews()

        # may not work

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

            log.debug('songChoiceToGraph is going to set to %r', newSong)

            # I get bogus newSong values in here sometimes. This

            now = time.time()

            if now < self.muteSongChoiceUntil:

                log.debug('muted')

                return

            self.muteSongChoiceUntil = now + 1

        songChoice.subscribe(songChoiceToGraph)

    def registerCurrentPlayerSongToUi(self, wtree, graph, songChoice):

        """current_player_song 'song' param -> playerSong ui

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

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

                    log.debug('followPlayerSongChoice is on')

                    songChoice(song)

    def acceptDragsOnCurveViews(self):

        w = self.wtree.get_object("curves")

        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:

                    # we're not making sure the expression/etc are

                    # correct-- user mihgt need to fix things

                    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

            print "time", t

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

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

                       targetType, time):

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

        if '?' in data:

            self.handleSubtermDrop(data)

            return

            subName = current.label(data)

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

    def handleSubtermDrop(self, data):

        params = parse_qsl(data.split('?')[1])

        flattened = dict(params)

        self.makeSubterm(Literal(flattened['subtermName']),

            wc = self.wtree.get_object("newSubtermMakeCurve").get_active()

            self.makeSubterm(newname, withCurve=wc)

        dialog.hide()

    def currentSong(self):

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

    def songSubtermsContext(self):

        return self.currentSong()

    def makeSubterm(self, newname, withCurve=False, expr=None, sub=None):

          .button:link { font-size: 7px }

        ''')

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

        for p in providers:

            Gtk.StyleContext.add_provider_for_screen(