New upstream version 0.620

recursive-include extensions *

recursive-include docs *

include runtests.py

include waiter.py

include mypy_self_check.ini

include LICENSE

Metadata-Version: 2.1

Name: mypy

Version: 0.610

Version: 0.620

Summary: Optional static typing for Python

Home-page: http://www.mypy-lang.org/

Author: Jukka Lehtosalo

<img src="http://mypy-lang.org/static/mypy_light.svg" alt="mypy logo" width="300px"/>

Mypy: Optional Static Typing for Python

=======================================

[![Build Status](https://api.travis-ci.org/python/mypy.svg?branch=master)](https://travis-ci.org/python/mypy)

[![Chat at https://gitter.im/python/typing](https://badges.gitter.im/python/typing.svg)](https://gitter.im/python/typing?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)

Got a question? Join us on Gitter!

* Emacs: using [Flycheck](https://github.com/flycheck/) and [Flycheck-mypy](https://github.com/lbolla/emacs-flycheck-mypy)

* Sublime Text: [SublimeLinter-contrib-mypy](https://github.com/fredcallaway/SublimeLinter-contrib-mypy)

* Atom: [linter-mypy](https://atom.io/packages/linter-mypy)

* PyCharm: PyCharm integrates [its own implementation of PEP 484](https://www.jetbrains.com/help/pycharm/2017.1/type-hinting-in-pycharm.html).

* PyCharm: [mypy plugin](https://github.com/dropbox/mypy-PyCharm-plugin) (PyCharm integrates [its own implementation of PEP 484](https://www.jetbrains.com/help/pycharm/type-hinting-in-product.html))

* VS Code: provides [basic integration](https://code.visualstudio.com/docs/python/linting#_mypy) with mypy.

Mypy can also be integrated into [Flake8] using [flake8-mypy].

This section discusses various features that did not fit in naturally in one

of the previous sections.

.. _function-overloading:

.. _dataclasses_support:

Function overloading

********************

Dataclasses

***********

Sometimes the types in a function depend on each other in ways that

can't be captured with a ``Union``.  For example, the ``__getitem__``

(``[]`` bracket indexing) method can take an integer and return a

single item, or take a ``slice`` and return a ``Sequence`` of items.

You might be tempted to annotate it like so:

In Python 3.7, a new ``dataclasses`` module has been added to the standard library.

This module allows defining and customizing simple boilerplate-free classes.

They can be defined using the ``@dataclasses.dataclass`` decorator:

.. code-block:: python

    from typing import Sequence, TypeVar, Union

    T = TypeVar('T')

    from dataclasses import dataclass, field

    @dataclass

    class Application:

        name: str

        plugins: List[str] = field(default_factory=list)

    test = Application("Testing...")  # OK

    bad = Application("Testing...", "with plugin")  # Error: List[str] expected

Mypy will detect special methods (such as ``__lt__``) depending on the flags used to

define dataclasses. For example:

.. code-block:: python

    from dataclasses import dataclass

    class MyList(Sequence[T]):

        def __getitem__(self, index: Union[int, slice]) -> Union[T, Sequence[T]]:

            if isinstance(index, int):

                ...  # Return a T here

            elif isinstance(index, slice):

                ...  # Return a sequence of Ts here

            else:

                raise TypeError(...)

But this is too loose, as it implies that when you pass in an ``int``

you might sometimes get out a single item and sometimes a sequence.

The return type depends on the parameter type in a way that can't be

expressed using a type variable.  Instead, we can use `overloading

<https://www.python.org/dev/peps/pep-0484/#function-method-overloading>`_

to give the same function multiple type annotations (signatures) and

accurately describe the function's behavior.

    @dataclass(order=True)

    class OrderedPoint:

        x: int

        y: int

    @dataclass(order=False)

    class UnorderedPoint:

        x: int

        y: int

    OrderedPoint(1, 2) < OrderedPoint(3, 4)  # OK

    UnorderedPoint(1, 2) < UnorderedPoint(3, 4)  # Error: Unsupported operand types

Dataclasses can be generic and can be used in any other way a normal

class can be used:

.. code-block:: python

    from typing import overload, Sequence, TypeVar, Union

    from dataclasses import dataclass

    from typing import Generic, TypeVar

    T = TypeVar('T')

    class MyList(Sequence[T]):

        # The @overload definitions are just for the type checker,

        # and overwritten by the real implementation below.

        @overload

        def __getitem__(self, index: int) -> T:

            pass  # Don't put code here

        # All overloads and the implementation must be adjacent

        # in the source file, and overload order may matter:

        # when two overloads may overlap, the more specific one

        # should come first.

        @overload

        def __getitem__(self, index: slice) -> Sequence[T]:

            pass  # Don't put code here

        # The implementation goes last, without @overload.

        # It may or may not have type hints; if it does,

        # these are checked against the overload definitions

        # as well as against the implementation body.

        def __getitem__(self, index: Union[int, slice]) -> Union[T, Sequence[T]]:

            # This is exactly the same as before.

            if isinstance(index, int):

                ...  # Return a T here

            elif isinstance(index, slice):

                ...  # Return a sequence of Ts here

            else:

                raise TypeError(...)

Calls to overloaded functions are type checked against the variants,

not against the implementation. A call like ``my_list[5]`` would have

type ``T``, not ``Union[T, Sequence[T]]`` because it matches the

first overloaded definition, and ignores the type annotations on the

implementation of ``__getitem__``. The code in the body of the

definition of ``__getitem__`` is checked against the annotations on

the corresponding declaration. In this case the body is checked

with ``index: Union[int, slice]`` and a return type

``Union[T, Sequence[T]]``. If there are no annotations on the

corresponding definition, then code in the function body is not type

checked.

The annotations on the function body must be compatible with the

types given for the overloaded variants listed above it. The type

checker will verify that all the types for the overloaded variants

are compatible with the types given for the implementation. In this

case it checks that the parameter type ``int`` and the return type

``T`` are compatible with ``Union[int, slice]`` and

``Union[T, Sequence[T]]`` for the first variant. For the second

variant it verifies that the parameter type ``slice`` and the return

type ``Sequence[T]`` are compatible with ``Union[int, slice]`` and

``Union[T, Sequence[T]]``.

Overloaded function variants are still ordinary Python functions and

they still define a single runtime object. There is no automatic

dispatch happening, and you must manually handle the different types

in the implementation (usually with :func:`isinstance` checks, as

shown in the example).

The overload variants must be adjacent in the code. This makes code

clearer, as you don't have to hunt for overload variants across the

file.

Overloads in stub files are exactly the same, except there is no

implementation.

    @dataclass

    class BoxedData(Generic[T]):

        data: T

        label: str

.. note::

    def unbox(bd: BoxedData[T]) -> T:

        ...

   As generic type variables are erased at runtime when constructing

   instances of generic types, an overloaded function cannot have

   variants that only differ in a generic type argument,

   e.g. ``List[int]`` and ``List[str]``.

    val = unbox(BoxedData(42, "<important>"))  # OK, inferred type is int

.. note::

For more information see `official docs <https://docs.python.org/3/library/dataclasses.html>`_

and `PEP 557 <https://www.python.org/dev/peps/pep-0557/>`_.

   If you just need to constrain a type variable to certain types or

   subtypes, you can use a :ref:`value restriction

   <type-variable-value-restriction>`.

**Note:** Some functions in the ``dataclasses`` module, such as ``replace()`` and ``asdict()``,

have imprecise (too permissive) types. This will be fixed in future releases.

.. _attrs_package:

.. code-block:: python

   from typing import List, Set, Dict, Tuple, Text, Optional, AnyStr

   from typing import List, Set, Dict, Tuple, Optional

   # For simple built-in types, just use the name of the type

   x: int = 1

   x: float = 1.0

   x: bool = True

   x: str = "test"

   x: str = u"test"

   x: bytes = b"test"

   # For collections, the name of the type is capitalized, and the

   # For tuples, we specify the types of all the elements

   x: Tuple[int, str, float] = (3, "yes", 7.5)

   # For textual data, use Text if you care about Python 2 compatibility

   # ("Text" means "unicode" in Python 2 and "str" in Python 3)

   x: List[Text] = ["string", u"unicode"]

   # Use Optional[] for values that could be None

   x: Optional[str] = some_function()

   if x is not None:

.. code-block:: python

   import asyncio

   from typing import Generator, Any

   # A coroutine is typed like a normal function

   async def countdown35(tag: str, count: int) -> str: