def testCD(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
msg_id, content = execute(kc=kc, code="%cd ..")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="print(os.getcwd())")
stdout, stderr = assemble_output(iopub)
self.assertTrue(stdout.strip().endswith('jupyter'))
self.assertEqual(stderr, '')
msg_id, content = execute(kc=kc, code="%cd test")
def testWith(self):
'''Test magic with'''
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
msg_id, content = execute(kc=kc, code='var = [1, 2, 3, 4]')
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code='%with R -i var -o m\nm=mean(var)')
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%dict m")
res = get_result(iopub)
self.assertEqual(res['m'], 2.5)
def testSetSigil(self):
'''Test set_options of sigil'''
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
msg_id, content = execute(kc=kc, code='%set_options sigil=None')
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code='a="${}".format(100)')
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%dict a")
res = get_result(iopub)
self.assertEqual(res['a'], "$100")
def testSubKernel(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
msg_id, content = execute(kc=kc, code="%use R")
stdout, stderr = assemble_output(iopub)
self.assertEqual(stderr, '')
msg_id, content = execute(kc=kc, code="a <- 1024")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="a")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 1024')
msg_id, content = execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testHelp(self):
'''Test help messages'''
with sos_kernel() as kc:
# create a data frame
execute(kc=kc,
code='\n'.join(
'%{} -h'.format(magic)
for magic in ('cd', 'debug', 'dict', 'get',
'matplotlib', 'paste', 'preview', 'put',
'render', 'rerun', 'run', 'save',
'sandbox', 'set', 'sessioninfo',
'sosrun', 'sossave', 'shutdown',
'taskinfo', 'tasks', 'toc', 'use',
'with', 'pull', 'push')))
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 testPullPush(self):
'''Test set_options of sigil'''
import random
fname = os.path.expanduser("~/push_pull_{}.txt".format(random.randint(1, 100000)))
with open(fname, 'w') as pp:
pp.write('something')
with sos_kernel() as kc:
# create a data frame
execute(kc=kc, code='%push {} --to docker -c ~/docker.yml'.format(fname))
wait_for_idle(kc)
os.remove(fname)
self.assertFalse(os.path.isfile(fname))
#
execute(kc=kc, code='%pull {} --from docker -c ~/docker.yml'.format(fname))
_, stderr = get_std_output(kc.iopub_channel)
self.assertEqual(stderr, '', 'Expect no error, get {}'.format(stderr))
self.assertTrue(os.path.isfile(fname))
def testMagicDict(self):
'''Test %dict magic'''
with sos_kernel() as kc:
iopub = kc.iopub_channel
msg_id, content = execute(kc=kc, code="a=12345")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%dict a")
self.assertEqual(get_result(iopub)['a'], 12345)
msg_id, content = execute(kc=kc, code="%dict --keys")
self.assertTrue('a' in get_result(iopub))
msg_id, content = execute(kc=kc, code="%dict --reset")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%dict --keys --all")
res = get_result(iopub)
self.assertTrue('a' not in res)
for key in ('run', 'sh', 'tcsh', 'expand_pattern'):
self.assertTrue(key in res)
def testGetPythonDataFromRuby(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
''')
wait_for_idle(kc)
execute(kc=kc, code='''
%use Ruby
%get null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var set_var list_var dict_var mat_var recursive_var comp_var
%dict -r
%put null_var num_var num_arr_var logic_var logic_arr_var char_var char_arr_var set_var list_var dict_var mat_var recursive_var comp_var
%use sos
''')
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 set_var list_var dict_var mat_var recursive_var comp_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['set_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))
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 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 testIsComplete(self):
with sos_kernel() as kc:
# match magics
status = is_complete(kc, "prin")
self.assertEqual(status["status"], "incomplete")
#
status = is_complete(kc, "a=1")
self.assertEqual(status["status"], "incomplete")
#
status = is_complete(kc, "")
self.assertEqual(status["status"], "complete")
#
status = is_complete(kc, "input:\n a=1,")
self.assertEqual(status["status"], "incomplete")
#
status = is_complete(kc, "%dict -r")
self.assertEqual(status["status"], "complete")
wait_for_idle(kc)
def testIsComplete(self):
with sos_kernel() as kc:
# match magics
status = is_complete(kc, 'prin')
self.assertEqual(status['status'], 'incomplete')
#
status = is_complete(kc, 'a=1')
self.assertEqual(status['status'], 'incomplete')
#
status = is_complete(kc, '')
self.assertEqual(status['status'], 'complete')
#
status = is_complete(kc, 'input:\n a=1,')
self.assertEqual(status['status'], 'incomplete')
#
status = is_complete(kc, '%dict -r')
self.assertEqual(status['status'], 'complete')
wait_for_idle(kc)
def testCompleter(self):
with sos_kernel() as kc:
# match magics
self.assertTrue('%get ' in get_completions(kc, '%g')['matches'])
self.assertTrue('%get ' in get_completions(kc, '%')['matches'])
self.assertTrue('%with ' in get_completions(kc, '%w')['matches'])
# path complete
self.assertGreater(len(get_completions(kc, '!ls ')['matches']), 0)
self.assertEqual(
len(get_completions(kc, '!ls SOMETHING')['matches']), 0)
#
wait_for_idle(kc)
# variable complete
execute(kc=kc, code='alpha=5')
wait_for_idle(kc)
execute(kc=kc, code='%use Python3')
wait_for_idle(kc)
self.assertTrue('alpha' in get_completions(kc, 'al')['matches'])
self.assertTrue('all(' in get_completions(kc, 'al')['matches'])
# for no match
self.assertEqual(
len(get_completions(kc, 'alphabetatheta')['matches']), 0)
# get with all variables in
self.assertTrue('alpha' in get_completions(kc, '%get ')['matches'])
self.assertTrue(
'alpha' in get_completions(kc, '%get al')['matches'])
# with use and restart has kernel name
self.assertTrue(
'Python3' in get_completions(kc, '%with ')['matches'])
self.assertTrue(
'Python3' in get_completions(kc, '%use ')['matches'])
self.assertTrue(
'Python3' in get_completions(kc, '%shutdown ')['matches'])
self.assertTrue(
'Python3' in get_completions(kc, '%shutdown ')['matches'])
self.assertTrue(
'Python3' in get_completions(kc, '%use Py')['matches'])
#
self.assertEqual(len(get_completions(kc, '%use SOME')['matches']),
0)
#
wait_for_idle(kc)
execute(kc=kc, code='%use SoS')
wait_for_idle(kc)
def testInspector(self):
with sos_kernel() as kc:
# match magics
self.assertTrue("%get " in get_completions(kc, "%g")["matches"])
self.assertTrue("%get " in get_completions(kc, "%")["matches"])
self.assertTrue("%with " in get_completions(kc, "%w")["matches"])
# path complete
self.assertGreater(len(get_completions(kc, "!ls ")["matches"]), 0)
self.assertEqual(
len(get_completions(kc, "!ls SOMETHING")["matches"]), 0)
#
wait_for_idle(kc)
# variable complete
execute(kc=kc, code="alpha=5")
wait_for_idle(kc)
execute(kc=kc, code="%use Python3")
wait_for_idle(kc)
self.assertTrue("alpha" in get_completions(kc, "al")["matches"])
self.assertTrue("all(" in get_completions(kc, "al")["matches"])
# for no match
self.assertEqual(
len(get_completions(kc, "alphabetatheta")["matches"]), 0)
# get with all variables in
self.assertTrue("alpha" in get_completions(kc, "%get ")["matches"])
self.assertTrue(
"alpha" in get_completions(kc, "%get al")["matches"])
# with use and restart has kernel name
self.assertTrue(
"Python3" in get_completions(kc, "%with ")["matches"])
self.assertTrue(
"Python3" in get_completions(kc, "%use ")["matches"])
self.assertTrue(
"Python3" in get_completions(kc, "%shutdown ")["matches"])
self.assertTrue(
"Python3" in get_completions(kc, "%shutdown ")["matches"])
self.assertTrue(
"Python3" in get_completions(kc, "%use Py")["matches"])
#
self.assertEqual(len(get_completions(kc, "%use SOME")["matches"]),
0)
#
wait_for_idle(kc)
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 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 testAutoSharedVars(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code="sos_null = None")
wait_for_idle(kc)
execute(kc=kc, code="sos_num = 123")
wait_for_idle(kc)
execute(kc=kc, code="%use R")
wait_for_idle(kc)
execute(kc=kc, code="sos_num")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 123')
execute(kc=kc, code="sos_num = sos_num + 10")
wait_for_idle(kc)
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
execute(kc=kc, code="sos_num")
res = get_display_data(iopub)
self.assertEqual(res, '133')
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 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 testGetPythonDataFrameFromR(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
msg_id, content = 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)
msg_id, content = execute(kc=kc, code="%use R")
stdout, stderr = assemble_output(iopub)
self.assertEqual(stderr, '')
msg_id, content = execute(kc=kc, code="%get df")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="dim(df)")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 1000 10')
msg_id, content = execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testIsComplete(self):
with sos_kernel() as kc:
# match magics
status = is_complete(kc, "prin")
self.assertEqual(status["status"], "complete")
#
status = is_complete(kc, "a=1")
self.assertEqual(status["status"], "complete")
#
status = is_complete(kc, "")
self.assertEqual(status["status"], "complete")
# the status seems to be version dependent on ipython
#status = is_complete(kc, "input:\n a=1,")
#self.assertEqual(status["status"], "complete")
#
#status = is_complete(kc, "parameter: a=1,")
#self.assertEqual(status["status"], "complete")
#
status = is_complete(kc, "%dict -r")
self.assertEqual(status["status"], "complete")
wait_for_idle(kc)
def testMagicCapture(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
# preview variable
execute(kc=kc, code='''
%capture --to res
print('kkk')
''')
wait_for_idle(kc)
execute(kc=kc, code='''
res
''')
stdout, _ = get_std_output(iopub)
# FIXME: Not sure why this test does not work
#self.assertTrue('kkk' in stdout, 'Got stdout "{}"'.format(stdout))
execute(kc=kc,
code=r'''
%capture --as csv --to res
print('a,b\nc,d')
''')
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '', f"Get error {stderr}")
#
execute(kc=kc,
code=r'''
%capture --as tsv --to res
print('a\tb\nc\td')
''')
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '', f"Get error {stderr}")
#
execute(kc=kc,
code=r'''
%capture --as json --to res
print('[1,2,3]')
''')
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '', f"Get error {stderr}")
def testGetPythonDataFrameFromR(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
msg_id, content = 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)
msg_id, content = execute(kc=kc, code="%use R")
stdout, stderr = assemble_output(iopub)
self.assertEqual(stderr, '')
msg_id, content = execute(kc=kc, code="%get df")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="dim(df)")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 1000 10')
msg_id, content = execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testMagicGet(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
msg_id, content = execute(kc=kc, code="a = 1025")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="_b_a = 22")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%use R")
stdout, stderr = assemble_output(iopub)
self.assertEqual(stderr, '')
msg_id, content = execute(kc=kc, code="%get a")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="a")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 1025')
#
msg_id, content = execute(kc=kc, code="%get _b_a")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code=".b_a")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 22')
msg_id, content = execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testMagicShutdown(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code='''
%use R
a = 100
cat(a)
''')
stdout, stderr = get_std_output(iopub)
self.assertTrue(stdout.endswith('100'),
'Should have output {}'.format(stdout))
#self.assertEqual(stderr, '')
#now let us restart
execute(kc=kc, code='''
%shutdown --restart R
%use R
cat(a)
''')
stdout, _ = get_std_output(iopub)
# not sure what is going on
self.assertEqual(stdout, '')
execute(kc=kc, code='%use SoS')
wait_for_idle(kc)
def testMagicGet(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
msg_id, content = execute(kc=kc, code="a = 1025")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="_b_a = 22")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%use R")
stdout, stderr = assemble_output(iopub)
self.assertEqual(stderr, '')
msg_id, content = execute(kc=kc, code="%get a")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="a")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 1025')
#
msg_id, content = execute(kc=kc, code="%get _b_a")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code=".b_a")
res = get_display_data(iopub)
self.assertEqual(res, '[1] 22')
msg_id, content = execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testReverseSharedVariable(self):
'''Test shared variables defined in auxiliary steps'''
file_target('a.txt').remove('both')
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)
execute(kc=kc, code="b")
res = get_result(iopub)
self.assertEqual(res, 1)
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 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 testAutoSharedVars(self):
'''Test the sharing of variables automatically'''
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code="""\
sos_null = None
sos_num = 123
""")
wait_for_idle(kc)
execute(kc=kc, code="%use Python3")
wait_for_idle(kc)
execute(kc=kc, code="sos_num")
res = get_display_data(iopub)
self.assertEqual(res, '123')
execute(kc=kc, code="sos_num = sos_num + 10")
wait_for_idle(kc)
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
execute(kc=kc, code="sos_num")
res = get_display_data(iopub)
self.assertEqual(res, '133')
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 testPythonToCppDataframe(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 C++14')
wait_for_idle(kc)
execute(kc=kc, code='%get dataframe')
wait_for_idle(kc)
execute(kc=kc, code='std::cout << dataframe.size();')
stdout, _ = assemble_output(iopub)
self.assertEqual(stdout.strip(), '4000')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testJavaToPythonDataframe(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
execute(kc=kc, code='%use Java')
wait_for_idle(kc)
execute(kc=kc,
code='''
String[] animals = {"bear", "cat", "giraffe"};
double[] cuteness = {90.1, 84.3, 99.7};
Table cuteAnimals = Table.create("Cute Animals").addColumns(
StringColumn.create("Animal types", animals), DoubleColumn.create("rating", cuteness));
''')
wait_for_idle(kc)
execute(kc=kc, code='%put cuteAnimals')
wait_for_idle(kc)
execute(kc=kc, code='%use sos')
wait_for_idle(kc)
execute(kc=kc, code='print(cuteAnimals["rating"][2])')
stdout, _ = assemble_output(iopub)
self.assertEqual(stdout.strip(), '99.7')
def testPutRDataFrameToPython(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
msg_id, content = execute(kc=kc, code='%use R')
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%put mtcars")
stdout, stderr = assemble_output(iopub)
# the message can contain "Loading required package feathre"
#self.assertEqual(stderr, '')
msg_id, content = execute(kc=kc, code="%use sos")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="mtcars.shape")
res = get_result(iopub)
self.assertEqual(res, (32, 11))
msg_id, content = execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testGetPythonNoneFromRuby(self):
# Python -> Ruby
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
execute(kc=kc, code='''
null_var = None
''')
clear_channels(iopub)
execute(kc=kc, code="%use Ruby")
wait_for_idle(kc)
execute(kc=kc, code="%get null_var")
wait_for_idle(kc)
execute(kc=kc, code="null_var == nil")
res = get_display_data(iopub)
self.assertEqual(res, 'true')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testGetPythonMatrixFromRuby(self):
# Python -> Ruby
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a matrix
execute(kc=kc, code='''
import numpy as np
mat_var = np.matrix([[1,2],[3,4]])
''')
clear_channels(iopub)
execute(kc=kc, code="%use Ruby")
wait_for_idle(kc)
execute(kc=kc, code="%get mat_var")
wait_for_idle(kc)
execute(kc=kc, code="mat_var.size()")
res = get_display_data(iopub)
self.assertEqual(res, '4')
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testMagicPut(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
msg_id, content = execute(kc=kc, code="%use R")
stdout, stderr = assemble_output(iopub)
self.assertEqual(stderr, '')
msg_id, content = execute(kc=kc, code="a <- 1024")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%put a")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%put __k_k")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%use sos")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="a")
res = get_result(iopub)
self.assertEqual(res, 1024)
# strange name
msg_id, content = execute(kc=kc, code="%use R")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code=".a.b <- 22")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%put .a.b")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%use sos")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="_a_b")
res = get_result(iopub)
self.assertEqual(res, 22)
def testGetPythonDataFromR(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
msg_id, content = execute(kc=kc, code="null_var = None")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="num_var = 123")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="import numpy\nnum_arr_var = numpy.array([1, 2, 3])")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="logic_var = True")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="logic_arr_var = [True, False, True]")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="char_var = '123'")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="char_arr_var = ['1', '2', '3']")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="list_var = [1, 2, '3']")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="dict_var = dict(a=1, b=2, c='3')")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="set_var = {1, 2, '3'}")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="mat_var = numpy.matrix([[1,2],[3,4]])")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%use R")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%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")
wait_for_idle(kc)
# need to test passed values
# but let us cheat by passing data back
msg_id, content = execute(kc=kc, code="%dict -r")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%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")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="%use sos")
wait_for_idle(kc)
msg_id, content = 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")
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'], '123')
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))
def testMagicConnectInfo(self):
'''Test connect info'''
with sos_kernel() as kc:
# create a data frame
execute(kc=kc, code='%connectinfo')
wait_for_idle(kc)
def testPutRDataToPython(self):
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
msg_id, content = execute(kc=kc, code='%use R')
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="null_var = NULL")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="num_var = 123")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="num_arr_var = c(1, 2, 3)")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="logic_var = TRUE")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="logic_arr_var = c(TRUE, FALSE, TRUE)")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="char_var = '123'")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="char_arr_var = c(1, 2, '3')")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="list_var = list(1, 2, '3')")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="named_list_var = list(a=1, b=2, c='3')")
wait_for_idle(kc)
msg_id, content = execute(kc=kc, code="mat_var = matrix(c(1,2,3,4), nrow=2)")
wait_for_idle(kc)
msg_id, content = 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")
wait_for_idle(kc)
msg_id, content = 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")
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'], '123')
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))
msg_id, content = execute(kc=kc, code="%use sos")
wait_for_idle(kc)
