Pylance should ignore treated errors

[Jota-Ve]

Shouldn't Pylance ignore type errors if it is inside a try block ?

I know it won't always be desired, but there are some really obvious examples where the error is clearly expected and treated, so why complain it at all ? Here is a dummy example similar to what I run into very often

from typing import Optional

def capitalize(x: Optional[str]) -> Optional[str]:
    try:
        return x.capitalize()
    except AttributeError:
        return None

print(capitalize("test"))
print(capitalize(None))

I know x migth not have the capitalize() method, that's why it is inside a try block with except AttributeError. But this is what I get

This forces me to use the #type: ignore, wich is not ideal, or to replace the try/except block with an if statement, wich slow things down with multiple calls, and is not the recommended “it's easier to ask for forgiveness than permission”.

[erictraut]

Type consistency errors within a try block are not (and should not be) ignored by a type checker.

As you pointed out, you can use a # type: ignore if you want. Even better is to refactor your code so you don't use try/except for non-exceptional code flow. Using it in this manner is a bit of an abuse of the language feature. In your example above, if you know that x might be None in input, you should check for that condition and handle it appropriately. If your intent is that x should never contain None on input, you can change its type from Optional[str] to str and let the static type checker detect any places where a caller is potentially passing None.

[Jota-Ve]

Well, as I said this is just a silly example for the problem. And I can't change the behaviour of the codebase, because a lot of other softwares depend on it.

But nevertheless, I still think the proposed behaviour would make more sense. #type: ignore will turn off all error messages, wich is not what I'm asking. Thi example here:

x.capitalize() might throw an AttributeError, but it is explicitly handled so I don't think it should complain at all (even without #type: ignore). But, the division of a string would cause a TypeError, wich is not handled, so I still want to be warned about it.

I'm not asking for pylance to completely ignore the line, as #type: ignore does, I'm asking it to ignore only the errors that are handled.

And sorry if this is merging 2 different discussions into one, but... Is this supposed to happen ?

I assumed the first one would understand that really_long_list is list[int] if it has no None

[erictraut]

You should not use try/except blocks for expected code flow. By definition, try/except is used for exceptional conditionals. The recommended approach in this case is:

if x is None:
    return None
return x.capitalize()

or

return None if x is None else x.capitalize()

Not only is this more readable, it's faster at runtime, and it works well with static type checking.

In general, if you find yourself using a # type: ignore, there's probably a better way to write your code.