Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
    Shantanu
    @hauntsaninja
    @madelesi python/mypy#5160
    Abdalaziz Rashid
    @abdalazizrashid
    Shape = TypeVar("Shape")
    DType = TypeVar("DType")
    
    class Array(np.ndarray, Generic[Shape, DType]):
        pass
    I'm trying to make mypy check the shape of the array somehow, I defined this new type but I'm getting error: Invalid type comment or annotation
    What is going on?
    Shantanu
    @hauntsaninja
    I don't get that with your^
    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)
    Abdalaziz Rashid
    @abdalazizrashid
    mypy version is 0.790
    And the way I use it is x: Array["A", float]
    I also get this error Name 'A' is not defined
    Callek
    @jwood:mozilla.org
    [m]
    is "A" a class/classvar/typevar/etc, or what is it?
    Abdalaziz Rashid
    @abdalazizrashid
    Nothing just annotation for the array dimensions say we have an image so we write def foo_image(im: Array['H,W,3', np.uint8])
    Callek
    @jwood:mozilla.org
    [m]
    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
    Abdalaziz Rashid
    @abdalazizrashid
    But why it wouldn't generate any errors in this case? x: Array["A, B", float]
    Callek
    @jwood:mozilla.org
    [m]
    No idea
    Jörn Heissler
    @joernheissler
    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)
    Jörn Heissler
    @joernheissler
    Never mind, got it sorted.
    Ashesh
    @Ashesh3
    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?

    Jörn Heissler
    @joernheissler
    Try is not None
    Ashesh
    @Ashesh3
    Thanks , works
    Shantanu
    @hauntsaninja
    @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
    Shaun Stanworth
    @shauns_uk_gitlab

    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.

    ignormies
    @ignormies:matrix.org
    [m]
    I believe you'll need to wait for pep612:
    https://www.python.org/dev/peps/pep-0612/
    Shaun Stanworth
    @shauns_uk_gitlab
    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...
    Bryan Forbes
    @bryanforbes
    @hauntsaninja does that mean there are wheels for the 0.790 release?
    Shantanu
    @hauntsaninja
    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
    Václav Brožík
    @vbrozik
    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)
    Callek
    @jwood:mozilla.org
    [m]
    @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
    Bryan Forbes
    @bryanforbes
    @hauntsaninja thanks for letting me know… is there a way to point pip at a github URL and have it figure out which wheel to download for the arcitechture it’s running on?
    Shantanu
    @hauntsaninja
    not sure. maybe you could do something with --find-links.
    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
    Václav Brožík
    @vbrozik
    ...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)
    Shantanu
    @hauntsaninja
    @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])
    Shantanu
    @hauntsaninja
    it gets more complicated for generics. in particular, mypy almost never infers Any, since that causes code to go without type checking. in your example, you essentially want mypy to get a type with Any in it (Iterable is the same as Iterable[Any]).
    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.
    Shantanu
    @hauntsaninja
    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
    Bryan Forbes
    @bryanforbes
    @hauntsaninja thanks for the clue about --find-linkspip install -U --find-links https://github.com/mypyc/mypy_mypyc-wheels/releases/latest mypy works brilliantly
    Christoph Tyralla
    @tyralla

    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.

    Christoph Tyralla
    @tyralla
    ```
    Christoph Tyralla
    @tyralla
    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]
    5 replies
    Henry Schreiner
    @henryiii

    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.
    Adrian Freund
    @freundTech
    @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."
    Henry Schreiner
    @henryiii
    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
    Henry Schreiner
    @henryiii
    I’ve put this issue in: python/mypy#9902
    Abc Abc
    @Blackjack37_gitlab
    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)
    2 replies