mypy

How should I annotate a @classmethod that returns an instance of cls ? Here's a bad example: class Foo(object): def __init__(self, bar: str): self.bar = bar @classmethod def with_stuff_appended(cls, bar: str) -> ???: return cls(bar + "stuff") This returns a Foo but more accurately returns whichever subclass of Foo this is called on, so annotating with -> "Foo" wouldn't be good enough. The trick is to explicitly add an annotation to the cls parameter, in combination with TypeVar , for generics , and Type , to represent a class rather then the instance itself , like so: from typing import

How do I specific a function can take a list of numbers which can be ints or floats? I tried making a new type using Union like so: num = Union[int, float] def quick_sort(arr: List[num]) -> List[num]: ... However, mypy didn't like this: quickSortLomutoFirst.py:32: error: Argument 1 to "quickSortOuter" has incompatible type List[int]; expected List[Union[int, float]] Is there a Type that encompasses ints and floats? The short answer to your question is you should use either TypeVars or Sequence -- using List[Union[int, float]] would actually potentially introduce a bug into your code! In short,

Suppose I want to write a generic class using mypy, but the type argument for the class is itself a generic type. For example: from typing import TypeVar, Generic, Callable A = TypeVar("A") B = TypeVar("B") T = TypeVar("T") class FunctorInstance(Generic[T]): def __init__(self, map: Callable[[Callable[[A], B], T[A]], T[B]]): self._map = map def map(self, x: T[A], f: Callable[[A], B]) -> T[B]: return self._map(f, x) When I try to call mypy in the definition above I get an error: $ mypy typeclasses.py typeclasses.py:9: error: Type variable "T" used with arguments typeclasses.py:12: error: Type

Does the typing module (or any other module) exhibit an API to typecheck a variable at runtime, similar to isinstance() but understanding the type classes defined in typing ? I'd like to be to run something akin to: from typing import List assert isinstance([1, 'bob'], List[int]), 'Wrong type' There is no such function in the typing module, and most likely there won't ever be. Checking whether an object is an instance of a class - which only means "this object was created by the class' constructor" - is a simple matter of testing some tagging. However, checking whether an object is an

I have several namedtuples that share some fields. I have a function that accepts these tuples and is guaranteed to only interact with the shared fields. I want to typecheck such code in mypy. An example of the code would be: from typing import NamedTuple class Base(NamedTuple): x: int y: int class BaseExtended(NamedTuple): x: int y: int z: str def DoSomething(tuple: Base): return tuple.x + tuple.y base = Base(3, 4) base_extended = BaseExtended(5, 6, 'foo') DoSomething(base) DoSomething(base_extended) When I run mypy on this code I get a predictable error: mypy_example.py:20: error: Argument 1