def test_attach(self): ''' Tests the following: 1. Attaching to a registered pdarray 2. The registered and attached pdarrays are equal 3. The attached pdarray is deleted server-side following unregister of registered pdarray and invocation of ak.clear() 4. method invocation on cleared attached array raises RuntimeError ''' ar_array = self.a_array.register('test_int64_a') aar_array = ak.attach_pdarray('test_int64_a') self.assertEqual(ar_array.name, aar_array.name) self.assertTrue( (ar_array.to_ndarray() == aar_array.to_ndarray()).all()) ak.disconnect() ak.connect(server=ArkoudaTest.server, port=ArkoudaTest.port) aar_array = ak.attach_pdarray('test_int64_a') self.assertEqual(ar_array.name, aar_array.name) self.assertTrue( (ar_array.to_ndarray() == aar_array.to_ndarray()).all()) ar_array.unregister() ak.clear() with self.assertRaises(RuntimeError): str(aar_array) with self.assertRaises(RuntimeError): repr(aar_array)
def test_disconnect_on_disconnected_client(self): ''' Tests the ak.disconnect() method invoked on a client that is already disconnect to ensure there is no error ''' ak.disconnect() self.assertFalse(ak.client.connected) ak.disconnect() ak.connect(server=ArkoudaTest.server, port=ArkoudaTest.port)
def test_client_connected(self): ''' Tests the following methods: ak.client.connected() ak.client.disconnect() ak.client.connect() :return: None :raise: AssertionError if an assert* method returns incorrect value or if there is a error in connecting or disconnecting from the Arkouda server ''' self.assertTrue(ak.client.connected) try: ak.disconnect() except Exception as e: raise AssertionError(e) self.assertFalse(ak.client.connected) try: ak.connect(server=ArkoudaTest.server, port=ArkoudaTest.port) except Exception as e: raise AssertionError(e) self.assertTrue(ak.client.connected)
class GroupByCompareStrategiesTest(ArkoudaTest): if __name__ == '__main__': import sys if len(sys.argv) < 5: print(f"Usage: {sys.argv[0]} <server> <port> <length> <num_categories> [op [dtype]]") if len(sys.argv) < 6: op = 'sum' else: op = sys.argv[5] if len(sys.argv) < 7: dtype = 'float64' else: dtype = sys.argv[6] ak.connect(sys.argv[1], int(sys.argv[2])) compare_strategies(int(sys.argv[3]), int(sys.argv[4]), op, dtype) sys.exit()
strings2 = ak.array(test_strings2) stuck = strings.stick(strings2, delimiter=delim).to_ndarray() tstuck = np.array([delim.join((a, b)) for a, b in zip(test_strings, test_strings2)]) assert ((stuck == tstuck).all()) assert ((strings + strings2) == strings.stick(strings2, delimiter="")).all() lstuck = strings.lstick(strings2, delimiter=delim).to_ndarray() tlstuck = np.array([delim.join((b, a)) for a, b in zip(test_strings, test_strings2)]) assert ((lstuck == tlstuck).all()) assert ((strings2 + strings) == strings.lstick(strings2, delimiter="")).all() if __name__ == '__main__': import sys if len(sys.argv) > 1: ak.connect(server=sys.argv[1], port=sys.argv[2]) else: ak.connect() print("Running test from string_test.__main__") # with open(__file__, 'r') as f: # base_words = np.array(f.read().split()) # test_strings = np.random.choice(base_words, N, replace=True) # strings = ak.array(test_strings) base_words1 = ak.random_strings_uniform(1, 10, UNIQUE, characters='printable') base_words2 = ak.random_strings_lognormal(2, 0.25, UNIQUE, characters='printable') gremlins = ak.array(['"', ' ', '']) base_words = ak.concatenate((base_words1, base_words2)) np_base_words = np.hstack((base_words1.to_ndarray(), base_words2.to_ndarray())) assert(compare_strings(base_words.to_ndarray(), np_base_words))
def test_large(self): check_large(10**3) 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 create_parser(): parser = argparse.ArgumentParser(description="Check coargsort correctness.") parser.add_argument('hostname', help='Hostname of arkouda server') parser.add_argument('port', type=int, help='Port of arkouda server') parser.add_argument('-n', '--size', type=int, default=10**3, help='Problem size: length of array to argsort') return parser if __name__ == "__main__": import sys parser = create_parser() args = parser.parse_args() ak.verbose = False ak.connect(server=args.hostname, port=args.port) print("array size = {:,}".format(args.size)) check_coargsort(args.size) sys.exit(0)
self.assertEqual(np.float64(5), dArray[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 testAllOperators(self): run_tests(verbose) if __name__ == '__main__': ''' Enables invocation of operator tests outside of pytest test harness ''' import sys if len(sys.argv) not in (3, 4): print(f"Usage: {sys.argv[0]} <server_name> <port> [<verbose>=(0|1)]") verbose = False if len(sys.argv) == 4 and sys.argv[3] == "1": verbose = True ak.connect(server=sys.argv[1], port=int(sys.argv[2])) success = run_tests(verbose) ak.disconnect() sys.exit((1, 0)[success])
def test_disconnect_on_disconnected_client(self): ak.disconnect() self.assertFalse(ak.client.connected) ak.disconnect() ak.connect()
if __name__ == '__main__': import sys if len(sys.argv) != 7: print( f"Usage: {sys.argv[0]} <server> <port> <strategy (0=global, 1=perLocale)> <length> <num_keys> <num_vals>" ) sys.exit() per_locale = (sys.argv[3] == '1') print("per_locale = ", per_locale) length = int(sys.argv[4]) print("length = ", length) nkeys = int(sys.argv[5]) print("nkeys = ", nkeys) nvals = int(sys.argv[6]) print("nvals = ", nvals) ak.connect(sys.argv[1], int(sys.argv[2])) print("Generating keys and vals...") start = time() keys, vals = generate_arrays(length, nkeys, nvals) print(f"{time() - start:.2f} seconds", end="\n\n") print("GroupBy...") start = time() g = ak.GroupBy(keys, per_locale) print(f"{time() - start:.2f} seconds", end="\n\n") for op in OPERATORS: print(f"Aggregate('{op}') ...") start = time() uk, rv = g.aggregate(vals, op) print(f"{time() - start:.2f} seconds", end="\n\n") sys.exit()
start = time.time() dictionary2 = ak.read_all(allfiles) end = time.time() t2 = end - start print("read_all() seconds: %.3f" % (t2)) for key, value in dictionary2.items(): print(key, type(value), value, len(value)) if __name__ == '__main__': if len(sys.argv) < 3: print("Usage: {} <hostname> <port> <HDF5_filenames>".format( sys.argv[0])) sys.exit() ak.connect(sys.argv[1], sys.argv[2]) ak.verbose = False #client verbose Flag cwd = os.getcwd() allfiles = glob(cwd + '/../converter/netflow_day-*.hdf') if len(sys.argv) > 3: allfiles = sys.argv[3:] start = time.time() dictionary1 = ak.read_all(allfiles, iterative=True) end = time.time() t1 = end - start print("read_all(iterative=True) seconds: %.3f" % (t1)) for key, value in dictionary1.items(): print(key, type(value), value, len(value)) start = time.time()
if __name__ == "__main__": import argparse, sys parser = argparse.ArgumentParser( description= "Runs and times reductions over arrays in both arkouda and numpy.") parser.add_argument('hostname', help='Hostname of arkouda server') parser.add_argument('port', type=int, help='Port of arkouda server') parser.add_argument('-n', '--size', type=int, default=10**6, help='Problem size: length of array to argsort') args = parser.parse_args() ak.verbose = False ak.connect(args.hostname, args.port) print("size = ", args.size) SIZE = args.size a = ak.randint(0, 2 * SIZE, SIZE) b = ak.randint(0, 2 * SIZE, SIZE) set_union = ak.union1d(a, b) print("union1d = ", set_union.size, set_union) # elements in a or elements in b (or in both a and b) passed = ak.all(ak.in1d(set_union, a) | ak.in1d(set_union, b)) print("union1d passed test: ", passed) set_intersection = ak.intersect1d(a, b) print("intersect1d = ", set_intersection.size, set_intersection) # elements in a and elements in b (elements in both a and b) passed = ak.all(
def test_disconnect_on_disconnected_client(self): ak.disconnect() self.assertFalse(ak.client.connected) ak.disconnect() ak.connect(server=ArkoudaTest.server, port=ArkoudaTest.port)