class TestParallelEvaluate(BaseTestCase):
KERNEL_PATH = json_config and json_config.get("kernel", None) or None
def test_parallel_evaluate_local(self):
exprs = [wl.FromLetterNumber(i) for i in range(1, 11)]
res = parallel_evaluate(exprs, evaluator_spec=self.KERNEL_PATH)
self.assertEqual(res,
["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])
def test_parallel_evaluate_sizeone(self):
exprs = [wl.FromLetterNumber(i) for i in range(1, 11)]
res = parallel_evaluate(exprs,
evaluator_spec=self.KERNEL_PATH,
max_evaluators=1)
self.assertEqual(res,
["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])
def test_parallel_evaluate_sizeone(self):
exprs = [wl.FromLetterNumber(i) for i in range(1, 11)]
res = parallel_evaluate(
exprs,
evaluator_spec=[
self.KERNEL_PATH, self.KERNEL_PATH, self.KERNEL_PATH
],
max_evaluators=1,
)
self.assertEqual(res,
["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])
class TestParalleleEvaluate(BaseTestCase):
if json_config:
KERNEL_PATH = json_config.get('kernel', None)
def test_parallel_evaluate_local(self):
exprs = [wl.FromLetterNumber(i) for i in range(1, 11)]
res = parallel_evaluate(exprs, evaluator_spec=self.KERNEL_PATH)
self.assertEqual(res,
["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])
def test_parallel_evaluate_sizeone(self):
exprs = [wl.FromLetterNumber(i) for i in range(1, 11)]
res = parallel_evaluate(exprs,
evaluator_spec=self.KERNEL_PATH,
max_evaluators=1)
self.assertEqual(res,
["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])
def test_parallel_evaluate_sizeone(self):
exprs = [wl.FromLetterNumber(i) for i in range(1, 11)]
res = parallel_evaluate(exprs,
evaluator_spec=[
self.KERNEL_PATH, self.KERNEL_PATH,
self.KERNEL_PATH
],
max_evaluators=1)
self.assertEqual(res,
["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])
def test_parallel_evaluate_cloud(self):
cloud = WolframCloudAsyncSession(
credentials=secured_authentication_key, server=server)
exprs = [wl.FromLetterNumber(i) for i in range(1, 11)]
res = parallel_evaluate(exprs, evaluator_spec=cloud)
self.assertEqual(len(res), 10)
for elem in res:
self.assertTrue(isinstance(elem, six.string_types))
def test_parallel_evaluate_mixed(self):
cloud = WolframCloudAsyncSession(
credentials=secured_authentication_key, server=server)
exprs = [wl.FromLetterNumber(i) for i in range(1, 11)]
res = parallel_evaluate(
exprs, evaluator_spec=[cloud, self.KERNEL_PATH, cloud])
self.assertEqual(len(res), 10)
for elem in res:
self.assertTrue(isinstance(elem, six.string_types))
class TestCaseSettings(BaseTestCase):
KERNEL_PATH = json_config and json_config.get("kernel", None) or None
@classmethod
def setUpClass(cls):
cls.setupKernelSession()
@classmethod
def tearDownClass(cls):
cls.tearDownKernelSession()
@classmethod
def tearDownKernelSession(cls):
if cls.kernel_session is not None:
cls.kernel_session.terminate()
@classmethod
def setupKernelSession(cls):
cls.kernel_session = WolframLanguageSession(
cls.KERNEL_PATH, kernel_loglevel=logging.INFO)
cls.kernel_session.set_parameter("STARTUP_TIMEOUT", 5)
cls.kernel_session.set_parameter("TERMINATE_TIMEOUT", 3)
cls.kernel_session.start()
@classmethod
def class_kwargs_parameters(cls, testcase, kernelclass):
kernel_session = kernelclass(
cls.KERNEL_PATH,
kernel_loglevel=logging.INFO,
STARTUP_TIMEOUT=5,
TERMINATE_TIMEOUT=3,
HIDE_SUBPROCESS_WINDOW=False,
)
testcase.assertEqual(kernel_session.get_parameter("STARTUP_TIMEOUT"),
5)
testcase.assertEqual(kernel_session.get_parameter("TERMINATE_TIMEOUT"),
3)
testcase.assertEqual(
kernel_session.get_parameter("HIDE_SUBPROCESS_WINDOW"), False)
@classmethod
def class_bad_kwargs_parameters(cls, testcase, kernelclass):
with testcase.assertRaises(KeyError):
kernel_session = kernelclass(cls.KERNEL_PATH,
kernel_loglevel=logging.INFO,
foo=1)
kernel_session.get_parameter("foo")
class TestParallelEvaluateCloud(TestParallelEvaluate):
KERNEL_PATH = json_config and json_config.get("kernel", None) or None
def test_parallel_evaluate_cloud(self):
cloud = WolframCloudAsyncSession(
credentials=secured_authentication_key, server=server)
exprs = [wl.FromLetterNumber(i) for i in range(1, 11)]
res = parallel_evaluate(exprs, evaluator_spec=cloud)
self.assertEqual(len(res), 10)
for elem in res:
self.assertTrue(isinstance(elem, six.string_types))
def test_parallel_evaluate_mixed(self):
cloud = WolframCloudAsyncSession(
credentials=secured_authentication_key, server=server)
exprs = [wl.FromLetterNumber(i) for i in range(1, 11)]
res = parallel_evaluate(
exprs, evaluator_spec=[cloud, self.KERNEL_PATH, cloud])
self.assertEqual(len(res), 10)
for elem in res:
self.assertTrue(isinstance(elem, six.string_types))
class TestKernelCloudPool(TestKernelPool):
KERNEL_PATH = json_config and json_config.get("kernel", None) or None
@run_in_loop
async def test_pool_from_one_cloud(self):
session = WolframCloudAsyncSession(
credentials=secured_authentication_key, server=server)
async with WolframEvaluatorPool(session,
kernel_loglevel=logging.INFO,
STARTUP_TIMEOUT=5,
TERMINATE_TIMEOUT=3) as pool:
await self._pool_evaluation_check(pool)
self.assertFalse(session.started)
self.assertTrue(session.stopped)
@run_in_loop
async def test_pool_from_mixed_kernel_cloud_path(self):
await self.pool.terminate()
sessions = (
WolframCloudAsyncSession(credentials=secured_authentication_key,
server=server),
WolframLanguageAsyncSession(self.KERNEL_PATH),
self.KERNEL_PATH,
)
async with WolframEvaluatorPool(sessions,
kernel_loglevel=logging.INFO,
STARTUP_TIMEOUT=5,
TERMINATE_TIMEOUT=3) as pool:
await self._pool_evaluation_check(pool)
for session in sessions:
if not isinstance(session, six.string_types):
self.assertFalse(session.started)
self.assertTrue(session.stopped)
class TestCoroutineSession(BaseTestCase):
KERNEL_PATH = json_config and json_config.get("kernel", None) or None
@classmethod
def setUpClass(cls):
cls.async_session = WolframLanguageAsyncSession(
cls.KERNEL_PATH, kernel_loglevel=logging.INFO)
cls.async_session.set_parameter("STARTUP_TIMEOUT", 5)
cls.async_session.set_parameter("TERMINATE_TIMEOUT", 3)
LOOP.run_until_complete(cls.async_session.start())
@classmethod
def tearDownClass(cls):
if cls.async_session is not None:
LOOP.run_until_complete(cls.async_session.stop())
@run_in_loop
async def test_eval_inputform(self):
start = time.perf_counter()
task = asyncio.create_task(
self.async_session.evaluate(wlexpr("Pause[.1]; Range[3]")))
timer = time.perf_counter() - start
self.assertTrue(timer < 0.1)
res = await task
numpy.assert_array_equal(res, numpy.arange(1, 4))
@run_in_loop
async def test_eval_wlsymbol(self):
start = time.perf_counter()
task = asyncio.create_task(
self.async_session.evaluate(
wl.CompoundExpression(wl.Pause(0.1), wl.Range(2))))
timer = time.perf_counter() - start
self.assertTrue(timer < 0.1)
res = await task
numpy.assert_array_equal(res, numpy.arange(1, 3))
@run_in_loop
async def test_eval_wxf(self):
start = time.perf_counter()
task = asyncio.create_task(
self.async_session.evaluate_wxf(wlexpr("Pause[.1]; Range[3]")))
timer = time.perf_counter() - start
self.assertTrue(timer < 0.1)
wxf = await task
res = binary_deserialize(wxf)
numpy.assert_array_equal(res, numpy.arange(1, 4))
@run_in_loop
async def test_eval_wrap(self):
start = time.perf_counter()
task = asyncio.create_task(
self.async_session.evaluate_wrap(wlexpr("Pause[.1]; Range[3]")))
timer = time.perf_counter() - start
self.assertTrue(timer < 0.1)
res = await task
numpy.assert_array_equal(res.get(), numpy.arange(1, 4))
@run_in_loop
async def test_eval_many(self):
exprs = [("%s+%s" % (i, i)) for i in range(10)]
expected = [i + i for i in range(10)]
res = await self.async_session.evaluate_many(exprs)
self.assertEqual(res, expected)
@run_in_loop
async def test_eval_start(self):
try:
async_session = WolframLanguageAsyncSession(
self.KERNEL_PATH, kernel_loglevel=logging.INFO)
res = await async_session.evaluate(wl.Plus(1, 1))
self.assertTrue(res, 2)
finally:
if async_session:
await async_session.terminate()
@run_in_loop
async def test_eval_parallel(self):
tasks = [
asyncio.create_task(self.async_session.evaluate(i + 1))
for i in range(10)
]
res = await asyncio.gather(*tasks)
self.assertEqual(res, list(range(1, 11)))
def test_kwargs_parameters(self):
TestKernelBase.class_kwargs_parameters(self,
WolframLanguageAsyncSession)
def test_bad_kwargs_parameters(self):
TestKernelBase.class_bad_kwargs_parameters(
self, WolframLanguageAsyncSession)
class TestKernelPool(BaseTestCase):
KERNEL_PATH = json_config and json_config.get("kernel", None) or None
@classmethod
def setUpClass(cls):
cls.pool = WolframEvaluatorPool(
cls.KERNEL_PATH,
kernel_loglevel=logging.INFO,
STARTUP_TIMEOUT=5,
TERMINATE_TIMEOUT=3,
)
LOOP.run_until_complete(cls.pool.start())
@run_in_loop
async def test_eval_wlsymbol(self):
tasks = [
asyncio.create_task(self.pool.evaluate(wl.FromLetterNumber(i)))
for i in range(1, 11)
]
res = await asyncio.gather(*tasks)
self.assertEqual({*res},
{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"})
@run_in_loop
async def test_eval_inputform(self):
tasks = [
asyncio.create_task(
self.pool.evaluate(wlexpr("FromLetterNumber[%i]" % i)))
for i in range(1, 11)
]
res = await asyncio.gather(*tasks)
self.assertEqual({*res},
{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"})
@run_in_loop
async def test_eval_wxf(self):
tasks = [
asyncio.create_task(
self.pool.evaluate_wxf(wlexpr("FromLetterNumber[%i]" % i)))
for i in range(1, 11)
]
res = await asyncio.gather(*tasks)
res = {binary_deserialize(wxf, consumer=WXFConsumer()) for wxf in res}
self.assertEqual(res,
{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"})
@run_in_loop
async def test_failed_expr(self):
tasks = [
asyncio.create_task(self.pool.evaluate(wlexpr("Pause[.1]; 1/0")))
for i in range(1, 10)
]
res = await asyncio.gather(*tasks)
self.assertEqual(res, [wl.DirectedInfinity() for _ in range(1, 10)])
@run_in_loop
async def test_pool_from_one_kernel(self):
await self.pool.terminate()
session = WolframLanguageAsyncSession(self.KERNEL_PATH)
async with WolframEvaluatorPool(session,
kernel_loglevel=logging.INFO,
STARTUP_TIMEOUT=5,
TERMINATE_TIMEOUT=3) as pool:
await self._pool_evaluation_check(pool)
self.assertFalse(session.started)
self.assertTrue(session.stopped)
async def _pool_evaluation_check(self, pool):
tasks = [
asyncio.create_task(pool.evaluate(wl.FromLetterNumber(i)))
for i in range(1, 11)
]
res = await asyncio.gather(*tasks)
self.assertEqual({*res},
{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"})
def setUpClass(cls):
cls.KERNEL_PATH = json_config.get('kernel', None)
cls.setupKernelSession()
class TestKernelPool(BaseTestCase):
if json_config:
KERNEL_PATH = json_config.get('kernel', None)
@classmethod
def setUpClass(cls):
cls.setupKernelSession()
@classmethod
def tearDownClass(cls):
cls.tearDownKernelSession()
@classmethod
def tearDownKernelSession(cls):
if cls.pool is not None:
LOOP.run_until_complete(cls.pool.terminate())
@classmethod
def setupKernelSession(cls):
cls.pool = WolframEvaluatorPool(cls.KERNEL_PATH,
kernel_loglevel=logging.INFO,
STARTUP_TIMEOUT=5,
TERMINATE_TIMEOUT=3)
LOOP.run_until_complete(cls.pool.start())
@run_in_loop
async def test_eval_wlsymbol(self):
tasks = [
asyncio.create_task(self.pool.evaluate(wl.FromLetterNumber(i)))
for i in range(1, 11)
]
res = await asyncio.gather(*tasks)
self.assertEqual({*res},
{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"})
@run_in_loop
async def test_eval_inputform(self):
tasks = [
asyncio.create_task(
self.pool.evaluate(wlexpr('FromLetterNumber[%i]' % i)))
for i in range(1, 11)
]
res = await asyncio.gather(*tasks)
self.assertEqual({*res},
{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"})
@run_in_loop
async def test_eval_wxf(self):
tasks = [
asyncio.create_task(
self.pool.evaluate_wxf(wlexpr('FromLetterNumber[%i]' % i)))
for i in range(1, 11)
]
res = await asyncio.gather(*tasks)
res = {binary_deserialize(wxf) for wxf in res}
self.assertEqual(res,
{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"})
@run_in_loop
async def test_failed_expr(self):
tasks = [
asyncio.create_task(self.pool.evaluate(wlexpr('Pause[.1]; 1/0')))
for i in range(1, 10)
]
res = await asyncio.gather(*tasks)
self.assertEqual(res, [wl.DirectedInfinity() for _ in range(1, 10)])
@run_in_loop
async def test_pool_from_one_kernel(self):
await self.pool.terminate()
session = WolframLanguageAsyncSession(self.KERNEL_PATH)
async with WolframEvaluatorPool(session,
kernel_loglevel=logging.INFO,
STARTUP_TIMEOUT=5,
TERMINATE_TIMEOUT=3) as pool:
await self._pool_evaluation_check(pool)
self.assertFalse(session.started)
self.assertTrue(session.stopped)
@run_in_loop
async def test_pool_from_one_cloud(self):
session = WolframCloudAsyncSession(
credentials=secured_authentication_key, server=server)
async with WolframEvaluatorPool(session,
kernel_loglevel=logging.INFO,
STARTUP_TIMEOUT=5,
TERMINATE_TIMEOUT=3) as pool:
await self._pool_evaluation_check(pool)
self.assertFalse(session.started)
self.assertTrue(session.stopped)
@run_in_loop
async def test_pool_from_mixed_kernel_cloud_path(self):
await self.pool.terminate()
sessions = (WolframCloudAsyncSession(
credentials=secured_authentication_key,
server=server), WolframLanguageAsyncSession(self.KERNEL_PATH),
self.KERNEL_PATH)
async with WolframEvaluatorPool(sessions,
kernel_loglevel=logging.INFO,
STARTUP_TIMEOUT=5,
TERMINATE_TIMEOUT=3) as pool:
await self._pool_evaluation_check(pool)
for session in sessions:
if not isinstance(session, six.string_types):
self.assertFalse(session.started)
self.assertTrue(session.stopped)
async def _pool_evaluation_check(self, pool):
tasks = [
asyncio.create_task(pool.evaluate(wl.FromLetterNumber(i)))
for i in range(1, 11)
]
res = await asyncio.gather(*tasks)
self.assertEqual({*res},
{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"})
