What are the python builtin __exit__ argument types?

Question

Classes have a defineable function __exit__ that allows implementation of a context manager.

It takes the required arguments:

def __exit__(self, exc_type, exc_val, exc_tb):

but I cannot find a definitive definition of what those arguments are and their types.

Here's my best guess of what they are and why, but I'm not entirely sure:

def __exit__(self, exc_type: Exception, exc_val: TracebackException, exc_tb: TracebackType):

exc_type

Python defines a TracebackException class that accepts an exc_type argument which is used contextually in the constructor within issubclass with SyntaxError, which infers that exc_type is indeed some sort of Exception, which SyntaxError inherits from.

exc_val

Also, in that TracebackException class is an exc_value argument that matches up to our exc_val which seems to have various attributes like __cause__, __context__, and other attributes that are all defined in TracebackType itself. This makes me think that the parameter is itself an instance of TracebackException.

exc_tb

Python defines a walk_tb function that uses exc_tb as an argument (manually traced from docs.python.org), and this object appears to have tb_frame, tb_lineno, and tb_next attributes which can be traced back to a TracebackType class in the typeshed library.

Thoughts?

Answer 1

exc_type is the exception's class. exc_val is the exception instance. exc_tb is a traceback object, of which there is a reference in types.TracebackType.

In general it should be the case that

• type(exc_val) is exc_type
• exc_val.__traceback__ is exc_tb

Note that __exit__ is still invoked when there was no exception raised by the code under a context manager, and the args will be (None, None, None) so all three arguments should be annotated optional.

Then a correct annotation for it should look something like this:

def __exit__(self, exctype: Optional[Type[BaseException]],
             excinst: Optional[BaseException],
             exctb: Optional[TracebackType]) -> bool: ...

You might wonder why this API has three arguments when two of them can be trivially determined from the exception instance itself. But it wasn't always that way, in older versions of Python you could raise strings as exceptions, and the exception's __traceback__ attribute wasn't there until Python 2.5. And you can still raise old-style classes as exceptions in Python 2.7 (!)