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"])
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)
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))
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)
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
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) m.save(e1) m.save(e1) m.save(e1) e2 = Experiment(project='YourProject', experimenter="John Doe") o1 = Observer(name="Max Mustermann", handedness="right", age=26) o2 = Observer(name="Susanne Sorgenfrei", handedness='left', age=38) o3 = Observer(name="Susi Sorgen", handedness='left', age=40) print o3.param["name"] import datetime s1 = Session(date=datetime.date.today()) s2 = Session(date=datetime.date.today()) # e1.context.append(Context(context=s2))
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])
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) t1.parent = e1 t2.parent = e1 t3.parent = e2 t4.parent = e3 s1_1.parent = t1 s1_2.parent = t1 s2_1.parent = t2 s2_2.parent = t2 s3_1.parent = t3 s4_1.parent = t4 t1.attach("Observer", o1) t2.attach("Observer", o1)
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 exp_monorail.info() print ""
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()
# available types: # 'integer', 'float', 'string', 'date', 'time', 'datetime', 'boolean' # Next: register the objects m.register(Experiment) m.register(Trial) m.register(Observer) # for this data we have the convention: # each Trial has one Experiment it belongs to. (parent–child relationship) # Observers don’t belong to anything but Trials can hold a connection to an Observer. e1 = Experiment(project="My Project", experimenter="John Do") m.save(e1) e2 = Experiment() e2.params["project"] = "My other project" t1 = Trial() t1.parent = e1 t1.data["data set 1"].put("Some data") o1 = Observer(name="John H. Observer", age=31) t1.attach("Observer", o1) m.save(e1, e2, t1, o1)
# Next: register the objects m.register(Experiment_nodate) m_2.register(Experiment) m.register(Trial) m.register(Observer) # for this data we have the convention: # each Trial has one Experiment it belongs to. (parent–child relationship) # Observers don’t belong to anything but Trials can hold a connection to an Observer. e1 = Experiment(project="My Project", experimenter=u"Dareios Marika Nainsí") e2 = Experiment(project="My Project", experimenter=u"Malin Calliope Lilly") e2.parent = e1 e3 = Experiment(project="My Project", experimenter=u"Ilinka Iodocus") m.save(e1, e2, e3) e3.data["a"].put("Some Data") e3.data["b"].put("Even more data") e4 = Experiment(project="My other Project", experimenter="Nichol Pauline") m_2.save(e4) e3.attach("O", e1) m.save(e3, e2) mapping = {Experiment_nodate: Experiment} from sqlalchemy.orm import exc