(How) can I make a decorator narrow a type in the function body?

I am implementing a decorator to replace repeated early-exit checks such as

if self.data is None:
    self.log_something()
    return

at the top of my methods. This approach (highly simplified here) does work nicely:

"""early exit decorator."""
from collections.abc import Callable

Method = Callable[["Class"], None]
Condition = Callable[["Class"], bool]

def early_exit_if(condition: Condition) -> Callable[[Method], Method]:
    def decorator(method: Method) -> Method:
        def wrapper(instance: "Class") -> None:
            if condition(instance):
                return
            method(instance)
        return wrapper
    return decorator

class Class:
    def __init__(self) -> None:
        self.data: list[int] | None = None

    @staticmethod
    def data_is_none(instance: "Class") -> bool:
        return instance.data is None

    @early_exit_if(data_is_none)
    def do_something_with_data(self) -> None:
        self.data.append(0)

if __name__ == "__main__":
    Class().do_something_with_data()

In short, @early_exit_if(data_is_none) ensures that data is not None in the body of do_something_with_data. However, mypy does not know that:

> bug.py:30: error: Item "None" of "list[int] | None" has no attribute "append" [union-attr]

How can I let mypy know (ideally, from within the decorator) that data is not None?

I know that assert self.data is not None works, but I dislike duplicating the check.

Edit: I just learned about TypeGuards, and I wonder if this approach can be combined with decorators.

Actually, you may already have the best answer:

assert self.data is not None

Is well documented by mypy in type narrowing among other things.

Remember that it doesn't necessarily duplicate the check as assert is meant to be use mostly at development time, in production you can run "python -O" (optimized mode) and asserts are just ignored, so it doesn't impact performance at all.