Merge from master

.flake8

@@ -5,7 +5,7 @@
 #  7155 E302 expected 2 blank lines
 #  1463 F401 imported but unused
 #   967 E701 multiple statements on one line (colon)
-#   457 F811 redefinition
+#   457 F811 redefinition (should be fixed in pyflakes 2.1.2)
 #   390 E305 expected 2 blank lines
 #     4 E741 ambiguous variable name
 
@@ -18,8 +18,6 @@
 [flake8]
 ignore = F401, F403, F405, F811, E301, E302, E305, E501, E701, E704, E741, B303, W504
 # We are checking with Python 3 but many of the stubs are Python 2 stubs.
-# A nice future improvement would be to provide separate .flake8
-# configurations for Python 2 and Python 3 files.
 builtins = StandardError,apply,basestring,buffer,cmp,coerce,execfile,file,intern,long,raw_input,reduce,reload,unichr,unicode,xrange
 exclude = .venv*,@*,.git
 max-line-length = 130

README.md

@@ -45,10 +45,13 @@ pytype repo.
 
 ## Format
 
-Each Python module is represented by a `.pyi` "stub". This is a normal Python
-file (i.e., it can be interpreted by Python 3), except all the methods are empty.
+Each Python module is represented by a `.pyi` "stub file".  This is a
+syntactically valid Python file, although it usually cannot be run by
+Python 3 (since forward references don't require string quotes).  All
+the methods are empty.
+
 Python function annotations ([PEP 3107](https://www.python.org/dev/peps/pep-3107/))
-are used to describe the types the function has.
+are used to describe the signature of each function or method.
 
 See [PEP 484](http://www.python.org/dev/peps/pep-0484/) for the exact
 syntax of the stub files and [CONTRIBUTING.md](CONTRIBUTING.md) for the

requirements-tests-py3.txt

@@ -2,7 +2,7 @@ git+https://github.com/python/mypy.git@master
 typed-ast>=1.0.4
 black==19.3b0
 flake8==3.7.8
-flake8-bugbear==19.3.0
+flake8-bugbear==19.8.0
 flake8-pyi==19.3.0
 isort==4.3.21
-pytype>=2019.7.30
+pytype>=2019.10.17

stdlib/2/UserDict.pyi

@@ -6,7 +6,7 @@ _VT = TypeVar('_VT')
 _T = TypeVar('_T')
 
 class UserDict(Dict[_KT, _VT], Generic[_KT, _VT]):
-    data: Mapping[_KT, _VT]
+    data: Dict[_KT, _VT]
 
     def __init__(self, initialdata: Mapping[_KT, _VT] = ...) -> None: ...
 

stdlib/2/UserList.pyi

@@ -1,9 +1,10 @@
-from typing import Iterable, MutableSequence, TypeVar, Union, overload
+from typing import Iterable, MutableSequence, TypeVar, Union, overload, List
 
 _T = TypeVar("_T")
 _S = TypeVar("_S")
 
 class UserList(MutableSequence[_T]):
+    data: List[_T]
     def insert(self, index: int, object: _T) -> None: ...
     @overload
     def __setitem__(self, i: int, o: _T) -> None: ...

stdlib/2/UserString.pyi

@@ -62,7 +62,7 @@ class UserString(Sequence[UserString]):
     def upper(self: _UST) -> _UST: ...
     def zfill(self: _UST, width: int) -> _UST: ...
 
-class MutableString(UserString, MutableSequence[MutableString]):  # type: ignore
+class MutableString(UserString, MutableSequence[MutableString]):
     @overload
     def __getitem__(self: _MST, i: int) -> _MST: ...
     @overload

stdlib/2/__builtin__.pyi

@@ -11,12 +11,17 @@ from typing import (
 )
 from abc import abstractmethod, ABCMeta
 from ast import mod, AST
-from types import TracebackType, CodeType, ModuleType
+from types import TracebackType, CodeType
 import sys
 
 if sys.version_info >= (3,):
     from typing import SupportsBytes, SupportsRound
 
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
 _T = TypeVar('_T')
 _T_co = TypeVar('_T_co', covariant=True)
 _KT = TypeVar('_KT')
@@ -29,6 +34,9 @@ _T4 = TypeVar('_T4')
 _T5 = TypeVar('_T5')
 _TT = TypeVar('_TT', bound='type')
 
+class _SupportsIndex(Protocol):
+    def __index__(self) -> int: ...
+
 class object:
     __doc__: Optional[str]
     __dict__: Dict[str, Any]
@@ -129,10 +137,12 @@ class super(object):
 
 class int:
     @overload
-    def __init__(self, x: Union[Text, bytes, SupportsInt] = ...) -> None: ...
+    def __init__(self, x: Union[Text, bytes, SupportsInt, _SupportsIndex] = ...) -> None: ...
     @overload
     def __init__(self, x: Union[Text, bytes, bytearray], base: int) -> None: ...
 
+    if sys.version_info >= (3, 8):
+        def as_integer_ratio(self) -> Tuple[int, Literal[1]]: ...
     @property
     def real(self) -> int: ...
     @property
@@ -209,7 +219,7 @@ class int:
     def __index__(self) -> int: ...
 
 class float:
-    def __init__(self, x: Union[SupportsFloat, Text, bytes, bytearray] = ...) -> None: ...
+    def __init__(self, x: Union[SupportsFloat, _SupportsIndex, Text, bytes, bytearray] = ...) -> None: ...
     def as_integer_ratio(self) -> Tuple[int, int]: ...
     def hex(self) -> str: ...
     def is_integer(self) -> bool: ...
@@ -271,11 +281,9 @@ class float:
 
 class complex:
     @overload
-    def __init__(self, re: float = ..., im: float = ...) -> None: ...
-    @overload
-    def __init__(self, s: str) -> None: ...
+    def __init__(self, real: float = ..., imag: float = ...) -> None: ...
     @overload
-    def __init__(self, s: SupportsComplex) -> None: ...
+    def __init__(self, real: Union[str, SupportsComplex, _SupportsIndex]) -> None: ...
 
     @property
     def real(self) -> float: ...
@@ -804,12 +812,12 @@ class memoryview(Sized, Container[_mv_container_type]):
     def __iter__(self) -> Iterator[_mv_container_type]: ...
     def __len__(self) -> int: ...
 
+    @overload
+    def __setitem__(self, s: slice, o: memoryview) -> None: ...
     @overload
     def __setitem__(self, i: int, o: bytes) -> None: ...
     @overload
     def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ...
-    @overload
-    def __setitem__(self, s: slice, o: memoryview) -> None: ...
 
     def tobytes(self) -> bytes: ...
     def tolist(self) -> List[int]: ...
@@ -987,6 +995,8 @@ class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
     def __setitem__(self, k: _KT, v: _VT) -> None: ...
     def __delitem__(self, v: _KT) -> None: ...
     def __iter__(self) -> Iterator[_KT]: ...
+    if sys.version_info >= (3, 8):
+        def __reversed__(self) -> Iterator[_KT]: ...
     def __str__(self) -> str: ...
     __hash__: None  # type: ignore
 
@@ -1117,8 +1127,6 @@ if sys.version_info < (3,):
 if sys.version_info >= (3,):
     def ascii(__o: object) -> str: ...
 
-class _SupportsIndex(Protocol):
-    def __index__(self) -> int: ...
 def bin(__number: Union[int, _SupportsIndex]) -> str: ...
 
 if sys.version_info >= (3, 7):
@@ -1160,20 +1168,15 @@ if sys.version_info >= (3,):
     def filter(__function: Callable[[_T], Any], __iterable: Iterable[_T]) -> Iterator[_T]: ...
 else:
     @overload
-    def filter(__function: Callable[[AnyStr], Any],  # type: ignore
-               __iterable: AnyStr) -> AnyStr: ...
+    def filter(__function: Callable[[AnyStr], Any], __iterable: AnyStr) -> AnyStr: ...  # type: ignore
     @overload
-    def filter(__function: None,  # type: ignore
-               __iterable: Tuple[Optional[_T], ...]) -> Tuple[_T, ...]: ...
+    def filter(__function: None, __iterable: Tuple[Optional[_T], ...]) -> Tuple[_T, ...]: ...  # type: ignore
     @overload
-    def filter(__function: Callable[[_T], Any],  # type: ignore
-               __iterable: Tuple[_T, ...]) -> Tuple[_T, ...]: ...
+    def filter(__function: Callable[[_T], Any], __iterable: Tuple[_T, ...]) -> Tuple[_T, ...]: ...  # type: ignore
     @overload
-    def filter(__function: None,
-               __iterable: Iterable[Optional[_T]]) -> List[_T]: ...
+    def filter(__function: None, __iterable: Iterable[Optional[_T]]) -> List[_T]: ...
     @overload
-    def filter(__function: Callable[[_T], Any],
-               __iterable: Iterable[_T]) -> List[_T]: ...
+    def filter(__function: Callable[[_T], Any], __iterable: Iterable[_T]) -> List[_T]: ...
 def format(__o: object, __format_spec: str = ...) -> str: ...  # TODO unicode
 def getattr(__o: Any, name: Text, __default: Any = ...) -> Any: ...
 def globals() -> Dict[str, Any]: ...
@@ -1193,7 +1196,7 @@ def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ...
 @overload
 def iter(__function: Callable[[], Optional[_T]], __sentinel: None) -> Iterator[_T]: ...
 @overload
-def iter(__function: Callable[[], Any], __sentinel: Any) -> Iterator[Any]: ...
+def iter(__function: Callable[[], _T], __sentinel: Any) -> Iterator[_T]: ...
 def isinstance(__o: object, __t: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ...
 def issubclass(__cls: type, __classinfo: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ...
 def len(__o: Sized) -> int: ...
@@ -1383,7 +1386,7 @@ if sys.version_info >= (3,):
     @overload
     def round(number: SupportsRound[_T]) -> int: ...
     @overload
-    def round(number: SupportsRound[_T], ndigits: None) -> int: ...  # type: ignore
+    def round(number: SupportsRound[_T], ndigits: None) -> int: ...
     @overload
     def round(number: SupportsRound[_T], ndigits: int) -> _T: ...
 else:
@@ -1452,7 +1455,7 @@ else:
 def __import__(name: Text, globals: Optional[Mapping[str, Any]] = ...,
                locals: Optional[Mapping[str, Any]] = ...,
                fromlist: Sequence[str] = ...,
-               level: int = ...) -> ModuleType: ...
+               level: int = ...) -> Any: ...
 
 # Actually the type of Ellipsis is <type 'ellipsis'>, but since it's
 # not exposed anywhere under that name, we make it private here.

stdlib/2/_collections.pyi

@@ -23,18 +23,14 @@ class deque(Generic[_T]):
     def count(self, x: Any) -> int: ...
     def extend(self, iterable: Iterator[_T]) -> None: ...
     def extendleft(self, iterable: Iterator[_T]) -> None: ...
-    def pop(self) -> _T:
-        raise IndexError()
-    def popleft(self) -> _T:
-        raise IndexError()
-    def remove(self, value: _T) -> None:
-        raise IndexError()
+    def pop(self) -> _T: ...
+    def popleft(self) -> _T: ...
+    def remove(self, value: _T) -> None: ...
     def reverse(self) -> None: ...
     def rotate(self, n: int = ...) -> None: ...
     def __contains__(self, o: Any) -> bool: ...
     def __copy__(self) -> deque[_T]: ...
-    def __getitem__(self, i: int) -> _T:
-        raise IndexError()
+    def __getitem__(self, i: int) -> _T: ...
     def __iadd__(self, other: deque[_T2]) -> deque[Union[_T, _T2]]: ...
     def __iter__(self) -> Iterator[_T]: ...
     def __len__(self) -> int: ...

stdlib/2/_hotshot.pyi

@@ -6,29 +6,19 @@
 from typing import Any, List, Tuple, Dict, Generic
 
 def coverage(a: str) -> Any: ...
-
-def logreader(a: str) -> LogReaderType:
-    raise IOError()
-    raise RuntimeError()
-
-def profiler(a: str, *args, **kwargs) -> Any:
-    raise IOError()
-
+def logreader(a: str) -> LogReaderType: ...
+def profiler(a: str, *args, **kwargs) -> Any: ...
 def resolution() -> Tuple[Any, ...]: ...
 
-
 class LogReaderType(object):
     def close(self) -> None: ...
-    def fileno(self) -> int:
-        raise ValueError()
+    def fileno(self) -> int: ...
 
 class ProfilerType(object):
     def addinfo(self, a: str, b: str) -> None: ...
     def close(self) -> None: ...
-    def fileno(self) -> int:
-        raise ValueError()
+    def fileno(self) -> int: ...
     def runcall(self, *args, **kwargs) -> Any: ...
-    def runcode(self, a, b, *args, **kwargs) -> Any:
-        raise TypeError()
+    def runcode(self, a, b, *args, **kwargs) -> Any: ...
     def start(self) -> None: ...
     def stop(self) -> None: ...

stdlib/2/_socket.pyi

@@ -256,23 +256,19 @@ class SocketType(object):
     def accept(self) -> Tuple[SocketType, Tuple[Any, ...]]: ...
     def bind(self, address: Tuple[Any, ...]) -> None: ...
     def close(self) -> None: ...
-    def connect(self, address: Tuple[Any, ...]) -> None:
-        raise gaierror
-        raise timeout
+    def connect(self, address: Tuple[Any, ...]) -> None: ...
     def connect_ex(self, address: Tuple[Any, ...]) -> int: ...
     def dup(self) -> SocketType: ...
     def fileno(self) -> int: ...
     def getpeername(self) -> Tuple[Any, ...]: ...
     def getsockname(self) -> Tuple[Any, ...]: ...
     def getsockopt(self, level: int, option: int, buffersize: int = ...) -> str: ...
     def gettimeout(self) -> float: ...
-    def listen(self, backlog: int) -> None:
-        raise error
+    def listen(self, backlog: int) -> None: ...
     def makefile(self, mode: str = ..., buffersize: int = ...) -> IO[Any]: ...
     def recv(self, buffersize: int, flags: int = ...) -> str: ...
     def recv_into(self, buffer: bytearray, nbytes: int = ..., flags: int = ...) -> int: ...
-    def recvfrom(self, buffersize: int, flags: int = ...) -> Tuple[Any, ...]:
-        raise error
+    def recvfrom(self, buffersize: int, flags: int = ...) -> Tuple[Any, ...]: ...
     def recvfrom_into(self, buffer: bytearray, nbytes: int = ...,
                       flags: int = ...) -> int: ...
     def send(self, data: str, flags: int = ...) -> int: ...

stdlib/2/_sre.pyi

@@ -8,19 +8,16 @@ MAXREPEAT: long
 copyright: str
 
 class SRE_Match(object):
-    def start(self, group: int = ...) -> int:
-        raise IndexError()
-    def end(self, group: int = ...) -> int:
-        raise IndexError()
+    def start(self, group: int = ...) -> int: ...
+    def end(self, group: int = ...) -> int: ...
     def expand(self, s: str) -> Any: ...
     @overload
     def group(self) -> str: ...
     @overload
     def group(self, group: int = ...) -> Optional[str]: ...
     def groupdict(self) -> Dict[int, Optional[str]]: ...
     def groups(self) -> Tuple[Optional[str], ...]: ...
-    def span(self) -> Tuple[int, int]:
-        raise IndexError()
+    def span(self) -> Tuple[int, int]: ...
     @property
     def regs(self) -> Tuple[Tuple[int, int], ...]: ...  # undocumented
 
@@ -44,11 +41,14 @@ class SRE_Pattern(object):
     def sub(self, repl: str, string: str, count: int = ...) -> Tuple[Any, ...]: ...
     def subn(self, repl: str, string: str, count: int = ...) -> Tuple[Any, ...]: ...
 
-def compile(pattern: str, flags: int, code: List[int],
-            groups: int = ...,
-            groupindex: Mapping[str, int] = ...,
-            indexgroup: Sequence[int] = ...) -> SRE_Pattern:
-    raise OverflowError()
+def compile(
+    pattern: str,
+    flags: int,
+    code: List[int],
+    groups: int = ...,
+    groupindex: Mapping[str, int] = ...,
+    indexgroup: Sequence[int] = ...,
+) -> SRE_Pattern: ...
 
 def getcodesize() -> int: ...
 

stdlib/2/_threading_local.pyi

@@ -1,7 +1,5 @@
 # Source: https://hg.python.org/cpython/file/2.7/Lib/_threading_local.py
-from typing import Any, List
-
-__all__: List[str]
+from typing import Any
 
 class _localbase(object): ...
 

stdlib/2/functools.pyi

@@ -4,7 +4,6 @@
 
 from abc import ABCMeta, abstractmethod
 from typing import Any, Callable, Generic, Dict, Iterable, Optional, Sequence, Tuple, TypeVar, overload
-from collections import namedtuple
 
 _AnyCallable = Callable[..., Any]
 

stdlib/2/heapq.pyi

@@ -7,12 +7,10 @@ class _Sortable(Protocol):
 
 def cmp_lt(x, y) -> bool: ...
 def heappush(heap: List[_T], item: _T) -> None: ...
-def heappop(heap: List[_T]) -> _T:
-    raise IndexError()  # if heap is empty
+def heappop(heap: List[_T]) -> _T: ...
 def heappushpop(heap: List[_T], item: _T) -> _T: ...
 def heapify(x: List[_T]) -> None: ...
-def heapreplace(heap: List[_T], item: _T) -> _T:
-    raise IndexError()  # if heap is empty
+def heapreplace(heap: List[_T], item: _T) -> _T: ...
 def merge(*iterables: Iterable[_T]) -> Iterable[_T]: ...
 def nlargest(n: int, iterable: Iterable[_T],
              key: Optional[Callable[[_T], _Sortable]] = ...) -> List[_T]: ...