import optparse

import os

import time

import treq

import cyclone.web, cyclone.websocket, cyclone.httpclient

from greplin import scales

from run_local import log

from lib.cycloneerr import PrettyErrorHandler

from light9.namespaces import L9, RDF

from light9 import networking, showconfig

from light9.paint.capture import writeCaptureDescription

from light9.greplin_cyclone import StatsForCyclone

from light9.effect.settings import DeviceSettings

from light9.effect.sequencer import sendToCollector

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)

        return treq.get(self.imageUrl).addCallbacks(

            lambda r: self._done(writePath, r), log.error)

#!bin/python

import os, sys

sys.path.append(".")

from twisted.internet import reactor

import cyclone.web, cyclone.httpclient, logging

from rdflib import Namespace, Literal, URIRef

from light9 import networking

if __name__ == "__main__":

    logging.basicConfig(level=logging.DEBUG)

    log = logging.getLogger()

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

    from light9.Submaster import PersistentSubmaster

    sub = PersistentSubmaster(graph=g, uri=URIRef("http://light9.bigasterisk.com/sub/bcools"))

    #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

import optparse

import time

import traceback

import cyclone.web, cyclone.websocket

from greplin import scales

from run_local import log

from lib.cycloneerr import PrettyErrorHandler

from light9.collector.output import EnttecDmx, Udmx, DummyOutput

from light9.collector.collector import Collector

from light9.namespaces import L9

from light9 import networking

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

from light9 import showconfig, networking

from light9.curvecalc import curveview 

from light9.curvecalc.curve import Curveset

from light9.curvecalc.curveedit import serveCurveEdit

from light9.curvecalc.musicaccess import Music

from light9.curvecalc.output import Output

from light9.curvecalc.subterm import Subterm

from light9.curvecalc.subtermview import add_one_subterm

from light9.editchoicegtk import EditChoice, Local

from light9.gtkpyconsole import togglePyConsole

from light9.namespaces import L9

from light9.observable import Observable

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.currentSubterms = [] # Subterm objects that are synced to the graph

import cyclone.web, cyclone.websocket, cyclone.httpclient

import sys, optparse, logging, subprocess, json, itertools

from rdflib import URIRef, Literal

sys.path.append('/usr/lib/pymodules/python2.7/') # for numpy, on rpi

sys.path.append('/usr/lib/python2.7/dist-packages') # For numpy

from light9 import networking, showconfig

from light9.effecteval.effect import EffectNode

from light9.effect.edit import getMusicStatus, songNotePatch

from light9.effecteval.effectloop import makeEffectLoop

from light9.greplin_cyclone import StatsForCyclone

from light9.namespaces import L9

from greplin import scales

from lib.cycloneerr import PrettyErrorHandler

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

    def get(self):

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

        self.write(open("light9/effecteval/effect.html").read())

    def delete(self):

        graph = self.settings.graph

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

        with graph.currentState(tripleFilter=(None, L9['effect'], uri)) as g:

#!bin/python

"""

plays back effect notes from the timeline

"""

from __future__ import division

from run_local import log

from twisted.internet import reactor

from light9.greplin_cyclone import StatsForCyclone

from light9 import networking, showconfig

from greplin import scales

import optparse, sys, logging

import cyclone.web

from rdflib import URIRef

from light9.effect.sequencer import Sequencer, sendToCollector

class App(object):

    def __init__(self, show, session):

        self.show = show

        self.session = session

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

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

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

                                       scales.PmfStat('sendLevels'),

#!bin/python

import run_local

import gtk

import sys

sys.path.append(".")

from rdflib import URIRef

from light9 import networking

from light9.editchoicegtk import EditChoice, Local

from light9.observable import Observable

win = gtk.Window()

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

r1 = URIRef("http://example.com/interestingThing")

v = Observable(r1)

win.add(EditChoice(graph, v))

win.show_all()

gtk.main()

#!bin/python

from run_local import log

from rdflib import RDF, URIRef

from light9 import networking, showconfig

from light9.namespaces import L9

from urlparse import urlparse

from urllib import splitport

from twisted.internet import reactor

graph = showconfig.getGraph()

netHome = graph.value(showconfig.showUri(), L9['networking'])

webServer = graph.value(netHome, L9['webServer'])

if not webServer:

    raise ValueError('no %r :webServer' % netHome)

print "listen %s;" % splitport(urlparse(webServer).netloc)[1]

def location(path, server):

    print """

#!bin/python

import sys

sys.path.append('/usr/lib/python2.7/dist-packages') # For gtk

from twisted.internet import gtk3reactor

gtk3reactor.install()

from twisted.internet import reactor

from rdflib import URIRef

import optparse, logging, urllib, time

from gi.repository import Gtk

from run_local import log

from light9 import showconfig, networking

import cyclone.httpclient

from light9.curvecalc.client import sendLiveInputPoint

class App(object):

    def __init__(self):

        parser = optparse.OptionParser()

        parser.set_usage("%prog [opts] [curve uri]")

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

                          help="log at DEBUG")

        clientsession.add_option(parser)

        opts, args = parser.parse_args()

#!bin/python

"""

read Quneo midi events, write to curvecalc and maybe to effects

"""

from __future__ import division

from run_local import log

import logging, urllib

import cyclone.web, cyclone.httpclient

from rdflib import URIRef

from twisted.internet import reactor, task

from light9.curvecalc.client import sendLiveInputPoint

from light9.namespaces import L9, RDF, RDFS

from light9 import networking

import sys

sys.path.append('/usr/lib/python2.7/dist-packages') # For pygame

import pygame.midi

curves = {

    23: URIRef('http://light9.bigasterisk.com/show/dance2014/song1/curve/c-2'),

    24: URIRef('http://light9.bigasterisk.com/show/dance2014/song1/curve/c-3'),

    25: URIRef('http://light9.bigasterisk.com/show/dance2014/song1/curve/c-4'),

    6:URIRef('http://light9.bigasterisk.com/show/dance2014/song1/curve/c-5'),

    18: URIRef('http://light9.bigasterisk.com/show/dance2014/song1/curve/c-6'),

from louie import dispatcher

from twisted.internet import reactor, tksupport

from twisted.web import resource

from rdflib import URIRef, Literal

import Tix as tk

from light9.Fadable import Fadable

from light9.subclient import SubClient

from light9 import showconfig, networking, prof

from light9.uihelpers import toplevelat

from light9.namespaces import L9, RDF, RDFS

from light9.tkdnd import initTkdnd, dragSourceRegister, dropTargetRegister

from light9.effect.sequencer import CodeWatcher

import light9.effect.effecteval

from light9.effect.settings import DeviceSettings

from bcf2000 import BCF2000

nudge_keys = {

    'up'   : list('qwertyui'),

    'down' : list('asdfghjk')

}

class DummySliders:

    def valueOut(self, name, value):

        pass

    def close(self):

in .zshrc:

function _songs { local expl;  _description files expl 'songs';  compadd "$expl[@]" - `${LIGHT9_SHOW}/../../bin/listsongs` }

compdef _songs curvecalc

"""

from run_local import log

from twisted.internet import reactor

from rdflib import RDF

from light9 import networking

from light9.namespaces import L9

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

@graph.initiallySynced.addCallback

def printSongs(result):

    with graph.currentState() as current:

        for song in current.subjects(RDF.type, L9['Song']):

            print song

    reactor.stop()

reactor.run()

#!bin/python

from __future__ import division

from run_local import log

import json

from twisted.internet import reactor

from light9.greplin_cyclone import StatsForCyclone

from light9 import networking, showconfig

from greplin import scales

import optparse, sys, logging

import cyclone.web

from rdflib import URIRef

import light9.paint.solve

from lib.cycloneerr import PrettyErrorHandler

from light9.namespaces import RDF, L9, DEV

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

    def post(self):

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

        with self.settings.stats.solve.time():

            img = self.settings.solver.draw(painting)

"""

from twisted.internet import reactor, defer

import twisted.internet.error

from twisted.python.filepath import FilePath

from twisted.python.failure import Failure

from twisted.internet.inotify import humanReadableMask, IN_CREATE

import sys, optparse, logging, json, os

import cyclone.web, cyclone.httpclient, cyclone.websocket

sys.path.append(".")

from light9 import networking, showconfig, prof

from rdflib import ConjunctiveGraph, URIRef, Graph

from twisted.internet.inotify import INotify

from run_local import log

log.setLevel(logging.DEBUG)

from lib.cycloneerr import PrettyErrorHandler

class WebsocketDisconnect(ValueError):

    pass

def sendGraphToClient(graph, client):

    """send the client the whole graph contents"""

import louie as dispatcher

from twisted.internet import reactor, tksupport, task

from rdflib import URIRef, RDF, RDFS, Literal

from run_local import log

log.setLevel(logging.DEBUG)

from light9.dmxchanedit import Levelbox

from light9 import dmxclient, Submaster, prof, showconfig, networking

from light9.Patch import get_channel_name

from light9.uihelpers import toplevelat

from light9.tkdnd import initTkdnd

from light9.namespaces import L9

from light9.observable import Observable

from light9.editchoice import EditChoice, Local

from light9.subcomposer import subcomposerweb

class Subcomposer(tk.Frame):

    """

    <session> l9:currentSub ?sub is the URI of the sub we're tied to for displaying and

    editing. If we don't have a currentSub, then we're actually

    editing a session-local sub called <session> l9:currentSub <sessionLocalSub>

    I'm not sure that Locals should even be PersistentSubmaster with

#!bin/python

"""

live web display of all existing subs with pictures, mainly for

dragging them into CC or Timeline

"""

from run_local import log

import sys, optparse, logging, json, subprocess, datetime

from dateutil.tz import tzlocal

from twisted.internet import reactor, defer

import cyclone.web, cyclone.httpclient, cyclone.websocket

from rdflib import RDF, URIRef, Literal

import pyjade.utils

from light9.namespaces import L9, DCTERMS

from light9 import networking, showconfig

from lib.cycloneerr import PrettyErrorHandler

class Static(PrettyErrorHandler, cyclone.web.StaticFileHandler):

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

        if path in ['', 'effects']:

            return self.respondStaticJade("light9/subserver/%s.jade" %

                                          (path or 'index'))

        if path.endswith(".js"):

sys.path.append('/usr/lib/python2.7/dist-packages') # For gtk

from twisted.internet import gtk2reactor

gtk2reactor.install()

from twisted.internet import reactor, defer

import gobject

gobject.threads_init()

import gtk

import sys, logging, optparse, json

import cyclone.web, cyclone.httpclient, cyclone.websocket

from light9 import networking, showconfig

from light9.vidref.main import Gui

from light9.vidref.replay import snapshotDir

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

#!bin/python

""" this should be part of vidref, but I haven't worked out sharing

camera captures with a continuous camera capture yet """

from run_local import log

import sys, optparse, logging, json, subprocess, datetime

from dateutil.tz import tzlocal

from twisted.internet import reactor, defer

import cyclone.web, cyclone.httpclient, cyclone.websocket

from rdflib import RDF, URIRef, Literal

import pyjade.utils

from light9.namespaces import L9, DCTERMS

from light9 import networking, showconfig

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

from __future__ import division

import os, logging, time

from rdflib import Graph, RDF

from rdflib import RDFS, Literal, BNode

from light9.namespaces import L9, XSD

from light9.TLUtility import dict_scale, dict_max

from light9 import showconfig

from light9.Patch import resolve_name, get_dmx_channel, get_channel_uri, reload_data

from louie import dispatcher

log = logging.getLogger('submaster')

class Submaster(object):

    """mapping of channels to levels"""

    def __init__(self, name, levels):

        """this sub has a name just for debugging. It doesn't get persisted.

        See PersistentSubmaster.

        levels is a dict

        """

        self.name = name

        self.levels = levels

import unittest

import datetime, time

from freezegun import freeze_time

from rdflib import Namespace, URIRef

from light9.namespaces import L9, DEV

from light9.collector.collector import Collector, outputMap

UDMX = Namespace('http://light9.bigasterisk.com/output/udmx/')

DMX0 = Namespace('http://light9.bigasterisk.com/output/dmx0/')

PREFIX = '''

   @prefix : <http://light9.bigasterisk.com/> .

        @prefix dev: <http://light9.bigasterisk.com/device/> .

        @prefix udmx: <http://light9.bigasterisk.com/output/udmx/> .

        @prefix dmx0: <http://light9.bigasterisk.com/output/dmx0/> .

'''

THEATER = '''

from __future__ import division

import glob, time, logging, ast, os

from bisect import bisect_left,bisect

import louie as dispatcher

from twisted.internet import reactor

from rdflib import Literal

from light9 import showconfig

from light9.namespaces import L9, RDF, RDFS

log = logging.getLogger()

# todo: move to config, consolidate with ascoltami, musicPad, etc

introPad = 4

postPad = 4

class Curve(object):

    """curve does not know its name. see Curveset"""

    def __init__(self, uri, pointsStorage='graph'):

        self.uri = uri

        self.pointsStorage = pointsStorage

        self.points = [] # x-sorted list of (x,y)

import math, os, random, logging

from rdflib import Graph, URIRef, RDF, RDFS, Literal

from louie import dispatcher

import light9.Effects

from light9 import Submaster, showconfig, prof

from light9.Patch import get_dmx_channel

from light9.namespaces import L9

log = logging.getLogger()

class Expr(object):

    """singleton, provides functions for use in subterm expressions,

    e.g. chases"""

    def __init__(self):

        self.effectGlobals = light9.Effects.configExprGlobals()

    def exprGlobals(self, startDict, t):

        """globals dict for use by expressions"""

import json

import cyclone.httpclient

from twisted.internet.defer import inlineCallbacks, returnValue

from rdflib import URIRef, Literal

from light9 import networking

from light9.namespaces import L9, RDF, RDFS

from light9.curvecalc.curve import CurveResource

def clamp(x, lo, hi):

    return max(lo, min(hi, x))

@inlineCallbacks

def getMusicStatus():

    returnValue(json.loads((yield cyclone.httpclient.fetch(

        networking.musicPlayer.path('time'), timeout=.5)).body))

@inlineCallbacks

from __future__ import division

"""

Data structure and convertors for a table of (device,attr,value)

rows. These might be effect attrs ('strength'), device attrs ('rx'),

or output attrs (dmx channel).

"""

import decimal

import numpy

from rdflib import URIRef, Literal

from light9.namespaces import RDF, L9, DEV

import logging

log = logging.getLogger('settings')

from light9.collector.device import resolve

def parseHex(h):

    if h[0] != '#': raise ValueError(h)

    return [int(h[i:i+2], 16) for i in 1, 3, 5]

def parseHexNorm(h):

    return [x / 255 for x in parseHex(h)]

def toHex(rgbFloat):

import unittest

from rdflib import Literal

from light9.namespaces import RDF, L9, DEV

from light9.effect.settings import DeviceSettings

class TestDeviceSettings(unittest.TestCase):

    def setUp(self):

        self.graph = LocalSyncedGraph(files=['test/cam/lightConfig.n3',

                                             'test/cam/bg.n3'])

    def testToVectorZero(self):

        ds = DeviceSettings(self.graph, [])

        self.assertEqual([0] * 30, ds.toVector())

import os

from rdflib import URIRef

from light9 import showconfig

from light9.namespaces import L9, RDF

from light9.paint.solve import loadNumpy

def writeCaptureDescription(graph, ctx, session, uri, dev, outPath,

                            settingsSubgraphCache, settings):

    graph.patch(Patch(addQuads=settings.statements(

        uri, ctx=ctx,

        settingRoot=URIRef('/'.join([

            showconfig.showUri(), 'capture', dev.rsplit('/')[1]])),

        settingsSubgraphCache=settingsSubgraphCache)))

    graph.patch(Patch(addQuads=[

        (dev, L9['capture'], uri, ctx),

import unittest

import numpy.testing

import solve

from rdflib import Namespace

from light9.namespaces import RDF, L9, DEV

from light9.effect.settings import DeviceSettings

class TestSolve(unittest.TestCase):

    def setUp(self):

        self.graph = LocalSyncedGraph(files=['test/cam/lightConfig.n3',

                                             'test/cam/bg.n3'])

        self.solver = solve.Solver(self.graph, imgSize=(100, 48), sessions=[L9['session0']])

        self.solver.loadSamples()

        self.solveMethod = self.solver.solve

    @unittest.skip('solveBrute unfinished')

    def testBlack(self):

scipy==0.19.0

service_identity==16.0.0

statprof==0.1.2

toposort==1.5

treq==17.3.1

Twisted==17.1.0

txosc==0.2.0

txzmq==0.8.0

typing==3.6.1

watchdog==0.8.3

web.py==0.38

webcolors==1.7