What is your mypy version? If it's not 0.790 could you update?
(If you're using a version of mypy from more than a year or two ago, you'll get errors like that when running mypy with Python 3.9)
ahh right numpy stuff.... I'll note that it looks like mypy is treating
Array as a type and trying to find a generic base type of "A" which it can't find because it doesn't exist
jwood:mozilla.org @jwood:mozilla.org says as merely a user not an author
Hi. Could someone please help me add the type annotations to my class?
it is an iterable of an unspecified type.class Foo:
def __init__(self, it):
self.it = it
def __iter__(self):
return self
def __next__(self):
return next(self.it)
for i in Foo(iter(range(10))):
print(i)
a: List[Optional[int]] = [None, None]
a[0] = 5
a[1] = 10
b: int = 0
if a[0] != None:
b = a[0]It shows an Error:
test.py:12: error: Incompatible types in assignment (expression has
type "Optional[int]", variable has type "int")
Found 1 error in 1 file (checked 1 source file)I do check if a[0] is not None but I don't know why it still fails to narrow down the type of a[0] from int | None to int as the condition for None is already checked for.
any idea why?
@bryanforbes as of today, we now build 3.9 wheels, so you can download them for yourself from https://github.com/mypyc/mypy_mypyc-wheels/releases/latest
I think the answer here is that it's not possible, but I'd like to be able to do the equivalent of a Typescript typeof for a function. An example:
def foo(i: int) -> str:
return "foo"
class Bar:
def __init__(self, fn: "foo"):
self.captured = fn
def baz(self):
return self.captured("123")So the fn parameter in Bar constructor I'd like to enforce as matching the signature of foo (somehow). Obviously I could write a separate Callable or protocol, but this feels like duplication.
Thank you - it's close to it (particularly the rejected
ParametersOf approach) but I think the gap is more about the ergonomics of being able to lift a type from some other variable. Like uses_same_type_as_x: TypeOf[x] = ...(where in this example x happens to be a function) . Had a look through the PEPs and couldn't find anything along those lines. Wonder if a mypy plugin could do this...
no it doesn't (i don't have the ability to do that), but it does mean you can download precompiled wheels for mypy master (which is much less painful than building them yourself). it also means it would now be fairly easy to add 3.9 wheels to 0.790 for someone with the ability to upload wheels to pypi
It looks like I have encountered an error in mypy 0.790.
if else operator alternation of types compatible with Callable[[Iterable], Sequence] gives incompatible type builtins.object:#!/usr/bin/python3.9
from typing import Callable, Iterable, Sequence
deterministic: bool = True
processlist1: Callable[[Iterable], Sequence] = sorted
processlist2: Callable[[Iterable], Sequence] = list
processlist3: Callable[[Iterable], Sequence] = sorted if deterministic else list
reveal_type(sorted)
reveal_type(list)
reveal_type(sorted if deterministic else list)Python-tests$ mypy --show-error-code creator-callable.py
creator-callable.py:8: error: Incompatible types in assignment (expression has type "object", variable has type "Callable[[Iterable[Any]], Sequence[Any]]") [assignment]
creator-callable.py:10: note: Revealed type is 'Overload(def [_LT <: builtins._SupportsLessThan] (typing.Iterable[_LT`-1], *, key: None =, reverse: builtins.bool =) -> builtins.list[_LT`-1], def [_T] (typing.Iterable[_T`-1], *, key: def (_T`-1) -> builtins._SupportsLessThan, reverse: builtins.bool =) -> builtins.list[_T`-1])'
creator-callable.py:11: note: Revealed type is 'Overload(def [_T] () -> builtins.list[_T`1], def [_T] (iterable: typing.Iterable[_T`1]) -> builtins.list[_T`1])'
creator-callable.py:12: note: Revealed type is 'builtins.object'
Found 1 error in 1 file (checked 1 source file)
@vbrozik: I'm not a dev, but I'd be interested if its reproduceable in 3.8 or latest dev build wheel of mypy for 3.9 -- since 0.790 did not officially support 3.9 and has no wheels available https://github.com/mypyc/mypy_mypyc-wheels/releases
in case it's useful, here's some code in mypy to download all wheels for a given tag: https://github.com/python/mypy/blob/0c5936e08975ce1936c86f559d128cf25d30000e/misc/upload-pypi.py#L37 ... once downloaded, --find-links should work
...if its reproduceable in 3.8...
@jwood:mozilla.org thank you, I did not know that the current mypy does not support Python 3.9. I have changed the shebang to#!/usr/bin/python3.8(I am using the default Python in Ubuntu 20.04:Python 3.8.5) and run mypy with Python 3.8 explicitly. The result is the same :(Python-tests$ python3.8 -m mypy --show-error-code creator-callable.py creator-callable.py:8: error: Incompatible types in assignment (expression has type "object", variable has type "Callable[[Iterable[Any]], Sequence[Any]]") [assignment] creator-callable.py:10: note: Revealed type is 'Overload(def [_LT <: builtins._SupportsLessThan] (typing.Iterable[_LT`-1], *, key: None =, reverse: builtins.bool =) -> builtins.list[_LT`-1], def [_T] (typing.Iterable[_T`-1], *, key: def (_T`-1) -> builtins._SupportsLessThan, reverse: builtins.bool =) -> builtins.list[_T`-1])' creator-callable.py:11: note: Revealed type is 'Overload(def [_T] () -> builtins.list[_T`1], def [_T] (iterable: typing.Iterable[_T`1]) -> builtins.list[_T`1])' creator-callable.py:12: note: Revealed type is 'builtins.object' Found 1 error in 1 file (checked 1 source file)
@jwood:mozilla.org there are only two caveats to using mypy with 3.9, as mentioned here: https://github.com/python/mypy/issues/9761#issue-751858217 lack of a mypyc compiled wheel just means mypy runs a little slower. no need for FUD :-)
2 replies
the type signature for sorted was changed in the typeshed mypy 0.790 uses to enforce that the elements of the iterable are comparable
this is to allow type checkers to catch issues like
sorted([5, None])
anyway, with a ternary expression, mypy performs what it calls a join to determine the type of the expression
"join"-ing types means
reveal_type(5 if random() else "asdf") reveals object (as opposed to Union[str, int])
mypy does do what it calls type context, where it takes into account your annotation while making inferences. but not sure the logic is advanced enough for that to apply here.
there's also the question of whether mypy should use a join for ternary. i think it shouldn't, but big changes in inference are often annoying for users. ref https://github.com/python/mypy/issues/9264#issuecomment-674039604 (and the issue that that in turn links to)
your case is actually very similar to that issue
Hi, is mypy drawing a wrong conclusion in the following example?
```from typing import Literal, runtime_checkable, Protocol
@runtime_checkable
class A(Protocol):
x: Literal[0]
class B:
x: Literal[0, 1]
class C(B):
x: Literal[1]
b = B()
if isinstance(b, A): # error: Subclass of "B" and "A" cannot exist: would have incompatible method signatures [unreachable]
b.x = 0 # error: Statement is unreachable [unreachable]```
First, it says: "would have incompatible ... signatures". IMO, it should say: "could have incompatible ... signatures".
Second, it handles the last line as (definitely) unreachable and does not analyse it further. However, it is just eventually unreachable, and mypy thus misses the definite bug in the last line.
It doesn't need the Protocols. Maybe this example is clearer (mypy itself does not claim an incompatibility when defining class
C1):from abc import abstractmethod
from typing import *
class A0:
f: ClassVar[Literal[0]] = 0
class A1:
f: ClassVar[Literal[1]] = 1
class B:
@property
@abstractmethod
def f(self) -> Literal[0, 1]:
...
def t(self) -> None:
if isinstance(self, A0): # error: Subclass of "B" and "A0" cannot exist: would have incompatible method signatures [unreachable]
...
class C1(A0, B):
...
reveal_type(C1().f) # Revealed type is 'Literal[0]'
class C2(B, A0): # Definition of "f" in base class "B" is incompatible with definition in base class "A0" [misc
...
reveal_type(C2().f) # Cannot instantiate abstract class 'C2' with abstract attribute 'f' [abstract]
To me, it seems like this is valid but produces an error in MyPy:
class BaseDict(TypedDict):
a: str
class CustomDict(BaseDict):
b: str
def my_general_fun(x: BaseDict) -> None:
print(x[“a”], x.get(“b”))MyPy will not allow this because BaseDict has no attribute ”b”. But isn’t the point of .get to get an attribute that might be missing?
Couldn’t find anything exactly matching it in the issues, but it’s tricy to search for.
@henryiii I'm not that experienced with mypy, but from my Understanding of PEP589 that should be allowed:
"Operations with arbitrary str keys (instead of string literals or other expressions with known string values) should generally be rejected. This involves both destructive operations such as setting an item and read-only operations such as subscription expressions. As an exception to the above rule, d.get(e) and e in d should be allowed for TypedDict objects, for an arbitrary expression e with type str. The motivation is that these are safe and can be useful for introspecting TypedDict objects."
"Operations with arbitrary str keys (instead of string literals or other expressions with known string values) should generally be rejected. This involves both destructive operations such as setting an item and read-only operations such as subscription expressions. As an exception to the above rule, d.get(e) and e in d should be allowed for TypedDict objects, for an arbitrary expression e with type str. The motivation is that these are safe and can be useful for introspecting TypedDict objects."
This seems to be where it’s being locked in. Sounds a little silly, but since this is a literal check, making this a variable makes it pass.
I think it should infer the type if it’s a
get and known, but if it’s not known, it should return Any (or at the very least, the second part of the get or None)
I feel the description "arbitrary expression” above includes literal expressions
Hey, I'm trying to use a TypedDict and make a function that only accept values from the TypedDict but when I try to create that function using a Union Mypy complain that the dictionary values are of type object, how can I make him understand the real possible types? This is an example of the problem:
from typing import Union, TypedDict
def func(arg: Union[str, int]):
print(arg)
class Type(TypedDict, total=False):
a: str
b: int
c = Type({"a": "a", "b": 2})
for val in c.values():
func(val)