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
#all objects are root
#m.save(e1)
#m.save(e2, o1, o2, o3)
#m.save(s1, s2)
with m.auto_session as session:
session.add_all([e1, e2, o1, o2, o3, s1, s2])
# print m.get_children(e1)
# print m.get_children(o1, 1)
# print m.get_data_matrix([], {'Observer':['age','name']})
print "---"
experiments = m.find_all(Experiment)
for num, experiment in enumerate(experiments):
print experiment._params
# experiment.param["countme"] = num
experiment.param["project"] = "PPP" + str(num)
experiments = m.find_all(Experiment(project="PPP1"))
for num, experiment in enumerate(experiments):
print experiment._params
e1.data = {"hlkk": "lkjlkjkl#äjkljysdsa"}
m.save(e1)
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
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])
trial1_1.info()
# test print
exp_monorail.print_tree()
print ""
exp_neptune.print_tree()
print ""
obs_1.print_tree()
print ""
trial1_1.print_tree()
#exp_neptune.attach("C", obs_1)
from xdapy.structures import Context
print m.find_all(Context)
#m.delete(obs_1)
#print m.find_all(Context)
m.delete(*m.find_all(Context))
print m.find_all(Context)
print m.find_all(Experiment)
contx = m.find_first(Context)
#m.registerConnection(Experiment, Observer, "Observer")
exp_monorail.attach("Observer", obs_1)
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()
m.save(e)
f.close()
ee = m.find_all(E)
for e in ee:
if not "100M" in e.data.keys():
print "N"
m.delete(e)
continue
print "KEYS", e.data.keys()
out = open("out.dat", "w")
e.data["100M"].get(out)
print e.data["100M"].size()
print e.data["100M"].is_consistent()
print ""
print "CHUNKS"
print e.data["100M"].chunks()
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)
experiment1 = Experiment(project="Fake Experiment", experimenter="Aaron Duindam")
experiment2 = Experiment(project="Complex Experiment", experimenter="Yasmin J. Winter")
observer1 = Observer(name=u"Irena Albertsdóttir", age=44)
observer2 = Observer(name="Semrawit Welde", age=28)
observer3 = Observer(name="Giraldo Ortega Rico", age=18)
observer4 = Observer(name="Isabel Blomqvist", age=47)
m.save(experiment1, experiment2, observer1, observer2, observer3, observer4)
#print m.toXML()
# find an object…
from xdapy.operators import *
print m.find_all(Experiment, {'experimenter': "John Do"})
print m.find(Experiment, {'experimenter': "John Do"}).all()
print m.find(Experiment, {'experimenter': "John Do"}).first()
print m.find_all(Experiment(experimenter="John Do"))
print m.find_all(Experiment, {'experimenter': "%J%"})
print m.find_all(Observer, filter={"name": "%Blom%"})
print m.find_all(Observer, filter={"name": ["%"]})
print m.find_all(Observer, filter={"age": range(30, 50), "name": ["%Alb%"]})
print m.find_all(Observer, filter={"age": between(30, 50)})
print m.find_all(Observer, filter={"age": 18})
print m.find_all(Observer, filter={"age": gt(20)})
#print m.find_all(Session, filter={"date": ge(datetime.date.today())})
