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)
