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 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 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 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 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 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 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 testMagicWith(self):
if os.path.isfile('py3_file.txt'):
os.remove('py3_file.txt')
with sos_kernel() as kc:
iopub = kc.iopub_channel
# preview variable
execute(kc=kc, code='''
%with Python3 --out a
a = f'{22}'
''')
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '',
f"Get error {stderr} for magic revisions")
execute(kc=kc, code='''
print(a)
''')
stdout, stderr = get_std_output(iopub)
self.assertEqual(stderr, '',
f"Get error {stderr} for magic revisions")
self.assertEqual(stdout, '22\n',
f"Get stdout {stdout} for magic revisions")
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 testSoSVar(self):
if os.path.isfile('py3_file.txt'):
os.remove('py3_file.txt')
with sos_kernel() as kc:
iopub = kc.iopub_channel
# preview variable
execute(kc=kc, code='''\
%use Python3
sosa = f'{24}'
''')
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '',
f"Get error {stderr} for magic revisions")
execute(kc=kc, code='''\
%use sos
print(sosa)
''')
stdout, stderr = get_std_output(iopub)
self.assertEqual(stderr, '',
f"Get error {stderr} for magic revisions")
self.assertEqual(stdout, '24\n',
f"Get stdout {stdout} for magic revisions")
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 testMagicSet(self):
# test preview of remote file
with sos_kernel() as kc:
iopub = kc.iopub_channel
# preview variable
execute(kc=kc, code='''
%set
%set -v2
%set
%set -v1
''')
stdout, stderr = get_std_output(iopub)
self.assertEqual(stderr, '', 'Got {}'.format(stderr))
self.assertTrue('set' in stdout, 'Got {}'.format(stdout))
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 testMagicRemotePreview(self):
# test preview of remote file
with sos_kernel() as kc:
iopub = kc.iopub_channel
# preview variable
execute(kc=kc,
code='''
%preview -n abc.txt -c ~/docker.yml -r docker
%run -r docker -c ~/docker.yml
run:
echo abc > abc.txt
''')
stdout, _ = get_std_output(iopub)
#self.assertEqual(stderr, '', 'Got error {}'.format(stderr))
self.assertTrue('abc' in stdout, 'Got stdout "{}"'.format(stdout))
def testSoSSave(self):
# the test would not work because ipython file does not exist
if os.path.isfile('sossave.html'):
os.remove('sossave.html')
with sos_kernel() as kc:
iopub = kc.iopub_channel
# preview variable
execute(kc=kc,
code='''
%sossave sossave.html --force
[10]
print('kkk')
''')
_, stderr = get_std_output(iopub)
self.assertTrue('.ipynb does not exist' in stderr,
f"Get error {stderr}")
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 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 testNewKernel(self):
'''Test magic use to create new kernels'''
with sos_kernel() as kc:
iopub = kc.iopub_channel
# create a data frame
execute(kc=kc, code='%use R2 -l R')
wait_for_idle(kc)
execute(kc=kc, code='%use R3 -l R -c black')
wait_for_idle(kc)
execute(kc=kc, code='%use R4 -k ir -l R -c green')
wait_for_idle(kc)
execute(kc=kc, code='%use R4 -c cyan')
wait_for_idle(kc)
execute(kc=kc, code='%with R5 -l sos_r.kernel:sos_R -c default')
wait_for_idle(kc)
execute(kc=kc, code='%with R6 -l unknown -c default')
_, stderr = get_std_output(iopub)
self.assertTrue('Failed to switch' in stderr,
'expect error {}'.format(stderr))
execute(kc=kc, code="%use sos")
wait_for_idle(kc)
def testMagicPreview(self):
with sos_kernel() as kc:
# preview variable
iopub = kc.iopub_channel
execute(kc=kc, code='''\
%preview -n a
a=1
''')
_, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
# preview csv file
execute(kc=kc,
code='''\
%preview a.csv
with open('a.csv', 'w') as csv:
csv.write("""\
a,b,c
1,2,3
4,5,6
""")
''')
res = get_display_data(iopub, 'text/html')
self.assertTrue('dataframe_container' in res,
'Expect preview {}'.format(res))
# preview txt file
execute(kc=kc,
code='''
%preview a.txt
with open('a.txt', 'w') as txt:
txt.write("""\
hello
world
""")
''')
stdout, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
self.assertTrue('world' in stdout,
'Expect preview {}'.format(stdout))
# preview zip
execute(kc=kc,
code='''
%preview -n a.zip
import zipfile
with zipfile.ZipFile('a.zip', 'w') as zfile:
zfile.write('a.csv')
''')
stdout, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
self.assertTrue('a.csv' in stdout,
'Expect preview {}'.format(stdout))
# preview tar
execute(kc=kc,
code='''
%preview -n a.tar
import tarfile
with tarfile.open('a.tar', 'w') as tar:
tar.add('a.csv')
''')
stdout, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
self.assertTrue('a.csv' in stdout,
'Expect preview {}'.format(stdout))
# preview tar.gz
execute(kc=kc,
code='''\
%preview -n a.tar.gz
import tarfile
with tarfile.open('a.tar.gz', 'w:gz') as tar:
tar.add('a.csv')
''')
stdout, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
self.assertTrue('a.csv' in stdout,
'Expect preview {}'.format(stdout))
#
# preview regular .gz
execute(kc=kc,
code='''
%preview -n a.gz
import gzip
with gzip.open('a.gz', 'w') as gz:
gz.write(b"""
Hello
world
""")
''')
stdout, stderr = get_std_output(iopub)
self.assertEqual(stderr, '')
self.assertTrue('world' in stdout,
'Expect preview {}'.format(stdout))
# preview md
execute(kc=kc,
code='''
%preview -n a.md
with open('a.md', 'w') as md:
md.write("""\
# title
* item
* item
""")
''')
res = get_display_data(iopub, 'text/html')
self.assertTrue('<li>item</li>' in res,
'Expect preview {}'.format(res))
# preview html
execute(kc=kc,
code='''
%preview -n a.html
with open('a.html', 'w') as dot:
dot.write("""\
<!DOCTYPE html>
<html>
<body>
<h1>My First Heading</h1>
<p>My first paragraph.</p>
</body>
</html>
""")
''')
res = get_display_data(iopub, 'text/html')
# preview dot, needs imagemagick, which is unavailable under windows.
if sys.platform == 'win32':
return
execute(kc=kc,
code='''
%preview -n a.dot
with open('a.dot', 'w') as dot:
dot.write("""\
graph graphname {
a -- b -- c;
b -- d;
}
""")
''')
res = get_display_data(iopub, 'image/png')
self.assertGreater(len(res), 1000, 'Expect a image {}'.format(res))
