#!/usr/bin/python

import math

import twisted.internet.fdesc

from twisted.internet import reactor

from twisted.internet.task import LoopingCall

class BCF2000(object):

    control = {81 : "slider1", 82 : "slider2", 83 : "slider3", 84 : "slider4",

               85 : "slider5", 86 : "slider6", 87 : "slider7", 88 : "slider8",

    def __init__(self, dev="/dev/snd/midiC2D0"):

        """device was usually /dev/snd/midiC1D0 but then it showed up

        once as C0D0. It should be autodetected"""

        self.devPath = dev

        self.dev = None

        self.reopen()

        self.packet = ""

        loop = LoopingCall(self.poll)

        loop.start(.01)

    def poll(self):

        try:

            bytes = self.dev.read(3)

        except (IOError, AttributeError):

            return

        if len(bytes) == 0:

            self.reopen()

            return

        self.packet += bytes

        if len(self.packet) == 3:

            p = self.packet

            self.packet = ""

            name = self.control[which]

            if name.startswith("button-"):

                value = value > 0

            self.lastValue[name] = value

            self.valueIn(name, value)

        else:

    def reopen(self):

        if self.dev is not None:

            try:

                self.dev.close()

            except IOError:

        self.dev = open(self.devPath, "r+")

        twisted.internet.fdesc.setNonBlocking(self.dev)

    def valueIn(self, name, value):

        """override this with your handler for when events come in

        from the hardware"""

        if name == 'slider1':

            for x in range(2,8+1):

                v2 = int(64 + 64 * math.sin(x / 3 + value / 10))

                self.valueOut('slider%d' % x, v2)

            for x in range(1,8+1):

                self.valueOut('button-upper%s' % x, value > x*15)

            return

        value = int(value)

        if self.lastValue.get(name) == value:

            return

        self.lastValue[name] = value

        assert len(which) == 1, "unknown control name %r" % name

        if name.startswith('button-'):

            value = value * 127

        #print "bcf: write %s %s" % (name, value)

        self.dev.write(chr(0xb0) + chr(which[0]) + chr(int(value)))

import webcolors, colorsys

from louie import dispatcher

from twisted.internet import reactor, tksupport

from twisted.web import resource

from rdflib import URIRef, Literal

import tkinter.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

    def __init__(self, master, graph, sub, session, col, row):

        self.graph = graph

        self.sub = sub

        self.session = session

        self.col, self.row = col, row

        rgb = webcolors.hex_to_rgb(bg)

        hsv = colorsys.rgb_to_hsv(*[x / 255 for x in rgb])

        darkBg = webcolors.rgb_to_hex(

            tuple([

                int(x * 255) for x in colorsys.hsv_to_rgb(hsv[0], hsv[1], .2)

            ]))

    def __init__(self, root, graph, session, hw_sliders=True):

        tk.Frame.__init__(self, root, bg='black')

        SubClient.__init__(self)

        self.graph = graph

        self.session = session

        self.current_row = 0  # should come from session graph

        self.use_hw_sliders = hw_sliders

        self.connect_to_hw(hw_sliders)

                               self.graph.value(effect, L9['order']),

                               self.graph.label(effect), effect))

        withgroups.sort()

        log.info("withgroups %s", withgroups)

        imp.reload(light9.effect.effecteval)

        simpleOutputs = SimpleOutputs(self.graph)

        for group, order, sortLabel, effect in withgroups:

            if col == 0 or group != last_group:

                row = self.make_row(group)

                rowcount += 1

#!bin/python

import run_local  # noqa

import os

from light9 import networking, showconfig

import rdfdb.service

rdfdb.service.main(

    dirUriMap={

    },

    prefixes={

    },

    port=networking.rdfdb.port,

)

log = logging.getLogger('coll_client')

_zmqClient = None

class TwistedZmqClient(object):

    def __init__(self, service):

        zf = ZmqFactory()

        e = ZmqEndpoint('connect', 'tcp://%s:%s' % (service.host, service.port))

        self.conn = ZmqPushConnection(zf, e)

    def send(self, msg):

from light9.namespaces import L9, DEV

from webcolors import rgb_to_hex, hex_to_rgb

from colorsys import hsv_to_rgb

import math

from noise import pnoise1

import logging

from light9.effect.settings import DeviceSettings

from light9.effect.scale import scale

import random

random.seed(0)

print("reload effecteval")

log = logging.getLogger('effecteval')

        strength = float(effectSettings[L9['strength']])

        if strength <= 0:

            return DeviceSettings(self.graph, []), {'zero': True}

        report = {}

        out.update(

            self.simpleOutputs.values(

                self.effect, strength,

                effectSettings.get(L9['colorScale'], None)))

from twisted.internet import defer

from twisted.internet.inotify import INotify

from twisted.python.filepath import FilePath

import cyclone.sse

import logging, bisect, time

import traceback

from light9.namespaces import L9, RDF

from light9.vidref.musictime import MusicTime

from light9.effect import effecteval

from light9.effect.settings import DeviceSettings

from light9.effect.simple_outputs import SimpleOutputs

from greplin import scales

import imp

log = logging.getLogger('sequencer')

stats = scales.collection(

    def __init__(self, graph, uri, effectevalModule, simpleOutputs):

        g = self.graph = graph

        self.uri = uri

        self.effectEval = effectevalModule.EffectEval(

            graph, g.value(uri, L9['effectClass']), simpleOutputs)

        for s in g.objects(uri, L9['setting']):

            settingValues = dict(g.predicate_objects(s))

            ea = settingValues[L9['effectAttr']]

            self.baseEffectSettings[ea] = settingValues[L9['value']]

        def floatVal(s, p):

            return float(g.value(s, p).toPython())

        originTime = floatVal(uri, L9['originTime'])

        for curve in g.objects(uri, L9['curve']):

            self.points.extend(

                self.getCurvePoints(curve, L9['strength'], originTime))

        self.points.sort()

        points = []

        po = list(self.graph.predicate_objects(curve))

        if dict(po).get(L9['attr'], None) != attr:

            return []

        for point in [row[1] for row in po if row[0] == L9['point']]:

            po2 = dict(self.graph.predicate_objects(point))

        # in case we got an event at the start of the write

        reactor.callLater(.1, go)

class Sequencer(object):

        self.graph = graph

        self.fps = fps

        self.sendToCollector = sendToCollector

        self.music = MusicTime(period=.2, pollCurvecalc=False)

        self._compileGraphCall = None

        self.simpleOutputs = SimpleOutputs(self.graph)

        self.graph.addHandler(self.compileGraph)

        self.updateLoop()

        self.codeWatcher = CodeWatcher(

            onChange=lambda: self.graph.addHandler(self.compileGraph))

        self.notes[song] = []

        for note in self.graph.objects(song, L9['note']):

            self.notes[song].append(

                Note(self.graph, note, effecteval, self.simpleOutputs))

        log.info('  compile %s took %.2f ms', song, 1000 * (time.time() - t1))

        # print "updateLoop"

        now = time.time()

        self.recentUpdateTimes = self.recentUpdateTimes[-40:] + [now]

        stats.recentFps = len(self.recentUpdateTimes) / (

            self.recentUpdateTimes[-1] - self.recentUpdateTimes[0] + .0001)

        if now > self.lastStatLog + .2:

class Updates(cyclone.sse.SSEHandler):

    def __init__(self, application, request, **kwargs):

        cyclone.sse.SSEHandler.__init__(self, application, request, **kwargs)

        dispatcher.connect(self.updateState, 'state')

        self.numConnected = 0

    def updateState(self, update):

        self.state.update(update)

import numpy

from rdflib import URIRef, Literal

from light9.namespaces import RDF, L9

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 getVal(graph, subj):

    lit = graph.value(subj, L9['value']) or graph.value(subj, L9['scaledValue'])

    ret = lit.toPython()

    if isinstance(ret, decimal.Decimal):

    default values are 0 or '#000000'. Internal rep must not store zeros or some

    comparisons will break.

    """

    def __init__(self, graph, settingsList):

        self.graph = graph  # for looking up all possible attrs

        for row in settingsList:

            self._compiled.setdefault(row[0], {})[row[1]] = row[2]

        # self._compiled may not be final yet- see _fromCompiled

        self._delZeros()

    @classmethod

                v = getVal(g, s)

                settingsList.append((d, da, v))

        return cls(graph, settingsList)

    @classmethod

    def fromVector(cls, graph, vector, deviceAttrFilter=None):

        i = 0

        for (d, a) in cls(graph, [])._vectorKeys(deviceAttrFilter):

            if a == L9['color']:

                v = toHex(vector[i:i + 3])

                i += 3

            else:

        return out

    def devices(self):

        return list(self._compiled.keys())

    def toVector(self, deviceAttrFilter=None):

        for dev, attr in self._vectorKeys(deviceAttrFilter):

            v = self.getValue(dev, attr)

            if attr == L9['color']:

                out.extend(parseHexNorm(v))

            else:

                out.append(v)

import traceback

from light9.namespaces import L9, RDF

from light9.effect.scale import scale

class SimpleOutputs(object):

    def __init__(self, graph):

        self.graph = graph

        # effect : [(dev, attr, value, isScaled)]

        self.graph.addHandler(self.updateEffectsFromGraph)

    def updateEffectsFromGraph(self):

        for effect in self.graph.subjects(RDF.type, L9['Effect']):

            settings = []

from rdflib import Namespace, RDF, RDFS  # noqa

# Namespace was showing up in profiles

class FastNs(object):

    def __init__(self, base):

        self.ns = Namespace(base)

    def __getitem__(self, term):

        if term not in self.cache:

            self.cache[term] = self.ns[term]

        return self.cache[term]

from urllib.parse import urlparse

from .showconfig import getGraph, showUri

from .namespaces import L9

class ServiceAddress(object):

            raise ValueError("no url for %s -> %s -> %s" %

                             (showUri(), L9['networking'], self.service))

        return str(ret)

    @property

    def port(self):

    @property

    def host(self):

    @property

    def url(self):

        return self._url()

    value = url

import sys, traceback, time, logging

log = logging.getLogger()

def run(main, profile=None):

    if not profile:

        main()

    """whenever we hit this line, print a stack trace. event='call'

    for lines that are function definitions, like what a profiler

    gives you.

    Switch to 'line' to match lines inside functions. Execution speed

    will be much slower."""

    def trace(frame, ev, arg):

        if ev == event:

            if (frame.f_code.co_filename, frame.f_lineno) == (filename, lineno):

                stack = ''.join(traceback.format_stack(frame))

                if stack not in seenTraces:

import logging, warnings

from twisted.python.filepath import FilePath

from os import path, getenv

from rdflib import Graph

from .namespaces import L9

log = logging.getLogger('showconfig')

_config = None  # graph

    warnings.warn(

        "code that's using showconfig.getGraph should be "

        "converted to use the sync graph",

        stacklevel=2)

    global _config

    if _config is None:

                root()).globChildren("build/*.n3"):

            graph.parse(location=f.path, format='n3')

        _config = graph

    return _config

    r = getenv("LIGHT9_SHOW")

    if r is None:

        raise OSError(

            "LIGHT9_SHOW env variable has not been set to the show root")

_showUri = None

    """Return the show URI associated with $LIGHT9_SHOW."""

    global _showUri

    if _showUri is None:

    return _showUri

    """given a song URI, where's the on-disk file that mpd would read?"""

    graph = getGraph()

    root = graph.value(showUri(), L9['musicRoot'])

    if not root:

        raise ValueError("%s has no :musicRoot" % showUri())

    name = graph.value(song, L9['songFilename'])

    if not name:

        raise ValueError("Song %r has no :songFilename" % song)

    """

    'http://light9.bigasterisk.com/show/dance2007/song8' -> 'song8'

    everything that uses this should be deprecated for real URIs

    everywhere"""

    assert isinstance(uri, URIRef)

    playList = graph.value(show, L9['playList'])

    if not playList:

        raise ValueError("%r has no l9:playList" % show)

    # The patch in https://github.com/RDFLib/rdflib/issues/305 fixed a

    # serious bug here.

    songs = list(graph.items(playList))

    return songs

def curvesDir():

def subFile(subname):

def subsDir():

from glob import glob

from os.path import join, basename

class TkdndEvent(object):

    """

    see http://www.ellogon.org/petasis/tcltk-projects/tkdnd/tkdnd-man-page

    for details on the fields

class Hover(object):

    def __init__(self, widget, style):

        self.widget, self.style = widget, style

    def set(self, ev):

        for k, v in list(self.style.items()):

            self.oldStyle[k] = self.widget.cget(k)

        self.widget.configure(**self.style)

        return ev.action

#from Tkinter import Button

import logging, time

from rdflib import Literal

from tkinter.tix import Button, Toplevel, Tk, IntVar, Entry, DoubleVar

import tkinter

from light9.namespaces import L9

log = logging.getLogger("toplevel")

windowlocations = {

    'sub': '425x738+00+00',

    'console': '168x24+848+000',

def toplevelat(name, existingtoplevel=None, graph=None, session=None):

    tl = existingtoplevel or Toplevel()

    tl.title(name)

    lastSaved = [None]

    setOnce = [False]

    def setPosFromGraphOnce():

        """

        the graph is probably initially empty, but as soon as it gives

        us one window position, we stop reading them

        """

        if setOnce[0]:

            return

        log.debug("setPosFromGraphOnce %s", geo)

        setOnce[0] = True

        graphSetTime[0] = time.time()

        if geo is not None and geo != lastSaved[0]:

            tl.geometry(geo)

        if graphSetTime[0] == 0 or time.time() < graphSetTime[0] + 3:

            return

        if not setOnce[0]:

            return

        lastSaved[0] = geo

        log.debug("saving position %s", geo)

    if graph is not None and session is not None:

        graph.addHandler(setPosFromGraphOnce)

    if name in windowlocations:

        tl.geometry(positionOnCurrentDesktop(windowlocations[name]))

    """color a label based on its own text"""

    txt = label['text'] or "0"

    lev = float(txt) / 100

    low = (80, 80, 180)

    high = (255, 55, 0o50)

    out = [int(l + lev * (h - l)) for h, l in zip(high, low)]

    label.config(bg=col)

# TODO: get everyone to use this

def colorfade(low, high, percent):

    '''not foolproof.  make sure 0 < percent < 1'''

    out = [int(l + percent * (h - l)) for h, l in zip(high, low)]

    return col

def colortotuple(anytkobj, colorname):

    'pass any tk object and a color name, like "yellow"'

    rgb = anytkobj.winfo_rgb(colorname)

class FancyDoubleVar(DoubleVar):

    def __init__(self, master=None):

        DoubleVar.__init__(self, master)

    def trace_variable(self, mode, callback):

        """Define a trace callback for the variable.

        MODE is one of "r", "w", "u" for read, write, undefine.

        CALLBACK must be a function which is called when

import time, json, logging

from light9 import networking

from twisted.internet import reactor

from cyclone.httpclient import fetch

log = logging.getLogger()

class MusicTime(object):

    """

    fetch times from ascoltami in a background thread; return times

        end of a song)

        """

        self.period = period

        self.hoverPeriod = .05

        self.onChange = onChange

        # driven by our pollCurvecalcTime and also by Gui.incomingTime

        self.lastHoverTime = None  # None means "no recent value"

        self.pollMusicTime()

        if pollCurvecalc:

            self.pollCurvecalcTime()

    def sendTime(self, t):

        """request that the player go to this time"""

        fetch(

            method=b'POST',

            url=networking.musicPlayer.path('time'),

            headers={b"content-type": [b"application/json"]},

        )

/*

*/

function reconnectingWebSocket(url, onMessage) {

    var pong = 0;

    var fullUrl = (

        "ws://"

coverage==4.3.4

ipdb==0.10.2

ipython==5.3.0

mypy==0.701

flake8

git+http://github.com/drewp/scales.git@448d59fb491b7631877528e7695a93553bfaaa93#egg=scales

git+http://github.com/11craft/louie.git@f18bb71010c114eca9c6b88c96453340e3b39454#egg=louie

git+http://github.com/webpy/webpy@ace0f8954c28311004b33c7a513c6e40a3c02470#egg=web

https://github.com/drewp/cyclone/archive/python3.zip#egg=cyclone

    ]

def pkg_sources():

    return glob.glob('light9/**/*.py', recursive=True)

@task

def mypy(ctx):

    def run(sources):

        ss = ' '.join(sources)

                pty=True, warn=True)

    sources = ' '.join(bin_sources + pkg_sources())

    ctx.run(f'env/bin/flake8 --ignore=E115,E123,E124,E126,E225,E231,E261,E262,E265,E301,E302,E303,E305,E306,E401,E402,E501,E701,E731,W291,W293,W391,W504 {sources}', warn=True)