root + 'env/lib/python3.7/lib-dynload',

        '/usr/lib/python3/dist-packages/',

        '/usr/lib/python3.7',

        root + 'env/lib/python3.7/site-packages',

    ]

import random as random_mod

import math

import logging, colorsys

from time import time, sleep

class Mass:

    def __init__(self):

import os, logging, time

from rdflib import Graph, RDF

from rdflib import RDFS, Literal, BNode

from .rdfdb.patch import Patch

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.

    def __mul__(self, scalar):

        return Submaster("%s*%s" % (self.name, scalar),

                         levels=dict_scale(self.levels, scalar))

    __rmul__ = __mul__

    def max(self, *othersubs):

        return sub_maxes(self, *othersubs)

        return hash(self.ident())

    def get_dmx_list(self):

        levels = []

        for k, v in list(leveldict.items()):

            try:

                dmxchan = get_dmx_channel(k) - 1

            except ValueError:

                raise

            if dmxchan >= len(levels):

                levels.extend([0] * (dmxchan - len(levels) + 1))

        xfaded_sub = Submaster("xfade", {})

        for k in all_keys:

        return xfaded_sub

class PersistentSubmaster(Submaster):

    def __init__(self, graph, uri):

        if uri is None:

            raise TypeError("uri must be URIRef")

    def changeName(self, newName):

        self.graph.patchObject(self.uri, self.uri, RDFS.label, Literal(newName))

    def setName(self):

        log.info("sub update name %s %s", self.uri, self.graph.label(self.uri))

        self.name = self.graph.label(self.uri)

        typeStmt = (self.uri, RDF.type, L9['Submaster'])

        with self.graph.currentState(tripleFilter=typeStmt) as current:

            try:

                ctx = current.contextsForStatement(typeStmt)[0]

            except IndexError:

                log.info("declaring %s to be a submaster" % self.uri)

                ctx = self.uri

                    ]))

        return ctx

    def editLevel(self, chan, newLevel):

        self.graph.patchMapping(self._saveContext(),

                                nodeClass=L9['ChannelSetting'],

                                valuePred=L9['level'],

                                newValue=Literal(newLevel))

        quads = []

        with self.graph.currentState() as current:

            quads.extend(current.quads((self.uri, None, None)))

                if p == L9['lightLevel']:

                    quads.extend(current.quads((o, None, None)))

        return quads

    def save(self):

        raise NotImplementedError("obsolete?")

        if self.temporary:

            return

        graph = Graph()

    level = start + (amount * (end - start))

    return level

def sub_maxes(*subs):

    nonzero_subs = [s for s in subs if not s.no_nonzero()]

    name = "max(%s)" % ", ".join([repr(s) for s in nonzero_subs])

    return Submaster(name,

                     levels=dict_max(*[sub.levels for sub in nonzero_subs]))

def combine_subdict(subdict, name=None, permanent=False):

    """A subdict is { Submaster objects : levels }.  We combine all

    submasters first by multiplying the submasters by their corresponding

    return maxes

class Submasters(object):

    "Collection o' Submaster objects"

    def __init__(self, graph):

        self.graph = graph

        graph.addHandler(self.findSubs)

    def get_sub_by_name(self, name):

        return get_sub_by_name(name, self)

# a global instance of Submasters, created on demand

_submasters = None

def get_global_submasters(graph):

    """

    Get (and make on demand) the global instance of

        _submasters = Submasters(graph)

    return _submasters

def get_sub_by_name(name, submasters=None):

    """name is a channel or sub nama, submasters is a Submasters object.

    If you leave submasters empty, it will use the global instance of

    try:

        val = int(name)

        return s

    except ValueError:

        pass

    try:

        subnum = get_dmx_channel(name)

        return s

    except ValueError:

        pass

"""Collected utility functions, many are taken from Drew's utils.py in

Cuisine CVS and Hiss's Utility.py."""

import sys

__author__ = "David McClosky <dmcc@bigasterisk.com>, " + \

             "Drew Perttula <drewp@bigasterisk.com>"

__cvsid__ = "$Id: TLUtility.py,v 1.1 2003/05/25 08:25:35 dmcc Exp $"

def make_attributes_from_args(*argnames):

    """

            self.baz=baz

            ... 

    """

    for a in argnames:

        try:

        except KeyError:

            raise KeyError("Function has no argument '%s'" % a)

def enumerate(*collections):

    """Generates an indexed series:  (0,coll[0]), (1,coll[1]) ...

    i = 0

    iters = [iter(collection) for collection in collections]

    while True:

        i += 1

def dumpobj(o):

    """Prints all the object's non-callable attributes"""

    print(repr(o))

            pass

    print("")

def dict_filter_update(d, **newitems):

    """Adds a set of new keys and values to dictionary 'd' if the values are

    true:

    for k, v in list(newitems.items()):

        if v: d[k] = v

def try_get_logger(channel):

    """Tries to get a logger with the channel 'channel'.  Will return a

    silent DummyClass if logging is not available."""

        log = DummyClass()

    return log

class DummyClass:

    """A class that can be instantiated but never used.  It is intended to

    be replaced when information is available.

      File "Utility.py", line 33, in __getattr__

        raise AttributeError, "Attempted usage of a DummyClass: %s" % key

    AttributeError: Attempted usage of a DummyClass: somefunction"""

    def __init__(self, use_warnings=1, raise_exceptions=0, **kw):

        """Constructs a DummyClass"""

        make_attributes_from_args('use_warnings', 'raise_exceptions')

    def __getattr__(self, key):

        """Raises an exception to warn the user that a Dummy is not being

        replaced in time."""

        if self.raise_exceptions:

            raise AttributeError(msg)

        return lambda *args, **kw: self.bogus_function()

    def bogus_function(self):

        pass

class ClassyDict(dict):

    """A dict that accepts attribute-style access as well (for keys

    that are legal names, obviously). I used to call this Struct, but

    chose the more colorful name to avoid confusion with the struct

    module."""

    def __getattr__(self, a):

        return self[a]

    def __setattr__(self, a, v):

        self[a] = v

    def __delattr__(self, a):

        del self[a]

def trace(func):

    """Good old fashioned Lisp-style tracing.  Example usage:

          indent for recursive call like the lisp version (possible use of 

              generators?)"""

    name = func.__name__

    def tracer(*args, **kw):

        s = '|>> %s called' % name

        if args:

        ret = func(*args, **kw)

        print('<<| %s returned %s' % (name, ret))

        return ret

    return tracer

# these functions taken from old light8 code

def dict_max(*dicts):

    """

    """

    newdict = {}

    for d in dicts:

            newdict[k] = max(v, newdict.get(k, 0))

    return newdict

    """scales all values in dict and returns a new dict"""

def dict_subset(d, dkeys, default=0):

    """Subset of dictionary d: only the keys in dkeys.  If you plan on omitting

    keys, make sure you like the default."""

    for k in dkeys:

        newd[k] = d.get(k, default)

    return newd

# functions specific to Timeline

# TBD

def last_less_than(array, x):

            return best

    return best

# TBD

def first_greater_than(array, x):

    """array must be sorted"""

        elif best is not None:

            return best

    return best

def chase(t,

          ontime=0.5,

          offset=0.2,

from .namespaces import MUS, L9

log = logging.getLogger('showconfig')

def getGraph():

    global _config

    if _config is None:

        graph = Graph()

        # note that logging is probably not configured the first time

        # we're in here

        warnings.warn("reading n3 files around %r" % root())

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

        _config = graph

    return _config

def root():

    r = getenv("LIGHT9_SHOW")

    if r is None:

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

    return r

_showUri = None

def showUri():

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

    global _showUri

        _showUri = URIRef(open(path.join(root(), 'URI')).read().strip())

    return _showUri

def songOnDisk(song):

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

    graph = getGraph()

    return path.abspath(path.join(root, name))

def songFilenameFromURI(uri):

    """

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

    assert isinstance(uri, URIRef)

    return uri.split('/')[-1]

def getSongsFromShow(graph, show):

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

    if not playList:

    return songs

def curvesDir():

def subFile(subname):

def subsDir():

import logging

log = logging.getLogger()

class SubClient:

    def __init__(self):

        """assumed that your init saves self.graph"""

    def get_levels_as_sub(self):

        """Subclasses must implement this method and return a Submaster

    def send_levels_loop(self, delay=1000):

        now = time.time()

        def done(sec):

                              self.send_levels_loop)

        def err(e):

            log.warn('subclient loop: %r', e)

            reactor.callLater(2, self.send_levels_loop)

        d = self._send_sub()

        d.addCallbacks(done, err)

    def _send_sub(self):

        try:

            with self.graph.currentState() as g:

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

    unnecessarily change their types later.

    """

    substitutions = {

    @classmethod

    def makeEvent(cls, *args):

    def __repr__(self):

        return "<TkdndEvent %r>" % self.__dict__

class Hover(object):

    def __init__(self, widget, style):

        self.widget, self.style = widget, style

        self.oldStyle = {}

    def restore(self, ev):

        self.widget.configure(**self.oldStyle)

def initTkdnd(tk, tkdndBuildDir):

    """

    pass the 'tk' attribute of any Tkinter object, and the top dir of

    your built tkdnd package

    """

    tk.call('source', join(tkdndBuildDir, 'library/tkdnd.tcl'))

    """

    if the 'data' param is callable, it will be called every time to

    look up the current data.

            return

        return (action, datatype, dataValue)

    widget.bind("<<DragInitCmd>>", funcId)

    """

    the optional callbacks will be called with a TkdndEvent

    argument.

    if hoverStyle is not None:

        hover = Hover(widget, hoverStyle)

        def wrappedDrop(ev):

            hover.restore(ev)

            if onDrop:

                return onDrop(ev)

                                  onDropEnter=hover.set,

                                  onDropLeave=hover.restore,

                                  onDropPosition=onDropPosition,

    if typeList is None:

        typeList = ['*']

    for sequence, handler in [

        ('<<DropEnter>>', onDropEnter),

        ('<<DropPosition>>', onDropPosition),

        ('<<DropLeave>>', onDropLeave),

        ('<<Drop>>', onDrop),

        if not handler:

            continue

        widget.bind(sequence, func + " " + TkdndEvent.tclSubstitutions)

"""all the tiny tk helper functions"""

#from Tkinter import Button

import logging, time

from rdflib import Literal

log = logging.getLogger("toplevel")

windowlocations = {

}

    root.bind(key, func)

    for w in root.winfo_children():

        w.bind(key, func)

    try:

        geo = tl.geometry()

        if not geo.startswith("1x1"):

            f.write(tl.geometry())

        # else the window never got mapped

    except Exception as e:

        # it's ok if there's no saved geometry

        pass

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

    tl = existingtoplevel or Toplevel()

    tl.title(name)

    lastSaved = [None]

    setOnce = [False]

    graphSetTime = [0]

    def setPosFromGraphOnce():

        """

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

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

    if graph is not None:

    return tl

def positionOnCurrentDesktop(xform, screenWidth=1920, screenHeight=1440):

    size, x, y = xform.split('+')

    x = int(x) % screenWidth

    else:

        s.set(0)

# for lambda callbacks

def printout(t):

    print('printout', t)

def printevent(ev):

    for k in dir(ev):

        if not k.startswith('__'):

    "passes an event to the parent, screws up TixComboBoxes"

    wid_class = str(ev.widget.__class__)

    if wid_class == 'Tix.ComboBox' or wid_class == 'Tix.TixSubWidget':

        return

    for x in ['state', 'time', 'y', 'x', 'serial']:

#    evdict['button']=ev.num

    #else the event made it all the way to the top, unhandled

def colorlabel(label):

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

    label.config(bg=col)

# TODO: get everyone to use this

def colorfade(low, high, percent):

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

    return col

def colortotuple(anytkobj, colorname):

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

    rgb = anytkobj.winfo_rgb(colorname)

    return [v / 256 for v in rgb]

class Togglebutton(Button):

    """works like a single radiobutton, but it's a button so the

    label's on the button face, not to the side. the optional command

    callback is called on button set, not on unset. takes a variable

    just like a checkbutton"""

        self.oldcommand = command

        self._origbkg = self.cget('bg')

        self.downcolor = downcolor

        self._variable = variable

        if self._variable: