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)
