def test_xlsx_pandas_io(tmpdir, session, meta): fpath = tmp_path(tmpdir, 'test_session.xlsx') session.meta = meta session.save(fpath, engine='pandas_excel') s = Session() s.load(fpath, engine='pandas_excel') assert list(s.keys()) == ['a', 'b', 'a01', 'b12', 'e', 'g', 'f'] assert s.meta == meta # update a Group + an Axis + an array # XXX: overwrite is not taken into account by the pandas_excel engine a2 = Axis('a=0..2') a2_01 = a2['0,1'] >> 'a01' e2 = ndtest((a2, 'b=b0..b2')) Session(a=a2, a01=a2_01, e=e2, meta=meta).save(fpath, engine='pandas_excel') s = Session() s.load(fpath, engine='pandas_excel') assert list(s.keys()) == ['a', 'a01', 'e'] assert s['a'].equals(a2) assert all(s['a01'] == a2_01) assert_array_nan_equal(s['e'], e2) assert s.meta == meta # load only some objects session.save(fpath, engine='pandas_excel') s = Session() s.load(fpath, names=['a', 'a01', 'e', 'f'], engine='pandas_excel') assert list(s.keys()) == ['a', 'a01', 'e', 'f'] assert s.meta == meta
def test_sub(self): sess = self.session.filter(kind=LArray) other = Session({'e': self.e - 1, 'f': 1}) diff = sess - other assert_array_nan_equal(diff['e'], np.full((2, 3), 1, dtype=np.int32)) assert_array_nan_equal(diff['f'], np.arange(-1, 5).reshape(3, 2)) self.assertTrue(isnan(diff['g']).all())
def test_to_globals(self): with pytest.warns(RuntimeWarning) as caught_warnings: self.session.to_globals() assert len(caught_warnings) == 1 assert caught_warnings[0].message.args[0] == "Session.to_globals should usually only be used in interactive " \ "consoles and not in scripts. Use warn=False to deactivate this " \ "warning." assert caught_warnings[0].filename == __file__ self.assertIs(a, self.a) self.assertIs(b, self.b) self.assertIs(c, self.c) self.assertIs(d, self.d) self.assertIs(e, self.e) self.assertIs(f, self.f) self.assertIs(g, self.g) # test inplace backup_dest = e backup_value = self.session.e.copy() self.session.e = zeros_like(e) self.session.to_globals(inplace=True, warn=False) # check the variable is correct (the same as before) self.assertIs(e, backup_dest) self.assertIsNot(e, self.session.e) # check the content has changed assert_array_nan_equal(e, self.session.e) self.assertFalse(larray_equal(e, backup_value))
def test_pickle_io(tmpdir, session, meta): fpath = tmp_path(tmpdir, 'test_session.pkl') session.meta = meta session.save(fpath) s = Session() s.load(fpath, engine='pickle') assert list(s.keys()) == ['b', 'a', 'b12', 'a01', 'e', 'g', 'f'] assert s.meta == meta # update a Group + an Axis + an array (overwrite=False) a2 = Axis('a=0..2') a2_01 = a2['0,1'] >> 'a01' e2 = ndtest((a2, 'b=b0..b2')) Session(a=a2, a01=a2_01, e=e2).save(fpath, overwrite=False) s = Session() s.load(fpath, engine='pickle') assert list(s.keys()) == ['b', 'a', 'b12', 'a01', 'e', 'g', 'f'] assert s['a'].equals(a2) assert isinstance(a2_01, Group) assert isinstance(s['a01'], Group) assert s['a01'].eval() == a2_01.eval() assert_array_nan_equal(s['e'], e2) assert s.meta == meta # load only some objects s = Session() s.load(fpath, names=['a', 'a01', 'e', 'f'], engine='pickle') assert list(s.keys()) == ['a', 'a01', 'e', 'f'] assert s.meta == meta
def test_h5_io(tmpdir, session, meta): fpath = tmp_path(tmpdir, 'test_session.h5') session.meta = meta session.save(fpath) s = Session() s.load(fpath) # HDF does *not* keep ordering (ie, keys are always sorted + # read Axis objects, then Groups objects and finally LArray objects) assert list(s.keys()) == ['a', 'b', 'a01', 'b12', 'e', 'f', 'g'] assert s.meta == meta # update a Group + an Axis + an array (overwrite=False) a2 = Axis('a=0..2') a2_01 = a2['0,1'] >> 'a01' e2 = ndtest((a2, 'b=b0..b2')) Session(a=a2, a01=a2_01, e=e2).save(fpath, overwrite=False) s = Session() s.load(fpath) assert list(s.keys()) == ['a', 'b', 'a01', 'b12', 'e', 'f', 'g'] assert s['a'].equals(a2) assert all(s['a01'] == a2_01) assert_array_nan_equal(s['e'], e2) assert s.meta == meta # load only some objects s = Session() s.load(fpath, names=['a', 'a01', 'e', 'f']) assert list(s.keys()) == ['a', 'a01', 'e', 'f'] assert s.meta == meta
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 test_xlsx_xlwings_io(tmpdir, session, meta): fpath = tmp_path(tmpdir, 'test_session_xw.xlsx') session.meta = meta # test save when Excel file does not exist session.save(fpath, engine='xlwings_excel') s = Session() s.load(fpath, engine='xlwings_excel') # ordering is only kept if the file did not exist previously (otherwise the ordering is left intact) assert list(s.keys()) == ['a', 'b', 'a01', 'b12', 'e', 'g', 'f'] assert s.meta == meta # update a Group + an Axis + an array (overwrite=False) a2 = Axis('a=0..2') a2_01 = a2['0,1'] >> 'a01' e2 = ndtest((a2, 'b=b0..b2')) Session(a=a2, a01=a2_01, e=e2).save(fpath, engine='xlwings_excel', overwrite=False) s = Session() s.load(fpath, engine='xlwings_excel') assert list(s.keys()) == ['a', 'b', 'a01', 'b12', 'e', 'g', 'f'] assert s['a'].equals(a2) assert all(s['a01'] == a2_01) assert_array_nan_equal(s['e'], e2) assert s.meta == meta # load only some objects s = Session() s.load(fpath, names=['a', 'a01', 'e', 'f'], engine='xlwings_excel') assert list(s.keys()) == ['a', 'a01', 'e', 'f'] assert s.meta == meta
def test_rdiv(session): sess = session # scalar / session with must_warn(RuntimeWarning, msg="divide by zero encountered during operation", check_num=False): res = 2 / sess with np.errstate(divide='ignore'): expected_e = 2 / e expected_f = 2 / f expected_g = 2 / g assert_array_nan_equal(res['e'], expected_e) assert_array_nan_equal(res['f'], expected_f) assert_array_nan_equal(res['g'], expected_g) assert res.a is a assert res.a01 is a01 assert res.c is c # dict(Array and scalar) - session other = {'e': e, 'f': f} with must_warn( RuntimeWarning, msg= "invalid value (NaN) encountered during operation (this is typically caused by a 0 / 0)", check_num=False): res = other / sess with np.errstate(invalid='ignore'): expected_e = e / e expected_f = f / f assert_array_nan_equal(res['e'], expected_e) assert_array_nan_equal(res['f'], expected_f) assert res.a is a assert res.a01 is a01 assert res.c is c
def test_to_globals(session): with pytest.warns(RuntimeWarning) as caught_warnings: session.to_globals() assert len(caught_warnings) == 1 assert caught_warnings[0].message.args[0] == "Session.to_globals should usually only be used in interactive " \ "consoles and not in scripts. Use warn=False to deactivate this " \ "warning." assert caught_warnings[0].filename == __file__ assert a is session.a assert b is session.b assert c is session.c assert d is session.d assert e is session.e assert f is session.f assert g is session.g # test inplace backup_dest = e backup_value = session.e.copy() session.e = zeros_like(e) session.to_globals(inplace=True, warn=False) # check the variable is correct (the same as before) assert e is backup_dest assert e is not session.e # check the content has changed assert_array_nan_equal(e, session.e) assert not e.equals(backup_value) # reset e to its original value e[:] = backup_value
def test_to_globals(session): msg = "Session.to_globals should usually only be used in interactive consoles and not in scripts. " \ "Use warn=False to deactivate this warning." with must_warn(RuntimeWarning, msg=msg): session.to_globals() assert a is session.a assert b is session.b assert c is session.c assert d is session.d assert e is session.e assert f is session.f assert g is session.g # test inplace backup_dest = e backup_value = session.e.copy() session.e = zeros_like(e) session.to_globals(inplace=True, warn=False) # check the variable is correct (the same as before) assert e is backup_dest assert e is not session.e # check the content has changed assert_array_nan_equal(e, session.e) assert not e.equals(backup_value) # reset e to its original value e[:] = backup_value
def test_pickle_io(self): fpath = abspath('test_session.pkl') self.session.save(fpath) s = Session() s.load(fpath, engine='pickle') self.assertEqual(list(s.keys()), ['e', 'g', 'f']) # update an array (overwrite=False) Session(e=self.e2).save(fpath, overwrite=False) s.load(fpath, engine='pickle') self.assertEqual(list(s.keys()), ['e', 'g', 'f']) assert_array_nan_equal(s['e'], self.e2)
def test_rdiv(self): sess = self.session.filter(kind=LArray) # scalar / session res = 2 / sess assert_array_nan_equal(res['e'], 2 / self.e) assert_array_nan_equal(res['f'], 2 / self.f) assert_array_nan_equal(res['g'], 2 / self.g) # dict(LArray and scalar) - session other = {'e': self.e, 'f': self.f} res = other / sess assert_array_nan_equal(res['e'], self.e / self.e) assert_array_nan_equal(res['f'], self.f / self.f)
def test_rsub(self): sess = self.session.filter(kind=LArray) # scalar - session diff = 2 - sess assert_array_nan_equal(diff['e'], 2 - self.e) assert_array_nan_equal(diff['f'], 2 - self.f) assert_array_nan_equal(diff['g'], 2 - self.g) # dict(LArray and scalar) - session other = {'e': ones_like(self.e), 'f': 1} diff = other - sess assert_array_nan_equal(diff['e'], ones_like(self.e) - self.e) assert_array_nan_equal(diff['f'], 1 - self.f) assert isnan(diff['g']).all()
def test_setattr_cs(checkedsession): cs = checkedsession # only change values of an array -> OK cs.h = zeros_like(h) # trying to add an undeclared variable -> prints a warning message with must_warn(UserWarning, msg=f"'i' is not declared in '{cs.__class__.__name__}'"): cs.i = ndtest((3, 3)) # trying to set a variable with an object of different type -> should fail # a) type given explicitly # -> Axis with must_raise(TypeError, msg="instance of Axis expected"): cs.a = 0 # -> CheckedArray with must_raise(TypeError, msg="Expected object of type 'Array' or a scalar for the variable 'h' but got " "object of type 'ndarray'"): cs.h = h.data # b) type deduced from the given default value with must_raise(TypeError, msg="instance of Axis expected"): cs.b = ndtest((3, 3)) # trying to set a CheckedArray variable using a scalar -> OK cs.h = 5 # trying to set a CheckedArray variable using an array with axes in different order -> OK cs.h = h.transpose() assert cs.h.axes.names == h.axes.names # broadcasting (missing axis) is allowed cs.h = ndtest(a3) assert_array_nan_equal(cs.h['b0'], cs.h['b1']) # trying to set a CheckedArray variable using an array with wrong axes -> should fail # a) extra axis with must_raise(ValueError, msg="Array 'h' was declared with axes {a, b} but got array with axes {a, b, c} " "(unexpected {c} axis)"): cs.h = ndtest((a3, b2, 'c=c0..c2')) # b) incompatible axis msg = """\ Incompatible axis for array 'h': Axis(['a0', 'a1', 'a2', 'a3', 'a4'], 'a') vs Axis(['a0', 'a1', 'a2', 'a3'], 'a')""" with must_raise(ValueError, msg=msg): cs.h = h.append('a', 0, 'a4')
def test_div(session): sess = session other = Session({'e': e - 1, 'f': f + 1}) with pytest.warns(RuntimeWarning) as caught_warnings: res = sess / other assert len(caught_warnings) == 1 assert caught_warnings[0].message.args[0] == "divide by zero encountered during operation" assert caught_warnings[0].filename == __file__ with np.errstate(divide='ignore', invalid='ignore'): flat_e = np.arange(6) / np.arange(-1, 5) assert_array_nan_equal(res['e'], flat_e.reshape(2, 3)) flat_f = np.arange(6) / np.arange(1, 7) assert_array_nan_equal(res['f'], flat_f.reshape(3, 2)) assert isnan(res['g']).all()
def test_div(self): sess = self.session.filter(kind=LArray) other = Session({'e': self.e - 1, 'f': self.f + 1}) with pytest.warns(RuntimeWarning) as caught_warnings: res = sess / other assert len(caught_warnings) == 1 assert caught_warnings[0].message.args[ 0] == "divide by zero encountered during operation" assert caught_warnings[0].filename == __file__ with np.errstate(divide='ignore', invalid='ignore'): flat_e = np.arange(6) / np.arange(-1, 5) assert_array_nan_equal(res['e'], flat_e.reshape(2, 3)) flat_f = np.arange(6) / np.arange(1, 7) assert_array_nan_equal(res['f'], flat_f.reshape(3, 2)) self.assertTrue(isnan(res['g']).all())
def test_h5_io(self): fpath = abspath('test_session.h5') self.session.save(fpath) s = Session() s.load(fpath) # HDF does *not* keep ordering (ie, keys are always sorted) self.assertEqual(list(s.keys()), ['e', 'f', 'g']) # update an array (overwrite=False) Session(e=self.e2).save(fpath, overwrite=False) s.load(fpath) self.assertEqual(list(s.keys()), ['e', 'f', 'g']) assert_array_nan_equal(s['e'], self.e2) s = Session() s.load(fpath, ['e', 'f']) self.assertEqual(list(s.keys()), ['e', 'f'])
def test_xlsx_pandas_io(self): fpath = abspath('test_session.xlsx') self.session.save(fpath, engine='pandas_excel') s = Session() s.load(fpath, engine='pandas_excel') self.assertEqual(list(s.keys()), ['e', 'g', 'f']) # update an array (overwrite=False) Session(e=self.e2).save(fpath, engine='pandas_excel', overwrite=False) s.load(fpath, engine='pandas_excel') self.assertEqual(list(s.keys()), ['e', 'g', 'f']) assert_array_nan_equal(s['e'], self.e2) fpath = abspath('test_session_ef.xlsx') self.session.save(fpath, ['e', 'f'], engine='pandas_excel') s = Session() s.load(fpath, engine='pandas_excel') self.assertEqual(list(s.keys()), ['e', 'f'])
def test_div(session): sess = session session_cls = session.__class__ other = session_cls({'e': e, 'f': f}) other['e'] = e - 1 other['f'] = f + 1 with must_warn(RuntimeWarning, msg="divide by zero encountered during operation"): res = sess / other with np.errstate(divide='ignore', invalid='ignore'): flat_e = np.arange(6) / np.arange(-1, 5) assert_array_nan_equal(res['e'], flat_e.reshape(2, 3)) flat_f = np.arange(6) / np.arange(1, 7) assert_array_nan_equal(res['f'], flat_f.reshape(3, 2)) assert isnan(res['g']).all()
def test_rdiv(session): sess = session # scalar / session res = 2 / sess assert_array_nan_equal(res['e'], 2 / e) assert_array_nan_equal(res['f'], 2 / f) assert_array_nan_equal(res['g'], 2 / g) assert res.a is a assert res.a01 is a01 assert res.c is c # dict(LArray and scalar) - session other = {'e': e, 'f': f} res = other / sess assert_array_nan_equal(res['e'], e / e) assert_array_nan_equal(res['f'], f / f) assert res.a is a assert res.a01 is a01 assert res.c is c
def test_rsub(session): sess = session # scalar - session diff = 2 - sess assert_array_nan_equal(diff['e'], 2 - e) assert_array_nan_equal(diff['f'], 2 - f) assert_array_nan_equal(diff['g'], 2 - g) assert diff.a is a assert diff.a01 is a01 assert diff.c is c # dict(Array and scalar) - session other = {'e': ones_like(e), 'f': 1} diff = other - sess assert_array_nan_equal(diff['e'], ones_like(e) - e) assert_array_nan_equal(diff['f'], 1 - f) assert isnan(diff['g']).all() assert diff.a is a assert diff.a01 is a01 assert diff.c is c
def test_rsub(session): sess = session # scalar - session diff = 2 - sess assert_array_nan_equal(diff['e'], 2 - e) assert_array_nan_equal(diff['f'], 2 - f) assert_array_nan_equal(diff['g'], 2 - g) assert diff.a is a assert diff.a01 is a01 assert diff.c is c # dict(LArray and scalar) - session other = {'e': ones_like(e), 'f': 1} diff = other - sess assert_array_nan_equal(diff['e'], ones_like(e) - e) assert_array_nan_equal(diff['f'], 1 - f) assert isnan(diff['g']).all() assert diff.a is a assert diff.a01 is a01 assert diff.c is c
def test_xlsx_xlwings_io(self): fpath = abspath('test_session_xw.xlsx') # test save when Excel file does not exist self.session.save(fpath, engine='xlwings_excel') s = Session() s.load(fpath, engine='xlwings_excel') # ordering is only kept if the file did not exist previously (otherwise the ordering is left intact) self.assertEqual(list(s.keys()), ['e', 'g', 'f']) # update an array (overwrite=False) Session(e=self.e2).save(fpath, engine='xlwings_excel', overwrite=False) s.load(fpath, engine='xlwings_excel') self.assertEqual(list(s.keys()), ['e', 'g', 'f']) assert_array_nan_equal(s['e'], self.e2) fpath = abspath('test_session_ef_xw.xlsx') self.session.save(fpath, ['e', 'f'], engine='xlwings_excel') s = Session() s.load(fpath, engine='xlwings_excel') self.assertEqual(list(s.keys()), ['e', 'f'])
def test_neg_cs(checkedsession): cs = checkedsession neg_cs = -cs # --- non-array variables --- assert isnan(neg_cs.b) assert isnan(neg_cs.b024) assert isnan(neg_cs.a) assert isnan(neg_cs.a2) assert isnan(neg_cs.anonymous) assert isnan(neg_cs.a01) assert isnan(neg_cs.ano01) assert isnan(neg_cs.c) assert isnan(neg_cs.d) # --- non constant arrays --- assert_array_nan_equal(neg_cs.e, -e) assert_array_nan_equal(neg_cs.g, -g) assert_array_nan_equal(neg_cs.f, -f) assert_array_nan_equal(neg_cs.h, -h)
def test_sub(self): sess = self.session.filter(kind=LArray) # session - session other = Session({'e': self.e - 1, 'f': ones_like(self.f)}) diff = sess - other assert_array_nan_equal(diff['e'], np.full((2, 3), 1, dtype=np.int32)) assert_array_nan_equal(diff['f'], self.f - ones_like(self.f)) assert isnan(diff['g']).all() # session - scalar diff = sess - 2 assert_array_nan_equal(diff['e'], self.e - 2) assert_array_nan_equal(diff['f'], self.f - 2) assert_array_nan_equal(diff['g'], self.g - 2) # session - dict(LArray and scalar) other = {'e': ones_like(self.e), 'f': 1} diff = sess - other assert_array_nan_equal(diff['e'], self.e - ones_like(self.e)) assert_array_nan_equal(diff['f'], self.f - 1) assert isnan(diff['g']).all()
def test_sub(session): sess = session # session - session other = Session({'e': e, 'f': f}) other['e'] = e - 1 other['f'] = ones_like(f) diff = sess - other assert_array_nan_equal(diff['e'], np.full((2, 3), 1, dtype=np.int32)) assert_array_nan_equal(diff['f'], f - ones_like(f)) assert isnan(diff['g']).all() assert diff.a is a assert diff.a01 is a01 assert diff.c is c # session - scalar diff = sess - 2 assert_array_nan_equal(diff['e'], e - 2) assert_array_nan_equal(diff['f'], f - 2) assert_array_nan_equal(diff['g'], g - 2) assert diff.a is a assert diff.a01 is a01 assert diff.c is c # session - dict(Array and scalar) other = {'e': ones_like(e), 'f': 1} diff = sess - other assert_array_nan_equal(diff['e'], e - ones_like(e)) assert_array_nan_equal(diff['f'], f - 1) assert isnan(diff['g']).all() assert diff.a is a assert diff.a01 is a01 assert diff.c is c # session - array axes = [a, b] other = Session([('a', a), ('a01', a01), ('c', c), ('e', ndtest((a, b))), ('f', full((a, b), fill_value=3)), ('g', ndtest('c=c0..c2'))]) diff = other - ones(axes) assert_array_nan_equal(diff['e'], other['e'] - ones(axes)) assert_array_nan_equal(diff['f'], other['f'] - ones(axes)) assert_array_nan_equal(diff['g'], other['g'] - ones(axes)) assert diff.a is a assert diff.a01 is a01 assert diff.c is c
def test_sub(session): sess = session # session - session other = Session({'e': e - 1, 'f': ones_like(f)}) diff = sess - other assert_array_nan_equal(diff['e'], np.full((2, 3), 1, dtype=np.int32)) assert_array_nan_equal(diff['f'], f - ones_like(f)) assert isnan(diff['g']).all() assert diff.a is a assert diff.a01 is a01 assert diff.c is c # session - scalar diff = sess - 2 assert_array_nan_equal(diff['e'], e - 2) assert_array_nan_equal(diff['f'], f - 2) assert_array_nan_equal(diff['g'], g - 2) assert diff.a is a assert diff.a01 is a01 assert diff.c is c # session - dict(LArray and scalar) other = {'e': ones_like(e), 'f': 1} diff = sess - other assert_array_nan_equal(diff['e'], e - ones_like(e)) assert_array_nan_equal(diff['f'], f - 1) assert isnan(diff['g']).all() assert diff.a is a assert diff.a01 is a01 assert diff.c is c
def test_sub_cs(checkedsession): cs = checkedsession session_cls = cs.__class__ # session - session other = session_cls(a=a, a2=a2, a01=a01, e=e - 1, g=zeros_like(g), f=zeros_like(f), h=ones_like(h)) diff = cs - other assert isinstance(diff, session_cls) # --- non-array variables --- assert diff.b is b assert diff.b024 is b024 assert diff.a is a assert diff.a2 is a2 assert diff.anonymous is anonymous assert diff.a01 is a01 assert diff.ano01 is ano01 assert diff.c is c assert diff.d is d # --- array variables --- assert_array_nan_equal(diff.e, np.full((2, 3), 1, dtype=np.int32)) assert_array_nan_equal(diff.g, g) assert_array_nan_equal(diff.f, f) assert_array_nan_equal(diff.h, h - ones_like(h)) # session - scalar diff = cs - 2 assert isinstance(diff, session_cls) # --- non-array variables --- assert diff.b is b assert diff.b024 is b024 assert diff.a is a assert diff.a2 is a2 assert diff.anonymous is anonymous assert diff.a01 is a01 assert diff.ano01 is ano01 assert diff.c is c assert diff.d is d # --- non constant arrays --- assert_array_nan_equal(diff.e, e - 2) assert_array_nan_equal(diff.g, g - 2) assert_array_nan_equal(diff.f, f - 2) assert_array_nan_equal(diff.h, h - 2) # session - dict(Array and scalar) other = {'e': ones_like(e), 'h': 1} diff = cs - other assert isinstance(diff, session_cls) # --- non-array variables --- assert diff.b is b assert diff.b024 is b024 assert diff.a is a assert diff.a2 is a2 assert diff.anonymous is anonymous assert diff.a01 is a01 assert diff.ano01 is ano01 assert diff.c is c assert diff.d is d # --- non constant arrays --- assert_array_nan_equal(diff.e, e - ones_like(e)) assert isnan(diff.g).all() assert isnan(diff.f).all() assert_array_nan_equal(diff.h, h - 1) # session - array axes = cs.h.axes cs.e = ndtest(axes) cs.g = ones_like(cs.h) diff = cs - ones(axes) assert isinstance(diff, session_cls) # --- non-array variables --- assert diff.b is b assert diff.b024 is b024 assert diff.a is a assert diff.a2 is a2 assert diff.anonymous is anonymous assert diff.a01 is a01 assert diff.ano01 is ano01 assert diff.c is c assert diff.d is d # --- non constant arrays --- assert_array_nan_equal(diff.e, cs.e - ones(axes)) assert_array_nan_equal(diff.g, cs.g - ones(axes)) assert isnan(diff.f).all() assert_array_nan_equal(diff.h, cs.h - ones(axes))
def test_rsub_cs(checkedsession): cs = checkedsession session_cls = cs.__class__ # scalar - session diff = 2 - cs assert isinstance(diff, session_cls) # --- non-array variables --- assert diff.b is b assert diff.b024 is b024 assert diff.a is a assert diff.a2 is a2 assert diff.anonymous is anonymous assert diff.a01 is a01 assert diff.ano01 is ano01 assert diff.c is c assert diff.d is d # --- non constant arrays --- assert_array_nan_equal(diff.e, 2 - e) assert_array_nan_equal(diff.g, 2 - g) assert_array_nan_equal(diff.f, 2 - f) assert_array_nan_equal(diff.h, 2 - h) # dict(Array and scalar) - session other = {'e': ones_like(e), 'h': 1} diff = other - cs assert isinstance(diff, session_cls) # --- non-array variables --- assert diff.b is b assert diff.b024 is b024 assert diff.a is a assert diff.a2 is a2 assert diff.anonymous is anonymous assert diff.a01 is a01 assert diff.ano01 is ano01 assert diff.c is c assert diff.d is d # --- non constant arrays --- assert_array_nan_equal(diff.e, ones_like(e) - e) assert isnan(diff.g).all() assert isnan(diff.f).all() assert_array_nan_equal(diff.h, 1 - h)