def format_traceback(err: _E) -> str: tb_formatter = FormattedTB('Context', 'NoColor') structured_tb: List[str] = tb_formatter.structured_traceback( type(err), err, err.__traceback__ ) tb_string: str = tb_formatter.stb2text(structured_tb) return html.escape(tb_string)
def make_kernel(namespace, kernel_factory, out_stream_factory=None, display_hook_factory=None): """ Creates a kernel, redirects stdout/stderr, and installs a display hook and exception handler. """ # Re-direct stdout/stderr, if necessary. if namespace.no_stdout or namespace.no_stderr: blackhole = file(os.devnull, 'w') if namespace.no_stdout: sys.stdout = sys.__stdout__ = blackhole if namespace.no_stderr: sys.stderr = sys.__stderr__ = blackhole # Install minimal exception handling sys.excepthook = FormattedTB(mode='Verbose', color_scheme='NoColor', ostream=sys.__stdout__) # Create a context, a session, and the kernel sockets. io.raw_print("Starting the kernel at pid:", os.getpid()) context = zmq.Context() # Uncomment this to try closing the context. # atexit.register(context.close) session = Session(username=u'kernel') reply_socket = context.socket(zmq.XREP) xrep_port = bind_port(reply_socket, namespace.ip, namespace.xrep) io.raw_print("XREP Channel on port", xrep_port) pub_socket = context.socket(zmq.PUB) pub_port = bind_port(pub_socket, namespace.ip, namespace.pub) io.raw_print("PUB Channel on port", pub_port) req_socket = context.socket(zmq.XREQ) req_port = bind_port(req_socket, namespace.ip, namespace.req) io.raw_print("REQ Channel on port", req_port) hb = Heartbeat(context, (namespace.ip, namespace.hb)) hb.start() hb_port = hb.port io.raw_print("Heartbeat REP Channel on port", hb_port) # Helper to make it easier to connect to an existing kernel, until we have # single-port connection negotiation fully implemented. io.raw_print("To connect another client to this kernel, use:") io.raw_print("-e --xreq {0} --sub {1} --rep {2} --hb {3}".format( xrep_port, pub_port, req_port, hb_port)) # Redirect input streams and set a display hook. if out_stream_factory: sys.stdout = out_stream_factory(session, pub_socket, u'stdout') sys.stderr = out_stream_factory(session, pub_socket, u'stderr') if display_hook_factory: sys.displayhook = display_hook_factory(session, pub_socket) # Create the kernel. kernel = kernel_factory(session=session, reply_socket=reply_socket, pub_socket=pub_socket, req_socket=req_socket) kernel.record_ports(xrep_port=xrep_port, pub_port=pub_port, req_port=req_port, hb_port=hb_port) return kernel
def make_kernel(namespace, kernel_factory, out_stream_factory=None, display_hook_factory=None): """ Creates a kernel, redirects stdout/stderr, and installs a display hook and exception handler. """ # If running under pythonw.exe, the interpreter will crash if more than 4KB # of data is written to stdout or stderr. This is a bug that has been with # Python for a very long time; see http://bugs.python.org/issue706263. if sys.executable.endswith('pythonw.exe'): blackhole = file(os.devnull, 'w') sys.stdout = sys.stderr = blackhole sys.__stdout__ = sys.__stderr__ = blackhole # Install minimal exception handling sys.excepthook = FormattedTB(mode='Verbose', color_scheme='NoColor', ostream=sys.__stdout__) # Create a context, a session, and the kernel sockets. io.raw_print("Starting the kernel at pid:", os.getpid()) context = zmq.Context() # Uncomment this to try closing the context. # atexit.register(context.close) session = Session(username=u'kernel') reply_socket = context.socket(zmq.XREP) xrep_port = bind_port(reply_socket, namespace.ip, namespace.xrep) io.raw_print("XREP Channel on port", xrep_port) pub_socket = context.socket(zmq.PUB) pub_port = bind_port(pub_socket, namespace.ip, namespace.pub) io.raw_print("PUB Channel on port", pub_port) req_socket = context.socket(zmq.XREQ) req_port = bind_port(req_socket, namespace.ip, namespace.req) io.raw_print("REQ Channel on port", req_port) hb = Heartbeat(context, (namespace.ip, namespace.hb)) hb.start() hb_port = hb.port io.raw_print("Heartbeat REP Channel on port", hb_port) # Helper to make it easier to connect to an existing kernel, until we have # single-port connection negotiation fully implemented. io.raw_print("To connect another client to this kernel, use:") io.raw_print("-e --xreq {0} --sub {1} --rep {2} --hb {3}".format( xrep_port, pub_port, req_port, hb_port)) # Redirect input streams and set a display hook. if out_stream_factory: sys.stdout = out_stream_factory(session, pub_socket, u'stdout') sys.stderr = out_stream_factory(session, pub_socket, u'stderr') if display_hook_factory: sys.displayhook = display_hook_factory(session, pub_socket) # Create the kernel. kernel = kernel_factory(session=session, reply_socket=reply_socket, pub_socket=pub_socket, req_socket=req_socket) kernel.record_ports(xrep_port=xrep_port, pub_port=pub_port, req_port=req_port, hb_port=hb_port) return kernel
def _wrap_errors(_): """Install traceback handling for callbacks""" self._traceback = sys.exc_info()[2] # Compute number of stack frames to skip to get down to callback tb_werkzeug = get_current_traceback() skip = 0 if dev_tools_prune_errors: for i, line in enumerate(tb_werkzeug.plaintext.splitlines()): if "%% callback invoked %%" in line: skip = int((i + 1) / 2) break # Customized formatargvalues function so we can place function parameters # on separate lines original_formatargvalues = inspect.formatargvalues inspect.formatargvalues = _custom_formatargvalues try: # Use IPython traceback formatting to build colored ANSI traceback # string ostream = io.StringIO() ipytb = FormattedTB( tb_offset=skip, mode="Verbose", color_scheme="Linux", include_vars=True, ostream=ostream ) ipytb() finally: # Restore formatargvalues inspect.formatargvalues = original_formatargvalues # Print colored ANSI representation if requested ansi_stacktrace = ostream.getvalue() if inline_exceptions: print(ansi_stacktrace) # Use ansi2html to convert the colored ANSI string to HTML conv = Ansi2HTMLConverter(scheme="ansi2html", dark_bg=False) html_str = conv.convert(ansi_stacktrace) # Set width to fit 75-character wide stack trace and font to a size the # won't require a horizontal scroll bar html_str = html_str.replace( '<html>', '<html style="width: 75ch; font-size: 0.86em">' ) # Remove explicit background color so Dash dev-tools can set background # color html_str = re.sub("background-color:[^;]+;", "", html_str) return html_str, 500
def init_crash_handler(self): # Install minimal exception handling sys.excepthook = FormattedTB(mode='Verbose', color_scheme='NoColor', ostream=sys.__stdout__)
def setup_exceptions(): try: from IPython.core.ultratb import FormattedTB sys.excepthook = FormattedTB(mode='Plain', color_scheme='Neutral') except ImportError: pass