mypy

Suppose I have a Child class that is a subclass of Parent class, and a function that accepts a list of instances of Parent subclasses: from typing import List class Parent: pass class Child(Parent): pass def func(objects: List[Parent]) -> None: print(objects) children = [Child()] func(children) running mypy on this produces an error: error: Argument 1 to "func" has incompatible type "List[Child]"; expected "List[Parent]" How do I create a type for this? P.S. There's a way to fix this particular error with a Sequence type: def func(objects: Sequence[Parent]) -> None: print(objects) but this

So, let's start with an example. Suppose we have several types that can be combined together, let's say we are using __add__ to implement this. Unfortunately, due to circumstances beyond our control, everything has to be "nullable", so we are forced to use Optional everywhere. from typing import Optional, List, overload class Foo: value: int def __init__(self, value: int) -> None: self.value = value def __add__(self, other: 'Foo') -> 'Optional[Foo]': result = self.value - other.value if result > 42: return None else: return Foo(result) class Bar: value: str def __init__(self, value: str) ->

A little background, I essentially need to define an int wrapper type, say MyInt (among some other classes), and another generic Interval type which can accept MyInt objects as well as other types of objects. Since the types acceptable by the Interval do not fall into a neat hierarchy, I thought this would be a perfect use-case for the experimental Protocol , which in my case would require a couple of methods and a couple of @classmethod s. All the methods return a "self-type", i.e., MyInt.my_method returns a MyInt . Here is a MCVE: from dataclasses import dataclass from typing import Union,

I am trying the typing hint introduced by Python 3.5 and got a problem by using local stubs as the typing hint with mypy. The experiment I do is to creat kk.py containing def type_check(a): pass Also, I put kk.pyi containing def type_check(a: int):... in the same directory. In this way, I tried to trigger the error of "ncompatible types in assignment" by passing a string to type_check in kk.py. However, when I ran mypy kk.py and get no error. Thus I tried another way that mypy doc suggests, which is to set environment variable MYPYPATH to ~/some/path/stub and put kk.pyi in the directory. I got

I'm using mypy in my python project for type checking. I'm also using PyYAML for reading and writing the project configuration files. Unfortunately, when using the recommended import mechanism from the PyYAML documentation this generates a spurious error in a try/except clause that attempts to import native libraries: from yaml import load, dump try: from yaml import CLoader as Loader, CDumper as Dumper except ImportError: from yaml import Loader, Dumper On my system CLoader and CDumper aren't present, which results in the errors error: Module 'yaml' has no attribute 'CLoader' and error:

How should a context manager be annotated with Python type hints? import typing @contextlib.contextmanager def foo() -> ???: yield The documentation on contextlib doesn't mention types much. The documentation on typing.ContextManager is not all that helpful either. There's also typing.Generator , which at least has an example. Does that mean I should use typing.Generator[None, None, None] and not typing.ContextManager ? import typing @contextlib.contextmanager def foo() -> typing.Generator[None, None, None]: yield Whenever I'm not 100% sure what types a function accepts, I like to consult