class Setup(unittest.TestCase): def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(Observer, Experiment, Trial, Session) def tearDown(self): self.connection.drop_tables() # need to dispose manually to avoid too many connections error self.connection.engine.dispose()
def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(Experiment) class GrandParent(Entity): declared_params = { "A1": "string", "A2": "string", "A3": "integer", "A4": "integer" } class Parent(Entity): declared_params = { "A1": "integer" } class Child(Entity): declared_params = { "A1": "string", "A4": "integer", "A5": "float", "A6": "float" } self.gparent = GrandParent(A1="GP", A2="GP", A3=300) self.parent = Parent(A1=100) self.child = Child(A1="C", A4=500, A5=0.5) self.child.parent = self.parent self.parent.parent = self.gparent
def setUp(self): """Create test database in memory""" self.connection = Connection.test() self.connection.create_tables() self.mapper = Mapper(self.connection) self.mapper.register(*objects)
class TestParamsReload(unittest.TestCase): def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(Experiment) self.good_params = { "datetime": [datetime(2011, 1, 1, 12, 32, 11)], "time": [time(12, 32, 11)], "date": [date(2011, 1, 1)], "integer": [112, 20010213322], "float": [11.2, 200.10213322], "boolean": [True, False], "string": [u"Kleiner Text", u"äöü", u"Юникод"]} def tearDown(self): self.connection.drop_tables() # need to dispose manually to avoid too many connections error self.connection.engine.dispose() def test_param_reprs(self): e = MultiEntity() for key, vals in self.good_params.iteritems(): for val in vals: e.params[key] = val self.assertEqual(e.params[key], val) json_val = e.json_params[key] e.json_params[key] = json_val self.assertEqual(e.params[key], val) # setting from real value works as well e.json_params[key] = val self.assertEqual(e.params[key], val) json_val = e.str_params[key] e.str_params[key] = json_val self.assertEqual(e.params[key], val) # setting from real value works as well e.str_params[key] = val self.assertEqual(e.params[key], val)
def setUp(self): class MyTestEntity(Entity): declared_params = { "some_param": "string" } self.MyTestEntity = MyTestEntity self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(self.MyTestEntity)
class TestSavedTypes(unittest.TestCase): def setUp(self): class MyTestEntity(Entity): declared_params = { "some_param": "string" } self.MyTestEntity = MyTestEntity self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(self.MyTestEntity) def tearDown(self): self.connection.drop_tables() # need to dispose manually to avoid too many connections error self.connection.engine.dispose() def test_entity_type_is_correct(self): ent = self.MyTestEntity(some_param = "a short string") self.assertEqual(ent.type, "MyTestEntity") self.assertEqual(ent._type, "MyTestEntity_0b97eed8bcd1ab0ceb7370dd2f9d8cb9") self.m.save(ent) self.assertEqual(ent.type, "MyTestEntity") self.assertEqual(ent._type, "MyTestEntity_0b97eed8bcd1ab0ceb7370dd2f9d8cb9") found = self.m.find(Entity).one() self.assertEqual(found.type, "MyTestEntity") self.assertEqual(found._type, "MyTestEntity_0b97eed8bcd1ab0ceb7370dd2f9d8cb9") def test_entity_type_is_class_name(self): ent = self.MyTestEntity(some_param = "a short string") self.assertEqual(ent._type, ent.__class__.__name__) def test_polymorphic_id_is_type(self): ent = self.MyTestEntity(some_param = "a short string") self.assertEqual(ent._type, ent.__mapper_args__["polymorphic_identity"])
def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(Experiment) self.good_params = { "datetime": [datetime(2011, 1, 1, 12, 32, 11)], "time": [time(12, 32, 11)], "date": [date(2011, 1, 1)], "integer": [112, 20010213322], "float": [11.2, 200.10213322], "boolean": [True, False], "string": [u"Kleiner Text", u"äöü", u"Юникод"]}
class TestObjectDict(unittest.TestCase): def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(Experiment) def tearDown(self): self.connection.drop_tables() # need to dispose manually to avoid too many connections error self.connection.engine.dispose() def testConstructor(self): """Test constructor""" exp = Experiment(project="P", experimenter="E", int_value=0) self.assertEqual(exp.params['project'], "P") self.assertEqual(exp.params['experimenter'], "E") self.assertEqual(exp.params['int_value'], 0) self.assertEqual(exp.data, {}) def testParamInit(self): """Test parameter initalisation""" exp = Experiment() exp.params['project'] = "P" exp.params['experimenter'] = "E" self.assertEqual(exp.params['project'], "P") self.assertEqual(exp.params['experimenter'], "E") self.assertEqual(exp.data, {}) def testSaving(self): """Test checks for dirtyness and modification""" exp = Experiment() exp.params['project'] = "P" exp.params['experimenter'] = "E" obj_session = Session.object_session(exp) self.assertTrue(obj_session is None) self.m.save(exp) obj_session = Session.object_session(exp) self.assertEqual(obj_session, self.m.session) self.assertFalse(self.m.session.is_modified(exp)) self.assertFalse(exp in self.m.session.dirty) def test_param_delete(self): exp = Experiment() self.m.save(exp) with self.m.auto_session: exp.params['project'] = "P" self.assertEqual(len(self.m.find_all(StringParameter)), 1) with self.m.auto_session: del exp.params['project'] self.assertEqual(len(self.m.find_all(StringParameter)), 0) def testSetItem(self): """Test parameter setting""" exp = Experiment() exp.params['project'] = "P" exp.params['experimenter'] = "E" self.m.save(exp) exp.params['project'] = "PP" # exp is not actually modified itself (only the param is) # but the parameter is considered dirty self.assertTrue(exp._params['project'] in self.m.session.dirty) self.assertFalse(self.m.session.is_modified(exp)) self.assertEqual(exp.params['project'], "PP") self.m.save(exp) # Everything is clean again self.assertFalse(exp._params['project'] in self.m.session.dirty) self.assertFalse(exp in self.m.session.dirty) self.assertEqual(exp.params['project'], "PP") def testSetData(self): exp = Experiment() exp.params['project'] = "P" exp.params['experimenter'] = "E" self.m.save(exp) exp.data['default'].put("2") exp.data['input'].put("1") self.assertEqual(exp.data['default'].get_string(), "2") #Sideeffects of assignments self.m.save(exp) self.assertRaises(TypeError, exp.data, []) exp.data['newkey'].put('newvalue') # adding to data saves automatically self.assertFalse(exp in self.m.session.dirty) # check how the data keys behave exp.data['0'] exp.data['1'].mimetype = "m" exp.data['2'].put("V") self.assertFalse('0' in exp.data) self.assertTrue('1' in exp.data) self.assertTrue('2' in exp.data) def access_mimetype(key): return exp.data[key].mimetype def access_data(key): return exp.data[key].get_string() self.assertRaises(KeyError, access_mimetype, "3") self.assertRaises(KeyError, access_mimetype, "3") # We check twice - maybe it has been set during our check self.assertRaises(KeyError, access_data, "4") self.assertRaises(KeyError, access_data, "4") self.assertRaises(KeyError, exp.data['0'].delete) exp.data['1'].delete() exp.data['2'].delete() self.assertRaises(KeyError, access_mimetype, "1") self.assertRaises(KeyError, access_mimetype, "2") self.assertRaises(KeyError, access_data, "1") self.assertRaises(KeyError, access_data, "2") def testAdvancedData(self): exp_1 = Experiment() exp_2 = Experiment() self.m.save(exp_1, exp_2) exp_1.data['a'].put("1") exp_1.data['b'].put("1") exp_1.data['M'].mimetype = "plain" exp_2.data['b'].put("2") exp_2.data['c'].put("2") exp_2.data.update(exp_1.data) self.assertEqual(len(exp_1.data), 3) self.assertEqual(len(exp_2.data), 4) self.assertEqual(exp_2.data["a"].get_string(), "1") self.assertEqual(exp_2.data["b"].get_string(), "1") self.assertEqual(exp_2.data["c"].get_string(), "2") self.assertEqual(exp_2.data["M"].mimetype, "plain") for v in ["a", "b", "c"]: self.assertEqual(exp_2.data[v].chunks(), 1) self.assertEqual(exp_1.data["M"].chunks(), 0) self.assertEqual(exp_2.data["M"].chunks(), 0) # delete data again with self.m.auto_session: for key in list(exp_1.data): del exp_1.data[key] data = self.m.find_all(Data) self.assertEqual(len(data), 4) datachunks = self.m.find_all(DataChunks) self.assertEqual(len(datachunks), 3) # delete data again with self.m.auto_session: for key in list(exp_2.data): del exp_2.data[key] data = self.m.find_all(Data) self.assertEqual(len(data), 0) datachunks = self.m.find_all(DataChunks) self.assertEqual(len(datachunks), 0) def testAssignDataTooEarly(self): exp = Experiment() self.assertRaises(MissingSessionError, exp.data['default'].put, "2") def test_large_data(self): exp_1 = Experiment() self.m.save(exp_1) old_chunk_size = xdapy.data.DATA_CHUNK_SIZE xdapy.data.DATA_CHUNK_SIZE = 10 data = "0123456789ABCDEF" * 100 exp_1.data['alphabet'].put(data) exp_1.data['alphabet2'].put(data) chunk_ids = exp_1.data['alphabet'].chunk_ids() chunk_ids2 = exp_1.data['alphabet2'].chunk_ids() self.assertEqual(len(chunk_ids), 160) self.assertEqual(len(chunk_ids2), 160) self.assertEqual(chunk_ids, range(1, 161)) self.assertEqual(chunk_ids2, range(161, 321)) chunk_index = exp_1.data['alphabet'].chunk_index() chunk_index2 = exp_1.data['alphabet2'].chunk_index() self.assertEqual(len(chunk_index), 160) self.assertEqual(len(chunk_index2), 160) self.assertEqual(chunk_index, range(1, 161)) self.assertEqual(chunk_index2, range(1, 161)) self.assertEqual(exp_1.data['alphabet'].size(), 1600) chunks = exp_1.data['alphabet'].get_data()._chunks self.assertTrue(all(chunk.length == xdapy.data.DATA_CHUNK_SIZE for chunk in chunks)) xdapy.data.DATA_CHUNK_SIZE = old_chunk_size
# -*- coding: utf-8 -*- from xdapy import Connection, Mapper, Entity connection = Connection.profile("demo", echo=True) # use standard profile # drop the old database structure connection.create_tables() m = Mapper(connection) # from objects import Experiment, ... class Experiment(Entity): """Concrete class for experiments""" declared_params = { 'experimenter': 'string', 'project': 'string' } #class Experiment(Entity): # """Concrete class for experiments""" # declared_params = { # 'experimenter': 'string', # 'project': 'string' # } class Trial(Entity): declared_params = { 'date': 'datetime', 'number_of_runs': 'integer' }
class TestTypeMagic(unittest.TestCase): def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) def tearDown(self): self.connection.drop_tables() # need to dispose manually to avoid too many connections error self.connection.engine.dispose() def test_rebrand(self): class E0(Entity): declared_params = { "q": "integer" } class E1(Entity): declared_params = { "q": "integer", "q1": "integer" } e0 = E0(q=100) self.m.save(e0) self.m.rebrand(E0, E1) # trying to load something from e0 now raises self.assertRaises(DetachedInstanceError, lambda: e0.type) self.assertRaises(DetachedInstanceError, lambda: dict(e0.params)) # lazy, so we call dict e1 = self.m.find_roots()[0] #self.m.session.expunge(e1) import pdb #pdb.set_trace() self.assertEqual(e1._type, E1.__name__) self.assertEqual(e1.params["q"], 100) e1.params["q"] = 0 e1.params["q1"] = 0 def test_multi_step_rebrand(self): class MyEntity1(Entity): declared_params = { "name": "string", "version": "integer" } class MyEntity2a(Entity): declared_params = { "name": "string", "version": "integer", "version_string": "string", "release_date": "date" } class MyEntity2b(Entity): declared_params = { "name": "string", "version_string": "string", "release_date": "date" } class MyEntity3(Entity): declared_params = { "name": "string", "version": "string", "release_date": "date" } orig_entities = [ MyEntity1(name="abc", version=1), MyEntity1(name="def", version=2), MyEntity1(name="ghi", version=3), MyEntity1(name="jkl", version=4), MyEntity1(name="mno", version=5), MyEntity1(name="pqr", version=6), MyEntity1(name="stu", version=7) ] self.m.save(*orig_entities) def change_version_string_add_date(e, params): params["version_string"] = str(params["version"]) del params["version"] params["release_date"] = datetime.date.today() return params def change_version_string(e, params): params["version"] = params["version_string"] del params["version_string"] return params self.assertEqual(len(self.m.find(MyEntity1).all()), 7) self.assertEqual(len(self.m.find(MyEntity3).all()), 0) version_1 = [e.params["version"] for e in self.m.find(MyEntity1)] self.assertEqual(len(version_1), 7) self.assertTrue(all(type(v)==int for v in version_1)) # we cannot rebrand directly: self.assertRaises(ValueError, self.m.rebrand, MyEntity1, MyEntity3) # do the rebranding self.m.rebrand(MyEntity1, MyEntity2a, after=change_version_string_add_date) # still won’t work to do this directly self.assertRaises(ValueError, self.m.rebrand, MyEntity2a, MyEntity3) self.m.rebrand(MyEntity2a, MyEntity2b) self.m.rebrand(MyEntity2b, MyEntity3, after=change_version_string) self.assertEqual(len(self.m.find(MyEntity1).all()), 0) self.assertEqual(len(self.m.find(MyEntity3).all()), 7) version_3 = [e.params["version"] for e in self.m.find(MyEntity3)] self.assertEqual(len(version_3), 7) self.assertTrue(all(isinstance(v, basestring) for v in version_3))
from xdapy import Mapper, Connection, Entity connection = Connection.default() m = Mapper(connection) from objects import Experiment, Observer, Trial, Session m.register(Experiment, Observer, Trial, Session) print set(str(o.parent) for o in m.find_all("Session")) obs = m.find("Observer", {"name": "%Frank%"}).all() print obs[0].data import pdb pdb.set_trace() #print m.find_with("Session").parent(m.find("Observer", {"name": ["%Alex%", "%Frank%"]})).all() from xdapy.operators import gt, lt #trials = m.find_with("Trial", {"_id": lambda id: id*id < 300}).parent(m.find_with("Session", {"_id": lt(300)}).parent(m.find("Observer", {"name": "%Alex%"}))).all() trials = m.find_with("Trial", {"_id": lambda id: id*id < 300, "_parent": ("Session", {"_id": lt(300), "_parent": ("Observer", {"name": "%Alex%"})}), "_with": lambda entity: entity.id != 10}) # find_complex is more powerful but does not use SQLAlchemy
from xdapy import Mapper, Connection, Entity class E(Entity): declared_params = {} connection = Connection.profile("demo")#, echo=True) # use standard profile connection.create_tables()#overwrite=True) m = Mapper(connection) m.register(E) f = open("10M.dat") #f = open("100M.dat") #f = open("1G.dat") e = E() m.save(e) import pdb e.data["100M"].mimetype = "a" e.data["100M"].put("f") print e.data["100M"].get_string() #e.data["100M"].put(f) print e.data["100M"].mimetype print "CHUNKS" print e.data["100M"].chunks() print e.data["100M"].chunk_ids()
class TestXml(unittest.TestCase): test_xml = """<?xml version="1.0" ?> <xdapy><values> <entity id="1" type="Experiment"> <data encoding="base64" name="hlkk"> bGtqbGtqa2wjw6Rqa2xqeXNkc2E= </data> <parameter name="project" type="string" value="PPP0"/> <parameter name="experimenter" type="string" value="John Do"/> <entity id="4" type="Observer" parent="id:1"> <parameter name="age" type="integer" value="26"/> <parameter name="handedness" type="string" value="right"/> <parameter name="name" type="string" value="Max Mustermann"/> </entity> </entity> <entity id="2" type="Session"> <parameter name="date" type="date" value="2010-12-21"/> </entity> <entity id="3" type="Experiment"> <parameter name="project" type="string" value="PPP1"/> <parameter name="experimenter" type="string" value="John Doe"/> </entity> <entity id="5" type="Observer"> <parameter name="age" type="integer" value="38"/> <parameter name="handedness" type="string" value="left"/> <parameter name="name" type="string" value="Susanne Sorgenfrei"/> </entity> <entity id="6" type="Observer"> <parameter name="age" type="integer" value="40"/> <parameter name="handedness" type="string" value="left"/> <parameter name="name" type="string" value="Susi Sorgen"/> </entity> <entity id="7" type="Session"> <parameter name="date" type="date" value="2010-12-21"/> </entity> </values> <relations> <context name="Some Context" from="id:1" to="id:5" /> </relations> </xdapy>""" def setUp(self): """Create test database in memory""" self.connection = Connection.test() self.connection.create_tables() self.mapper = Mapper(self.connection) self.mapper.register(*objects) def tearDown(self): # need to dispose manually to avoid too many connections error self.connection.drop_tables() self.connection.engine.dispose() def testXml(self): xmlio = XmlIO(self.mapper) xmlio.read(self.test_xml) objs = self.mapper.find_all(Entity) roots = self.mapper.find_roots() self.assertEqual(len(objs), 7) self.assertEqual(len(roots), 6) def test_unique_id(self): test_xml = wrap_xml_values("""<entity id="1" type="Experiment" unique_id="2" />""") xmlio = XmlIO(self.mapper) xmlio.read(test_xml) def test_undefined_type(self): test_xml = """<xdapy><types> <entity name="Experiment" /> </types></xdapy>""" xmlio = XmlIO(self.mapper) self.assertRaises(UnregisteredTypesError, xmlio.read, test_xml) def test_type_name_twice(self): class Experiment(Entity): declared_params = {"project": "string"} test_xml = """<xdapy><types> <entity name="Experiment"> <parameter name="project" type="string"/> <parameter name="experimenter" type="string"/> </entity> <entity name="Experiment"> <parameter name="project" type="string"/> </entity> </types></xdapy>""" objects = self.mapper.registered_entities objects.append(Experiment) xmlio = XmlIO(self.mapper, objects) self.assertRaises(AmbiguousObjectError, xmlio.read, test_xml) def test_same_type_defined_twice(self): test_xml = """<xdapy><types> <entity name="Experiment"> <parameter name="project" type="string"/> <parameter name="experimenter" type="string"/> </entity> <entity name="Experiment"> <parameter name="project" type="string"/> <parameter name="experimenter" type="string"/> </entity> </types></xdapy>""" xmlio = XmlIO(self.mapper) xmlio.read(test_xml) def test_wrong_parameter(self): test_xml = """<xdapy><types> <entity name="Experiment"> <parameter name="s" type="string" /> </entity> </types></xdapy>""" xmlio = XmlIO(self.mapper) self.assertRaises(UnregisteredTypesError, xmlio.read, test_xml) def test_wrong_parameter_type(self): test_xml = """<xdapy><types> <entity name="Experiment"> <parameter name="project" type="strong" /> </entity> </types></xdapy>""" xmlio = XmlIO(self.mapper) self.assertRaises(UnregisteredTypesError, xmlio.read, test_xml) def test_invalid_type_entity(self): test_xml = """<xdapy><types> <entty name="Experiment"> <parameter name="project" type="strong" /> </entty> </types></xdapy>""" xmlio = XmlIO(self.mapper) self.assertRaises(InvalidInputError, xmlio.read, test_xml)
def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(NameEntityAutoId) self.m.register(NameEntity)
class TestUniqueId(unittest.TestCase): def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(NameEntityAutoId) self.m.register(NameEntity) def tearDown(self): self.connection.drop_tables() # need to dispose manually to avoid too many connections error self.connection.engine.dispose() def test_unique_id(self): user = NameEntity(first_name="David", last_name="Persaud") self.assertTrue(user._unique_id is None) self.m.save(user) self.assertEqual(user.unique_id, "David Persaud") # does not work twice user2 = NameEntity(first_name="David", last_name="Persaud") self.assertTrue(user2._unique_id is None) self.assertRaises(IntegrityError, self.m.save, user2) # setting it manually user2._unique_id = "David Persaud (II)" # now it works self.m.save(user2) self.assertEqual(user2.unique_id, "David Persaud (II)") def test_auto_gen_unique_id(self): user = NameEntityAutoId(first_name="David", last_name="Persaud") self.assertTrue(user._unique_id is None) self.m.save(user) # it is something completely different self.assertTrue(user._unique_id is not None) self.assertNotEqual(user.unique_id, "David Persaud") # does work twice user2 = NameEntityAutoId(first_name="David", last_name="Persaud") self.assertTrue(user2._unique_id is None) self.m.save(user2) # it is something completely different self.assertTrue(user2._unique_id is not None) self.assertNotEqual(user2.unique_id, "David Persaud") self.assertNotEqual(user._unique_id, user2._unique_id)
def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(Experiment)
class TestInheritedParams(unittest.TestCase): def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(Experiment) class GrandParent(Entity): declared_params = { "A1": "string", "A2": "string", "A3": "integer", "A4": "integer" } class Parent(Entity): declared_params = { "A1": "integer" } class Child(Entity): declared_params = { "A1": "string", "A4": "integer", "A5": "float", "A6": "float" } self.gparent = GrandParent(A1="GP", A2="GP", A3=300) self.parent = Parent(A1=100) self.child = Child(A1="C", A4=500, A5=0.5) self.child.parent = self.parent self.parent.parent = self.gparent def tearDown(self): self.connection.drop_tables() # need to dispose manually to avoid too many connections error self.connection.engine.dispose() def test_access(self): gparent = self.gparent parent = self.parent child = self.child self.assertEqual(child.inherited_params, {"A1": "C", "A2": "GP", "A3": 300, "A4": 500, "A5": 0.5}) self.assertEqual(child.unique_params, {"A2": "GP", "A3": 300, "A5": 0.5}) # now the type must have changed to the inherited int del child.params["A1"] self.assertEqual(child.inherited_params, {"A1": 100, "A2": "GP", "A3": 300, "A4": 500, "A5": 0.5}) self.assertEqual(child.unique_params, {"A2": "GP", "A3": 300, "A5": 0.5}) # and again del parent.params["A1"] self.assertEqual(child.inherited_params, {"A1": "GP", "A2": "GP", "A3": 300, "A4": 500, "A5": 0.5}) self.assertEqual(child.unique_params, {"A2": "GP", "A3": 300, "A5": 0.5}) del child.params["A5"] self.assertEqual(child.inherited_params, {"A1": "GP", "A2": "GP", "A3": 300, "A4": 500}) self.assertEqual(child.unique_params, {"A2": "GP", "A3": 300}) def reassign_inherited(): child.inherited_params["A1"] = "C0" self.assertRaises(TypeError, reassign_inherited) def reassign_unique(): child.unique_params["A2"] = "C0" self.assertRaises(TypeError, reassign_unique) def access_non_unique(): child.unique_params["A1"] self.assertRaises(KeyError, access_non_unique) def test_access_failure(self): self.assertRaises(KeyError, operator.getitem, self.child.unique_params, "unknown") self.assertRaises(KeyError, operator.getitem, self.child.inherited_params, "unknown") def test_len(self): self.assertEqual(len(self.child.inherited_params), 5) self.assertEqual(len(self.parent.inherited_params), 3) self.assertEqual(len(self.gparent.inherited_params), 3) self.assertEqual(len(self.child.unique_params), 3) self.assertEqual(len(self.parent.unique_params), 2) self.assertEqual(len(self.gparent.unique_params), 3) def test_str_repr(self): # should not fail str(self.child.inherited_params) str(self.child.unique_params) repr(self.child.inherited_params) repr(self.child.unique_params)
trial2_1 = Trial() trial2_1.parent = sess2 trial2_2 = Trial() trial2_2.parent = sess2 trial3_1 = Trial() trial3_1.parent = sess3 trial3_2 = Trial() trial3_2.parent = sess3 db = Connection.test() db.create_tables() m = Mapper(db) m.register(Observer, Experiment, Trial) m.save(exp_monorail, exp_neptune) eeee = Experiment() oooo = Observer() eeee.attach("Obs", oooo) exp_monorail.attach("Observer", obs_1) exp_monorail.attach("Observer", obs_2) exp_neptune.attach("Observer", obs_1) # test print
from xdapy import Mapper, Connection, Entity connection = Connection.profile("demo") connection.create_tables() m = Mapper(connection) from objects import Experiment, Observer, Trial, Session m.register(Experiment, Observer, Trial, Session) o1 = Observer(name="A") o2 = Observer(name="B") e1 = Experiment(project="E1", experimenter="X1") e2 = Experiment(project="E2", experimenter="X1") e3 = Experiment(project="E3") t1 = Trial(count=1) t2 = Trial(count=2) t3 = Trial(count=3) t4 = Trial(count=4) s1_1 = Session(count=1) s1_2 = Session(count=1) s2_1 = Session(count=1) s2_2 = Session(count=1) s3_1 = Session(count=1) s4_1 = Session(count=1) m.save(o1, o2, e1, e2, e3, t1, t2, t3, t4, s1_1, s1_2, s2_1, s2_2, s3_1, s4_1)
class TestAll(unittest.TestCase): def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.mapper = Mapper(self.connection) #register params self.mapper.register(Observer, Experiment, Session, Trial) #_register_parameter('Observer', 'name', 'string') #self.p._register_parameter('Observer', 'age', 'integer') #self.p._register_parameter('Observer', 'handedness', 'string') #self.p._register_parameter('Experiment', 'project', 'string') #self.p._register_parameter('Experiment', 'experimenter', 'string') #self.p._register_parameter('Session', 'date', 'string') #self.p._register_parameter('Trial', 'time', 'string') #self.p._register_parameter('Trial', 'rt', 'integer') #self.p._register_parameter('Trial', 'valid', 'integer') #self.p._register_parameter('Trial', 'response', 'string') #create hierarchy self.e1 = Experiment(project='MyProject', experimenter="John Doe") self.e2 = Experiment(project='YourProject', experimenter="Jeanne Done") self.o3 = Observer(name="Max Mustermann", handedness="right", age=26) self.o4 = Observer(name="Susanne Sorgenfrei", handedness='left', age=38) self.o5 = Observer(name="Susi Sorgen", handedness='left', age=40) self.s6 = Session(date='2009-08-20') self.s7 = Session(date='2009-09-21') self.s8 = Session(date='2009-09-22') self.s9 = Session(date='2009-09-23') self.s10 = Session(date='2009-09-24') self.t11 = Trial(rt=int(randint(100, 3000)), valid=True, response='left') self.t12 = Trial(rt=randint(100, 3000), valid=True, response='right') self.t13 = Trial(rt=randint(100, 3000), valid=True, response='left') self.t14 = Trial(rt=randint(100, 3000), valid=True, response='right') self.t15 = Trial(rt=randint(100, 3000), valid=True, response='left') self.t16 = Trial(rt=randint(100, 3000), valid=True, response='right') self.t17 = Trial(rt=randint(100, 3000), valid=True, response='left') self.t18 = Trial(rt=randint(100, 3000), valid=False, response='right') self.t19 = Trial(rt=randint(100, 3000), valid=False, response='left') self.t20 = Trial(rt=randint(100, 3000), valid=False, response='right') self.t21 = Trial(rt=randint(100, 3000), valid=False, response='left') self.t22 = Trial(rt=randint(100, 3000), valid=False, response='right') self.t23 = Trial(rt=randint(100, 3000), valid=False, response='left') self.t24 = Trial(rt=randint(100, 3000), valid=False, response='right') self.mapper.save(self.e1, self.e2, self.o3, self.o4, self.o5, self.s6, self.s7, self.s8, self.s9, self.s10, self.t11, self.t12, self.t13, self.t14, self.t15, self.t16, self.t17, self.t18, self.t19, self.t20, self.t21, self.t22, self.t23, self.t24) self.e1.children.append(self.o3) self.e1.children.append(self.o4) self.e2.children.append(self.o4) self.o3.children.append(self.s6) self.o3.children.append(self.s7) self.o4.children.append(self.s8)#, self.e1) # TODO: Children can be saved twice #self.o4.children.append(self.s8)#, self.e2) self.o4.children.append(self.s9)#, self.e2) self.o4.children.append(self.s10)#, self.e2) self.s6.children.append(self.t11) self.s6.children.append(self.t12) self.s7.children.append(self.t13) self.s7.children.append(self.t14) #self.s8.children.append(self.t15, self.e1) #self.s8.children.append(self.t16, self.e1) #self.s8.children.append(self.t17, self.e2) self.s9.children.append(self.t18) self.s9.children.append(self.t19) self.s9.children.append(self.t20) self.s10.children.append(self.t21) self.s10.children.append(self.t22) self.s10.children.append(self.t23) self.s10.children.append(self.t24) self.mapper.save(self.e1, self.e2, self.o3, self.o4, self.o5, self.s6, self.s7, self.s8, self.s9, self.s10, self.t11, self.t12, self.t13, self.t14, self.t15, self.t16, self.t17, self.t18, self.t19, self.t20, self.t21, self.t22, self.t23, self.t24) def tearDown(self): self.connection.drop_tables() # need to dispose manually to avoid too many connections error self.connection.engine.dispose() def testReturn(self): self.assertEqual(self.mapper.find_first(Observer(name="Susanne Sorgenfrei")).children, [self.s8, self.s9, self.s10]) self.assertEqual(self.mapper.find_first(Observer(name="Susi Sorgen")).children, []) self.assertEqual(self.mapper.find_first(Observer(name="Max Mustermann")).children, [self.s6, self.s7]) self.assertEqual(self.mapper.find_first("Observer", {"name": "Max Mustermann"}).children, [self.s6, self.s7]) self.assertEqual(self.mapper.find("Trial").count(), 14) self.assertEqual(self.mapper.find_first("Observer", {"name": "Max"}, {"strict": False}).children, [self.s6, self.s7]) self.assertEqual(self.mapper.find_first(Observer(name="Max"), options={"strict": False}).children, [self.s6, self.s7]) self.assertEqual(self.mapper.find_first(Session(date='2009-09-24')), self.s10) self.assertEqual(self.mapper.find_all(Session, {"date": "2009"}, options={"strict": False, "convert_string": True}), [self.s6, self.s7, self.s8, self.s9, self.s10]) # self.assertEqual(self.mapper.find_all(Session, {"date": "2009-09"}, options={"strict": False, "convert_string": True}), [self.s7, self.s8, self.s9, self.s10]) self.assertEqual(self.mapper.find_all(Session, {"date": "2009-08"}, options={"strict": False, "convert_string": True}), [self.s6])
# -*- coding: utf-8 -*- from xml.etree import ElementTree as ET from xdapy.utils.decorators import autoappend from xdapy.io import XmlIO from xdapy import Connection, Mapper, Entity connection = Connection.profile("demo") # use standard profile # connection = Connection(dbname="xdapy") # drop the old database structure connection.create_tables() m = Mapper(connection) objects = [] @autoappend(objects) class Trial(Entity): declared_params = { "count": "string", "phase_of_signal_in_first_interval": "string", "reaction_time": "string", "noise_seed": "string", "phase_of_signal_in_second_interval": "string", "signal_interval": "string", "note": "string", "start": "string",
def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.mapper = Mapper(self.connection) #register params self.mapper.register(Observer, Experiment, Session, Trial) #_register_parameter('Observer', 'name', 'string') #self.p._register_parameter('Observer', 'age', 'integer') #self.p._register_parameter('Observer', 'handedness', 'string') #self.p._register_parameter('Experiment', 'project', 'string') #self.p._register_parameter('Experiment', 'experimenter', 'string') #self.p._register_parameter('Session', 'date', 'string') #self.p._register_parameter('Trial', 'time', 'string') #self.p._register_parameter('Trial', 'rt', 'integer') #self.p._register_parameter('Trial', 'valid', 'integer') #self.p._register_parameter('Trial', 'response', 'string') #create hierarchy self.e1 = Experiment(project='MyProject', experimenter="John Doe") self.e2 = Experiment(project='YourProject', experimenter="Jeanne Done") self.o3 = Observer(name="Max Mustermann", handedness="right", age=26) self.o4 = Observer(name="Susanne Sorgenfrei", handedness='left', age=38) self.o5 = Observer(name="Susi Sorgen", handedness='left', age=40) self.s6 = Session(date='2009-08-20') self.s7 = Session(date='2009-09-21') self.s8 = Session(date='2009-09-22') self.s9 = Session(date='2009-09-23') self.s10 = Session(date='2009-09-24') self.t11 = Trial(rt=int(randint(100, 3000)), valid=True, response='left') self.t12 = Trial(rt=randint(100, 3000), valid=True, response='right') self.t13 = Trial(rt=randint(100, 3000), valid=True, response='left') self.t14 = Trial(rt=randint(100, 3000), valid=True, response='right') self.t15 = Trial(rt=randint(100, 3000), valid=True, response='left') self.t16 = Trial(rt=randint(100, 3000), valid=True, response='right') self.t17 = Trial(rt=randint(100, 3000), valid=True, response='left') self.t18 = Trial(rt=randint(100, 3000), valid=False, response='right') self.t19 = Trial(rt=randint(100, 3000), valid=False, response='left') self.t20 = Trial(rt=randint(100, 3000), valid=False, response='right') self.t21 = Trial(rt=randint(100, 3000), valid=False, response='left') self.t22 = Trial(rt=randint(100, 3000), valid=False, response='right') self.t23 = Trial(rt=randint(100, 3000), valid=False, response='left') self.t24 = Trial(rt=randint(100, 3000), valid=False, response='right') self.mapper.save(self.e1, self.e2, self.o3, self.o4, self.o5, self.s6, self.s7, self.s8, self.s9, self.s10, self.t11, self.t12, self.t13, self.t14, self.t15, self.t16, self.t17, self.t18, self.t19, self.t20, self.t21, self.t22, self.t23, self.t24) self.e1.children.append(self.o3) self.e1.children.append(self.o4) self.e2.children.append(self.o4) self.o3.children.append(self.s6) self.o3.children.append(self.s7) self.o4.children.append(self.s8)#, self.e1) # TODO: Children can be saved twice #self.o4.children.append(self.s8)#, self.e2) self.o4.children.append(self.s9)#, self.e2) self.o4.children.append(self.s10)#, self.e2) self.s6.children.append(self.t11) self.s6.children.append(self.t12) self.s7.children.append(self.t13) self.s7.children.append(self.t14) #self.s8.children.append(self.t15, self.e1) #self.s8.children.append(self.t16, self.e1) #self.s8.children.append(self.t17, self.e2) self.s9.children.append(self.t18) self.s9.children.append(self.t19) self.s9.children.append(self.t20) self.s10.children.append(self.t21) self.s10.children.append(self.t22) self.s10.children.append(self.t23) self.s10.children.append(self.t24) self.mapper.save(self.e1, self.e2, self.o3, self.o4, self.o5, self.s6, self.s7, self.s8, self.s9, self.s10, self.t11, self.t12, self.t13, self.t14, self.t15, self.t16, self.t17, self.t18, self.t19, self.t20, self.t21, self.t22, self.t23, self.t24)
class TestJson(unittest.TestCase): def setUp(self): """Create test database in memory""" self.connection = Connection.test() self.connection.create_tables() self.mapper = Mapper(self.connection) def tearDown(self): self.connection.drop_tables() # need to dispose manually to avoid too many connections error self.connection.engine.dispose() def test_null_import(self): json = """ { "types": [], "objects": [], "relations": [] }""" jio = JsonIO(self.mapper) objs = jio.read_string(json) self.assertEqual(len(objs), 0) def test_unknown_types(self): json = """ { "types": [{"type": "A"}, {"type": "B"}], "objects": [{"type": "A"}, {"type": "A"}, {"type": "A"}, {"type": "B"}], "relations": [] }""" jio = JsonIO(self.mapper) self.assertRaises(InvalidInputError, jio.read_string, json) def test_simple_import(self): json = """ { "types": [{"type": "A"}, {"type": "B"}], "objects": [{"type": "A"}, {"type": "A"}, {"type": "A"}, {"type": "B"}], "relations": [] }""" jio = JsonIO(self.mapper, add_new_types=True) objs = jio.read_string(json) self.assertEqual(len(objs), 4) def test_parameters(self): json = """ { "types": [ { "type": "A", "parameters": { "s": "string", "d": "datetime", "i": "integer" } } ], "objects": [ { "type": "A", "parameters": { "s": "string", "d": "2012-02-10T20:00:00", "i": 12 } }, { "type": "A" }, { "type": "A" } ], "relations": [] }""" jio = JsonIO(self.mapper, add_new_types=True) objs = jio.read_string(json) self.assertEqual(len(objs), 3) self.assertEqual(objs[0].params["s"], "string") self.assertEqual(objs[0].params["d"], datetime.datetime(2012, 2, 10, 20, 0, 0)) self.assertEqual(objs[0].params["i"], 12) def test_parameters_as_dict(self): json = { "types": [ { "type": "A", "parameters": { "s": "string", "d": "datetime" } } ], "objects": [ { "type": "A", "parameters": { "s": "string", "d": "2012-02-10T20:00:00" } }, { "type": "A", "parameters": { "d": datetime.datetime(2012, 2, 10, 20, 0, 0) }}, { "type": "A" } ], "relations": [] } jio = JsonIO(self.mapper, add_new_types=True) objs = jio.read_json(json) self.assertEqual(len(objs), 3) self.assertEqual(objs[0].params["s"], "string") self.assertEqual(objs[0].params["d"], datetime.datetime(2012, 2, 10, 20, 0, 0)) def test_children(self): json = { "types": [{ "type": "A", "parameters": { "s": "string" } }], "objects": [ { "type": "A", "id": 1, "parameters": { "s": "parent1" } }, { "type": "A", "parameters": { "s": "parent2" }, "children": [ { "type": "A", "parameters": { "s": "child21" } }, { "type": "A", "parameters": { "s": "child22" } }, ] }, { "type": "A", "id": 2, "parameters": { "s": "child11" } } ], "relations": [ { "relation": "child", "from": "id:2", "to": "id:1" } ] } jio = JsonIO(self.mapper, add_new_types=True) objs = jio.read_json(json) self.assertEqual(len(objs), 5) roots = self.mapper.find_roots() self.assertEqual(set([roots[0].params["s"], roots[1].params["s"]]), set(["parent1", "parent2"])) def test_data_export(self): class SomeEntity(Entity): declared_params = {"some_value": "string"} obj = SomeEntity() self.mapper.register(SomeEntity) self.mapper.save(obj) data_to_save = [("some key", "ABCDE", None), ("some other key", "ABCDEFGHIJ", "text")] for (key, value, mimetype) in data_to_save: obj.data[key].put(value) if mimetype: obj.data[key].mimetype = mimetype # we create a named temporary file and just hope # there is no conflict with the autodetected folder name tmp_name = tempfile.mktemp() jio = JsonIO(self.mapper, add_new_types=True) jio.write_file(self.mapper.find_roots(), tmp_name) # check that file has been written: for (data_key, data_value, data_mimetype) in data_to_save: data_file = os.path.join(tmp_name + ".data", obj.unique_id, data_key) with open(data_file) as df: self.assertEqual(df.read(), data_value) with open(tmp_name) as tmp_file: json_obj = json.load(tmp_file) #print json_obj jio_2 = JsonIO(self.mapper) self.assertRaises(IntegrityError, jio_2.read_file, tmp_name) self.mapper.delete(*self.mapper.find_roots()) jio_2 = JsonIO(self.mapper) jio_2.read_file(tmp_name) obj_in_db = self.mapper.find_first(SomeEntity) for (data_key, data_value, data_mimetype) in data_to_save: self.assertEqual(obj_in_db.data[data_key].get_string(), data_value) self.assertEqual(obj_in_db.data[data_key].mimetype, data_mimetype)
# -*- coding: utf-8 -*- from xdapy import Connection, Mapper connection = Connection.profile("demo") # use standard profile connection.create_tables() m = Mapper(connection) from objects import Experiment, Observer, Trial, Session m.register(Observer) m.register(Experiment) m.register(Trial) m.register(Session) f = open("demo/xml.xml") xml = f.read() m.typesFromXML(xml) with m.auto_session as session: session.add_all(m.fromXML(xml)) xml = m.toXML() print xml e1 = Experiment(project='MyProject', experimenter="John Do") e1.param['project'] = "NoProject" m.save(e1)
def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(Observer, Experiment, Trial, Session)
class TestStrJsonParams(unittest.TestCase): def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection) self.m.register(Experiment) def tearDown(self): self.connection.drop_tables() # need to dispose manually to avoid too many connections error self.connection.engine.dispose() def test_access(self): exp = Experiment(project="MyProject", int_value=20) self.assertEqual(exp.str_params["project"], "MyProject") self.assertEqual(exp.json_params["project"], "MyProject") self.assertEqual(exp.str_params["int_value"], "20") self.assertEqual(exp.json_params["int_value"], 20) def test_setter(self): exp = Experiment() exp.str_params["project"] = "MyProject" exp.str_params["int_value"] = "50" self.assertEqual(exp.params["project"], "MyProject") self.assertEqual(exp.params["int_value"], 50) exp.str_params["project"] = "My other project" exp.str_params["int_value"] = 70 self.assertEqual(exp.params["project"], "My other project") self.assertEqual(exp.params["int_value"], 70) def test_set_none(self): exp = Experiment(project="MyProject", int_value=20) def set_str(): exp.str_params["project"] = None self.assertRaises(ValueError, set_str) def set_json(): exp.json_params["project"] = None self.assertRaises(ValueError, set_json) def test_set_deletion(self): exp = Experiment(project="MyProject", int_value=20, experimenter="No Name") del exp.str_params["project"] self.assertRaises(KeyError, operator.getitem, exp.str_params, "project") self.assertRaises(KeyError, operator.getitem, exp.params, "project") del exp.str_params["int_value"] self.assertRaises(KeyError, operator.getitem, exp.str_params, "int_value") self.assertRaises(KeyError, operator.getitem, exp.params, "int_value") # experimenter unchanged self.assertEqual(exp.params, {"experimenter": "No Name"}) def test_len(self): exp = Experiment(project="MyProject", int_value=20, experimenter="No Name") self.assertEqual(len(exp.str_params), 3) self.assertEqual(len(exp.json_params), 3) def test_str_repr(self): exp = Experiment(project="MyProject", int_value=20, experimenter="No Name") str(exp.str_params) str(exp.json_params) repr(exp.str_params) repr(exp.json_params)
def setUp(self): self.connection = Connection.test() self.connection.create_tables() self.m = Mapper(self.connection)
# -*- coding: utf-8 -*- from xdapy import Connection, Mapper, Entity connection = Connection.profile("demo") # use standard profile connection_2 = Connection.default() # use standard profile # drop the old database structure connection.create_tables() connection_2.create_tables() m = Mapper(connection) m_2 = Mapper(connection_2) # from objects import Experiment, ... class Experiment(Entity): """Concrete class for experiments""" declared_params = { 'experimenter': 'string', 'project': 'string' } Experiment_nodate = Experiment class Experiment(Entity): """Concrete class for experiments""" declared_params = { 'experimenter': 'string', 'project': 'string', 'date': 'date' }