networking.musicPlayer.path('time'))

        songTime = json.loads(response.body)['t']

        node = EffectNode(self.settings.graph, uri)

        outSub = node.eval(songTime)

        self.write(json.dumps(outSub.get_dmx_list()))

# Completely not sure where the effect background loop should

# go. Another process could own it, and get this request repeatedly:

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

    def get(self):

        song = URIRef(self.get_argument('song'))

        effects = effectsForSong(self.settings.graph, song)

        raise NotImplementedError

        self.write(maxDict(effectDmxDict(e) for e in effects))

        # return dmx dict for all effects in the song, already combined

class App(object):

    def __init__(self, show, outputWhere):

        self.show = show

        self.outputWhere = outputWhere

        self.graph = SyncedGraph(networking.rdfdb.url, "effectEval")

        self.graph.initiallySynced.addCallback(self.launch)

        self.stats = scales.collection('/',

                                       scales.PmfStat('sendLevels'),

                                       scales.PmfStat('getMusic'),

                                       scales.PmfStat('evals'),

                                       scales.PmfStat('sendOutput'),

                                       scales.IntStat('errors'),

                                       )

    def launch(self, *args):

        self.loop = makeEffectLoop(self.graph, self.stats, self.outputWhere)

        self.loop.startLoop()

        SFH = cyclone.web.StaticFileHandler

        self.cycloneApp = cyclone.web.Application(handlers=[

            (r'/()', SFH,

             {'path': 'light9/effecteval', 'default_filename': 'index.html'}),

            (r'/effect', EffectEdit),

            (r'/(websocket\.js)', SFH, {'path': 'light9/rdfdb/web/'}),

            (r'/effect\.js', StaticCoffee, {'src': 'light9/effecteval/effect.coffee'}),

            (r'/index\.js', StaticCoffee, {'src': 'light9/effecteval/index.coffee'}),

            (r'/effectUpdates', EffectUpdates),

            (r'/code', Code),

            (r'/songEffectsUpdates', SongEffectsUpdates),

            (r'/effect/eval', EffectEval),

            (r'/songEffects', SongEffects),

            (r'/songEffects/eval', SongEffectsEval),

            (r'/stats', StatsForCyclone),

        ],

                                                  debug=True,

                                                  graph=self.graph,

                                                  stats=self.stats)

        reactor.listenTCP(networking.effectEval.port, self.cycloneApp)

        log.info("listening on %s" % networking.effectEval.port)

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

    def initialize(self, src):

        super(StaticCoffee, self).initialize()

        self.src = src

    def get(self):

        self.set_header('Content-Type', 'application/javascript')

        self.write(subprocess.check_output([

            '/usr/bin/coffee', '--compile', '--print', self.src]))

if __name__ == "__main__":

    parser = optparse.OptionParser()

    parser.add_option('--show',

        help='show URI, like http://light9.bigasterisk.com/show/dance2008',

                      default=showconfig.showUri())

    parser.add_option("-v", "--verbose", action="store_true",

                      help="logging.DEBUG")

    parser.add_option("--twistedlog", action="store_true",

                      help="twisted logging")

    parser.add_option("--output", metavar="WHERE", help="dmx or leds")

    (options, args) = parser.parse_args()

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

    if not options.show:

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

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

    if options.twistedlog:

        from twisted.python import log as twlog

        twlog.startLogging(sys.stderr)

    reactor.run()

                                              self.frameTimes[1:])]

            avg = sum(deltas) / len(deltas)

            log.info("fps: %.1f", 1 / avg)

            self.lastFpsLog = now

class Pics(cyclone.web.RequestHandler):

    @inlineCallbacks

    def get(self):

        try:

            self.set_header('Content-Type', 'x-application/length-time-jpeg')

            c = self.settings.camera

            setCameraParams(c, self.get_argument)

            resize = setupCrop(c, self.get_argument)

            self.running = True

            log.info("connection open from %s", self.request.remote_ip)

            fpsReport = FpsReport()

            def onFrame(frameTime, frame):

                if not self.running:

                    raise StopIteration

                now = time.time()

                self.write("%s %s\n" % (len(frame), frameTime))

                self.write(frame)

                self.flush()

                fpsReport.frame()

            # another camera request coming in at the same time breaks

            # the server. it would be nice if this request could

            # let-go-and-reopen when it knows about another request

            # coming in

            yield captureContinuousAsync(c, resize, onFrame)

        except Exception:

            traceback.print_exc()

    def on_connection_close(self, *a, **kw):

        log.info("connection closed")

        self.running = False

log.setLevel(logging.INFO)

with cameraCls() as camera:

    port = 8001

    reactor.listenTCP(port, cyclone.web.Application(handlers=[

        (r'/pic', Pic),

        (r'/pics', Pics),

        (r'/(|gui.js)', cyclone.web.StaticFileHandler, {'path': 'light9/vidref/',

                                                 'default_filename': 'index.html'}),

        ], debug=True, camera=camera))

    log.info("serving on %s" % port)

    reactor.run()

        c.sendMessage(j)

class Live(cyclone.websocket.WebSocketHandler):

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

        log.info("websocket opened")

        liveClients.add(self)

        self.settings.db.sendClientsToAllLivePages()

    def connectionLost(self, reason):

        log.info("websocket closed")

        liveClients.remove(self)

    def messageReceived(self, message):

        log.info("got message %s" % message)

        self.sendMessage(message)

class NoExts(cyclone.web.StaticFileHandler):

    # .xhtml pages can be get() without .xhtml on them

    def get(self, path, *args, **kw):

        if path and '.' not in path:

            path = path + ".xhtml"

        cyclone.web.StaticFileHandler.get(self, path, *args, **kw)

if __name__ == "__main__":

    logging.basicConfig()

    log = logging.getLogger()

    parser = optparse.OptionParser()

    parser.add_option("-v", "--verbose", action="store_true",

                      help="logging.DEBUG")

    (options, args) = parser.parse_args()

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

    db = Db(dirUriMap={os.environ['LIGHT9_SHOW'].rstrip('/') + '/':

                       URIRef('http://light9.bigasterisk.com/show/dance2014/')})

    from twisted.python import log as twlog

    twlog.startLogging(sys.stdout)

    port = 8051

    reactor.listenTCP(port, cyclone.web.Application(handlers=[

        (r'/live', Live),

        (r'/graph', GraphResource),

        (r'/patches', Patches),

        (r'/graphClients', GraphClients),

        (r'/(.*)', NoExts,

         {"path" : "light9/rdfdb/web",

          "default_filename" : "index.xhtml"}),

        ], debug=True, db=db))

    log.info("serving on %s" % port)

    prof.run(reactor.run, profile=None)

        if created > newest[0]:

            newest = (created, img)

    return newest[1]

if __name__ == "__main__":

    parser = optparse.OptionParser()

    parser.add_option("-v", "--verbose", action="store_true",

                      help="logging.DEBUG")

    (options, args) = parser.parse_args()

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

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

    d = {}

    def updateSubs():

        subs = []

        for sub in sorted(graph.subjects(RDF.type, L9['Submaster'])):

            rec = {'uri' : sub}

            rec['isLocal'] = graph.contains((sub, RDF.type,

                                             L9['LocalSubmaster']))

            rec['label'] = graph.label(sub)

            rec['img'] = newestImage(sub)

            subs.append(rec)

        d.clear()

        d.update({'subs': subs})

        d['chases'] = []

        for chase in sorted(graph.subjects(RDF.type, L9['Chase'])):

            fakeLabel = chase.rsplit('/', 1)[-1]

            d['chases'].append({

                'uri': chase,

                'label': fakeLabel,

            })

        sendToLiveClients(d=d)

    def onNewClient():

        sendToLiveClients(d=d)

    graph.addHandler(updateSubs)

    port = 8052

    reactor.listenTCP(port, cyclone.web.Application(handlers=[

        (r'/live', Live),

        (r'/effectsUpdates', EffectsUpdates),

        (r'/snapshot', Snapshot),

        (r'/(.*)', Static,

         {"path" : "light9/subserver",

          "default_filename" : "index.jade"}),

        ], debug=True, graph=graph, onNewClient=onNewClient))

    log.info("serving on %s" % port)

    reactor.run()

from light9 import networking, showconfig

from light9.vidref.main import Gui

from light9.vidref.replay import snapshotDir

from light9.rdfdb.syncedgraph import SyncedGraph

 # find replay dirs correctly. show multiple

 # replays. trash. reorder/pin. dump takes that are too short; they're

 # just from seeking

parser = optparse.OptionParser()

parser.add_option("-v", "--verbose", action="store_true",

                  help="logging.DEBUG")

(options, args) = parser.parse_args()

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

class Snapshot(cyclone.web.RequestHandler):

    @defer.inlineCallbacks

    def post(self):

        # save next pic

        # return /snapshot/path

        try:

            outputFilename = yield self.settings.gui.snapshot()

            assert outputFilename.startswith(snapshotDir())

            out = networking.vidref.path(

                "snapshot/%s" % outputFilename[len(snapshotDir()):].lstrip('/'))

            self.write(json.dumps({'snapshot': out}))

            self.set_header("Location", out)

            self.set_status(303)

        except Exception as e:

            import traceback

            traceback.print_exc()

            raise

class SnapshotPic(cyclone.web.StaticFileHandler):

    pass

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

gui = Gui(graph)

port = networking.vidref.port

reactor.listenTCP(port, cyclone.web.Application(handlers=[

    (r'/()', cyclone.web.StaticFileHandler,

     {'path': 'light9/vidref', 'default_filename': 'vidref.html'}),

    (r'/snapshot', Snapshot),

    (r'/snapshot/(.*)', SnapshotPic, {"path": snapshotDir()}),

    ], debug=True, gui=gui))

log.info("serving on %s" % port)

reactor.run()

from lib.cycloneerr import PrettyErrorHandler

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

    def get(self):

        return self.redirect(networking.picamserve.path(

            'pic?' + self.request.query))

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

    def get(self):

        self.set_header('Content-Type', 'text/plain')

        self.write(networking.picamserve.path('pic'))

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

    def get(self):

        graph = self.settings.graph

        show = showconfig.showUri()

        with graph.currentState(tripleFilter=(show, None, None)) as g:

            ret = g.value(show, L9['vidrefCamRequest'])

            if ret is None:

                self.send_error(404)

            self.redirect(ret)

    def put(self):

        graph = self.settings.graph

        show = showconfig.showUri()

        graph.patchObject(context=URIRef(show + '/vidrefConfig'),

                          subject=show,

                          predicate=L9['vidrefCamRequest'],

                          newObject=URIRef(self.get_argument('uri')))

        self.send_error(202)

def main():

    parser = optparse.OptionParser()

    parser.add_option("-v", "--verbose", action="store_true",

                      help="logging.DEBUG")

    (options, args) = parser.parse_args()

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

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

    # deliberately conflict with vidref since they can't talk at once to cam

    port = networking.vidref.port 

    reactor.listenTCP(port, cyclone.web.Application(handlers=[

        (r'/pic', RedirToCamera),

        (r'/picUrl', UrlToCamera),

        (r'/vidrefCamRequest', VidrefCamRequest),

        (r'/()', cyclone.web.StaticFileHandler, {'path': 'light9/vidref/', 'default_filename': 'vidref.html'}),

        ], debug=True, graph=graph))

    log.info("serving on %s" % port)

    reactor.run()

main()

<?xml version="1.0" encoding="iso-8859-1"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"

"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" 

      xmlns:py="http://genshi.edgewall.org/">

  <head>

    <title>ascoltami on ${host}</title>

  </head>

  <body>

    <h1>ascoltami on ${host}</h1>

    <div class="songs"/>

    <div class="dimStalled">

      <table>

        <tr><td colspan="3">Song: <span id="currentSong"/></td></tr>

        <tr>

          <td>Time: <span id="currentTime"/></td>

          <td>Left: <span id="leftTime"/></td>

          <td>Until autostop: <span id="leftAutoStopTime"/></td>

        </tr>

        <tr>

          <td colspan="3">

            Update freq: requested <span id="updateReq"/>, actual <span id="updateActual"/>

            States: <span id="states"/>

          </td>

        </tr>

      </table>

      <div class="timeRow">

        <div id="timeSlider"/>

      </div>

    </div>

    <div class="commands">

      <button id="cmd-stop" class="playMode">Stop<div class="key">s</div></button>

      <button id="cmd-play" class="playMode">Play <div class="key">p</div></button>

      <button id="cmd-intro">Skip intro <div class="key">i</div></button>

      <button id="cmd-post">Skip to Post <div class="key">t</div></button>

      <button id="cmd-go">Go  <div class="key">space</div></button>

      <button id="cmd-out0">Output 0</button>

      <button id="cmd-out1">Output 1</button>

    </div>

    <p>Running on <span id="nav"/></p>

    todo: display next action

    <p><button onclick="window.open('/', '_blank', 'scrollbars=1,resizable=1,titlebar=0,location=0')">reopen this in a simpler window</button></p>

    <p><a href="">reload</a></p>

<script type="text/javascript">

// <![CDATA[

$(function () {

    $("#nav").text(navigator.userAgent);

        songs = getSongsFromShow(graph, self.settings.app.show)

        self.set_header("Content-Type", "application/json")

        self.write(json.dumps({"songs" : [

            {"uri" : s,

             "path" : graph.value(s, L9['showPath']),

             "label" : graph.label(s)} for s in songs]}))

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

    def post(self):

        """post a uri of song to switch to (and start playing)"""

        graph = self.settings.app.graph

        self.settings.app.player.setSong(songLocation(graph, URIRef(self.request.body)))

        self.set_header("Content-Type", "text/plain")

        self.write("ok")

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

    def post(self):

        player = self.settings.app.player

        data = json.loads(self.request.body)

        if player.isPlaying():

            player.pause()

        else:

            player.seek(data['t'])

            player.resume()

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

    def post(self):

        d = json.loads(self.request.body)

        subprocess.check_call(["bin/movesinks", str(d['sink'])])

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

    def post(self):

        """

        if music is playing, this silently does nothing.

        """

        graph, player = self.settings.app.graph, self.settings.app.player

        if player.isPlaying():

            pass

        else:

            player.resume()

        self.set_header("Content-Type", "text/plain")

        self.write("ok")

def makeWebApp(app):

    return cyclone.web.Application(handlers=[

        (r"/", root),

        (r"/time", timeResource),

        (r"/song", songResource),

        (r"/songs", songs),

        (r"/seekPlayOrPause", seekPlayOrPause),

        (r"/output", output),

        (r"/go", goButton),

        ], app=app)

<!doctype html>

<html>

  <head>

    <title>effect</title>

    <meta charset="utf-8" />

  </head>

  <body>

    <a href="./">Effects</a> / <a class="effect" data-bind="attr: {href: toSave.uri}, text: toSave.uri"></a>

    <div data-bind="foreach: toSave.codeLines">

      <div>

        code:

        <input type="text" size="160" data-bind="value: text"></input>

      </div>

    </div>

    <script src="effect.js"></script>

  </body>

</html>

<!doctype html>

<html>

  <head>

    <title>effecteval</title>

    <meta charset="utf-8" />

  </head>

  <body>

    <div><a href="stats">/stats</a></div>

    <h1>Effect instances</h1>

    <div><a href=".">View all songs</a></div>

    <!-- subscribe to a query of all effects and their songs -->

    <ul data-bind="foreach: songs">

      <li>

        <a class="song" data-bind="attr: {href: uri}, click: $root.focusSong">Song <span data-bind="text: label"></span></a>

        <ul>

          <!-- ko foreach: effects -->

          <li>

            <a class="effect" data-bind="attr: {href: 'effect?'+jQuery.param({uri: uri})}, text: label"></a> <button data-bind="click: deleteEffect">Delete</button>

          </li>

          <!-- /ko -->

          <li class="dropTarget" data-bind="event: {dragover: $root.dragover, dragenter: $root.dragover, drop: function(data, event) { $root.drop(uri, event); }}">Add another (drop a sub or effect class)</li>

        </ul>

      </li>

    </ul>

    <script src="index.js"></script>

  </body>

</html>

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"

"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

  <head>

    <title>graphview</title>

  </head>

  <body>

    <!--

        this page is another graph client who maintains the whole

        graph all the time

    -->

    <p>status: <span id="status">starting...</span></p>

    <fieldset>

      <legend>Messages</legend>

      <div id="out"></div>

    </fieldset>

    <p>URI substring: <input type="text" id="uriSubstring"/></p>

    <table>

      <thead>

        <tr>

          <th>subject</th> <th>predicate</th> <th>object</th> <th>context</th>

        </tr>

      </thead>

      <tbody>

      </tbody>

    </table>

    <script type="text/javascript" src="syncedgraph.js"></script>

    <script type="text/javascript">

      // <![CDATA[

      $(function(){

      });

      // ]]>

    </script>

  </body>

</html>

<?xml version="1.0" encoding="utf8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"

"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

  <head>

    <title>rdfdb</title>

  </head>

  <body>

    <h1>rdfdb</h1>

    <p>status: <span id="status">starting...</span></p>

    <section>

      <h2>Edits</h2>

      <div id="patches"></div>

    </section>

    <p>Clients: <span id="clients"/></p>

    <fieldset>

      <legend>Messages</legend>

      <div id="out"></div>

    </fieldset>

    <script type="text/javascript">

      // <![CDATA[

      $(function(){

          function collapseCuries(s) {

            // this is temporary. The correct thing is to parse the quad (or receive it as a tree) and then make links to the full URIs and display curies of them

              return s

                  .replace(/<http:\/\/www.w3.org\/2001\/XMLSchema#(.*?)>/g, function (match, short) { return "xsd:"+short; })

                  .replace(/<http:\/\/light9.bigasterisk.com\/(.*?)>/g, function (match, short) { return "light9:"+short; })

                  .replace(/<http:\/\/light9.bigasterisk.com\/show\/dance2012\/sessions\/(.*?)>/g, function (match, short) { return "kcsession:"+short });

          }

          function onMessage(d) {

              if (d.clients !== undefined) {

                  $("#clients").empty().text(JSON.stringify(d.clients));

              }

              if (d.patch !== undefined) {

                  $("#patches").prepend(

                      $("<fieldset>").addClass("patch")

                          .append($("<legend>").text("Patch"))

                          .append($("<div>").addClass("deletes").text(collapseCuries(d.patch.deletes)))

                          .append($("<div>").addClass("adds").text(collapseCuries(d.patch.adds)))

                  );

              }

              $('#out').append($('<div>').text(JSON.stringify(d)));

          }

          reconnectingWebSocket("ws://localhost:8051/live", onMessage);

      });

      // ]]>

    </script>

  </body>

</html>

doctype html

html

  head

    title effects

  body

    h1 Effects

    div(data-bind="foreach: moreExprs")

      div.resource.chase

        span(data-bind="text: label")

        | 

        a.resource(data-bind="attr: {href: $root.subtermLink(label, expr)}, text: expr")

    div(data-bind="foreach: chases")

      div.resource.chase

        | Chase

        a(data-bind="attr: {href: uri}, text: label")

        ul(data-bind="foreach: $parent.subtermExprs($data)")

          li: a.resource(data-bind="attr: {href: $root.subtermLink($parent.label, $data)}, text: $data")

    div(data-bind="foreach: classes")

      div.resource.effectClass

        h2

          | Effect class

          | 

          a(data-bind="attr: {href: uri}, text: label")

          button(data-bind="click: $root.addToCurrentSong") Add to current song

        div

          code(data-bind="text: code")

    #status

    script(src="effects.js")

doctype html

html

  head

    title subs

  body

    h1 Submasters

    div

      input(type='checkbox', data-bind='checked: showLocal', id='showLocal')

      label(for='showLocal') show local

    div(data-bind="foreach: subs")

      // ko if: $parent.showLocal() || !isLocal

      a.resource.sub(data-bind="css: {local: isLocal}, attr: {href: uri}")

        div(data-bind="if: isLocal") (local)

        div

          | Label

          input(type="text", data-bind="value: label")

        div

          img(data-bind="attr: {src: img}")

        div

          button(data-bind="click: $root.snapshot")

            New snapshot