`warnings.catch_warnings`: allow to control which warnings are caught

[calestyo]

Feature or enhancement

Proposal:

Hey.

(Assuming this isn't a major feature, I've skipped the "Major feature proposals should generally be discussed on Discourse before opening a GitHub issue.". 😇)

I have code like:

with warnings.catch_warnings(record=True) as w:
    long_running_func()
    #handle w

where long running func may give back some warnings for which I use custom types that are derived from UserWarning.

After the function, these warnings are somehow handled.

But in principle, I'd only like to catch only certain types of warnings... and the others should ideally be "let through" normally (i.e. per default, printed immediately, and not only when I'd e.g. handle and re-emit it manually during my post-function handling).

So perhaps, something like a catch_categories parameter, which then might be a sequence type, and would cause the context manager to only catch those that are instances of the given categories?

Thanks for consideration,
Chris.

Has this already been discussed elsewhere?

This is a minor feature, which does not need previous discussion elsewhere

Links to previous discussion of this feature:

No response

[picnixz]

Actually, isn't it already handled by the category parameter? https://docs.python.org/3/library/warnings.html#warnings.catch_warnings

[StanFromIreland]

There are also filters?

    with warnings.catch_warnings():
        warnings.simplefilter("ignore", (...))

[picnixz]

Closing since there's an existing solution (I think category is what you were looking for, feel free to object if this wasn't the case).

[calestyo]

I tried both filters and category and they seem to do something different.

1. Regrading simplefilter:
   First it wasn't clear to me (no offence meant, but the documentation of warnings seems to be not the best of Python :-) ) whether it's a difference to call simplefilter() inside a context manager, compare to outside.
   But my understanding of ignore is, that any such warning would be simply completely ignored ("never print matching warnings"). What I however want is that it's simply not caught be the catch_warnings and "let through" for normal processing (whatever that is, perhaps even another outside context manager).

The idea is that one can basically replicate what a try/catch block allows, where I can catch particular exceptions and let others though.

2. Regarding category
   This would allow only one category to be matched, as if one could only do one except in a try/catch block.
   But apart from that, it simply doesn't seem to do what I meant (i.e. selecting which warnings get caught while letting the others through.

If I do e.g.:

import warnings

class MyWarning(UserWarning):
    pass

def foo():
    warnings.warn(MyWarning("my"))
    warnings.warn("other")
with warnings.catch_warnings(record=True, action="ignore", category=MyWarning) as caught_warnings:
    foo()


for w in caught_warnings:
    print(w.message)

I get:

other

so it catches both, but ignores MyWarnings.
If I change the action to e.g. always, I get:

my
other

Still catches both, ignores none.

But in neither case it let's any of the ones I don't want to be caught through.

[picnixz]

FTR catch_warnings(record=True, action=..., **kwargs) is equivalent to:

with catch_warnings(record=True) as cm:
    warnings.simplefilter(action, **kwargs)

This would allow only one category to be matched, as if one could only do one except in a try/catch block.

Use record=True and refine the filter by setting warnings.simplefilter() for each warnings you want. Though, I agree we should maybe allow specifying one or more warning classes in category as we do it for issubclass.

with warnings.catch_warnings(record=True, action="ignore", category=MyWarning) as caught_warnings:
    foo()

This means that you want to ignore MyWarning instances. This is why you get "other" (because it's not an instance of MyWarning).

If I change the action to e.g. always, I get [...] Still catches both, ignores none.

This one seems weird but I think the "always" actually makes the category being ignored. It could be a legitimate bug but this needs to be properly investigated.

But in neither case it let's any of the ones I don't want to be caught through.

Which one do you want to ignore and which one do you want to catch?