Can EAFP and mypy coexist?

Question

EAFP

Easier to ask for forgiveness than permission. This common Python coding style assumes the existence of valid keys or attributes and catches exceptions if the assumption proves false. This clean and fast style is characterized by the presence of many try and except statements. The technique contrasts with the LBYL style common to many other languages such as C.

From Python Glossary

mypy

What is mypy?

Mypy is an optional static type checker for Python. You can add type hints (PEP 484) to your Python programs, and use mypy to type check them statically. Find bugs in your programs without even running them!

You can mix dynamic and static typing in your programs. You can always fall back to dynamic typing when static typing is not convenient, such as for legacy code.

Here's an awesome YouTube video about EAFP: https://youtu.be/x3v9zMX1s4s

I'm trying to use mypy, but it's getting angry basically every time I write some EAFP code.

For example:

from contextlib import suppress

from typing import Optional


class MyClass:
    def __init__(self):
        self.__name: Optional[str] = None

    @property
    def name(self) -> Optional[str]:
        return self.__name

    @name.setter
    def name(self, name: str):
        self.__name = name

    @property
    def upper_name(self) -> Optional[str]:
        with suppress(AttributeError):
            return self.name.upper()  # Item "None" of "Optional[str]" has no attribute "upper" - mypy(error)
        return None

In this example, I want the upper_name property to try to convert name to uppercase, but in case name is None, it'll raise an AttributeError, that is then suppressed by suppress(AttributeError), so the function returns None instead.

I have the explicit return None at the bottom because PEP 8 says to:

Be consistent in return statements. Either all return statements in a function should return an expression, or none of them should. If any return statement returns an expression, any return statements where no value is returned should explicitly state this as return None, and an explicit return statement should be present at the end of the function (if reachable).

I have submitted this as an issue (#9467) to the mypy repo, but it got almost instantly closed.

I do think it'd be possible to have mypy understand EAFP.

For example, if it sees a type Optional[something], and it sees an expression that would raise a SomethingError if it receives None, but succeed if it receives something, and that expression is enclosed in a try or suppress block that can handle SomethingError, then it could assume it's some EAFP code, and not freak out.

But the way it is now, to have it not freak out with the example above, I'd have to change it to:

from typing import Optional


class MyClass:
    def __init__(self):
        self.__name: Optional[str] = None

    @property
    def name(self) -> Optional[str]:
        return self.__name

    @name.setter
    def name(self, name: str):
        self.__name = name

    @property
    def upper_name(self) -> Optional[str]:
        if self.name is not None:
            return self.name.upper()  # No error here this time
        else:
            return None

Another example:

Suppose I can have a house that can have a garage that can have a car that has a brand, something like this would allow me to get it's brand:

from contextlib import suppress

from my_module import house

car_brand = None
try:
    car = house.garage.car
except AttributeError:
    pass
else:
    car_brand = car.brand

If house is None, or if its garage is None, or if its car is None, car_brand will stay None. But if there is a house with a garage with a car, it'll try to get its brand. If the car has no brand, that error will not be suppressed, because a car MUST have a brand.

The other way of doing it, to not have mypy erroring, would be:

from my_module import house

car_brand = None
if house is not None:
    garage = house.garage
    if garage is not None:
        car = garage.car
        if car is not None:
            car_brand = car.brand

And I don't think that's very readable or clean.

Another point that I believe is valid is avoiding race conditions. If I first read a value to check if it's valid, then read it again to use it if it's valid, I believe there's nothing that guarantees the second time I'm reading it I'll receive the same value as the first time.

With doing things the "EAFP" way, I only read values once, so it doesn't matter if the value changes drastically just after I've read it.

My examples aren't perfect, but I think they do the trick in conveying the idea.

So my question is, how can I use the EAFP style and still use mypy? Is there a flag or argument I can give mypy so it doesn't freak out in the mere existence of EAFP? Or is there a "better" EAFP way of doing stuff, that doesn't make mypy sad?

• Python 3.8.6
• mypy 0.782