def testForceTask(self):
'''Test the execution of tasks with -s force'''
# FIXME This test will not work because there is no frontend in the
# test so there is no way to pass the --resume option to the kernel
# to actually rerun the scripts.
with sos_kernel() as kc:
# the cell will actually be executed several times
# with automatic-reexecution
code = """
%set -v1
%run -s force
[10]
input: for_each={'i': range(1)}
task:
run: expand=True
echo this is "{i}"
sleep {i}
[20]
input: for_each={'i': range(2)}
task:
run: expand=True
echo this aa is "{i}"
sleep {i}
"""
# these should be automatically rerun by the frontend
long_execute(kc=kc, code=code)
wait_for_idle(kc)
def testPendingTask(self):
'''Test the execution of tasks with -s force'''
with sos_kernel() as kc:
# the cell will actually be executed several times
# with automatic-reexecution
code = """
%run -s force -W
[10]
input: for_each={'i': range(2)}
task:
run: expand=True
echo this is jupyter pending test "{i}"
sleep {10+i}
"""
# these should be automatically rerun by the frontend
execute(kc=kc, code=code)
wait_for_idle(kc)
# check for task?
execute(kc=kc, code='%tasks')
res = get_display_data(kc.iopub_channel, 'text/html')
# get IDs
# table_localhost_ac755352394584f797cebddf2c0b8ca7"
tid = res.split('table_localhost_')[-1].split('"')[0]
# now we have the tid, we can check task info
execute(kc=kc, code='%taskinfo ' + tid)
res = get_display_data(kc.iopub_channel, 'text/html')
self.assertTrue(tid in res)
def testShell(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code="!echo ha ha")
stdout, stderr = get_std_output(iopub)
self.assertTrue('ha ha' in stdout, "GOT ERROR {}".format(stderr))
self.assertEqual(stderr, '')
def testRemoteTaskFromJupyter(self):
'''Test the execution of tasks with -q '''
from ipykernel.tests.utils import execute
from sos_notebook.test_utils import sos_kernel, get_display_data
subprocess.call(['sos', 'purge'])
with sos_kernel() as kc:
# the cell will actually be executed several times
# with automatic-reexecution
code = """
%run -s force -W -q ts -c ~/docker.yml
[10]
input: for_each={'i': range(2)}
task:
run: expand=True
echo this is jupyter pending test "{i}"
sleep {10+i}
"""
# these should be automatically rerun by the frontend
execute(kc=kc, code=code)
res = get_display_data(kc.iopub_channel, 'text/html')
# check for task?
execute(kc=kc, code='%tasks -q ts')
res = get_display_data(kc.iopub_channel, 'text/html')
self.assertTrue('table_ts_' in res, 'Got {}'.format(res))
# get IDs
# table_localhost_ac755352394584f797cebddf2c0b8ca7"
tid = res.split('table_ts_')[-1].split('"')[0]
# now we have the tid, we can check task info
execute(kc=kc, code='%taskinfo -q ts ' + tid)
res = get_display_data(kc.iopub_channel, 'text/html')
self.assertTrue(tid in res, 'expect {} in {}'.format(tid, res))
# there should be two tasks
lines = subprocess.check_output(['sos', 'status', '-q', 'ts', '-c', '~/docker.yml']).decode().splitlines()
self.assertGreaterEqual(len(lines), 2)
def testCompleter(self):
with sos_kernel() as kc:
# match magics
ins_print = inspect(kc, 'print')['data']['text/plain']
self.assertTrue('print' in ins_print,
'Returned: {}'.format(ins_print))
wait_for_idle(kc)
#
# keywords
ins_depends = inspect(kc, 'depends:')['data']['text/plain']
self.assertTrue('dependent targets' in ins_depends,
'Returned: {}'.format(ins_depends))
wait_for_idle(kc)
#
execute(kc=kc, code='alpha=5')
wait_for_idle(kc)
execute(kc=kc, code='%use Python3')
wait_for_idle(kc)
# action
ins_run = inspect(kc, 'run:')['data']['text/plain']
self.assertTrue('sos.actions' in ins_run,
'Returned: {}'.format(ins_run))
wait_for_idle(kc)
#
ins_alpha = inspect(kc, 'alpha')['data']['text/plain']
self.assertTrue('5' in ins_alpha, 'Returned: {}'.format(ins_alpha))
wait_for_idle(kc)
for magic in ('get', 'run', 'set', 'sosrun', 'rerun', 'toc'):
ins_magic = inspect(kc, '%' + magic, 2)['data']['text/plain']
self.assertTrue('usage: %' + magic in ins_magic,
'Returned: {}'.format(ins_magic))
wait_for_idle(kc)
execute(kc=kc, code='%use SoS')
wait_for_idle(kc)
def testCompleter(self):
with sos_kernel() as kc:
# match magics
ins_print = inspect(kc, "print")["data"]["text/plain"]
self.assertTrue("print" in ins_print,
"Returned: {}".format(ins_print))
wait_for_idle(kc)
#
# keywords
ins_depends = inspect(kc, "depends:")["data"]["text/plain"]
self.assertTrue("dependent targets" in ins_depends,
"Returned: {}".format(ins_depends))
wait_for_idle(kc)
#
execute(kc=kc, code="alpha=5")
wait_for_idle(kc)
execute(kc=kc, code="%use Python3")
wait_for_idle(kc)
# action
ins_run = inspect(kc, "run:")["data"]["text/plain"]
self.assertTrue("sos.actions" in ins_run,
"Returned: {}".format(ins_run))
wait_for_idle(kc)
#
ins_alpha = inspect(kc, "alpha")["data"]["text/plain"]
self.assertTrue("5" in ins_alpha, "Returned: {}".format(ins_alpha))
wait_for_idle(kc)
for magic in ("get", "run", "set", "sosrun", "toc"):
ins_magic = inspect(kc, "%" + magic, 2)["data"]["text/plain"]
self.assertTrue("usage: %" + magic in ins_magic,
"Returned: {}".format(ins_magic))
wait_for_idle(kc)
execute(kc=kc, code="%use SoS")
wait_for_idle(kc)
def testPythonToJavaScalars(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc,
code='''
import numpy as np
int1 = 10
int2 = 1000000000000000000
int4 = np.intc(20)
float1 = 0.1
float2 = 1e+50
string1 = 'abc'
bool1 = True
''')
wait_for_idle(kc)
execute(kc=kc, code='%use Java')
wait_for_idle(kc)
execute(kc=kc,
code='%get int1 int2 int4 float1 float2 string1 bool1')
wait_for_idle(kc)
#Test int1
execute(kc=kc, code='System.out.println(int1);')
stdout, _ = assemble_output(iopub)
self.assertEqual(stdout.strip(), '10')
#Test int2
execute(kc=kc, code='System.out.println(int2);')
stdout, _ = assemble_output(iopub)
self.assertEqual(stdout.strip(), '1000000000000000000')
#Test int4
execute(kc=kc, code='System.out.println(int4);')
stdout, _ = assemble_output(iopub)
self.assertEqual(stdout.strip(), '20')
#Test float1
execute(kc=kc, code='System.out.println(float1);')
stdout, _ = assemble_output(iopub)
self.assertEqual(stdout.strip()[:3], '0.1')
#Test float2
execute(kc=kc, code='System.out.println(float2);')
stdout, _ = assemble_output(iopub)
self.assertEqual(stdout.strip(), '1.0E50')
#Test string1
execute(kc=kc, code='System.out.println(string1);')
stdout, _ = assemble_output(iopub)
self.assertEqual(stdout.strip(), 'abc')
#Test bool1
execute(kc=kc, code='System.out.println(bool1);')
stdout, _ = assemble_output(iopub)
self.assertEqual(stdout.strip(), 'true')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testGetPythonDictWithSpecialKeyFromR(self):
# Python -> R
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
execute(kc=kc,
code='''
special_dict = {}
special_dict['11111'] = 1
special_dict['_1111'] = 'a'
special_dict[11112] = 2
special_dict[(1,2)] = 3
''')
wait_for_idle(kc)
execute(kc=kc,
code='''%use R
%get special_dict
keys = names(special_dict)
''')
wait_for_idle(kc)
execute(kc=kc,
code='''%use sos
%get keys --from R
%dict keys
''')
res = get_result(iopub)['keys']
for key in ["X11111", "X_1111", "X11112", "X_1__2_"]:
self.assertTrue(key in res, f"Expecting {key}")
def testMagicUse(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code="%use R0 -l sos_r.kernel:sos_R -c #CCCCCC")
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
execute(kc=kc,
code="%use R1 -l sos_r.kernel:sos_R -k ir -c #CCCCCC")
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
execute(kc=kc, code="%use R2 -k ir")
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
execute(kc=kc, code="a <- 1024")
wait_for_idle(kc)
execute(kc=kc, code="a")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 1024')
execute(kc=kc, code="%use R3 -k ir -l R")
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
execute(kc=kc, code="a <- 233")
wait_for_idle(kc)
execute(kc=kc, code="a")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 233')
execute(kc=kc, code="%use R2 -c red")
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
execute(kc=kc, code="a")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 1024')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testPythonToJavaDataframe(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc,
code='''
import numpy as np
import pandas as pd
dataframe = pd.DataFrame(np.random.randn(1000,4), columns=list('ABCD'))
''')
wait_for_idle(kc)
execute(kc=kc, code='%use Java')
wait_for_idle(kc)
execute(kc=kc, code='%get dataframe')
wait_for_idle(kc)
execute(
kc=kc,
code=
'System.out.println(dataframe.rowCount() * dataframe.columnCount());'
)
stdout, _ = assemble_output(iopub)
self.assertEqual(stdout.strip(), '4000')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testGetPythonDataFrameFromRuby(self):
# Python -> Ruby
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
execute(kc=kc, code='''
import pandas as pd
import numpy as np
arr = np.random.randn(1000)
arr[::10] = np.nan
df = pd.DataFrame({'column_{0}'.format(i): arr for i in range(10)})
''')
clear_channels(iopub)
execute(kc=kc, code="%use Ruby")
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '', "GOT ERROR {}".format(stderr))
execute(kc=kc, code="%get df")
wait_for_idle(kc)
execute(kc=kc, code="df.size()")
res = get_display_data(iopub)
self.assertEqual(res, '1000')
execute(kc=kc, code="df.vectors().to_a().size()")
res = get_display_data(iopub)
self.assertEqual(res, '10')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testReverseSharedVariable(self):
'''Test shared variables defined in auxiliary steps'''
if file_target('a.txt').exists():
file_target('a.txt').unlink()
script = r'''
%run B
[A: shared='b', provides='a.txt']
b = 1
run:
touch a.txt
[B_1]
depends: 'a.txt'
[B_2]
print(b)
'''
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code=script)
wait_for_idle(kc)
self.assertTrue(os.path.isfile('a.txt'))
execute(kc=kc, code="b")
res = get_result(iopub)
self.assertEqual(res, 1)
def testGetPythonDataFrameFromMatlab(self):
# Python -> Matlab/Matlab
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
execute(kc=kc,
code='''
import pandas as pd
import numpy as np
import scipy.io as sio
arr = np.random.randn(1000)
arr[::10] = np.nan
df = pd.DataFrame({'column_{0}'.format(i): arr for i in range(10)})
''')
clear_channels(iopub)
execute(kc=kc, code="%use MATLAB")
wait_for_idle(kc)
#_, stderr = assemble_output(iopub)
#self.assertEqual(stderr, '')
execute(kc=kc, code="%get df")
wait_for_idle(kc)
execute(kc=kc, code="display(size(df))")
stdout, _ = assemble_output(iopub)
self.assertEqual(stdout.strip().split(), ['1000', '10'])
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testPutMatlabDataToPython(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc,
code="""
%use MATLAB
null_var = NaN
num_var = 123
num_arr_var = [1, 2, 3]
logic_var = true
logic_arr_var = [true, false, true]
char_var = '1"23'
char_arr_var = ['1'; '2'; '3']
mat_var = [1:3; 2:4]
""")
wait_for_idle(kc)
execute(kc=kc,
code="""
%dict -r
%put null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var mat_var
%dict null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var mat_var
""")
res = get_result(iopub)
self.assertEqual(res['null_var'], None)
self.assertEqual(res['num_var'], 123)
self.assertEqual(list(res['num_arr_var']), [1, 2, 3])
self.assertEqual(res['logic_var'], True)
self.assertEqual(res['logic_arr_var'], [True, False, True])
self.assertEqual(res['char_var'], '1"23')
#self.assertEqual(res['named_list_var'], {'a': 1, 'b': 2, 'c': '3'})
self.assertEqual(res['mat_var'].shape, (2, 3))
self.assertEqual(res['char_arr_var'], ['1', '2', '3'])
#self.assertEqual(res['recursive_var'], {'a': 1, 'b': {'c': 3, 'd': 'whatever'}})
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testMagicDebug(self):
with sos_kernel() as kc:
# preview variable
execute(kc=kc, code='''
%debug on
%debug off
''')
wait_for_idle(kc)
def testKernel(self):
with sos_kernel() as kc:
execute(kc=kc, code='a = 1')
stdout, stderr = assemble_output(kc.get_iopub_msg)
self.assertEqual(stdout.strip(), '',
f'Stdout is not empty, "{stdout}" received')
self.assertEqual(stderr.strip(), '',
f'Stderr is not empty, "{stderr}" received')
def testMagicSessioninfo(self):
with sos_kernel() as kc:
# preview variable
execute(kc=kc, code='''
%use Python3
%use SoS
%sessioninfo
''')
wait_for_idle(kc)
def testMagicPut(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code="%use R")
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
execute(kc=kc, code="a <- 1024")
wait_for_idle(kc)
execute(kc=kc, code="%put a")
wait_for_idle(kc)
#execute(kc=kc, code="%put __k_k")
#wait_for_idle(kc)
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
execute(kc=kc, code="a")
res = get_result(iopub)
self.assertEqual(res, 1024)
# strange name
execute(kc=kc, code="%use R")
wait_for_idle(kc)
execute(kc=kc, code=".a.b <- 22")
wait_for_idle(kc)
execute(kc=kc, code="%put .a.b")
wait_for_idle(kc)
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
execute(kc=kc, code="_a_b")
res = get_result(iopub)
self.assertEqual(res, 22)
#
# test to yet another kernel
#
execute(kc=kc, code="%put --to Python3 _a_b")
wait_for_idle(kc)
execute(kc=kc, code="%use Python3")
wait_for_idle(kc)
execute(kc=kc, code="_a_b")
res = get_result(iopub)
self.assertEqual(res, 22)
#
execute(kc=kc, code="kkk = 'ast'")
wait_for_idle(kc)
execute(kc=kc, code="%put --to R kkk")
res = get_result(iopub)
execute(kc=kc, code="%use R")
wait_for_idle(kc)
execute(kc=kc, code="kkk <- paste0(kkk, '1')")
wait_for_idle(kc)
execute(kc=kc, code="%put --to Python3 kkk")
wait_for_idle(kc)
execute(kc=kc, code="%use Python3")
wait_for_idle(kc)
execute(kc=kc, code="kkk")
res = get_result(iopub)
self.assertEqual(res, 'ast1')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testGetPythonDataFromR(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc,
code='''
null_var = None
num_var = 123
import numpy
import pandas
num_arr_var = numpy.array([1, 2, 3])
logic_var = True
logic_arr_var = [True, False, True]
char_var = '1"23'
char_arr_var = ['1', '2', '3']
list_var = [1, 2, '3']
dict_var = dict(a=1, b=2, c='3')
set_var = {1, 2, '3'}
mat_var = numpy.matrix([[1,2],[3,4]])
recursive_var = {'a': {'b': 123}, 'c': True}
comp_var = 1+2j
seri_var = pandas.Series([1,2,3,3,3,3])
''')
wait_for_idle(kc)
execute(kc=kc,
code='''\
%use R
%get null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var mat_var set_var list_var dict_var recursive_var comp_var seri_var
%dict -r
%put null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var mat_var set_var list_var dict_var recursive_var comp_var seri_var
%use sos
seri_var = list(seri_var)
''')
wait_for_idle(kc)
execute(kc=kc,
code='''\
%dict null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var mat_var set_var list_var dict_var recursive_var comp_var seri_var
''')
res = get_result(iopub)
self.assertEqual(res['null_var'], None)
self.assertEqual(res['num_var'], 123)
self.assertEqual(res['num_arr_var'].tolist(), [1, 2, 3])
self.assertEqual(res['logic_var'], True)
self.assertEqual(res['logic_arr_var'], [True, False, True])
self.assertEqual(res['char_var'], '1"23')
self.assertEqual(res['char_arr_var'], ['1', '2', '3'])
self.assertEqual(res['list_var'], [1, 2, '3'])
self.assertEqual(res['dict_var'], {'a': 1, 'b': 2, 'c': '3'})
self.assertEqual(res['mat_var'].shape, (2, 2))
self.assertEqual(res['recursive_var'], {
'a': {
'b': 123
},
'c': True
})
self.assertEqual(res['comp_var'], 1 + 2j)
self.assertEqual(res['seri_var'], [1, 2, 3, 3, 3, 3])
def testPutRDataToPython(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
execute(kc=kc,
code="""\
%use R
null_var = NULL
num_var = 123
num_arr_var = c(1, 2, 3)
logic_var = TRUE
logic_arr_var = c(TRUE, FALSE, TRUE)
char_var = '1\"23'
char_arr_var = c(1, 2, '3')
list_var = list(1, 2, '3')
named_list_var = list(a=1, b=2, c='3')
mat_var = matrix(c(1,2,3,4), nrow=2)
recursive_var = list(a=1, b=list(c=3, d='whatever'))
comp_var = 1+2i
seri_var = setNames(c(1,2,3,3,3,3),c(0:5))
""")
wait_for_idle(kc)
execute(kc=kc,
code='''\
%put null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var mat_var list_var named_list_var recursive_var comp_var seri_var
%use sos
seri_var = list(seri_var)
''')
wait_for_idle(kc)
execute(
kc=kc,
code=
"%dict null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var mat_var list_var named_list_var recursive_var comp_var seri_var"
)
res = get_result(iopub)
self.assertEqual(res['null_var'], None)
self.assertEqual(res['num_var'], 123)
self.assertEqual(res['num_arr_var'], [1, 2, 3])
self.assertEqual(res['logic_var'], True)
self.assertEqual(res['logic_arr_var'], [True, False, True])
self.assertEqual(res['char_var'], '1"23')
self.assertEqual(res['char_arr_var'], ['1', '2', '3'])
self.assertEqual(res['list_var'], [1, 2, '3'])
self.assertEqual(res['named_list_var'], {'a': 1, 'b': 2, 'c': '3'})
self.assertEqual(res['mat_var'].shape, (2, 2))
self.assertEqual(res['recursive_var'], {
'a': 1,
'b': {
'c': 3,
'd': 'whatever'
}
})
self.assertEqual(res['comp_var'], 1 + 2j)
self.assertEqual(res['seri_var'], [1, 2, 3, 3, 3, 3])
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testCD(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code="%cd ..")
wait_for_idle(kc)
execute(kc=kc, code="print(os.getcwd())")
stdout, stderr = get_std_output(iopub)
self.assertFalse(stdout.strip().endswith('jupyter'))
self.assertEqual(stderr, '')
execute(kc=kc, code="%cd jupyter")
def testMagicRevisions(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
# preview variable
execute(kc=kc, code='''
%revisions
''')
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '',
f"Get error {stderr} for magic revisions")
def testMagicPreview(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
#
execute(kc=kc, code='''
%preview mtcars
%use R
''')
wait_for_idle(kc)
execute(kc=kc, code='''%use sos''')
wait_for_idle(kc)
# preview figure
execute(kc=kc,
code='''\
%preview -n a.png
R:
png('a.png')
plot(0)
dev.off()
''')
res = get_display_data(iopub, 'image/png')
self.assertGreater(len(res), 1000, 'Expect a image {}'.format(res))
# preview jpg
execute(kc=kc,
code='''\
%preview a.jp*
R:
jpeg('a.jpg')
plot(0)
dev.off()
''')
res = get_display_data(iopub, 'image/jpeg')
self.assertGreater(len(res), 1000, 'Expect a image {}'.format(res))
# preview pdf in iframe (by default)
execute(kc=kc,
code='''
%preview a.pdf
R:
pdf('a.pdf')
plot(0)
dev.off()
''')
# or png (which requires imagemagick
wait_for_idle(kc)
execute(kc=kc, code='''\
%preview a.pdf -s png
''')
# could return html or image depending on configuration
res = get_display_data(iopub, ('text/html', 'image/png'))
self.assertTrue('iframe' in res or len(res) > 1000,
'Expect a image {}'.format(res))
#
# switch back
execute(kc=kc, code='%use SoS')
wait_for_idle(kc)
def testMagicSandbox(self):
with sos_kernel() as kc:
# preview variable
execute(kc=kc,
code='''
%sandbox
with open('test_blah.txt', 'w') as tb:
tb.write('a')
''')
wait_for_idle(kc)
self.assertFalse(os.path.exists('test_blah.txt'))
def testGetPythonDataFromMatlab(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc,
code='''
null_var = None
num_var = 123
import numpy
import scipy.io as sio
num_arr_var = numpy.array([1, 2, 3])
logic_var = True
logic_arr_var = [True, False, True]
float_var = [1.2, 2.1]
char_var = '1"23'
char_arr_var = ['1', '2', '3']
list_var = [1, 2, '3']
dict_var = dict(a=1, b=2, c='3')
set_var = {1, 2, '3'}
mat_var = numpy.matrix([[1,2],[3,4]])
recursive_var = {'a': {'b': 123}, 'c': True}
''')
wait_for_idle(kc)
execute(kc=kc,
code='''
%use MATLAB
%get null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var mat_var set_var list_var dict_var recursive_var float_var
%dict -r
%put null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var mat_var set_var list_var dict_var recursive_var float_var
%use sos
%dict null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var mat_var set_var list_var dict_var recursive_var float_var
''')
res = get_result(iopub)
self.assertEqual(res['null_var'], None)
self.assertEqual(res['num_var'], 123)
self.assertEqual(list(res['num_arr_var']), [1, 2, 3],
"Got {}".format(res['num_arr_var']))
self.assertEqual(res['logic_var'], True)
self.assertEqual(res['logic_arr_var'], [True, False, True])
self.assertEqual(res['char_var'], '1"23')
self.assertEqual(list(res['float_var']), [1.2, 2.1])
self.assertEqual(list(res['list_var']), [1, 2, '3'],
'Got {}'.format(res['list_var']))
self.assertEqual(res['dict_var'], {'a': 1, 'b': 2, 'c': '3'})
self.assertTrue(
len(res['set_var']) == 3 and '3' in res['set_var']
and 1 in res['set_var'] and 2 in res['set_var'])
self.assertEqual(res['mat_var'].shape, (2, 2))
self.assertEqual(res['recursive_var'], {
'a': {
'b': 123
},
'c': True
})
def testMagicSessionInfo(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
# preview variable
execute(kc=kc, code='''
%use Python3
%use SoS
%sessioninfo
''')
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '',
f"Get error {stderr} for magic sessioninfo")
def testSubKernel(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code="%use R")
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
execute(kc=kc, code="a <- 1024")
wait_for_idle(kc)
execute(kc=kc, code="a")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 1024')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testMagicSave(self):
with sos_kernel() as kc:
if os.path.isfile('test.txt'):
os.remove('test.txt')
execute(kc=kc,
code='''\
%preview ~/test.txt
%save ~/test.txt
a=1
''')
wait_for_idle(kc)
with open(os.path.join(os.path.expanduser('~'), 'test.txt')) as tt:
self.assertEqual(tt.read(), 'a=1\n')
def testMagicMatplotlib(self):
with sos_kernel() as kc:
# create a data frame
execute(kc=kc,
code='''
%matplotlib inline
In [59]:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10)
plt.plot(x, np.sin(x), '--', linewidth=2)
plt.show()''')
wait_for_idle(kc)
def testKernel(self):
with sos_kernel() as kc:
execute(kc=kc, code='a = 1')
stdout, stderr = assemble_output(kc.iopub_channel)
self.assertEqual(stdout.strip(), '',
f'Stdout is not empty, "{stdout}" received')
self.assertEqual(stderr.strip(), '',
f'Stderr is not empty, "{stderr}" received')
execute(kc=kc, code='%use Python3\n%get a\nprint(a)')
stdout, stderr = assemble_output(kc.iopub_channel)
self.assertEqual(stderr.strip(), '',
f'Stderr is not empty, "{stderr}" received')
self.assertEqual(stdout.strip(), '1',
f'Stdout should be 1, "{stdout}" received')
