homepage

When an exception is raised by inspect.Signature.bind() in some cases the exception has a StopIteration as its __context__:
import inspect
try:
 inspect.signature(lambda x:None).bind()
except Exception as exc:
 print(repr(exc))
 print(repr(exc.__context__))
This prints:
 TypeError("missing a required argument: 'x'",)
 StopIteration()
I would have expected it to print:
 TypeError("missing a required argument: 'x'",)
 None
This reason for this is that the code in bind() has nested exception handlers. The innermost handler does
 raise TypeError(...) from None
to drop the exception context, but another context exception gets added by the outermost exception handler.

Hi Walter,
Thanks for reporting this. A patch is attached.

This isn't a bug, as "raise exc from None" only hides *display* of the context, it doesn't lose the record of the context entirely.
This means Walter's display code is incorrect, as it isn't checking for __suppress_context__:
>>> import inspect
>>> try:
... inspect.signature(lambda x:None).bind()
... except Exception as e:
... exc = e
... 
>>> exc.__suppress_context__
True
Interestingly, neither PEP 409 *nor* PEP 415 capture the rationale for that design: retaining the full context data even when it's hidden by the default exception display routines means that you can still debug code that uses "raise X from None" inappropriately. (I thought there was an open RFE to make it easy to force the traceback module to ignore __suppress_context__ but if there is one, I can't find it)

> This isn't a bug, as "raise exc from None" only hides *display* of the context, it doesn't lose the record of the context entirely.
Agree. My patch, though, is still valid. I think removing try..except blocks actually simplifies the code, and removes the need of using 'raise .. from None' completely.

The sentinel form of next() is nice when there's a natural sentinel value, but needing to *create* a sentinel is generally a sign that the out-of-band exception is a better fit.
The function could likely do with some refactoring (e.g. breaking out some helper functions to make the logic easier to follow), but shifting from idiomatic code to non-idiomatic code isn't a good way of tackling that.