def _s2f(s, base): """make a formula from a string. Cribbed from llyn.BI_parsedAsN3 should be part of the myStore API, no? yes. TODO >>> _s2f("<#sky> <#color> <#blue>.", "http://example/socrates") {sky color blue} ^ that test output depends on the way formulas print themselves. """ # """ emacs python mode needs help import notation3 graph = formula() graph.setClosureMode("e") # Implement sameAs by smushing p = notation3.SinkParser(graph.store, openFormula=graph, baseURI=base, thisDoc="data:@@some-formula-string") p.startDoc() p.feed(s) f = p.endDoc() f.close() bindings = {} for s in f.statementsMatching(pred=reason.representedBy): val, _, key = s.spo() bindings[key] = val return f.substitution(bindings)
def getParser(format, inputURI, workingContext, flags): """Return something which can load from a URI in the given format, while writing to the given store. """ r = BecauseOfCommandLine( sys.argv[0]) # @@ add user, host, pid, date time? Privacy! if format == "rdf": touch(_store) if "l" in flags["rdf"]: from rdflib2rdf import RDFXMLParser else: rdfParserName = os.environ.get("CWM_RDF_PARSER", "sax2rdf") if rdfParserName == "rdflib2rdf": from rdflib2rdf import RDFXMLParser elif rdfParserName == "sax2rdf": from sax2rdf import RDFXMLParser else: raise RuntimeError("Unknown RDF parser: " + rdfParserName) return RDFXMLParser(_store, workingContext, inputURI, flags=flags[format], why=r) elif format == "n3": touch(_store) return notation3.SinkParser(_store, openFormula=workingContext, thisDoc=inputURI, why=r) else: need(lxkb) touch(lxkb) return LX.language.getParser(language=format, sink=lxkb, flags=flags)
def parse(self, stream, host=None): # # make a new SinkParser each time, because it seems # to want to know thisDoc at creation time.... # # @@ what is the difference between SinkParser.thisDoc and # SinkParser.baseURI? # # host is not used yet # uri = stream.info().uri print "Using sink", self.sink self.sink.dumpPrefixes(sys.stdout) p = notation3.SinkParser(self.sink, uri) result = p.loadStream(stream) self.sink.top = result # possible approach.... We need
def load(store, uri=None, openFormula=None, asIfFrom=None, contentType=None, flags="", referer=None, why=None, topLevel=False): """Get and parse document. Guesses format if necessary. uri: if None, load from standard input. remember: if 1, store as metadata the relationship between this URI and this formula. Returns: top-level formula of the parsed document. Raises: IOError, SyntaxError, DocumentError This is an independent function, as it is fairly independent of the store. However, it is natural to call it as a method on the store. And a proliferation of APIs confuses. """ # if referer is None: # raise RuntimeError("We are trying to force things to include a referer header") try: baseURI = uripath.base() if uri != None: addr = uripath.join(baseURI, uri) # Make abs from relative if diag.chatty_flag > 40: progress("Taking input from " + addr) netStream = urlopenForRDF(addr, referer) if diag.chatty_flag > 60: progress(" Headers for %s: %s\n" % (addr, netStream.headers.items())) receivedContentType = netStream.headers.get( HTTP_Content_Type, None) else: if diag.chatty_flag > 40: progress("Taking input from standard input") addr = uripath.join(baseURI, "STDIN") # Make abs from relative netStream = sys.stdin receivedContentType = None # if diag.chatty_flag > 19: progress("HTTP Headers:" +`netStream.headers`) # @@How to get at all headers?? # @@ Get sensible net errors and produce dignostics guess = None if receivedContentType: if diag.chatty_flag > 9: progress("Recieved Content-type: " + ` receivedContentType ` + " for " + addr) if receivedContentType.find('xml') >= 0 or ( receivedContentType.find('rdf') >= 0 and not (receivedContentType.find('n3') >= 0)): guess = "application/rdf+xml" elif receivedContentType.find('n3') >= 0: guess = "text/rdf+n3" if guess == None and contentType: if diag.chatty_flag > 9: progress("Given Content-type: " + ` contentType ` + " for " + addr) if contentType.find('xml') >= 0 or ( contentType.find('rdf') >= 0 and not (contentType.find('n3') >= 0)): guess = "application/rdf+xml" elif contentType.find('n3') >= 0: guess = "text/rdf+n3" elif contentType.find('sparql') >= 0 or contentType.find('rq'): guess = "x-application/sparql" buffer = netStream.read() if guess == None: # can't be XML if it starts with these... if buffer[0:1] == "#" or buffer[0:7] == "@prefix": guess = 'text/rdf+n3' elif buffer[0:6] == 'PREFIX' or buffer[0:4] == 'BASE': guess = "x-application/sparql" elif buffer.find('xmlns="') >= 0 or buffer.find('xmlns:') >= 0: #" guess = 'application/rdf+xml' else: guess = 'text/rdf+n3' if diag.chatty_flag > 9: progress("Guessed ContentType:" + guess) except (IOError, OSError): raise DocumentAccessError(addr, sys.exc_info()) if asIfFrom == None: asIfFrom = addr if openFormula != None: F = openFormula else: F = store.newFormula() if topLevel: newTopLevelFormula(F) import os if guess == "x-application/sparql": if diag.chatty_flag > 49: progress("Parsing as SPARQL") from sparql import sparql_parser import sparql2cwm convertor = sparql2cwm.FromSparql(store, F, why=why) import StringIO p = sparql_parser.N3Parser(StringIO.StringIO(buffer), sparql_parser.branches, convertor) F = p.parse(sparql_parser.start).close() elif guess == 'application/rdf+xml': if diag.chatty_flag > 49: progress("Parsing as RDF") # import sax2rdf, xml.sax._exceptions # p = sax2rdf.RDFXMLParser(store, F, thisDoc=asIfFrom, flags=flags) if flags == 'rdflib' or int(os.environ.get("CWM_RDFLIB", 0)): parser = 'rdflib' flags = '' else: parser = os.environ.get("CWM_RDF_PARSER", "sax2rdf") import rdfxml p = rdfxml.rdfxmlparser(store, F, thisDoc=asIfFrom, flags=flags, parser=parser, why=why) p.feed(buffer) F = p.close() else: assert guess == 'text/rdf+n3' if diag.chatty_flag > 49: progress("Parsing as N3") if os.environ.get("CWM_N3_PARSER", 0) == 'n3p': import n3p_tm import triple_maker tm = triple_maker.TripleMaker(formula=F, store=store) p = n3p_tm.n3p_tm(asIfFrom, tm) else: p = notation3.SinkParser(store, F, thisDoc=asIfFrom, flags=flags, why=why) try: p.startDoc() p.feed(buffer) p.endDoc() except: progress("Failed to parse %s" % uri or buffer) raise if not openFormula: F = F.close() return F