pyright | Static Type Checker for Python | Code Analyzer library

The issue you are talking about is called "Duck Typing". You can find more information about it by Googling the term.

Python explicitly allows duck typing. If an object has a swim method, then you can call swim() and hope that it does the right thing.

One of the jobs of a linter is to protect you against duck typing. If you're saying that a method accepts a Duck, then the type checker's job is make sure that you only pass it an instance of a Duck. Sure, you can pass it an instance of a Whale, and that whale also has a swim method. But what happens when you later decide you want your duck to fly()?

The solution to your problem is Protocols. You might have a protocol Swimmable indicating that the object has a swim() method. Then your method makes it argument type be Swimmable.

In short, the linter is doing its job.

What if you're explicit about the types in SingularFoo? This seems to make mypy happy:

I posted this to the Pyright issue tracker and was informed that I had to add a Union[NoReturn, None] annotation to the check implementation to resolve the error:

[This] falls out of pyright's rules for return type inference. Pyright will infer a NoReturn type only in the case that all code paths raise an exception. It's quite common for some code paths raise an exception, and it would produce many false positives if pyright were to include NoReturn in the union in that case, so NoReturn is always elided from a union in an inferred return type.

Mypy doesn't have any support for return type inference, so that explains why this doesn't occur for mypy.

The correct way to annotate this is to include an explicit None | NoReturn return type for the implementation.

Unfortunately, this defeats the purpose of the overloads in the first place, which is to allow PyRight to infer from the arguments when NoReturn is the return type. I asked whether it is possible to use overloads to conditionally express NoReturn to the type checker. Apparently it is not:

Unfortunately, pyright cannot make this determination because of its core architecture. The "reachability" of nodes within a code flow graph cannot rely on type evaluations because type evaluations depend on reachability of code flow nodes. To work around this chicken-and-egg problem, the logic that determines reachability does some basic checks to determine if the called function is potentially a "NoReturn" function, but these basic checks are not sophisticated enough to handle overload evaluation. Evaluating overloads requires the full type evaluator, and that depends on reachability.

As juanpa.arrivillaga has pointed out, the assignment statements docs indicate that, in the case that the left hand side of an assignment statement is a comma separated list of one or more targets,

The object must be an iterable with the same number of items as there are targets in the target list, and the items are assigned, from left to right, to the corresponding targets.

Therefore, if one wants to unpack a bare object, one must necessarily implement __iter__, which will always have a return type of Iterator[Union[...]] or Iterator[SufficientlyGenericSubsumingType] when it includes multiple attribute types. A static type checker, therefore, cannot effectively reason about the specific types of unpacked variables.

Presumably, when a tuple is on the right hand side of an assignment, even though the language specification indicates that it will be treated as an iterable, a static type checker can still reason effectively about the types of its constituents.

As such, as juanpa.arrivillaga has also pointed out, a bespoke astuple method which emits a tuple[...] type is probably the best approach if one must unpack attributes, even though it does not avoid the pitfall of multi-level list comprehensions mentioned in the question. In terms of the question, we could now have:

"fruits" is not a type (hint), but Literal["fruits"] is.

The problem here is that I had broken dependencies which would not allow me to do any updates nor new installs.

This had to do with having packages from both conda and pip. Some of them play nice together, some don't.

My solution, was unfortunately, rather atomic. I deleted the environment and created a new one with Python 3.7. Upon doing that, I also added an extra conda channel conda-forge which I recommend instead of pip.

Once I did that I installed all the dependencies and packages using conda and it worked.

Here are the command I used:

You can always use the typing.cast function to say "trust me, I know what I'm doing."

This is not how type hinting works. To know that an input of etree._Element always results in a return of etree._Element and an input of None always results in None the IDE would need to parse the function, analyse all paths and get to that result.

I highly doubt that it is build to do that. Instead the IDE simply parses for annotations in the signatures and returns them as hint - type hints are just that - they are not enforced on code execution.

You may want to check with a simpler function:

Okay, here we go. It passes MyPy --strict, but it isn't pretty.

For a given class A, we know that the type of an instance of A will be A (obviously). But what is the type of A itself? Technically, the type of A is type, as all python classes that don't use metaclassses are instances of type. However, annotating an argument with type doesn't tell the type-checker much. The syntax used for python type-checking to go "one step up" in the type hierarchy is, instead, Type[A]. So if we have a function myfunc that returns an instance of a class inputted as a parameter, we can fairly simply annotate that as follows: