In Python, how can I check and then re-throw an exception while maintaining the original call stack?

Question content

I ran into a situation where I was catching a specific exception type, checking the exception's message to check if it was indeed what I wanted The exception to catch, or re-throw the exception if not:

try:
    # do something exception-prone
except FooException as e:
    if e.message == 'Something I want to handle':
        # handle the exception
    else:
        raise e

This works fine, but there is a problem. In the case where I reraise the exception, the exception now occurs at the line where I reraised it (i.e. at raise e), rather than at the location where the exception originally occurred. This is not ideal for debugging, since you want to know where the original exception occurred.

So my question is: Is there a way to re-throw or otherwise "pass" the exception after catching it, while maintaining the original exception location?

NOTE: If you're wondering what's actually going on: I'm using __import__ to dynamically import some modules. I'm catching importerror to gracefully handle the case where any of these modules don't exist. However, if those modules themselves contain import statements that raise importerror, I want those "real" (from my application's perspective) exceptions to be raised - and in the original place of debugging involving tools.

Correct answer

Just do this:

raise

instead of raise e. See the tutorial section on raising exceptions and the language reference for the ##raise statement:

The above is the detailed content of In Python, how can I check and then re-throw an exception while maintaining the original call stack?. For more information, please follow other related articles on the PHP Chinese website!