def test_delete_registered(self): """ Tests the following: 1. delete cmd doesn't delete registered objects and returns appropriate message 2. delete cmd does delete non-registered objects and returns appropriate message 3. delete cmd raises RuntimeError for unknown symbols """ cleanup() a = ak.ones(3, dtype=ak.int64) b = ak.ones(3, dtype=ak.int64) # registered objects are not deleted from symbol table a.register('keep') self.assertEqual(ak.client.generic_msg(cmd='delete', args=a.name), f'registered symbol, {a.name}, not deleted') self.assertTrue(a.name in ak.list_symbol_table()) # non-registered objects are deleted from symbol table self.assertEqual(ak.client.generic_msg(cmd='delete', args=b.name), 'deleted ' + b.name) self.assertTrue(b.name not in ak.list_symbol_table()) # RuntimeError when calling delete on an object not in the symbol table with self.assertRaises(RuntimeError): ak.client.generic_msg(cmd='delete', args='not_in_table')
def testErrorHandling(self): # Test NotImplmentedError that prevents pddarray iteration with self.assertRaises(NotImplementedError): iter(ak.ones(100)) # Test NotImplmentedError that prevents Strings iteration with self.assertRaises(NotImplementedError): iter(ak.array(['String {}'.format(i) for i in range(0, 10)])) # Test ak,histogram against unsupported dtype #with self.assertRaises(ValueError) as cm: # ak.histogram((ak.randint(0, 1, 100, dtype=ak.bool))) #self.assertEqual('Error: histogramMsg: bool not implemented', # cm.exception.args[0]) with self.assertRaises(RuntimeError) as cm: ak.concatenate([ak.array([True]), ak.array([True])]).is_sorted() self.assertEqual('Error: reductionMsg: is_sorted bool not implemented', cm.exception.args[0]) with self.assertRaises(TypeError): ak.ones(100).any([0]) with self.assertRaises(TypeError) as cm: ak.unique(list(range(0, 10))) self.assertEqual('must be pdarray, Strings, or Categorical {}', cm.exception.args[0]) with self.assertRaises(RuntimeError) as cm: ak.concatenate([ak.ones(100), ak.array([True])]) self.assertEqual( 'Error: concatenateMsg: Incompatible arguments: ' + 'Expected float64 dtype but got bool dtype', cm.exception.args[0])
def test_error_handling(self): ones = ak.ones(100) short_ones = ak.ones(10) with self.assertRaises(ValueError): ak.coargsort([ones, short_ones]) with self.assertRaises(ValueError): ak.coargsort([list(range(0,10)), [0]])
def testTo_ndarray(self): ones = ak.ones(10) n_ones = ones.to_ndarray() new_ones = ak.array(n_ones) self.assertTrue((ones.to_ndarray() == new_ones.to_ndarray()).all()) empty_ones = ak.ones(0) n_empty_ones = empty_ones.to_ndarray() new_empty_ones = ak.array(n_empty_ones) self.assertTrue((empty_ones.to_ndarray() == new_empty_ones.to_ndarray()).all())
def test_error_handling(self): ones = ak.ones(100) short_ones = ak.ones(10) for algo in ak.SortingAlgorithm: with self.assertRaises(ValueError): ak.coargsort([ones, short_ones], algo) for algo in ak.SortingAlgorithm: with self.assertRaises(TypeError): ak.coargsort([list(range(0, 10)), [0]], algo)
def test_double_register(self): """ Tests the case when two objects get registered using the same user_defined_name """ a = ak.ones(3, dtype=ak.int64) b = ak.ones(3, dtype=ak.int64) b.fill(2) a.register("foo") with self.assertRaises(RegistrationError, msg="Should raise an Error"): b.register("foo") # Clean up the registry a.unregister()
def test_clear(self): ''' Tests the following: 1. clear() removes server-side pdarrays that are unregistered 2. Registered pdarrays remain after ak.clear() 3. All cleared pdarrays throw RuntimeError upon method invocation 4. Method invocation on registered arrays succeeds after ak.clear() ''' ar_array = self.a_array.register('test_int64_a') br_array = self.a_array.register('test_int64_b') twos_array = ak.ones(10,dtype=ak.int64).register('twos_array') twos_array.fill(2) g_twos_array = self.a_array + self.b_array self.assertTrue((twos_array.to_ndarray() == g_twos_array.to_ndarray()).all()) ak.clear() with self.assertRaises(RuntimeError): str(self.a_array) with self.assertRaises(RuntimeError): self.a_array + self.b_array g_twos_array = ar_array + br_array self.assertTrue((twos_array.to_ndarray() == g_twos_array.to_ndarray()).all())
def test_eros_like(self): intZeros = ak.zeros(5, dtype=ak.int64) intZerosLike = ak.zeros_like(intZeros) self.assertIsInstance(intZerosLike, ak.pdarray) self.assertEqual(ak.int64, intZerosLike.dtype) floatZeros = ak.ones(5, dtype=ak.float64) floatZerosLike = ak.ones_like(floatZeros) self.assertEqual(ak.float64, floatZerosLike.dtype) boolZeros = ak.ones(5, dtype=ak.bool) boolZerosLike = ak.ones_like(boolZeros) self.assertEqual(ak.bool, boolZerosLike.dtype)
def test_compare_set_slice(self): # create np version a = np.ones(N) a[::2] = a[::2] * -1 # create ak version b = ak.ones(N) b[::2] = b[::2] * -1 self.assertEqual(a.all(), b.to_ndarray().all())
def check_ones(N): # create np version a = np.ones(N) # create ak version b = ak.ones(N) # print(a,b) c = a == b.to_ndarray() # print(type(c),c) return pass_fail(c.all())
def testPdArrayDivideInt(self): aArray = ak.ones(100) dArray = aArray * 15 / 3 self.assertIsInstance(dArray, ak.pdarrayclass.pdarray) self.assertEqual(np.float64(5), dArray[0]) dArray = 15 * aArray / 3 self.assertIsInstance(dArray, ak.pdarrayclass.pdarray) self.assertEqual(np.float64(5), dArray[0])
def testPdArrayMultNumpyInt(self): aArray = ak.ones(100) mArray = aArray * np.int64(5) self.assertIsInstance(mArray, ak.pdarrayclass.pdarray) self.assertEqual(np.float64(5), mArray[0]) mArray = np.int64(5) * aArray self.assertIsInstance(mArray, ak.pdarrayclass.pdarray) self.assertEqual(np.float64(5), mArray[0])
def testPdArrayAddNumpyInt(self): aArray = ak.ones(100) addArray = aArray + np.int64(1) self.assertIsInstance(addArray, ak.pdarrayclass.pdarray) self.assertEqual(np.float64(2), addArray[0]) addArray = np.int64(1) + aArray self.assertIsInstance(addArray, ak.pdarrayclass.pdarray) self.assertEqual(np.float64(2), addArray[0])
def testPdArraySubtractNumpyInt(self): aArray = ak.ones(100) subArray = aArray - np.int64(2) self.assertIsInstance(subArray, ak.pdarrayclass.pdarray) self.assertEqual(np.float64(-1), subArray[0]) subArray = np.int64(2) - aArray self.assertIsInstance(subArray, ak.pdarrayclass.pdarray) self.assertEqual(np.float64(1), subArray[0])
def testPdArrayDivideNumpyInt(self): aArray = ak.ones(100) dArray = aArray * np.int64(15) / 3 self.assertIsInstance(dArray, ak.pdarrayclass.pdarray) self.assertEqual(np.float64(5), dArray[0]) dArray = np.int64(15) * aArray / 3 self.assertIsInstance(dArray, ak.pdarrayclass.pdarray) self.assertEqual(np.float64(5), dArray[0])
def setUp(self): ArkoudaTest.setUp(self) self.N = 1000 self.a1 = ak.ones(self.N, dtype=np.int64) self.a2 = ak.arange(0, self.N, 1) self.t1 = self.a1 self.t2 = self.a1 * 10 self.dt = 10 ak.verbose = False
def check_set_slice(N): # create np version a = np.ones(N) a[::2] = a[::2] * -1 # create ak version b = ak.ones(N) b[::2] = b[::2] * -1 # print(a,b) c = a == b.to_ndarray() return pass_fail(c.all())
def test_clear(self): ''' Tests the following: 1. clear() removes server-side pdarrays that are unregistered 2. Registered pdarrays remain after ak.clear() 3. All cleared pdarrays throw RuntimeError upon method invocation 4. Method invocation on registered arrays succeeds after ak.clear() ''' ar_array = self.a_array.register('test_int64_a') aar_array = self.a_array.register('test_int64_aa') self.assertTrue( ar_array is aar_array, msg="With inplace modification, these should be the same") self.assertEqual( ar_array.name, "test_int64_aa", msg="ar_array.name should be updated with inplace modification") twos_array = ak.ones(10, dtype=ak.int64).register('twos_array') twos_array.fill(2) g_twos_array = self.a_array + self.b_array self.assertTrue( (twos_array.to_ndarray() == g_twos_array.to_ndarray()).all()) ak.clear() # This should remove self.b_array and g_twos_array with self.assertRaises( RuntimeError, msg= "g_twos_array should have been cleared because it wasn't registered" ): str(g_twos_array) with self.assertRaises( RuntimeError, msg= "self.b_array should have been cleared because it wasn't registered" ): str(self.b_array) # Assert these exist by invoking them and not receiving an exception str(self.a_array) str(ar_array) with self.assertRaises( RuntimeError, msg="Should raise error because self.b_array was cleared"): self.a_array + self.b_array g_twos_array = ar_array + aar_array self.assertTrue( (twos_array.to_ndarray() == g_twos_array.to_ndarray()).all())
def testErrorHandling(self): # Test NotImplmentedError that prevents pddarray iteration with self.assertRaises(NotImplementedError): iter(ak.ones(100)) # Test NotImplmentedError that prevents Strings iteration with self.assertRaises(NotImplementedError): iter(ak.array(['String {}'.format(i) for i in range(0, 10)])) # Test ak,histogram against unsupported dtype with self.assertRaises(ValueError): ak.histogram((ak.randint(0, 1, 100, dtype=ak.bool))) with self.assertRaises(RuntimeError) as cm: ak.concatenate([ak.array([True]), ak.array([True])]).is_sorted() self.assertEqual('Error: reductionMsg: is_sorted bool not implemented', cm.exception.args[0]) with self.assertRaises(TypeError): ak.ones(100).any([0])
def check_bool(N): a = ak.arange(N) b = ak.ones(N) try: c = a and b except ValueError: correct = True except: correct = False d = ak.array([1]) correct = correct and (d and 5) return pass_fail(correct)
def test_attach_weak_binding(self): """ Ultimately pdarrayclass issues delete calls to the server when a bound object goes out of scope, if you bind to a server object more than once and one of those goes out of scope it affects all other references to it. """ cleanup() a = ak.ones(3, dtype=ak.int64).register("a_reg") self.assertTrue(str(a), "Expected to pass") b = ak.attach_pdarray("a_reg") b.unregister() b = None # Force out of scope with self.assertRaises(RuntimeError): str(a)
def test_is_registered(self): """ Tests the pdarray.is_registered() function """ cleanup() a = ak.ones(10, dtype=ak.int64) self.assertFalse(a.is_registered()) a.register('keep') self.assertTrue(a.is_registered()) a.unregister() self.assertFalse(a.is_registered()) ak.clear()
def test_fill(self): ones = ak.ones(100) ones.fill(2) self.assertTrue((2 == ones.to_ndarray()).all()) ones.fill(np.int64(2)) self.assertTrue((np.int64(2) == ones.to_ndarray()).all()) ones.fill(np.float(2)) self.assertTrue((float(2) == ones.to_ndarray()).all()) ones.fill(np.float64(2)) self.assertTrue((np.float64(2) == ones.to_ndarray()).all())
def run_test() -> int: a = ak.ones(SIZE, dtype=ak.float64) b = ak.ones(SIZE, dtype=ak.int64) d = ak.register_pda(a, 'test_float64') e = ak.register_pda(b, 'test_int64') ak.clear() # will get decremented to 0 if test is successful result = 2 try: a + b except: result -= 1 try: d + e result -= 1 except: result = 100 ak.unregister_pda(d) ak.unregister_pda(e) return result
def test_error_handling(self): with self.assertRaises(RuntimeError) as cm: ak.concatenate([ak.ones(100), ak.array([True])]) self.assertEqual( 'Error: concatenateMsg: Incompatible arguments: ' + 'Expected float64 dtype but got bool dtype', cm.exception.args[0]) with self.assertRaises(TypeError): ak.union1d([-1, 0, 1], [-2, 0, 2]) with self.assertRaises(RuntimeError) as cm: ak.cos(ak.randint(0, 1, 100, dtype=ak.bool)) self.assertEqual('Error: efuncMsg: cos bool not implemented', cm.exception.args[0])
def test_get_mem_used(self): ''' Tests the ak.client.get_mem_used method :return: None :raise: AssertionError if one or more ak.get_mem_used values are not as expected or the call to ak.client.get_mem_used() fails ''' try: config = ak.client.get_config() a = ak.ones(1024 * 1024 * config['numLocales']) mem_used = ak.client.get_mem_used() except Exception as e: raise AssertionError(e) self.assertTrue(mem_used > 0)
def test_list_registry(self): """ Tests the generic ak.list_registry() function """ cleanup() # Test list_registry when the symbol table is empty self.assertFalse(ak.list_registry(), "registry should be empty") a = ak.ones(10, dtype=ak.int64) # list_registry() should return an empty list which is implicitly False self.assertFalse(ak.list_registry()) a.register('keep') self.assertTrue('keep' in ak.list_registry()) cleanup()
def test_in_place_info(self): """ Tests the class level info method for pdarray, String, and Categorical """ cleanup() my_pda = ak.ones(10, ak.int64) self.assertFalse( any([sym['registered'] for sym in json.loads(my_pda.info())]), msg= 'no components of my_pda should be registered before register call' ) my_pda.register('my_pda') self.assertTrue( all([sym['registered'] for sym in json.loads(my_pda.info())]), msg= 'all components of my_pda should be registered after register call' ) my_str = ak.random_strings_uniform(1, 10, UNIQUE, characters='printable') self.assertFalse( any([sym['registered'] for sym in json.loads(my_str.info())]), msg= 'no components of my_str should be registered before register call' ) my_str.register('my_str') self.assertTrue( all([sym['registered'] for sym in json.loads(my_str.info())]), msg= 'all components of my_str should be registered after register call' ) my_cat = ak.Categorical(ak.array([f"my_cat {i}" for i in range(1, 11)])) self.assertFalse( any([sym['registered'] for sym in json.loads(my_cat.info())]), msg= 'no components of my_cat should be registered before register call' ) my_cat.register('my_cat') self.assertTrue( all([sym['registered'] for sym in json.loads(my_cat.info())]), msg= 'all components of my_cat should be registered after register call' ) cleanup()
def testValueCounts(self): pda = ak.ones(100, dtype=ak.int64) result = ak.value_counts(pda) self.assertEqual(ak.array([1]), result[0]) self.assertEqual(ak.array([100]), result[1]) pda = ak.linspace(1, 10, 10) with self.assertRaises(RuntimeError) as cm: ak.value_counts(pda) self.assertEqual('Error: unique: float64 not implemented', cm.exception.args[0]) with self.assertRaises(TypeError) as cm: ak.value_counts([0]) self.assertEqual( 'type of argument "pda" must be arkouda.pdarrayclass.pdarray; got list instead', cm.exception.args[0])
def testOnes(self): intOnes = ak.ones(5, dtype=ak.int64) self.assertIsInstance(intOnes, ak.pdarray) self.assertEqual(ak.int64, intOnes.dtype) floatOnes = ak.ones(5, dtype=ak.float64) self.assertEqual(ak.float64, floatOnes.dtype) boolOnes = ak.ones(5, dtype=ak.bool) self.assertEqual(ak.bool, boolOnes.dtype) ones = ak.ones('5') self.assertEqual(5, len(ones)) with self.assertRaises(TypeError) as cm: ak.ones(5, dtype=ak.uint8) self.assertEqual('unsupported dtype uint8', cm.exception.args[0]) with self.assertRaises(TypeError) as cm: ak.ones(5, dtype=str) self.assertEqual('unsupported dtype <U0', cm.exception.args[0])