def test_or_lset(): # without axis assert LSet(['a', 'b']) | LSet(['c', 'd']) == LSet(['a', 'b', 'c', 'd']) assert LSet(['a', 'b', 'c']) | LSet(['c', 'd']) == LSet( ['a', 'b', 'c', 'd']) alpha = Axis('alpha=a,b,c,d') res = alpha['a', 'b'].set() | alpha['c', 'd'].set() assert res.axis is alpha assert res == alpha['a', 'b', 'c', 'd'].set() assert alpha['a', 'b', 'c'].set() | alpha['c', 'd'].set() == alpha['a', 'b', 'c', 'd'].set() alpha = Axis('alpha=a,b,c,d') res = alpha['a', 'b'].set() | alpha['c', 'd'] assert res.axis is alpha assert res == alpha['a', 'b', 'c', 'd'].set() assert alpha['a', 'b', 'c'].set() | alpha['c', 'd'] == alpha['a', 'b', 'c', 'd'].set() alpha = Axis('alpha=a,b,c,d') res = alpha['a', 'b'].set().named('ab') | alpha['c', 'd'].set().named('cd') assert res.axis is alpha assert res.name == 'ab | cd' assert res == alpha['a', 'b', 'c', 'd'].set() assert alpha['a', 'b', 'c'].set() | alpha['c', 'd'] == alpha['a', 'b', 'c', 'd'].set() num = Axis(range(10), 'num') assert num[1, 5, 3].set() | 4 == num[1, 5, 3, 4].set() assert num[1, 5, 3].set() | num[4] == num[1, 5, 3, 4].set() assert num[4].set() | num[1, 5, 3] == num[4, 1, 5, 3].set() assert num[:2].set() | num[8:] == num[0, 1, 2, 8, 9].set() assert num[:2].set() | num[5] == num[0, 1, 2, 5].set()
def test_init_lgroup(lgroups): assert lgroups.slice_both_named_wh_named_axis.name == "full" assert lgroups.slice_both_named_wh_named_axis.key == slice(1, 5, None) assert lgroups.slice_both_named_wh_named_axis.axis is age assert lgroups.slice_both_named.name == "named" assert lgroups.slice_both_named.key == slice(1, 5, None) assert lgroups.slice_both.key == slice(1, 5, None) assert lgroups.slice_start.key == slice(1, None, None) assert lgroups.slice_stop.key == slice(None, 5, None) assert lgroups.slice_none_no_axis.key == slice(None, None, None) assert lgroups.slice_none_wh_named_axis.axis is lipro assert lgroups.slice_none_wh_anonymous_axis.axis is anonymous assert lgroups.single_value.key == 'P03' assert lgroups.list.key == ['P01', 'P03', 'P04'] group = LGroup('1:5', age, age) assert group.name == age.name group = age['1:5'] >> age assert group.name == age.name group2 = LGroup('1', axis=age) group = LGroup('1', group2, axis=age) assert group.name == '1' group = age['1'] >> group2 assert group.name == '1' group2 = LGroup('1:5', 'age', age) group = LGroup('1:5', group2, axis=age) assert group.name == group2.name group = age['1:5'] >> group2 assert group.name == group2.name axis = Axis('axis=a,a0..a3,b,b0..b3,c,c0..c3') for code in axis.matching(regex='^.$'): group = axis.startingwith(code) >> code assert group.equals(axis.startingwith(code) >> str(code))
def test_contains(self): col = self.collection self.assertTrue('lipro' in col) self.assertFalse('nonexisting' in col) self.assertTrue(0 in col) self.assertTrue(1 in col) self.assertTrue(2 in col) self.assertTrue(-1 in col) self.assertTrue(-2 in col) self.assertTrue(-3 in col) self.assertFalse(3 in col) # objects actually in col self.assertTrue(self.lipro in col) self.assertTrue(self.sex in col) self.assertTrue(self.age in col) # other axis with the same name self.assertTrue(self.sex2 in col) self.assertFalse(self.geo in col) self.assertFalse(self.value in col) # test anonymous axes anon = Axis([0, 1]) col.append(anon) self.assertTrue(anon in col) # different object, same values anon2 = anon.copy() self.assertTrue(anon2 in col) # different values anon3 = Axis([0, 2]) self.assertFalse(anon3 in col)
def test_index(col): assert col.index('lipro') == 0 with pytest.raises(ValueError): col.index('nonexisting') assert col.index(0) == 0 assert col.index(1) == 1 assert col.index(2) == 2 assert col.index(-1) == -1 assert col.index(-2) == -2 assert col.index(-3) == -3 with pytest.raises(ValueError): col.index(3) # objects actually in col assert col.index(lipro) == 0 assert col.index(sex) == 1 assert col.index(age) == 2 assert col.index(sex2) == 1 with pytest.raises(ValueError): col.index(geo) with pytest.raises(ValueError): col.index(value) # test anonymous axes anon = Axis([0, 1]) col.append(anon) assert col.index(anon) == 3 anon2 = anon.copy() assert col.index(anon2) == 3 anon3 = Axis([0, 2]) with pytest.raises(ValueError): col.index(anon3)
def test_add(self): col = self.collection.copy() lipro, sex, age = self.lipro, self.sex, self.age geo, value = self.geo, self.value # 1) list # a) no dupe new = col + [self.geo, value] self.assertEqual(new, [lipro, sex, age, geo, value]) # check the original has not been modified self.assertEqual(col, self.collection) # b) with compatible dupe # the "new" age axis is ignored (because it is compatible) new = col + [Axis('geo=A11,A12,A13'), Axis('age=0..7')] self.assertEqual(new, [lipro, sex, age, geo]) # c) with incompatible dupe # XXX: the "new" age axis is ignored. We might want to ignore it if it # is the same but raise an exception if it is different with self.assertRaises(ValueError): col + [Axis('geo=A11,A12,A13'), Axis('age=0..6')] # 2) other AxisCollection new = col + AxisCollection([geo, value]) self.assertEqual(new, [lipro, sex, age, geo, value])
def test_add(session): i = Axis('i=i0..i2') i01 = i['i0,i1'] >> 'i01' session.add(i, i01, j='j') assert i.equals(session.i) assert i01 == session.i01 assert session.j == 'j'
def test_add(session): h = Axis('h=h0..h2') h01 = h['h0,h1'] >> 'h01' session.add(h, h01, i='i') assert h.equals(session.h) assert h01 == session.h01 assert session.i == 'i'
def test_init_lgroup(lgroups): assert lgroups.slice_both_named_wh_named_axis.name == "full" assert lgroups.slice_both_named_wh_named_axis.key == slice(1, 5, None) assert lgroups.slice_both_named_wh_named_axis.axis is age assert lgroups.slice_both_named.name == "named" assert lgroups.slice_both_named.key == slice(1, 5, None) assert lgroups.slice_both.key == slice(1, 5, None) assert lgroups.slice_start.key == slice(1, None, None) assert lgroups.slice_stop.key == slice(None, 5, None) assert lgroups.slice_none_no_axis.key == slice(None, None, None) assert lgroups.slice_none_wh_named_axis.axis is lipro assert lgroups.slice_none_wh_anonymous_axis.axis is anonymous assert lgroups.single_value.key == 'P03' assert lgroups.list.key == ['P01', 'P03', 'P04'] group = LGroup('1:5', age, age) assert group.name == age.name group = age['1:5'] >> age assert group.name == age.name group2 = LGroup('1', axis=age) group = LGroup('1', group2, axis=age) assert group.name == '1' group = age['1'] >> group2 assert group.name == '1' group2 = LGroup('1:5', 'age', age) group = LGroup('1:5', group2, axis=age) assert group.name == group2.name group = age['1:5'] >> group2 assert group.name == group2.name axis = Axis('axis=a,a0..a3,b,b0..b3,c,c0..c3') for code in axis.matching('^.$'): group = axis.startingwith(code) >> code assert group.equals(axis.startingwith(code) >> str(code))
def test_ipfp(self): a = Axis(2, 'a') b = Axis(2, 'b') initial = LArray([[2, 1], [1, 2]], [a, b]) # array sums already match target sums # [3, 3], [3, 3] r = ipfp([initial.sum(a), initial.sum(b)], initial) assert_array_equal(r, [[2, 1], [1, 2]]) # array sums do not match target sums (ie the usual case) along_a = LArray([2, 1], b) along_b = LArray([1, 2], a) r = ipfp([along_a, along_b], initial) assert_array_equal(r, [[0.8, 0.2], [1.0, 1.0]]) # same as above but using a more precise threshold r = ipfp([along_a, along_b], initial, threshold=0.01) assert_array_equal(r, [[0.8450704225352113, 0.15492957746478875], [1.1538461538461537, 0.8461538461538463]]) # inverted target sums with self.assertRaisesRegexp( ValueError, "axes of target sum along axis 0 \(a\) do not match corresponding " "array axes: got {a\*} but expected {b\*}. Are the target sums in the " "correct order\?"): ipfp([along_b, along_a], initial, threshold=0.01)
def test_init(self): sex_tuple = ('M', 'F') sex_list = ['M', 'F'] sex_array = np.array(sex_list) # wildcard axis axis = Axis(10, 'axis') assert len(axis) == 10 assert list(axis.labels) == list(range(10)) # tuple of strings assert_array_equal(Axis(sex_tuple, 'sex').labels, sex_array) # list of strings assert_array_equal(Axis(sex_list, 'sex').labels, sex_array) # array of strings assert_array_equal(Axis(sex_array, 'sex').labels, sex_array) # single string assert_array_equal(Axis('sex=M,F').labels, sex_array) # list of ints assert_array_equal(Axis(range(116), 'age').labels, np.arange(116)) # range-string axis = Axis('0..115', 'age') assert_array_equal(axis.labels, np.arange(116)) # another axis group group = axis[:10] group_axis = Axis(group) assert_array_equal(group_axis.labels, np.arange(11)) assert_array_equal(group_axis.name, 'age') # another axis as labels argument other = Axis('other=0..10') axis = Axis(other, 'age') assert_array_equal(axis.labels, other.labels) assert_array_equal(axis.name, 'age')
class TestInheritance(TestCheckedSession): # override variables b = b2 c: int = 5 f: CheckedArray((a3, b2), dtype=int) h: CheckedArray((Axis(3), Axis(2))) # new variables n0 = 'first new var' n1: str
def test_aslarray(self): with open_excel(visible=False) as wb: sheet = wb[0] arr1 = ndtest([Axis(2), Axis(3)]) # no header so that we have an uniform dtype for the whole sheet sheet['A1'] = arr1 res1 = aslarray(sheet['A1:C2']) assert res1.equals(arr1) assert res1.dtype == arr1.dtype
def test_ipfp_no_values(): # 6, 12, 18 along_a = ndtest([(3, 'b')], start=1) * 6 # 6, 12, 18 along_b = ndtest([(3, 'a')], start=1) * 6 r = ipfp([along_a, along_b]) assert_array_equal(r, [[1.0, 2.0, 3.0], [2.0, 4.0, 6.0], [3.0, 6.0, 9.0]]) along_a = Array([2, 1], Axis(2, 'b')) along_b = Array([1, 2], Axis(2, 'a')) r = ipfp([along_a, along_b]) assert_array_equal(r, [[2 / 3, 1 / 3], [4 / 3, 2 / 3]])
def test_add(col): col2 = col.copy() new = col2 + [geo, value] assert new == [lipro, sex, age, geo, value] assert col2 == col new = col2 + [Axis('geo=A11,A12,A13'), Axis('age=0..7')] assert new == [lipro, sex, age, geo] with pytest.raises(ValueError): col2 + [Axis('geo=A11,A12,A13'), Axis('age=0..6')] # 2) other AxisCollection new = col2 + AxisCollection([geo, value]) assert new == [lipro, sex, age, geo, value]
class TestCheckedSession(CheckedSession): b = b b024 = b024 a: Axis a2: Axis anonymous = anonymous a01: Group ano01 = ano01 c: str = c d = d e: Array g: Array f: CheckedArray((Axis(3), Axis(2))) h: CheckedArray((a3, b2), dtype=int)
def test_sub(): col = AxisCollection('a0,a1;b0,b1,b2') res = col - Axis(2) assert res == AxisCollection('b0,b1,b2') res = col - Axis(3) assert res == AxisCollection('a0,a1') col = AxisCollection('a0,a1;b0,b1') # when several axes are compatible, remove first res = col - Axis(2) assert res == AxisCollection('b0,b1') # when no axis is compatible, do not remove any res = col - Axis(3) assert res == col
def test_getitem_lgroup_keys(self): def group_equal(g1, g2): return (g1.key == g2.key and g1.name == g2.name and g1.axis is g2.axis) age = Axis(range(100), 'age') ages = [1, 5, 9] val_only = LGroup(ages) self.assertTrue(group_equal(age[val_only], LGroup(ages, axis=age))) self.assertTrue( group_equal(age[val_only] >> 'a_name', LGroup(ages, 'a_name', axis=age))) val_name = LGroup(ages, 'val_name') self.assertTrue( group_equal(age[val_name], LGroup(ages, 'val_name', age))) self.assertTrue( group_equal(age[val_name] >> 'a_name', LGroup(ages, 'a_name', age))) val_axis = LGroup(ages, axis=age) self.assertTrue(group_equal(age[val_axis], LGroup(ages, axis=age))) self.assertTrue( group_equal(age[val_axis] >> 'a_name', LGroup(ages, 'a_name', axis=age))) val_axis_name = LGroup(ages, 'val_axis_name', age) self.assertTrue( group_equal(age[val_axis_name], LGroup(ages, 'val_axis_name', age))) self.assertTrue( group_equal(age[val_axis_name] >> 'a_name', LGroup(ages, 'a_name', age)))
def test_add_cs(checkedsession): cs = checkedsession test_add(cs) u = Axis('u=u0..u2') with must_warn(UserWarning, msg=f"'u' is not declared in '{cs.__class__.__name__}'", check_file=False): cs.add(u)
def _test_io(tmpdir, session, meta, engine, ext): filename = f"test_{engine}.{ext}" if 'csv' not in engine else f"test_{engine}{ext}" fpath = tmp_path(tmpdir, filename) is_excel_or_csv = 'excel' in engine or 'csv' in engine kind = Array if is_excel_or_csv else (Axis, Group, Array) + _supported_scalars_types session = session.filter(kind=kind) session.meta = meta # save and load session.save(fpath, engine=engine) s = Session() s.load(fpath, engine=engine) # use Session.names instead of Session.keys because CSV, Excel and HDF do *not* keep ordering assert s.names == session.names assert s.equals(session) if not is_excel_or_csv: for key in s.filter(kind=Axis).keys(): assert s[key].dtype == session[key].dtype if engine != 'pandas_excel': assert s.meta == meta # update a Group + an Axis + an array (overwrite=False) a4 = Axis('a=0..3') a4_01 = a3['0,1'] >> 'a01' e2 = ndtest((a4, 'b=b0..b2')) h2 = full_like(h, fill_value=10) Session(a=a4, a01=a4_01, e=e2, h=h2).save(fpath, overwrite=False, engine=engine) s = Session() s.load(fpath, engine=engine) if engine == 'pandas_excel': # Session.save() via engine='pandas_excel' always overwrite the output Excel files assert s.names == ['e', 'h'] elif is_excel_or_csv: assert s.names == ['e', 'f', 'g', 'h'] else: assert s.names == session.names assert s['a'].equals(a4) assert s['a01'].equals(a4_01) assert_array_nan_equal(s['e'], e2) if engine != 'pandas_excel': assert s.meta == meta # load only some objects session.save(fpath, engine=engine) s = Session() names_to_load = ['e', 'f'] if is_excel_or_csv else [ 'a', 'a01', 'a2', 'anonymous', 'e', 'f', 's_bool', 's_int' ] s.load(fpath, names=names_to_load, engine=engine) assert s.names == names_to_load if engine != 'pandas_excel': assert s.meta == meta return fpath
def setUp(self): self.age = Axis('age=0..10') self.lipro = Axis('lipro=P01..P05') self.anonymous = Axis(range(3)) self.slice_both_named_wh_named_axis = LGroup('1:5', "full", self.age) self.slice_both_named = LGroup('1:5', "named") self.slice_both = LGroup('1:5') self.slice_start = LGroup('1:') self.slice_stop = LGroup(':5') self.slice_none_no_axis = LGroup(':') self.slice_none_wh_named_axis = LGroup(':', axis=self.lipro) self.slice_none_wh_anonymous_axis = LGroup(':', axis=self.anonymous) self.single_value = LGroup('P03') self.list = LGroup('P01,P03,P04') self.list_named = LGroup('P01,P03,P04', "P134")
def test_and_lset(): # without axis assert LSet(['a', 'b', 'c']) & LSet(['c', 'd']) == LSet(['c']) alpha = Axis('alpha=a,b,c,d') res = alpha['a', 'b', 'c'].named('abc').set() & alpha['c', 'd'].named('cd') assert res.axis is alpha assert res.name == 'abc & cd' assert res == alpha[['c']].set()
def test_positional(self): age = Axis('age=0..115') # these are NOT equivalent (not translated until used in an LArray # self.assertEqual(age.i[:17], age[':17']) key = age.i[:-1] self.assertEqual(key.key, slice(None, -1)) self.assertIs(key.axis, age)
def test_getitem(self): age = Axis('age=0..10') # a tuple a159 = age[1, 5, 9] self.assertEqual(a159.key, [1, 5, 9]) self.assertIs(a159.name, None) self.assertIs(a159.axis, age) # a normal list a159 = age[[1, 5, 9]] self.assertEqual(a159.key, [1, 5, 9]) self.assertIs(a159.name, None) self.assertIs(a159.axis, age) # a string list a159 = age['1,5,9'] self.assertEqual(a159.key, [1, 5, 9]) self.assertIs(a159.name, None) self.assertIs(a159.axis, age) # a normal slice a10to20 = age[5:9] self.assertEqual(a10to20.key, slice(5, 9)) self.assertIs(a10to20.axis, age) # a string slice a10to20 = age['5:9'] self.assertEqual(a10to20.key, slice(5, 9)) self.assertIs(a10to20.axis, age) # with name group = age[[1, 5, 9]] >> 'test' self.assertEqual(group.key, [1, 5, 9]) self.assertEqual(group.name, 'test') self.assertIs(group.axis, age) # all group = age[:] >> 'all' self.assertEqual(group.key, slice(None)) self.assertIs(group.axis, age) # an axis age2 = Axis('age=0..5') group = age[age2] assert list(group.key) == list(age2.labels)
def test_and(self): # without axis self.assertEqual(LSet(['a', 'b', 'c']) & LSet(['c', 'd']), LSet(['c'])) # with axis & name alpha = Axis('alpha=a,b,c,d') res = alpha['a', 'b', 'c'].named('abc').set() & alpha['c', 'd'].named('cd') self.assertIs(res.axis, alpha) self.assertEqual(res.name, 'abc & cd') self.assertEqual(res, alpha[['c']].set())
def setUp(self): self.a = Axis([], 'a') self.b = Axis([], 'b') self.c = 'c' self.d = {} self.e = ndrange([(2, 'a0'), (3, 'a1')]) self.e2 = ndrange(('a=a0..a2', 'b=b0..b2')) self.f = ndrange([(3, 'a0'), (2, 'a1')]) self.g = ndrange([(2, 'a0'), (4, 'a1')]) self.session = Session([ ('b', self.b), ('a', self.a), ('c', self.c), ('d', self.d), ('e', self.e), ('g', self.g), ('f', self.f), ])
def test_getitem(self): axis = Axis("a=a0,a1") assert axis.i[0][0] == 'a' assert axis.i[0][1] == '0' assert axis.i[0:1][1] == 'a1' assert axis.i[:][1] == 'a1' assert list(axis.i[:][0:2]) == ['a0', 'a1'] assert list((axis.i[:][[1, 0]])) == ['a1', 'a0'] assert axis.i[[0, 1, 0]][2] == 'a0' assert axis.i[(0, 1, 0)][2] == 'a0'
def test_or(self): # without axis self.assertEqual( LSet(['a', 'b']) | LSet(['c', 'd']), LSet(['a', 'b', 'c', 'd'])) self.assertEqual( LSet(['a', 'b', 'c']) | LSet(['c', 'd']), LSet(['a', 'b', 'c', 'd'])) # with axis (pure) alpha = Axis('alpha=a,b,c,d') res = alpha['a', 'b'].set() | alpha['c', 'd'].set() self.assertIs(res.axis, alpha) self.assertEqual(res, alpha['a', 'b', 'c', 'd'].set()) self.assertEqual(alpha['a', 'b', 'c'].set() | alpha['c', 'd'].set(), alpha['a', 'b', 'c', 'd'].set()) # with axis (mixed) alpha = Axis('alpha=a,b,c,d') res = alpha['a', 'b'].set() | alpha['c', 'd'] self.assertIs(res.axis, alpha) self.assertEqual(res, alpha['a', 'b', 'c', 'd'].set()) self.assertEqual(alpha['a', 'b', 'c'].set() | alpha['c', 'd'], alpha['a', 'b', 'c', 'd'].set()) # with axis & name alpha = Axis('alpha=a,b,c,d') res = alpha['a', 'b'].set().named('ab') | alpha['c', 'd'].set().named('cd') self.assertIs(res.axis, alpha) self.assertEqual(res.name, 'ab | cd') self.assertEqual(res, alpha['a', 'b', 'c', 'd'].set()) self.assertEqual(alpha['a', 'b', 'c'].set() | alpha['c', 'd'], alpha['a', 'b', 'c', 'd'].set()) # numeric axis num = Axis(range(10), 'num') # single int self.assertEqual(num[1, 5, 3].set() | 4, num[1, 5, 3, 4].set()) self.assertEqual(num[1, 5, 3].set() | num[4], num[1, 5, 3, 4].set()) self.assertEqual(num[4].set() | num[1, 5, 3], num[4, 1, 5, 3].set()) # slices self.assertEqual(num[:2].set() | num[8:], num[0, 1, 2, 8, 9].set()) self.assertEqual(num[:2].set() | num[5], num[0, 1, 2, 5].set())
def test_equals(): a = Axis('a=a0..a2') # keys are single value assert a['a0'].equals(a['a0']) # keys are arrays assert a[np.array(['a0', 'a2'])].equals(a[np.array(['a0', 'a2'])]) # axis names anonymous_axis = Axis('a0..a2') assert anonymous_axis['a0:a2'].equals(anonymous_axis['a0:a2']) assert not a['a0:a2'].equals(anonymous_axis['a0:a2']) assert not a['a0:a2'].equals(a.rename('other_name')['a0:a2']) # list of labels a02 = a['a0,a1,a2'] >> 'group' assert a02.equals(a02) a02_unamed = a['a0,a1,a2'] assert not a02.equals(a02_unamed) a13 = a['a1,a2,a3'] >> 'group' assert not a02.equals(a13) a02_other_axis_name = a.rename('other_name')['a0,a1,a2'] >> 'group' assert not a02.equals(a02_other_axis_name)
def test_getitem(self): axis = Axis("a=a0,a1") assert axis['a0'][0] == 'a' assert axis['a0'][1] == '0' assert axis['a0':'a1'][1] == 'a1' assert axis[:][1] == 'a1' assert list(axis[:][0:2]) == ['a0', 'a1'] assert list((axis[:][[1, 0]])) == ['a1', 'a0'] assert axis[['a0', 'a1', 'a0']][2] == 'a0' assert axis[('a0', 'a1', 'a0')][2] == 'a0' assert axis[ndtest("a=a0,a1,a0")][2] == 2
def __init__(self): self.code_axis = Axis('code=a0..a4') self.slice_both_named = self.code_axis.i[1:4] >> 'a123' self.slice_both = self.code_axis.i[1:4] self.slice_start = self.code_axis.i[1:] self.slice_stop = self.code_axis.i[:4] self.slice_none = self.code_axis.i[:] self.first_value = self.code_axis.i[0] self.last_value = self.code_axis.i[-1] self.list = self.code_axis.i[[0, 1, -2, -1]] self.tuple = self.code_axis.i[0, 1, -2, -1]
def test_init(self): self.assertEqual(self.slice_both_named_wh_named_axis.name, "full") self.assertEqual(self.slice_both_named_wh_named_axis.key, slice(1, 5, None)) self.assertIs(self.slice_both_named_wh_named_axis.axis, self.age) self.assertEqual(self.slice_both_named.name, "named") self.assertEqual(self.slice_both_named.key, slice(1, 5, None)) self.assertEqual(self.slice_both.key, slice(1, 5, None)) self.assertEqual(self.slice_start.key, slice(1, None, None)) self.assertEqual(self.slice_stop.key, slice(None, 5, None)) self.assertEqual(self.slice_none_no_axis.key, slice(None, None, None)) self.assertIs(self.slice_none_wh_named_axis.axis, self.lipro) self.assertIs(self.slice_none_wh_anonymous_axis.axis, self.anonymous) self.assertEqual(self.single_value.key, 'P03') self.assertEqual(self.list.key, ['P01', 'P03', 'P04']) # passing an axis as name group = LGroup('1:5', self.age, self.age) assert group.name == self.age.name group = self.age['1:5'] >> self.age assert group.name == self.age.name # passing an unnamed group as name group2 = LGroup('1', axis=self.age) group = LGroup('1', group2, axis=self.age) assert group.name == '1' group = self.age['1'] >> group2 assert group.name == '1' # passing a named group as name group2 = LGroup('1:5', 'age', self.age) group = LGroup('1:5', group2, axis=self.age) assert group.name == group2.name group = self.age['1:5'] >> group2 assert group.name == group2.name # additional test axis = Axis('axis=a,a0..a3,b,b0..b3,c,c0..c3') for code in axis.matching('^.$'): group = axis.startingwith(code) >> code assert group == axis.startingwith(code) >> str(code)
def setUp(self): self.lipro = Axis('lipro=P01..P04') self.sex = Axis('sex=M,F') self.sex2 = Axis('sex=F,M') self.age = Axis('age=0..7') self.geo = Axis('geo=A11,A12,A13') self.value = Axis('value=0..10') self.collection = AxisCollection((self.lipro, self.sex, self.age))
def test_contains(col): assert 'lipro' in col assert not ('nonexisting' in col) assert 0 in col assert 1 in col assert 2 in col assert -1 in col assert -2 in col assert -3 in col assert not (3 in col) assert lipro in col assert sex in col assert age in col assert sex2 in col assert not (geo in col) assert not (value in col) anon = Axis([0, 1]) col.append(anon) assert anon in col anon2 = anon.copy() assert anon2 in col anon3 = Axis([0, 2]) assert not (anon3 in col)
def test_matching(): sutcode = Axis(['A23', 'A2301', 'A25', 'A2501'], 'sutcode') assert sutcode.matching('^...$') == LGroup(['A23', 'A25']) assert sutcode.startingwith('A23') == LGroup(['A23', 'A2301']) assert sutcode.endingwith('01') == LGroup(['A2301', 'A2501'])
def test_h5_io(tmpdir): age = Axis('age=0..10') lipro = Axis('lipro=P01..P05') anonymous = Axis(range(3)) wildcard = Axis(3, 'wildcard') fpath = os.path.join(str(tmpdir), 'axes.h5') # ---- default behavior ---- # int axis age.to_hdf(fpath) age2 = read_hdf(fpath, key=age.name) assert age.equals(age2) # string axis lipro.to_hdf(fpath) lipro2 = read_hdf(fpath, key=lipro.name) assert lipro.equals(lipro2) # anonymous axis with pytest.raises(ValueError, message="Argument key must be provided explicitly in case of anonymous axis"): anonymous.to_hdf(fpath) # wildcard axis wildcard.to_hdf(fpath) wildcard2 = read_hdf(fpath, key=wildcard.name) assert wildcard2.iswildcard assert wildcard.equals(wildcard2) # ---- specific key ---- # int axis key = 'axis_age' age.to_hdf(fpath, key) age2 = read_hdf(fpath, key=key) assert age.equals(age2) # string axis key = 'axis_lipro' lipro.to_hdf(fpath, key) lipro2 = read_hdf(fpath, key=key) assert lipro.equals(lipro2) # anonymous axis key = 'axis_anonymous' anonymous.to_hdf(fpath, key) anonymous2 = read_hdf(fpath, key=key) assert anonymous2.name is None assert_array_equal(anonymous.labels, anonymous2.labels) # wildcard axis key = 'axis_wildcard' wildcard.to_hdf(fpath, key) wildcard2 = read_hdf(fpath, key=key) assert wildcard2.iswildcard assert wildcard.equals(wildcard2) # ---- specific hdf group + key ---- hdf_group = 'my_axes' # int axis key = hdf_group + '/axis_age' age.to_hdf(fpath, key) age2 = read_hdf(fpath, key=key) assert age.equals(age2) # string axis key = hdf_group + '/axis_lipro' lipro.to_hdf(fpath, key) lipro2 = read_hdf(fpath, key=key) assert lipro.equals(lipro2) # anonymous axis key = hdf_group + '/axis_anonymous' anonymous.to_hdf(fpath, key) anonymous2 = read_hdf(fpath, key=key) assert anonymous2.name is None assert_array_equal(anonymous.labels, anonymous2.labels) # wildcard axis key = hdf_group + '/axis_wildcard' wildcard.to_hdf(fpath, key) wildcard2 = read_hdf(fpath, key=key) assert wildcard2.iswildcard assert wildcard.equals(wildcard2)
def test_split(): # test splitting an anonymous axis a_b = Axis('a0_b0,a0_b1,a0_b2,a1_b0,a1_b1,a1_b2') a, b = a_b.split() assert a.equals(Axis(['a0', 'a1'])) assert b.equals(Axis(['b0', 'b1', 'b2']))
def test_translate(): # an axis with labels having the object dtype a = Axis(np.array(["a0", "a1"], dtype=object), 'a') assert a.index('a1') == 1 assert a.index('a1 >> A1') == 1