Using tblib you can pass wrapped exceptions and reraise them later: import tblib.pickling_support tblib.pickling_support.install() from multiprocessing import Pool import sys class ExceptionWrapper(object): def __init__(self, ee): self.ee = ee __, __, self.tb = sys.exc_info() def re_raise(self): raise self.ee.with_traceback(self.tb) # for Python 2 replace the previous line by: # raise self.ee, None, self.tb # example of how … Read more
Here’s a function based on this answer. It will also work when no exception is present: def full_stack(): import traceback, sys exc = sys.exc_info()[0] stack = traceback.extract_stack()[:-1] # last one would be full_stack() if exc is not None: # i.e. an exception is present del stack[-1] # remove call of full_stack, the printed exception # … Read more
In order to print your own stacktrace, you would need to handle all unhandled exceptions yourself; this is how the sys.excepthook becomes handy. The signature for this function is sys.excepthook(type, value, traceback) and its job is: This function prints out a given traceback and exception to sys.stderr. So as long as you can play with … Read more
traceback.format_exc() or sys.exc_info() will yield more info if that’s what you want. import traceback import sys try: do_stuff() except Exception: print(traceback.format_exc()) # or print(sys.exc_info()[2])
You can turn off the traceback by limiting its depth. Python 2.x import sys sys.tracebacklimit = 0 Python 3.x In Python 3.5.2 and 3.6.1, setting tracebacklimit to 0 does not seem to have the intended effect. This is a known bug. Note that -1 doesn’t work either. Setting it to None does however seem to … Read more
Alright, since this appears to be more about what stack frames/call stacks are in general, let’s go through this: def f(): try: g() except: # WE WILL DO THINGS HERE def g(): h() def h(): raise Exception(‘stuff’) #CALL f() When we’re in h(), there are 4 frames on the call stack. [top level] [f()] [g()] … Read more
A blank raise raises the last exception. # need to re-raise err so caller can do its own handling if err: raise If you use raise something Python has no way of knowing if something was an exception just caught before, or a new exception with a new stack trace. That’s why there is the … Read more
You can get what you want by assigning to warnings.showwarning. The warnings module documentation itself recommends that you do that, so it’s not that you’re being tempted by the dark side of the source. 🙂 You may replace this function with an alternative implementation by assigning to warnings.showwarning. You can define a new function that … Read more
You are presumably encountering an exception and the program is exiting because of this (with a traceback). The first thing to do therefore is to catch that exception, before exiting cleanly (maybe with a message, example given). Try something like this in your main routine: import sys, traceback def main(): try: do main program stuff … Read more
import sys, os try: raise NotImplementedError(“No error”) except Exception as e: exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1] print(exc_type, fname, exc_tb.tb_lineno)