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 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 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 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 testMagicDict(self):
'''Test %dict magic'''
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code="a=12345")
wait_for_idle(kc)
execute(kc=kc, code="%dict a")
self.assertEqual(get_result(iopub)['a'], 12345)
execute(kc=kc, code="%dict --keys")
self.assertTrue('a' in get_result(iopub))
execute(kc=kc, code="%dict --reset")
wait_for_idle(kc)
execute(kc=kc, code="%dict --keys --all")
res = get_result(iopub)
self.assertTrue('a' not in res)
for key in ('run', 'expand_pattern'):
self.assertTrue(key in res)
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 testPutRDataFrameToPython(self):
# R -> Python
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
execute(kc=kc, code='%use R')
wait_for_idle(kc)
execute(kc=kc, code="%put mtcars")
assemble_output(iopub)
# the message can contain "Loading required package feathre"
#self.assertEqual(stderr, '')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
execute(kc=kc, code="mtcars.shape")
res = get_result(iopub)
self.assertEqual(res, (32, 11))
execute(kc=kc, code="mtcars.index[0]")
res = get_result(iopub)
self.assertEqual(res, 'Mazda RX4')
def testMagicGet(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code="a = 1025")
wait_for_idle(kc)
execute(kc=kc, code="_b_a = 22")
wait_for_idle(kc)
execute(kc=kc, code="%use R")
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
execute(kc=kc, code="%get a")
wait_for_idle(kc)
execute(kc=kc, code="a")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 1025')
execute(kc=kc, code="b <- 122\nc<-555")
wait_for_idle(kc)
#
execute(kc=kc, code="%get _b_a")
wait_for_idle(kc)
execute(kc=kc, code=".b_a")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 22')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
#
# get from a sub kernel
execute(kc=kc, code="%get --from R b")
wait_for_idle(kc)
execute(kc=kc, code="b")
res = get_result(iopub)
self.assertEqual(res, 122)
# get from a third kernel
execute(kc=kc, code="%use Python3")
wait_for_idle(kc)
execute(kc=kc, code="%get --from R c")
wait_for_idle(kc)
execute(kc=kc, code="c")
res = get_result(iopub)
self.assertEqual(res, 555)
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
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 testWith(self):
'''Test magic with'''
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
execute(kc=kc, code='var = [1, 2, 3, 4]')
wait_for_idle(kc)
execute(kc=kc, code='%with R -i var -o m\nm=mean(var)')
wait_for_idle(kc)
execute(kc=kc, code="%dict m")
res = get_result(iopub)
self.assertEqual(res['m'], 2.5)
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testDAG(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code='''\
%run
[a]
b=10
[default]
sos_run('a')
''')
wait_for_idle(kc)
execute(kc=kc, code="b")
res = get_result(iopub)
self.assertEqual(res, 10)
def testPutRubyDataToPython(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
execute(kc=kc, code="""\
%use Ruby
null_var = nil
num_var = 123
num_arr_var = [1, 2, 3]
logic_var = true
logic_arr_var = [true, true, false]
char_arr_var = [1, 2, "3"]
char_var = '1"23'
mat_var = N[[1, 2], [3, 4]]
recursive_var = {"a"=>1, "b"=>{"c"=>3}, "d"=>"whatever"}
comp_var = Complex(1,2)
single_char_var = 'a'
""")
wait_for_idle(kc)
execute(kc=kc, code="%put null_var num_var num_arr_var logic_var logic_arr_var char_arr_var char_var mat_var recursive_var comp_var single_char_var")
wait_for_idle(kc)
execute(kc=kc, code="%use sos")
# wait_for_idle(kc)
# execute(kc=kc, code='''
#%use sos
#named_list_var = list(named_list_var)
#''')
wait_for_idle(kc)
execute(kc=kc, code="%dict null_var num_var num_arr_var logic_var logic_arr_var char_arr_var char_var mat_var recursive_var comp_var single_char_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, True, False])
self.assertEqual(res['char_var'], '1"23')
self.assertEqual(res['char_arr_var'], [1, 2, '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['single_char_var'], 'a')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testRerun(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code='''\
%run
parameter: a=10
[default]
b = a
''')
wait_for_idle(kc)
#
execute(kc=kc, code='''\
%rerun --a 20
''')
wait_for_idle(kc)
execute(kc=kc, code="b")
res = get_result(iopub)
self.assertEqual(res, 20)
def testTarget(self):
for f in [
'A1.txt', 'A2.txt', 'C2.txt', 'B2.txt', 'B1.txt', 'B3.txt',
'C1.txt', 'C3.txt', 'C4.txt'
]:
if file_target(f).exists():
file_target(f).unlink()
#
# A1 <- B1 <- B2 <- B3
# |
# |
# \/
# A2 <- B2 <- C1 <- C2 <- C4
# C3
#
script = '''\
%run -t B1.txt -s force
[A_1]
input: 'B1.txt'
output: 'A1.txt'
run:
touch A1.txt
[A_2]
depends: 'B2.txt'
run:
touch A2.txt
[B1: provides='B1.txt']
depends: 'B2.txt'
run:
touch B1.txt
[B2: provides='B2.txt']
depends: 'B3.txt', 'C1.txt'
run:
touch B2.txt
[B3: provides='B3.txt']
run:
touch B3.txt
[C1: provides='C1.txt']
depends: 'C2.txt', 'C3.txt'
run:
touch C1.txt
[C2: provides='C2.txt']
depends: 'C4.txt'
run:
touch C2.txt
[C3: provides='C3.txt']
depends: 'C4.txt'
run:
touch C3.txt
[C4: provides='C4.txt']
run:
touch C4.txt
'''
script2 = '''\
import os
fail = 0
for f in ['A1.txt', 'A2.txt']:
fail += os.path.exists(f)
for f in ['C2.txt', 'B2.txt', 'B1.txt', 'B3.txt', 'C1.txt', 'C3.txt', 'C4.txt']:
fail += not os.path.exists(f)
fail
'''
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code=script)
wait_for_idle(kc)
execute(kc=kc, code=script2)
res = get_result(iopub)
self.assertEqual(res, 0)
