class AllegroTripleStore(SesameTripleStore):
def connect(self, dburi):
host, rest = dburi[7:].split(':', 1)
port, self._name = rest.split('/', 1)
self._url = 'http://%s:%s/sesame' % (host, port)
self._http = httplib2.Http()
params = urlencode({'id': self._name, 'if-exists': 'open'})
try:
resp, content = self._http.request(
'%s/repositories?%s' % (self._url, params), "POST")
except socket.error:
raise ConnectionError(
'Can not connect to repository, is it running?')
if resp['status'] != '204':
raise ConnectionError('Can not connect to server: %s' %
resp['status'])
def _turtle_to_ntriples(self, data):
# Turtle syntax is not supported by allegro graph
# HACK workaround using redland
import RDF
model = RDF.Model()
parser = RDF.TurtleParser()
try:
parser.parse_string_into_model(model, data.read(), '-')
except RDF.RedlandError, err:
raise TripleStoreError(err)
serializer = RDF.Serializer(name='ntriples')
return StringIO(serializer.serialize_model_to_string(model))
def write(self, path, fmt='', base_uri=None):
if fmt == '':
fmt = self._guess_fmt(path)
gzipped_path = None
if self._gzipped(path):
gzipped_path = path
tmp = self._mktemp()
path = tmp
serializer = RDF.Serializer(name=fmt)
for (prefix, uri) in self.namespace_tbl.items():
serializer.set_namespace(prefix, uri)
logger.info('writing to "%s"...' % path)
d = os.path.dirname(path)
if d != '' and not os.path.exists(d):
logger.warning('No such directory: "%s"' % d)
logger.info('creating "%s"...' % d)
os.makedirs(d)
serializer.serialize_model_to_file(path,
self._model,
base_uri=base_uri)
logger.info('done.')
if gzipped_path:
self._gzip(path, gzipped_path)
os.unlink(path)
def _serialize_stream(self, stream, format):
temp = model_from_uri('memory')
temp.add_statements(stream)
serializer = RDF.Serializer(name=format)
for prefix, ns in self._nsmap.items():
serializer.set_namespace(prefix, ns)
return StringIO(serializer.serialize_model_to_string(temp))
def serialize(g):
print >>sys.stderr, 'Serializing ...',
ser = RDF.Serializer(name='rdfxml-abbrev')
for prefix, namespace in rdfob.NAMESPACES.iteritems():
ser.set_namespace(prefix, namespace[''].uri)
s = ser.serialize_model_to_string(g)
print >>sys.stderr, 'done'
return s
def serialize(model, ns, filename, format):
if format is None:
format = "turtle"
serializer = RDF.Serializer(name=format)
for prefix in ns:
serializer.set_namespace(prefix, RDF.Uri(ns[prefix]))
serializer.serialize_model_to_file(filename, model)
def _turtle_to_ntriples(self, data):
# Turtle syntax is not supported by allegro graph
# HACK workaround using redland
import RDF
model = RDF.Model()
parser = RDF.TurtleParser()
try:
parser.parse_string_into_model(model, data.read(), '-')
except RDF.RedlandError as err:
raise TripleStoreError(err)
serializer = RDF.Serializer(name='ntriples')
return StringIO(serializer.serialize_model_to_string(model))
def _rdfxml_to_ntriples(self, data):
# Ntriples syntax is not supported by allegro graph
# as a result format for SPARQL Construct Queries
# HACK workaround using redland
import RDF
model = RDF.Model()
parser = RDF.Parser()
try:
parser.parse_string_into_model(model, data.read(), '-')
except RDF.RedlandError as err:
raise TripleStoreError(err)
serializer = RDF.Serializer(name='ntriples')
return StringIO(serializer.serialize_model_to_string(model))
def updateVoIDFile(to):
"""Updates a VoID file with a new last-modified value.
Note: The filepath of the VoID file is accessed by a global variable.
The resulting VoID file should look something like this:
@prefix void: <http://rdfs.org/ns/void#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix dcterms: <http://purl.org/dc/terms/> .
@prefix d1lod: <http://dataone.org/> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
d1lod:d1lod a void:Dataset ;
void:feature d1lod:fulldump ;
dcterms:modified "2015-11-01";
void:dataDump d1lod:d1lod.ttl .
"""
# Create the VoID RDF Model
m = createVoIDModel(to)
# Verify the size of the model as a check for its successful creation
if m.size() != 4:
logging.error(
"The VoID model that was created was the wronng size (%d, not %d).",
m.size(), 4)
return
# Create a serializer
s = RDF.Serializer(name="turtle")
# Add in namespaces
void = "http://rdfs.org/ns/void#"
d1lod = "http://dataone.org/"
s.set_namespace('rdf', NAMESPACES['rdf'])
s.set_namespace('void', void)
s.set_namespace('dcterms', NAMESPACES['dcterms'])
s.set_namespace('d1lod', d1lod)
# Write to different locations depending on production or testing
try:
if os.path.isfile(VOID_FILEPATH):
s.serialize_model_to_file(VOID_FILEPATH, m)
else:
s.serialize_model_to_file('./void.ttl', m)
except Exception, e:
logging.exception(e)
def voidify(self, serialize_as="ntriples"):
model = self.update_model(RDF.Model())
# serialize to string and return
serializer = RDF.Serializer(name=serialize_as)
if serialize_as == "ntriples":
return serializer.serialize_model_to_string(void_model)
serializer.set_namespace("void", "http://rdfs.org/ns/void#")
serializer.set_namespace(
"rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
serializer.set_namespace("qb", "http://purl.org/linked-data/cube#")
serializer.set_namespace("xstats", "http://example.org/XStats#")
#serializer.set_namespace("thisdataset", dataset_ns._prefix)
return serializer.serialize_model_to_string(void_model)
def _ntriples_to_turtle(self, data):
# Turtle syntax is not supported by allegro graph
# HACK workaround using redland
import RDF
model = RDF.Model()
parser = RDF.Parser('ntriples')
data = data.read()
data = (data.strip() + '\n')
try:
parser.parse_string_into_model(model, data, '-')
except RDF.RedlandError as err:
raise TripleStoreError(err)
serializer = RDF.Serializer(name='turtle')
for prefix, ns in self._nsmap.items():
serializer.set_namespace(prefix, ns)
return StringIO(serializer.serialize_model_to_string(model))
def save(self):
"""
Saves the pass process modell to a file using the given file path. If no file
path is given, an error is thrown.
@return :
@author
"""
if (self._filePath is not None):
#Create the needed datatypes (storage and model) for rdf
storage = RDF.MemoryStorage()
if (storage is None):
raise Exception(
"Failed to create storage for saving the model!")
#The model
model = RDF.Model(storage)
if (model is None):
raise Exception("Failed to creat a new RDF model for saving!")
#Now request all statements from the resources and add them to the model
for resource in self.resources:
for statement in resource.serialize():
model.add_statement(statement)
#Now serialize to file
#Get right type of serializer depending on the ending
fileExtension = os.path.splitext(self._filePath)[-1]
name = None
mimeType = None
if (fileExtension == ".nt"):
name = "ntriples"
else:
#By default use the default serialize
pass
#Now serialize
serializer = RDF.Serializer(name=name, mime_type=mimeType)
serializer.serialize_model_to_file(self.filePath, model)
print(("INFO! Saving model to file \"" + self.filePath +
"\" was successfull!"))
else:
#No file path is currently set
raise Exception(
"Cannot save a file directly that has never been saved before. Use \"saveAs(self, filePath)\" instead "
)
def __init__(self, namespaces={}):
# Initialize variables
name = "db-{0!s}".format(random.randint(1, 999999))
self.db = RDF.Storage(storage_name="hashes",
name=name,
options_string="hash-type='bdb'")
self.model = RDF.Model(self.db)
self.serializer = RDF.Serializer(name="turtle")
self.ns = {}
# Define basic namespaces
basicNamespaces = {
"rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
"xsd": "http://www.w3.org/2001/XMLSchema#",
}
# Extend basic namespaces with those provided in parameters
basicNamespaces.update(namespaces)
self.addNamespaces(basicNamespaces)
atexit.register(self.clearTempFiles)
def export_volume(self, volume_urn, fd):
""" Serialize a suitable properties file for the
volume_urn. We include all the objects which are contained in
the volume.
"""
storage = RDF.Storage(storage_name='hashes',
name='X',
options_string="new='yes',hash-type='memory',dir='.'")
model = RDF.Model(storage)
for urn in aff4.oracle.resolve_list(volume_urn, AFF4_CONTAINS):
try:
urn_id = self.get_id_by_urn(urn)
except ValueError: continue
self.export_model(urn, model)
self.export_model(volume_urn, model)
serializer = RDF.Serializer("turtle")
fd.write(serializer.serialize_model_to_string(model))
def serialize(graph, format='turtle'):
# TODO this is not quite so simple ...
# it would see that we can't just give it a list of statements ...
def r_to_l(element):
if isinstance(element, rdflib.URIRef):
RDF.Uri(element)
elif isinstance(element, rdflib.Literal):
if element.datatype:
kwargs = dict(datatype=RDF.Uri(element.datatype))
else:
kwargs = dict(language=element.language)
RDF.Node(literal=str(element), **kwargs)
elif isinstance(element, rdflib.BNode):
RDF.Node(blank=str(element))
gen = (RDF.Statement(*(r_to_l(e) for e in t)) for t in graph)
stream = Stream(gen)
ser = RDF.Serializer(name=format)
string = ser.serialize_stream_to_string(stream)
return string
def get_serializer(self):
serializer = RDF.Serializer(name=self.serialize_as)
serializer.set_namespace("rdf", self.namespaces.get_namespace('rdf'))
serializer.set_namespace("void", self.namespaces.get_namespace('void'))
serializer.set_namespace("void-ext",
self.namespaces.get_namespace('void_ext'))
serializer.set_namespace("qb", self.namespaces.get_namespace('qb'))
serializer.set_namespace("dcterms",
self.namespaces.get_namespace('dcterms'))
serializer.set_namespace("ls-void",
self.namespaces.get_namespace('ls_void'))
serializer.set_namespace("ls-qb",
self.namespaces.get_namespace('ls_qb'))
serializer.set_namespace("ls-cr",
self.namespaces.get_namespace('ls_cr'))
serializer.set_namespace("xsd", self.namespaces.get_namespace('xsd'))
serializer.set_namespace("xstats",
self.namespaces.get_namespace('stats'))
serializer.set_namespace("foaf", self.namespaces.get_namespace('foaf'))
serializer.set_namespace("rdfs", self.namespaces.get_namespace('rdfs'))
return serializer
import ckan.model as model
import pylons
import RDF
import re
import urllib
root = 'http://localhost:5000/'
path_to_dataset = 'dataset/'
path_to_user = '******'
path_to_subscription = 'subscription/'
serializer = RDF.Serializer(name='ntriples')
def dataset_to_uri(dataset_name):
return root + path_to_dataset + dataset_name
def user_to_uri(user_name):
return root + path_to_user + user_name
def subscription_to_uri(user_name, subscription_name):
return root + path_to_user + user_name + '/' + path_to_subscription + urllib.quote(subscription_name)
def user_id_to_object(user_id):
return model.Session.query(model.User).get(user_id)
serializer = RDF.Serializer(name='ntriples')
return StringIO(serializer.serialize_model_to_string(model))
def _rdfxml_to_ntriples(self, data):
# Ntriples syntax is not supported by allegro graph
# as a result format for SPARQL Construct Queries
# HACK workaround using redland
import RDF
model = RDF.Model()
parser = RDF.Parser()
try:
parser.parse_string_into_model(model, data.read(), '-')
except RDF.RedlandError, err:
raise TripleStoreError(err)
serializer = RDF.Serializer(name='ntriples')
return StringIO(serializer.serialize_model_to_string(model))
def _ntriples_to_turtle(self, data):
# Turtle syntax is not supported by allegro graph
# HACK workaround using redland
import RDF
model = RDF.Model()
parser = RDF.Parser('ntriples')
data = data.read()
data = (data.strip() + '\n')
try:
parser.parse_string_into_model(model, data, '-')
except RDF.RedlandError, err:
raise TripleStoreError(err)
if opt in ("-i", "--input"):
inputPath = arg
elif opt in ("-o", "--output"):
outputUri = arg
elif opt in ("-b", "--baseUri"):
baseUri = arg
elif opt in ("-h", "--help"):
help()
sys.exit(0)
sys.stderr.write("Input: " + inputPath + "\n")
model = RDF.Model()
addFiles(model, baseUri, inputPath)
ttlSerializer = RDF.Serializer(name="turtle")
ttlSerializer.set_namespace("rdfs", "http://www.w3.org/2000/01/rdf-schema#")
ttlSerializer.set_namespace("foaf", "http://xmlns.com/foaf/0.1/")
ttlSerializer.set_namespace("sysont", "http://ns.ontowiki.net/SysOnt/")
ttlSerializer.set_namespace("site", "http://ns.ontowiki.net/SysOnt/Site/")
string = ttlSerializer.serialize_model_to_string(model, baseUri)
if (outputUri):
outFile = open(outputUri, "w")
else:
outFile = sys.stdout
outFile.write(string)
sys.stderr.write("done\n")
count = count + 1
print "Parsing added", count, "statements"
print "Printing all statements"
for s in model.as_stream():
print "Statement:", s
q = RDF.Query(
"PREFIX dc: <http://purl.org/dc/elements/1.1/> SELECT ?a ?c WHERE {?a dc:title ?c}"
)
print "Querying for dc:titles:"
for result in q.execute(model):
print "{"
for k in result:
print " " + k + " = " + str(result[k])
print "}"
print "Writing model to test-out.rdf as rdf/xml"
# Use any rdf/xml parser that is available
serializer = RDF.Serializer()
serializer.set_namespace("dc", RDF.Uri("http://purl.org/dc/elements/1.1/"))
serializer.serialize_model_to_file("test-out.rdf", model)
print "Serialized to ntriples as a string size", len(
model.to_string(name="ntriples",
base_uri="http://example.org/base#")), "bytes"
print "Done"