More callables should be usable as Exception Group predicates

[SlaushVunter]

Bug report

If a bound method is used as the condition for BaseExceptionGroup.split the following exception is raised:

TypeError: expected a function, exception type or tuple of exception types

Consider the following example:

class HandleError:
    def __enter__(self):
        pass

    def __exit__(self, exc_type, exc_inst, exc_tb):
        if exc_type is None:
            return False
        if isinstance(exc_inst, ExceptionGroup):
            match, rest = exc_inst.split(self._log_and_ignore_error)
            if match is None:
                return False
            elif rest is None:
                return True
            raise rest
        else:
            return self._log_and_ignore_error(exc_inst)

    def _log_and_ignore_error(self, e: BaseException) -> bool:
        ...
        return True
    
    
with HandleError():
    raise ExceptionGroup('foo', [ValueError('bar')])

If we replace the bound method with a lambda (lambda e: self._log_and_ignore_error(e)) then no exception is raised.

I think it would be useful to accept any callable here. I guess the code update would be simple too, just replace PyFunction_Check with PyCallable_Check in

    if (PyFunction_Check(value)) {
        *type = EXCEPTION_GROUP_MATCH_BY_PREDICATE;
        return 0;
    }

Update the exception message to allow callables, and change the assert in

    case EXCEPTION_GROUP_MATCH_BY_PREDICATE: {
        assert(PyFunction_Check(matcher_value));
        PyObject *exc_matches = PyObject_CallOneArg(matcher_value, exc);

to call PyCallable_Check again.

Your environment

• CPython versions tested on: 3.11.2

The c code snippets are from origin/main.

Linked PRs

• gh-105730: support more callables in ExceptionGroup.split() and subgroup() #106035

[sunmy2019]

@iritkatriel

[iritkatriel]

Thank you @SlaushVunter for the report. We could make more callables work with split(), but not all of them because that would be ambiguous - an Exception subclass is callable but it is matched by type and not as a predicate. Also, this would be a feature request rather than a bug report because the documentation says function, not callable. This means that it can only be changed in version 3.13.

That said, I don't think the code you provided above is a good motivating example for this. Iterating over leaf exceptions of an exception group like this gives you the leaf exceptions with truncated tracebacks (too see how to do this, look at the leaf_generator function in https://peps.python.org/pep-0654/#handling-exception-groups).

I would probably just split on some condition, log the matching subgroup (as a whole group) and then raise the non-matching part. The traceback of an exception group contains all the traceback information, laid out in a structured and concise manner.

[SlaushVunter]

Thank you for the quick reply, and the quick fix! And sorry for my late answer.

My example was the result of a simplification. In my original example I did not want to log the traceback for the matched leaf exceptions (communication errors), because they are not needed, the error message is enough. Anyway thank you for your suggestion also.