def test_refresh(self): """Test refreshing CUDS objects.""" c = city.City(name="Freiburg") p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Anna") p3 = city.Citizen(name="Julia") c.add(p1, p2, p3, rel=city.hasInhabitant) p1.add(p3, rel=city.hasChild) p2.add(p3, rel=city.hasChild) with TransportSessionClient(SqliteSession, URI, path=DB) \ as session: wrapper = city.CityWrapper(session=session) cw = wrapper.add(c) p1w, p2w, p3w = cw.get(p1.uid, p2.uid, p3.uid) session.commit() self.assertEqual(cw.name, "Freiburg") self.assertEqual(p1w.name, "Peter") self.assertEqual(p2w.name, "Anna") self.assertEqual(p3w.name, "Julia") self.assertEqual(session._expired, {wrapper.uid}) update_db(DB, c, p1, p2, p3) session.refresh(cw, p1w, p2w, p3w) self.assertEqual(cw.name, "Paris") self.assertEqual(p1w.name, "Maria") self.assertEqual(set(cw.get()), {p1w}) self.assertEqual(p2w.get(), list()) self.assertFalse(hasattr(p3w, "name")) self.assertNotIn(p3w.uid, session._registry)
def test_expiring(self): """Test expring CUDS objects.""" c = city.City(name="Freiburg") p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Anna") p3 = city.Citizen(name="Julia") c.add(p1, p2, p3, rel=city.hasInhabitant) p1.add(p3, rel=city.hasChild) p2.add(p3, rel=city.hasChild) with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) cw = wrapper.add(c) p1w, p2w, p3w = cw.get(p1.uid, p2.uid, p3.uid) session.commit() # p1w is no longer expired after the following assert self.assertEqual(p1w.name, "Peter") self.assertEqual(p2w.name, "Anna") update_db(DB, c, p1, p2, p3) self.assertEqual(p2w.name, "Anna") self.assertEqual(cw.name, "Paris") # expires outdated neighbor p2w self.assertEqual(p2w.name, "Jacob") self.assertEqual(p1w.name, "Peter") session.expire_all() self.assertEqual(p1w.name, "Maria") self.assertEqual(set(cw.get()), {p1w}) self.assertEqual(p2w.get(), list()) self.assertFalse(hasattr(p3w, "name")) self.assertNotIn(p3w.uid, session._registry)
def test_clear_database(self): """Test clearing the database.""" # db is empty (no error occurs) with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) session._clear_database() with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) wrapper.session.commit() session._clear_database() # db is not empty c = city.City(name="Freiburg") p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Anna") p3 = city.Citizen(name="Julia") c.add(p1, p2, p3, rel=city.hasInhabitant) p1.add(p3, rel=city.hasChild) p2.add(p3, rel=city.hasChild) with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) wrapper.add(c) session.commit() session._clear_database() check_db_cleared(self, DB)
def test_recursive_store(self): """Test if _recursive_store correctly stores cuds_objects correctly. It should correct dangling and one-way connections. """ c = city.City(name="Freiburg") p1 = city.Citizen() p2 = city.Citizen() p3 = city.Citizen() p4 = city.Citizen() with CoreSession() as session: w = city.CityWrapper(session=session) cw = w.add(c) c.add(p1, p2, p3, rel=city.hasInhabitant) p3.add(p1, p2, rel=city.isChildOf) p3.add(p4, rel=city.hasChild) cw = w._recursive_store(c, cw) p1w, p2w, p3w = cw.get(p1.uid, p2.uid, p3.uid) p4w = p3w.get(p4.uid) self.assertEqual(w.get(rel=city.hasPart), [cw]) self.assertEqual(set(cw.get(rel=city.hasInhabitant)), {p1w, p2w, p3w}) self.assertEqual(set(cw.get(rel=city.isPartOf)), {w}) self.assertEqual(p3w.get(rel=city.INVERSE_OF_hasInhabitant), [cw]) self.assertEqual(set(p3w.get(rel=city.isChildOf)), {p1w, p2w}) self.assertEqual(p3w.get(rel=city.hasChild), [p4w])
def test_load_by_oclass(self): """Test loading by oclass.""" c = city.City(name="Freiburg") p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Anna") p3 = city.Citizen(name="Julia") c.add(p1, p2, p3, rel=city.hasInhabitant) p1.add(p3, rel=city.hasChild) p2.add(p3, rel=city.hasChild) with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) wrapper.add(c) session.commit() with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) cs = wrapper.get(c.uid) r = session.load_by_oclass(city.City) self.assertIs(next(r), cs) r = session.load_by_oclass(city.Citizen) self.assertEqual(set(r), {p1, p2, p3}) r = session.load_by_oclass(city.Person) self.assertEqual(set(r), {p1, p2, p3}) with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) cs = wrapper.get(c.uid) r = session.load_by_oclass(city.Street) self.assertRaises(StopIteration, next, r)
def test_iter(self): """Tests the iter() method when no ontology class is provided.""" c = city.City(name="a city") n = city.Neighborhood(name="a neighborhood") p = city.Citizen(name="John Smith") q = city.Citizen(name="Jane Doe") c.add(n) c.add(p, q, rel=city.hasInhabitant) elements = set(list(c.iter())) self.assertEqual(elements, {n, p, q}) # return_rel=True get_p_uid, get_p_rel = next(c.iter(p.uid, return_rel=True)) self.assertEqual(get_p_uid, p) self.assertEqual(get_p_rel, city.hasInhabitant) result = c.iter(rel=city.encloses, return_rel=True) self.assertEqual( set(result), set([ (p, city.hasInhabitant), (q, city.hasInhabitant), (n, city.hasPart), ]), )
def test_load_by_iri(self): """Test if it is possible to load objects by their IRIs.""" c = city.City(name="Freiburg") p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Anna") p3 = city.Citizen(name="Julia") c.add(p1, p2, p3, rel=city.hasInhabitant) p1.add(p3, rel=city.hasChild) p2.add(p3, rel=city.hasChild) with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) wrapper.add(c) session.commit() with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) cs = wrapper.get(c.uid) r = session.load_from_iri(cs.iri) self.assertIs(next(r), cs) r = session.load_from_iri(p1.iri, p2.iri, p3.iri) self.assertEqual(set(r), {p1, p2, p3}) with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) cs = wrapper.get(c.uid) r = session.load_from_iri(iri_from_uid(uuid.UUID(int=1))) self.assertEqual(set(r), {None})
def test_expiring(self): """Test expiring with transport + db session.""" c = city.City(name="Freiburg") p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Anna") p3 = city.Citizen(name="Julia") c.add(p1, p2, p3, rel=city.hasInhabitant) p1.add(p3, rel=city.hasChild) p2.add(p3, rel=city.hasChild) with TransportSessionClient(SqliteSession, URI, path=DB)\ as session: wrapper = city.CityWrapper(session=session) cw = wrapper.add(c) p1w, p2w, p3w = cw.get(p1.uid, p2.uid, p3.uid) session.commit() # p1w is no longer expired after the following assert self.assertEqual(p1w.name, "Peter") update_db(DB, c, p1, p2, p3) self.assertEqual(cw.name, "Paris") self.assertEqual(p1w.name, "Peter") session.expire_all() self.assertEqual(p1w.name, "Maria") self.assertEqual(set(cw.get()), {p1w}) self.assertEqual(p2w.get(), list()) self.assertFalse(hasattr(p3w, "name")) self.assertNotIn(p3w.uid, session._registry)
def test_init(self): """Test if first level of children are loaded automatically.""" c = city.City(name="Freiburg") p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Anna") p3 = city.Citizen(name="Julia") c.add(p1, p2, p3, rel=city.hasInhabitant) p1.add(p3, rel=city.hasChild) p2.add(p3, rel=city.hasChild) with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) wrapper.add(c) session.commit() with TransportSessionClient(SqliteSession, URI, path=DB) \ as session: wrapper = city.CityWrapper(session=session) self.assertEqual(set(session._registry.keys()), {c.uid, wrapper.uid}) self.assertEqual(wrapper.get(c.uid).name, "Freiburg") self.assertEqual( session._registry.get(c.uid)._neighbors[city.hasInhabitant], {p1.uid: p1.oclasses, p2.uid: p2.oclasses, p3.uid: p3.oclasses}) self.assertEqual( session._registry.get(c.uid)._neighbors[city.isPartOf], {wrapper.uid: wrapper.oclasses})
def test_create_recycle(self): """Test creation of cuds_objects for different session.""" default_session = CoreSession() osp.core.cuds.Cuds._session = default_session a = city.City(name="Freiburg") self.assertIs(a.session, default_session) with TestWrapperSession() as session: w = city.CityWrapper(session=session) with EngineContext(session): b = create_recycle(oclass=city.City, kwargs={"name": "Offenburg"}, uid=a.uid, session=session, fix_neighbors=False) self.assertEqual(b.name, "Offenburg") self.assertEqual(b.uid, a.uid) self.assertEqual(set(default_session._registry.keys()), {a.uid}) self.assertIs(default_session._registry.get(a.uid), a) self.assertEqual(set(session._registry.keys()), {b.uid, w.uid}) self.assertIs(session._registry.get(b.uid), b) self.assertEqual(session._buffers, [[{ w.uid: w }, dict(), dict()], [{ b.uid: b }, dict(), dict()]]) x = city.Citizen() x = b.add(x, rel=city.hasInhabitant) c = create_recycle(oclass=city.City, kwargs={"name": "Emmendingen"}, session=session, uid=a.uid, fix_neighbors=False) self.assertIs(b, c) self.assertEqual(c.name, "Emmendingen") self.assertEqual(c.get(rel=cuba.relationship), []) self.assertNotEqual(x.get(rel=cuba.relationship), []) self.assertEqual(set(default_session._registry.keys()), {a.uid, x.uid}) self.assertIs(default_session._registry.get(a.uid), a) self.assertEqual(session._buffers, [[{ w.uid: w, x.uid: x }, { c.uid: c }, dict()], [dict(), dict(), dict()]]) x = city.Citizen() x = c.add(x, rel=city.hasInhabitant) c = create_recycle(oclass=city.City, kwargs={"name": "Karlsruhe"}, session=session, uid=a.uid, fix_neighbors=True) self.assertEqual(x.get(rel=cuba.relationship), [])
def test_validate_tree_against_schema(self): """Test validation of CUDS tree against schema.yml.""" schema_file = os.path.join(os.path.dirname(__file__), 'test_validation_schema_city.yml') schema_file_with_missing_entity = os.path.join( os.path.dirname(__file__), 'test_validation_schema_city_with_missing_entity.yml') schema_file_with_missing_relationship = os.path.join( os.path.dirname(__file__), 'test_validation_schema_city_with_missing_relationship.yml') schema_file_with_optional_subtree = os.path.join( os.path.dirname(__file__), 'test_validation_schema_city_with_optional_subtree.yml') c = city.City(name='freiburg') # empty city is not valid self.assertRaises(ConsistencyError, validate_tree_against_schema, c, schema_file) # unless I do not specify relationships for it validate_tree_against_schema(c, schema_file_with_missing_relationship) # but it at least should be a city, # even when no relationships are defined wrong_object = cuba.File(path='some path') self.assertRaises(ConsistencyError, validate_tree_against_schema, wrong_object, schema_file_with_missing_relationship) # with opional inhabitants an empty city is ok validate_tree_against_schema(c, schema_file_with_optional_subtree) # but the optional subtree should follow its own constraints # (here a citizen needs to work in a city) c.add(city.Citizen(name='peter'), rel=city.hasInhabitant) self.assertRaises(CardinalityError, validate_tree_against_schema, c, schema_file_with_optional_subtree) c.add(city.Neighborhood(name='some hood')) c.add(city.Citizen(name='peter'), rel=city.hasInhabitant) # street of neighborhood violated self.assertRaises(CardinalityError, validate_tree_against_schema, c, schema_file) c.get(oclass=city.Neighborhood)[0].add(city.Street(name='abc street')) # now the city is valid and validation should pass validate_tree_against_schema(c, schema_file) # entity that was defined is completely missing in cuds tree self.assertRaises(ConsistencyError, validate_tree_against_schema, c, schema_file_with_missing_entity)
def test_change_oclass(self): """Check utility method to change oclass.""" c = city.City(name="Freiburg") p1 = city.Citizen(name="Tim") p2 = city.Citizen(name="Tom") c.add(p1, p2, rel=city.hasInhabitant) change_oclass(c, city.PopulatedPlace, {"name": "Umkirch"}) self.assertEqual(c.oclass, city.PopulatedPlace) self.assertEqual(p1._neighbors[city.INVERSE_OF_hasInhabitant], {c.uid: [city.PopulatedPlace]}) self.assertEqual(p2._neighbors[city.INVERSE_OF_hasInhabitant], {c.uid: [city.PopulatedPlace]})
def test_insert(self): """Test inserting in the sqlite table.""" c = city.City(name="Freiburg") p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Georg") c.add(p1, p2, rel=city.hasInhabitant) with DataspaceSession(URI) as session: wrapper = city.CityWrapper(session=session) wrapper.add(c) session.commit() check_state(self, c, p1, p2, db=DB)
def test_delete_cuds_object_recursively(self): """Test the delete_cuds_object_recursively function.""" with TestWrapperSession() as session: wrapper = city.CityWrapper(session=session) a = city.City(name="freiburg", session=session) b = city.Citizen(name="peter", session=session) branch(wrapper, branch(a, b, rel=city.hasInhabitant)) self.maxDiff = None session._reset_buffers(BufferContext.USER) delete_cuds_object_recursively(a) self.assertEqual( session._buffers, [ [{}, { wrapper.uid: wrapper }, { a.uid: a, b.uid: b }], [{}, {}, {}], ], ) self.assertEqual(wrapper.get(rel=cuba.relationship), []) self.assertEqual(a.get(rel=cuba.relationship), []) self.assertEqual(b.get(rel=cuba.relationship), [])
def test_text_turtle_cuds_triples(self): """Test exporting the `text/turtle` mime type from a cuds object. This test uses the city ontology. """ # Exporting c = city.City(name="Freiburg", coordinates=[47, 7]) p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Anne") c.add(p1, rel=city.hasInhabitant) c.add(p2, rel=city.hasInhabitant) exported_file = io.StringIO() export_cuds(c, file=exported_file, format="text/turtle") exported_file.seek(0) cuds = import_cuds(exported_file, format="text/turtle") self.assertIs(type(cuds), Cuds)
def test_serializable(self): """Test function to make Cuds objects json serializable.""" p = city.Citizen(age=23, name="Peter", uid=uuid.UUID(int=123)) c = city.City(name="Freiburg", uid=uuid.UUID(int=1)) c1 = city.Person(uid=uuid.UUID(int=2)) c2 = city.Person(uid=uuid.UUID(int=3)) p.add(c, rel=city.INVERSE_OF_hasInhabitant) p.add(c1, c2, rel=city.hasChild) assertJsonLdEqual(self, CUDS_DICT, serializable(p)) assertJsonLdEqual(self, [CUDS_DICT], serializable([p])) assertJsonLdEqual(self, None, serializable(None)) assertJsonLdEqual(self, [None, None], serializable([None, None])) assertJsonLdEqual(self, {"UUID": "00000000-0000-0000-0000-000000000001"}, serializable(uuid.UUID(int=1))) assertJsonLdEqual(self, [{ "UUID": "00000000-0000-0000-0000-000000000001" }, { "UUID": "00000000-0000-0000-0000-000000000002" }], serializable([uuid.UUID(int=1), uuid.UUID(int=2)])) assertJsonLdEqual(self, {"ENTITY": "city.Citizen"}, serializable(city.Citizen)) assertJsonLdEqual(self, [{ "ENTITY": "city.Citizen" }, { "ENTITY": "city.City" }], serializable([city.Citizen, city.City])) assertJsonLdEqual(self, [1, 1.2, "hallo"], serializable([1, 1.2, "hallo"]))
def test_creation(self): """Test the instantiation and type of the objects.""" if not RUN_PERFORMANCE_TEST: return print("Test cuds object creation") for i in range(self.iterations): city.Citizen(name='citizen ' + str(i))
def test_add_rel(self): """Test the instantiation and type of the objects.""" if not RUN_PERFORMANCE_TEST: return print("Test adding with a general relationship") for i in range(self.iterations): self.c.add(city.Citizen(name='citizen ' + str(i)), rel=city.hasInhabitant)
def test_update(self): """Test updating the sqlite table.""" c = city.City(name="Paris") p1 = city.Citizen(name="Peter") c.add(p1, rel=city.hasInhabitant) with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) cw = wrapper.add(c) session.commit() p2 = city.Citizen(name="Georg") cw.add(p2, rel=city.hasInhabitant) cw.name = "Freiburg" session.commit() check_state(self, c, p1, p2)
def test_create_from_cuds_object(self): """Test copying cuds_objects to different session.""" default_session = CoreSession() Cuds._session = default_session a = city.City(name="Freiburg") self.assertIs(a.session, default_session) with TestWrapperSession() as session: w = city.CityWrapper(session=session) with EngineContext(session): b = create_from_cuds_object(a, session) self.assertEqual(b.name, "Freiburg") self.assertEqual(b.uid, a.uid) self.assertEqual(set(default_session._registry.keys()), {a.uid}) self.assertIs(default_session._registry.get(a.uid), a) self.assertEqual(set(session._registry.keys()), {b.uid, w.uid}) self.assertIs(session._registry.get(b.uid), b) self.assertEqual( session._buffers, [[dict(), dict(), dict()], [{ b.uid: b }, dict(), dict()]], ) b.name = "Emmendingen" x = city.Citizen(age=54, name="Franz", session=default_session) b.add(x, rel=city.hasInhabitant) y = city.Citizen(age=21, name="Rolf", session=default_session) a.add(y, rel=city.hasInhabitant) c = create_from_cuds_object(a, session) self.assertIs(b, c) self.assertEqual(c.name, "Freiburg") self.assertEqual(len(c.get(rel=cuba.relationship)), 1) self.assertEqual(c._neighbors[city.hasInhabitant], {y.uid: [city.Citizen]}) self.assertEqual(set(default_session._registry.keys()), {a.uid, x.uid, y.uid}) self.assertIs(default_session._registry.get(a.uid), a) self.assertEqual( session._buffers, [[{ x.uid: x }, { c.uid: c }, dict()], [dict(), dict(), dict()]], )
def test_branch(self): """Test the branch function.""" x = branch( branch(city.City(name="Freiburg"), city.Citizen(name="Peter"), city.Citizen(name="Maria"), rel=city.hasInhabitant), city.Neighborhood(name="Herdern"), city.Neighborhood(name="Vauban")) self.assertEqual(x.name, "Freiburg") self.assertEqual({"Herdern", "Vauban"}, set( map(lambda x: x.name, x.get(oclass=city.Neighborhood)))) self.assertEqual({"Peter", "Maria"}, set( map(lambda x: x.name, x.get(rel=city.hasInhabitant))))
def _benchmark_set_up(self): self.citizen = city.Citizen(name="Lukas", age=93) self.city = city.City(name="Freiburg", coordinates=[108, 49]) self.address = city.Address(postalCode=79111) self.things = itertools.cycle((self.citizen, self.city, self.address)) self.attributes = itertools.cycle( (("age",), ("coordinates",), ("postalCode",)) )
def _benchmark_set_up(self): self.city = city.City(name="Freiburg") self.citizens = tuple( city.Citizen(name=f"citizen {i}") for i in range(self.size) ) self.uids = tuple(citizen.uid for citizen in self.citizens) for citizen in self.citizens: self.city.add(citizen, rel=city.hasInhabitant)
def fill_db(self, c, random_uid=True): """Fill the database with data.""" for i in range(self.iterations): j = i * 9 uids = iter([None for i in range(9)]) if not random_uid: uids = iter(range(j * 9 + 1, (j + 1) * 9 + 1)) c.add(city.Citizen(uid=next(uids)), rel=city.hasInhabitant) c.add(city.Citizen(uid=next(uids)), rel=city.encloses) c.add(city.Citizen(uid=next(uids)), rel=city.hasPart) c.add(city.Neighborhood(name="", uid=next(uids)), rel=city.hasInhabitant) c.add(city.Neighborhood(name="", uid=next(uids)), rel=city.encloses) c.add(city.Neighborhood(name="", uid=next(uids)), rel=city.hasPart) c.add(city.Street(name="", uid=next(uids)), rel=city.hasInhabitant) c.add(city.Street(name="", uid=next(uids)), rel=city.encloses) c = c.add(city.Street(name="", uid=next(uids)), rel=city.hasPart)
def test_delete(self): """Test to delete cuds_objects from the sqlite table.""" c = city.City(name="Freiburg") p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Georg") p3 = city.Citizen(name="Hans") c.add(p1, p2, p3, rel=city.hasInhabitant) with DataspaceSession(URI) as session: wrapper = city.CityWrapper(session=session) cw = wrapper.add(c) session.commit() cw.remove(p3.uid) session.prune() session.commit() check_state(self, c, p1, p2, db=DB)
def get_test_city(): """Set up a test City for the tests.""" c = city.City(name="Freiburg", coordinates=[1, 2]) p1 = city.Citizen(name="Rainer") p2 = city.Citizen(name="Carlos") p3 = city.Citizen(name="Maria") n1 = city.Neighborhood(name="Zähringen", coordinates=[2, 3]) n2 = city.Neighborhood(name="St. Georgen", coordinates=[3, 4]) s1 = city.Street(name="Lange Straße", coordinates=[4, 5]) c.add(p1, p2, p3, rel=city.hasInhabitant) p1.add(p3, rel=city.hasChild) p2.add(p3, rel=city.hasChild) c.add(n1, n2) n1.add(s1) n2.add(s1) s1.add(p2, p3, rel=city.hasInhabitant) return [c, p1, p2, p3, n1, n2, s1]
def test_update_throws_exception(self): """Tests the update() method for unusual behaviors. - Update an element that wasn't added before """ c = city.City(name="a city") n = city.Neighborhood(name="a neighborhood") c.add(n) p = city.Citizen() self.assertRaises(ValueError, c.update, p)
def test_load_missing(self): """Test if missing objects are loaded automatically.""" c = city.City(name="Freiburg") p1 = city.Citizen(name="Peter") p2 = city.Citizen(name="Anna") p3 = city.Citizen(name="Julia") c.add(p1, p2, p3, rel=city.hasInhabitant) p1.add(p3, rel=city.hasChild) p2.add(p3, rel=city.hasChild) with SqliteSession(DB) as session: wrapper = city.CityWrapper(session=session) wrapper.add(c) session.commit() with TransportSessionClient(SqliteSession, URI, path=DB) as session: wrapper = city.CityWrapper(session=session) self.assertEqual(set(session._registry.keys()), {c.uid, wrapper.uid}) cw = wrapper.get(c.uid) p1w = cw.get(p1.uid) p2w = cw.get(p2.uid) p3w = p1w.get(p3.uid) self.assertEqual( set(session._registry.keys()), {c.uid, wrapper.uid, p1.uid, p2.uid, p3.uid}, ) self.assertEqual(p1w.name, "Peter") self.assertEqual(p2w.name, "Anna") self.assertEqual(p3w.name, "Julia") self.assertEqual( p3w._neighbors[city.isChildOf], { p1.uid: p1.oclasses, p2.uid: p2.oclasses }, ) self.assertEqual(p2w._neighbors[city.hasChild], {p3.uid: p3.oclasses}) self.assertEqual( p2w._neighbors[city.INVERSE_OF_hasInhabitant], {c.uid: c.oclasses}, )
def setUp(self): """Start the timer.""" if not RUN_PERFORMANCE_TEST: return self.iterations = 100000 self.c = city.City(name="A big city") for i in range(10): j = i * 9 self.c.add(city.Citizen(uid=j + 0), rel=city.hasInhabitant) self.c.add(city.Citizen(uid=j + 1), rel=city.encloses) self.c.add(city.Citizen(uid=j + 2), rel=city.hasPart) self.c.add(city.Neighborhood(name="", uid=j + 3), rel=city.hasInhabitant) self.c.add(city.Neighborhood(name="", uid=j + 4), rel=city.encloses) self.c.add(city.Neighborhood(name="", uid=j + 5), rel=city.hasPart) self.c.add(city.Street(name="", uid=j + 6), rel=city.hasInhabitant) self.c.add(city.Street(name="", uid=j + 7), rel=city.encloses) self.c.add(city.Street(name="", uid=j + 8), rel=city.hasPart) self.start = time.time()
def _benchmark_set_up(self): self.city = city.City(name="Freiburg") self.iris = tuple( rdflib.URIRef(f"http://example.org/city#Citizen_{i}") for i in range(self.size) ) self.citizens = tuple( city.Citizen(name=f"citizen {i}", uid=self.iris[i]) for i in range(self.size) ) for citizen in self.citizens: self.city.add(citizen, rel=city.hasInhabitant)