def test_lazy_with_lazy__realised_dtype(self):
dtype = np.dtype('int16')
dm1 = DataManager(as_lazy_data(self.real_array),
realised_dtype=dtype)
dm2 = DataManager(as_lazy_data(self.real_array),
realised_dtype=dtype)
self.assertEqual(dm1, dm2)
def test_lazy_with_lazy__fill_value_failure(self):
fill_value = 1234
dm1 = DataManager(as_lazy_data(self.real_array),
fill_value=fill_value)
dm2 = DataManager(as_lazy_data(self.real_array),
fill_value=fill_value)
self.assertFalse(dm1 != dm2)
def test_lazy_with_lazy__fill_value(self):
fill_value = 1234
dm1 = DataManager(as_lazy_data(self.real_array),
fill_value=fill_value)
dm2 = DataManager(as_lazy_data(self.real_array),
fill_value=fill_value)
self.assertEqual(dm1, dm2)
def test_real_with_real(self):
dm = DataManager(self.real_array)
data = self.real_array.copy() * 10
result = dm._deepcopy(self.memo, data=data)
expected = DataManager(data)
self.assertEqual(result, expected)
self.assertIs(result._real_array, data)
def test_lazy_with_lazy(self):
dm = DataManager(as_lazy_data(self.real_array))
data = as_lazy_data(self.real_array) * 10
result = dm._deepcopy(self.memo, data=data)
expected = DataManager(data)
self.assertEqual(result, expected)
self.assertIs(result._lazy_array, data)
def test_ndim_0(self):
real_array = np.array(0)
dm = DataManager(real_array)
self.assertEqual(dm.ndim, 0)
lazy_array = as_lazy_data(real_array)
dm = DataManager(lazy_array)
self.assertEqual(dm.ndim, 0)
def test_shape_scalar(self):
real_array = np.array(0)
dm = DataManager(real_array)
self.assertEqual(dm.shape, ())
lazy_array = as_lazy_data(real_array)
dm = DataManager(lazy_array)
self.assertEqual(dm.shape, ())
def test_lazy_with_lazy__realised_dtype_failure(self):
dtype = np.dtype('int16')
dm1 = DataManager(as_lazy_data(self.real_array),
realised_dtype=dtype)
dm2 = DataManager(as_lazy_data(self.real_array),
realised_dtype=dtype)
self.assertFalse(dm1 != dm2)
def test_ndim_nd(self):
shape = (2, 3, 4)
real_array = np.arange(24).reshape(shape)
dm = DataManager(real_array)
self.assertEqual(dm.ndim, len(shape))
lazy_array = as_lazy_data(real_array)
dm = DataManager(lazy_array)
self.assertEqual(dm.ndim, len(shape))
def test_lazy_with_realised_dtype(self):
dm = DataManager(as_lazy_data(self.real_array),
realised_dtype=np.dtype('int16'))
data = as_lazy_data(self.real_array) * 10
dtype = np.dtype('int8')
result = dm._deepcopy(self.memo, data=data, realised_dtype=dtype)
expected = DataManager(data, realised_dtype=dtype)
self.assertEqual(result, expected)
self.assertIs(result._lazy_array, data)
def test_lazy_array__fill_value_clearance(self):
fill_value = 1234
dm = DataManager(as_lazy_data(np.array(0)),
fill_value=fill_value)
self.assertEqual(dm.fill_value, fill_value)
dm.data = as_lazy_data(np.array(1))
self.assertIsNone(dm.fill_value)
def test_zero_ndim_lazy_to_scalar_1d_real_promote(self):
real_array = np.array([456])
dm = DataManager(as_lazy_data(np.array(123)))
self.assertTrue(dm.has_lazy_data())
dm.data = real_array
self.assertFalse(dm.has_lazy_data())
self.assertArrayEqual(dm.data, real_array)
def test_zero_ndim_lazy_to_scalar_1d_lazy_promote(self):
lazy_array = as_lazy_data(np.array([456]))
dm = DataManager(as_lazy_data(np.array(123)))
self.assertTrue(dm.has_lazy_data())
dm.data = lazy_array
self.assertTrue(dm.has_lazy_data())
self.assertArrayEqual(dm.data, lazy_array.compute())
def test_zero_ndim_lazy_with_zero_ndim_real(self):
real_array = np.array(456)
dm = DataManager(as_lazy_data(np.array(123)))
self.assertTrue(dm.has_lazy_data())
dm.data = real_array
self.assertFalse(dm.has_lazy_data())
self.assertArrayEqual(dm.data, real_array)
def test_zero_ndim_lazy_with_zero_ndim_lazy(self):
lazy_array = as_lazy_data(np.array(456))
dm = DataManager(as_lazy_data(np.array(123)))
self.assertTrue(dm.has_lazy_data())
dm.data = lazy_array
self.assertTrue(dm.has_lazy_data())
self.assertArrayEqual(dm.data, lazy_array.compute())
def test_lazy__realised_dtype(self):
dtype = np.dtype('int16')
dm = DataManager(self.lazy_array, realised_dtype=dtype)
result = repr(dm)
fmt = '{}({!r}, realised_dtype={!r})'
expected = fmt.format(self.name, self.lazy_array, dtype)
self.assertEqual(result, expected)
def test_zero_ndim_real_with_scalar_float(self):
value = 456.0
dm = DataManager(np.array(123))
self.assertFalse(dm.has_lazy_data())
dm.data = value
self.assertFalse(dm.has_lazy_data())
self.assertArrayEqual(dm.data, np.array(value))
def test_with_real_mask_array__with_fill_value_None(self):
fill_value = 1234
self.mask_array.fill_value = fill_value
dm = DataManager(self.mask_array, fill_value=None)
self.assertIsNone(dm.fill_value)
np_fill_value = ma.array(0, dtype=dm.dtype).fill_value
self.assertEqual(dm.data.fill_value, np_fill_value)
def test_with_lazy_mask_array__masked_fill_value_None(self):
dm = DataManager(self.lazy_mask_array_masked,
fill_value=None,
realised_dtype=self.realised_dtype)
self.assertIsNone(dm.fill_value)
np_fill_value = ma.array(0, dtype=dm.dtype).fill_value
self.assertEqual(dm.data.fill_value, np_fill_value)
def test_real_with_real__promote_shape_with_dtype_failure(self):
data = np.array(666)
dm = DataManager(data)
emsg = 'Cannot set realised dtype, no lazy data is available'
with self.assertRaisesRegexp(ValueError, emsg):
dm.replace(np.array([999]), realised_dtype=np.dtype('float32'))
self.assertArrayEqual(dm.data, data)
def test_nop__with_real_array(self):
fill_value = 1234
dm = DataManager(self.real_array)
dm.fill_value = 1234
self.assertEqual(dm.fill_value, fill_value)
dm._propagate_masked_data_fill_value()
self.assertEqual(dm.fill_value, fill_value)
def test_with_real_array(self):
dm = DataManager(self.real_array)
self.assertFalse(dm.has_lazy_data())
result = dm.lazy_data()
self.assertFalse(dm.has_lazy_data())
self.assertEqual(result, self.lazy_array)
self.assertFalse(dm.has_lazy_data())
def test_real_with_real(self):
dm = DataManager(self.real_array * 10)
self.assertFalse(dm.has_lazy_data())
dm.replace(self.real_array)
self.assertFalse(dm.has_lazy_data())
self.assertIs(dm._real_array, self.real_array)
self.assertIs(dm.data, self.real_array)
def test__clear_fill_value_masked(self):
fill_value = 1234
dm = DataManager(np.array(0), fill_value=fill_value)
self.assertEqual(dm.fill_value, fill_value)
data = ma.masked_array(1, fill_value=4321)
dm.replace(data)
self.assertIsNone(dm.fill_value)
def test_mask_array__with_fill_value(self):
dm = DataManager(np.array(0))
self.assertIsNone(dm.fill_value)
fill_value = 1234
data = ma.array(1, fill_value=fill_value)
dm.data = data
self.assertEqual(dm.fill_value, fill_value)
def test_with_lazy_mask_array__masked_with_fill_value(self):
fill_value = 1234
dm = DataManager(self.lazy_mask_array_masked,
fill_value=fill_value,
realised_dtype=self.realised_dtype)
self.assertEqual(dm.fill_value, fill_value)
self.assertEqual(dm.data.fill_value, fill_value)
def test_fill_value_overflow(self):
fill_value = np.float(1e+20)
data = np.array([0], dtype=np.int32)
dm = DataManager(data)
emsg = 'Fill value of .* invalid for dtype'
with self.assertRaisesRegexp(ValueError, emsg):
dm.fill_value = fill_value
def test_lazy__fill_value(self):
fill_value = 1234.0
dm = DataManager(self.lazy_array, fill_value=fill_value)
result = repr(dm)
fmt = '{}({!r}, fill_value={!r})'
expected = fmt.format(self.name, self.lazy_array, fill_value)
self.assertEqual(result, expected)
def test_real_with_real__realised_dtype_failure(self):
dm = DataManager(self.real_array)
emsg = 'Cannot set realised dtype, no lazy data is available.'
with self.assertRaisesRegexp(ValueError, emsg):
dm.replace(self.real_array * 10, realised_dtype=np.dtype('int16'))
self.assertIs(dm._real_array, self.real_array)
self.assertArrayEqual(dm.data, self.real_array)
def setUp(self):
self.real_array = np.array(0)
self.mask_array = ma.array(0)
np_fill_value = ma.array(0, dtype=self.mask_array.dtype).fill_value
assert np_fill_value == self.mask_array.fill_value
self.np_fill_value = np_fill_value
self.dm = DataManager(self.mask_array)
self.dm.fill_value = None
