#!bin/python

from run_local import log

from twisted.internet import reactor

import web, thread, sys, optparse, logging

from rdflib import URIRef

sys.path.append(".")

import gi

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

gi.require_version('Gtk', '3.0')

from light9.ascoltami.player import Player

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)

        self.player.seek(0)

        thisSongUri = songUri(graph, URIRef(song))

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

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

    if not options.show:

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

    graph = showconfig.getGraph()

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

    if options.twistedlog:

        from twisted.python import log as twlog

        twlog.startLogging(sys.stderr)

    reactor.listenTCP(networking.musicPlayer.port, makeWebApp(app))

"""

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

#!bin/python

import sys, time, math

import Tkinter as tk

import run_local

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

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

        startTime = time.time()

        self.captureId = 'cap%s' % (int(startTime) - 1495170000)

        self.toGather = []

        rxSteps = steps(.06, .952, 10)

        rySteps = steps(0.1, .77, 5)

        zoomSteps = steps(.12, .85, 3)

        # aura

        rxSteps = steps(0.15, .95, 10)

        rySteps = steps(0, .9, 5)

        row = 0

        for ry in rySteps:

            xSteps = rxSteps[:]

            if row % 2:

                xSteps.reverse()

            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:

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

    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.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"""

        self.pendingMessageForDev[dev] = (attrs, outputMap)

        try:

            self._flush()

            return

        self.lastFlush = now

        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.

            for client, seen in self.clients:

                if seen.get(dev) == attrs:

                    continue

                client.sendMessage(msg)

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

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

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

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

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

        ]

    except Exception:

        log.error("setting up outputs:")

        traceback.print_exc()

        raise

    listeners = WebListeners()

    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,

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

if __name__ == '__main__':

    loadTest()

#!bin/python

"""

now launches like this:

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

todo: curveview should preserve more objects, for speed maybe

"""

from __future__ import division

import sys

from twisted.internet import gtk3reactor

gtk3reactor.install()

from twisted.internet import reactor

import time, textwrap, os, optparse, linecache, signal, traceback, json

import gi

from gi.repository import Gtk

from gi.repository import GObject

from gi.repository import Gdk

from urlparse import parse_qsl