note = URIRef(note)

        log.info("adding to %s", song)

        note, p = yield songNotePatch(self.settings.graph, dropped, song, event, ctx=song, note=note)

        self.settings.graph.patch(p)

        self.write(json.dumps({'note': note}))

class SongEffectsUpdates(cyclone.websocket.WebSocketHandler):

    def connectionMade(self, *args, **kwargs):

        self.graph = self.settings.graph

        self.graph.addHandler(self.updateClient)

class WatchedFiles(object):

    """

    find files, notice new files.

    This object watches directories. Each GraphFile watches its own file.

    """

        self.dirUriMap = dirUriMap # {abspath : uri prefix}

        self.patch, self.getSubgraph = patch, getSubgraph

        self.addlPrefixes = addlPrefixes

        self.graphFiles = {} # context uri : GraphFile

        # read into one file called config.n3. New versions won't read

        # it.

        if inFile.endswith("config.n3"):

            return

        ctx = uriFromFile(self.dirUriMap, inFile)

        log.info("%s do initial read", inFile)

        gf.reread()

    def aboutToPatch(self, ctx):

        """

        warn us that a patch is about to come to this context. it's more

        g = self.getSubgraph(ctx)

        if ctx not in self.graphFiles:

            outFile = fileForUri(self.dirUriMap, ctx)

            assert '//' not in outFile, (outFile, self.dirUriMap, ctx)

            log.info("starting new file %r", outFile)

    def dirtyFiles(self, ctxs):

        """mark dirty the files that we watch in these contexts.

        the ctx might not be a file that we already read; it might be

        for a new file we have to create, or it might be for a

        transient context that we're not going to save

class Db(object):

    """

    the master graph, all the connected clients, all the files we're watching

    """

        self.clients = []

        self.graph = ConjunctiveGraph()

        self.watchedFiles = WatchedFiles(dirUriMap,

        self.summarizeToLog()

    def patch(self, p, dueToFileChange=False):

        """

        apply this patch to the master graph then notify everyone about it

            self.settings.db.addClient(Client(upd, self.get_argument("label")))

        except:

            import traceback

            traceback.print_exc()

            raise

_wsClientSerial = 0

class WebsocketClient(cyclone.websocket.WebSocketHandler):

    def connectionMade(self, *args, **kwargs):

        global _wsClientSerial

        connectionId = 'connection-%s' % _wsClientSerial

    # .html pages can be get() without .html on them

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

        if path and '.' not in path:

            path = path + ".html"

        cyclone.web.StaticFileHandler.get(self, path, *args, **kw)

if __name__ == "__main__":

    logging.basicConfig()

    log = logging.getLogger()

    parser = optparse.OptionParser()

    parser.add_option("-v", "--verbose", action="store_true",

    (options, args) = parser.parse_args()

    log.setLevel(logging.DEBUG if options.verbose else logging.INFO)

    db = Db(dirUriMap={os.environ['LIGHT9_SHOW'].rstrip('/') + '/':

                       showconfig.showUri() + '/'},

    from twisted.python import log as twlog

    twlog.startLogging(sys.stdout)

    reactor.listenTCP(networking.rdfdb.port, cyclone.web.Application(handlers=[

        (r'/live', Live),

        (r'/graph', GraphResource),

        (r'/patches', Patches),

        (r'/graphClients', GraphClients),

        (r'/syncedGraph', WebsocketClient),

        (r'/(.*)', NoExts,

         {"path" : "light9/rdfdb/web",

          "default_filename" : "index.html"}),

        ], debug=True, db=db))

        settingsSubgraphCache=settingsSubgraphCache)))

    graph.patch(Patch(addQuads=[

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

        (uri, RDF.type, L9['LightSample'], ctx),

        (uri, L9['imagePath'], URIRef('/'.join([showconfig.showUri(), relOutPath])), ctx),

        ]))

class CaptureLoader(object):

    def __init__(self, graph):

        self.graph = graph

    def loadImage(self, pic, thumb=(100, 100)):

from light9.rdfdb.patch import Patch

from light9.rdfdb.rdflibpatch import inContext

log = logging.getLogger('graphfile')

iolog = logging.getLogger('io')

    # todo: make a n3serializer subclass with whitespace settings

    from rdflib.plugins.serializers.turtle import TurtleSerializer, OBJECT

    originalWrite = TurtleSerializer.write

    def write(self, s):

        lines = s.split('\n')

        if len(lines) > 1:

            return

        self.verb(propList[0], newline=newline)

        self.objectList(properties[propList[0]])

        for predicate in propList[1:]:

            self.write(';')

            # can't do proper wrapping since we don't know how much is coming

                self.write('\n' + self.indent(1))

            self.verb(predicate, newline=False)

            self.objectList(properties[predicate])

    def objectList(self, objects):

        count = len(objects)

        if count == 0:

patchN3SerializerToUseLessWhitespace()

class GraphFile(object):

    """

    one rdf file that we read from, write to, and notice external changes to

    """

        """

        uri is the context for the triples in this file. We assume

        sometimes that we're the only ones with triples in this

        context.

        this does not include an initial reread() call

        """

        self.path, self.uri = path, uri

        self.patch, self.getSubgraph = patch, getSubgraph

        self.lastWriteTimestamp = 0 # mtime from the last time _we_ wrote

        if not os.path.exists(path):

            # can't start notify until file exists

            try:

                os.makedirs(os.path.dirname(path))

            except OSError:

                # patch our graph as if it had just been cleared. We

                # shouldn't even be here reading this, but

                # lastWriteTimestamp didn't work.

                return

            new.parse(location=self.path, format='n3')

        except SyntaxError as e:

            print e

            traceback.print_exc()

            log.error("%s syntax error", self.path)

            # todo: likely bug- if a file has this error upon first

            # read, I think we don't retry it right.

    def flush(self):

        self.writeCall = None

        tmpOut = self.path + ".rdfdb-temp"

        f = open(tmpOut, 'w')

        t1 = time.time()

            self.graphToWrite.bind(p, n)

        self.graphToWrite.serialize(destination=f, format='n3')

        serializeTime = time.time() - t1

        f.close()

        self.lastWriteTimestamp = os.path.getmtime(tmpOut)

        os.rename(tmpOut, self.path)

PatchSender - collects and transmits your graph edits

"""

from rdflib import ConjunctiveGraph

import logging, cyclone.httpclient, traceback

from twisted.internet import defer

log = logging.getLogger('syncedgraph')

from light9.rdfdb.rdflibpatch import patchQuads

from light9.rdfdb.patchsender import PatchSender

from light9.rdfdb.patchreceiver import PatchReceiver

from light9.rdfdb.currentstategraphapi import CurrentStateGraphApi

        log.debug('runDepsOnNewPatch')

        self.runDepsOnNewPatch(p)

        log.debug('sendPatch')

        self._sender.sendPatch(p).addErrback(self.sendFailed)

        log.debug('patch is done %s', debugKey)

    def sendFailed(self, result):

        """

        we asked for a patch to be queued and sent to the master, and

        that ultimately failed because of a conflict

        """