def fetch(self, entity_name):
u = self._get_access_url(entity_name)
print(u)
r = requests.get(u, headers=self.headers, allow_redirects=True)
g = rdflib.Dataset()
local = g.graph(rdflib.BNode())
text = r.text
for pattern, repl in self.replace:
text = re.sub(pattern, repl, text)
print(text)
local.parse(data=text, format=self.format)
# print self.postprocess_update
if self.postprocess_update is not None:
commands = self.postprocess_update
if isinstance(commands, str):
commands = [commands]
for command in commands:
# print "update postprocess query."
g.update(command)
if self.postprocess is not None:
print("postprocessing", entity_name)
p = self.postprocess
p(g)
# print g.serialize(format="trig")
return rdflib.ConjunctiveGraph(identifier=local.identifier,
store=g.store)
def process_graph(self, inputGraph):
instances = self.getInstances(inputGraph)
results = []
for i in instances:
print("Processing", i.identifier, self)
output_nanopub = Nanopublication()
o = output_nanopub.assertion.resource(
i.identifier) # OutputClass(i.identifier)
error = False
try:
result = self.process_nanopub(i, o, output_nanopub)
except Exception as e:
output_nanopub.add(
(output_nanopub.assertion.identifier,
self.app.NS.sioc.content, rdflib.Literal(str(e))))
logging.exception(
"Error processing resource %s in nanopub %s" %
(i.identifier, inputGraph.identifier))
error = True
print("Output Graph", output_nanopub.identifier,
len(output_nanopub))
for new_np in self.app.nanopub_manager.prepare(
rdflib.ConjunctiveGraph(store=output_nanopub.store)):
if len(new_np.assertion) == 0 and not error:
continue
self.explain(new_np, i, o)
new_np.add((new_np.identifier, sio.isAbout, i.identifier))
# print new_np.serialize(format="trig")
if not self.dry_run:
self.app.nanopub_manager.publish(new_np)
results.append(new_np)
return results
def __init__(self, store, prefix, app, update_listener=None):
self.db = rdflib.ConjunctiveGraph(store)
self.store = store
self.app = app
self.depot = DepotManager.get('nanopublications')
self.prefix = rdflib.Namespace(prefix)
self.update_listener = update_listener
def create_annotation_graph_ressource_version(path_to_annot_graphs_dir, version, ressource_name, desc, title, sources):
"""
This function is used to create the ressource_info file associated to the version of the created annotation_graph.
- path_to_annot_graphs_dir: a path to annotation graphs directory
- version: the version of the annotation graph
- ressource_name: the name of the associated ressource for the annotation graph
- desc: a description of the graph
- title: a title for the graph
- sources: a list of uris which vere used to build the annotation graph
"""
ressource_version = Database_ressource_version(ressource = ressource_name, version = version)
n_triples = 0
subjects = set()
for annot_graph in os.listdir(path_to_annot_graphs_dir):
if not annot_graph.endswith(".ttl"):
continue
if annot_graph == "void.ttl":
continue
sub_g = rdflib.ConjunctiveGraph()
sub_g.parse(path_to_annot_graphs_dir + annot_graph, format = 'turtle')
n_triples += len(sub_g)
subjects = subjects.union(set([s for s in sub_g.subjects()]))
ressource_version.add_DataDump(annot_graph)
for source in sources:
ressource_version.add_version_attribute(DCTERMS["source"], rdflib.URIRef(source))
ressource_version.add_version_attribute(DCTERMS["description"], rdflib.Literal(desc))
ressource_version.add_version_attribute(DCTERMS["title"], rdflib.Literal(title))
ressource_version.add_version_attribute(VOID["triples"], rdflib.Literal(n_triples, datatype=XSD.long ))
ressource_version.add_version_attribute(VOID["distinctSubjects"], rdflib.Literal(len(subjects), datatype=XSD.long ))
ressource_version.version_graph.serialize(destination=path_to_annot_graphs_dir + "void.ttl", format = 'turtle')
def catalyst_graph_for(file):
if file.startswith('/'):
file = 'file://'+file
logging.info("InferenceStore catalyst_graph_for started")
# quads = jsonld.to_rdf(file, {'format': 'application/nquads'})
logging.info("InferenceStore JSON-LD loaded")
g = ConjunctiveGraph()
g.namespace_manager = namespace_manager
# g.parse(data=quads, format='nquads')
g.load(file, format="json-ld")
logging.info("InferenceStore base graph loaded")
f = FuXiInferenceStore.get_instance()
# get the inference engine
cl = f.get_inference(g)
logging.info("InferenceStore inference graph loaded")
union_g = rdflib.ConjunctiveGraph()
for s,p,o in g.triples( (None, None, None) ):
union_g.add( (s,p,o) )
for s,p,o in cl.triples( (None, None, None) ):
union_g.add( (s,p,o) )
logging.info("InferenceStore union graph prepared")
return union_g
def get(self, nanopub_uri, graph=None):
nanopub_uri = rdflib.URIRef(nanopub_uri)
f = None
if nanopub_uri in self._idmap:
f = self.depot.get(self._idmap[nanopub_uri])
else:
#try:
fileid = nanopub_uri.replace(self.prefix, "", 1)
f = self.depot.get(fileid)
#except:
# try:
# fileid = self.db.value(nanopub_uri, dc.identifier)
# if fileid is not None:
# self._idmap[nanopub_uri] = fileid
# f = self.depot.get(fileid)
# except Exception as e:
# return None
if graph is None:
graph = rdflib.ConjunctiveGraph()
nanopub = Nanopublication(store=graph.store, identifier=nanopub_uri)
nanopub.parse(f, format="trig")
try:
f.close()
except:
pass
return nanopub
def __init__(self, store, archive_path, prefix):
self.db = rdflib.ConjunctiveGraph(store)
self.store = store
self.archive_path = archive_path
self.prefix = rdflib.Namespace(prefix)
if not os.path.exists(self.archive_path):
os.makedirs(self.archive_path)
def write_ttl_news(entries, out_file, template=None, subject_uri=None):
"""Write NEWS in Turtle format"""
import rdflib
import rdflib.namespace
import rdflib.resource
import datetime
# Set up namespaces and make a graph for the output
doap = rdflib.Namespace("http://usefulinc.com/ns/doap#")
dcs = rdflib.Namespace("http://ontologi.es/doap-changeset#")
rdfs = rdflib.Namespace("http://www.w3.org/2000/01/rdf-schema#")
rdf = rdflib.Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
xsd = rdflib.Namespace("http://www.w3.org/2001/XMLSchema#")
g = rdflib.ConjunctiveGraph()
ns = rdflib.namespace.NamespaceManager(g)
ns.bind("doap", doap)
ns.bind("dcs", dcs)
# Load given template file
if template is not None:
g.load(template, format="turtle")
if subject_uri is not None:
# Use given subject uri
subject = rdflib.URIRef(subject_uri)
g.add((subject, rdf.type, doap.Project))
else:
# Find project URI to use as subject, and optionally the maintainer
subject = g.value(None, rdf.type, doap.Project)
ensure(subject is not None, "Unable to find project URI for subject")
maintainer = g.value(subject, doap.maintainer, None)
for r, e in entries.items():
semver = parse_version(e["revision"])
ver_string = "%03d%03d%03d" % semver
release = rdflib.BNode("r%s" % ver_string)
g.add((subject, doap.release, release))
g.add((release, doap.revision, rdflib.Literal(e["revision"])))
if "dist" in e:
g.add((release, doap["file-release"], rdflib.URIRef(e["dist"])))
utc_date = e["date"].astimezone(datetime.timezone.utc)
date_str = utc_date.strftime("%Y-%m-%dT%H:%M:%S") + "Z"
time = rdflib.Literal(date_str, datatype=xsd.dateTime, normalize=False)
g.add((release, doap.created, time))
if maintainer is not None:
g.add((release, dcs.blame, maintainer))
changeset = rdflib.BNode("c%s" % ver_string)
g.add((release, dcs.changeset, changeset))
for index, item in enumerate(e["items"]):
item_node = rdflib.BNode("i%s%08d" % (ver_string, index))
g.add((changeset, dcs.item, item_node))
g.add((item_node, rdfs.label, rdflib.Literal(item)))
g.serialize(out_file, format="turtle")
def testAll(self):
for rdf_processor in self._ALL:
endpoint = mock.Mock(spec=humfrey.sparql.endpoint.Endpoint)
graph = rdflib.ConjunctiveGraph()
doc_uri = rdflib.URIRef('http://example.org/doc/Foo')
subject_uri = rdflib.URIRef('http://example.org/id/Foo')
subject = resource.Resource(subject_uri, graph, endpoint)
#import pdb;pdb.set_trace()
doc_view = views.DocView()
renderers = Conneg(obj=doc_view).renderers
request = self.factory.get('')
doc_view.context = {
'graph': graph,
'doc_uri': doc_uri,
'subject_uri': subject_uri,
'subject': subject,
'endpoint': endpoint
}
doc_view.context['renderers'] = [
doc_view.renderer_for_context(request, renderer)
for renderer in renderers
]
rdf_processor(request=request, context=doc_view.context)
self.assertFalse(
endpoint.query.called,
"The RDF processor should not be touching the endpoint (at the moment)"
)
self.check_valid_terms(graph)
self.assertIsInstance(doc_view.context, (type(None), dict))
def load_sparql(self, sparql_endpoint, verbose=False, hide_base_schemas=True, credentials=None):
"""
Set up a SPARQLStore backend as a virtual ontospy graph
Note: we're using a 'SPARQLUpdateStore' backend instead of 'SPARQLStore' cause otherwise authentication fails (https://github.com/RDFLib/rdflib/issues/755)
"""
try:
# graph = rdflib.ConjunctiveGraph('SPARQLStore')
graph = rdflib.ConjunctiveGraph('SPARQLUpdateStore')
if credentials and type(credentials) == tuple:
# https://github.com/RDFLib/rdflib/issues/343
graph.store.setCredentials(credentials[0], credentials[1])
# graph.store.setHTTPAuth('BASIC') # graph.store.setHTTPAuth('DIGEST')
graph.open(sparql_endpoint)
self.rdflib_graph = graph
self.sparql_endpoint = sparql_endpoint
self.sources = [sparql_endpoint]
self.sparqlHelper = SparqlHelper(self.rdflib_graph, self.sparql_endpoint)
self.namespaces = sorted(self.rdflib_graph.namespaces())
except:
printDebug("Error trying to connect to Endpoint.")
raise
def test_json_to_ttl_match(self):
json_files = sorted(
glob(os.path.join(os.path.dirname(__file__), 'json', '*.json')))
# invalid round trip files
skip = list(range(352, 380))
# invalid literal set representation e.g., set((1, True))
skip_match = [5, 6, 7, 8, 15, 27, 28, 29, 75, 76, 77, 78, 79, 80, 260,
261, 262, 263, 264,
306, 313, 315, 317, 322, 323, 324, 325, 330, 332, 344,
346, 382, 389, 395, 397,
]
for idx, fname in enumerate(json_files):
_, ttl_file = os.path.split(fname)
ttl_file = os.path.join(os.path.dirname(__file__), 'rdf',
ttl_file.replace('json', 'ttl'))
error_raised = False
try:
g = pm.ProvDocument.deserialize(fname)
if len(g.bundles) == 0:
format = 'turtle'
else:
format = 'trig'
if format == 'trig':
ttl_file = ttl_file.replace('ttl', 'trig')
with open(ttl_file, 'rb') as fp:
g_rdf = rl.ConjunctiveGraph().parse(fp, format=format)
g0_rdf = rl.ConjunctiveGraph().parse(
StringIO(g.serialize(format='rdf', rdf_format=format)),
format=format)
if idx not in skip_match:
self.assertTrue(find_diff(g_rdf, g0_rdf)[0])
else:
logger.info('Skipping match: %s' % fname)
if idx in skip:
logger.info('Skipping deserialization: %s' % fname)
continue
g1 = pm.ProvDocument.deserialize(
content=g.serialize(format='rdf', rdf_format=format),
format='rdf', rdf_format=format)
except Exception as e:
print(e)
logger.info(e)
error_raised = True
self.assertFalse(error_raised)
def testGetNoReasoning(self):
graph = rdflib.ConjunctiveGraph(getStore())
grrm2.EquilibriumStructure.new(graph, "http://example.com/eq1")
grrm2.TransitionState.new(graph, "http://example.com/ts1")
grrm2.BarrierlessDissociated.new(graph,
"http://example.com/blessdiss1")
grrm2.BarrierDissociated.new(graph, "http://example.com/bdiss1")
grrm2.InterconversionStep.new(graph, "http://example.com/ic1")
grrm2.Interconversion.new(graph, "http://example.com/iconv1")
grrm2.RunData.new(graph, "http://example.com/rundata1")
grrm2.Run.new(graph, "http://example.com/run1")
grrm2.Molecule.new(graph, "http://example.com/mol1")
grrm2.RunInput.new(graph, "http://example.com/runin1")
grrm2.RunOutput.new(graph, "http://example.com/runout1")
grrm2.InterconversionResult.new(graph, "http://example.com/icres1")
self.assertEqual(
grrm2.EquilibriumStructure.get(graph,
"http://example.com/eq1").__class__,
grrm2.EquilibriumStructure)
self.assertEqual(
grrm2.TransitionState.get(graph,
"http://example.com/ts1").__class__,
grrm2.TransitionState)
self.assertEqual(
grrm2.BarrierlessDissociated.get(
graph, "http://example.com/blessdiss1").__class__,
grrm2.BarrierlessDissociated)
self.assertEqual(
grrm2.BarrierDissociated.get(
graph, "http://example.com/bdiss1").__class__,
grrm2.BarrierDissociated)
self.assertEqual(
grrm2.InterconversionStep.get(graph,
"http://example.com/ic1").__class__,
grrm2.InterconversionStep)
self.assertEqual(
grrm2.Interconversion.get(graph,
"http://example.com/iconv1").__class__,
grrm2.Interconversion)
self.assertEqual(
grrm2.RunData.get(graph, "http://example.com/rundata1").__class__,
grrm2.RunData)
self.assertEqual(
grrm2.Run.get(graph, "http://example.com/run1").__class__,
grrm2.Run)
self.assertEqual(
grrm2.Molecule.get(graph, "http://example.com/mol1").__class__,
grrm2.Molecule)
self.assertEqual(
grrm2.RunInput.get(graph, "http://example.com/runin1").__class__,
grrm2.RunInput)
self.assertEqual(
grrm2.RunOutput.get(graph, "http://example.com/runout1").__class__,
grrm2.RunOutput)
self.assertEqual(
grrm2.InterconversionResult.get(
graph, "http://example.com/icres1").__class__,
grrm2.InterconversionResult)
def write_news(name, in_files, out_file):
import rdflib
import textwrap
from time import strftime, strptime
doap = rdflib.Namespace('http://usefulinc.com/ns/doap#')
dcs = rdflib.Namespace('http://ontologi.es/doap-changeset#')
rdfs = rdflib.Namespace('http://www.w3.org/2000/01/rdf-schema#')
foaf = rdflib.Namespace('http://xmlns.com/foaf/0.1/')
rdf = rdflib.Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#')
m = rdflib.ConjunctiveGraph()
try:
for i in in_files:
m.parse(i, format='n3')
except:
Logs.warn('Error parsing data, unable to generate NEWS')
return
proj = m.value(None, rdf.type, doap.Project)
for f in m.triples([proj, rdfs.seeAlso, None]):
if f[2].endswith('.ttl'):
m.parse(f[2], format='n3')
entries = {}
for r in m.triples([proj, doap.release, None]):
release = r[2]
revision = m.value(release, doap.revision, None)
date = m.value(release, doap.created, None)
blamee = m.value(release, dcs.blame, None)
changeset = m.value(release, dcs.changeset, None)
if revision and date and blamee and changeset:
entry = '%s (%s) stable;\n' % (name, revision)
for i in m.triples([changeset, dcs.item, None]):
entry += '\n * ' + '\n '.join(
textwrap.wrap(m.value(i[2], rdfs.label, None), width=79))
entry += '\n\n --'
blamee_name = m.value(blamee, foaf.name, None)
blamee_mbox = m.value(blamee, foaf.mbox, None)
if blamee_name and blamee_mbox:
entry += ' %s <%s>' % (blamee_name,
blamee_mbox.replace('mailto:', ''))
entry += ' %s\n\n' % (strftime('%a, %d %b %Y %H:%M:%S +0000',
strptime(date, '%Y-%m-%d')))
entries[revision] = entry
else:
Logs.warn('Ignored incomplete %s release description' % name)
if len(entries) > 0:
news = open(out_file, 'w')
for e in sorted(entries.keys(), reverse=True):
news.write(entries[e])
news.close()
def __init__(self, graph=None):
"""
@brief Manages an ontology using rdflib
"""
if graph is not None:
self._ontology = graph
else:
self._ontology = rdflib.ConjunctiveGraph() # store='Sleepycat' #TODO:
def modfy(bundle):
manifest_path = os.path.join(bundle, 'manifest.ttl')
resources = os.path.join(os.path.realpath(bundle), 'modgui')
if not os.path.exists(resources):
os.mkdir(resources)
resources = 'file://%s' % resources
rdfschema = rdflib.Namespace('http://www.w3.org/2000/01/rdf-schema#')
rdfsyntax = rdflib.Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#')
lv2core = rdflib.Namespace('http://lv2plug.in/ns/lv2core#')
mod = rdflib.Namespace('http://portalmod.com/ns/modgui#')
manifest = rdflib.ConjunctiveGraph()
manifest.parse(manifest_path, format='n3')
for triple in manifest.triples((None, rdfsyntax.type, lv2core.Plugin)):
url = triple[0]
for triple in manifest.triples((url, rdfschema.seeAlso, None)):
ttl_path = triple[2]
plugin_name = ttl_path.split('/')[-1].replace('.ttl', '')
plugin = rdflib.ConjunctiveGraph()
plugin.parse(ttl_path, format='n3')
try:
modgui = list(plugin.triples(url, rdfsyntax.type, mod.GUI))[0]
except:
pass
else:
continue
for triple in plugin.triples((None, None, None)):
if triple[0].startswith('http://portalmod.com/ns/extensions/effect#'):
plugin.remove(triple)
gui = rdflib.BNode()
uri = rdflib.term.URIRef
resources = 'modgui'
plugin.add((url, mod.gui, gui))
plugin.add((gui, mod.resourcesDirectory, uri(resources)))
plugin.add((gui, mod.iconTemplate, uri('%s/%s.html' % (resources, plugin_name))))
plugin.add((gui, mod.templateData, uri('%s/%s.json' % (resources, plugin_name))))
plugin.add((gui, mod.screenshot, uri('%s/%s.png' % (resources, plugin_name))))
plugin.add((gui, mod.thumbnail, uri('%s/%s-thumb.png' % (resources, plugin_name))))
plugin.namespace_manager.bind('mod', mod)
plugin.serialize(ttl_path, format='n3')
def query_virtuoso(q):
endpoint = virtuoso_address
store = sparqlstore.SPARQLUpdateStore(endpoint)
gs = rdflib.ConjunctiveGraph(store)
gs.open((endpoint, endpoint))
gs1 = gs.get_context(rdflib.URIRef(virtuoso_graph_uri))
res = gs1.query(q)
return res
def testParser(self):
graph = rdflib.ConjunctiveGraph()
p = parsinghelpers.OutputTSFileParser(
graph,
os.path.join(os.path.dirname(__file__), "formaldehyde-newnames",
"grrm_HCHO_TS_list.log"))
self.assertEqual(len(p.moleculeUris()), 9)
print graph.serialize()
def __init__(self):
self.relations = []
self.attributes = []
self.bnodes = []
store = TripleIteratorStore(self._handle_attribute_triple,
self._handle_relation_triple,
self._handle_bnode_triple)
self.graph = rdflib.ConjunctiveGraph(store)
def query_from_files(kb, goal, nokbdbg, nolog):
import pyin
pyin.nolog = nolog
pyin.nokbdbg = nokbdbg
# kb= open('kb_for_external.nq', 'rb')
# goal=open('query_for_external.nq', 'rb')
kb_stream, goal_stream = kb, goal
implies = rdflib.URIRef("http://www.w3.org/2000/10/swap/log#implies")
store = OrderedStore()
kb_graph = rdflib.Graph(store=store, identifier='@default')
kb_conjunctive = rdflib.ConjunctiveGraph(store=store)
kb_graph.parse(kb_stream, format='nquads')
#exit()
rules = []
"""
--------
kb:
?x y ?z.
query:
...
--------
--------
?x y ?z.
?z w a.
--------
"""
for s,p,o in kb_graph.triples((None, None, None)):
_t = Triple(p, [s, o])
rules.append(Rule(kb_graph, _t, Graph()))
if p == implies:
head_triples = kb_conjunctive.triples((None, None, None), o)
for head_triple in head_triples:
body = Graph()
for body_triple in kb_conjunctive.triples((None, None, None), s):
body.append(Triple((body_triple[1]), [(body_triple[0]), (body_triple[2])]))
rules.append(Rule(head_triples, Triple((head_triple[1]), [(head_triple[0]), (head_triple[2])]), body))
goal_rdflib_graph = rdflib.Graph(store=OrderedStore())
goal_rdflib_graph.parse(goal_stream, format='nquads')
goal = Graph()
for s,p,o in goal_rdflib_graph.triples((None, None, None)):
goal.append(Triple((p), [(s), (o)]))
for result in query(rules, goal):
print ()
o = ' RESULT : '
for triple in result:
o += str(triple)
print (o)
def extract_CID_InchiKey(pmids_cids_graph_list, inchikeys_graph_list,
path_out):
# Inti output file
with open(path_out, "w") as out:
out_writer = csv.writer(out, delimiter=',')
m = out_writer.writerow(['CID', 'INCHIKEY'])
# Init variables
available_cids = set()
for pmid_cid_f_input in pmids_cids_graph_list:
# release memory
g_pmid_cid = None
# Import pmid_cid graph
print("Importing " + pmid_cid_f_input + " ...", end='')
g_pmid_cid = rdflib.ConjunctiveGraph()
with gzip.open(pmid_cid_f_input, "rb") as f:
g_pmid_cid.parse(f, format="turtle")
# Get all objects
extracted_objects = [
uri.toPython().split(
'http://rdf.ncbi.nlm.nih.gov/pubchem/compound/CID')[1]
for uri in list(g_pmid_cid.objects())
]
available_cids = available_cids.union(extracted_objects)
print(" Ok")
# Then, we browse inchikey files to select CID - inchikey association for which the CID has an associated corpus
for inchikey_f_input in inchikeys_graph_list:
g_inchikey = None
g_inchikey = rdflib.Graph()
print("treating file " + inchikey_f_input + " ...", end='')
# Add InchiKeys triples to the graph
with gzip.open(inchikey_f_input, "rb") as f:
g_inchikey.parse(f, format="turtle")
# Get cid - inchikey associations
cids_inchikeys = list(
g_inchikey.subject_objects(
rdflib.URIRef(
"http://semanticscience.org/resource/is-attribute-of")))
inchikeys = [
cid_inchikey[0].toPython().split(
"http://rdf.ncbi.nlm.nih.gov/pubchem/inchikey/")[1]
for cid_inchikey in cids_inchikeys
]
cids = [
cid_inchikey[1].toPython().split(
"http://rdf.ncbi.nlm.nih.gov/pubchem/compound/CID")[1]
for cid_inchikey in cids_inchikeys
]
with open(path_out, "a") as out:
out_writer = csv.writer(out, delimiter=',')
for cid_index in range(0, len(cids)):
if cids[cid_index] in available_cids:
m = out_writer.writerow(
[cids[cid_index], inchikeys[cid_index]])
print(" Ok")
# Release all memory
g_inchikey = None
g_pmid_cid = None
print("End procedure CID - InchiKeys associations !")
def _build_cache(source_file, skip_cache=False):
"""Builds the cached data by parsing the RDF taxonomy file or a
vocabulary file.
@var source_file: source file of the taxonomy, RDF file
@keyword skip_cache: boolean, if True, build cache will not be
saved (pickled) - it is saved as <source_file.db> """
if rdflib:
if rdflib.__version__ >= '2.3.2':
store = rdflib.ConjunctiveGraph()
else:
store = rdflib.Graph()
else:
store = None
if skip_cache:
log.info("You requested not to save the cache to disk.")
else:
cache_path = _get_cache_path(source_file)
cache_dir = os.path.dirname(cache_path)
# Make sure we have a cache_dir readable and writable.
try:
os.makedirs(cache_dir)
except:
pass
if os.access(cache_dir, os.R_OK):
if not os.access(cache_dir, os.W_OK):
log.error("Cache directory exists but is not writable. Check your permissions for: %s" % cache_dir)
raise Exception("Cache directory exists but is not writable. Check your permissions for: %s" % cache_dir)
else:
log.error("Cache directory does not exist (and could not be created): %s" % cache_dir)
raise Exception("Cache directory does not exist (and could not be created): %s" % cache_dir)
timer_start = time.clock()
namespace = None
single_keywords, composite_keywords = {}, {}
try:
if not rdflib:
import rdflib as rdflib_reimport
log.info("Building RDFLib's conjunctive graph from: %s" % source_file)
try:
store.parse(source_file)
except urllib2.URLError, exc:
if source_file[0] == '/':
store.parse("file://" + source_file)
else:
store.parse("file:///" + source_file)
except rdflib_exceptions_Error, e:
log.error("Serious error reading RDF file")
log.error(e)
log.error(traceback.format_exc())
raise rdflib.exceptions.Error(e)
def run(self, input_file, file_format="trig", was_revision_of=None):
flask.current_app.managed = True
if was_revision_of is not None:
wasRevisionOf = set(
flask.current_app.db.objects(
predicate=np.hasAssertion,
subject=rdflib.URIRef(was_revision_of)))
if len(wasRevisionOf) == 0:
print("Could not find active nanopublication to revise:",
was_revision_of)
return
was_revision_of = wasRevisionOf
g = rdflib.ConjunctiveGraph(identifier=rdflib.BNode().skolemize(),
store="Sleepycat")
graph_tempdir = tempfile.mkdtemp()
g.store.open(graph_tempdir, True)
# g = rdflib.ConjunctiveGraph(identifier=rdflib.BNode().skolemize())
g1 = g.parse(location=input_file,
format=file_format,
publicID=flask.current_app.NS.local)
if len(list(g.subjects(rdflib.RDF.type, np.Nanopublication))) == 0:
print("Could not find existing nanopublications.", len(g1), len(g))
new_np = Nanopublication(store=g1.store)
new_np.add(
(new_np.identifier, rdflib.RDF.type, np.Nanopublication))
new_np.add((new_np.identifier, np.hasAssertion, g1.identifier))
new_np.add((g1.identifier, rdflib.RDF.type, np.Assertion))
nanopub_prepare_graph = rdflib.ConjunctiveGraph(store="Sleepycat")
nanopub_prepare_graph_tempdir = tempfile.mkdtemp()
nanopub_prepare_graph.store.open(nanopub_prepare_graph_tempdir, True)
nanopubs = []
for npub in flask.current_app.nanopub_manager.prepare(
g, store=nanopub_prepare_graph.store):
if was_revision_of is not None:
for r in was_revision_of:
print("Marking as revision of", r)
npub.pubinfo.add(
(npub.assertion.identifier,
flask.current_app.NS.prov.wasRevisionOf, r))
print('Prepared', npub.identifier)
nanopubs.append(npub)
flask.current_app.nanopub_manager.publish(*nanopubs)
print("Published", npub.identifier)
def CREATE_GRAPH():
"""
Create the global graph.
"""
global __global_graph__
try:
__global_graph__ = rdflib.ConjunctiveGraph()
except:
__global_graph__ = rdflib.graph.ConjunctiveGraph()
def test_fail_on_non_empty_target(dirs):
d = Descriptor('test')
g = rdflib.ConjunctiveGraph()
bi = Installer(*dirs, graph=g)
bundles_directory = dirs[1]
sma = p(bundles_directory, 'test', '1', 'blah')
makedirs(sma)
with pytest.raises(TargetIsNotEmpty):
bi.install(d)
def testRememberNamespace(self):
g = rdflib.ConjunctiveGraph()
g.add(TRIPLE + (rdflib.URIRef("http://example.com/graph1"), ))
# In 4.2.0 the first serialization would fail to include the
# prefix for the graph but later serialize() calls would work.
first_out = g.serialize(format="trig", encoding="latin-1")
second_out = g.serialize(format="trig", encoding="latin-1")
self.assertTrue(b"@prefix ns1: <http://example.com/> ." in second_out)
self.assertTrue(b"@prefix ns1: <http://example.com/> ." in first_out)
def test_load1(self):
""" Put the appropriate triples in. Try to load them """
g = R.ConjunctiveGraph()
self.config['rdf.graph'] = g
for t in self.trips:
g.add(t)
c = self.ctx.Connection(conf=self.config)
for x in c.load():
self.assertIsInstance(x, Connection)
def triples(self, sub, pre, obj):
graph = rdflib.ConjunctiveGraph()
data = StringInputSource(self.conn.statements_default_graph(
self.repository,
'text/plain'
))
graph.parse(data, format="nt")
t = self.parse_triple(sub, pre, obj)
return graph.triples(t)
def __init__(self, *args, **kwargs):
allowed_keys = ['verbose']
self.__dict__.update((k, False) for k in allowed_keys)
self.__dict__.update(
(k, v) for k, v in kwargs.items() if k in allowed_keys)
self.uri = None
self.data = None # the raw data coming back from SciGraph
self.rdfgraph = rdflib.ConjunctiveGraph()
def __init__(self, subject=None, graph=None, format='n3'):
if graph:
self.graph = graph
else:
self.graph = rdflib.ConjunctiveGraph()
self.subject = subject
self.format = format
self.parsed_files = set()
self._data = None
def generateroutesdatardf(routes_data):
routesbaseuri = base_uri + 'route/'
retRDF = rdflib.ConjunctiveGraph()
for route in routes_data:
for p in routes_data[route]:
pred = rdflib.URIRef(routesbaseuri + p)
obj = routes_data[route][p]
retRDF.add((route, pred, rdflib.Literal(obj)))
return retRDF