def _showtraceback(self, etype, evalue, stb): # try to preserve ordering of tracebacks and print statements sys.stdout.flush() sys.stderr.flush() exc_content = { u'traceback': stb, u'ename': unicode_type(etype.__name__), u'evalue': py3compat.safe_unicode(evalue), } dh = self.displayhook # Send exception info over pub socket for other clients than the caller # to pick up topic = None if dh.topic: topic = dh.topic.replace(b'execute_result', b'error') exc_msg = dh.session.send(dh.pub_socket, u'error', json_clean(exc_content), dh.parent_header, ident=topic) # FIXME - Once we rely on Python 3, the traceback is stored on the # exception object, so we shouldn't need to store it here. self._last_traceback = stb
def _showtraceback(self, etype, evalue, stb): # try to preserve ordering of tracebacks and print statements sys.stdout.flush() sys.stderr.flush() exc_content = { u'traceback' : stb, u'ename' : unicode_type(etype.__name__), u'evalue' : py3compat.safe_unicode(evalue), } dh = self.displayhook # Send exception info over pub socket for other clients than the caller # to pick up topic = None if dh.topic: topic = dh.topic.replace(b'execute_result', b'error') exc_msg = dh.session.send(dh.pub_socket, u'error', json_clean(exc_content), dh.parent_header, ident=topic) # FIXME - Hack: store exception info in shell object. Right now, the # caller is reading this info after the fact, we need to fix this logic # to remove this hack. Even uglier, we need to store the error status # here, because in the main loop, the logic that sets it is being # skipped because runlines swallows the exceptions. exc_content[u'status'] = u'error' self._reply_content = exc_content # /FIXME return exc_content
def _repr_html_(self): """ Return HTML representation of VDOM object. HTML escaping is performed wherever necessary. """ # Use StringIO to avoid a large number of memory allocations with string concat with io.StringIO() as out: out.write('<{tag}'.format(tag=escape(self.tag_name))) if self.style: # Important values are in double quotes - cgi.escape only escapes double quotes, not single quotes! out.write(' style="{css}"'.format( css=escape(self._to_inline_css(self.style)))) for k, v in self.attributes.items(): # Important values are in double quotes - cgi.escape only escapes double quotes, not single quotes! if isinstance(v, string_types): out.write(' {key}="{value}"'.format(key=escape(k), value=escape(v))) if isinstance(v, bool) and v: out.write(' {key}'.format(key=escape(k))) out.write('>') for c in self.children: if isinstance(c, string_types): out.write(escape(safe_unicode(c))) else: out.write(c._repr_html_()) out.write('</{tag}>'.format(tag=escape(self.tag_name))) return out.getvalue()
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False): shell = self.shell # we'll need this a lot here self._forward_input(allow_stdin) reply_content = {} try: res = shell.run_cell(code, store_history=store_history, silent=silent) finally: self._restore_input() if res.error_before_exec is not None: err = res.error_before_exec else: err = res.error_in_exec if res.success: reply_content[u'status'] = u'ok' else: reply_content[u'status'] = u'error' reply_content.update({ u'traceback': shell._last_traceback or [], u'ename': unicode_type(type(err).__name__), u'evalue': safe_unicode(err), }) # FIXME: deprecated piece for ipyparallel (remove in 5.0): e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='execute') reply_content['engine_info'] = e_info # Return the execution counter so clients can display prompts reply_content['execution_count'] = shell.execution_count - 1 if 'traceback' in reply_content: self.log.info("Exception in execute request:\n%s", '\n'.join(reply_content['traceback'])) # At this point, we can tell whether the main code execution succeeded # or not. If it did, we proceed to evaluate user_expressions if reply_content['status'] == 'ok': reply_content[u'user_expressions'] = \ shell.user_expressions(user_expressions or {}) else: # If there was an error, don't even try to compute expressions reply_content[u'user_expressions'] = {} # Payloads should be retrieved regardless of outcome, so we can both # recover partial output (that could have been generated early in a # block, before an error) and always clear the payload system. reply_content[u'payload'] = shell.payload_manager.read_payload() # Be aggressive about clearing the payload because we don't want # it to sit in memory until the next execute_request comes in. shell.payload_manager.clear_payload() return reply_content
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False): shell = self.shell # we'll need this a lot here self._forward_input(allow_stdin) reply_content = {} try: res = self.engine.run_cell(code, store_history=store_history, silent=silent) finally: self._restore_input() if res.error_before_exec is not None: err = res.error_before_exec else: err = res.error_in_exec if res.success: reply_content[u'status'] = u'ok' else: reply_content[u'status'] = u'error' reply_content.update({ u'traceback': shell._last_traceback or [], u'ename': unicode_type(type(err).__name__), u'evalue': safe_unicode(err), }) # FIXME: deprecated piece for ipyparallel (remove in 5.0): e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='execute') reply_content['engine_info'] = e_info # Return the execution counter so clients can display prompts reply_content['execution_count'] = shell.execution_count - 1 if 'traceback' in reply_content: self.log.info("Exception in execute request:\n%s", '\n'.join(reply_content['traceback'])) # At this point, we can tell whether the main code execution succeeded # or not. If it did, we proceed to evaluate user_expressions if reply_content['status'] == 'ok': reply_content[u'user_expressions'] = \ shell.user_expressions(user_expressions or {}) else: # If there was an error, don't even try to compute expressions reply_content[u'user_expressions'] = {} # Payloads should be retrieved regardless of outcome, so we can both # recover partial output (that could have been generated early in a # block, before an error) and always clear the payload system. reply_content[u'payload'] = shell.payload_manager.read_payload() # Be aggressive about clearing the payload because we don't want # it to sit in memory until the next execute_request comes in. shell.payload_manager.clear_payload() return reply_content
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.connect((self.pyserver_host, self.pyserver_port)) except socket.error: exc_type, exc_value, exc_traceback = sys.exc_info() content = { 'name': 'stderr', 'text': 'ERROR: Cannot connect to BALL PyServer. Please make sure PyServer is running!' } self.send_response(self.iopub_socket, 'stream', content) content.update({ 'status': 'error', 'ename': type(exc_type).__name__, 'evalue': safe_unicode(traceback.format_exception_only(exc_type, exc_value)), 'traceback': traceback.format_tb(exc_traceback), 'execution_count': self.execution_count - 1, 'payload': [], 'user_expression': {} }) return content code = json.dumps({ 'msg_type': 'execute_request', 'content': code }) s.sendall(code.encode('utf-8')) data = self.recvall(s) s.close() content = {} if data is None: content.update({ 'name': 'stderr', 'text': 'WARNING: Response from BALL PyServer is incomplete!\n' 'Your code was evaluated by the BALL PyServer but the output cannot be shown!' }) else: content.update({ 'name': 'stdout' if data['msg_type'] == 'execute_result' else 'stderr', 'text': data['content'] }) self.send_response(self.iopub_socket, 'stream', content) content.update({ 'status': 'ok', 'execution_count': self.execution_count, 'payload': [], 'user_expressions': {}, }) return content
def do_apply(self, content, bufs, msg_id, reply_metadata): from .serialize import serialize_object, unpack_apply_message shell = self.shell try: working = shell.user_ns prefix = "_"+str(msg_id).replace("-","")+"_" f,args,kwargs = unpack_apply_message(bufs, working, copy=False) fname = getattr(f, '__name__', 'f') fname = prefix+"f" argname = prefix+"args" kwargname = prefix+"kwargs" resultname = prefix+"result" ns = { fname : f, argname : args, kwargname : kwargs , resultname : None } # print ns working.update(ns) code = "%s = %s(*%s,**%s)" % (resultname, fname, argname, kwargname) try: exec(code, shell.user_global_ns, shell.user_ns) result = working.get(resultname) finally: for key in ns: working.pop(key) result_buf = serialize_object(result, buffer_threshold=self.session.buffer_threshold, item_threshold=self.session.item_threshold, ) except BaseException as e: # invoke IPython traceback formatting shell.showtraceback() reply_content = { u'traceback': shell._last_traceback or [], u'ename': unicode_type(type(e).__name__), u'evalue': safe_unicode(e), } # FIXME: deprecated piece for ipyparallel (remove in 5.0): e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='apply') reply_content['engine_info'] = e_info self.send_response(self.iopub_socket, u'error', reply_content, ident=self._topic('error')) self.log.info("Exception in apply request:\n%s", '\n'.join(reply_content['traceback'])) result_buf = [] reply_content['status'] = 'error' else: reply_content = {'status' : 'ok'} return reply_content, result_buf
def do_apply(self, content, bufs, msg_id, reply_metadata): from .serialize import serialize_object, unpack_apply_message shell = self.shell try: working = shell.user_ns prefix = "_"+str(msg_id).replace("-","")+"_" f,args,kwargs = unpack_apply_message(bufs, working, copy=False) fname = getattr(f, '__name__', 'f') fname = prefix+"f" argname = prefix+"args" kwargname = prefix+"kwargs" resultname = prefix+"result" ns = { fname : f, argname : args, kwargname : kwargs , resultname : None } # print ns working.update(ns) code = "%s = %s(*%s,**%s)" % (resultname, fname, argname, kwargname) try: exec(code, shell.user_global_ns, shell.user_ns) result = working.get(resultname) finally: for key in ns: working.pop(key) result_buf = serialize_object(result, buffer_threshold=self.session.buffer_threshold, item_threshold=self.session.item_threshold, ) except BaseException as e: # invoke IPython traceback formatting shell.showtraceback() reply_content = { u'traceback': shell._last_traceback or [], u'ename': unicode_type(type(e).__name__), u'evalue': safe_unicode(e), } # FIXME: deprecated piece for ipyparallel (remove in 5.0): e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='apply') reply_content['engine_info'] = e_info self.send_response(self.iopub_socket, u'error', reply_content, ident=self._topic('error')) self.log.info("Exception in apply request:\n%s", '\n'.join(reply_content['traceback'])) result_buf = [] reply_content['status'] = 'error' else: reply_content = {'status' : 'ok'} return reply_content, result_buf
def do_workflow(self, notebook, ident, parent): shell = self.shell reply_content = {} if (_asyncio_runner and shell.loop_runner is _asyncio_runner and asyncio.get_event_loop().is_running()): coro = shell.run_workflow(notebook) coro_future = asyncio.ensure_future(coro) with self._cancel_on_sigint(coro_future): try: res = yield coro_future finally: shell.events.trigger('post_execute') else: coro = shell.run_workflow(notebook) if shell.trio_runner: runner = shell.trio_runner else: runner = shell.loop_runner res = runner(coro) # Send outputs to cell streams for cell_name, content in res.result.items(): self.session.send(self.iopub_thread, 'stream', content={ 'name': cell_name, 'text': content }, parent=extract_header(parent), ident=ident) # Send reply message if res.error_before_exec is not None: err = res.error_before_exec else: err = res.error_in_exec if res.success: reply_content['status'] = 'ok' else: reply_content['status'] = 'error' # noinspection PyProtectedMember reply_content.update({ 'traceback': shell._last_traceback or [], 'ename': str(type(err).__name__), 'evalue': safe_unicode(err), }) reply_content['execution_count'] = shell.execution_count - 1 reply_content['payload'] = shell.payload_manager.read_payload() shell.payload_manager.clear_payload() return reply_content
def _showtraceback(self, etype, evalue, stb): # This override is largely the same as the base implementation with special # handling to provide error_details in the response if a ColabErrorDetails # item was passed along. sys.stdout.flush() sys.stderr.flush() error_details = None if isinstance(stb, _shell_customizations.ColabTraceback): colab_tb = stb error_details = colab_tb.error_details stb = colab_tb.stb exc_content = { 'traceback': stb, 'ename': py3compat.unicode_type(etype.__name__), 'evalue': py3compat.safe_unicode(evalue), } if error_details: exc_content['error_details'] = error_details self._send_error(exc_content) self._last_traceback = stb
def _showtraceback(self, etype, evalue, stb): # try to preserve ordering of tracebacks and print statements sys.stdout.flush() sys.stderr.flush() exc_content = { u'traceback' : stb, u'ename' : unicode_type(etype.__name__), u'evalue' : py3compat.safe_unicode(evalue), } dh = self.displayhook # Send exception info over pub socket for other clients than the caller # to pick up topic = None if dh.topic: topic = dh.topic.replace(b'execute_result', b'error') exc_msg = dh.session.send(dh.pub_socket, u'error', json_clean(exc_content), dh.parent_header, ident=topic) # FIXME - Once we rely on Python 3, the traceback is stored on the # exception object, so we shouldn't need to store it here. self._last_traceback = stb
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False): shell = self.shell # we'll need this a lot here self._forward_input(allow_stdin) reply_content = {} if hasattr(shell, 'run_cell_async') and hasattr( shell, 'should_run_async'): run_cell = shell.run_cell_async should_run_async = shell.should_run_async else: should_run_async = lambda cell: False # older IPython, # use blocking run_cell and wrap it in coroutine @gen.coroutine def run_cell(*args, **kwargs): return shell.run_cell(*args, **kwargs) try: # default case: runner is asyncio and asyncio is already running # TODO: this should check every case for "are we inside the runner", # not just asyncio if (_asyncio_runner and should_run_async(code) and shell.loop_runner is _asyncio_runner and asyncio.get_event_loop().is_running()): coro = run_cell(code, store_history=store_history, silent=silent) coro_future = asyncio.ensure_future(coro) with self._cancel_on_sigint(coro_future): res = None try: res = yield coro_future finally: shell.events.trigger('post_execute') if not silent: shell.events.trigger('post_run_cell', res) else: # runner isn't already running, # make synchronous call, # letting shell dispatch to loop runners res = shell.run_cell(code, store_history=store_history, silent=silent) finally: self._restore_input() if res.error_before_exec is not None: err = res.error_before_exec else: err = res.error_in_exec if res.success: reply_content['status'] = 'ok' else: reply_content['status'] = 'error' reply_content.update({ 'traceback': shell._last_traceback or [], 'ename': str(type(err).__name__), 'evalue': safe_unicode(err), }) # FIXME: deprecated piece for ipyparallel (remove in 5.0): e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='execute') reply_content['engine_info'] = e_info # Return the execution counter so clients can display prompts reply_content['execution_count'] = shell.execution_count - 1 if 'traceback' in reply_content: self.log.info("Exception in execute request:\n%s", '\n'.join(reply_content['traceback'])) # At this point, we can tell whether the main code execution succeeded # or not. If it did, we proceed to evaluate user_expressions if reply_content['status'] == 'ok': reply_content['user_expressions'] = \ shell.user_expressions(user_expressions or {}) else: # If there was an error, don't even try to compute expressions reply_content['user_expressions'] = {} # Payloads should be retrieved regardless of outcome, so we can both # recover partial output (that could have been generated early in a # block, before an error) and always clear the payload system. reply_content['payload'] = shell.payload_manager.read_payload() # Be aggressive about clearing the payload because we don't want # it to sit in memory until the next execute_request comes in. shell.payload_manager.clear_payload() return reply_content
def do_apply(self, content, bufs, msg_id, reply_metadata): shell = self.shell try: working = shell.user_ns prefix = "_" + str(msg_id).replace("-", "") + "_" f, args, kwargs = unpack_apply_message(bufs, working, copy=False) fname = getattr(f, '__name__', 'f') fname = prefix + "f" argname = prefix + "args" kwargname = prefix + "kwargs" resultname = prefix + "result" ns = {fname: f, argname: args, kwargname: kwargs, resultname: None} # print ns working.update(ns) code = "%s = %s(*%s,**%s)" % (resultname, fname, argname, kwargname) try: exec(code, shell.user_global_ns, shell.user_ns) result = working.get(resultname) finally: for key in ns: working.pop(key) result_buf = serialize_object( result, buffer_threshold=self.session.buffer_threshold, item_threshold=self.session.item_threshold, ) except BaseException as e: # invoke IPython traceback formatting shell.showtraceback() reply_content = { 'traceback': [], 'ename': unicode_type(type(e).__name__), 'evalue': safe_unicode(e), } # get formatted traceback, which ipykernel recorded if hasattr(shell, '_last_traceback'): # ipykernel 4.4 reply_content['traceback'] = shell._last_traceback or [] elif hasattr(shell, '_reply_content'): # ipykernel <= 4.3 if shell._reply_content and 'traceback' in shell._reply_content: reply_content['traceback'] = shell._reply_content[ 'traceback'] else: self.log.warning("Didn't find a traceback where I expected to") shell._last_traceback = None e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='apply') reply_content['engine_info'] = e_info self.send_response(self.iopub_socket, u'error', reply_content, ident=self._topic('error')) self.log.info("Exception in apply request:\n%s", '\n'.join(reply_content['traceback'])) result_buf = [] reply_content['status'] = 'error' else: reply_content = {'status': 'ok'} return reply_content, result_buf
def do_execute( self, code: str, silent: bool, store_history: bool = True, user_expressions: Optional[Dict[str, str]] = None, allow_stdin: bool = False, ) -> Generator[Any, Any, Dict[str, Any]]: """ Copied from IPythonKernel.do_execute(), stripped from comments. Only thing that was modified is running non-async code that uses `loop.run_in_executor()` instead to avoid blocking the bot. While Dev cog's eval doesn't do this, with IPython there are reasons, why it's good to do it like this (e.g. using the shell magic cell). """ shell = self.shell self._forward_input(allow_stdin) reply_content: Dict[str, Any] = {} if hasattr(shell, "run_cell_async") and hasattr( shell, "should_run_async"): run_cell = shell.run_cell_async should_run_async = shell.should_run_async else: def should_run_async(*args: Any, **kwargs: Any) -> Literal[False]: return False # mypy has its issues with this @gen.coroutine def run_cell(*args: Any, **kwargs: Any) -> ExecutionResult: return shell.run_cell(*args, **kwargs) try: if (_asyncio_runner and should_run_async(code) and shell.loop_runner is _asyncio_runner and asyncio.get_event_loop().is_running()): coro = run_cell(code, store_history=store_history, silent=silent) coro_future = asyncio.ensure_future(coro) with self._cancel_on_sigint(coro_future): res = None try: res = yield coro_future finally: shell.events.trigger("post_execute") if not silent: shell.events.trigger("post_run_cell", res) else: loop = asyncio.get_event_loop() # run non-async code in executor unlike the super-method res = yield loop.run_in_executor( None, functools.partial(shell.run_cell, code, store_history=store_history, silent=silent), ) finally: self._restore_input() if res.error_before_exec is not None: err = res.error_before_exec else: err = res.error_in_exec if res.success: reply_content["status"] = "ok" else: reply_content["status"] = "error" reply_content.update({ "traceback": shell._last_traceback or [], "ename": str(type(err).__name__), "evalue": safe_unicode(err), }) e_info = dict( engine_uuid=self.ident, engine_id=self.int_id, method="execute", ) reply_content["engine_info"] = e_info reply_content["execution_count"] = shell.execution_count - 1 if "traceback" in reply_content: self.log.info( "Exception in execute request:\n%s", "\n".join(reply_content["traceback"]), ) if reply_content["status"] == "ok": reply_content["user_expressions"] = shell.user_expressions( user_expressions or {}) else: reply_content["user_expressions"] = {} reply_content["payload"] = shell.payload_manager.read_payload() shell.payload_manager.clear_payload() return reply_content
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False): shell = self.shell # we'll need this a lot here self._forward_input(allow_stdin) reply_content = {} if hasattr(shell, 'run_cell_async') and hasattr(shell, 'should_run_async'): run_cell = shell.run_cell_async should_run_async = shell.should_run_async else: should_run_async = lambda cell: False # older IPython, # use blocking run_cell and wrap it in coroutine @gen.coroutine def run_cell(*args, **kwargs): return shell.run_cell(*args, **kwargs) try: # default case: runner is asyncio and asyncio is already running # TODO: this should check every case for "are we inside the runner", # not just asyncio if ( _asyncio_runner and should_run_async(code) and shell.loop_runner is _asyncio_runner and asyncio.get_event_loop().is_running() ): coro = run_cell(code, store_history=store_history, silent=silent) coro_future = asyncio.ensure_future(coro) with self._cancel_on_sigint(coro_future): res = yield coro_future else: # runner isn't already running, # make synchronous call, # letting shell dispatch to loop runners res = shell.run_cell(code, store_history=store_history, silent=silent) finally: self._restore_input() if res.error_before_exec is not None: err = res.error_before_exec else: err = res.error_in_exec if res.success: reply_content[u'status'] = u'ok' else: reply_content[u'status'] = u'error' reply_content.update({ u'traceback': shell._last_traceback or [], u'ename': unicode_type(type(err).__name__), u'evalue': safe_unicode(err), }) # FIXME: deprecated piece for ipyparallel (remove in 5.0): e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='execute') reply_content['engine_info'] = e_info # Return the execution counter so clients can display prompts reply_content['execution_count'] = shell.execution_count - 1 if 'traceback' in reply_content: self.log.info("Exception in execute request:\n%s", '\n'.join(reply_content['traceback'])) # At this point, we can tell whether the main code execution succeeded # or not. If it did, we proceed to evaluate user_expressions if reply_content['status'] == 'ok': reply_content[u'user_expressions'] = \ shell.user_expressions(user_expressions or {}) else: # If there was an error, don't even try to compute expressions reply_content[u'user_expressions'] = {} # Payloads should be retrieved regardless of outcome, so we can both # recover partial output (that could have been generated early in a # block, before an error) and always clear the payload system. reply_content[u'payload'] = shell.payload_manager.read_payload() # Be aggressive about clearing the payload because we don't want # it to sit in memory until the next execute_request comes in. shell.payload_manager.clear_payload() return reply_content
def do_apply(self, content, bufs, msg_id, reply_metadata): shell = self.shell try: working = shell.user_ns prefix = "_"+str(msg_id).replace("-","")+"_" f,args,kwargs = unpack_apply_message(bufs, working, copy=False) fname = getattr(f, '__name__', 'f') fname = prefix+"f" argname = prefix+"args" kwargname = prefix+"kwargs" resultname = prefix+"result" ns = { fname : f, argname : args, kwargname : kwargs , resultname : None } # print ns working.update(ns) code = "%s = %s(*%s,**%s)" % (resultname, fname, argname, kwargname) try: exec(code, shell.user_global_ns, shell.user_ns) result = working.get(resultname) finally: for key in ns: working.pop(key) result_buf = serialize_object(result, buffer_threshold=self.session.buffer_threshold, item_threshold=self.session.item_threshold, ) except BaseException as e: # invoke IPython traceback formatting shell.showtraceback() reply_content = { 'traceback': [], 'ename': unicode_type(type(e).__name__), 'evalue': safe_unicode(e), } # get formatted traceback, which ipykernel recorded if hasattr(shell, '_last_traceback'): # ipykernel 4.4 reply_content['traceback'] = shell._last_traceback or [] elif hasattr(shell, '_reply_content'): # ipykernel <= 4.3 if shell._reply_content and 'traceback' in shell._reply_content: reply_content['traceback'] = shell._reply_content['traceback'] else: self.log.warning("Didn't find a traceback where I expected to") shell._last_traceback = None e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='apply') reply_content['engine_info'] = e_info self.send_response(self.iopub_socket, u'error', reply_content, ident=self._topic('error')) self.log.info("Exception in apply request:\n%s", '\n'.join(reply_content['traceback'])) result_buf = [] reply_content['status'] = 'error' else: reply_content = {'status' : 'ok'} return reply_content, result_buf