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'
}
