class Submaster:

    "Contain a dictionary of levels, but you didn't need to know that"

        self.name = name

        if leveldict:

            self.levels = leveldict

        else:

            self.levels = {}

            self.reload()

    def reload(self):

        try:

            self.levels.clear()

            subfile = file("subs/%s" % self.name)

        except IOError:

            print "Can't read file for sub: %s" % self.name

    def save(self):

        subfile = file("subs/%s" % self.name, 'w')

        names = self.levels.keys()

        names.sort()

        return self.levels

    def __mul__(self, scalar):

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

    __rmul__ = __mul__

    def max(self, *othersubs):

        return sub_maxes(self, *othersubs)

    def __repr__(self):

    def get_dmx_list(self):

        leveldict = self.get_levels() # gets levels of sub contents

        levels = [0] * 68

        for k, v in leveldict.items():

        return levels

def sub_maxes(*subs):

    return Submaster("max(%r)" % (subs,),

class Submasters:

    "Collection o' Submaster objects"

        files = os.listdir('subs')

        for filename in files:

                continue

            self.submasters[filename] = Submaster(filename)

    def get_all_subs(self):

        "All Submaster objects"

    def get_sub_by_name(self, name):

        "Makes a new sub if there isn't one."

        return self.submasters.get(name, Submaster(name))

if __name__ == "__main__":

    Patch.reload_data()

    s = Submasters()

    print s.get_all_subs()

from Timeline import *

from Submaster import Submasters, sub_maxes

        "set time of current timeline"

        self.current_time = time

        self.current_timeline.set_time(time)

# this is the default blender

linear = LinearBlender()

FORWARD = 1

BACKWARD = -1

class TimedEvent:

    """Container for a Frame which includes a time that it occurs at,

    and which blender occurs after it."""

        make_attributes_from_args('time', 'frame')

        self.next_blender = blender

        self.level = level

    def __float__(self):

        return self.time

    def __cmp__(self, other):

        if type(other) in (float, int):

            return cmp(self.time, other)

        else:

    """Blenders are functions that merge the effects of two LevelFrames."""

    def __init__(self):

        pass

        """Return a LevelFrame combining two LevelFrames (startframe and 

        endframe).  blendtime is how much of the blend should be performed

        and will be expressed as a percentage divided by 100, i.e. a float

        Very important note: Blenders will *not* be asked for values

        at end points (i.e. blendtime=0.0 and blendtime=1.0).

        0.25 * endframe.  This function is included since many blenders are

        just functions on the percentage and still combine start and end frames

        in this way."""

        if startframe.frame == endframe.frame:

        else:

            levels = {startframe.frame : (1.0 - blendtime) * startframe.level,

                endframe.frame : blendtime * endframe.level}

        return levels

class InstantEnd(Blender):

    """Instant change from startframe to endframe at the end.  In other words,

    the value returned will be the startframe all the way until the very end

    of the blend."""

        # "What!?" you say, "Why don't you care about blendtime?"

        # This is because Blenders never be asked for blenders at the endpoints

        # (after all, they wouldn't be blenders if they were). Please see

    """Instant change from startframe to endframe at the beginning.  In other

    words, the value returned will be the startframe at the very beginning

    and then be endframe at all times afterwards."""

        # "What!?" you say, "Why don't you care about blendtime?"

        # This is because Blenders never be asked for blenders at the endpoints

        # (after all, they wouldn't be blenders if they were). Please see

class LinearBlender(Blender):

    """Linear fade from one frame to another"""

        return self.linear_blend(startframe, endframe, blendtime)

class ExponentialBlender(Blender):

    as LinearBlender."""

    def __init__(self, exponent):

        self.exponent = exponent

        blendtime = blendtime ** self.exponent

        return self.linear_blend(startframe, endframe, blendtime)

class SmoothBlender(Blender):

    """Drew's "Smoove" Blender function.  Hopefully he'll document and

    parametrize it."""

        blendtime = (-1 * blendtime) * blendtime * (blendtime - 1.5) * 2

        return self.linear_blend(startframe, endframe, blendtime)

class TimelineTrack:

    """TimelineTrack is a single track in a Timeline.  It consists of a

    list of TimedEvents and a name.  Length is automatically the location

    of the last TimedEvent.  To extend the Timeline past that, add an

    EmptyTimedEvent (which doesn't exist :-/)."""

        self.name = name

        self.events = list(timedevents)

        self.events.sort()

    def __str__(self):

        return "<TimelineTrack with events: %r>" % self.events

    def has_events(self):

            percent = elapsed / diff

            if not before.next_blender:

                raise MissingBlender, before

class Timeline:

        """

        Most/all of this is old:

        is bounded by their last frame.  You can put an EmptyFrame at

        some time if you want to extend a Timeline."""

        self.current_time = 0

        self.last_clock_time = None

        self.stopped = 1

        T(18, 'blue', level=1.0),

        T(20, 'blue', level=0.0))

    tl.play()

import sys, time, socket

sys.path.append("../light8")

import Patch, Timeline, dmxclient, xmlrpclib

import TheShow

Patch.reload_data()

        self.show = show

        self.find_player()

    def find_player(self):

        self.player = xmlrpclib.Server("http://localhost:8040")

    def send_levels(self):

        levels = self.show.calc_active_submaster().get_dmx_list()

        dmxclient.outputlevels(levels)

                self.sync_times()

                self.send_levels()

                time.sleep(0.01)

        except KeyboardInterrupt:

            sys.exit(0)

if __name__ == "__main__":

    s.show.set_timeline('strobe test')

    s.mainloop()