def sparql_queryString(source, queryString):
from query import applySparqlQueries
store = source.store
ns = store.newSymbol(SPARQL_NS)
from sparql import sparql_parser
import sparql2cwm
convertor = sparql2cwm.FromSparql(store)
import StringIO
p = sparql_parser.N3Parser(StringIO.StringIO(queryString), sparql_parser.branches, convertor)
q = p.parse(sparql_parser.start).close()
F = store.newFormula()
applySparqlQueries(source, q, F)
F = F.close()
## print 'result is ', F
## print 'query is ', q.n3String()
return outputString(q, F)
return null, predict
except ImportError:
p = get_productions(uri)
f = find_nulls(p)
predict = find_null_connected(p, f)
out = file('earley_tables.py', 'w')
make_table(out, f, predict)
return f, predict
if __name__ == '__main__':
f, predict = cache_get(sys.argv[1])
## for m in sorted(predict.items()):
## print '\t%s: %s\n' % m
## sys.exit(0)
print 'ready to lex'
results, t1, k2 = parse(sys.argv[3], sys.argv[2], predict, f)
t2 = time.time() - k2
#print '\n\n\t'.join([`a` for a in results])
import sparql2cwm, myStore, notation3
_outSink = notation3.ToN3(sys.stdout.write, quiet=1, flags='')
for a in results:
sink = sparql2cwm.FromSparql(myStore._checkStore(), ve=1)
f = AST((sys.argv[2], ) + a[3], sink).run().close()
myStore._checkStore().dumpNested(f, _outSink)
print t1, t2, t1 + t2
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