def run_cell(self, cell):
'''
Run a notebook cell and update the output of that cell in-place.
'''
logging.info('Running cell:\n%s\n', cell.input)
self.shell.execute(cell.input)
reply = self.shell.get_msg()
status = reply['content']['status']
if status == 'error':
logging.info('Cell raised uncaught exception: %s', reply['content']['ename'])
else:
logging.info('Cell returned')
outs = list()
while True:
try:
msg = self.iopub.get_msg(timeout=1)
if msg['msg_type'] == 'status':
if msg['content']['execution_state'] == 'idle':
break
except Empty:
# execution state should return to idle before the queue becomes empty,
# if it doesn't, something bad has happened
raise
content = msg['content']
msg_type = msg['msg_type']
out = NotebookNode(output_type=msg_type)
if 'execution_count' in content:
cell['prompt_number'] = content['execution_count']
out.prompt_number = content['execution_count']
if msg_type in ['status', 'pyin']:
continue
elif msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].iteritems():
try:
attr = self.MIME_MAP[mime]
except KeyError:
raise NotImplementedError('unhandled mime type: %s' % mime)
setattr(out, attr, data)
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
logging.log('\n'.join(content['traceback']))
else:
raise NotImplementedError('unhandled iopub message: %s' % msg_type)
outs.append(out)
cell['outputs'] = outs
if status == 'error':
raise NotebookError()
def run_cell(shell, iopub, cell, output=False):
shell.execute(cell.input)
#shell.get_msg() # timeout=20
outs = []
while True:
try:
msg = iopub.get_msg(timeout=0.1)
except Empty:
continue
msg_type = msg['msg_type']
if msg_type == 'pyin':
continue
elif msg_type == 'clear_output':
outs = []
continue
elif msg_type == 'status':
if msg['content']['execution_state'] == 'idle':
break
else:
outs = []
continue
content = msg['content']
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
if output:
print(out.texti)#, end="")
elif msg_type in ('display_data', 'pyout'):
out['metadata'] = content['metadata']
for mime, data in content['data'].items():
attr = mime.split('/')[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
out.prompt_number = content['execution_count']
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
log.error("Unhandled iopub msg : ", msg_type)
outs.append(out)
return outs
def run_cell(kc, cell):
shell = kc.shell_channel
iopub = kc.iopub_channel
outputs = []
shell.execute(cell.input)
# wait for finish, maximum 20s
try:
shell.get_msg(timeout=10)
except Empty:
return outputs
failures = 0
messages = 0
while True:
try:
reply = iopub.get_msg(timeout=0.2)
messages += 1
except Empty:
break
content = reply['content']
msg_type = reply['msg_type']
if msg_type in ('status', 'pyin'):
continue
elif msg_type == 'clear_output':
outputs = []
continue
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].iteritems():
attr = mime.split('/')[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
out.prompt_number = content['execution_count']
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
print "unhandled iopub msg:", msg_type
outputs.append(out)
return outputs
def run_cell(kc, cell):
shell = kc.shell_channel
iopub = kc.iopub_channel
outputs = []
shell.execute(cell.input)
# wait for finish, maximum 20s
try:
shell.get_msg(timeout=10)
except Empty:
return outputs
failures = 0
messages = 0
while True:
try:
reply = iopub.get_msg(timeout=0.2)
messages += 1
except Empty:
break
content = reply["content"]
msg_type = reply["msg_type"]
if msg_type in ("status", "pyin"):
continue
elif msg_type == "clear_output":
outputs = []
continue
out = NotebookNode(output_type=msg_type)
if msg_type == "stream":
out.stream = content["name"]
out.text = content["data"]
elif msg_type in ("display_data", "pyout"):
for mime, data in content["data"].iteritems():
attr = mime.split("/")[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace("+xml", "").replace("plain", "text")
setattr(out, attr, data)
if msg_type == "pyout":
out.prompt_number = content["execution_count"]
elif msg_type == "pyerr":
out.ename = content["ename"]
out.evalue = content["evalue"]
out.traceback = content["traceback"]
else:
print "unhandled iopub msg:", msg_type
outputs.append(out)
return outputs
def run_cell(shell, iopub, cell):
stime = time.time()
shell.execute(cell.input)
# wait for finish or timeout (in seconds)
shell.get_msg(timeout=120)
outs = []
elapsedtime = time.time() - stime
print ' %.2f sec | cell done.\n%s' % (elapsedtime, str(cell.input)[:50])
while True:
try:
msg = iopub.get_msg(timeout=1.0)
except Empty:
break
msg_type = msg['msg_type']
if msg_type in ('status', 'pyin'):
continue
elif msg_type == 'clear_output':
outs = []
continue
content = msg['content']
# print msg_type, content
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].iteritems():
attr = mime.split('/')[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
#out.prompt_number = content['execution_count']
#TODO: need to find better workaround
pass
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
print "unhandled iopub msg:", msg_type
outs.append(out)
return outs
def run_cell(km, cell):
shell = km.shell_channel
iopub = km.sub_channel
# print "\n\ntesting:"
# print cell.input
msg_id = shell.execute(cell.input)
# wait for finish, no maximum
msg = get_child_msg(km, msg_id)
execution_count = msg['content']['execution_count']
outs = []
while True:
try:
msg = iopub.get_msg(timeout=0.2)
except Empty:
break
msg_type = msg['msg_type']
if msg_type in ('status', 'pyin'):
continue
elif msg_type == 'clear_output':
outs = []
continue
content = msg['content']
# print msg_type, content
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].iteritems():
attr = mime.split('/')[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
out.prompt_number = content['execution_count']
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
print "unhandled iopub msg:", msg_type
outs.append(out)
return outs, execution_count
def run_cell(shell, iopub, cell):
# print cell.input
shell.execute(cell.input)
# wait for finish, maximum 20s
shell.get_msg(timeout=20)
outs = []
while True:
try:
msg = iopub.get_msg(timeout=0.2)
except Empty:
break
msg_type = msg['msg_type']
if msg_type in ('status', 'pyin'):
continue
elif msg_type == 'clear_output':
outs = []
continue
content = msg['content']
# print msg_type, content
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].iteritems():
attr = mime.split('/')[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
#out.prompt_number = content['execution_count']
#TODO: need to find better workaround
pass
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
print "unhandled iopub msg:", msg_type
outs.append(out)
return outs
def run_cell(self, shell, iopub, cell, exec_count):
outs = []
shell.execute(cell.input)
# hard-coded timeout, problem?
shell.get_msg(timeout=20)
cell.prompt_number = exec_count # msg["content"]["execution_count"]
while True:
try:
# whats the assumption on timeout here?
# is it asynchronous?
msg = iopub.get_msg(timeout=.2)
except Empty:
break
msg_type = msg["msg_type"]
if msg_type in ["status", "pyin"]:
continue
elif msg_type == "clear_output":
outs = []
continue
content = msg["content"]
out = NotebookNode(output_type=msg_type)
if msg_type == "stream":
out.stream = content["name"]
out.text = content["data"]
elif msg_type in ["display_data", "pyout"]:
for mime, data in content["data"].iteritems():
attr = mime.split("/")[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == "pyout":
out.prompt_number = exec_count #content["execution_count"]
elif msg_type == "pyerr":
out.ename = content["ename"]
out.evalue = content["evalue"]
out.traceback = content["traceback"]
else:
print "unhandled iopub msg:", msg_type
outs.append(out)
return outs
def run_cell(shell, iopub, cell):
# print cell.input
shell.execute(cell.input)
# wait for finish, maximum 48h
shell.get_msg(timeout=172800)
outs = []
while True:
try:
msg = iopub.get_msg(timeout=0.2)
except Empty:
break
msg_type = msg["msg_type"]
if msg_type in ("status", "pyin"):
continue
elif msg_type == "clear_output":
outs = []
continue
content = msg["content"]
# print msg_type, content
out = NotebookNode(output_type=msg_type)
if msg_type == "stream":
out.stream = content["name"]
out.text = content["data"]
elif msg_type in ("display_data", "pyout"):
for mime, data in content["data"].iteritems():
attr = mime.split("/")[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace("+xml", "").replace("plain", "text")
setattr(out, attr, data)
if msg_type == "pyout":
# out.prompt_number = content['execution_count']
# TODO: need to find better workaround
pass
elif msg_type == "pyerr":
out.ename = content["ename"]
out.evalue = content["evalue"]
out.traceback = content["traceback"]
else:
print "unhandled iopub msg:", msg_type
outs.append(out)
return outs
def run_cell(self, shell, iopub, cell, exec_count):
outs = []
shell.execute(cell.input)
# hard-coded timeout, problem?
shell.get_msg(timeout=90)
cell.prompt_number = exec_count # msg["content"]["execution_count"]
while True:
try:
# whats the assumption on timeout here?
# is it asynchronous?
msg = iopub.get_msg(timeout=.2)
except Empty:
break
msg_type = msg["msg_type"]
if msg_type in ["status" , "pyin"]:
continue
elif msg_type == "clear_output":
outs = []
continue
content = msg["content"]
out = NotebookNode(output_type=msg_type)
if msg_type == "stream":
out.stream = content["name"]
out.text = content["data"]
elif msg_type in ["display_data", "pyout"]:
for mime, data in content["data"].iteritems():
attr = mime.split("/")[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == "pyout":
out.prompt_number = exec_count #content["execution_count"]
elif msg_type == "pyerr":
out.ename = content["ename"]
out.evalue = content["evalue"]
out.traceback = content["traceback"]
else:
print "unhandled iopub msg:", msg_type
outs.append(out)
return outs
def run_cell(km, cell, timeout=20):
shell = km.shell_channel
iopub = km.iopub_channel
shell.execute(cell.input)
shell.get_msg(timeout=timeout)
outs = []
while True:
try:
msg = iopub.get_msg(timeout=0.2)
except Empty:
break
msg_type = msg['msg_type']
if msg_type in ('status', 'pyin'):
continue
elif msg_type == 'clear_output':
outs = []
continue
content = msg['content']
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.txt = content['data']
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].items():
attr = mime.split('/')[-1].lower()
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
out.prompt_number = content['execution_count']
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
print("unhandled iopub msg:", msg_type)
outs.append(out)
cell.outputs = outs
return outs
def run(self, cell, timeout = None):
use_timeout = self.default_timeout
if timeout is not None:
use_timeout = timeout
self.shell.execute(cell.input)
self.shell.get_msg(timeout=use_timeout)
outs = []
while True:
try:
msg = self.iopub.get_msg(timeout=0.5)
except Empty:
break
msg_type = msg['msg_type']
if msg_type in ('status', 'pyin'):
continue
elif msg_type == 'clear_output':
outs = []
continue
content = msg['content']
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
out['metadata'] = content['metadata']
for mime, data in content['data'].iteritems():
attr = mime.split('/')[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
out.prompt_number = content['execution_count']
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
print "unhandled iopub msg:", msg_type
outs.append(out)
return outs
def run(self, cell, timeout=None):
use_timeout = self.default_timeout
if timeout is not None:
use_timeout = timeout
self.shell.execute(cell.input)
self.shell.get_msg(timeout=use_timeout)
outs = []
while True:
try:
msg = self.iopub.get_msg(timeout=0.5)
except Empty:
break
msg_type = msg['msg_type']
if msg_type in ('status', 'pyin'):
continue
elif msg_type == 'clear_output':
outs = []
continue
content = msg['content']
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
out['metadata'] = content['metadata']
for mime, data in content['data'].iteritems():
attr = mime.split('/')[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
out.prompt_number = content['execution_count']
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
print "unhandled iopub msg:", msg_type
outs.append(out)
return outs
def run_cell(km, cell, timeout=20):
shell = km.shell_channel
iopub = km.iopub_channel
shell.execute(cell.input)
shell.get_msg(timeout=timeout)
outs = []
while True:
try:
msg = iopub.get_msg(timeout=0.2)
except Empty:
break
msg_type = msg['msg_type']
if msg_type in ('status', 'pyin'):
continue
elif msg_type == 'clear_output':
outs = []
continue
content = msg['content']
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.txt = content['data']
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].items():
attr = mime.split('/')[-1].lower()
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
out.prompt_number = content['execution_count']
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
print("unhandled iopub msg:", msg_type)
outs.append(out)
cell.outputs = outs
return outs
def run_cell(shell, iopub, cell):
shell.execute(cell.input)
# wait for finish, maximum 20s
shell.get_msg(timeout=20)
outs = []
while True:
try:
msg = iopub.get_msg(timeout=0.2)
except Empty:
break
msg_type = msg['msg_type']
if msg_type in ('status', 'pyin'):
continue
elif msg_type == 'clear_output':
outs = []
continue
content = msg['content']
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
out['metadata'] = content['metadata']
for mime, data in content['data'].items():
attr = mime.split('/')[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
out.prompt_number = content['execution_count']
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
elif msg_type not in ('comm_msg', 'comm_open'):
print("unhandled iopub msg:", msg_type)
outs.append(out)
return outs
def _process_execute_error(self, msg):
""" Process a reply for an execution request that resulted in an error.
"""
content = msg['content']
# If a SystemExit is passed along, this means exit() was called - also
# all the ipython %exit magic syntax of '-k' to be used to keep
# the kernel running
if content['ename']=='SystemExit':
keepkernel = content['evalue']=='-k' or content['evalue']=='True'
self._keep_kernel_on_exit = keepkernel
self.exit_requested.emit(self)
else:
traceback = ''.join(content['traceback'])
logging.error(traceback)
out = NotebookNode(output_type='pyerr')
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
self._current_cell['outputs'].append(out)
self.run_notebook_completed(error=True, traceback=content['traceback'])
def run_cell(self, cell):
'''
Run a notebook cell and update the output of that cell in-place.
'''
logging.info('Running cell:\n%s\n', cell.input)
self.shell.execute(cell.input)
reply = self.shell.get_msg()
status = reply['content']['status']
if status == 'error':
traceback_text = 'Cell raised uncaught exception: \n' + \
'\n'.join(reply['content']['traceback'])
logging.info(traceback_text)
else:
logging.info('Cell returned')
outs = list()
while True:
try:
msg = self.iopub.get_msg(timeout=1)
if msg['msg_type'] == 'status':
if msg['content']['execution_state'] == 'idle':
break
except Empty:
# execution state should return to idle before the queue becomes empty,
# if it doesn't, something bad has happened
raise
content = msg['content']
msg_type = msg['msg_type']
# IPython 3.0.0-dev writes pyerr/pyout in the notebook format but uses
# error/execute_result in the message spec. This does the translation
# needed for tests to pass with IPython 3.0.0-dev
notebook3_format_conversions = {
'error': 'pyerr',
'execute_result': 'pyout'
}
msg_type = notebook3_format_conversions.get(msg_type, msg_type)
out = NotebookNode(output_type=msg_type)
if 'execution_count' in content:
cell['prompt_number'] = content['execution_count']
out.prompt_number = content['execution_count']
if msg_type in ('status', 'pyin', 'execute_input'):
continue
elif msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
#print(out.text, end='')
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].items():
try:
attr = self.MIME_MAP[mime]
except KeyError:
raise NotImplementedError('unhandled mime type: %s' % mime)
setattr(out, attr, data)
#print(data, end='')
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
#logging.error('\n'.join(content['traceback']))
elif msg_type == 'clear_output':
outs = list()
continue
else:
raise NotImplementedError('unhandled iopub message: %s' % msg_type)
outs.append(out)
cell['outputs'] = outs
if status == 'error':
raise NotebookError(traceback_text)
def _process_execute_ok(self, msg):
""" Process a reply for a successful execution request.
"""
payload = msg['content']['payload']
for item in payload:
if not self._process_execute_payload(item):
warning = 'Warning: received unknown payload of type %s'
print(warning % repr(item['source']))
content = msg['content']
msg_type = msg['msg_type']
# IPython 3.0.0-dev writes pyerr/pyout in the notebook format but uses
# error/execute_result in the message spec. This does the translation
# needed for tests to pass with IPython 3.0.0-dev
notebook3_format_conversions = {
'error': 'pyerr',
'execute_result': 'pyout'
}
msg_type = notebook3_format_conversions.get(msg_type, msg_type)
out = NotebookNode(output_type=msg_type)
if 'execution_count' in content:
self._current_cell['prompt_number'] = content['execution_count']
out.prompt_number = content['execution_count']
if msg_type in ('status', 'pyin', 'execute_input'):
return
elif msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
# Is this handled in _handle_execute_result?
for mime, data in content['data'].items():
try:
attr = self.MIME_MAP[mime]
except KeyError:
raise NotImplementedError('unhandled mime type: %s' % mime)
setattr(out, attr, data)
return
elif msg_type == 'pyerr':
# Is this handled in _handle_execute_errror?
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
return
elif msg_type == 'clear_output':
self._current_cell['outputs'] = []
return
elif msg_type == 'execute_reply':
pass
else:
raise NotImplementedError('unhandled iopub message: %s' % msg_type)
self._current_cell['outputs'].append(out)
def run_cell(self, cell):
'''
Run a notebook cell and update the output of that cell in-place.
'''
logging.info('Running cell:\n%s\n', cell.input)
self.shell.execute(cell.input)
reply = self.shell.get_msg()
status = reply['content']['status']
if status == 'error':
logging.info('Cell raised uncaught exception: %s',
reply['content']['ename'])
else:
logging.info('Cell returned')
outs = list()
while True:
try:
msg = self.iopub.get_msg(timeout=1)
if msg['msg_type'] == 'status':
if msg['content']['execution_state'] == 'idle':
break
except Empty:
# execution state should return to idle before the queue becomes empty,
# if it doesn't, something bad has happened
raise
content = msg['content']
msg_type = msg['msg_type']
out = NotebookNode(output_type=msg_type)
if 'execution_count' in content:
cell['prompt_number'] = content['execution_count']
out.prompt_number = content['execution_count']
if msg_type in ['status', 'pyin']:
continue
elif msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
#print(out.text, end='')
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].items():
try:
attr = self.MIME_MAP[mime]
except KeyError:
raise NotImplementedError('unhandled mime type: %s' %
mime)
setattr(out, attr, data)
#print(data, end='')
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
#logging.error('\n'.join(content['traceback']))
else:
raise NotImplementedError('unhandled iopub message: %s' %
msg_type)
outs.append(out)
cell['outputs'] = outs
if status == 'error':
raise NotebookError()
def run_cell(self, cell):
"""
Run a notebook cell and update the output of that cell in-place.
"""
#Changes to ensure proper order of pylab and matplotlib
if 'from pylab import *' in cell.input:
cell.input = cell.input.replace('from pylab import *', '')
cell.input = 'from pylab import *\n' + cell.input
if 'import matplotlib\n' in cell.input:
cell.input = cell.input.replace('import matplotlib\n', '\n')
if self.first_cell:
self.first_cell = False
cell.input = 'import matplotlib\nmatplotlib.use(\'pgf\')\n' + cell.input
cell.input = cell.input.replace('%matplotlib inline', '')
logging.info('Running cell:\n%s\n', cell.input)
self.kc.execute(cell.input)
reply = self.kc.get_shell_msg()
status = reply['content']['status']
traceback_text = ''
if status == 'error':
traceback_text = 'Cell raised uncaught exception: \n' + \
'\n'.join(reply['content']['traceback'])
logging.info(traceback_text)
else:
logging.info('Cell returned')
outs = list()
while True:
try:
msg = self.kc.get_iopub_msg(timeout=1)
if msg['msg_type'] == 'status':
if msg['content']['execution_state'] == 'idle':
break
except Empty:
# execution state should return to idle
# before the queue becomes empty,
# if it doesn't, something bad has happened
raise
content = msg['content']
msg_type = msg['msg_type']
# IPython 3.0.0-dev writes pyerr/pyout in the notebook format
# but uses error/execute_result in the message spec. This does the
# translation needed for tests to pass with IPython 3.0.0-dev
notebook3_format_conversions = {
'error': 'pyerr',
'execute_result': 'pyout'
}
msg_type = notebook3_format_conversions.get(msg_type, msg_type)
out = NotebookNode(output_type=msg_type)
if 'execution_count' in content:
cell['prompt_number'] = content['execution_count']
out.prompt_number = content['execution_count']
if msg_type in ('status', 'pyin', 'execute_input'):
continue
elif msg_type == 'stream':
out.stream = content['name']
# in msgspec 5, this is name, text
# in msgspec 4, this is name, data
if 'text' in content:
out.text = content['text']
else:
out.text = content['data']
#print(out.text, end='')
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].items():
try:
attr = self.MIME_MAP[mime]
except KeyError:
raise NotImplementedError(
'unhandled mime type: %s' % mime
)
setattr(out, attr, data)
#print(data, end='')
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
#logging.error('\n'.join(content['traceback']))
elif msg_type == 'clear_output':
outs = list()
continue
else:
raise NotImplementedError(
'unhandled iopub message: %s' % msg_type
)
outs.append(out)
cell['outputs'] = outs
if status == 'error':
raise NotebookError(traceback_text)
def run_cell(self, cell, autosave):
'''
Run a notebook cell and update the output of that cell in-place.
'''
logging.info('Running cell:\n%s\n', cell.input)
self.shell.execute(cell.input)
cell['outputs'] = []
while True:
try:
msg = self.iopub.get_msg(timeout=1)
if msg['msg_type'] == 'status':
if msg['content']['execution_state'] == 'idle':
break
except Empty:
pass
content = msg['content']
msg_type = msg['msg_type']
out = NotebookNode(output_type=msg_type)
if 'execution_count' in content:
cell['prompt_number'] = content['execution_count'] - 1
out.prompt_number = content['execution_count'] - 1
if msg_type in ['status', 'pyin']:
continue
elif msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
#print(out.text, end='')
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].items():
try:
attr = self.MIME_MAP[mime]
except KeyError:
raise NotImplementedError('unhandled mime type: %s' % mime)
setattr(out, attr, data)
#print(data, end='')
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
#logging.error('\n'.join(content['traceback']))
else:
raise NotImplementedError('unhandled iopub message: %s' % msg_type)
cell['outputs'].append(out)
if autosave:
self.save_notebook(autosave)
reply = self.shell.get_msg()
status = reply['content']['status']
if status == 'error':
logging.info('Cell raised uncaught exception: \n%s', '\n'.join(reply['content']['traceback']))
raise NotebookError()
else:
logging.info('Cell returned')
def run_cell(self, shell, iopub, cell):
msg_id = shell.execute(cell.input)
self.log.debug("Executing cell:\n%s", cell.input)
# wait for finish, with timeout
while True:
try:
msg = shell.get_msg(timeout=self.timeout)
except Empty:
self.log.error("Timeout waiting for execute reply")
raise
if msg['parent_header'].get('msg_id') == msg_id:
break
else:
# not our reply
continue
outs = []
while True:
try:
msg = iopub.get_msg(timeout=self.timeout)
except Empty:
self.log.warn("Timeout waiting for IOPub output")
break
if msg['parent_header'].get('msg_id') != msg_id:
# not an output from our execution
continue
msg_type = msg['msg_type']
self.log.debug("output: %s", msg_type)
content = msg['content']
out = NotebookNode(output_type=self.msg_type_map.get(msg_type, msg_type))
# set the prompt number for the input and the output
if 'execution_count' in content:
cell['prompt_number'] = content['execution_count']
out.prompt_number = content['execution_count']
if msg_type == 'status':
if content['execution_state'] == 'idle':
break
else:
continue
elif msg_type in {'execute_input', 'pyin'}:
continue
elif msg_type == 'clear_output':
outs = []
continue
if msg_type == 'stream':
out.stream = content['name']
out.text = content['text']
elif msg_type in ('display_data', 'execute_result'):
out['metadata'] = content['metadata']
for mime, data in content['data'].items():
# map mime-type keys to nbformat v3 keys
# this will be unnecessary in nbformat v4
key = self.mime_map.get(mime, mime)
out[key] = data
elif msg_type == 'error':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
self.log.error("unhandled iopub msg: " + msg_type)
outs.append(out)
return outs
def run_cell(self, cell): # noqa: C901
"""Run a notebook cell and update the output of that cell in-place."""
self.shell.execute(cell.input)
reply = self.shell.get_msg()
status = reply['content']['status']
if status == 'error':
traceback_text = ("Cell raised uncaught exception: \n"
"\n".join(reply['content']['traceback']))
outs = []
while True:
msg = self.iopub.get_msg(timeout=1)
msg_type = msg['msg_type']
content = msg['content']
if msg_type == 'status' and content['execution_state'] == 'idle':
break
# IPython 3.0.0-dev writes pyerr/pyout in the notebook format
# but uses error/execute_result in the message spec. This does
# the translation needed for tests to pass with IPython 3.0.0-dev
notebook3_format_conversions = {
'error': 'pyerr',
'execute_result': 'pyout',
}
msg_type = notebook3_format_conversions.get(msg_type, msg_type)
out = NotebookNode(output_type=msg_type)
if 'execution_count' in content:
cell['prompt_number'] = content['execution_count']
out.prompt_number = content['execution_count']
if msg_type in ('status', 'pyin', 'execute_input'):
continue
elif msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].items():
try:
attr = self.MIME_MAP[mime]
except KeyError:
raise NotImplementedError(
'unhandled mime type: %s' % mime)
setattr(out, attr, data)
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
elif msg_type == 'clear_output':
outs = []
continue
else:
raise NotImplementedError(
'unhandled iopub message: %s' % msg_type)
outs.append(out)
cell['outputs'] = outs
if status == 'error':
raise Exception(traceback_text)
def run_cell(kc, cell, collect_outputs=True):
"""
Run contents of a cell in a kernel client.
If collect_outputs is True, return the outputs as a list.
"""
shell = kc.shell_channel
iopub = kc.iopub_channel
outputs = []
shell.execute(cell.input)
# wait for finish, maximum 20s
try:
msg = shell.get_msg(timeout=10)
except Empty:
return []
reply = msg['content']
if reply['status'] == 'error':
print("\nFAILURE:")
print(cell.input)
print('-----')
print("raised:")
print('\n'.join(reply['traceback']))
if collect_outputs:
outputs = []
while True:
try:
reply = iopub.get_msg(timeout=0.5)
except Empty:
break
content = reply['content']
msg_type = reply['msg_type']
if msg_type in ('status', 'pyin'):
continue
elif msg_type == 'clear_output':
outputs = []
continue
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].iteritems():
attr = mime.split('/')[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
out.prompt_number = cell.prompt_number
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
print("unhandled iopub msg:", msg_type)
outputs.append(out)
return outputs
return []
def run_cell(self, cell):
'''
Run a notebook cell and update the output of that cell in-place.
'''
logging.info('Running cell:\n%s\n', cell.input)
self.kc.execute(cell.input)
reply = self.kc.get_shell_msg()
status = reply['content']['status']
if status == 'error':
traceback_text = 'Cell raised uncaught exception: \n' + \
'\n'.join(reply['content']['traceback'])
logging.info(traceback_text)
else:
logging.info('Cell returned')
outs = list()
while True:
try:
msg = self.kc.get_iopub_msg(timeout=1)
if msg['msg_type'] == 'status':
if msg['content']['execution_state'] == 'idle':
break
except Empty:
# execution state should return to idle before the queue becomes empty,
# if it doesn't, something bad has happened
raise
content = msg['content']
msg_type = msg['msg_type']
# IPython 3.0.0-dev writes pyerr/pyout in the notebook format but uses
# error/execute_result in the message spec. This does the translation
# needed for tests to pass with IPython 3.0.0-dev
notebook3_format_conversions = {
'error': 'pyerr',
'execute_result': 'pyout'
}
msg_type = notebook3_format_conversions.get(msg_type, msg_type)
out = NotebookNode(output_type=msg_type)
if 'execution_count' in content:
cell['prompt_number'] = content['execution_count']
out.prompt_number = content['execution_count']
if msg_type in ('status', 'pyin', 'execute_input'):
continue
elif msg_type == 'stream':
out.stream = content['name']
# in msgspec 5, this is name, text
# in msgspec 4, this is name, data
if 'text' in content:
out.text = content['text']
else:
out.text = content['data']
#print(out.text, end='')
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].items():
try:
attr = self.MIME_MAP[mime]
except KeyError:
raise NotImplementedError('unhandled mime type: %s' % mime)
setattr(out, attr, data)
#print(data, end='')
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
#logging.error('\n'.join(content['traceback']))
elif msg_type == 'clear_output':
outs = list()
continue
else:
raise NotImplementedError('unhandled iopub message: %s' % msg_type)
outs.append(out)
cell['outputs'] = outs
if status == 'error':
raise NotebookError(traceback_text)
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].iteritems():
attr = mime.split('/')[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
out.prompt_number = content['execution_count']
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
print "unhandled iopub msg:", msg_type
outs.append(out)
return outs
def execute_notebook(nb):
km = BlockingKernelManager()
km.start_kernel(extra_arguments=['--pylab=inline'], stderr=open(os.devnull, 'w'))
km.start_channels()
# run %pylab inline, because some notebooks assume this
# even though they shouldn't
km.shell_channel.execute("pass")
def _process_execute_ok(self, msg):
""" Process a reply for a successful execution request.
"""
payload = msg['content']['payload']
for item in payload:
if not self._process_execute_payload(item):
warning = 'Warning: received unknown payload of type %s'
print(warning % repr(item['source']))
content = msg['content']
msg_type = msg['msg_type']
# IPython 3.0.0-dev writes pyerr/pyout in the notebook format but uses
# error/execute_result in the message spec. This does the translation
# needed for tests to pass with IPython 3.0.0-dev
notebook3_format_conversions = {
'error': 'pyerr',
'execute_result': 'pyout'
}
msg_type = notebook3_format_conversions.get(msg_type, msg_type)
out = NotebookNode(output_type=msg_type)
if 'execution_count' in content:
self._current_cell['prompt_number'] = content['execution_count']
out.prompt_number = content['execution_count']
if msg_type in ('status', 'pyin', 'execute_input'):
return
elif msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
# Is this handled in _handle_execute_result?
for mime, data in content['data'].items():
try:
attr = self.MIME_MAP[mime]
except KeyError:
raise NotImplementedError('unhandled mime type: %s' % mime)
setattr(out, attr, data)
return
elif msg_type == 'pyerr':
# Is this handled in _handle_execute_errror?
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
return
elif msg_type == 'clear_output':
self._current_cell['outputs'] = []
return
elif msg_type == 'execute_reply':
pass
else:
raise NotImplementedError('unhandled iopub message: %s' % msg_type)
self._current_cell['outputs'].append(out)
def run_cell(kc, cell, collect_outputs=True, timeout=10):
"""
Run contents of a cell in a kernel client.
If collect_outputs is True, return the outputs as a list.
"""
shell = kc.shell_channel
iopub = kc.iopub_channel
outputs = []
shell.execute(cell.input)
# wait for finish, maximum 20s
try:
msg = shell.get_msg(timeout=timeout)
except Empty:
return []
reply = msg['content']
if reply['status'] == 'error':
print "\nFAILURE:"
print cell.input
print '-----'
print "raised:"
print '\n'.join(reply['traceback'])
if collect_outputs:
outputs = []
while True:
try:
reply = iopub.get_msg(timeout=3)
except Empty:
break
content = reply['content']
msg_type = reply['msg_type']
if msg_type in ('status', 'pyin'):
continue
elif msg_type == 'clear_output':
outputs = []
continue
out = NotebookNode(output_type=msg_type)
if msg_type == 'stream':
out.stream = content['name']
out.text = content['data']
elif msg_type in ('display_data', 'pyout'):
for mime, data in content['data'].iteritems():
attr = mime.split('/')[-1].lower()
# this gets most right, but fix svg+html, plain
attr = attr.replace('+xml', '').replace('plain', 'text')
setattr(out, attr, data)
if msg_type == 'pyout':
out.prompt_number = cell.prompt_number
elif msg_type == 'pyerr':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
print "unhandled iopub msg:", msg_type
outputs.append(out)
return outputs
return []
def run_cell(self, shell, iopub, cell):
msg_id = shell.execute(cell.input)
self.log.debug("Executing cell:\n%s", cell.input)
# wait for finish, with timeout
while True:
try:
msg = shell.get_msg(timeout=self.timeout)
except Empty:
self.log.error("Timeout waiting for execute reply")
raise
if msg['parent_header'].get('msg_id') == msg_id:
break
else:
# not our reply
continue
outs = []
while True:
try:
msg = iopub.get_msg(timeout=self.timeout)
except Empty:
self.log.warn("Timeout waiting for IOPub output")
break
if msg['parent_header'].get('msg_id') != msg_id:
# not an output from our execution
continue
msg_type = msg['msg_type']
self.log.debug("output: %s", msg_type)
content = msg['content']
out = NotebookNode(
output_type=self.msg_type_map.get(msg_type, msg_type))
# set the prompt number for the input and the output
if 'execution_count' in content:
cell['prompt_number'] = content['execution_count']
out.prompt_number = content['execution_count']
if msg_type == 'status':
if content['execution_state'] == 'idle':
break
else:
continue
elif msg_type in {'execute_input', 'pyin'}:
continue
elif msg_type == 'clear_output':
outs = []
continue
if msg_type == 'stream':
out.stream = content['name']
out.text = content['text']
elif msg_type in ('display_data', 'execute_result'):
out['metadata'] = content['metadata']
for mime, data in content['data'].items():
# map mime-type keys to nbformat v3 keys
# this will be unnecessary in nbformat v4
key = self.mime_map.get(mime, mime)
out[key] = data
elif msg_type == 'error':
out.ename = content['ename']
out.evalue = content['evalue']
out.traceback = content['traceback']
else:
self.log.error("unhandled iopub msg: " + msg_type)
outs.append(out)
return outs
def run_cell(self, cell):
"""
Run a notebook cell and update the output of that cell in-place.
"""
logging.info("Running cell:\n%s\n", cell.input)
self.shell.execute(cell.input)
reply = self.shell.get_msg()
status = reply["content"]["status"]
if status == "error":
logging.info("Cell raised uncaught exception: \n%s", "\n".join(reply["content"]["traceback"]))
else:
logging.info("Cell returned")
outs = list()
while True:
try:
msg = self.iopub.get_msg(timeout=1)
if msg["msg_type"] == "status":
if msg["content"]["execution_state"] == "idle":
break
except Empty:
# execution state should return to idle before the queue becomes empty,
# if it doesn't, something bad has happened
raise
content = msg["content"]
msg_type = msg["msg_type"]
out = NotebookNode(output_type=msg_type)
if "execution_count" in content:
cell["prompt_number"] = content["execution_count"]
out.prompt_number = content["execution_count"]
if msg_type in ["status", "pyin"]:
continue
elif msg_type == "stream":
out.stream = content["name"]
out.text = content["data"]
# print(out.text, end='')
elif msg_type in ("display_data", "pyout"):
for mime, data in content["data"].items():
try:
attr = self.MIME_MAP[mime]
except KeyError:
raise NotImplementedError("unhandled mime type: %s" % mime)
setattr(out, attr, data)
# print(data, end='')
elif msg_type == "pyerr":
out.ename = content["ename"]
out.evalue = content["evalue"]
out.traceback = content["traceback"]
# logging.error('\n'.join(content['traceback']))
else:
raise NotImplementedError("unhandled iopub message: %s" % msg_type)
outs.append(out)
cell["outputs"] = outs
if status == "error":
raise Exception(json.dumps(out))
