def update_list():
"""
Reads the triple store looking for twitter usernames and adds
them to the dev8d list.
"""
g = ConjunctiveGraph("Sleepycat")
g.open("store")
# get oauth client in order
credentials = get_credentials()
consumer = oauth.Consumer(credentials['key'], credentials['secret'])
client = oauth.Client(consumer, credentials['access_token'])
list_update_url = 'http://api.twitter.com/1/%s/%s/members.json' % \
(credentials['list_owner'], credentials['list_name'])
# create the list if necessary
create_list(credentials['list_owner'], credentials['list_name'], client)
# look at all the twitter usernames and add them to the list
for twitter_username in g.objects(predicate=w['Twitter']):
id = twitter_user_id(twitter_username, client)
if id:
logging.info("adding %s (%s) to list" % (twitter_username, id))
body = "id=%s" % id
resp, content = client.request(list_update_url, 'POST', body=body)
else:
logging.error("unable to get twitter id for %s" % twitter_username)
g.close()
def test_issue_4(self):
ident = URIRef("rdflib_test")
g = Graph(store="SQLAlchemy", identifier=ident)
rt = g.open(self.uri, create=True)
if rt == NO_STORE:
g.open(self.uri, create=True)
else:
assert rt == VALID_STORE, "The underlying store is corrupt"
g.destroy(self.uri)
def test_issue_4(self):
ident = URIRef("rdflib_test")
g = Graph(store="SQLAlchemy", identifier=ident)
rt = g.open(self.uri, create=True)
if rt == NO_STORE:
g.open(self.uri, create=True)
else:
assert rt == VALID_STORE, "The underlying store is corrupt"
g.destroy(self.uri)
class TestBDBTransactions(unittest.TestCase):
non_core = True
def setUp(self):
self.graph = ConjunctiveGraph(store="BerkeleyDB")
self.path = mkdtemp()
self.graph.open(self.path, create=True)
def tearDown(self):
self.graph.close()
def get_context(self, identifier):
assert isinstance(identifier, URIRef) or \
isinstance(identifier, BNode), type(identifier)
return Graph(store=self.graph.store, identifier=identifier,
namespace_manager=self)
def __manyOpsManyThreads(self, worker, workers=10, triples=1000, input=[]):
all_ops = []
pool = []
for i in range(0, workers):
t = Thread(target=worker, args=(all_ops, self.graph, triples), kwargs={'input':input})
pool.append(t)
t.start()
for t in pool:
t.join()
return all_ops
def testAddManyManyThreads(self):
# TODO: sometimes this test leads to TypeError exceptions?
w = 4
t = 1000
self.__manyOpsManyThreads(worker_add, workers=w, triples=t)
#print "graph size after finish: ", len(self.graph)
self.failUnless(len(self.graph) == w*t)
def testRemove(self):
ops = self.__manyOpsManyThreads(worker_add, workers=1, triples=10)
self.__manyOpsManyThreads(worker_remove, workers=1, triples=7, input=ops)
#print "graph size after finish: ", len(self.graph)
self.failUnless(len(self.graph) == 3)
def testRemoveAll(self):
ops = self.__manyOpsManyThreads(worker_add, workers=1, triples=10)
try:
self.graph.remove((None, None, None))
except Exception, e:
#print "Could not remove all: ", e
raise e
#print "graph size after finish: ", len(self.graph)
self.failUnless(len(self.graph) == 0)
class TestBDBOptimized:
non_core = True
bsddb = True
def setUp(self):
self.graph = ConjunctiveGraph(store="BDBOptimized")
self.path = mkdtemp()
self.graph.open(self.path, create=True)
def tearDown(self):
self.graph.close()
def test_issue_4(self):
from rdflib.graph import ConjunctiveGraph as Graph
from rdflib.store import NO_STORE, VALID_STORE
from rdflib.term import URIRef
ident = URIRef("rdflib_test")
g = Graph(store="SQLAlchemy", identifier=ident)
rt = g.open(self.uri, create=True)
if rt == NO_STORE:
g.open(self.uri, create=True)
else:
assert rt == VALID_STORE, "The underlying store is corrupt"
g.destroy(self.uri)
def test_issue_4(self):
from rdflib.graph import ConjunctiveGraph as Graph
from rdflib.store import NO_STORE, VALID_STORE
from rdflib.term import URIRef
ident = URIRef("rdflib_test")
g = Graph(store="SQLAlchemy", identifier=ident)
rt = g.open(self.uri, create=True)
if rt == NO_STORE:
g.open(self.uri, create=True)
else:
assert rt == VALID_STORE, "The underlying store is corrupt"
g.destroy(self.uri)
def init_store(path):
"""
Initialize the Conjunctive Graph
"""
global store
if store is not None:
raise RuntimeError("Don't initialize the graph more than once")
store = plugin.get('Sleepycat', Store)('rdfstore')
graph = ConjunctiveGraph(store=store, identifier=graph_uri)
rt = graph.open(path)
if rt == NO_STORE:
graph.open(path, create=True)
else:
assert rt == VALID_STORE
def rdf_description(name, notation='xml' ):
"""
Funtion takes title of node, and rdf notation.
"""
valid_formats = ["xml", "n3", "ntriples", "trix"]
default_graph_uri = "http://gstudio.gnowledge.org/rdfstore"
configString = "/var/tmp/rdfstore"
# Get the Sleepycat plugin.
store = plugin.get('Sleepycat', Store)('rdfstore')
# Open previously created store, or create it if it doesn't exist yet
graph = Graph(store="Sleepycat",
identifier = URIRef(default_graph_uri))
path = mkdtemp()
rt = graph.open(path, create=False)
if rt == NO_STORE:
#There is no underlying Sleepycat infrastructure, create it
graph.open(path, create=True)
else:
assert rt == VALID_STORE, "The underlying store is corrupt"
# Now we'll add some triples to the graph & commit the changes
rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
graph.bind("gstudio", "http://gnowledge.org/")
exclusion_fields = ["id", "rght", "node_ptr_id", "image", "lft", "_state", "_altnames_cache", "_tags_cache", "nid_ptr_id", "_mptt_cached_fields"]
node=Objecttype.objects.get(title=name)
node_dict=node.__dict__
subject=str(node_dict['id'])
for key in node_dict:
if key not in exclusion_fields:
predicate=str(key)
pobject=str(node_dict[predicate])
graph.add((rdflib[subject], rdflib[predicate], Literal(pobject)))
graph.commit()
print graph.serialize(format=notation)
graph.close()
def rdf_description(name, notation='xml'):
"""
Funtion takes title of node, and rdf notation.
"""
valid_formats = ["xml", "n3", "ntriples", "trix"]
default_graph_uri = "http://gstudio.gnowledge.org/rdfstore"
configString = "/var/tmp/rdfstore"
# Get the Sleepycat plugin.
store = plugin.get('Sleepycat', Store)('rdfstore')
# Open previously created store, or create it if it doesn't exist yet
graph = Graph(store="Sleepycat", identifier=URIRef(default_graph_uri))
path = mkdtemp()
rt = graph.open(path, create=False)
if rt == NO_STORE:
#There is no underlying Sleepycat infrastructure, create it
graph.open(path, create=True)
else:
assert rt == VALID_STORE, "The underlying store is corrupt"
# Now we'll add some triples to the graph & commit the changes
rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
graph.bind("gstudio", "http://gnowledge.org/")
exclusion_fields = [
"id", "rght", "node_ptr_id", "image", "lft", "_state",
"_altnames_cache", "_tags_cache", "nid_ptr_id", "_mptt_cached_fields"
]
node = Objecttype.objects.get(title=name)
node_dict = node.__dict__
subject = str(node_dict['id'])
for key in node_dict:
if key not in exclusion_fields:
predicate = str(key)
pobject = str(node_dict[predicate])
graph.add((rdflib[subject], rdflib[predicate], Literal(pobject)))
graph.commit()
print graph.serialize(format=notation)
graph.close()
def test_graph_update(self):
graph = ConjunctiveGraph("SPARQLUpdateStore")
graph.open((self.query_endpoint, self.update_endpoint))
update_statement = f"INSERT DATA {{ {EG['subj']} {EG['pred']} {EG['obj']}. }}"
self.httpmock.do_post_responses.append(
MockHTTPResponse(
200,
"OK",
b"Update succeeded",
{"Content-Type": ["text/plain; charset=UTF-8"]},
))
# This test assumes that updates are performed using POST
# at the moment this is the only supported way for SPARQLUpdateStore
# to do updates.
graph.update(update_statement)
self.assertEqual(self.httpmock.call_count, 1)
req = self.httpmock.do_post_requests.pop(0)
self.assertEqual(req.parsed_path.path, self.update_path)
self.assertIn("application/sparql-update",
req.headers.get("content-type"))
def get_conjunctive_graph(store_id=None):
"""
Returns an open conjunctive graph.
"""
if not store_id:
store_id = DEFAULT_STORE
store = DjangoStore(DEFAULT_STORE)
graph = ConjunctiveGraph(store=store, identifier=store_id)
if graph.open(None) != VALID_STORE:
raise ValueError(
"The store identified by {0} is not a valid store".format(
store_id))
return graph
class TestIssue11(unittest.TestCase):
debug = True
def setUp(self):
self.graph = ConjunctiveGraph(store="SQLite")
fp, path = tempfile.mkstemp(suffix='.sqlite')
self.graph.open(path, create=True)
def testSPARQL_SQLite_lessthan_filter_a(self):
self.graph.parse(data=testgraph1, format="n3", publicID=NS)
rt = self.graph.query(good_testquery,
initNs={'rdf': RDF, 'xsd': XSD}, DEBUG=True)
# rt = self.graph.query(good_testquery, DEBUG=True)
# assert str(list(rt)[0][0]) == "http://example.org/bar", list(rt)
assert len(list(rt)) == 1, list(rt)
def testSPARQL_SQLite_lessthan_filter_b(self):
self.graph.parse(data=testgraph2, format="n3", publicID=NS)
# Counter-example demo
rt = self.graph.query(bad_testquery,
initNs={'rdf': RDF, 'xsd': XSD}, DEBUG=True)
# rt = self.graph.query(bad_testquery, DEBUG=True)
assert len(list(rt)) == 3, list(rt)
def open_graph(self):
graph = ConjunctiveGraph(store='hstore')
graph.open(connection_uri, create=True)
self.graphs.append(graph)
return graph
class ContextTestCase(unittest.TestCase):
#store = 'Memory'
store = 'default'
slow = True
tmppath = None
def setUp(self):
self.graph = ConjunctiveGraph(store=self.store)
if self.store == "MySQL":
from mysql import configString
from rdflib.store.MySQL import MySQL
path = configString
MySQL().destroy(path)
else:
self.tmppath = mkdtemp()
self.graph.open(self.tmppath, create=True)
self.michel = URIRef(u'michel')
self.tarek = URIRef(u'tarek')
self.bob = URIRef(u'bob')
self.likes = URIRef(u'likes')
self.hates = URIRef(u'hates')
self.pizza = URIRef(u'pizza')
self.cheese = URIRef(u'cheese')
self.c1 = URIRef(u'context-1')
self.c2 = URIRef(u'context-2')
# delete the graph for each test!
self.graph.remove((None, None, None))
def tearDown(self):
self.graph.close()
shutil.rmtree(self.tmppath)
def get_context(self, identifier):
assert isinstance(identifier, URIRef) or \
isinstance(identifier, BNode), type(identifier)
return Graph(store=self.graph.store,
identifier=identifier,
namespace_manager=self)
def addStuff(self):
tarek = self.tarek
michel = self.michel
bob = self.bob
likes = self.likes
hates = self.hates
pizza = self.pizza
cheese = self.cheese
c1 = self.c1
graph = Graph(self.graph.store, c1)
graph.add((tarek, likes, pizza))
graph.add((tarek, likes, cheese))
graph.add((michel, likes, pizza))
graph.add((michel, likes, cheese))
graph.add((bob, likes, cheese))
graph.add((bob, hates, pizza))
graph.add((bob, hates, michel)) # gasp!
def removeStuff(self):
tarek = self.tarek
michel = self.michel
bob = self.bob
likes = self.likes
hates = self.hates
pizza = self.pizza
cheese = self.cheese
c1 = self.c1
graph = Graph(self.graph.store, c1)
graph.remove((tarek, likes, pizza))
graph.remove((tarek, likes, cheese))
graph.remove((michel, likes, pizza))
graph.remove((michel, likes, cheese))
graph.remove((bob, likes, cheese))
graph.remove((bob, hates, pizza))
graph.remove((bob, hates, michel)) # gasp!
def addStuffInMultipleContexts(self):
c1 = self.c1
c2 = self.c2
triple = (self.pizza, self.hates, self.tarek) # revenge!
# add to default context
self.graph.add(triple)
# add to context 1
graph = Graph(self.graph.store, c1)
graph.add(triple)
# add to context 2
graph = Graph(self.graph.store, c2)
graph.add(triple)
def testConjunction(self):
self.addStuffInMultipleContexts()
triple = (self.pizza, self.likes, self.pizza)
# add to context 1
graph = Graph(self.graph.store, self.c1)
graph.add(triple)
self.assertEquals(len(self.graph), len(graph))
def testAdd(self):
self.addStuff()
def testRemove(self):
self.addStuff()
self.removeStuff()
def testLenInOneContext(self):
c1 = self.c1
# make sure context is empty
self.graph.remove_context(self.get_context(c1))
graph = Graph(self.graph.store, c1)
oldLen = len(self.graph)
for i in range(0, 10):
graph.add((BNode(), self.hates, self.hates))
self.assertEquals(len(graph), oldLen + 10)
self.assertEquals(len(self.get_context(c1)), oldLen + 10)
self.graph.remove_context(self.get_context(c1))
self.assertEquals(len(self.graph), oldLen)
self.assertEquals(len(graph), 0)
def testLenInMultipleContexts(self):
oldLen = len(self.graph)
self.addStuffInMultipleContexts()
# addStuffInMultipleContexts is adding the same triple to
# three different contexts. So it's only + 1
self.assertEquals(len(self.graph), oldLen + 1)
graph = Graph(self.graph.store, self.c1)
self.assertEquals(len(graph), oldLen + 1)
def testRemoveInMultipleContexts(self):
c1 = self.c1
c2 = self.c2
triple = (self.pizza, self.hates, self.tarek) # revenge!
self.addStuffInMultipleContexts()
# triple should be still in store after removing it from c1 + c2
self.assert_(triple in self.graph)
graph = Graph(self.graph.store, c1)
graph.remove(triple)
self.assert_(triple in self.graph)
graph = Graph(self.graph.store, c2)
graph.remove(triple)
self.assert_(triple in self.graph)
self.graph.remove(triple)
# now gone!
self.assert_(triple not in self.graph)
# add again and see if remove without context removes all triples!
self.addStuffInMultipleContexts()
self.graph.remove(triple)
self.assert_(triple not in self.graph)
def testContexts(self):
triple = (self.pizza, self.hates, self.tarek) # revenge!
self.addStuffInMultipleContexts()
def cid(c):
return c.identifier
self.assert_(self.c1 in map(cid, self.graph.contexts()))
self.assert_(self.c2 in map(cid, self.graph.contexts()))
contextList = map(cid, list(self.graph.contexts(triple)))
self.assert_(self.c1 in contextList)
self.assert_(self.c2 in contextList)
def testRemoveContext(self):
c1 = self.c1
self.addStuffInMultipleContexts()
self.assertEquals(len(Graph(self.graph.store, c1)), 1)
self.assertEquals(len(self.get_context(c1)), 1)
self.graph.remove_context(self.get_context(c1))
self.assert_(self.c1 not in self.graph.contexts())
def testRemoveAny(self):
Any = None
self.addStuffInMultipleContexts()
self.graph.remove((Any, Any, Any))
self.assertEquals(len(self.graph), 0)
def testTriples(self):
tarek = self.tarek
michel = self.michel
bob = self.bob
likes = self.likes
hates = self.hates
pizza = self.pizza
cheese = self.cheese
c1 = self.c1
asserte = self.assertEquals
triples = self.graph.triples
graph = self.graph
c1graph = Graph(self.graph.store, c1)
c1triples = c1graph.triples
Any = None
self.addStuff()
# unbound subjects with context
asserte(len(list(c1triples((Any, likes, pizza)))), 2)
asserte(len(list(c1triples((Any, hates, pizza)))), 1)
asserte(len(list(c1triples((Any, likes, cheese)))), 3)
asserte(len(list(c1triples((Any, hates, cheese)))), 0)
# unbound subjects without context, same results!
asserte(len(list(triples((Any, likes, pizza)))), 2)
asserte(len(list(triples((Any, hates, pizza)))), 1)
asserte(len(list(triples((Any, likes, cheese)))), 3)
asserte(len(list(triples((Any, hates, cheese)))), 0)
# unbound objects with context
asserte(len(list(c1triples((michel, likes, Any)))), 2)
asserte(len(list(c1triples((tarek, likes, Any)))), 2)
asserte(len(list(c1triples((bob, hates, Any)))), 2)
asserte(len(list(c1triples((bob, likes, Any)))), 1)
# unbound objects without context, same results!
asserte(len(list(triples((michel, likes, Any)))), 2)
asserte(len(list(triples((tarek, likes, Any)))), 2)
asserte(len(list(triples((bob, hates, Any)))), 2)
asserte(len(list(triples((bob, likes, Any)))), 1)
# unbound predicates with context
asserte(len(list(c1triples((michel, Any, cheese)))), 1)
asserte(len(list(c1triples((tarek, Any, cheese)))), 1)
asserte(len(list(c1triples((bob, Any, pizza)))), 1)
asserte(len(list(c1triples((bob, Any, michel)))), 1)
# unbound predicates without context, same results!
asserte(len(list(triples((michel, Any, cheese)))), 1)
asserte(len(list(triples((tarek, Any, cheese)))), 1)
asserte(len(list(triples((bob, Any, pizza)))), 1)
asserte(len(list(triples((bob, Any, michel)))), 1)
# unbound subject, objects with context
asserte(len(list(c1triples((Any, hates, Any)))), 2)
asserte(len(list(c1triples((Any, likes, Any)))), 5)
# unbound subject, objects without context, same results!
asserte(len(list(triples((Any, hates, Any)))), 2)
asserte(len(list(triples((Any, likes, Any)))), 5)
# unbound predicates, objects with context
asserte(len(list(c1triples((michel, Any, Any)))), 2)
asserte(len(list(c1triples((bob, Any, Any)))), 3)
asserte(len(list(c1triples((tarek, Any, Any)))), 2)
# unbound predicates, objects without context, same results!
asserte(len(list(triples((michel, Any, Any)))), 2)
asserte(len(list(triples((bob, Any, Any)))), 3)
asserte(len(list(triples((tarek, Any, Any)))), 2)
# unbound subjects, predicates with context
asserte(len(list(c1triples((Any, Any, pizza)))), 3)
asserte(len(list(c1triples((Any, Any, cheese)))), 3)
asserte(len(list(c1triples((Any, Any, michel)))), 1)
# unbound subjects, predicates without context, same results!
asserte(len(list(triples((Any, Any, pizza)))), 3)
asserte(len(list(triples((Any, Any, cheese)))), 3)
asserte(len(list(triples((Any, Any, michel)))), 1)
# all unbound with context
asserte(len(list(c1triples((Any, Any, Any)))), 7)
# all unbound without context, same result!
asserte(len(list(triples((Any, Any, Any)))), 7)
for c in [graph, self.get_context(c1)]:
# unbound subjects
asserte(set(c.subjects(likes, pizza)), set((michel, tarek)))
asserte(set(c.subjects(hates, pizza)), set((bob, )))
asserte(set(c.subjects(likes, cheese)), set([tarek, bob, michel]))
asserte(set(c.subjects(hates, cheese)), set())
# unbound objects
asserte(set(c.objects(michel, likes)), set([cheese, pizza]))
asserte(set(c.objects(tarek, likes)), set([cheese, pizza]))
asserte(set(c.objects(bob, hates)), set([michel, pizza]))
asserte(set(c.objects(bob, likes)), set([cheese]))
# unbound predicates
asserte(set(c.predicates(michel, cheese)), set([likes]))
asserte(set(c.predicates(tarek, cheese)), set([likes]))
asserte(set(c.predicates(bob, pizza)), set([hates]))
asserte(set(c.predicates(bob, michel)), set([hates]))
asserte(set(c.subject_objects(hates)),
set([(bob, pizza), (bob, michel)]))
asserte(
set(c.subject_objects(likes)),
set([(tarek, cheese), (michel, cheese), (michel, pizza),
(bob, cheese), (tarek, pizza)]))
asserte(set(c.predicate_objects(michel)),
set([(likes, cheese), (likes, pizza)]))
asserte(set(c.predicate_objects(bob)),
set([(likes, cheese), (hates, pizza), (hates, michel)]))
asserte(set(c.predicate_objects(tarek)),
set([(likes, cheese), (likes, pizza)]))
asserte(set(c.subject_predicates(pizza)),
set([(bob, hates), (tarek, likes), (michel, likes)]))
asserte(set(c.subject_predicates(cheese)),
set([(bob, likes), (tarek, likes), (michel, likes)]))
asserte(set(c.subject_predicates(michel)), set([(bob, hates)]))
asserte(
set(c),
set([(bob, hates, michel), (bob, likes, cheese),
(tarek, likes, pizza), (michel, likes, pizza),
(michel, likes, cheese), (bob, hates, pizza),
(tarek, likes, cheese)]))
# remove stuff and make sure the graph is empty again
self.removeStuff()
asserte(len(list(c1triples((Any, Any, Any)))), 0)
asserte(len(list(triples((Any, Any, Any)))), 0)
def rdf_all(notation='xml'):
"""
Funtion takes title of node, and rdf notation.
"""
valid_formats = ["xml", "n3", "ntriples", "trix"]
default_graph_uri = "http://gstudio.gnowledge.org/rdfstore"
configString = "/var/tmp/rdfstore"
# Get the IOMemory plugin.
store = plugin.get('IOMemory', Store)('rdfstore')
# Open previously created store, or create it if it doesn't exist yet
graph = Graph(store="IOMemory",
identifier = URIRef(default_graph_uri))
path = mkdtemp()
rt = graph.open(path, create=False)
if rt == NO_STORE:
graph.open(path, create=True)
else:
assert rt == VALID_STORE, "The underlying store is corrupt"
# Now we'll add some triples to the graph & commit the changes
graph.bind("gstudio", "http://gnowledge.org/")
exclusion_fields = ["id", "rght", "node_ptr_id", "image", "lft", "_state", "_altnames_cache", "_tags_cache", "nid_ptr_id", "_mptt_cached_fields"]
for node in NID.objects.all():
node_dict=node.ref.__dict__
node_type = node.reftype
try:
if (node_type=='Gbobject'):
node=Gbobject.objects.get(title=node)
elif (node_type=='None'):
node=Gbobject.objects.get(title=node)
elif (node_type=='Processes'):
node=Gbobject.objects.get(title=node)
elif (node_type=='System'):
node=Gbobject.objects.get(title=node)
rdflib=link(node)
url_addr=link1(node)
a=fstore_dump(url_addr)
elif (node_type=='Objecttype'):
node=Objecttype.objects.get(title=node)
elif (node_type=='Attributetype'):
node=Attributetype.objects.get(title=node)
elif (node_type=='Complement'):
node=Complement.objects.get(title=node)
elif (node_type=='Union'):
node=Union.objects.get(title=node)
elif (node_type=='Intersection'):
node=Intersection.objects.get(title=node)
elif (node_type=='Expression'):
node=Expression.objects.get(title=node)
elif (node_type=='Processtype'):
node=Processtype.objects.get(title=node)
elif (node_type=='Systemtype'):
node=Systemtype.objects.get(title=node)
elif (node_type=='AttributeSpecification'):
node=AttributeSpecification.objects.get(title=node)
elif (node_type=='RelationSpecification'):
node=RelationSpecification.objects.get(title=node)
rdflib=link(node)
url_addr=link1(node)
a=fstore_dump(url_addr)
if(node_type=='Attribute'):
node=Attribute.objects.get(title=node)
rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
elif(node_type=='Relationtype' ):
node=Relationtype.objects.get(title=node)
rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
elif(node_type=='Metatype'):
node=Metatype.objects.get(title=node)
rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
url_addr='http://sbox.gnowledge.org/gstudio/'
a=fstore_dump(url_addr)
except:
if(node_type=='Attribute'):
rdflib= Namespace('http://sbox.gnowledge.org/gstudio/')
if(node_type=='Relationtype' ):
rdflib= Namespace('http://sbox.gnowledge.org/gstudio/')
if(node_type=='Metatype'):
rdflib= Namespace('http://sbox.gnowledge.org/gstudio/')
subject=str(node_dict['id'])
for key in node_dict:
if key not in exclusion_fields:
predicate=str(key)
pobject=str(node_dict[predicate])
graph.add((rdflib[subject], rdflib[predicate], Literal(pobject)))
rdf_code=graph.serialize(format=notation)
#path to store the rdf in a file
#x = os.path.join(os.path.dirname(__file__), 'rdffiles.rdf')
graph.commit()
graph.close()
import rdflib
from rdflib.graph import ConjunctiveGraph as Graph
#from rdflib.graph import Graph
configString = "/tmp/rdfstore12"
graph = Graph(store="KyotoCabinet")
print graph.store
path = configString
rt = graph.open(path, create=False)
print "Triples in graph: ", len(graph)
print "first 20 are as follows:"
i=20
for subj, pred, obj in graph:
print(subj, pred, obj)
i-=1
if i==0:
break
graph.close()
class TestLevelDBConjunctiveGraphCore(unittest.TestCase):
def setUp(self):
store = "LevelDB"
self.graph = ConjunctiveGraph(store=store)
self.path = configString
self.graph.open(self.path, create=True)
def tearDown(self):
self.graph.destroy(self.path)
try:
self.graph.close()
except:
pass
if getattr(self, 'path', False) and self.path is not None:
if os.path.exists(self.path):
if os.path.isdir(self.path):
for f in os.listdir(self.path):
os.unlink(self.path + '/' + f)
os.rmdir(self.path)
elif len(self.path.split(':')) == 1:
os.unlink(self.path)
else:
os.remove(self.path)
def test_namespaces(self):
self.graph.bind("dc", "http://http://purl.org/dc/elements/1.1/")
self.graph.bind("foaf", "http://xmlns.com/foaf/0.1/")
self.assert_(len(list(self.graph.namespaces())) == 5)
self.assert_(('foaf', rdflib.term.URIRef(u'http://xmlns.com/foaf/0.1/')
) in list(self.graph.namespaces()))
def test_readable_index(self):
print(readable_index(111))
def test_triples_context_reset(self):
michel = rdflib.URIRef(u'michel')
likes = rdflib.URIRef(u'likes')
pizza = rdflib.URIRef(u'pizza')
cheese = rdflib.URIRef(u'cheese')
self.graph.add((michel, likes, pizza))
self.graph.add((michel, likes, cheese))
self.graph.commit()
ntriples = self.graph.triples((None, None, None),
context=self.graph.store)
self.assert_(len(list(ntriples)) == 2)
def test_remove_context_reset(self):
michel = rdflib.URIRef(u'michel')
likes = rdflib.URIRef(u'likes')
pizza = rdflib.URIRef(u'pizza')
cheese = rdflib.URIRef(u'cheese')
self.graph.add((michel, likes, pizza))
self.graph.add((michel, likes, cheese))
self.graph.commit()
self.graph.store.remove((michel, likes, cheese), self.graph.store)
self.graph.commit()
self.assert_(
len(
list(
self.graph.triples((None, None, None),
context=self.graph.store))) == 1)
def test_remove_db_exception(self):
michel = rdflib.URIRef(u'michel')
likes = rdflib.URIRef(u'likes')
pizza = rdflib.URIRef(u'pizza')
cheese = rdflib.URIRef(u'cheese')
self.graph.add((michel, likes, pizza))
self.graph.add((michel, likes, cheese))
self.graph.commit()
self.graph.store.__len__(context=self.graph.store)
self.assert_(
len(
list(
self.graph.triples((None, None, None),
context=self.graph.store))) == 2)
def rdf_description(notation='xml'):
"""
Funtion takes title of node, and rdf notation.
"""
name = 'student'
valid_formats = ["xml", "n3", "ntriples", "trix"]
default_graph_uri = "http://gstudio.gnowledge.org/rdfstore"
# default_graph_uri = "http://example.com/"
configString = "/var/tmp/rdfstore"
# Get the Sleepycat plugin.
store = plugin.get('IOMemory', Store)('rdfstore')
# Open previously created store, or create it if it doesn't exist yet
graph = Graph(store="IOMemory", identifier=URIRef(default_graph_uri))
path = mkdtemp()
rt = graph.open(path, create=False)
if rt == NO_STORE:
#There is no underlying Sleepycat infrastructure, create it
graph.open(path, create=True)
else:
assert rt == VALID_STORE, "The underlying store is corrupt"
# Now we'll add some triples to the graph & commit the changes
# rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
graph.bind("gstudio", "http://gnowledge.org/")
exclusion_fields = [
"id", "rght", "node_ptr_id", "image", "lft", "_state",
"_altnames_cache", "_tags_cache", "nid_ptr_id", "_mptt_cached_fields"
]
node_type = get_nodetype()
if (node_type == 'gbobject'):
node = Gbobject.objects.get(title=name)
elif (node_type == 'objecttype'):
node = Objecttype.objects.get(title=name)
elif (node_type == 'metatype'):
node = Metatype.objects.get(title=name)
elif (node_type == 'attributetype'):
node = Attributetype.objects.get(title=name)
elif (node_type == 'relationtype'):
node = Relationtype.objects.get(title=name)
elif (node_type == 'attribute'):
node = Attribute.objects.get(title=name)
elif (node_type == 'complement'):
node = Complement.objects.get(title=name)
elif (node_type == 'union'):
node = Union.objects.get(title=name)
elif (node_type == 'intersection'):
node = Intersection.objects.get(title=name)
elif (node_type == 'expression'):
node = Expression.objects.get(title=name)
elif (node_type == 'processtype'):
node = Processtype.objects.get(title=name)
elif (node_type == 'systemtype'):
node = Systemtype.objects.get(title=name)
node_url = node.get_absolute_url()
site_add = node.sites.all()
a = site_add[0]
host_name = a.name
#host_name=name
link = 'http://'
#Concatenating the above variables will give the url address.
url_add = link + host_name + node_url
rdflib = Namespace(url_add)
# node=Objecttype.objects.get(title=name)
node_dict = node.__dict__
subject = str(node_dict['id'])
for key in node_dict:
if key not in exclusion_fields:
predicate = str(key)
pobject = str(node_dict[predicate])
graph.add((rdflib[subject], rdflib[predicate], Literal(pobject)))
rdf_code = graph.serialize(format=notation)
#graph = rdflib.Graph("IOMemory")
#graph.open("store", create=True)
#graph.parse(rdf_code)
# print out all the triples in the graph
# for subject, predicate, object in graph:
# print subject, predicate, object
# store.add(self,(subject, predicate, object),context)
graph.commit()
print rdf_code
graph.close()
#!/usr/bin/env python
from rdflib.graph import ConjunctiveGraph
from rdflib.namespace import Namespace
dct = Namespace('http://purl.org/dc/terms/')
g = ConjunctiveGraph('Sleepycat')
g.open('store')
subjects = {}
for o in g.objects(predicate=dct['subject']):
sub = o.split('/')[-1]
subjects[sub] = subjects.get(sub, 0) + 1
sorted_keys = subjects.keys()
sorted_keys.sort(lambda a, b: cmp(subjects[b], subjects[a]))
for subject in sorted_keys:
print subject, "\t", subjects[subject]
def rdf_description(notation='xml' ):
"""
Funtion takes title of node, and rdf notation.
"""
name='student'
valid_formats = ["xml", "n3", "ntriples", "trix"]
default_graph_uri = "http://gstudio.gnowledge.org/rdfstore"
# default_graph_uri = "http://example.com/"
configString = "/var/tmp/rdfstore"
# Get the Sleepycat plugin.
store = plugin.get('IOMemory', Store)('rdfstore')
# Open previously created store, or create it if it doesn't exist yet
graph = Graph(store="IOMemory",
identifier = URIRef(default_graph_uri))
path = mkdtemp()
rt = graph.open(path, create=False)
if rt == NO_STORE:
#There is no underlying Sleepycat infrastructure, create it
graph.open(path, create=True)
else:
assert rt == VALID_STORE, "The underlying store is corrupt"
# Now we'll add some triples to the graph & commit the changes
# rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
graph.bind("gstudio", "http://gnowledge.org/")
exclusion_fields = ["id", "rght", "node_ptr_id", "image", "lft", "_state", "_altnames_cache", "_tags_cache", "nid_ptr_id", "_mptt_cached_fields"]
node_type=get_nodetype()
if (node_type=='gbobject'):
node=Gbobject.objects.get(title=name)
elif (node_type=='objecttype'):
node=Objecttype.objects.get(title=name)
elif (node_type=='metatype'):
node=Metatype.objects.get(title=name)
elif (node_type=='attributetype'):
node=Attributetype.objects.get(title=name)
elif (node_type=='relationtype'):
node=Relationtype.objects.get(title=name)
elif (node_type=='attribute'):
node=Attribute.objects.get(title=name)
elif (node_type=='complement'):
node=Complement.objects.get(title=name)
elif (node_type=='union'):
node=Union.objects.get(title=name)
elif (node_type=='intersection'):
node=Intersection.objects.get(title=name)
elif (node_type=='expression'):
node=Expression.objects.get(title=name)
elif (node_type=='processtype'):
node=Processtype.objects.get(title=name)
elif (node_type=='systemtype'):
node=Systemtype.objects.get(title=name)
node_url=node.get_absolute_url()
site_add= node.sites.all()
a = site_add[0]
host_name =a.name
#host_name=name
link='http://'
#Concatenating the above variables will give the url address.
url_add=link+host_name+node_url
rdflib = Namespace(url_add)
# node=Objecttype.objects.get(title=name)
node_dict=node.__dict__
subject=str(node_dict['id'])
for key in node_dict:
if key not in exclusion_fields:
predicate=str(key)
pobject=str(node_dict[predicate])
graph.add((rdflib[subject], rdflib[predicate], Literal(pobject)))
rdf_code=graph.serialize(format=notation)
#graph = rdflib.Graph("IOMemory")
#graph.open("store", create=True)
#graph.parse(rdf_code)
# print out all the triples in the graph
# for subject, predicate, object in graph:
# print subject, predicate, object
# store.add(self,(subject, predicate, object),context)
graph.commit()
print rdf_code
graph.close()
def rdf_description(name, notation='xml'):
"""
Funtion takes title of node, and rdf notation.
"""
valid_formats = ["xml", "n3", "ntriples", "trix"]
default_graph_uri = "http://gstudio.gnowledge.org/rdfstore"
# default_graph_uri = "http://example.com/"
configString = "/var/tmp/rdfstore"
# Get the IOMemory plugin.
store = plugin.get('IOMemory', Store)('rdfstore')
# Open previously created store, or create it if it doesn't exist yet
graph = Graph(store="IOMemory", identifier=URIRef(default_graph_uri))
path = mkdtemp()
rt = graph.open(path, create=False)
if rt == NO_STORE:
graph.open(path, create=True)
else:
assert rt == VALID_STORE, "The underlying store is corrupt"
# Now we'll add some triples to the graph & commit the changes
#rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
graph.bind("gstudio", "http://gnowledge.org/")
exclusion_fields = [
"id", "rght", "node_ptr_id", "image", "lft", "_state",
"_altnames_cache", "_tags_cache", "nid_ptr_id", "_mptt_cached_fields"
]
#verifies the type of node
node = NID.objects.get(title=name)
node_type = node.reftype
if (node_type == 'Gbobject'):
node = Gbobject.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'None'):
node = Gbobject.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'Processes'):
node = Gbobject.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'System'):
node = Gbobject.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'Objecttype'):
node = Objecttype.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'Attributetype'):
node = Attributetype.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'Complement'):
node = Complement.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'Union'):
node = Union.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'Intersection'):
node = Intersection.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'Expression'):
node = Expression.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'Processtype'):
node = Processtype.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'Systemtype'):
node = Systemtype.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'AttributeSpecification'):
node = AttributeSpecification.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'RelationSpecification'):
node = RelationSpecification.objects.get(title=name)
rdflib = link(node)
elif (node_type == 'Attribute'):
node = Attribute.objects.get(title=name)
rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
elif (node_type == 'Relationtype'):
node = Relationtype.objects.get(title=name)
rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
elif (node_type == 'Metatype'):
node = Metatype.objects.get(title=name)
rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
else:
rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
node_dict = node.__dict__
subject = str(node_dict['id'])
for key in node_dict:
if key not in exclusion_fields:
predicate = str(key)
pobject = str(node_dict[predicate])
graph.add((rdflib[subject], rdflib[predicate], Literal(pobject)))
rdf_code = graph.serialize(format=notation)
graph.commit()
print rdf_code
graph.close()
def testFormulaStore(store="default", configString=None):
try:
g = ConjunctiveGraph(store=store)
except ImportError:
raise SkipTest("Dependencies for store '%s' not available!" % store)
if configString:
g.destroy(configString)
g.open(configString)
else:
if store == 'SQLite':
_, path = mkstemp(prefix='test', dir='/tmp', suffix='.sqlite')
g.open(path, create=True)
else:
g.open(mkdtemp(), create=True)
g.parse(data=testN3, format="n3")
try:
for s, p, o in g.triples((None, implies, None)):
formulaA = s
formulaB = o
assert type(formulaA) == QuotedGraph and type(formulaB) == QuotedGraph
# a = URIRef('http://test/a')
b = URIRef('http://test/b')
c = URIRef('http://test/c')
d = URIRef('http://test/d')
v = Variable('y')
universe = ConjunctiveGraph(g.store)
#test formula as terms
assert len(list(universe.triples((formulaA, implies, formulaB)))) == 1
#test variable as term and variable roundtrip
assert len(list(formulaB.triples((None, None, v)))) == 1
for s, p, o in formulaB.triples((None, d, None)):
if o != c:
assert isinstance(o, Variable)
assert o == v
s = list(universe.subjects(RDF.type, RDFS.Class))[0]
assert isinstance(s, BNode)
assert len(list(universe.triples((None, implies, None)))) == 1
assert len(list(universe.triples((None, RDF.type, None)))) == 1
assert len(list(formulaA.triples((None, RDF.type, None)))) == 1
assert len(list(formulaA.triples((None, None, None)))) == 2
assert len(list(formulaB.triples((None, None, None)))) == 2
assert len(list(universe.triples((None, None, None)))) == 3
assert len(list(formulaB.triples(
(None, URIRef('http://test/d'), None)))) == 2
assert len(list(universe.triples(
(None, URIRef('http://test/d'), None)))) == 1
# #context tests
# #test contexts with triple argument
# assert len(list(universe.contexts((a, d, c)))) == 1, \
# [ct for ct in universe.contexts((a, d, c))]
# FAIL: test.test_graph_formula.testFormulaStores('SQLite',)
# --------------------------------------------------------------------
# Traceback (most recent call last):
# File ".../site-packages/nose/case.py", line 197, in runTest
# self.test(*self.arg)
# File ".../test_graph_formula.py", line 80, in testFormulaStore
# [ct for ct in universe.contexts((a, d, c))]
# AssertionError: [
# <Graph identifier=N52fd4417ef7641089b2e4045ef19ad87
# (<class 'rdflib.graph.Graph'>)>,
# <Graph identifier=_:Formula16 (<class 'rdflib.graph.Graph'>)>
# ]
#Remove test cases
universe.remove((None, implies, None))
assert len(list(universe.triples((None, implies, None)))) == 0
assert len(list(formulaA.triples((None, None, None)))) == 2
assert len(list(formulaB.triples((None, None, None)))) == 2
formulaA.remove((None, b, None))
assert len(list(formulaA.triples((None, None, None)))) == 1
formulaA.remove((None, RDF.type, None))
assert len(list(formulaA.triples((None, None, None)))) == 0
universe.remove((None, RDF.type, RDFS.Class))
#remove_context tests
universe.remove_context(formulaB)
assert len(list(universe.triples((None, RDF.type, None)))) == 0
assert len(universe) == 1
assert len(formulaB) == 0
universe.remove((None, None, None))
assert len(universe) == 0
g.close()
if store == 'SQLite':
os.unlink(path)
else:
g.store.destroy(configString)
except:
g.close()
if store == 'SQLite':
os.unlink(path)
else:
g.store.destroy(configString)
raise
import rdflib
from rdflib.graph import ConjunctiveGraph as Graph
from rdflib import plugin
from rdflib.store import Store
configString = "/tmp/rdfstore"
store = plugin.get('KyotoCabinet', Store)('rdfstore')
graph = Graph(store="KyotoCabinet")
path = configString
rt = graph.open(path, create=True)
print "Triples in graph before add: ", len(graph)
graph.parse("http://130.88.198.11/co-ode-files/ontologies/pizza.owl", format="xml")
for subj, pred, obj in graph:
if (subj, pred, obj) not in graph:
raise Exception("It better be!")
graph.add((subj, pred, obj))
graph.commit()
print "Triples in graph after add: ", len(graph)
graph.close()
def testN3Store(store="default", configString=None):
storetest = True
g = ConjunctiveGraph(store=store)
if configString is not None:
g.destroy(configString)
g.open(configString, create=True)
g.parse(data=testN3, format="n3")
# op = g.serialize(format="n3")
# print(op)
formulaA = BNode()
formulaB = BNode()
try:
for s,p,o in g.triples((None,implies,None)):
formulaA = s
formulaB = o
assert type(formulaA)==QuotedGraph and type(formulaB)==QuotedGraph
a = URIRef('http://test/a')
b = URIRef('http://test/b')
c = URIRef('http://test/c')
d = URIRef('http://test/d')
v = Variable('y')
universe = ConjunctiveGraph(g.store)
#test formula as terms
assert len(list(universe.triples((formulaA,implies,formulaB))))==1
#test variable as term and variable roundtrip
assert len(list(formulaB.triples((None,None,v))))==1
for s,p,o in formulaB.triples((None,d,None)):
if o != c:
assert isinstance(o,Variable)
assert o == v
s = list(universe.subjects(RDF.type, RDFS.Class))[0]
assert isinstance(s,BNode)
assert len(list(universe.triples((None,implies,None)))) == 1
assert len(list(universe.triples((None,RDF.type,None)))) ==1
assert len(list(formulaA.triples((None,RDF.type,None))))==1
assert len(list(formulaA.triples((None,None,None))))==2
assert len(list(formulaB.triples((None,None,None))))==2
assert len(list(universe.triples((None,None,None))))==3
assert len(list(formulaB.triples((None,URIRef('http://test/d'),None))))==2
assert len(list(universe.triples((None,URIRef('http://test/d'),None))))==1
#context tests
#test contexts with triple argument
assert len(list(universe.contexts((a,d,c))))==1
#Remove test cases
universe.remove((None,implies,None))
assert len(list(universe.triples((None,implies,None))))==0
assert len(list(formulaA.triples((None,None,None))))==2
assert len(list(formulaB.triples((None,None,None))))==2
formulaA.remove((None,b,None))
assert len(list(formulaA.triples((None,None,None))))==1
formulaA.remove((None,RDF.type,None))
assert len(list(formulaA.triples((None,None,None))))==0
universe.remove((None,RDF.type,RDFS.Class))
#remove_context tests
universe.remove_context(formulaB)
assert len(list(universe.triples((None,RDF.type,None))))==0
assert len(universe)==1
assert len(formulaB)==0
universe.remove((None,None,None))
assert len(universe)==0
g.store.destroy(configString)
except:
g.store.destroy(configString)
raise
#!/usr/bin/env python
from rdflib.graph import ConjunctiveGraph
import re
g = ConjunctiveGraph("Sleepycat")
g.open("_tmpdb", create=True)
#g.parse("index.html", format='rdfa', lax=True)
#g.parse("index.rdf" )
q1 = 'SELECT distinct ?x FROM <file:index.rdf> WHERE { ?x <http://www.w3.org/2000/01/rdf-schema#isDefinedBy> <http://xmlns.com/foaf/0.1/> } ORDER BY ?x'
#q1 = 'SELECT distinct ?x ?src FROM <file:index.rdf> WHERE { GRAPH ?src { ?x <http://www.w3.org/2000/01/rdf-schema#isDefinedBy> <http://xmlns.com/foaf/0.1/> } } ORDER BY ?x'
i = 1
for x in g.query(q1):
# print "[" , i, "] src ", src, " - ", x
i = i + 1
regexp = re.compile("^(.*/0.1/)\s*(.*)$")
rez = regexp.search(x)
if rez == None:
print "Failed to parse ", x
else:
term = rez.group(2)
print "Redirect 303 /foaf/0.1/" + term + " http://xmlns.com/foaf/spec/"
g.close()
def testFormulaStore(store="default", configString=None):
try:
g = ConjunctiveGraph(store=store)
except ImportError:
raise SkipTest("Dependencies for store '%s' not available!"%store)
if configString:
g.destroy(configString)
g.open(configString)
else:
g.open(mkdtemp(), create=True)
g.parse(data=testN3, format="n3")
print g.store
try:
for s,p,o in g.triples((None,implies,None)):
formulaA = s
formulaB = o
assert type(formulaA)==QuotedGraph and type(formulaB)==QuotedGraph
a = URIRef('http://test/a')
b = URIRef('http://test/b')
c = URIRef('http://test/c')
d = URIRef('http://test/d')
v = Variable('y')
universe = ConjunctiveGraph(g.store)
#test formula as terms
assert len(list(universe.triples((formulaA,implies,formulaB))))==1
#test variable as term and variable roundtrip
assert len(list(formulaB.triples((None,None,v))))==1
for s,p,o in formulaB.triples((None,d,None)):
if o != c:
assert isinstance(o,Variable)
assert o == v
s = list(universe.subjects(RDF.type, RDFS.Class))[0]
assert isinstance(s,BNode)
assert len(list(universe.triples((None,implies,None)))) == 1
assert len(list(universe.triples((None,RDF.type,None)))) ==1
assert len(list(formulaA.triples((None,RDF.type,None))))==1
assert len(list(formulaA.triples((None,None,None))))==2
assert len(list(formulaB.triples((None,None,None))))==2
assert len(list(universe.triples((None,None,None))))==3
assert len(list(formulaB.triples((None,URIRef('http://test/d'),None))))==2
assert len(list(universe.triples((None,URIRef('http://test/d'),None))))==1
#context tests
#test contexts with triple argument
assert len(list(universe.contexts((a,d,c))))==1
#Remove test cases
universe.remove((None,implies,None))
assert len(list(universe.triples((None,implies,None))))==0
assert len(list(formulaA.triples((None,None,None))))==2
assert len(list(formulaB.triples((None,None,None))))==2
formulaA.remove((None,b,None))
assert len(list(formulaA.triples((None,None,None))))==1
formulaA.remove((None,RDF.type,None))
assert len(list(formulaA.triples((None,None,None))))==0
universe.remove((None,RDF.type,RDFS.Class))
#remove_context tests
universe.remove_context(formulaB)
assert len(list(universe.triples((None,RDF.type,None))))==0
assert len(universe)==1
assert len(formulaB)==0
universe.remove((None,None,None))
assert len(universe)==0
g.close()
g.store.destroy(configString)
except:
g.close()
g.store.destroy(configString)
raise
def testN3Store(store="default", configString=None):
storetest = True
del storetest
g = ConjunctiveGraph(store=store)
if configString:
# g.destroy(configString)
g.open(configString, create=True)
g.parse(data=testN3, format="n3")
# op = g.serialize(format="n3")
# print(op)
formulaA = BNode()
formulaB = BNode()
try:
for s, p, o in g.triples((None, implies, None)):
formulaA = s
formulaB = o
assert type(formulaA) == QuotedGraph \
and type(formulaB) == QuotedGraph
a = URIRef('http://test/a')
b = URIRef('http://test/b')
c = URIRef('http://test/c')
d = URIRef('http://test/d')
v = Variable('y')
universe = ConjunctiveGraph(g.store)
#test formula as terms
assert len(list(universe.triples((formulaA, implies, formulaB)))) == 1
#test variable as term and variable roundtrip
assert len(list(formulaB.triples((None, None, v)))) == 1
for s, p, o in formulaB.triples((None, d, None)):
if o != c:
assert isinstance(o, Variable)
assert o == v
s = list(universe.subjects(RDF.type, RDFS.Class))[0]
assert isinstance(s, BNode)
assert len(list(universe.triples((None, implies, None)))) == 1
assert len(list(universe.triples((None, RDF.type, None)))) == 1
assert len(list(formulaA.triples((None, RDF.type, None)))) == 1
assert len(list(formulaA.triples((None, None, None)))) == 2
assert len(list(formulaB.triples((None, None, None)))) == 2
assert len(list(universe.triples((None, None, None)))) == 3
assert len(
list(formulaB.triples((None, URIRef('http://test/d'), None)))) == 2
assert len(
list(universe.triples((None, URIRef('http://test/d'), None)))) == 1
#context tests
#test contexts with triple argument
assert len(list(universe.contexts((a, d, c)))) == 1
#Remove test cases
universe.remove((None, implies, None))
assert len(list(universe.triples((None, implies, None)))) == 0
assert len(list(formulaA.triples((None, None, None)))) == 2
assert len(list(formulaB.triples((None, None, None)))) == 2
formulaA.remove((None, b, None))
assert len(list(formulaA.triples((None, None, None)))) == 1
formulaA.remove((None, RDF.type, None))
assert len(list(formulaA.triples((None, None, None)))) == 0
universe.remove((None, RDF.type, RDFS.Class))
#remove_context tests
universe.remove_context(formulaB)
assert len(list(universe.triples((None, RDF.type, None)))) == 0
assert len(universe) == 1
assert len(formulaB) == 0
universe.remove((None, None, None))
assert len(universe) == 0
g.store.destroy(configString)
except:
g.store.destroy(configString)
raise
class ContextTestCase(unittest.TestCase):
#store = 'Memory'
store = 'default'
slow = True
def setUp(self):
self.graph = ConjunctiveGraph(store=self.store)
if self.store == "MySQL":
from mysql import configString
from rdflib.store.MySQL import MySQL
path=configString
MySQL().destroy(path)
else:
path = a_tmp_dir = mkdtemp()
self.graph.open(path, create=True)
self.michel = URIRef(u'michel')
self.tarek = URIRef(u'tarek')
self.bob = URIRef(u'bob')
self.likes = URIRef(u'likes')
self.hates = URIRef(u'hates')
self.pizza = URIRef(u'pizza')
self.cheese = URIRef(u'cheese')
self.c1 = URIRef(u'context-1')
self.c2 = URIRef(u'context-2')
# delete the graph for each test!
self.graph.remove((None, None, None))
def tearDown(self):
self.graph.close()
def get_context(self, identifier):
assert isinstance(identifier, URIRef) or \
isinstance(identifier, BNode), type(identifier)
return Graph(store=self.graph.store, identifier=identifier,
namespace_manager=self)
def addStuff(self):
tarek = self.tarek
michel = self.michel
bob = self.bob
likes = self.likes
hates = self.hates
pizza = self.pizza
cheese = self.cheese
c1 = self.c1
graph = Graph(self.graph.store, c1)
graph.add((tarek, likes, pizza))
graph.add((tarek, likes, cheese))
graph.add((michel, likes, pizza))
graph.add((michel, likes, cheese))
graph.add((bob, likes, cheese))
graph.add((bob, hates, pizza))
graph.add((bob, hates, michel)) # gasp!
def removeStuff(self):
tarek = self.tarek
michel = self.michel
bob = self.bob
likes = self.likes
hates = self.hates
pizza = self.pizza
cheese = self.cheese
c1 = self.c1
graph = Graph(self.graph.store, c1)
graph.remove((tarek, likes, pizza))
graph.remove((tarek, likes, cheese))
graph.remove((michel, likes, pizza))
graph.remove((michel, likes, cheese))
graph.remove((bob, likes, cheese))
graph.remove((bob, hates, pizza))
graph.remove((bob, hates, michel)) # gasp!
def addStuffInMultipleContexts(self):
c1 = self.c1
c2 = self.c2
triple = (self.pizza, self.hates, self.tarek) # revenge!
# add to default context
self.graph.add(triple)
# add to context 1
graph = Graph(self.graph.store, c1)
graph.add(triple)
# add to context 2
graph = Graph(self.graph.store, c2)
graph.add(triple)
def testConjunction(self):
self.addStuffInMultipleContexts()
triple = (self.pizza, self.likes, self.pizza)
# add to context 1
graph = Graph(self.graph.store, self.c1)
graph.add(triple)
self.assertEquals(len(self.graph), len(graph))
def testAdd(self):
self.addStuff()
def testRemove(self):
self.addStuff()
self.removeStuff()
def testLenInOneContext(self):
c1 = self.c1
# make sure context is empty
self.graph.remove_context(self.get_context(c1))
graph = Graph(self.graph.store, c1)
oldLen = len(self.graph)
for i in range(0, 10):
graph.add((BNode(), self.hates, self.hates))
self.assertEquals(len(graph), oldLen + 10)
self.assertEquals(len(self.get_context(c1)), oldLen + 10)
self.graph.remove_context(self.get_context(c1))
self.assertEquals(len(self.graph), oldLen)
self.assertEquals(len(graph), 0)
def testLenInMultipleContexts(self):
oldLen = len(self.graph)
self.addStuffInMultipleContexts()
# addStuffInMultipleContexts is adding the same triple to
# three different contexts. So it's only + 1
self.assertEquals(len(self.graph), oldLen + 1)
graph = Graph(self.graph.store, self.c1)
self.assertEquals(len(graph), oldLen + 1)
def testRemoveInMultipleContexts(self):
c1 = self.c1
c2 = self.c2
triple = (self.pizza, self.hates, self.tarek) # revenge!
self.addStuffInMultipleContexts()
# triple should be still in store after removing it from c1 + c2
self.assert_(triple in self.graph)
graph = Graph(self.graph.store, c1)
graph.remove(triple)
self.assert_(triple in self.graph)
graph = Graph(self.graph.store, c2)
graph.remove(triple)
self.assert_(triple in self.graph)
self.graph.remove(triple)
# now gone!
self.assert_(triple not in self.graph)
# add again and see if remove without context removes all triples!
self.addStuffInMultipleContexts()
self.graph.remove(triple)
self.assert_(triple not in self.graph)
def testContexts(self):
triple = (self.pizza, self.hates, self.tarek) # revenge!
self.addStuffInMultipleContexts()
def cid(c):
return c.identifier
self.assert_(self.c1 in map(cid, self.graph.contexts()))
self.assert_(self.c2 in map(cid, self.graph.contexts()))
contextList = map(cid, list(self.graph.contexts(triple)))
self.assert_(self.c1 in contextList)
self.assert_(self.c2 in contextList)
def testRemoveContext(self):
c1 = self.c1
self.addStuffInMultipleContexts()
self.assertEquals(len(Graph(self.graph.store, c1)), 1)
self.assertEquals(len(self.get_context(c1)), 1)
self.graph.remove_context(self.get_context(c1))
self.assert_(self.c1 not in self.graph.contexts())
def testRemoveAny(self):
Any = None
self.addStuffInMultipleContexts()
self.graph.remove((Any, Any, Any))
self.assertEquals(len(self.graph), 0)
def testTriples(self):
tarek = self.tarek
michel = self.michel
bob = self.bob
likes = self.likes
hates = self.hates
pizza = self.pizza
cheese = self.cheese
c1 = self.c1
asserte = self.assertEquals
triples = self.graph.triples
graph = self.graph
c1graph = Graph(self.graph.store, c1)
c1triples = c1graph.triples
Any = None
self.addStuff()
# unbound subjects with context
asserte(len(list(c1triples((Any, likes, pizza)))), 2)
asserte(len(list(c1triples((Any, hates, pizza)))), 1)
asserte(len(list(c1triples((Any, likes, cheese)))), 3)
asserte(len(list(c1triples((Any, hates, cheese)))), 0)
# unbound subjects without context, same results!
asserte(len(list(triples((Any, likes, pizza)))), 2)
asserte(len(list(triples((Any, hates, pizza)))), 1)
asserte(len(list(triples((Any, likes, cheese)))), 3)
asserte(len(list(triples((Any, hates, cheese)))), 0)
# unbound objects with context
asserte(len(list(c1triples((michel, likes, Any)))), 2)
asserte(len(list(c1triples((tarek, likes, Any)))), 2)
asserte(len(list(c1triples((bob, hates, Any)))), 2)
asserte(len(list(c1triples((bob, likes, Any)))), 1)
# unbound objects without context, same results!
asserte(len(list(triples((michel, likes, Any)))), 2)
asserte(len(list(triples((tarek, likes, Any)))), 2)
asserte(len(list(triples((bob, hates, Any)))), 2)
asserte(len(list(triples((bob, likes, Any)))), 1)
# unbound predicates with context
asserte(len(list(c1triples((michel, Any, cheese)))), 1)
asserte(len(list(c1triples((tarek, Any, cheese)))), 1)
asserte(len(list(c1triples((bob, Any, pizza)))), 1)
asserte(len(list(c1triples((bob, Any, michel)))), 1)
# unbound predicates without context, same results!
asserte(len(list(triples((michel, Any, cheese)))), 1)
asserte(len(list(triples((tarek, Any, cheese)))), 1)
asserte(len(list(triples((bob, Any, pizza)))), 1)
asserte(len(list(triples((bob, Any, michel)))), 1)
# unbound subject, objects with context
asserte(len(list(c1triples((Any, hates, Any)))), 2)
asserte(len(list(c1triples((Any, likes, Any)))), 5)
# unbound subject, objects without context, same results!
asserte(len(list(triples((Any, hates, Any)))), 2)
asserte(len(list(triples((Any, likes, Any)))), 5)
# unbound predicates, objects with context
asserte(len(list(c1triples((michel, Any, Any)))), 2)
asserte(len(list(c1triples((bob, Any, Any)))), 3)
asserte(len(list(c1triples((tarek, Any, Any)))), 2)
# unbound predicates, objects without context, same results!
asserte(len(list(triples((michel, Any, Any)))), 2)
asserte(len(list(triples((bob, Any, Any)))), 3)
asserte(len(list(triples((tarek, Any, Any)))), 2)
# unbound subjects, predicates with context
asserte(len(list(c1triples((Any, Any, pizza)))), 3)
asserte(len(list(c1triples((Any, Any, cheese)))), 3)
asserte(len(list(c1triples((Any, Any, michel)))), 1)
# unbound subjects, predicates without context, same results!
asserte(len(list(triples((Any, Any, pizza)))), 3)
asserte(len(list(triples((Any, Any, cheese)))), 3)
asserte(len(list(triples((Any, Any, michel)))), 1)
# all unbound with context
asserte(len(list(c1triples((Any, Any, Any)))), 7)
# all unbound without context, same result!
asserte(len(list(triples((Any, Any, Any)))), 7)
for c in [graph, self.get_context(c1)]:
# unbound subjects
asserte(set(c.subjects(likes, pizza)), set((michel, tarek)))
asserte(set(c.subjects(hates, pizza)), set((bob,)))
asserte(set(c.subjects(likes, cheese)), set([tarek, bob, michel]))
asserte(set(c.subjects(hates, cheese)), set())
# unbound objects
asserte(set(c.objects(michel, likes)), set([cheese, pizza]))
asserte(set(c.objects(tarek, likes)), set([cheese, pizza]))
asserte(set(c.objects(bob, hates)), set([michel, pizza]))
asserte(set(c.objects(bob, likes)), set([cheese]))
# unbound predicates
asserte(set(c.predicates(michel, cheese)), set([likes]))
asserte(set(c.predicates(tarek, cheese)), set([likes]))
asserte(set(c.predicates(bob, pizza)), set([hates]))
asserte(set(c.predicates(bob, michel)), set([hates]))
asserte(set(c.subject_objects(hates)), set([(bob, pizza), (bob, michel)]))
asserte(set(c.subject_objects(likes)), set([(tarek, cheese), (michel, cheese), (michel, pizza), (bob, cheese), (tarek, pizza)]))
asserte(set(c.predicate_objects(michel)), set([(likes, cheese), (likes, pizza)]))
asserte(set(c.predicate_objects(bob)), set([(likes, cheese), (hates, pizza), (hates, michel)]))
asserte(set(c.predicate_objects(tarek)), set([(likes, cheese), (likes, pizza)]))
asserte(set(c.subject_predicates(pizza)), set([(bob, hates), (tarek, likes), (michel, likes)]))
asserte(set(c.subject_predicates(cheese)), set([(bob, likes), (tarek, likes), (michel, likes)]))
asserte(set(c.subject_predicates(michel)), set([(bob, hates)]))
asserte(set(c), set([(bob, hates, michel), (bob, likes, cheese), (tarek, likes, pizza), (michel, likes, pizza), (michel, likes, cheese), (bob, hates, pizza), (tarek, likes, cheese)]))
# remove stuff and make sure the graph is empty again
self.removeStuff()
asserte(len(list(c1triples((Any, Any, Any)))), 0)
asserte(len(list(triples((Any, Any, Any)))), 0)
#!/usr/bin/env python
# queries an RDF quadstore
from rdflib.graph import ConjunctiveGraph
g = ConjunctiveGraph("Sleepycat")
g.open("store", create=True)
q1 = """PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?src1 ?src2 ?x
WHERE {
GRAPH ?src1 { ?gr1 foaf:member [ foaf:openid ?x ] }
GRAPH ?src2 { ?gr2 foaf:member [ foaf:openid ?x ] }
FILTER ( ?src1 != ?src2 )
}"""
for src1, src2, x in g.query(q1):
print src1, src2, x
g.close()
#!/usr/bin/env python
from rdflib.graph import ConjunctiveGraph
# Test basic SPARQL aggregation of the RDFa data
# see also http://identi.ca/notice/17728953 http://identi.ca/notice/17729227
g = ConjunctiveGraph("Sleepycat")
g.open("store", create=True)
g.parse("http://inkdroid.org/journal/network", format='rdfa', lax=True)
#g.parse("http://danbri.org/words/network", format='rdfa', lax=True)
g.parse("http://danbri.org/words/2009/12/29/523", format='rdfa', lax=True)
g.parse("http://melvincarvalho.com/blog/installed-f2f-plugin/", format='rdfa', lax=True)
q1="""PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?src1 ?src2 ?x
WHERE {
GRAPH ?src1 { ?gr1 foaf:member [ foaf:openid ?x ] }
GRAPH ?src2 { ?gr2 foaf:member [ foaf:openid ?x ] }
FILTER ( ?src1 != ?src2 )
}"""
for src1, src2, x in g.query(q1):
print src1, src2, x
g.close()
class ContextTest(test.TestCase):
"""
Testing different contexts.
Heavily based on https://github.com/RDFLib/rdflib-postgresql/blob/master/test/context_case.py
"""
store_name = "Django"
storetest = True
path = ""
create = True
michel = URIRef(u'michel')
tarek = URIRef(u'tarek')
bob = URIRef(u'bob')
likes = URIRef(u'likes')
hates = URIRef(u'hates')
pizza = URIRef(u'pizza')
cheese = URIRef(u'cheese')
c1 = URIRef(u'context-1')
c2 = URIRef(u'context-2')
def setUp(self):
self.graph = ConjunctiveGraph(store=self.store_name)
self.graph.destroy(self.path)
self.graph.open(self.path, create=self.create)
def tearDown(self):
self.graph.destroy(self.path)
self.graph.close()
def get_context(self, identifier):
assert isinstance(identifier, URIRef) or isinstance(identifier, BNode), type(identifier)
return Graph(store=self.graph.store, identifier=identifier, namespace_manager=self)
def addStuff(self):
tarek = self.tarek
michel = self.michel
bob = self.bob
likes = self.likes
hates = self.hates
pizza = self.pizza
cheese = self.cheese
c1 = self.c1
graph = Graph(self.graph.store, c1)
graph.add((tarek, likes, pizza))
graph.add((tarek, likes, cheese))
graph.add((michel, likes, pizza))
graph.add((michel, likes, cheese))
graph.add((bob, likes, cheese))
graph.add((bob, hates, pizza))
graph.add((bob, hates, michel))
def removeStuff(self):
tarek = self.tarek
michel = self.michel
bob = self.bob
likes = self.likes
hates = self.hates
pizza = self.pizza
cheese = self.cheese
c1 = self.c1
graph = Graph(self.graph.store, c1)
graph.remove((tarek, likes, pizza))
graph.remove((tarek, likes, cheese))
graph.remove((michel, likes, pizza))
graph.remove((michel, likes, cheese))
graph.remove((bob, likes, cheese))
graph.remove((bob, hates, pizza))
graph.remove((bob, hates, michel))
def addStuffInMultipleContexts(self):
c1 = self.c1
c2 = self.c2
triple = (self.pizza, self.hates, self.tarek)
# add to default context
self.graph.add(triple)
# add to context 1
graph = Graph(self.graph.store, c1)
graph.add(triple)
# add to context 2
graph = Graph(self.graph.store, c2)
graph.add(triple)
def testConjunction(self):
self.addStuffInMultipleContexts()
triple = (self.pizza, self.likes, self.pizza)
# add to context 1
graph = Graph(self.graph.store, self.c1)
graph.add(triple)
self.assertEquals(len(graph), 2)
self.assertEquals(len(self.graph), 2)
def testAdd(self):
self.addStuff()
def testRemove(self):
self.addStuff()
self.removeStuff()
def testLenInOneContext(self):
c1 = self.c1
# make sure context is empty
self.graph.remove_context(self.get_context(c1))
graph = Graph(self.graph.store, c1)
oldLen = len(self.graph)
for _ in range(0, 10):
graph.add((BNode(), self.hates, self.hates))
self.assertEquals(len(graph), oldLen + 10)
self.assertEquals(len(self.get_context(c1)), oldLen + 10)
self.graph.remove_context(self.get_context(c1))
self.assertEquals(len(self.graph), oldLen)
self.assertEquals(len(graph), 0)
def testLenInMultipleContexts(self):
oldLen = len(self.graph)
self.addStuffInMultipleContexts()
# addStuffInMultipleContexts is adding the same triple to
# three different contexts. So it's only + 1
self.assertEquals(len(self.graph), oldLen + 1)
graph = Graph(self.graph.store, self.c1)
self.assertEquals(len(graph), oldLen + 1)
def testRemoveInMultipleContexts(self):
c1 = self.c1
c2 = self.c2
triple = (self.pizza, self.hates, self.tarek)
self.addStuffInMultipleContexts()
# triple should be still in store after removing it from c1 + c2
self.assertIn(triple, self.graph)
graph = Graph(self.graph.store, c1)
graph.remove(triple)
self.assertIn(triple, self.graph)
graph = Graph(self.graph.store, c2)
graph.remove(triple)
self.assertIn(triple, self.graph)
self.graph.remove(triple)
# now gone!
self.assertNotIn(triple, self.graph)
# add again and see if remove without context removes all triples!
self.addStuffInMultipleContexts()
self.graph.remove(triple)
self.assertNotIn(triple, self.graph)
def testContexts(self):
triple = (self.pizza, self.hates, self.tarek)
self.addStuffInMultipleContexts()
def cid(c):
if not isinstance(c, basestring):
return c.identifier
return c
self.assertIn(self.c1, [cid(c) for c in self.graph.contexts()])
self.assertIn(self.c2, [cid(c) for c in self.graph.contexts()])
contextList = [cid(c) for c in self.graph.contexts(triple)]
self.assertIn(self.c1, contextList)
self.assertIn(self.c2, contextList)
def testRemoveContext(self):
c1 = self.c1
self.addStuffInMultipleContexts()
self.assertEquals(len(Graph(self.graph.store, c1)), 1)
self.assertEquals(len(self.get_context(c1)), 1)
self.graph.remove_context(self.get_context(c1))
self.assert_(self.c1 not in self.graph.contexts())
def testRemoveAny(self):
Any = None
self.addStuffInMultipleContexts()
self.graph.remove((Any, Any, Any))
self.assertEquals(len(self.graph), 0)
def testTriples(self):
triples = self.graph.triples
graph = self.graph
c1graph = Graph(self.graph.store, self.c1)
c1triples = c1graph.triples
Any = None
self.addStuff()
# unbound subjects with context
self.assertEquals(len(list(c1triples((Any, self.likes, self.pizza)))), 2)
self.assertEquals(len(list(c1triples((Any, self.hates, self.pizza)))), 1)
self.assertEquals(len(list(c1triples((Any, self.likes, self.cheese)))), 3)
self.assertEquals(len(list(c1triples((Any, self.hates, self.cheese)))), 0)
# unbound subjects without context, same results!
self.assertEquals(len(list(triples((Any, self.likes, self.pizza)))), 2)
self.assertEquals(len(list(triples((Any, self.hates, self.pizza)))), 1)
self.assertEquals(len(list(triples((Any, self.likes, self.cheese)))), 3)
self.assertEquals(len(list(triples((Any, self.hates, self.cheese)))), 0)
# unbound objects with context
self.assertEquals(len(list(c1triples((self.michel, self.likes, Any)))), 2)
self.assertEquals(len(list(c1triples((self.tarek, self.likes, Any)))), 2)
self.assertEquals(len(list(c1triples((self.bob, self.hates, Any)))), 2)
self.assertEquals(len(list(c1triples((self.bob, self.likes, Any)))), 1)
# unbound objects without context, same results!
self.assertEquals(len(list(triples((self.michel, self.likes, Any)))), 2)
self.assertEquals(len(list(triples((self.tarek, self.likes, Any)))), 2)
self.assertEquals(len(list(triples((self.bob, self.hates, Any)))), 2)
self.assertEquals(len(list(triples((self.bob, self.likes, Any)))), 1)
# unbound predicates with context
self.assertEquals(len(list(c1triples((self.michel, Any, self.cheese)))), 1)
self.assertEquals(len(list(c1triples((self.tarek, Any, self.cheese)))), 1)
self.assertEquals(len(list(c1triples((self.bob, Any, self.pizza)))), 1)
self.assertEquals(len(list(c1triples((self.bob, Any, self.michel)))), 1)
# unbound predicates without context, same results!
self.assertEquals(len(list(triples((self.michel, Any, self.cheese)))), 1)
self.assertEquals(len(list(triples((self.tarek, Any, self.cheese)))), 1)
self.assertEquals(len(list(triples((self.bob, Any, self.pizza)))), 1)
self.assertEquals(len(list(triples((self.bob, Any, self.michel)))), 1)
# unbound subject, objects with context
self.assertEquals(len(list(c1triples((Any, self.hates, Any)))), 2)
self.assertEquals(len(list(c1triples((Any, self.likes, Any)))), 5)
# unbound subject, objects without context, same results!
self.assertEquals(len(list(triples((Any, self.hates, Any)))), 2)
self.assertEquals(len(list(triples((Any, self.likes, Any)))), 5)
# unbound predicates, objects with context
self.assertEquals(len(list(c1triples((self.michel, Any, Any)))), 2)
self.assertEquals(len(list(c1triples((self.bob, Any, Any)))), 3)
self.assertEquals(len(list(c1triples((self.tarek, Any, Any)))), 2)
# unbound predicates, objects without context, same results!
self.assertEquals(len(list(triples((self.michel, Any, Any)))), 2)
self.assertEquals(len(list(triples((self.bob, Any, Any)))), 3)
self.assertEquals(len(list(triples((self.tarek, Any, Any)))), 2)
# unbound subjects, predicates with context
self.assertEquals(len(list(c1triples((Any, Any, self.pizza)))), 3)
self.assertEquals(len(list(c1triples((Any, Any, self.cheese)))), 3)
self.assertEquals(len(list(c1triples((Any, Any, self.michel)))), 1)
# unbound subjects, predicates without context, same results!
self.assertEquals(len(list(triples((Any, Any, self.pizza)))), 3)
self.assertEquals(len(list(triples((Any, Any, self.cheese)))), 3)
self.assertEquals(len(list(triples((Any, Any, self.michel)))), 1)
# all unbound with context
self.assertEquals(len(list(c1triples((Any, Any, Any)))), 7)
# all unbound without context, same result!
self.assertEquals(len(list(triples((Any, Any, Any)))), 7)
for c in [graph, self.get_context(self.c1)]:
# unbound subjects
self.assertEquals(set(c.subjects(self.likes, self.pizza)), {self.michel, self.tarek})
self.assertEquals(set(c.subjects(self.hates, self.pizza)), {self.bob})
self.assertEquals(set(c.subjects(self.likes, self.cheese)), {self.tarek, self.bob, self.michel})
self.assertEquals(set(c.subjects(self.hates, self.cheese)), set())
# unbound objects
self.assertEquals(set(c.objects(self.michel, self.likes)), {self.cheese, self.pizza})
self.assertEquals(set(c.objects(self.tarek, self.likes)), {self.cheese, self.pizza})
self.assertEquals(set(c.objects(self.bob, self.hates)), {self.michel, self.pizza})
self.assertEquals(set(c.objects(self.bob, self.likes)), {self.cheese})
# unbound predicates
self.assertEquals(set(c.predicates(self.michel, self.cheese)), {self.likes})
self.assertEquals(set(c.predicates(self.tarek, self.cheese)), {self.likes})
self.assertEquals(set(c.predicates(self.bob, self.pizza)), {self.hates})
self.assertEquals(set(c.predicates(self.bob, self.michel)), {self.hates})
self.assertEquals(set(c.subject_objects(self.hates)), {(self.bob, self.pizza), (self.bob, self.michel)})
self.assertEquals(set(c.subject_objects(self.likes)),
{(self.tarek, self.cheese), (self.michel, self.cheese), (self.michel, self.pizza), (self.bob, self.cheese), (self.tarek, self.pizza)})
self.assertEquals(set(c.predicate_objects(self.michel)), {(self.likes, self.cheese), (self.likes, self.pizza)})
self.assertEquals(set(c.predicate_objects(self.bob)), {(self.likes, self.cheese), (self.hates, self.pizza), (self.hates, self.michel)})
self.assertEquals(set(c.predicate_objects(self.tarek)), {(self.likes, self.cheese), (self.likes, self.pizza)})
self.assertEquals(set(c.subject_predicates(self.pizza)), {(self.bob, self.hates), (self.tarek, self.likes), (self.michel, self.likes)})
self.assertEquals(set(c.subject_predicates(self.cheese)), {(self.bob, self.likes), (self.tarek, self.likes), (self.michel, self.likes)})
self.assertEquals(set(c.subject_predicates(self.michel)), {(self.bob, self.hates)})
self.assertEquals(set(c), {(self.bob, self.hates, self.michel), (self.bob, self.likes, self.cheese), (self.tarek, self.likes, self.pizza),
(self.michel, self.likes, self.pizza), (self.michel, self.likes, self.cheese), (self.bob, self.hates, self.pizza),
(self.tarek, self.likes, self.cheese)})
# remove stuff and make sure the graph is empty again
self.removeStuff()
self.assertEquals(len(list(c1triples((Any, Any, Any)))), 0)
self.assertEquals(len(list(triples((Any, Any, Any)))), 0)
class TestKyotoCabinetConjunctiveGraphCore(unittest.TestCase):
def setUp(self):
store = "KyotoCabinet"
self.graph = ConjunctiveGraph(store=store)
self.path = configString
self.graph.open(self.path, create=True)
def tearDown(self):
self.graph.destroy(self.path)
try:
self.graph.close()
except:
pass
if getattr(self, "path", False) and self.path is not None:
if os.path.exists(self.path):
if os.path.isdir(self.path):
for f in os.listdir(self.path):
os.unlink(self.path + "/" + f)
os.rmdir(self.path)
elif len(self.path.split(":")) == 1:
os.unlink(self.path)
else:
os.remove(self.path)
def test_namespaces(self):
self.graph.bind("dc", "http://http://purl.org/dc/elements/1.1/")
self.graph.bind("foaf", "http://xmlns.com/foaf/0.1/")
self.assert_(len(list(self.graph.namespaces())) == 5)
self.assert_(("foaf", rdflib.term.URIRef(u"http://xmlns.com/foaf/0.1/")) in list(self.graph.namespaces()))
def test_play_journal(self):
self.assertRaises(NotImplementedError, self.graph.store.play_journal, {"graph": self.graph})
def test_readable_index(self):
print(readable_index(111))
def test_triples_context_reset(self):
michel = rdflib.URIRef(u"michel")
likes = rdflib.URIRef(u"likes")
pizza = rdflib.URIRef(u"pizza")
cheese = rdflib.URIRef(u"cheese")
self.graph.add((michel, likes, pizza))
self.graph.add((michel, likes, cheese))
self.graph.commit()
ntriples = self.graph.triples((None, None, None), context=self.graph.store)
self.assert_(len(list(ntriples)) == 2)
def test_remove_context_reset(self):
michel = rdflib.URIRef(u"michel")
likes = rdflib.URIRef(u"likes")
pizza = rdflib.URIRef(u"pizza")
cheese = rdflib.URIRef(u"cheese")
self.graph.add((michel, likes, pizza))
self.graph.add((michel, likes, cheese))
self.graph.commit()
self.graph.store.remove((michel, likes, cheese), self.graph.store)
self.graph.commit()
self.assert_(len(list(self.graph.triples((None, None, None), context=self.graph.store))) == 1)
def test_remove_db_exception(self):
michel = rdflib.URIRef(u"michel")
likes = rdflib.URIRef(u"likes")
pizza = rdflib.URIRef(u"pizza")
cheese = rdflib.URIRef(u"cheese")
self.graph.add((michel, likes, pizza))
self.graph.add((michel, likes, cheese))
self.graph.commit()
self.graph.store.__len__(context=self.graph.store)
self.assert_(len(list(self.graph.triples((None, None, None), context=self.graph.store))) == 2)
class ContextTest(TestCase):
"""
Testing different contexts.
Heavily based on https://github.com/RDFLib/rdflib-postgresql/blob/master/test/context_case.py
""" # noqa: E501
store_name = "Django"
storetest = True
path = ""
create = True
michel = URIRef(u'michel')
tarek = URIRef(u'tarek')
bob = URIRef(u'bob')
likes = URIRef(u'likes')
hates = URIRef(u'hates')
pizza = URIRef(u'pizza')
cheese = URIRef(u'cheese')
c1 = URIRef(u'context-1')
c2 = URIRef(u'context-2')
def setUp(self):
self.graph = ConjunctiveGraph(store=self.store_name)
self.graph.destroy(self.path)
self.graph.open(self.path, create=self.create)
def tearDown(self):
self.graph.destroy(self.path)
self.graph.close()
def get_context(self, identifier):
assert isinstance(identifier, URIRef) or isinstance(identifier, BNode), type(identifier) # noqa: E501
return Graph(store=self.graph.store, identifier=identifier, namespace_manager=self) # noqa: E501
def addStuff(self):
tarek = self.tarek
michel = self.michel
bob = self.bob
likes = self.likes
hates = self.hates
pizza = self.pizza
cheese = self.cheese
c1 = self.c1
graph = Graph(self.graph.store, c1)
graph.add((tarek, likes, pizza))
graph.add((tarek, likes, cheese))
graph.add((michel, likes, pizza))
graph.add((michel, likes, cheese))
graph.add((bob, likes, cheese))
graph.add((bob, hates, pizza))
graph.add((bob, hates, michel))
def removeStuff(self):
tarek = self.tarek
michel = self.michel
bob = self.bob
likes = self.likes
hates = self.hates
pizza = self.pizza
cheese = self.cheese
c1 = self.c1
graph = Graph(self.graph.store, c1)
graph.remove((tarek, likes, pizza))
graph.remove((tarek, likes, cheese))
graph.remove((michel, likes, pizza))
graph.remove((michel, likes, cheese))
graph.remove((bob, likes, cheese))
graph.remove((bob, hates, pizza))
graph.remove((bob, hates, michel))
def addStuffInMultipleContexts(self):
c1 = self.c1
c2 = self.c2
triple = (self.pizza, self.hates, self.tarek)
# add to default context
self.graph.add(triple)
# add to context 1
graph = Graph(self.graph.store, c1)
graph.add(triple)
# add to context 2
graph = Graph(self.graph.store, c2)
graph.add(triple)
def testConjunction(self):
self.addStuffInMultipleContexts()
triple = (self.pizza, self.likes, self.pizza)
# add to context 1
graph = Graph(self.graph.store, self.c1)
graph.add(triple)
self.assertEquals(len(graph), 2)
self.assertEquals(len(self.graph), 2)
def testAdd(self):
self.addStuff()
def testRemove(self):
self.addStuff()
self.removeStuff()
def testLenInOneContext(self):
c1 = self.c1
# make sure context is empty
self.graph.remove_context(self.get_context(c1))
graph = Graph(self.graph.store, c1)
oldLen = len(self.graph)
for _ in range(0, 10):
graph.add((BNode(), self.hates, self.hates))
self.assertEquals(len(graph), oldLen + 10)
self.assertEquals(len(self.get_context(c1)), oldLen + 10)
self.graph.remove_context(self.get_context(c1))
self.assertEquals(len(self.graph), oldLen)
self.assertEquals(len(graph), 0)
def testLenInMultipleContexts(self):
oldLen = len(self.graph)
self.addStuffInMultipleContexts()
# addStuffInMultipleContexts is adding the same triple to
# three different contexts. So it's only + 1
self.assertEquals(len(self.graph), oldLen + 1)
graph = Graph(self.graph.store, self.c1)
self.assertEquals(len(graph), oldLen + 1)
def testRemoveInMultipleContexts(self):
c1 = self.c1
c2 = self.c2
triple = (self.pizza, self.hates, self.tarek)
self.addStuffInMultipleContexts()
# triple should be still in store after removing it from c1 + c2
self.assertIn(triple, self.graph)
graph = Graph(self.graph.store, c1)
graph.remove(triple)
self.assertIn(triple, self.graph)
graph = Graph(self.graph.store, c2)
graph.remove(triple)
self.assertIn(triple, self.graph)
self.graph.remove(triple)
# now gone!
self.assertNotIn(triple, self.graph)
# add again and see if remove without context removes all triples!
self.addStuffInMultipleContexts()
self.graph.remove(triple)
self.assertNotIn(triple, self.graph)
def testContexts(self):
triple = (self.pizza, self.hates, self.tarek)
self.addStuffInMultipleContexts()
def cid(c):
if not isinstance(c, str):
return c.identifier
return c
self.assertIn(self.c1, [cid(c) for c in self.graph.contexts()])
self.assertIn(self.c2, [cid(c) for c in self.graph.contexts()])
contextList = [cid(c) for c in self.graph.contexts(triple)]
self.assertIn(self.c1, contextList)
self.assertIn(self.c2, contextList)
def testRemoveContext(self):
c1 = self.c1
self.addStuffInMultipleContexts()
self.assertEquals(len(Graph(self.graph.store, c1)), 1)
self.assertEquals(len(self.get_context(c1)), 1)
self.graph.remove_context(self.get_context(c1))
self.assert_(self.c1 not in self.graph.contexts())
def testRemoveAny(self):
Any = None
self.addStuffInMultipleContexts()
self.graph.remove((Any, Any, Any))
self.assertEquals(len(self.graph), 0)
def testTriples(self):
triples = self.graph.triples
graph = self.graph
c1graph = Graph(self.graph.store, self.c1)
c1triples = c1graph.triples
Any = None
self.addStuff()
# unbound subjects with context
self.assertEquals(
len(
list(
c1triples((Any, self.likes, self.pizza))
)
), 2
)
self.assertEquals(
len(
list(
c1triples((Any, self.hates, self.pizza))
)
), 1
)
self.assertEquals(
len(
list(
c1triples((Any, self.likes, self.cheese))
)
), 3
)
self.assertEquals(
len(
list(
c1triples((Any, self.hates, self.cheese))
)
), 0
)
# unbound subjects without context, same results!
self.assertEquals(len(list(triples((Any, self.likes, self.pizza)))), 2)
self.assertEquals(len(list(triples((Any, self.hates, self.pizza)))), 1)
self.assertEquals(len(list(triples((Any, self.likes, self.cheese)))), 3)
self.assertEquals(len(list(triples((Any, self.hates, self.cheese)))), 0)
# unbound objects with context
self.assertEquals(len(list(c1triples((self.michel, self.likes, Any)))), 2)
self.assertEquals(len(list(c1triples((self.tarek, self.likes, Any)))), 2)
self.assertEquals(len(list(c1triples((self.bob, self.hates, Any)))), 2)
self.assertEquals(len(list(c1triples((self.bob, self.likes, Any)))), 1)
# unbound objects without context, same results!
self.assertEquals(len(list(triples((self.michel, self.likes, Any)))), 2)
self.assertEquals(len(list(triples((self.tarek, self.likes, Any)))), 2)
self.assertEquals(len(list(triples((self.bob, self.hates, Any)))), 2)
self.assertEquals(len(list(triples((self.bob, self.likes, Any)))), 1)
# unbound predicates with context
self.assertEquals(len(list(c1triples((self.michel, Any, self.cheese)))), 1)
self.assertEquals(len(list(c1triples((self.tarek, Any, self.cheese)))), 1)
self.assertEquals(len(list(c1triples((self.bob, Any, self.pizza)))), 1)
self.assertEquals(len(list(c1triples((self.bob, Any, self.michel)))), 1)
# unbound predicates without context, same results!
self.assertEquals(len(list(triples((self.michel, Any, self.cheese)))), 1)
self.assertEquals(len(list(triples((self.tarek, Any, self.cheese)))), 1)
self.assertEquals(len(list(triples((self.bob, Any, self.pizza)))), 1)
self.assertEquals(len(list(triples((self.bob, Any, self.michel)))), 1)
# unbound subject, objects with context
self.assertEquals(len(list(c1triples((Any, self.hates, Any)))), 2)
self.assertEquals(len(list(c1triples((Any, self.likes, Any)))), 5)
# unbound subject, objects without context, same results!
self.assertEquals(len(list(triples((Any, self.hates, Any)))), 2)
self.assertEquals(len(list(triples((Any, self.likes, Any)))), 5)
# unbound predicates, objects with context
self.assertEquals(len(list(c1triples((self.michel, Any, Any)))), 2)
self.assertEquals(len(list(c1triples((self.bob, Any, Any)))), 3)
self.assertEquals(len(list(c1triples((self.tarek, Any, Any)))), 2)
# unbound predicates, objects without context, same results!
self.assertEquals(len(list(triples((self.michel, Any, Any)))), 2)
self.assertEquals(len(list(triples((self.bob, Any, Any)))), 3)
self.assertEquals(len(list(triples((self.tarek, Any, Any)))), 2)
# unbound subjects, predicates with context
self.assertEquals(len(list(c1triples((Any, Any, self.pizza)))), 3)
self.assertEquals(len(list(c1triples((Any, Any, self.cheese)))), 3)
self.assertEquals(len(list(c1triples((Any, Any, self.michel)))), 1)
# unbound subjects, predicates without context, same results!
self.assertEquals(len(list(triples((Any, Any, self.pizza)))), 3)
self.assertEquals(len(list(triples((Any, Any, self.cheese)))), 3)
self.assertEquals(len(list(triples((Any, Any, self.michel)))), 1)
# all unbound with context
self.assertEquals(len(list(c1triples((Any, Any, Any)))), 7)
# all unbound without context, same result!
self.assertEquals(len(list(triples((Any, Any, Any)))), 7)
for c in [graph, self.get_context(self.c1)]:
# unbound subjects
self.assertEquals(set(c.subjects(self.likes, self.pizza)), {self.michel, self.tarek})
self.assertEquals(set(c.subjects(self.hates, self.pizza)), {self.bob})
self.assertEquals(set(c.subjects(self.likes, self.cheese)), {self.tarek, self.bob, self.michel})
self.assertEquals(set(c.subjects(self.hates, self.cheese)), set())
# unbound objects
self.assertEquals(set(c.objects(self.michel, self.likes)), {self.cheese, self.pizza})
self.assertEquals(set(c.objects(self.tarek, self.likes)), {self.cheese, self.pizza})
self.assertEquals(set(c.objects(self.bob, self.hates)), {self.michel, self.pizza})
self.assertEquals(set(c.objects(self.bob, self.likes)), {self.cheese})
# unbound predicates
self.assertEquals(
set(
c.predicates(self.michel, self.cheese)
),
{self.likes}
)
self.assertEquals(
set(
c.predicates(self.tarek, self.cheese)
),
{self.likes}
)
self.assertEquals(set(c.predicates(self.bob, self.pizza)), {self.hates})
self.assertEquals(set(c.predicates(self.bob, self.michel)), {self.hates})
self.assertEquals(set(c.subject_objects(self.hates)), {(self.bob, self.pizza), (self.bob, self.michel)})
self.assertEquals(set(c.subject_objects(self.likes)),
{(self.tarek, self.cheese), (self.michel, self.cheese), (self.michel, self.pizza), (self.bob, self.cheese), (self.tarek, self.pizza)})
self.assertEquals(set(c.predicate_objects(self.michel)), {(self.likes, self.cheese), (self.likes, self.pizza)})
self.assertEquals(set(c.predicate_objects(self.bob)), {(self.likes, self.cheese), (self.hates, self.pizza), (self.hates, self.michel)})
self.assertEquals(set(c.predicate_objects(self.tarek)), {(self.likes, self.cheese), (self.likes, self.pizza)})
self.assertEquals(set(c.subject_predicates(self.pizza)), {(self.bob, self.hates), (self.tarek, self.likes), (self.michel, self.likes)})
self.assertEquals(set(c.subject_predicates(self.cheese)), {(self.bob, self.likes), (self.tarek, self.likes), (self.michel, self.likes)})
self.assertEquals(set(c.subject_predicates(self.michel)), {(self.bob, self.hates)})
self.assertEquals(set(c), {(self.bob, self.hates, self.michel), (self.bob, self.likes, self.cheese), (self.tarek, self.likes, self.pizza),
(self.michel, self.likes, self.pizza), (self.michel, self.likes, self.cheese), (self.bob, self.hates, self.pizza),
(self.tarek, self.likes, self.cheese)})
# remove stuff and make sure the graph is empty again
self.removeStuff()
self.assertEquals(len(list(c1triples((Any, Any, Any)))), 0)
self.assertEquals(len(list(triples((Any, Any, Any)))), 0)
from rdflib.store import Store, NO_STORE, VALID_STORE
from rdflib.namespace import Namespace
from rdflib.term import Literal
from rdflib.term import URIRef
from tempfile import mkdtemp
default_graph_uri = "http://rdflib.net/rdfstore"
configString = "/var/tmp/rdfstore"
# Get the Sleepycat plugin.
store = plugin.get('Sleepycat', Store)('rdfstore')
# Open previously created store, or create it if it doesn't exist yet
graph = Graph(store="Sleepycat", identifier=URIRef(default_graph_uri))
path = mkdtemp()
rt = graph.open(path, create=False)
if rt == NO_STORE:
# There is no underlying Sleepycat infrastructure, create it
graph.open(path, create=True)
else:
assert rt == VALID_STORE, "The underlying store is corrupt"
print "Triples in graph before add: ", len(graph)
# Now we'll add some triples to the graph & commit the changes
rdflib = Namespace('http://rdflib.net/test/')
graph.bind("test", "http://rdflib.net/test/")
graph.add((rdflib['pic:1'], rdflib['name'], Literal('Jane & Bob')))
graph.add((rdflib['pic:2'], rdflib['name'], Literal('Squirrel in Tree')))
graph.commit()
