class WriterPlugin(RDFWriter):
def __init__(self, reader, *args, **kwargs):
RDFWriter.__init__(self, reader, *args, **kwargs)
if isinstance(self.reader, ReaderPlugin):
self.__server = self.reader.server
self.__port = self.reader.port
self.__catalog = self.reader.catalog
self.__repository = self.reader.repository
self.__allegro_server = self.reader.allegro_server
self.__allegro_catalog = self.reader.allegro_catalog
self.__allegro_repository = self.reader.allegro_repository
if type(self.__repository) == list and len(self.__repository) > 1:
connections_to_federate = []
repositories_to_federate = []
for one_repository in self.reader.allegro_repository:
repositories_to_federate.append(self.__allegro_catalog
.getRepository(one_repository, Repository.ACCESS))
connections_to_federate.append(self.__allegro_catalog
.getRepository(one_repository, Repository.ACCESS)
.initialize().getConnection())
self.__allegro_repository = repositories_to_federate
self.__con = self.__allegro_server.openFederated(connections_to_federate, True)
else:
if type(self.__repository) == list and len(self.__repository) == 1:
self.__repository = self.__repository[0]
self.__allegro_repository = self.__allegro_catalog.getRepository(self.__repository, Repository.ACCESS)
self.__allegro_repository.initialize()
self.__con = self.allegro_repository.getConnection()
else:
self.__server = kwargs['server'] if 'server' in kwargs else 'localhost'
self.__port = kwargs['port'] if 'port' in kwargs else 6789
self.__catalog = kwargs['catalog'] if 'catalog' in kwargs else None
self.__repository = kwargs['repository'] if 'repository' in kwargs else None
if not self.__catalog or not self.__repository:
raise Exception('Must specify the <catalog> and the <repository> arguments')
self.__allegro_server = AllegroGraphServer(self.__server, port = self.__port)
self.__allegro_catalog = self.__allegro_server.openCatalog(self.__catalog)
if type(self.__repository) == list and len(self.__repository) > 1:
connections_to_federate = []
repositories_to_federate = []
for repository in self.__repository:
repositories_to_federate.append(self.__allegro_catalog
.getRepository(repository, Repository.ACCESS))
connections_to_federate.append(self.__allegro_catalog
.getRepository(repository, Repository.ACCESS)
.initialize().getConnection())
self.__allegro_repository = repositories_to_federate
self.__con = self.__allegro_server.openFederated(connections_to_federate, True)
else:
if type(self.__repository) == list and len(self.__repository) == 1:
self.__repository = self.__repository[0]
self.__allegro_repository = self.__allegro_catalog.getRepository(self.__repository, Repository.ACCESS)
self.__allegro_repository.initialize()
self.__con = self.allegro_repository.getConnection()
results_format = property(lambda self: 'json')
server = property(lambda self: self.__server)
port = property(lambda self: self.__port)
catalog = property(lambda self: self.__catalog)
repository = property(lambda self: self.__repository)
allegro_server = property(lambda self: self.__allegro_server)
allegro_catalog = property(lambda self: self.__allegro_catalog)
allegro_repository = property(lambda self: self.__allegro_repository)
def _save(self, *resources):
for resource in resources:
s = resource.subject
self.__remove(s)
for p, objs in resource.rdf_direct.items():
for o in objs:
self.__add(s, p, o)
def _update(self, *resources):
for resource in resources:
s = resource.subject
for p in resource.rdf_direct:
self.__remove(s, p)
for p, objs in resource.rdf_direct.items():
for o in objs:
self.__add(s, p, o)
def _remove(self, *resources, **kwargs):
inverse = kwargs.get("inverse")
for resource in resources:
self.__remove(s = resource.subject)
if inverse:
self.__remove(o = resource.subject)
def _size(self):
return self.__con.size()
def _add_triple(self, s = None, p = None, o = None, context = None):
self.__add(s, p, o, context)
def _set_triple(self, s = None, p = None, o = None, context = None):
self.__remove(s, p, context = context)
self.__add(s, p, o, context)
def _remove_triple(self, s = None, p = None, o = None, context = None):
self.__remove(s, p, o, context)
# used by the sesame api
def __add(self, s = None, p = None, o = None, context = None):
self.log.info('ADD TRIPLE: ' + unicode(s) + ', ' + unicode(p) + ', ' + unicode(o) + ', ' + unicode(context))
self.__con.addTriple(toSesame(s, self.__con), toSesame(p, self.__con), toSesame(o, self.__con), contexts = toSesame(context, self.__con))
def __remove(self, s = None, p = None, o = None, context = None):
self.log.info('REM TRIPLE: ' + unicode(s) + ', ' + unicode(p) + ', ' + unicode(o) + ', ' + unicode(context))
self.__con.removeTriples(toSesame(s, self.__con), toSesame(p, self.__con), toSesame(o, self.__con), contexts = toSesame(context, self.__con))
def index_triples(self, **kwargs):
""" Index triples if this functionality is present.
Return `True` if successful.
"""
all = kwargs['all'] if 'all' in kwargs else False
asynchronous = kwargs['asynchronous'] if 'asynchronous' in kwargs else False
self.__allegro_repository.indexTriples(all = all, asynchronous = asynchronous)
return True
def load_triples(self, **kwargs):
'''
loads triples from supported sources if such functionality is present
returns True if operation successfull
'''
format = kwargs['format'] if 'format' in kwargs else RDFFormat.RDFXML
format = RDFFormat.NTRIPLES if format is 'nt' else RDFFormat.RDFXML
source = kwargs['source'] if 'source' in kwargs else None
base = kwargs['base'] if 'base' in kwargs else None
context = kwargs['context'] if 'context' in kwargs else None
server_side = kwargs['server_side'] if 'server_side' in kwargs else True
if source:
self.__con.addFile(source, base = base, format = format, context = toSesame(context, self.__con), serverSide = server_side)
return True
return False
def _clear(self, context = None):
""" Clear the triple-store. """
self.__con.clear(contexts = toSesame(context, self.__con))
# Extra functionality
def register_fts_predicate(self, namespace, localname):
'''
register free text search predicates
'''
self.__allegro_repository.registerFreeTextPredicate(namespace = unicode(namespace), localname = localname)
def namespaces(self):
return self.__con.getNamespaces()
def namespace(self, prefix):
return self.__con.getNamespace(prefix)
def set_namespace(self, prefix, namespace):
self.__con.setNamespace(prefix, namespace)
def remove_namespace(self, prefix):
self.__con.removeNamespace(prefix)
def clear_namespaces(self):
self.__con.clearNamespaces()
def close(self):
self.__con.close()
class ReaderPlugin(RDFQueryReader):
def __init__(self, *args, **kwargs):
RDFQueryReader.__init__(self, *args, **kwargs)
self.__server = kwargs['server'] if 'server' in kwargs else 'localhost'
self.__port = kwargs['port'] if 'port' in kwargs else 6789
self.__catalog = kwargs['catalog'] if 'catalog' in kwargs else None
self.__repository = kwargs['repository'] if 'repository' in kwargs else None
if not self.__catalog or not self.__repository:
raise Exception('Must specify the <catalog> and the <repository> arguments')
self.__allegro_server = AllegroGraphServer(self.__server, port = self.__port)
self.__allegro_catalog = self.__allegro_server.openCatalog(self.__catalog)
if type(self.__repository) == list and len(self.__repository) > 1:
connections_to_federate = []
repositories_to_federate = []
for one_repository in self.__repository:
repositories_to_federate.append(self.__allegro_catalog
.getRepository(one_repository, Repository.ACCESS))
connections_to_federate.append(self.__allegro_catalog
.getRepository(one_repository, Repository.ACCESS)
.initialize().getConnection())
self.__allegro_repository = repositories_to_federate
self.__con = self.__allegro_server.openFederated(connections_to_federate, True)
else:
if type(self.__repository) == list and len(self.__repository) == 1:
self.__repository = self.__repository[0]
self.__allegro_repository = self.__allegro_catalog.getRepository(self.__repository, Repository.ACCESS)
self.__allegro_repository.initialize()
self.__con = self.allegro_repository.getConnection()
results_format = property(lambda self: 'json')
server = property(lambda self: self.__server)
port = property(lambda self: self.__port)
catalog = property(lambda self: self.__catalog)
repository = property(lambda self: self.__repository)
allegro_server = property(lambda self: self.__allegro_server)
allegro_catalog = property(lambda self: self.__allegro_catalog)
allegro_repository = property(lambda self: self.__allegro_repository)
def _to_table(self, result):
table = []
bindings = result.getBindingNames()
for bindingSet in result:
row = {}
for key in bindings:
try: v = toRdfLib(bindingSet[key])
except: v = None
row[key] = v
table.append(row)
return table
def _ask(self, result):
'''
returns the boolean value of a ASK query
'''
return result
# execute
def _execute(self, query):
if query.query_type == 'select':
return self.__execute_sparql(unicode(query))
elif query.query_type == 'ask':
return self.__execute_ask(unicode(query))
def __execute_ask(self, q_string):
boolQuery = self.__con.prepareBooleanQuery(QueryLanguage.SPARQL, q_string)
return boolQuery.evaluate()
def __execute_sparql(self, q_string, **kwargs):
self.log.debug(q_string)
tupleQuery = self.__con.prepareTupleQuery(QueryLanguage.SPARQL, q_string)
inference = kwargs['inference'] if 'inference' in kwargs else self.inference
tupleQuery.setIncludeInferred(inference)
return tupleQuery.evaluate()
def execute_sparql(self, q_string, format = 'JSON'):
results = self.__execute_sparql(q_string)
return self._results_to_json(results) if format == 'JSON' else results
def close(self):
self.__con.close()
def _results_to_json(self, results):
bindings = results.getBindingNames()
r_dict = {}
r_dict['head'] = {'vars': bindings}
r_dict['results'] = {'bindings':[]}
for bindingSet in results:
json_binding = {}
for b in bindings:
value = bindingSet.getValue(b)
if type(value) is sv.URI:
json_binding[b] = {'type':'uri', 'value': value.getURI()}
elif type(value) is sv.BNode:
json_binding[b] = {'type':'bnode', 'value': value.getID()}
elif type(value) is sl.Literal:
dtype = value.getDatatype() if value.getDatatype() else None
lang = value.getLanguage() if value.getLanguage() else None
lit_type = 'typed-literal' if dtype else 'literal'
json_binding[b] = {'type':lit_type, 'value': value.getLabel()}
if dtype:
if type(dtype) in [str, unicode] and dtype.startswith('<') and dtype.endswith('>'):
dtype = dtype.strip('<>')
json_binding[b]['datatype'] = URIRef(dtype)
if lang:
json_binding[b]['xml:lang'] = lang
r_dict['results']['bindings'].append(json_binding)
return r_dict
