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(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(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(shell, iopub, cell, timeout=60): shell.execute(cell.input) # wait for finish 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.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(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(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_cell(shell, iopub, cell): # print cell.input shell.execute(cell.input) # wait for finish, maximum 20s shell.get_msg(timeout=30) outs = [] while True: try: msg = iopub.get_msg(timeout=0.2) except queue.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"): 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: print("unhandled iopub msg:", msg_type) outs.append(out) 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 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 _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. """ #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(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 runtest(self): """ Run all the cell tests in one kernel without restarting. It is very common for ipython notebooks to run through assuming a single kernel. """ # Execute the code from the current cell and get the msg_id # of the shell process. msg_id = self.parent.kernel.execute_cell_input( self.cell.input, allow_stdin=False) # Time for the reply of the cell execution timeout = 2000 # This list stores the output information for the entire cell outs = [] # Wait for the execution reply (we can see this in the msg_type) # This execution produces a dictionary where a status string can be # obtained: 'ok' OR 'error' OR 'abort' # We can also get how many cells have been executed # until here, with the 'execution_count' entry #self.parent.kernel.kc.get_shell_msg(timeout=timeout) while True: """ The messages from the cell contain information such as input code, outputs generated and other messages. We iterate through each message until we reach the end of the cell. """ try: # Get one message at a time, per code block inside the cell msg = self.parent.get_kernel_message(timeout=1.) except Empty: # This is not working: ! The code will not be checked # if the time is out (when the cell stops to be executed?) # raise NbCellError("Timeout of %d seconds exceeded" # " executing cell: %s" (timeout, # self.cell.input)) # Just break the loop when the output is empty break """ Now that we have the output from a piece of code inside the cell, we want to compare the outputs of the messages to a reference output (the ones that are present before the notebook was executed) """ # Firstly, get the msg type from the cell to know if # the output comes from a code # It seems that the type 'stream' is irrelevant msg_type = msg['msg_type'] # REF: # execute_input: To let all frontends know what code is # being executed at any given time, these messages contain a # re-broadcast of the code portion of an execute_request, # along with the execution_count. if msg_type in ('status', 'execute_input'): continue # If there is no more output, continue with the executions # (it will break if it is empty, with the previous statements) # # REF: # This message type is used to clear the output that is # visible on the frontend # elif msg_type == 'clear_output': # outs = [] # continue # I added the msg_type 'idle' condition (when the cell stops) # so we get a complete cell output # REF: # When the kernel starts to execute code, it will enter the 'busy' # state and when it finishes, it will enter the 'idle' state. # The kernel will publish state 'starting' exactly # once at process startup. elif (msg_type == 'clear_output' and msg_type['execution_state'] == 'idle'): outs = [] continue # WE COULD ADD HERE a condition for the 'error' message type # Making the test to fail """ Now we get the reply from the piece of code executed and analyse the outputs """ reply = msg['content'] out = NotebookNode(output_type=msg_type) # Now check what type of output it is if msg_type == 'stream': out.stream = reply['name'] out.text = reply['text'] elif msg_type in ('display_data', 'execute_result'): # REF: # data and metadata are identical to a display_data message. # the object being displayed is that passed to the display # hook, i.e. the *result* of the execution. out['metadata'] = reply['metadata'] for mime, data in reply['data'].iteritems(): attr = mime.split('/')[-1].lower() attr = attr.replace('+xml', '').replace('plain', 'text') setattr(out, attr, data) if msg_type == 'execute_result': out.prompt_number = reply['execution_count'] else: print("unhandled iopub msg:", msg_type) outs.append(out) """ This message is the last message of the cell, which contains no output. It only indicates whether the entire cell ran successfully or if there was an error. """ reply = msg['content'] failed = False # THIS COMPARISON IS ONLY WHEN THE OUTPUT DICTIONARIES # ARE DIFFERENT, WHICH IS A DIFFERENT ERROR, not # from the output in the notebook # # SINCE WE SANITIZE AND COMPARE, IF THERE ARE DIFFERENT # NUMBER OF LINES, this error will be reported # # Compare if the outputs have the same number of lines # and throw an error if it fails # if len(outs) != len(self.cell.outputs): # self.diff_number_outputs(outs, self.cell.outputs) # failed = True # If the outputs are the same, compare them line by line # else: # for out, ref in zip(outs, self.cell.outputs): if not self.compare_outputs(outs, self.cell.outputs): failed = True # if reply['status'] == 'error': # Traceback is only when an error is raised (?) # We usually get an exception because traceback is not defined if failed: # Use this to make the test fail """ The pytest exception will be raised if there are any errors in the notebook cells. Now we check that the outputs produced from running each cell matches the outputs in the existing notebook. This code is taken from [REF]. """ raise NbCellError(self.cell_num, # Still needs correction. We could # add a description "Error with cell", self.cell.input, # Here we must put the traceback output: '\n'.join(self.comparisons))
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))
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 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)
def runtest(self): """ Run all the cell tests in one kernel without restarting. It is very common for ipython notebooks to run through assuming a single kernel. """ # Execute the code from the current cell and get the msg_id # of the shell process. msg_id = self.parent.kernel.execute_cell_input(self.cell.input, allow_stdin=False) # Time for the reply of the cell execution timeout = 2000 # This list stores the output information for the entire cell outs = [] # Wait for the execution reply (we can see this in the msg_type) # This execution produces a dictionary where a status string can be # obtained: 'ok' OR 'error' OR 'abort' # We can also get how many cells have been executed # until here, with the 'execution_count' entry #self.parent.kernel.kc.get_shell_msg(timeout=timeout) while True: """ The messages from the cell contain information such as input code, outputs generated and other messages. We iterate through each message until we reach the end of the cell. """ try: # Get one message at a time, per code block inside the cell msg = self.parent.get_kernel_message(timeout=1.) except Empty: # This is not working: ! The code will not be checked # if the time is out (when the cell stops to be executed?) # raise NbCellError("Timeout of %d seconds exceeded" # " executing cell: %s" (timeout, # self.cell.input)) # Just break the loop when the output is empty break """ Now that we have the output from a piece of code inside the cell, we want to compare the outputs of the messages to a reference output (the ones that are present before the notebook was executed) """ # Firstly, get the msg type from the cell to know if # the output comes from a code # It seems that the type 'stream' is irrelevant msg_type = msg['msg_type'] # REF: # execute_input: To let all frontends know what code is # being executed at any given time, these messages contain a # re-broadcast of the code portion of an execute_request, # along with the execution_count. if msg_type in ('status', 'execute_input'): continue # If there is no more output, continue with the executions # (it will break if it is empty, with the previous statements) # # REF: # This message type is used to clear the output that is # visible on the frontend # elif msg_type == 'clear_output': # outs = [] # continue # I added the msg_type 'idle' condition (when the cell stops) # so we get a complete cell output # REF: # When the kernel starts to execute code, it will enter the 'busy' # state and when it finishes, it will enter the 'idle' state. # The kernel will publish state 'starting' exactly # once at process startup. elif (msg_type == 'clear_output' and msg_type['execution_state'] == 'idle'): outs = [] continue # WE COULD ADD HERE a condition for the 'error' message type # Making the test to fail """ Now we get the reply from the piece of code executed and analyse the outputs """ reply = msg['content'] out = NotebookNode(output_type=msg_type) # Now check what type of output it is if msg_type == 'stream': out.stream = reply['name'] out.text = reply['text'] elif msg_type in ('display_data', 'execute_result'): # REF: # data and metadata are identical to a display_data message. # the object being displayed is that passed to the display # hook, i.e. the *result* of the execution. out['metadata'] = reply['metadata'] for mime, data in reply['data'].iteritems(): attr = mime.split('/')[-1].lower() attr = attr.replace('+xml', '').replace('plain', 'text') setattr(out, attr, data) if msg_type == 'execute_result': out.prompt_number = reply['execution_count'] else: print("unhandled iopub msg:", msg_type) outs.append(out) """ This message is the last message of the cell, which contains no output. It only indicates whether the entire cell ran successfully or if there was an error. """ reply = msg['content'] failed = False # THIS COMPARISON IS ONLY WHEN THE OUTPUT DICTIONARIES # ARE DIFFERENT, WHICH IS A DIFFERENT ERROR, not # from the output in the notebook # # SINCE WE SANITIZE AND COMPARE, IF THERE ARE DIFFERENT # NUMBER OF LINES, this error will be reported # # Compare if the outputs have the same number of lines # and throw an error if it fails # if len(outs) != len(self.cell.outputs): # self.diff_number_outputs(outs, self.cell.outputs) # failed = True # If the outputs are the same, compare them line by line # else: # for out, ref in zip(outs, self.cell.outputs): if not self.compare_outputs(outs, self.cell.outputs): failed = True # if reply['status'] == 'error': # Traceback is only when an error is raised (?) # We usually get an exception because traceback is not defined if failed: # Use this to make the test fail """ The pytest exception will be raised if there are any errors in the notebook cells. Now we check that the outputs produced from running each cell matches the outputs in the existing notebook. This code is taken from [REF]. """ raise NbCellError( self.cell_num, # Still needs correction. We could # add a description "Error with cell", self.cell.input, # Here we must put the traceback output: '\n'.join(self.comparisons))
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 def execute_notebook(nb): km = BlockingKernelManager() km.start_kernel(extra_arguments=['--pylab=inline'], stderr=open(os.devnull, 'w')) km.start_channels()
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, 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: %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()