class CSH(coloredlogs.ColoredStreamHandler):

    def render_timestamp(self, created):

        return time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(created)) + (

            "%.3f" % (created % 1)).lstrip('0')

    def render_name(self, name):

        return name

log.addHandler(CSH(show_hostname=False, show_name=True))

        OneLevel widget

          UI edits are caught here and go all the way back to currentSub

"""

from __future__ import division, nested_scopes

import time, logging

from optparse import OptionParser

import logging

import Tkinter as tk

import louie as dispatcher

from twisted.internet import reactor, tksupport, task

from run_local import log

from light9.dmxchanedit import Levelbox

from light9.uihelpers import toplevelat

from light9.rdfdb.syncedgraph import SyncedGraph

from light9.rdfdb import clientsession

from light9.tkdnd import initTkdnd

from light9.namespaces import L9

from light9.observable import Observable

from light9.editchoice import EditChoice, Local

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

    uri and graph storage, but I think that way is making fewer

        self._currentChoice = Observable(Local)

        # this is a PersistentSubmaster (even for local)

        self.currentSub = Observable(Submaster.PersistentSubmaster(

                    graph, self.makeLocal()))

        def pc(val):

            log.info("change viewed sub to %s", val)

        self._currentChoice.subscribe(pc)

        EditChoice(self, self.graph, self._currentChoice).frame.pack(side='top')

        self.setupSubChoiceLinks()

    def setupSubChoiceLinks(self):

        def ann():

            print "currently: session=%s currentSub=%r _currentChoice=%r" % (

                self.session, self.currentSub(), self._currentChoice())

        @graph.addHandler

        def graphChanged():

            s = graph.value(self.session, L9['currentSub'])

            if s is None:

                s = self.makeLocal()

            self.currentSub(Submaster.PersistentSubmaster(graph, s))

        @self.currentSub.subscribe

            if newChoice is not None:

                self.currentSub(Submaster.PersistentSubmaster(

                    graph, newChoice))

    def levelsChanged(self, sub):

        if sub == self.currentSub():

            self.sendupdate()

    def makeLocal(self):

        # todo: put a type on this, so subChanged can identify it right

        # todo: where will these get stored, or are they local to this

        # subcomposer process and don't use PersistentSubmaster at all?

    def setupLevelboxUi(self):

        self.levelbox.pack(side='top')

        tk.Button(self, text="All to zero",

             command=lambda *args: self.currentSub().clear()).pack(side='top')

    def savenewsub(self, subname):

        leveldict={}

        for i,lev in zip(range(len(self.levels)),self.levels):

            if lev!=0:

        s=Submaster.Submaster(subname,leveldict=leveldict)

        s.save()

    def sendupdate(self):

        d = self.currentSub().get_dmx_list()

        dmxclient.outputlevels(d, twisted=True)

def launch(opts, args, root, graph, session):

    if not opts.no_geometry:

        toplevelat("subcomposer - %s" % opts.session, root, graph, session)

    task.LoopingCall(sc.sendupdate).start(10)

#############################

if __name__ == "__main__":

    parser = OptionParser(usage="%prog [suburi]")

    parser.add_option('--no-geometry', action='store_true',

                      help="don't save/restore window geometry")

    clientsession.add_option(parser)

    opts, args = parser.parse_args()

    root=tk.Tk()

    root.config(bg='black')

    root.tk_setPalette("#004633")

    initTkdnd(root.tk, 'tkdnd/trunk/')

    graph = SyncedGraph("subcomposer")

    session = clientsession.getUri('subcomposer', opts)

    graph.initiallySynced.addCallback(lambda _: launch(opts, args, root, graph, session))

    root.protocol('WM_DELETE_WINDOW', reactor.stop)

                                             amount))

        return xfaded_sub

class PersistentSubmaster(Submaster):

    def __init__(self, graph, uri):

        if uri is None:

            raise TypeError("uri must be URIRef")

        self.graph, self.uri = graph, uri

        self.graph.addHandler(self.setName)

        self.graph.addHandler(self.setLevels)

        Submaster.__init__(self, self.name, self.levels)

        self.temporary = False

    def ident(self):

        return self.uri

    def _editedLevels(self):

        self.save()

    def setName(self):

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

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

    def setLevels(self):

        log.info("sub update levels")

        # bug left is that we'll retry too agressively on a file

        # that's being written

        from twisted.internet.inotify import IN_CLOSE_WRITE, IN_MOVED_FROM, IN_MODIFY, IN_DELETE, IN_DELETE_SELF, IN_CHANGED

        notifier.watch(FilePath(path),

                       mask=IN_CLOSE_WRITE | IN_MOVED_FROM | IN_DELETE | IN_DELETE_SELF | IN_CHANGED | 16383,

                       callbacks=[self.notify])

    def notify(self, notifier, filepath, mask):

        maskNames = humanReadableMask(mask)

        if maskNames[0] in ['open', 'access', 'close_nowrite', 'attrib', 'delete_self']:

            return

        try:

            if filepath.getModificationTime() == self.lastWriteTimestamp:

                log.debug("file %s changed, but we did this write", filepath)

                return

        except OSError as e:

            log.error("watched file %s: %r" % (filepath, e))

            return

        log.info("file %s changed (%s)", filepath, maskNames)

        try: