Fixing flake8 E261 errors

.flake8

@@ -13,7 +13,6 @@
 ignore = F401, F811, E301, E302, E305, E501, E701, E704
 
 # Errors that we need to fix before enabling flake8 by default:
-#  3097 E261 at least 2 spaces before inline comment
 #   921 F821 undefined name
 #   221 E128 continuation line under-indented for visual indent
 #   213 E231 missing whitespace after , or :

stdlib/2/ConfigParser.pyi

@@ -1,11 +1,11 @@
 from typing import Any, Tuple, IO
 
-__all__ = ... # type: list[str]
-DEFAULTSECT = ... # type: str
-MAX_INTERPOLATION_DEPTH = ... # type: int
+__all__ = ...  # type: list[str]
+DEFAULTSECT = ...  # type: str
+MAX_INTERPOLATION_DEPTH = ...  # type: int
 
 class Error(Exception):
-    message = ... # type: Any
+    message = ...  # type: Any
     def __init__(self, msg: str = ...) -> None: ...
     def _get_message(self) -> None: ...
     def _set_message(self, value: str) -> None: ...
@@ -13,26 +13,26 @@ class Error(Exception):
     def __str__(self) -> str: ...
 
 class NoSectionError(Error):
-    section = ... # type: str
+    section = ...  # type: str
     def __init__(self, section: str) -> None: ...
 
 class DuplicateSectionError(Error):
-    section = ... # type: str
+    section = ...  # type: str
     def __init__(self, section: str) -> None: ...
 
 class NoOptionError(Error):
-    section = ... # type: str
-    option = ... # type: str
+    section = ...  # type: str
+    option = ...  # type: str
     def __init__(self, option: str, section: str) -> None: ...
 
 class InterpolationError(Error):
-    section = ... # type: str
-    option = ... # type: str
-    msg = ... # type: str
+    section = ...  # type: str
+    option = ...  # type: str
+    msg = ...  # type: str
     def __init__(self, option: str, section: str, msg: str) -> None: ...
 
 class InterpolationMissingOptionError(InterpolationError):
-    reference = ... # type: str
+    reference = ...  # type: str
     def __init__(self, option: str, section: str, rawval: str, reference: str) -> None: ...
 
 class InterpolationSyntaxError(InterpolationError): ...
@@ -41,25 +41,25 @@ class InterpolationDepthError(InterpolationError):
     def __init__(self, option: str, section: str, rawval: str) -> None: ...
 
 class ParsingError(Error):
-    filename = ... # type: str
-    errors = ... # type: list[Tuple[Any,Any]]
+    filename = ...  # type: str
+    errors = ...  # type: list[Tuple[Any,Any]]
     def __init__(self, filename: str) -> None: ...
     def append(self, lineno: Any, line: Any) -> None: ...
 
 class MissingSectionHeaderError(ParsingError):
-    lineno = ... # type: Any
-    line = ... # type: Any
+    lineno = ...  # type: Any
+    line = ...  # type: Any
     def __init__(self, filename: str, lineno: Any, line: Any) -> None: ...
 
 
 class RawConfigParser:
-    _dict = ... # type: Any
-    _sections = ... # type: dict
-    _defaults = ... # type: dict
-    _optcre = ... # type: Any
-    SECTCRE = ... # type: Any
-    OPTCRE = ... # type: Any
-    OPTCRE_NV = ... # type: Any
+    _dict = ...  # type: Any
+    _sections = ...  # type: dict
+    _defaults = ...  # type: dict
+    _optcre = ...  # type: Any
+    SECTCRE = ...  # type: Any
+    OPTCRE = ...  # type: Any
+    OPTCRE_NV = ...  # type: Any
     def __init__(self, defaults: dict[Any,Any] = ..., dict_type: Any = ..., allow_no_value: bool = ...) -> None: ...
     def defaults(self) -> dict[Any,Any]: ...
     def sections(self) -> list[str]: ...
@@ -73,7 +73,7 @@ class RawConfigParser:
     def _get(self, section: str, conv: type, option: str) -> Any: ...
     def getint(self, section: str, option: str) -> int: ...
     def getfloat(self, section: str, option: str) -> float: ...
-    _boolean_states = ... # type: dict[str,bool]
+    _boolean_states = ...  # type: dict[str,bool]
     def getboolean(self, section: str, option: str) -> bool: ...
     def optionxform(self, optionstr: str) -> str: ...
     def has_option(self, section: str, option: str) -> bool: ...
@@ -84,13 +84,13 @@ class RawConfigParser:
     def _read(self, fp: file, fpname: str) -> None: ...
 
 class ConfigParser(RawConfigParser):
-    _KEYCRE = ... # type: Any
+    _KEYCRE = ...  # type: Any
     def get(self, section: str, option: str, raw: bool = ..., vars: dict = ...) -> Any: ...
     def items(self, section: str, raw: bool = ..., vars: dict = ...) -> list[Tuple[str,Any]]: ...
     def _interpolate(self, section: str, option: str, rawval: Any, vars: Any) -> str: ...
     def _interpolation_replace(self, match: Any) -> str: ...
 
 class SafeConfigParser(ConfigParser):
-    _interpvar_re = ... # type: Any
+    _interpvar_re = ...  # type: Any
     def _interpolate(self, section: str, option: str, rawval: Any, vars: Any) -> str: ...
     def _interpolate_some(self, option: str, accum: list, rest: str, section: str, map: dict, depth: int) -> None: ...

stdlib/2/Cookie.pyi

@@ -7,12 +7,12 @@ from typing import Any
 class CookieError(Exception): ...
 
 class Morsel(dict):
-    key = ... # type: Any
+    key = ...  # type: Any
     def __init__(self): ...
     def __setitem__(self, K, V): ...
     def isReservedKey(self, K): ...
-    value = ... # type: Any
-    coded_value = ... # type: Any
+    value = ...  # type: Any
+    coded_value = ...  # type: Any
     def set(self, key, val, coded_val, LegalChars=..., idmap=..., translate=...): ...
     def output(self, attrs=None, header=...): ...
     def js_output(self, attrs=None): ...
@@ -41,4 +41,4 @@ class SmartCookie(BaseCookie):
     def value_decode(self, val): ...
     def value_encode(self, val): ...
 
-Cookie = ... # type: Any
+Cookie = ...  # type: Any

stdlib/2/Queue.pyi

@@ -8,12 +8,12 @@ class Empty(Exception): ...
 class Full(Exception): ...
 
 class Queue(Generic[_T]):
-    maxsize = ... # type: Any
-    mutex = ... # type: Any
-    not_empty = ... # type: Any
-    not_full = ... # type: Any
-    all_tasks_done = ... # type: Any
-    unfinished_tasks = ... # type: Any
+    maxsize = ...  # type: Any
+    mutex = ...  # type: Any
+    not_empty = ...  # type: Any
+    not_full = ...  # type: Any
+    all_tasks_done = ...  # type: Any
+    unfinished_tasks = ...  # type: Any
     def __init__(self, maxsize: int = ...) -> None: ...
     def task_done(self) -> None: ...
     def join(self) -> None: ...

stdlib/2/StringIO.pyi

@@ -3,10 +3,10 @@
 from typing import Any, IO, AnyStr, Iterator, Iterable, Generic, List
 
 class StringIO(IO[AnyStr], Generic[AnyStr]):
-    closed = ... # type: bool
-    softspace = ... # type: int
-    len = ... # type: int
-    name = ... # type: str
+    closed = ...  # type: bool
+    softspace = ...  # type: int
+    len = ...  # type: int
+    name = ...  # type: str
     def __init__(self, buf: AnyStr = ...) -> None: ...
     def __iter__(self) -> Iterator[AnyStr]: ...
     def next(self) -> AnyStr: ...

stdlib/2/UserDict.pyi

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

stdlib/2/__builtin__.pyi

@@ -808,13 +808,13 @@ class buffer(Sized):
     def __mul__(self, x: int) -> str: ...
 
 class memoryview(Sized, Container[bytes]):
-    format = ... # type: str
-    itemsize = ... # type: int
-    shape = ... # type: Optional[Tuple[int, ...]]
-    strides = ... # type: Optional[Tuple[int, ...]]
-    suboffsets = ... # type: Optional[Tuple[int, ...]]
-    readonly = ... # type: bool
-    ndim = ... # type: int
+    format = ...  # type: str
+    itemsize = ...  # type: int
+    shape = ...  # type: Optional[Tuple[int, ...]]
+    strides = ...  # type: Optional[Tuple[int, ...]]
+    suboffsets = ...  # type: Optional[Tuple[int, ...]]
+    readonly = ...  # type: bool
+    ndim = ...  # type: int
 
     def __init__(self, obj: Union[str, bytearray, buffer, memoryview]) -> None: ...
 

stdlib/2/_ast.pyi

@@ -8,8 +8,8 @@ PyCF_ONLY_AST = ...  # type: int
 identifier = str
 
 class AST:
-    _attributes = ... # type: typing.Tuple[str, ...]
-    _fields = ... # type: typing.Tuple[str, ...]
+    _attributes = ...  # type: typing.Tuple[str, ...]
+    _fields = ...  # type: typing.Tuple[str, ...]
     def __init__(self, *args, **kwargs) -> None: ...
 
 class mod(AST):

stdlib/2/builtins.pyi

@@ -1 +0,0 @@
-__builtin__.pyi

stdlib/2/builtins.pyi

@@ -0,0 +1,944 @@
+# Stubs for builtins (Python 2.7)
+
+# True and False are deliberately omitted because they are keywords in
+# Python 3, and stub files conform to Python 3 syntax.
+
+from typing import (
+    TypeVar, Iterator, Iterable, overload,
+    Sequence, Mapping, Tuple, List, Any, Dict, Callable, Generic, Set,
+    AbstractSet, FrozenSet, Sized, Reversible, SupportsInt, SupportsFloat, SupportsAbs,
+    SupportsRound, IO, BinaryIO, Union, AnyStr, MutableSequence, MutableMapping,
+    MutableSet, ItemsView, KeysView, ValuesView, Optional, Container,
+)
+from abc import abstractmethod, ABCMeta
+
+_T = TypeVar('_T')
+_T_co = TypeVar('_T_co', covariant=True)
+_KT = TypeVar('_KT')
+_VT = TypeVar('_VT')
+_S = TypeVar('_S')
+_T1 = TypeVar('_T1')
+_T2 = TypeVar('_T2')
+_T3 = TypeVar('_T3')
+_T4 = TypeVar('_T4')
+_TT = TypeVar('_TT', bound='type')
+
+class staticmethod: pass   # Special, only valid as a decorator.
+class classmethod: pass  # Special, only valid as a decorator.
+
+class object:
+    __doc__ = ...  # type: Optional[str]
+    __class__ = ...  # type: type
+    __slots__ = ...  # type: Optional[Union[str, unicode, Iterable[Union[str, unicode]]]]
+
+    def __init__(self) -> None: ...
+    def __new__(cls) -> Any: ...
+    def __setattr__(self, name: str, value: Any) -> None: ...
+    def __eq__(self, o: object) -> bool: ...
+    def __ne__(self, o: object) -> bool: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __hash__(self) -> int: ...
+
+class type:
+    __bases__ = ...  # type: Tuple[type, ...]
+    __name__ = ...  # type: str
+    __module__ = ...  # type: str
+    __dict__ = ...  # type: Dict[unicode, Any]
+
+    @overload
+    def __init__(self, o: object) -> None: ...
+    @overload
+    def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ...
+    # TODO: __new__ may have to be special and not a static method.
+    @overload
+    def __new__(cls, o: object) -> type: ...
+    @overload
+    def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ...
+    def __call__(self, *args: Any, **kwds: Any) -> Any: ...
+
+    # Only new-style classes
+    __mro__ = ...  # type: Tuple[type, ...]
+    # Note: the documentation doesnt specify what the return type is, the standard
+    # implementation seems to be returning a list.
+    def mro(self) -> List[type]: ...
+    def __subclasses__(self: _TT) -> List[_TT]: ...
+
+class int(SupportsInt, SupportsFloat, SupportsAbs[int]):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, x: SupportsInt) -> None: ...
+    @overload
+    def __init__(self, x: Union[str, unicode, bytearray], base: int = 10) -> None: ...
+    def bit_length(self) -> int: ...
+
+    def __add__(self, x: int) -> int: ...
+    def __sub__(self, x: int) -> int: ...
+    def __mul__(self, x: int) -> int: ...
+    def __floordiv__(self, x: int) -> int: ...
+    def __div__(self, x: int) -> int: ...
+    def __truediv__(self, x: int) -> float: ...
+    def __mod__(self, x: int) -> int: ...
+    def __radd__(self, x: int) -> int: ...
+    def __rsub__(self, x: int) -> int: ...
+    def __rmul__(self, x: int) -> int: ...
+    def __rfloordiv__(self, x: int) -> int: ...
+    def __rdiv__(self, x: int) -> int: ...
+    def __rtruediv__(self, x: int) -> float: ...
+    def __rmod__(self, x: int) -> int: ...
+    def __pow__(self, x: int) -> Any: ...  # Return type can be int or float, depending on x.
+    def __rpow__(self, x: int) -> Any: ...
+    def __and__(self, n: int) -> int: ...
+    def __or__(self, n: int) -> int: ...
+    def __xor__(self, n: int) -> int: ...
+    def __lshift__(self, n: int) -> int: ...
+    def __rshift__(self, n: int) -> int: ...
+    def __rand__(self, n: int) -> int: ...
+    def __ror__(self, n: int) -> int: ...
+    def __rxor__(self, n: int) -> int: ...
+    def __rlshift__(self, n: int) -> int: ...
+    def __rrshift__(self, n: int) -> int: ...
+    def __neg__(self) -> int: ...
+    def __pos__(self) -> int: ...
+    def __invert__(self) -> int: ...
+
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: int) -> bool: ...
+    def __le__(self, x: int) -> bool: ...
+    def __gt__(self, x: int) -> bool: ...
+    def __ge__(self, x: int) -> bool: ...
+
+    def __str__(self) -> str: ...
+    def __float__(self) -> float: ...
+    def __int__(self) -> int: ...
+    def __abs__(self) -> int: ...
+    def __hash__(self) -> int: ...
+
+class float(SupportsFloat, SupportsInt, SupportsAbs[float]):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, x: SupportsFloat) -> None: ...
+    @overload
+    def __init__(self, x: unicode) -> None: ...
+    @overload
+    def __init__(self, x: bytearray) -> None: ...
+    def as_integer_ratio(self) -> Tuple[int, int]: ...
+    def hex(self) -> str: ...
+    def is_integer(self) -> bool: ...
+    @classmethod
+    def fromhex(cls, s: str) -> float: ...
+
+    def __add__(self, x: float) -> float: ...
+    def __sub__(self, x: float) -> float: ...
+    def __mul__(self, x: float) -> float: ...
+    def __floordiv__(self, x: float) -> float: ...
+    def __div__(self, x: float) -> float: ...
+    def __truediv__(self, x: float) -> float: ...
+    def __mod__(self, x: float) -> float: ...
+    def __pow__(self, x: float) -> float: ...
+    def __radd__(self, x: float) -> float: ...
+    def __rsub__(self, x: float) -> float: ...
+    def __rmul__(self, x: float) -> float: ...
+    def __rfloordiv__(self, x: float) -> float: ...
+    def __rdiv__(self, x: float) -> float: ...
+    def __rtruediv__(self, x: float) -> float: ...
+    def __rmod__(self, x: float) -> float: ...
+    def __rpow__(self, x: float) -> float: ...
+
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: float) -> bool: ...
+    def __le__(self, x: float) -> bool: ...
+    def __gt__(self, x: float) -> bool: ...
+    def __ge__(self, x: float) -> bool: ...
+    def __neg__(self) -> float: ...
+    def __pos__(self) -> float: ...
+
+    def __str__(self) -> str: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __abs__(self) -> float: ...
+    def __hash__(self) -> int: ...
+    def __format__(self, format_spec: AnyStr) -> str: ...
+
+class complex(SupportsAbs[float]):
+    @overload
+    def __init__(self, re: float = 0.0, im: float = 0.0) -> None: ...
+    @overload
+    def __init__(self, s: str) -> None: ...
+
+    @property
+    def real(self) -> float: ...
+    @property
+    def imag(self) -> float: ...
+
+    def conjugate(self) -> complex: ...
+
+    def __add__(self, x: complex) -> complex: ...
+    def __sub__(self, x: complex) -> complex: ...
+    def __mul__(self, x: complex) -> complex: ...
+    def __pow__(self, x: complex) -> complex: ...
+    def __div__(self, x: complex) -> complex: ...
+    def __truediv__(self, x: complex) -> complex: ...
+    def __radd__(self, x: complex) -> complex: ...
+    def __rsub__(self, x: complex) -> complex: ...
+    def __rmul__(self, x: complex) -> complex: ...
+    def __rpow__(self, x: complex) -> complex: ...
+    def __rdiv__(self, x: complex) -> complex: ...
+    def __rtruediv__(self, x: complex) -> complex: ...
+
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __neg__(self) -> complex: ...
+    def __pos__(self) -> complex: ...
+
+    def __str__(self) -> str: ...
+    def __abs__(self) -> float: ...
+    def __hash__(self) -> int: ...
+
+class basestring(metaclass=ABCMeta): ...
+
+class unicode(basestring, Sequence[unicode]):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, o: object) -> None: ...
+    @overload
+    def __init__(self, o: str, encoding: unicode = ..., errors: unicode = ...) -> None: ...
+    def capitalize(self) -> unicode: ...
+    def center(self, width: int, fillchar: unicode = u' ') -> unicode: ...
+    def count(self, x: unicode) -> int: ...
+    def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ...
+    def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...
+    def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]], start: int = 0,
+                 end: int = ...) -> bool: ...
+    def expandtabs(self, tabsize: int = 8) -> unicode: ...
+    def find(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
+    def format(self, *args: Any, **kwargs: Any) -> unicode: ...
+    def format_map(self, map: Mapping[unicode, Any]) -> unicode: ...
+    def index(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
+    def isalnum(self) -> bool: ...
+    def isalpha(self) -> bool: ...
+    def isdecimal(self) -> bool: ...
+    def isdigit(self) -> bool: ...
+    def isidentifier(self) -> bool: ...
+    def islower(self) -> bool: ...
+    def isnumeric(self) -> bool: ...
+    def isprintable(self) -> bool: ...
+    def isspace(self) -> bool: ...
+    def istitle(self) -> bool: ...
+    def isupper(self) -> bool: ...
+    def join(self, iterable: Iterable[unicode]) -> unicode: ...
+    def ljust(self, width: int, fillchar: unicode = u' ') -> unicode: ...
+    def lower(self) -> unicode: ...
+    def lstrip(self, chars: unicode = ...) -> unicode: ...
+    def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+    def replace(self, old: unicode, new: unicode, count: int = ...) -> unicode: ...
+    def rfind(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
+    def rindex(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
+    def rjust(self, width: int, fillchar: unicode = u' ') -> unicode: ...
+    def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+    def rsplit(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
+    def rstrip(self, chars: unicode = ...) -> unicode: ...
+    def split(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
+    def splitlines(self, keepends: bool = ...) -> List[unicode]: ...
+    def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]], start: int = 0,
+                   end: int = ...) -> bool: ...
+    def strip(self, chars: unicode = ...) -> unicode: ...
+    def swapcase(self) -> unicode: ...
+    def title(self) -> unicode: ...
+    def translate(self, table: Union[Dict[int, Any], unicode]) -> unicode: ...
+    def upper(self) -> unicode: ...
+    def zfill(self, width: int) -> unicode: ...
+
+    @overload
+    def __getitem__(self, i: int) -> unicode: ...
+    @overload
+    def __getitem__(self, s: slice) -> unicode: ...
+    def __getslice__(self, start: int, stop: int) -> unicode: ...
+    def __add__(self, s: unicode) -> unicode: ...
+    def __mul__(self, n: int) -> unicode: ...
+    def __mod__(self, x: Any) -> unicode: ...
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: unicode) -> bool: ...
+    def __le__(self, x: unicode) -> bool: ...
+    def __gt__(self, x: unicode) -> bool: ...
+    def __ge__(self, x: unicode) -> bool: ...
+
+    def __len__(self) -> int: ...
+    def __contains__(self, s: object) -> bool: ...
+    def __iter__(self) -> Iterator[unicode]: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __hash__(self) -> int: ...
+
+class str(basestring, Sequence[str]):
+    def __init__(self, object: object) -> None: ...
+    def capitalize(self) -> str: ...
+    def center(self, width: int, fillchar: str = ...) -> str: ...
+    def count(self, x: unicode) -> int: ...
+    def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ...
+    def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...
+    def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]]) -> bool: ...
+    def expandtabs(self, tabsize: int = 8) -> str: ...
+    def find(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
+    def format(self, *args: Any, **kwargs: Any) -> str: ...
+    def index(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
+    def isalnum(self) -> bool: ...
+    def isalpha(self) -> bool: ...
+    def isdigit(self) -> bool: ...
+    def islower(self) -> bool: ...
+    def isspace(self) -> bool: ...
+    def istitle(self) -> bool: ...
+    def isupper(self) -> bool: ...
+    def join(self, iterable: Iterable[AnyStr]) -> AnyStr: ...
+    def ljust(self, width: int, fillchar: str = ...) -> str: ...
+    def lower(self) -> str: ...
+    @overload
+    def lstrip(self, chars: str = ...) -> str: ...
+    @overload
+    def lstrip(self, chars: unicode) -> unicode: ...
+    @overload
+    def partition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...
+    @overload
+    def partition(self, sep: str) -> Tuple[str, str, str]: ...
+    @overload
+    def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+    def replace(self, old: AnyStr, new: AnyStr, count: int = ...) -> AnyStr: ...
+    def rfind(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
+    def rindex(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
+    def rjust(self, width: int, fillchar: str = ...) -> str: ...
+    @overload
+    def rpartition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...
+    @overload
+    def rpartition(self, sep: str) -> Tuple[str, str, str]: ...
+    @overload
+    def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+    @overload
+    def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+    @overload
+    def rsplit(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...
+    @overload
+    def rstrip(self, chars: str = ...) -> str: ...
+    @overload
+    def rstrip(self, chars: unicode) -> unicode: ...
+    @overload
+    def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+    @overload
+    def split(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...
+    def splitlines(self, keepends: bool = ...) -> List[str]: ...
+    def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]]) -> bool: ...
+    @overload
+    def strip(self, chars: str = ...) -> str: ...
+    @overload
+    def strip(self, chars: unicode) -> unicode: ...
+    def swapcase(self) -> str: ...
+    def title(self) -> str: ...
+    def translate(self, table: Optional[AnyStr], deletechars: AnyStr = ...) -> AnyStr: ...
+    def upper(self) -> str: ...
+    def zfill(self, width: int) -> str: ...
+
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __hash__(self) -> int: ...
+    @overload
+    def __getitem__(self, i: int) -> str: ...
+    @overload
+    def __getitem__(self, s: slice) -> str: ...
+    def __getslice__(self, start: int, stop: int) -> str: ...
+    def __add__(self, s: AnyStr) -> AnyStr: ...
+    def __mul__(self, n: int) -> str: ...
+    def __rmul__(self, n: int) -> str: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: unicode) -> bool: ...
+    def __le__(self, x: unicode) -> bool: ...
+    def __gt__(self, x: unicode) -> bool: ...
+    def __ge__(self, x: unicode) -> bool: ...
+    def __mod__(self, x: Any) -> str: ...
+
+class bytearray(MutableSequence[int]):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, x: Union[Iterable[int], str]) -> None: ...
+    @overload
+    def __init__(self, x: unicode, encoding: unicode,
+                 errors: unicode = ...) -> None: ...
+    @overload
+    def __init__(self, length: int) -> None: ...
+    def capitalize(self) -> bytearray: ...
+    def center(self, width: int, fillchar: str = ...) -> bytearray: ...
+    def count(self, x: str) -> int: ...
+    def decode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...
+    def endswith(self, suffix: Union[str, Tuple[str, ...]]) -> bool: ...
+    def expandtabs(self, tabsize: int = 8) -> bytearray: ...
+    def find(self, sub: str, start: int = 0, end: int = ...) -> int: ...
+    def index(self, sub: str, start: int = 0, end: int = ...) -> int: ...
+    def insert(self, index: int, object: int) -> None: ...
+    def isalnum(self) -> bool: ...
+    def isalpha(self) -> bool: ...
+    def isdigit(self) -> bool: ...
+    def islower(self) -> bool: ...
+    def isspace(self) -> bool: ...
+    def istitle(self) -> bool: ...
+    def isupper(self) -> bool: ...
+    def join(self, iterable: Iterable[str]) -> bytearray: ...
+    def ljust(self, width: int, fillchar: str = ...) -> bytearray: ...
+    def lower(self) -> bytearray: ...
+    def lstrip(self, chars: str = ...) -> bytearray: ...
+    def partition(self, sep: str) -> Tuple[bytearray, bytearray, bytearray]: ...
+    def replace(self, old: str, new: str, count: int = ...) -> bytearray: ...
+    def rfind(self, sub: str, start: int = 0, end: int = ...) -> int: ...
+    def rindex(self, sub: str, start: int = 0, end: int = ...) -> int: ...
+    def rjust(self, width: int, fillchar: str = ...) -> bytearray: ...
+    def rpartition(self, sep: str) -> Tuple[bytearray, bytearray, bytearray]: ...
+    def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[bytearray]: ...
+    def rstrip(self, chars: str = ...) -> bytearray: ...
+    def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[bytearray]: ...
+    def splitlines(self, keepends: bool = ...) -> List[bytearray]: ...
+    def startswith(self, prefix: Union[str, Tuple[str, ...]]) -> bool: ...
+    def strip(self, chars: str = ...) -> bytearray: ...
+    def swapcase(self) -> bytearray: ...
+    def title(self) -> bytearray: ...
+    def translate(self, table: str) -> bytearray: ...
+    def upper(self) -> bytearray: ...
+    def zfill(self, width: int) -> bytearray: ...
+    @staticmethod
+    def fromhex(x: str) -> bytearray: ...
+
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[int]: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __hash__(self) -> int: ...
+    @overload
+    def __getitem__(self, i: int) -> int: ...
+    @overload
+    def __getitem__(self, s: slice) -> bytearray: ...
+    def __getslice__(self, start: int, stop: int) -> bytearray: ...
+    @overload
+    def __setitem__(self, i: int, x: int) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, x: Union[Iterable[int], str]) -> None: ...
+    def __setslice__(self, start: int, stop: int, x: Union[Sequence[int], str]) -> None: ...
+    def __delitem__(self, i: Union[int, slice]) -> None: ...
+    def __delslice__(self, start: int, stop: int) -> None: ...
+    def __add__(self, s: str) -> bytearray: ...
+    def __mul__(self, n: int) -> bytearray: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: str) -> bool: ...
+    def __le__(self, x: str) -> bool: ...
+    def __gt__(self, x: str) -> bool: ...
+    def __ge__(self, x: str) -> bool: ...
+
+class bool(int, SupportsInt, SupportsFloat):
+    def __init__(self, o: object = ...) -> None: ...
+
+class slice:
+    start = 0
+    step = 0
+    stop = 0
+    def __init__(self, start: int, stop: int = 0, step: int = 0) -> None: ...
+
+class tuple(Sequence[_T_co], Generic[_T_co]):
+    def __init__(self, iterable: Iterable[_T_co] = ...) -> None: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, x: object) -> bool: ...
+    @overload
+    def __getitem__(self, x: int) -> _T_co: ...
+    @overload
+    def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ...
+    def __iter__(self) -> Iterator[_T_co]: ...
+    def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    def __le__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ...
+    def __mul__(self, n: int) -> Tuple[_T_co, ...]: ...
+    def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ...
+    def count(self, x: Any) -> int: ...
+    def index(self, x: Any) -> int: ...
+
+class function:
+    # TODO name of the class (corresponds to Python 'function' class)
+    __name__ = ...  # type: str
+    __module__ = ...  # type: str
+
+class list(MutableSequence[_T], Generic[_T]):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, iterable: Iterable[_T]) -> None: ...
+    def append(self, object: _T) -> None: ...
+    def extend(self, iterable: Iterable[_T]) -> None: ...
+    def pop(self, index: int = -1) -> _T: ...
+    def index(self, object: _T, start: int = 0, stop: int = ...) -> int: ...
+    def count(self, object: _T) -> int: ...
+    def insert(self, index: int, object: _T) -> None: ...
+    def remove(self, object: _T) -> None: ...
+    def reverse(self) -> None: ...
+    def sort(self, cmp: Callable[[_T, _T], Any] = ..., key: Callable[[_T], Any] = ..., reverse: bool = ...) -> None: ...
+
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __str__(self) -> str: ...
+    def __hash__(self) -> int: ...
+    @overload
+    def __getitem__(self, i: int) -> _T: ...
+    @overload
+    def __getitem__(self, s: slice) -> List[_T]: ...
+    def __getslice__(self, start: int, stop: int) -> List[_T]: ...
+    @overload
+    def __setitem__(self, i: int, o: _T) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
+    def __setslice__(self, start: int, stop: int, o: Sequence[_T]) -> None: ...
+    def __delitem__(self, i: Union[int, slice]) -> None: ...
+    def __delslice__(self, start: int, stop: int) -> None: ...
+    def __add__(self, x: List[_T]) -> List[_T]: ...
+    def __iadd__(self, x: Iterable[_T]) -> List[_T]: ...
+    def __mul__(self, n: int) -> List[_T]: ...
+    def __rmul__(self, n: int) -> List[_T]: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __reversed__(self) -> Iterator[_T]: ...
+    def __gt__(self, x: List[_T]) -> bool: ...
+    def __ge__(self, x: List[_T]) -> bool: ...
+    def __lt__(self, x: List[_T]) -> bool: ...
+    def __le__(self, x: List[_T]) -> bool: ...
+
+class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
+    # NOTE: Keyword arguments are special. If they are used, _KT must include
+    #       str, but we have no way of enforcing it here.
+    @overload
+    def __init__(self, **kwargs: _VT) -> None: ...
+    @overload
+    def __init__(self, map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
+    @overload
+    def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
+
+    def has_key(self, k: _KT) -> bool: ...
+    def clear(self) -> None: ...
+    def copy(self) -> Dict[_KT, _VT]: ...
+    def get(self, k: _KT, default: _VT = None) -> _VT: ...
+    def pop(self, k: _KT, default: _VT = ...) -> _VT: ...
+    def popitem(self) -> Tuple[_KT, _VT]: ...
+    def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ...
+    @overload
+    def update(self, m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
+    def keys(self) -> List[_KT]: ...
+    def values(self) -> List[_VT]: ...
+    def items(self) -> List[Tuple[_KT, _VT]]: ...
+    def iterkeys(self) -> Iterator[_KT]: ...
+    def itervalues(self) -> Iterator[_VT]: ...
+    def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ...
+    def viewkeys(self) -> KeysView[_KT]: ...
+    def viewvalues(self) -> ValuesView[_VT]: ...
+    def viewitems(self) -> ItemsView[_KT, _VT]: ...
+    @staticmethod
+    @overload
+    def fromkeys(seq: Sequence[_T]) -> Dict[_T, Any]: ...  # TODO: Actually a class method (mypy/issues#328)
+    @staticmethod
+    @overload
+    def fromkeys(seq: Sequence[_T], value: _S) -> Dict[_T, _S]: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, k: _KT) -> _VT: ...
+    def __setitem__(self, k: _KT, v: _VT) -> None: ...
+    def __delitem__(self, v: _KT) -> None: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def __str__(self) -> str: ...
+
+class set(MutableSet[_T], Generic[_T]):
+    def __init__(self, iterable: Iterable[_T] = ...) -> None: ...
+    def add(self, element: _T) -> None: ...
+    def clear(self) -> None: ...
+    def copy(self) -> set[_T]: ...
+    def difference(self, *s: Iterable[Any]) -> set[_T]: ...
+    def difference_update(self, *s: Iterable[Any]) -> None: ...
+    def discard(self, element: _T) -> None: ...
+    def intersection(self, *s: Iterable[Any]) -> set[_T]: ...
+    def intersection_update(self, *s: Iterable[Any]) -> None: ...
+    def isdisjoint(self, s: Iterable[Any]) -> bool: ...
+    def issubset(self, s: Iterable[Any]) -> bool: ...
+    def issuperset(self, s: Iterable[Any]) -> bool: ...
+    def pop(self) -> _T: ...
+    def remove(self, element: _T) -> None: ...
+    def symmetric_difference(self, s: Iterable[_T]) -> set[_T]: ...
+    def symmetric_difference_update(self, s: Iterable[_T]) -> None: ...
+    def union(self, *s: Iterable[_T]) -> set[_T]: ...
+    def update(self, *s: Iterable[_T]) -> None: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __str__(self) -> str: ...
+    def __and__(self, s: AbstractSet[Any]) -> set[_T]: ...
+    def __iand__(self, s: AbstractSet[Any]) -> set[_T]: ...
+    def __or__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
+    def __ior__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
+    def __sub__(self, s: AbstractSet[Any]) -> set[_T]: ...
+    def __isub__(self, s: AbstractSet[Any]) -> set[_T]: ...
+    def __xor__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
+    def __ixor__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
+    def __le__(self, s: AbstractSet[Any]) -> bool: ...
+    def __lt__(self, s: AbstractSet[Any]) -> bool: ...
+    def __ge__(self, s: AbstractSet[Any]) -> bool: ...
+    def __gt__(self, s: AbstractSet[Any]) -> bool: ...
+    # TODO more set operations
+
+class frozenset(FrozenSet[_T], Generic[_T]):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, iterable: Iterable[_T]) -> None: ...
+    def copy(self) -> frozenset[_T]: ...
+    def difference(self, *s: Iterable[Any]) -> frozenset[_T]: ...
+    def intersection(self, *s: Iterable[Any]) -> frozenset[_T]: ...
+    def isdisjoint(self, s: Iterable[_T]) -> bool: ...
+    def issubset(self, s: Iterable[Any]) -> bool: ...
+    def issuperset(self, s: Iterable[Any]) -> bool: ...
+    def symmetric_difference(self, s: Iterable[_T]) -> frozenset[_T]: ...
+    def union(self, *s: Iterable[_T]) -> frozenset[_T]: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __str__(self) -> str: ...
+    def __and__(self, s: AbstractSet[_T]) -> frozenset[_T]: ...
+    def __or__(self, s: AbstractSet[_S]) -> frozenset[Union[_T, _S]]: ...
+    def __sub__(self, s: AbstractSet[_T]) -> frozenset[_T]: ...
+    def __xor__(self, s: AbstractSet[_S]) -> frozenset[Union[_T, _S]]: ...
+    def __le__(self, s: AbstractSet[Any]) -> bool: ...
+    def __lt__(self, s: AbstractSet[Any]) -> bool: ...
+    def __ge__(self, s: AbstractSet[Any]) -> bool: ...
+    def __gt__(self, s: AbstractSet[Any]) -> bool: ...
+
+class enumerate(Iterator[Tuple[int, _T]], Generic[_T]):
+    def __init__(self, iterable: Iterable[_T], start: int = 0) -> None: ...
+    def __iter__(self) -> Iterator[Tuple[int, _T]]: ...
+    def next(self) -> Tuple[int, _T]: ...
+    # TODO __getattribute__
+
+class xrange(Sized, Iterable[int], Reversible[int]):
+    @overload
+    def __init__(self, stop: int) -> None: ...
+    @overload
+    def __init__(self, start: int, stop: int, step: int = 1) -> None: ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[int]: ...
+    def __getitem__(self, i: int) -> int: ...
+    def __reversed__(self) -> Iterator[int]: ...
+
+class module:
+    __name__ = ...  # type: str
+    __file__ = ...  # type: str
+    __dict__ = ...  # type: Dict[unicode, Any]
+
+class property:
+    def __init__(self, fget: Callable[[Any], Any] = None,
+                 fset: Callable[[Any, Any], None] = None,
+                 fdel: Callable[[Any], None] = None, doc: str = None) -> None: ...
+    def getter(self, fget: Callable[[Any], Any]) -> property: ...
+    def setter(self, fset: Callable[[Any, Any], None]) -> property: ...
+    def deleter(self, fdel: Callable[[Any], None]) -> property: ...
+    def __get__(self, obj: Any, type: type=None) -> Any: ...
+    def __set__(self, obj: Any, value: Any) -> None: ...
+    def __delete__(self, obj: Any) -> None: ...
+
+long = int
+bytes = str
+
+NotImplemented = ...  # type: Any
+
+def abs(n: SupportsAbs[_T]) -> _T: ...
+def all(i: Iterable) -> bool: ...
+def any(i: Iterable) -> bool: ...
+def bin(number: int) -> str: ...
+def callable(o: object) -> bool: ...
+def chr(code: int) -> str: ...
+def compile(source: Any, filename: unicode, mode: str, flags: int = 0,
+            dont_inherit: int = 0) -> Any: ...
+def delattr(o: Any, name: unicode) -> None: ...
+def dir(o: object = ...) -> List[str]: ...
+@overload
+def divmod(a: int, b: int) -> Tuple[int, int]: ...
+@overload
+def divmod(a: float, b: float) -> Tuple[float, float]: ...
+def exit(code: int = ...) -> None: ...
+@overload
+def filter(function: Callable[[_T], Any],
+           iterable: Iterable[_T]) -> List[_T]: ...
+@overload
+def filter(function: None,
+           iterable: Iterable[Optional[_T]]) -> List[_T]: ...
+def format(o: object, format_spec: str = '') -> str: ...  # TODO unicode
+def getattr(o: Any, name: unicode, default: Any = None) -> Any: ...
+def hasattr(o: Any, name: unicode) -> bool: ...
+def hash(o: object) -> int: ...
+def hex(i: int) -> str: ...  # TODO __index__
+def id(o: object) -> int: ...
+def input(prompt: unicode = ...) -> Any: ...
+def intern(string: str) -> str: ...
+@overload
+def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
+@overload
+def iter(function: Callable[[], _T], sentinel: _T) -> Iterator[_T]: ...
+def isinstance(o: object, t: Union[type, Tuple[type, ...]]) -> bool: ...
+def issubclass(cls: type, classinfo: Union[type, Tuple[type, ...]]) -> bool: ...
+def len(o: Sized) -> int: ...
+@overload
+def map(func: Callable[[_T1], _S], iter1: Iterable[_T1]) -> List[_S]: ...
+@overload
+def map(func: Callable[[_T1, _T2], _S],
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2]) -> List[_S]: ...  # TODO more than two iterables
+@overload
+def max(arg1: _T, arg2: _T, *args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
+@overload
+def max(iterable: Iterable[_T], key: Callable[[_T], Any] = ...) -> _T: ...
+@overload
+def min(arg1: _T, arg2: _T, *args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
+@overload
+def min(iterable: Iterable[_T], key: Callable[[_T], Any] = ...) -> _T: ...
+@overload
+def next(i: Iterator[_T]) -> _T: ...
+@overload
+def next(i: Iterator[_T], default: _T) -> _T: ...
+def oct(i: int) -> str: ...  # TODO __index__
+@overload
+def open(file: str, mode: str = 'r', buffering: int = ...) -> BinaryIO: ...
+@overload
+def open(file: unicode, mode: str = 'r', buffering: int = ...) -> BinaryIO: ...
+@overload
+def open(file: int, mode: str = 'r', buffering: int = ...) -> BinaryIO: ...
+def ord(c: unicode) -> int: ...
+# This is only available after from __future__ import print_function.
+def print(*values: Any, sep: unicode = u' ', end: unicode = u'\n',
+           file: IO[Any] = ...) -> None: ...
+@overload
+def pow(x: int, y: int) -> Any: ...  # The return type can be int or float, depending on y.
+@overload
+def pow(x: int, y: int, z: int) -> Any: ...
+@overload
+def pow(x: float, y: float) -> float: ...
+@overload
+def pow(x: float, y: float, z: float) -> float: ...
+def quit(code: int = ...) -> None: ...
+def range(x: int, y: int = 0, step: int = 1) -> List[int]: ...
+def raw_input(prompt: unicode = ...) -> str: ...
+
+@overload
+def reduce(function: Callable[[_T, _S], _T], iterable: Iterable[_S], initializer: _T) -> _T: ...
+@overload
+def reduce(function: Callable[[_T, _T], _T], iterable: Iterable[_T]) -> _T: ...
+
+def reload(module: Any) -> Any: ...
+@overload
+def reversed(object: Reversible[_T]) -> Iterator[_T]: ...
+@overload
+def reversed(object: Sequence[_T]) -> Iterator[_T]: ...
+def repr(o: object) -> str: ...
+@overload
+def round(number: float) -> float: ...
+@overload
+def round(number: float, ndigits: int) -> float: ...  # Always return a float if given ndigits.
+@overload
+def round(number: SupportsRound[_T]) -> _T: ...
+@overload
+def round(number: SupportsRound[_T], ndigits: int) -> _T: ...
+def setattr(object: Any, name: unicode, value: Any) -> None: ...
+def sorted(iterable: Iterable[_T], *,
+           cmp: Callable[[_T, _T], int] = ...,
+           key: Callable[[_T], Any] = ...,
+           reverse: bool = ...) -> List[_T]: ...
+def sum(iterable: Iterable[_T], start: _T = ...) -> _T: ...
+def unichr(i: int) -> unicode: ...
+def vars(object: Any = ...) -> Dict[str, Any]: ...
+@overload
+def zip(iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ...
+@overload
+def zip(iter1: Iterable[_T1],
+        iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
+@overload
+def zip(iter1: Iterable[_T1], iter2: Iterable[_T2],
+        iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
+@overload
+def zip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],
+        iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2,
+                                           _T3, _T4]]: ...  # TODO more than four iterables
+def __import__(name: unicode,
+               globals: Dict[str, Any] = ...,
+               locals: Dict[str, Any] = ...,
+               fromlist: List[str] = ..., level: int = ...) -> Any: ...
+
+def globals() -> Dict[str, Any]: ...
+def locals() -> Dict[str, Any]: ...
+
+# Actually the type of Ellipsis is <type 'ellipsis'>, but since it's
+# not exposed anywhere under that name, we make it private here.
+class ellipsis: ...
+Ellipsis = ...  # type: ellipsis
+
+# TODO: buffer support is incomplete; e.g. some_string.startswith(some_buffer) doesn't type check.
+AnyBuffer = TypeVar('AnyBuffer', str, unicode, bytearray, buffer)
+
+class buffer(Sized):
+    def __init__(self, object: AnyBuffer, offset: int = ..., size: int = ...) -> None: ...
+    def __add__(self, other: AnyBuffer) -> str: ...
+    def __cmp__(self, other: AnyBuffer) -> bool: ...
+    def __getitem__(self, key: Union[int, slice]) -> str: ...
+    def __getslice__(self, i: int, j: int) -> str: ...
+    def __len__(self) -> int: ...
+    def __mul__(self, x: int) -> str: ...
+
+class memoryview(Sized, Container[bytes]):
+    format = ...  # type: str
+    itemsize = ...  # type: int
+    shape = ...  # type: Optional[Tuple[int, ...]]
+    strides = ...  # type: Optional[Tuple[int, ...]]
+    suboffsets = ...  # type: Optional[Tuple[int, ...]]
+    readonly = ...  # type: bool
+    ndim = ...  # type: int
+
+    def __init__(self, obj: Union[str, bytearray, buffer, memoryview]) -> None: ...
+
+    @overload
+    def __getitem__(self, i: int) -> bytes: ...
+    @overload
+    def __getitem__(self, s: slice) -> memoryview: ...
+
+    def __contains__(self, x: object) -> bool: ...
+    def __iter__(self) -> Iterator[bytes]: ...
+    def __len__(self) -> int: ...
+
+    @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]: ...
+
+class BaseException:
+    args = ...  # type: Tuple[Any, ...]
+    message = ...  # type: str
+    def __init__(self, *args: Any) -> None: ...
+class GeneratorExit(BaseException): ...
+class KeyboardInterrupt(BaseException): ...
+class SystemExit(BaseException):
+    code = 0
+class Exception(BaseException): ...
+class StopIteration(Exception): ...
+class StandardError(Exception): ...
+class ArithmeticError(StandardError): ...
+class BufferError(StandardError): ...
+class EnvironmentError(StandardError):
+    errno = 0
+    strerror = ...  # type: str
+    # TODO can this be unicode?
+    filename = ...  # type: str
+class LookupError(StandardError): ...
+class RuntimeError(StandardError): ...
+class ValueError(StandardError): ...
+class AssertionError(StandardError): ...
+class AttributeError(StandardError): ...
+class EOFError(StandardError): ...
+class FloatingPointError(ArithmeticError): ...
+class IOError(EnvironmentError): ...
+class ImportError(StandardError): ...
+class IndexError(LookupError): ...
+class KeyError(LookupError): ...
+class MemoryError(StandardError): ...
+class NameError(StandardError): ...
+class NotImplementedError(RuntimeError): ...
+class OSError(EnvironmentError): ...
+class WindowsError(OSError):
+    winerror = ...  # type: int
+class OverflowError(ArithmeticError): ...
+class ReferenceError(StandardError): ...
+class SyntaxError(StandardError):
+    msg = ...  # type: str
+    lineno = ...  # type: int
+    offset = ...  # type: int
+    text = ...  # type: str
+class IndentationError(SyntaxError): ...
+class TabError(IndentationError): ...
+class SystemError(StandardError): ...
+class TypeError(StandardError): ...
+class UnboundLocalError(NameError): ...
+class UnicodeError(ValueError): ...
+class UnicodeDecodeError(UnicodeError): ...
+class UnicodeEncodeError(UnicodeError): ...
+class UnicodeTranslateError(UnicodeError): ...
+class ZeroDivisionError(ArithmeticError): ...
+
+class Warning(Exception): ...
+class UserWarning(Warning): ...
+class DeprecationWarning(Warning): ...
+class SyntaxWarning(Warning): ...
+class RuntimeWarning(Warning): ...
+class FutureWarning(Warning): ...
+class PendingDeprecationWarning(Warning): ...
+class ImportWarning(Warning): ...
+class UnicodeWarning(Warning): ...
+class BytesWarning(Warning): ...
+class ResourceWarning(Warning): ...
+
+def eval(s: str, globals: Dict[str, Any] = ..., locals: Dict[str, Any] = ...) -> Any: ...
+def exec(object: str,
+         globals: Dict[str, Any] = None,
+         locals: Dict[str, Any] = None) -> Any: ...  # TODO code object as source
+
+def cmp(x: Any, y: Any) -> int: ...
+
+def execfile(filename: str, globals: Dict[str, Any] = None, locals: Dict[str, Any] = None) -> None: ...
+
+class file(BinaryIO):
+    @overload
+    def __init__(self, file: str, mode: str = 'r', buffering: int = ...) -> None: ...
+    @overload
+    def __init__(self, file: unicode, mode: str = 'r', buffering: int = ...) -> None: ...
+    @overload
+    def __init__(self, file: int, mode: str = 'r', buffering: int = ...) -> None: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def read(self, n: int = ...) -> str: ...
+    def __enter__(self) -> BinaryIO: ...
+    def __exit__(self, t: type = None, exc: BaseException = None, tb: Any = None) -> bool: ...
+    def flush(self) -> None: ...
+    def fileno(self) -> int: ...
+    def isatty(self) -> bool: ...
+    def close(self) -> None: ...
+
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def seekable(self) -> bool: ...
+    def seek(self, offset: int, whence: int = ...) -> None: ...
+    def tell(self) -> int: ...
+    def readline(self, limit: int = ...) -> str: ...
+    def readlines(self, hint: int = ...) -> List[str]: ...
+    def write(self, data: str) -> None: ...
+    def writelines(self, data: Iterable[str]) -> None: ...
+    def truncate(self, pos: int = ...) -> int: ...
+
+# Very old builtins
+def apply(func: Callable[..., _T], args: Sequence[Any] = None, kwds: Mapping[str, Any] = None) -> _T: ...
+_N = TypeVar('_N', bool, int, float, complex)
+def coerce(x: _N, y: _N) -> Tuple[_N, _N]: ...

stdlib/2/codecs.pyi

@@ -24,12 +24,12 @@ _encoded = str
 
 # TODO: It is not possible to specify these signatures correctly, because
 # they have an optional positional or keyword argument for errors=.
-_encode_type = Callable[[_decoded], _encoded] # signature of Codec().encode
-_decode_type = Callable[[_encoded], _decoded] # signature of Codec().decode
-_stream_reader_type = Callable[[BinaryIO], 'StreamReader'] # signature of StreamReader __init__
-_stream_writer_type = Callable[[BinaryIO], 'StreamWriter'] # signature of StreamWriter __init__
-_incremental_encoder_type = Callable[[], 'IncrementalEncoder'] # signature of IncrementalEncoder __init__
-_incremental_decode_type = Callable[[], 'IncrementalDecoder'] # signature of IncrementalDecoder __init__
+_encode_type = Callable[[_decoded], _encoded]  # signature of Codec().encode
+_decode_type = Callable[[_encoded], _decoded]  # signature of Codec().decode
+_stream_reader_type = Callable[[BinaryIO], 'StreamReader']  # signature of StreamReader __init__
+_stream_writer_type = Callable[[BinaryIO], 'StreamWriter']  # signature of StreamWriter __init__
+_incremental_encoder_type = Callable[[], 'IncrementalEncoder']  # signature of IncrementalEncoder __init__
+_incremental_decode_type = Callable[[], 'IncrementalDecoder']  # signature of IncrementalDecoder __init__
 
 
 def encode(obj: _decoded, encoding: str = ..., errors: str = ...) -> _encoded:

stdlib/2/decimal.pyi

@@ -10,7 +10,7 @@ _ComparableNum = Union[Decimal, int, float]
 
 DecimalTuple = NamedTuple('DecimalTuple',
                           [('sign', int),
-                           ('digits', Sequence[int]), # TODO: Use Tuple[int, ...]
+                           ('digits', Sequence[int]),  # TODO: Use Tuple[int, ...]
                            ('exponent', int)])
 
 ROUND_DOWN = ...  # type: str

stdlib/2/email/_parseaddr.pyi

@@ -10,15 +10,15 @@ def mktime_tz(data): ...
 def quote(str): ...
 
 class AddrlistClass:
-    specials = ... # type: Any
-    pos = ... # type: Any
-    LWS = ... # type: Any
-    CR = ... # type: Any
-    FWS = ... # type: Any
-    atomends = ... # type: Any
-    phraseends = ... # type: Any
-    field = ... # type: Any
-    commentlist = ... # type: Any
+    specials = ...  # type: Any
+    pos = ...  # type: Any
+    LWS = ...  # type: Any
+    CR = ...  # type: Any
+    FWS = ...  # type: Any
+    atomends = ...  # type: Any
+    phraseends = ...  # type: Any
+    field = ...  # type: Any
+    commentlist = ...  # type: Any
     def __init__(self, field): ...
     def gotonext(self): ...
     def getaddrlist(self): ...
@@ -34,7 +34,7 @@ class AddrlistClass:
     def getphraselist(self): ...
 
 class AddressList(AddrlistClass):
-    addresslist = ... # type: Any
+    addresslist = ...  # type: Any
     def __init__(self, field): ...
     def __len__(self): ...
     def __add__(self, other): ...

stdlib/2/functools.pyi

@@ -17,8 +17,8 @@ def reduce(function: Callable[[_T, _T], _T],
 def reduce(function: Callable[[_T, _S], _T],
            sequence: Iterable[_S], initial: _T) -> _T: ...
 
-WRAPPER_ASSIGNMENTS = ... # type: Sequence[str]
-WRAPPER_UPDATES = ... # type: Sequence[str]
+WRAPPER_ASSIGNMENTS = ...  # type: Sequence[str]
+WRAPPER_UPDATES = ...  # type: Sequence[str]
 
 def update_wrapper(wrapper: _AnyCallable, wrapped: _AnyCallable, assigned: Sequence[str] = ...,
                    updated: Sequence[str] = ...) -> None: ...

stdlib/2/gc.pyi

@@ -18,12 +18,12 @@ def get_referrers(*objs: Any) -> List[Any]: ...
 def get_referents(*objs: Any) -> List[Any]: ...
 def is_tracked(obj: Any) -> bool: ...
 
-garbage = ... # type: List[Any]
+garbage = ...  # type: List[Any]
 
-DEBUG_STATS = ... # type: int
-DEBUG_COLLECTABLE = ... # type: int
-DEBUG_UNCOLLECTABLE = ... # type: int
-DEBUG_INSTANCES = ... # type: int
-DEBUG_OBJECTS = ... # type: int
-DEBUG_SAVEALL = ... # type: int
-DEBUG_LEAK = ... # type: int
+DEBUG_STATS = ...  # type: int
+DEBUG_COLLECTABLE = ...  # type: int
+DEBUG_UNCOLLECTABLE = ...  # type: int
+DEBUG_INSTANCES = ...  # type: int
+DEBUG_OBJECTS = ...  # type: int
+DEBUG_SAVEALL = ...  # type: int
+DEBUG_LEAK = ...  # type: int

stdlib/2/getopt.pyi

@@ -1,8 +1,8 @@
 from typing import List, Tuple
 
 class GetoptError(Exception):
-    opt = ... # type: str
-    msg = ... # type: str
+    opt = ...  # type: str
+    msg = ...  # type: str
     def __init__(self, msg: str, opt: str=...) -> None: ...
     def __str__(self) -> str: ...
 

stdlib/2/gzip.pyi

@@ -6,24 +6,24 @@ from typing import Any, IO
 import io
 
 class GzipFile(io.BufferedIOBase):
-    myfileobj = ... # type: Any
-    max_read_chunk = ... # type: Any
-    mode = ... # type: Any
-    extrabuf = ... # type: Any
-    extrasize = ... # type: Any
-    extrastart = ... # type: Any
-    name = ... # type: Any
-    min_readsize = ... # type: Any
-    compress = ... # type: Any
-    fileobj = ... # type: Any
-    offset = ... # type: Any
-    mtime = ... # type: Any
+    myfileobj = ...  # type: Any
+    max_read_chunk = ...  # type: Any
+    mode = ...  # type: Any
+    extrabuf = ...  # type: Any
+    extrasize = ...  # type: Any
+    extrastart = ...  # type: Any
+    name = ...  # type: Any
+    min_readsize = ...  # type: Any
+    compress = ...  # type: Any
+    fileobj = ...  # type: Any
+    offset = ...  # type: Any
+    mtime = ...  # type: Any
     def __init__(self, filename: str = ..., mode: str = ..., compresslevel: int = ...,
                  fileobj: IO[str] = ..., mtime: float = ...) -> None: ...
     @property
     def filename(self): ...
-    size = ... # type: Any
-    crc = ... # type: Any
+    size = ...  # type: Any
+    crc = ...  # type: Any
     def write(self, data): ...
     def read(self, size=...): ...
     @property

stdlib/2/htmlentitydefs.pyi

@@ -4,6 +4,6 @@
 
 from typing import Any, Mapping
 
-name2codepoint = ... # type: Mapping[str, int]
-codepoint2name = ... # type: Mapping[int, str]
-entitydefs = ... # type: Mapping[str, str]
+name2codepoint = ...  # type: Mapping[str, int]
+codepoint2name = ...  # type: Mapping[int, str]
+entitydefs = ...  # type: Mapping[str, str]

stdlib/2/httplib.pyi

@@ -9,25 +9,25 @@ import mimetools
 class HTTPMessage(mimetools.Message):
     def addheader(self, key: str, value: str) -> None: ...
     def addcontinue(self, key: str, more: str) -> None: ...
-    dict = ... # type: Dict[str, str]
-    unixfrom = ... # type: str
-    headers = ... # type: Any
-    status = ... # type: str
-    seekable = ... # type: bool
+    dict = ...  # type: Dict[str, str]
+    unixfrom = ...  # type: str
+    headers = ...  # type: Any
+    status = ...  # type: str
+    seekable = ...  # type: bool
     def readheaders(self) -> None: ...
 
 class HTTPResponse:
-    fp = ... # type: Any
-    debuglevel = ... # type: Any
-    strict = ... # type: Any
-    msg = ... # type: Any
-    version = ... # type: Any
-    status = ... # type: Any
-    reason = ... # type: Any
-    chunked = ... # type: Any
-    chunk_left = ... # type: Any
-    length = ... # type: Any
-    will_close = ... # type: Any
+    fp = ...  # type: Any
+    debuglevel = ...  # type: Any
+    strict = ...  # type: Any
+    msg = ...  # type: Any
+    version = ...  # type: Any
+    status = ...  # type: Any
+    reason = ...  # type: Any
+    chunked = ...  # type: Any
+    chunk_left = ...  # type: Any
+    length = ...  # type: Any
+    will_close = ...  # type: Any
     def __init__(self, sock, debuglevel=0, strict=0, method=None, buffering:bool=...) -> None: ...
     def begin(self): ...
     def close(self): ...
@@ -38,14 +38,14 @@ class HTTPResponse:
     def getheaders(self): ...
 
 class HTTPConnection:
-    response_class = ... # type: Any
-    default_port = ... # type: Any
-    auto_open = ... # type: Any
-    debuglevel = ... # type: Any
-    strict = ... # type: Any
-    timeout = ... # type: Any
-    source_address = ... # type: Any
-    sock = ... # type: Any
+    response_class = ...  # type: Any
+    default_port = ...  # type: Any
+    auto_open = ...  # type: Any
+    debuglevel = ...  # type: Any
+    strict = ...  # type: Any
+    timeout = ...  # type: Any
+    source_address = ...  # type: Any
+    sock = ...  # type: Any
     def __init__(self, host, port=None, strict=None, timeout=..., source_address=None) -> None: ...
     def set_tunnel(self, host, port=None, headers=None): ...
     def set_debuglevel(self, level): ...
@@ -59,26 +59,26 @@ class HTTPConnection:
     def getresponse(self, buffering:bool=...): ...
 
 class HTTP:
-    debuglevel = ... # type: Any
+    debuglevel = ...  # type: Any
     def __init__(self, host:str=..., port=None, strict=None) -> None: ...
     def connect(self, host=None, port=None): ...
     def getfile(self): ...
-    file = ... # type: Any
-    headers = ... # type: Any
+    file = ...  # type: Any
+    headers = ...  # type: Any
     def getreply(self, buffering:bool=...): ...
     def close(self): ...
 
 class HTTPSConnection(HTTPConnection):
-    default_port = ... # type: Any
-    key_file = ... # type: Any
-    cert_file = ... # type: Any
+    default_port = ...  # type: Any
+    key_file = ...  # type: Any
+    cert_file = ...  # type: Any
     def __init__(self, host, port=None, key_file=None, cert_file=None, strict=None, timeout=..., source_address=None, context=None) -> None: ...
-    sock = ... # type: Any
+    sock = ...  # type: Any
     def connect(self): ...
 
 class HTTPS(HTTP):
-    key_file = ... # type: Any
-    cert_file = ... # type: Any
+    key_file = ...  # type: Any
+    cert_file = ...  # type: Any
     def __init__(self, host:str=..., port=None, key_file=None, cert_file=None, strict=None, context=None) -> None: ...
 
 class HTTPException(Exception): ...
@@ -86,17 +86,17 @@ class NotConnected(HTTPException): ...
 class InvalidURL(HTTPException): ...
 
 class UnknownProtocol(HTTPException):
-    args = ... # type: Any
-    version = ... # type: Any
+    args = ...  # type: Any
+    version = ...  # type: Any
     def __init__(self, version) -> None: ...
 
 class UnknownTransferEncoding(HTTPException): ...
 class UnimplementedFileMode(HTTPException): ...
 
 class IncompleteRead(HTTPException):
-    args = ... # type: Any
-    partial = ... # type: Any
-    expected = ... # type: Any
+    args = ...  # type: Any
+    partial = ...  # type: Any
+    expected = ...  # type: Any
     def __init__(self, partial, expected=None) -> None: ...
 
 class ImproperConnectionState(HTTPException): ...
@@ -105,14 +105,14 @@ class CannotSendHeader(ImproperConnectionState): ...
 class ResponseNotReady(ImproperConnectionState): ...
 
 class BadStatusLine(HTTPException):
-    args = ... # type: Any
-    line = ... # type: Any
+    args = ...  # type: Any
+    line = ...  # type: Any
     def __init__(self, line) -> None: ...
 
 class LineTooLong(HTTPException):
     def __init__(self, line_type) -> None: ...
 
-error = ... # type: Any
+error = ...  # type: Any
 
 class LineAndFileWrapper:
     def __init__(self, line, file) -> None: ...
@@ -123,67 +123,67 @@ class LineAndFileWrapper:
 
 # Constants
 
-responses = ... # type: Dict[int, str]
+responses = ...  # type: Dict[int, str]
 
-HTTP_PORT = ... # type: int
-HTTPS_PORT = ... # type: int
+HTTP_PORT = ...  # type: int
+HTTPS_PORT = ...  # type: int
 
 # status codes
 # informational
-CONTINUE = ... # type: int
-SWITCHING_PROTOCOLS = ... # type: int
-PROCESSING = ... # type: int
+CONTINUE = ...  # type: int
+SWITCHING_PROTOCOLS = ...  # type: int
+PROCESSING = ...  # type: int
 
 # successful
-OK = ... # type: int
-CREATED = ... # type: int
-ACCEPTED = ... # type: int
-NON_AUTHORITATIVE_INFORMATION = ... # type: int
-NO_CONTENT = ... # type: int
-RESET_CONTENT = ... # type: int
-PARTIAL_CONTENT = ... # type: int
-MULTI_STATUS = ... # type: int
-IM_USED = ... # type: int
+OK = ...  # type: int
+CREATED = ...  # type: int
+ACCEPTED = ...  # type: int
+NON_AUTHORITATIVE_INFORMATION = ...  # type: int
+NO_CONTENT = ...  # type: int
+RESET_CONTENT = ...  # type: int
+PARTIAL_CONTENT = ...  # type: int
+MULTI_STATUS = ...  # type: int
+IM_USED = ...  # type: int
 
 # redirection
-MULTIPLE_CHOICES = ... # type: int
-MOVED_PERMANENTLY = ... # type: int
-FOUND = ... # type: int
-SEE_OTHER = ... # type: int
-NOT_MODIFIED = ... # type: int
-USE_PROXY = ... # type: int
-TEMPORARY_REDIRECT = ... # type: int
+MULTIPLE_CHOICES = ...  # type: int
+MOVED_PERMANENTLY = ...  # type: int
+FOUND = ...  # type: int
+SEE_OTHER = ...  # type: int
+NOT_MODIFIED = ...  # type: int
+USE_PROXY = ...  # type: int
+TEMPORARY_REDIRECT = ...  # type: int
 
 # client error
-BAD_REQUEST = ... # type: int
-UNAUTHORIZED = ... # type: int
-PAYMENT_REQUIRED = ... # type: int
-FORBIDDEN = ... # type: int
-NOT_FOUND = ... # type: int
-METHOD_NOT_ALLOWED = ... # type: int
-NOT_ACCEPTABLE = ... # type: int
-PROXY_AUTHENTICATION_REQUIRED = ... # type: int
-REQUEST_TIMEOUT = ... # type: int
-CONFLICT = ... # type: int
-GONE = ... # type: int
-LENGTH_REQUIRED = ... # type: int
-PRECONDITION_FAILED = ... # type: int
-REQUEST_ENTITY_TOO_LARGE = ... # type: int
-REQUEST_URI_TOO_LONG = ... # type: int
-UNSUPPORTED_MEDIA_TYPE = ... # type: int
-REQUESTED_RANGE_NOT_SATISFIABLE = ... # type: int
-EXPECTATION_FAILED = ... # type: int
-UNPROCESSABLE_ENTITY = ... # type: int
-LOCKED = ... # type: int
-FAILED_DEPENDENCY = ... # type: int
-UPGRADE_REQUIRED = ... # type: int
+BAD_REQUEST = ...  # type: int
+UNAUTHORIZED = ...  # type: int
+PAYMENT_REQUIRED = ...  # type: int
+FORBIDDEN = ...  # type: int
+NOT_FOUND = ...  # type: int
+METHOD_NOT_ALLOWED = ...  # type: int
+NOT_ACCEPTABLE = ...  # type: int
+PROXY_AUTHENTICATION_REQUIRED = ...  # type: int
+REQUEST_TIMEOUT = ...  # type: int
+CONFLICT = ...  # type: int
+GONE = ...  # type: int
+LENGTH_REQUIRED = ...  # type: int
+PRECONDITION_FAILED = ...  # type: int
+REQUEST_ENTITY_TOO_LARGE = ...  # type: int
+REQUEST_URI_TOO_LONG = ...  # type: int
+UNSUPPORTED_MEDIA_TYPE = ...  # type: int
+REQUESTED_RANGE_NOT_SATISFIABLE = ...  # type: int
+EXPECTATION_FAILED = ...  # type: int
+UNPROCESSABLE_ENTITY = ...  # type: int
+LOCKED = ...  # type: int
+FAILED_DEPENDENCY = ...  # type: int
+UPGRADE_REQUIRED = ...  # type: int
 
 # server error
-INTERNAL_SERVER_ERROR = ... # type: int
-NOT_IMPLEMENTED = ... # type: int
-BAD_GATEWAY = ... # type: int
-SERVICE_UNAVAILABLE = ... # type: int
-GATEWAY_TIMEOUT = ... # type: int
-HTTP_VERSION_NOT_SUPPORTED = ... # type: int
-INSUFFICIENT_STORAGE = ... # type: int
-NOT_EXTENDED = ... # type: int
+INTERNAL_SERVER_ERROR = ...  # type: int
+NOT_IMPLEMENTED = ...  # type: int
+BAD_GATEWAY = ...  # type: int
+SERVICE_UNAVAILABLE = ...  # type: int
+GATEWAY_TIMEOUT = ...  # type: int
+HTTP_VERSION_NOT_SUPPORTED = ...  # type: int
+INSUFFICIENT_STORAGE = ...  # type: int
+NOT_EXTENDED = ...  # type: int

stdlib/2/io.pyi

@@ -49,7 +49,7 @@ class StringIO(TextIO):
     def __init__(self, initial_value: unicode = ...,
                  newline: unicode = ...) -> None: ...
     # TODO see comments in BinaryIO for missing functionality
-    name = ... # type: str
+    name = ...  # type: str
     def close(self) -> None: ...
     def closed(self) -> bool: ...
     def fileno(self) -> int: ...

stdlib/2/itertools.pyi

@@ -9,7 +9,7 @@ _T = TypeVar('_T')
 _S = TypeVar('_S')
 
 def count(start: int = ...,
-          step: int = ...) -> Iterator[int]: ... # more general types?
+          step: int = ...) -> Iterator[int]: ...  # more general types?
 def cycle(iterable: Iterable[_T]) -> Iterator[_T]: ...
 
 def repeat(object: _T, times: int = ...) -> Iterator[_T]: ...

stdlib/2/json.pyi

@@ -70,14 +70,14 @@ class JSONDecoder(object):
         idx: int = ...) -> Tuple[Any, Any]: ...
 
 class JSONEncoder(object):
-    item_separator = ... # type: str
-    key_separator = ... # type: str
-    skipkeys = ... # type: bool
-    ensure_ascii = ... # type: bool
-    check_circular = ... # type: bool
-    allow_nan = ... # type: bool
-    sort_keys = ... # type: bool
-    indent = ... # type: int
+    item_separator = ...  # type: str
+    key_separator = ...  # type: str
+    skipkeys = ...  # type: bool
+    ensure_ascii = ...  # type: bool
+    check_circular = ...  # type: bool
+    allow_nan = ...  # type: bool
+    sort_keys = ...  # type: bool
+    indent = ...  # type: int
 
     def __init__(self,
         skipkeys: bool = ...,

stdlib/2/mimetools.pyi

@@ -6,15 +6,15 @@ from typing import Any
 import rfc822
 
 class Message(rfc822.Message):
-    encodingheader = ... # type: Any
-    typeheader = ... # type: Any
+    encodingheader = ...  # type: Any
+    typeheader = ...  # type: Any
     def __init__(self, fp, seekable=1): ...
-    plisttext = ... # type: Any
-    type = ... # type: Any
-    maintype = ... # type: Any
-    subtype = ... # type: Any
+    plisttext = ...  # type: Any
+    type = ...  # type: Any
+    maintype = ...  # type: Any
+    subtype = ...  # type: Any
     def parsetype(self): ...
-    plist = ... # type: Any
+    plist = ...  # type: Any
     def parseplist(self): ...
     def getplist(self): ...
     def getparam(self, name): ...

stdlib/2/multiprocessing/process.pyi

@@ -30,7 +30,7 @@ class Process:
     def exitcode(self): ...
     @property
     def ident(self): ...
-    pid = ... # type: Any
+    pid = ...  # type: Any
 
 class AuthenticationString(bytes):
     def __reduce__(self): ...

stdlib/2/multiprocessing/util.pyi

@@ -5,8 +5,8 @@
 from typing import Any
 import threading
 
-SUBDEBUG = ... # type: Any
-SUBWARNING = ... # type: Any
+SUBDEBUG = ...  # type: Any
+SUBWARNING = ...  # type: Any
 
 def sub_debug(msg, *args): ...
 def debug(msg, *args): ...

stdlib/2/os/__init__.pyi

@@ -7,12 +7,12 @@ from typing import (
 from . import path
 
 error = OSError
-name = ... # type: str
+name = ...  # type: str
 
 class _Environ(MutableMapping[str, str]):
     def copy(self) -> Dict[str, str]: ...
 
-environ = ... # type: _Environ
+environ = ...  # type: _Environ
 
 def chdir(path: unicode) -> None: ...
 def fchdir(fd: int) -> None: ...
@@ -129,7 +129,7 @@ def mkdir(path: unicode, mode: int = ...) -> None: ...
 def makedirs(path: unicode, mode: int = ...) -> None: ...
 def pathconf(path: unicode, name: str) -> str: ...
 
-pathconf_names = ... # type: Mapping[str, int]
+pathconf_names = ...  # type: Mapping[str, int]
 
 def readlink(path: AnyStr) -> AnyStr: ...
 def remove(path: unicode) -> None: ...
@@ -169,7 +169,7 @@ EX_UNAVAILABLE = 0  # Unix only
 EX_SOFTWARE = 0  # Unix only
 EX_OSERR = 0     # Unix only
 EX_OSFILE = 0    # Unix only
-EX_CANTCREAT = 0 # Unix only
+EX_CANTCREAT = 0  # Unix only
 EX_IOERR = 0     # Unix only
 EX_TEMPFAIL = 0  # Unix only
 EX_PROTOCOL = 0  # Unix only
@@ -198,11 +198,11 @@ def nice(increment: int) -> int: ...
 
 def spawnl(mode: int, path: AnyStr, arg0: AnyStr, *args: AnyStr) -> int: ...
 def spawnle(mode: int, path: AnyStr, arg0: AnyStr,
-            *args: Any) -> int: ... # Imprecise sig
+            *args: Any) -> int: ...  # Imprecise sig
 def spawnlp(mode: int, file: AnyStr, arg0: AnyStr,
             *args: AnyStr) -> int: ...  # Unix only TODO
 def spawnlpe(mode: int, file: AnyStr, arg0: AnyStr, *args: Any) -> int:
-    ... # Imprecise signature; Unix only TODO
+    ...  # Imprecise signature; Unix only TODO
 def spawnv(mode: int, path: AnyStr, args: List[AnyStr]) -> int: ...
 def spawnve(mode: int, path: AnyStr, args: List[AnyStr],
             env: Mapping[str, str]) -> int: ...
@@ -210,31 +210,31 @@ def spawnvp(mode: int, file: AnyStr, args: List[AnyStr]) -> int: ...  # Unix onl
 def spawnvpe(mode: int, file: AnyStr, args: List[AnyStr],
              env: Mapping[str, str]) -> int:
     ...  # Unix only
-def startfile(path: unicode, operation: str = ...) -> None: ... # Windows only
+def startfile(path: unicode, operation: str = ...) -> None: ...  # Windows only
 def system(command: unicode) -> int: ...
 def times() -> Tuple[float, float, float, float, float]: ...
-def wait() -> Tuple[int, int]: ... # Unix only
-def wait3(options: int) -> Tuple[int, int, Any]: ... # Unix only
-def wait4(pid: int, options: int) -> Tuple[int, int, Any]: ... # Unix only
+def wait() -> Tuple[int, int]: ...  # Unix only
+def wait3(options: int) -> Tuple[int, int, Any]: ...  # Unix only
+def wait4(pid: int, options: int) -> Tuple[int, int, Any]: ...  # Unix only
 def waitpid(pid: int, options: int) -> Tuple[int, int]: ...
 
 def confstr(name: Union[str, int]) -> Optional[str]: ...
-confstr_names = ... # type: Mapping[str, int]
+confstr_names = ...  # type: Mapping[str, int]
 
 def getloadavg() -> Tuple[float, float, float]: ...
 
 def sysconf(name: Union[str, int]) -> int: ...
-sysconf_names = ... # type: Mapping[str, int]
+sysconf_names = ...  # type: Mapping[str, int]
 
-curdir = ... # type: str
-pardir = ... # type: str
-sep = ... # type: str
-altsep = ... # type: str
-extsep = ... # type: str
-pathsep = ... # type: str
-defpath = ... # type: str
-linesep = ... # type: str
-devnull = ... # type: str
+curdir = ...  # type: str
+pardir = ...  # type: str
+sep = ...  # type: str
+altsep = ...  # type: str
+extsep = ...  # type: str
+pathsep = ...  # type: str
+defpath = ...  # type: str
+linesep = ...  # type: str
+devnull = ...  # type: str
 
 def urandom(n: int) -> str: ...
 
@@ -251,16 +251,16 @@ O_DSYNC = 0    # Unix only
 O_RSYNC = 0    # Unix only
 O_SYNC = 0     # Unix only
 O_NDELAY = 0   # Unix only
-O_NONBLOCK = 0 # Unix only
+O_NONBLOCK = 0  # Unix only
 O_NOCTTY = 0   # Unix only
 O_SHLOCK = 0   # Unix only
 O_EXLOCK = 0   # Unix only
 O_BINARY = 0     # Windows only
 O_NOINHERIT = 0  # Windows only
-O_SHORT_LIVED = 0# Windows only
+O_SHORT_LIVED = 0  # Windows only
 O_TEMPORARY = 0  # Windows only
 O_RANDOM = 0     # Windows only
-O_SEQUENTIAL = 0 # Windows only
+O_SEQUENTIAL = 0  # Windows only
 O_TEXT = 0       # Windows only
 O_ASYNC = 0      # Gnu extension if in C library
 O_DIRECT = 0     # Gnu extension if in C library

stdlib/2/platform.pyi

@@ -4,23 +4,23 @@
 
 from typing import Any
 
-__copyright__ = ... # type: Any
-DEV_NULL = ... # type: Any
+__copyright__ = ...  # type: Any
+DEV_NULL = ...  # type: Any
 
 def libc_ver(executable=..., lib=..., version=..., chunksize=2048): ...
 def linux_distribution(distname=..., version=..., id=..., supported_dists=..., full_distribution_name=1): ...
 def dist(distname=..., version=..., id=..., supported_dists=...): ...
 
 class _popen:
-    tmpfile = ... # type: Any
-    pipe = ... # type: Any
-    bufsize = ... # type: Any
-    mode = ... # type: Any
+    tmpfile = ...  # type: Any
+    pipe = ...  # type: Any
+    bufsize = ...  # type: Any
+    mode = ...  # type: Any
     def __init__(self, cmd, mode=..., bufsize=None): ...
     def read(self): ...
     def readlines(self): ...
     def close(self, remove=..., error=...): ...
-    __del__ = ... # type: Any
+    __del__ = ...  # type: Any
 
 def popen(cmd, mode=..., bufsize=None): ...
 def win32_ver(release=..., version=..., csd=..., ptype=...): ...

stdlib/2/posixpath.pyi

@@ -5,14 +5,14 @@
 from typing import Any, AnyStr, List
 from genericpath import *
 
-curdir = ... # type: Any
-pardir = ... # type: Any
-extsep = ... # type: Any
-sep = ... # type: Any
-pathsep = ... # type: Any
-defpath = ... # type: Any
-altsep = ... # type: Any
-devnull = ... # type: Any
+curdir = ...  # type: Any
+pardir = ...  # type: Any
+extsep = ...  # type: Any
+sep = ...  # type: Any
+pathsep = ...  # type: Any
+defpath = ...  # type: Any
+altsep = ...  # type: Any
+devnull = ...  # type: Any
 
 def normcase(s): ...
 def isabs(s): ...
@@ -35,7 +35,7 @@ def normpath(path): ...
 def abspath(path): ...
 def realpath(filename): ...
 
-supports_unicode_filenames = ... # type: Any
+supports_unicode_filenames = ...  # type: Any
 
 def relpath(path, start=...): ...
 

stdlib/2/resource.pyi

@@ -2,22 +2,22 @@ from typing import Tuple, NamedTuple
 
 class error(Exception): ...
 
-RLIM_INFINITY = ... # type: int
+RLIM_INFINITY = ...  # type: int
 def getrlimit(resource: int) -> Tuple[int, int]: ...
 def setrlimit(resource: int, limits: Tuple[int, int]) -> None: ...
 
-RLIMIT_CORE = ... # type: int
-RLIMIT_CPU = ... # type: int
-RLIMIT_FSIZE = ... # type: int
-RLIMIT_DATA = ... # type: int
-RLIMIT_STACK = ... # type: int
-RLIMIT_RSS = ... # type: int
-RLIMIT_NPROC = ... # type: int
-RLIMIT_NOFILE = ... # type: int
-RLIMIT_OFILE= ... # type: int
-RLIMIT_MEMLOCK = ... # type: int
-RLIMIT_VMEM = ... # type: int
-RLIMIT_AS = ... # type: int
+RLIMIT_CORE = ...  # type: int
+RLIMIT_CPU = ...  # type: int
+RLIMIT_FSIZE = ...  # type: int
+RLIMIT_DATA = ...  # type: int
+RLIMIT_STACK = ...  # type: int
+RLIMIT_RSS = ...  # type: int
+RLIMIT_NPROC = ...  # type: int
+RLIMIT_NOFILE = ...  # type: int
+RLIMIT_OFILE= ...  # type: int
+RLIMIT_MEMLOCK = ...  # type: int
+RLIMIT_VMEM = ...  # type: int
+RLIMIT_AS = ...  # type: int
 
 _RUsage = NamedTuple('_RUsage', [('ru_utime', float), ('ru_stime', float), ('ru_maxrss', int),
                                  ('ru_ixrss', int), ('ru_idrss', int), ('ru_isrss', int),
@@ -28,6 +28,6 @@ _RUsage = NamedTuple('_RUsage', [('ru_utime', float), ('ru_stime', float), ('ru_
 def getrusage(who: int) -> _RUsage: ...
 def getpagesize() -> int: ...
 
-RUSAGE_SELF = ... # type: int
-RUSAGE_CHILDREN = ... # type: int
-RUSAGE_BOTH = ... # type: int
+RUSAGE_SELF = ...  # type: int
+RUSAGE_CHILDREN = ...  # type: int
+RUSAGE_BOTH = ...  # type: int

stdlib/2/rfc822.pyi

@@ -5,16 +5,16 @@
 from typing import Any
 
 class Message:
-    fp = ... # type: Any
-    seekable = ... # type: Any
-    startofheaders = ... # type: Any
-    startofbody = ... # type: Any
+    fp = ...  # type: Any
+    seekable = ...  # type: Any
+    startofheaders = ...  # type: Any
+    startofbody = ...  # type: Any
     def __init__(self, fp, seekable=1): ...
     def rewindbody(self): ...
-    dict = ... # type: Any
-    unixfrom = ... # type: Any
-    headers = ... # type: Any
-    status = ... # type: Any
+    dict = ...  # type: Any
+    unixfrom = ...  # type: Any
+    headers = ...  # type: Any
+    status = ...  # type: Any
     def readheaders(self): ...
     def isheader(self, line): ...
     def islast(self, line): ...
@@ -23,7 +23,7 @@ class Message:
     def getfirstmatchingheader(self, name): ...
     def getrawheader(self, name): ...
     def getheader(self, name, default=None): ...
-    get = ... # type: Any
+    get = ...  # type: Any
     def getheaders(self, name): ...
     def getaddr(self, name): ...
     def getaddrlist(self, name): ...
@@ -42,14 +42,14 @@ class Message:
     def items(self): ...
 
 class AddrlistClass:
-    specials = ... # type: Any
-    pos = ... # type: Any
-    LWS = ... # type: Any
-    CR = ... # type: Any
-    atomends = ... # type: Any
-    phraseends = ... # type: Any
-    field = ... # type: Any
-    commentlist = ... # type: Any
+    specials = ...  # type: Any
+    pos = ...  # type: Any
+    LWS = ...  # type: Any
+    CR = ...  # type: Any
+    atomends = ...  # type: Any
+    phraseends = ...  # type: Any
+    field = ...  # type: Any
+    commentlist = ...  # type: Any
     def __init__(self, field): ...
     def gotonext(self): ...
     def getaddrlist(self): ...
@@ -65,7 +65,7 @@ class AddrlistClass:
     def getphraselist(self): ...
 
 class AddressList(AddrlistClass):
-    addresslist = ... # type: Any
+    addresslist = ...  # type: Any
     def __init__(self, field): ...
     def __len__(self): ...
     def __add__(self, other): ...

stdlib/2/runpy.pyi

@@ -5,14 +5,14 @@
 from typing import Any
 
 class _TempModule:
-    mod_name = ... # type: Any
-    module = ... # type: Any
+    mod_name = ...  # type: Any
+    module = ...  # type: Any
     def __init__(self, mod_name): ...
     def __enter__(self): ...
     def __exit__(self, *args): ...
 
 class _ModifiedArgv0:
-    value = ... # type: Any
+    value = ...  # type: Any
     def __init__(self, value): ...
     def __enter__(self): ...
     def __exit__(self, *args): ...

stdlib/2/select.pyi

@@ -71,16 +71,16 @@ def select(rlist, wlist, xlist, timeout: float = None) -> Tuple[List, List, List
 class error(Exception): ...
 
 class kevent(object):
-    data = ... # type: Any
-    fflags = ... # type: int
-    filter = ... # type: int
-    flags = ... # type: int
-    ident = ... # type: Any
-    udata = ... # type: Any
+    data = ...  # type: Any
+    fflags = ...  # type: int
+    filter = ...  # type: int
+    flags = ...  # type: int
+    ident = ...  # type: Any
+    udata = ...  # type: Any
     def __init__(self, *args, **kwargs) -> None: ...
 
 class kqueue(object):
-    closed = ... # type: bool
+    closed = ...  # type: bool
     def __init__(self) -> None: ...
     def close(self) -> None: ...
     def control(self, changelist: Optional[Iterable[kevent]], max_events: int, timeout: int = ...) -> List[kevent]: ...

stdlib/2/shlex.pyi

@@ -12,16 +12,16 @@ class shlex:
     def pop_source(self) -> IO[Any]: ...
     def error_leader(self, file: str = ..., line: int = ...) -> str: ...
 
-    commenters = ... # type: str
-    wordchars = ... # type: str
-    whitespace = ... # type: str
-    escape = ... # type: str
-    quotes = ... # type: str
-    escapedquotes = ... # type: str
-    whitespace_split = ... # type: bool
-    infile = ... # type: IO[Any]
-    source = ... # type: Optional[str]
-    debug = ... # type: int
-    lineno = ... # type: int
-    token = ... # type: Any
-    eof = ... # type: Optional[str]
+    commenters = ...  # type: str
+    wordchars = ...  # type: str
+    whitespace = ...  # type: str
+    escape = ...  # type: str
+    quotes = ...  # type: str
+    escapedquotes = ...  # type: str
+    whitespace_split = ...  # type: bool
+    infile = ...  # type: IO[Any]
+    source = ...  # type: Optional[str]
+    debug = ...  # type: int
+    lineno = ...  # type: int
+    token = ...  # type: Any
+    eof = ...  # type: Optional[str]

stdlib/2/smtplib.pyi

@@ -8,21 +8,21 @@ class SMTPException(Exception): ...
 class SMTPServerDisconnected(SMTPException): ...
 
 class SMTPResponseException(SMTPException):
-    smtp_code = ... # type: Any
-    smtp_error = ... # type: Any
-    args = ... # type: Any
+    smtp_code = ...  # type: Any
+    smtp_error = ...  # type: Any
+    args = ...  # type: Any
     def __init__(self, code, msg) -> None: ...
 
 class SMTPSenderRefused(SMTPResponseException):
-    smtp_code = ... # type: Any
-    smtp_error = ... # type: Any
-    sender = ... # type: Any
-    args = ... # type: Any
+    smtp_code = ...  # type: Any
+    smtp_error = ...  # type: Any
+    sender = ...  # type: Any
+    args = ...  # type: Any
     def __init__(self, code, msg, sender) -> None: ...
 
 class SMTPRecipientsRefused(SMTPException):
-    recipients = ... # type: Any
-    args = ... # type: Any
+    recipients = ...  # type: Any
+    args = ...  # type: Any
     def __init__(self, recipients) -> None: ...
 
 class SMTPDataError(SMTPResponseException): ...
@@ -34,25 +34,25 @@ def quoteaddr(addr): ...
 def quotedata(data): ...
 
 class SSLFakeFile:
-    sslobj = ... # type: Any
+    sslobj = ...  # type: Any
     def __init__(self, sslobj) -> None: ...
     def readline(self, size=...): ...
     def close(self): ...
 
 class SMTP:
-    debuglevel = ... # type: Any
-    file = ... # type: Any
-    helo_resp = ... # type: Any
-    ehlo_msg = ... # type: Any
-    ehlo_resp = ... # type: Any
-    does_esmtp = ... # type: Any
-    default_port = ... # type: Any
-    timeout = ... # type: Any
-    esmtp_features = ... # type: Any
-    local_hostname = ... # type: Any
+    debuglevel = ...  # type: Any
+    file = ...  # type: Any
+    helo_resp = ...  # type: Any
+    ehlo_msg = ...  # type: Any
+    ehlo_resp = ...  # type: Any
+    does_esmtp = ...  # type: Any
+    default_port = ...  # type: Any
+    timeout = ...  # type: Any
+    esmtp_features = ...  # type: Any
+    local_hostname = ...  # type: Any
     def __init__(self, host: str = ..., port: int = ..., local_hostname=..., timeout=...) -> None: ...
     def set_debuglevel(self, debuglevel): ...
-    sock = ... # type: Any
+    sock = ...  # type: Any
     def connect(self, host=..., port=...): ...
     def send(self, str): ...
     def putcmd(self, cmd, args=...): ...
@@ -68,7 +68,7 @@ class SMTP:
     def rcpt(self, recip, options=...): ...
     def data(self, msg): ...
     def verify(self, address): ...
-    vrfy = ... # type: Any
+    vrfy = ...  # type: Any
     def expn(self, address): ...
     def ehlo_or_helo_if_needed(self): ...
     def login(self, user, password): ...
@@ -78,13 +78,13 @@ class SMTP:
     def quit(self): ...
 
 class SMTP_SSL(SMTP):
-    default_port = ... # type: Any
-    keyfile = ... # type: Any
-    certfile = ... # type: Any
+    default_port = ...  # type: Any
+    keyfile = ...  # type: Any
+    certfile = ...  # type: Any
     def __init__(self, host=..., port=..., local_hostname=..., keyfile=..., certfile=..., timeout=...) -> None: ...
 
 class LMTP(SMTP):
-    ehlo_msg = ... # type: Any
+    ehlo_msg = ...  # type: Any
     def __init__(self, host=..., port=..., local_hostname=...) -> None: ...
-    sock = ... # type: Any
+    sock = ...  # type: Any
     def connect(self, host=..., port=...): ...

stdlib/2/socket.pyi

@@ -318,7 +318,7 @@ class socket:
                   flags: int = ...) -> Any: ...
     def send(self, data: str, flags: int = ...) -> int: ...
     def sendall(self, data: str, flags: int = ...) -> None:
-        ... # return type: None on success
+        ...  # return type: None on success
     def sendto(self, data: str, address: Union[tuple, str], flags: int = ...) -> int: ...
     def setblocking(self, flag: bool) -> None: ...
     def settimeout(self, value: Union[float, None]) -> None: ...

stdlib/2/sqlite3/dbapi2.pyi

@@ -6,62 +6,62 @@ from numbers import Integral
 from datetime import time, datetime
 from collections import Iterable
 
-paramstyle = ... # type: str
-threadsafety = ... # type: int
-apilevel = ... # type: str
-Date = ... # type: datetime
-Time = ... # type: time
-Timestamp = ... # type: datetime
+paramstyle = ...  # type: str
+threadsafety = ...  # type: int
+apilevel = ...  # type: str
+Date = ...  # type: datetime
+Time = ...  # type: time
+Timestamp = ...  # type: datetime
 
 def DateFromTicks(ticks): ...
 def TimeFromTicks(ticks): ...
 def TimestampFromTicks(ticks): ...
 
-version_info = ... # type: Any
-sqlite_version_info = ... # type: Any
-Binary = ... # type: Any
+version_info = ...  # type: Any
+sqlite_version_info = ...  # type: Any
+Binary = ...  # type: Any
 
 def register_adapters_and_converters(): ...
 
 # The remaining definitions are imported from _sqlite3.
 
-PARSE_COLNAMES = ... # type: int
-PARSE_DECLTYPES = ... # type: int
-SQLITE_ALTER_TABLE = ... # type: int
-SQLITE_ANALYZE = ... # type: int
-SQLITE_ATTACH = ... # type: int
-SQLITE_CREATE_INDEX = ... # type: int
-SQLITE_CREATE_TABLE = ... # type: int
-SQLITE_CREATE_TEMP_INDEX = ... # type: int
-SQLITE_CREATE_TEMP_TABLE = ... # type: int
-SQLITE_CREATE_TEMP_TRIGGER = ... # type: int
-SQLITE_CREATE_TEMP_VIEW = ... # type: int
-SQLITE_CREATE_TRIGGER = ... # type: int
-SQLITE_CREATE_VIEW = ... # type: int
-SQLITE_DELETE = ... # type: int
-SQLITE_DENY = ... # type: int
-SQLITE_DETACH = ... # type: int
-SQLITE_DROP_INDEX = ... # type: int
-SQLITE_DROP_TABLE = ... # type: int
-SQLITE_DROP_TEMP_INDEX = ... # type: int
-SQLITE_DROP_TEMP_TABLE = ... # type: int
-SQLITE_DROP_TEMP_TRIGGER = ... # type: int
-SQLITE_DROP_TEMP_VIEW = ... # type: int
-SQLITE_DROP_TRIGGER = ... # type: int
-SQLITE_DROP_VIEW = ... # type: int
-SQLITE_IGNORE = ... # type: int
-SQLITE_INSERT = ... # type: int
-SQLITE_OK = ... # type: int
-SQLITE_PRAGMA = ... # type: int
-SQLITE_READ = ... # type: int
-SQLITE_REINDEX = ... # type: int
-SQLITE_SELECT = ... # type: int
-SQLITE_TRANSACTION = ... # type: int
-SQLITE_UPDATE = ... # type: int
-adapters = ... # type: Any
-converters = ... # type: Any
-sqlite_version = ... # type: str
-version = ... # type: str
+PARSE_COLNAMES = ...  # type: int
+PARSE_DECLTYPES = ...  # type: int
+SQLITE_ALTER_TABLE = ...  # type: int
+SQLITE_ANALYZE = ...  # type: int
+SQLITE_ATTACH = ...  # type: int
+SQLITE_CREATE_INDEX = ...  # type: int
+SQLITE_CREATE_TABLE = ...  # type: int
+SQLITE_CREATE_TEMP_INDEX = ...  # type: int
+SQLITE_CREATE_TEMP_TABLE = ...  # type: int
+SQLITE_CREATE_TEMP_TRIGGER = ...  # type: int
+SQLITE_CREATE_TEMP_VIEW = ...  # type: int
+SQLITE_CREATE_TRIGGER = ...  # type: int
+SQLITE_CREATE_VIEW = ...  # type: int
+SQLITE_DELETE = ...  # type: int
+SQLITE_DENY = ...  # type: int
+SQLITE_DETACH = ...  # type: int
+SQLITE_DROP_INDEX = ...  # type: int
+SQLITE_DROP_TABLE = ...  # type: int
+SQLITE_DROP_TEMP_INDEX = ...  # type: int
+SQLITE_DROP_TEMP_TABLE = ...  # type: int
+SQLITE_DROP_TEMP_TRIGGER = ...  # type: int
+SQLITE_DROP_TEMP_VIEW = ...  # type: int
+SQLITE_DROP_TRIGGER = ...  # type: int
+SQLITE_DROP_VIEW = ...  # type: int
+SQLITE_IGNORE = ...  # type: int
+SQLITE_INSERT = ...  # type: int
+SQLITE_OK = ...  # type: int
+SQLITE_PRAGMA = ...  # type: int
+SQLITE_READ = ...  # type: int
+SQLITE_REINDEX = ...  # type: int
+SQLITE_SELECT = ...  # type: int
+SQLITE_TRANSACTION = ...  # type: int
+SQLITE_UPDATE = ...  # type: int
+adapters = ...  # type: Any
+converters = ...  # type: Any
+sqlite_version = ...  # type: str
+version = ...  # type: str
 
 # TODO: adapt needs to get probed
 def adapt(obj, protocol, alternate): ...
@@ -85,21 +85,21 @@ class Cache:
     def get(self, *args, **kwargs) -> None: ...
 
 class Connection:
-    DataError = ... # type: Any
-    DatabaseError = ... # type: Any
-    Error = ... # type: Any
-    IntegrityError = ... # type: Any
-    InterfaceError = ... # type: Any
-    InternalError = ... # type: Any
-    NotSupportedError = ... # type: Any
-    OperationalError = ... # type: Any
-    ProgrammingError = ... # type: Any
-    Warning = ... # type: Any
-    in_transaction = ... # type: Any
-    isolation_level = ... # type: Any
-    row_factory = ... # type: Any
-    text_factory = ... # type: Any
-    total_changes = ... # type: Any
+    DataError = ...  # type: Any
+    DatabaseError = ...  # type: Any
+    Error = ...  # type: Any
+    IntegrityError = ...  # type: Any
+    InterfaceError = ...  # type: Any
+    InternalError = ...  # type: Any
+    NotSupportedError = ...  # type: Any
+    OperationalError = ...  # type: Any
+    ProgrammingError = ...  # type: Any
+    Warning = ...  # type: Any
+    in_transaction = ...  # type: Any
+    isolation_level = ...  # type: Any
+    row_factory = ...  # type: Any
+    text_factory = ...  # type: Any
+    total_changes = ...  # type: Any
     def __init__(self, *args, **kwargs): ...
     def close(self) -> None: ...
     def commit(self) -> None: ...
@@ -126,12 +126,12 @@ class Connection:
     def __exit__(self, *args, **kwargs): ...
 
 class Cursor(Iterator[Any]):
-    arraysize = ... # type: Any
-    connection = ... # type: Any
-    description = ... # type: Any
-    lastrowid = ... # type: Any
-    row_factory = ... # type: Any
-    rowcount = ... # type: Any
+    arraysize = ...  # type: Any
+    connection = ...  # type: Any
+    description = ...  # type: Any
+    lastrowid = ...  # type: Any
+    row_factory = ...  # type: Any
+    rowcount = ...  # type: Any
     # TODO: Cursor class accepts exactly 1 argument
     # required type is sqlite3.Connection (which is imported as _Connection)
     # however, the name of the __init__ variable is unknown
@@ -166,7 +166,7 @@ class NotSupportedError(DatabaseError): ...
 class OperationalError(DatabaseError): ...
 
 class OptimizedUnicode:
-    maketrans = ... # type: Any
+    maketrans = ...  # type: Any
     def __init__(self, *args, **kwargs): ...
     def capitalize(self, *args, **kwargs): ...
     def casefold(self, *args, **kwargs): ...

stdlib/2/ssl.pyi

@@ -64,46 +64,46 @@ if sys.platform == 'win32':
     def enum_crls(store_name: str) -> _EnumRetType: ...
 
 
-CERT_NONE = ... # type: int
-CERT_OPTIONAL = ... # type: int
-CERT_REQUIRED = ... # type: int
+CERT_NONE = ...  # type: int
+CERT_OPTIONAL = ...  # type: int
+CERT_REQUIRED = ...  # type: int
 
-VERIFY_DEFAULT = ... # type: int
-VERIFY_CRL_CHECK_LEAF = ... # type: int
-VERIFY_CRL_CHECK_CHAIN = ... # type: int
-VERIFY_X509_STRICT = ... # type: int
-VERIFY_X509_TRUSTED_FIRST = ... # type: int
+VERIFY_DEFAULT = ...  # type: int
+VERIFY_CRL_CHECK_LEAF = ...  # type: int
+VERIFY_CRL_CHECK_CHAIN = ...  # type: int
+VERIFY_X509_STRICT = ...  # type: int
+VERIFY_X509_TRUSTED_FIRST = ...  # type: int
 
-PROTOCOL_SSLv23 = ... # type: int
-PROTOCOL_SSLv2 = ... # type: int
-PROTOCOL_SSLv3 = ... # type: int
-PROTOCOL_TLSv1 = ... # type: int
-PROTOCOL_TLSv1_1 = ... # type: int
-PROTOCOL_TLSv1_2 = ... # type: int
+PROTOCOL_SSLv23 = ...  # type: int
+PROTOCOL_SSLv2 = ...  # type: int
+PROTOCOL_SSLv3 = ...  # type: int
+PROTOCOL_TLSv1 = ...  # type: int
+PROTOCOL_TLSv1_1 = ...  # type: int
+PROTOCOL_TLSv1_2 = ...  # type: int
 
-OP_ALL = ... # type: int
-OP_NO_SSLv2 = ... # type: int
-OP_NO_SSLv3 = ... # type: int
-OP_NO_TLSv1 = ... # type: int
-OP_NO_TLSv1_1 = ... # type: int
-OP_NO_TLSv1_2 = ... # type: int
-OP_CIPHER_SERVER_PREFERENCE = ... # type: int
-OP_SINGLE_DH_USE = ... # type: int
-OP_SINGLE_ECDH_USE = ... # type: int
-OP_NO_COMPRESSION = ... # type: int
+OP_ALL = ...  # type: int
+OP_NO_SSLv2 = ...  # type: int
+OP_NO_SSLv3 = ...  # type: int
+OP_NO_TLSv1 = ...  # type: int
+OP_NO_TLSv1_1 = ...  # type: int
+OP_NO_TLSv1_2 = ...  # type: int
+OP_CIPHER_SERVER_PREFERENCE = ...  # type: int
+OP_SINGLE_DH_USE = ...  # type: int
+OP_SINGLE_ECDH_USE = ...  # type: int
+OP_NO_COMPRESSION = ...  # type: int
 
 HAS_ALPN = ...  # type: int
-HAS_ECDH = ... # type: bool
-HAS_SNI = ... # type: bool
-HAS_NPN = ... # type: bool
-CHANNEL_BINDING_TYPES = ... # type: List[str]
+HAS_ECDH = ...  # type: bool
+HAS_SNI = ...  # type: bool
+HAS_NPN = ...  # type: bool
+CHANNEL_BINDING_TYPES = ...  # type: List[str]
 
-OPENSSL_VERSION = ... # type: str
-OPENSSL_VERSION_INFO = ... # type: Tuple[int, int, int, int, int]
-OPENSSL_VERSION_NUMBER = ... # type: int
+OPENSSL_VERSION = ...  # type: str
+OPENSSL_VERSION_INFO = ...  # type: Tuple[int, int, int, int, int]
+OPENSSL_VERSION_NUMBER = ...  # type: int
 
-ALERT_DESCRIPTION_HANDSHAKE_FAILURE = ... # type: int
-ALERT_DESCRIPTION_INTERNAL_ERROR = ... # type: int
+ALERT_DESCRIPTION_HANDSHAKE_FAILURE = ...  # type: int
+ALERT_DESCRIPTION_INTERNAL_ERROR = ...  # type: int
 ALERT_DESCRIPTION_ACCESS_DENIED = ...  # type: int
 ALERT_DESCRIPTION_BAD_CERTIFICATE = ...  # type: int
 ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE = ...  # type: int
@@ -134,8 +134,8 @@ _PurposeType = NamedTuple('_PurposeType',
                          [('nid', int), ('shortname', str),
                           ('longname', str), ('oid', str)])
 class Purpose:
-    SERVER_AUTH = ... # type: _PurposeType
-    CLIENT_AUTH = ... # type: _PurposeType
+    SERVER_AUTH = ...  # type: _PurposeType
+    CLIENT_AUTH = ...  # type: _PurposeType
 
 
 class SSLSocket(socket.socket):
@@ -151,12 +151,12 @@ class SSLSocket(socket.socket):
 
 
 class SSLContext:
-    check_hostname = ... # type: bool
-    options = ... # type: int
+    check_hostname = ...  # type: bool
+    options = ...  # type: int
     @property
     def protocol(self) -> int: ...
-    verify_flags = ... # type: int
-    verify_mode = ... # type: int
+    verify_flags = ...  # type: int
+    verify_mode = ...  # type: int
     def __init__(self, protocol: int) -> None: ...
     def cert_store_stats(self) -> Dict[str, int]: ...
     def load_cert_chain(self, certfile: str, keyfile: Optional[str] = ...,

stdlib/2/struct.pyi

@@ -16,8 +16,8 @@ def unpack_from(fmt: str, buffer: Any, offset: int = ...) -> Tuple[Any, ...]: ..
 def calcsize(fmt: str) -> int: ...
 
 class Struct:
-    format = ... # type: str
-    size = ... # type: int
+    format = ...  # type: str
+    size = ...  # type: int
 
     def __init__(self, format: str) -> None: ...
 

stdlib/2/subprocess.pyi

@@ -52,20 +52,20 @@ def check_output(args: Union[str, Sequence[str]],
                  startupinfo: Any = ...,
                  creationflags: int = ...) -> str: ...
 
-PIPE = ... # type: int
-STDOUT = ... # type: int
+PIPE = ...  # type: int
+STDOUT = ...  # type: int
 
 class CalledProcessError(Exception):
     returncode = 0
     cmd = ...  # type: str
-    output = ...  # type: str # May be None
+    output = ...  # type: str  # May be None
 
     def __init__(self, returncode: int, cmd: str, output: Optional[str] = ...) -> None: ...
 
 class Popen:
-    stdin = ... # type: Optional[IO[Any]]
-    stdout = ... # type: Optional[IO[Any]]
-    stderr = ... # type: Optional[IO[Any]]
+    stdin = ...  # type: Optional[IO[Any]]
+    stdout = ...  # type: Optional[IO[Any]]
+    stderr = ...  # type: Optional[IO[Any]]
     pid = 0
     returncode = 0
 
@@ -99,11 +99,11 @@ def getoutput(cmd: str) -> str: ...
 
 # Windows-only: STARTUPINFO etc.
 
-STD_INPUT_HANDLE = ... # type: Any
-STD_OUTPUT_HANDLE = ... # type: Any
-STD_ERROR_HANDLE = ... # type: Any
-SW_HIDE = ... # type: Any
-STARTF_USESTDHANDLES = ... # type: Any
-STARTF_USESHOWWINDOW = ... # type: Any
-CREATE_NEW_CONSOLE = ... # type: Any
-CREATE_NEW_PROCESS_GROUP = ... # type: Any
+STD_INPUT_HANDLE = ...  # type: Any
+STD_OUTPUT_HANDLE = ...  # type: Any
+STD_ERROR_HANDLE = ...  # type: Any
+SW_HIDE = ...  # type: Any
+STARTF_USESTDHANDLES = ...  # type: Any
+STARTF_USESHOWWINDOW = ...  # type: Any
+CREATE_NEW_CONSOLE = ...  # type: Any
+CREATE_NEW_PROCESS_GROUP = ...  # type: Any

stdlib/2/sys.pyi

@@ -131,6 +131,6 @@ def getprofile() -> None: ...
 def gettrace() -> None: ...
 def setcheckinterval(interval: int) -> None: ...  # deprecated
 def setdlopenflags(n: int) -> None: ...
-def setprofile(profilefunc: Any) -> None: ... # TODO type
+def setprofile(profilefunc: Any) -> None: ...  # TODO type
 def setrecursionlimit(limit: int) -> None: ...
-def settrace(tracefunc: Any) -> None: ... # TODO type
+def settrace(tracefunc: Any) -> None: ...  # TODO type

stdlib/2/textwrap.pyi

@@ -7,23 +7,23 @@ from typing import Any
 class _unicode: ...
 
 class TextWrapper:
-    whitespace_trans = ... # type: Any
-    unicode_whitespace_trans = ... # type: Any
-    uspace = ... # type: Any
-    wordsep_re = ... # type: Any
-    wordsep_simple_re = ... # type: Any
-    sentence_end_re = ... # type: Any
-    width = ... # type: Any
-    initial_indent = ... # type: Any
-    subsequent_indent = ... # type: Any
-    expand_tabs = ... # type: Any
-    replace_whitespace = ... # type: Any
-    fix_sentence_endings = ... # type: Any
-    break_long_words = ... # type: Any
-    drop_whitespace = ... # type: Any
-    break_on_hyphens = ... # type: Any
-    wordsep_re_uni = ... # type: Any
-    wordsep_simple_re_uni = ... # type: Any
+    whitespace_trans = ...  # type: Any
+    unicode_whitespace_trans = ...  # type: Any
+    uspace = ...  # type: Any
+    wordsep_re = ...  # type: Any
+    wordsep_simple_re = ...  # type: Any
+    sentence_end_re = ...  # type: Any
+    width = ...  # type: Any
+    initial_indent = ...  # type: Any
+    subsequent_indent = ...  # type: Any
+    expand_tabs = ...  # type: Any
+    replace_whitespace = ...  # type: Any
+    fix_sentence_endings = ...  # type: Any
+    break_long_words = ...  # type: Any
+    drop_whitespace = ...  # type: Any
+    break_on_hyphens = ...  # type: Any
+    wordsep_re_uni = ...  # type: Any
+    wordsep_simple_re_uni = ...  # type: Any
     def __init__(self, width=..., initial_indent=..., subsequent_indent=..., expand_tabs=..., replace_whitespace=..., fix_sentence_endings=..., break_long_words=..., drop_whitespace=..., break_on_hyphens=...) -> None: ...
     def wrap(self, text): ...
     def fill(self, text): ...

stdlib/2/time.pyi

@@ -8,7 +8,7 @@ accept2dyear = False
 altzone = 0
 daylight = 0
 timezone = 0
-tzname = ... # type: Tuple[str, str]
+tzname = ...  # type: Tuple[str, str]
 
 class struct_time(NamedTuple('_struct_time',
                              [('tm_year', int), ('tm_mon', int), ('tm_mday', int),

stdlib/2/types.pyi

@@ -103,24 +103,24 @@ FileType = file
 XRangeType = xrange
 
 class TracebackType:
-    tb_frame = ... # type: FrameType
-    tb_lasti = ... # type: int
-    tb_lineno = ... # type: int
-    tb_next = ... # type: TracebackType
+    tb_frame = ...  # type: FrameType
+    tb_lasti = ...  # type: int
+    tb_lineno = ...  # type: int
+    tb_next = ...  # type: TracebackType
 
 class FrameType:
-    f_back = ... # type: FrameType
-    f_builtins = ... # type: Dict[str, Any]
-    f_code = ... # type: CodeType
-    f_exc_type = ... # type: None
-    f_exc_value = ... # type: None
-    f_exc_traceback = ... # type: None
-    f_globals = ... # type: Dict[str, Any]
-    f_lasti = ... # type: int
-    f_lineno = ... # type: int
-    f_locals = ... # type: Dict[str, Any]
-    f_restricted = ... # type: bool
-    f_trace = ... # type: Callable[[], None]
+    f_back = ...  # type: FrameType
+    f_builtins = ...  # type: Dict[str, Any]
+    f_code = ...  # type: CodeType
+    f_exc_type = ...  # type: None
+    f_exc_value = ...  # type: None
+    f_exc_traceback = ...  # type: None
+    f_globals = ...  # type: Dict[str, Any]
+    f_lasti = ...  # type: int
+    f_lineno = ...  # type: int
+    f_locals = ...  # type: Dict[str, Any]
+    f_restricted = ...  # type: bool
+    f_trace = ...  # type: Callable[[], None]
 
     def clear(self) -> None: pass
 

stdlib/2/typing.pyi

@@ -281,7 +281,7 @@ class TextIO(IO[unicode]):
     @property
     def line_buffering(self) -> bool: ...
     @property
-    def newlines(self) -> Any: ... # None, str or tuple
+    def newlines(self) -> Any: ...  # None, str or tuple
     @abstractmethod
     def __enter__(self) -> TextIO: ...
 

stdlib/2/unicodedata.pyi

@@ -2,10 +2,10 @@
 
 from typing import Any, TypeVar, Union
 
-ucd_3_2_0 = ... # type: UCD
-unidata_version = ... # type: str
+ucd_3_2_0 = ...  # type: UCD
+unidata_version = ...  # type: str
 # PyCapsule
-ucnhash_CAPI = ... # type: Any
+ucnhash_CAPI = ...  # type: Any
 
 _default = TypeVar("_default")
 
@@ -23,7 +23,7 @@ def normalize(form: str, unistr: unicode) -> unicode: ...
 def numeric(chr, default: _default = ...) -> Union[float, _default]: ...
 
 class UCD(object):
-    unidata_version = ... # type: str
+    unidata_version = ...  # type: str
     # The methods below are constructed from the same array in C
     # (unicodedata_functions) and hence identical to the methods above.
     def bidirectional(self, unichr: unicode) -> str: ...

stdlib/2/unittest.pyi

@@ -24,29 +24,29 @@ class Testable(metaclass=ABCMeta):
 # TODO ABC for test runners?
 
 class TestResult:
-    errors = ... # type: List[Tuple[Testable, str]]
-    failures = ... # type: List[Tuple[Testable, str]]
+    errors = ...  # type: List[Tuple[Testable, str]]
+    failures = ...  # type: List[Tuple[Testable, str]]
     testsRun = 0
-    shouldStop = ... # type: bool
+    shouldStop = ...  # type: bool
 
     def wasSuccessful(self) -> bool: ...
     def stop(self) -> None: ...
     def startTest(self, test: Testable) -> None: ...
     def stopTest(self, test: Testable) -> None: ...
     def addError(self, test: Testable,
-                  err: Tuple[type, Any, Any]) -> None: ... # TODO
+                  err: Tuple[type, Any, Any]) -> None: ...  # TODO
     def addFailure(self, test: Testable,
-                    err: Tuple[type, Any, Any]) -> None: ... # TODO
+                    err: Tuple[type, Any, Any]) -> None: ...  # TODO
     def addSuccess(self, test: Testable) -> None: ...
 
 class _AssertRaisesBaseContext:
-    expected = ... # type: Any
-    failureException = ... # type: type
+    expected = ...  # type: Any
+    failureException = ...  # type: type
     obj_name = ...  # type: str
-    expected_regex = ... # type: Pattern[str]
+    expected_regex = ...  # type: Pattern[str]
 
 class _AssertRaisesContext(_AssertRaisesBaseContext):
-    exception = ... # type: Any # TODO precise type
+    exception = ...  # type: Any # TODO precise type
     def __enter__(self) -> _AssertRaisesContext: ...
     def __exit__(self, exc_type, exc_value, tb) -> bool: ...
 
@@ -131,7 +131,7 @@ class TestCase(Testable):
     def countTestCases(self) -> int: ...
     def defaultTestResult(self) -> TestResult: ...
     def id(self) -> str: ...
-    def shortDescription(self) -> str: ... # May return None
+    def shortDescription(self) -> str: ...  # May return None
     def addCleanup(function: Any, *args: Any, **kwargs: Any) -> None: ...
     def skipTest(self, reason: Any) -> None: ...
 
@@ -170,7 +170,7 @@ def skip(reason: str) -> Any: ...
 
 def main(module: str = ..., defaultTest: str = ...,
          argv: List[str] = ..., testRunner: Any = ...,
-         testLoader: Any = ...) -> None: ... # TODO types
+         testLoader: Any = ...) -> None: ...  # TODO types
 
 # private but occasionally used
 util = ...  # type: module

stdlib/2/urllib.pyi

@@ -10,24 +10,24 @@ def urlretrieve(url, filename=..., reporthook=..., data=..., context=...): ...
 def urlcleanup() -> None: ...
 
 class ContentTooShortError(IOError):
-    content = ... # type: Any
+    content = ...  # type: Any
     def __init__(self, message, content) -> None: ...
 
 class URLopener:
-    version = ... # type: Any
-    proxies = ... # type: Any
-    key_file = ... # type: Any
-    cert_file = ... # type: Any
-    context = ... # type: Any
-    addheaders = ... # type: Any
-    tempcache = ... # type: Any
-    ftpcache = ... # type: Any
+    version = ...  # type: Any
+    proxies = ...  # type: Any
+    key_file = ...  # type: Any
+    cert_file = ...  # type: Any
+    context = ...  # type: Any
+    addheaders = ...  # type: Any
+    tempcache = ...  # type: Any
+    ftpcache = ...  # type: Any
     def __init__(self, proxies: Mapping[str, str] = ..., context=..., **x509) -> None: ...
     def __del__(self): ...
     def close(self): ...
     def cleanup(self): ...
     def addheader(self, *args): ...
-    type = ... # type: Any
+    type = ...  # type: Any
     def open(self, fullurl: str, data=...): ...
     def open_unknown(self, fullurl, data=...): ...
     def open_unknown_proxy(self, proxy, fullurl, data=...): ...
@@ -42,9 +42,9 @@ class URLopener:
     def open_data(self, url, data=...): ...
 
 class FancyURLopener(URLopener):
-    auth_cache = ... # type: Any
-    tries = ... # type: Any
-    maxtries = ... # type: Any
+    auth_cache = ...  # type: Any
+    tries = ...  # type: Any
+    maxtries = ...  # type: Any
     def __init__(self, *args, **kwargs) -> None: ...
     def http_error_default(self, url, fp, errcode, errmsg, headers): ...
     def http_error_302(self, url, fp, errcode, errmsg, headers, data=...): ...
@@ -62,17 +62,17 @@ class FancyURLopener(URLopener):
     def prompt_user_passwd(self, host, realm): ...
 
 class ftpwrapper:
-    user = ... # type: Any
-    passwd = ... # type: Any
-    host = ... # type: Any
-    port = ... # type: Any
-    dirs = ... # type: Any
-    timeout = ... # type: Any
-    refcount = ... # type: Any
-    keepalive = ... # type: Any
+    user = ...  # type: Any
+    passwd = ...  # type: Any
+    host = ...  # type: Any
+    port = ...  # type: Any
+    dirs = ...  # type: Any
+    timeout = ...  # type: Any
+    refcount = ...  # type: Any
+    keepalive = ...  # type: Any
     def __init__(self, user, passwd, host, port, dirs, timeout=..., persistent=...) -> None: ...
-    busy = ... # type: Any
-    ftp = ... # type: Any
+    busy = ...  # type: Any
+    ftp = ...  # type: Any
     def init(self): ...
     def retrfile(self, file, type): ...
     def endtransfer(self): ...
@@ -81,31 +81,31 @@ class ftpwrapper:
     def real_close(self): ...
 
 class addbase:
-    fp = ... # type: Any
-    read = ... # type: Any
-    readline = ... # type: Any
-    readlines = ... # type: Any
-    fileno = ... # type: Any
-    __iter__ = ... # type: Any
-    next = ... # type: Any
+    fp = ...  # type: Any
+    read = ...  # type: Any
+    readline = ...  # type: Any
+    readlines = ...  # type: Any
+    fileno = ...  # type: Any
+    __iter__ = ...  # type: Any
+    next = ...  # type: Any
     def __init__(self, fp) -> None: ...
     def close(self): ...
 
 class addclosehook(addbase):
-    closehook = ... # type: Any
-    hookargs = ... # type: Any
+    closehook = ...  # type: Any
+    hookargs = ...  # type: Any
     def __init__(self, fp, closehook, *hookargs) -> None: ...
     def close(self): ...
 
 class addinfo(addbase):
-    headers = ... # type: Any
+    headers = ...  # type: Any
     def __init__(self, fp, headers) -> None: ...
     def info(self): ...
 
 class addinfourl(addbase):
-    headers = ... # type: Any
-    url = ... # type: Any
-    code = ... # type: Any
+    headers = ...  # type: Any
+    url = ...  # type: Any
+    code = ...  # type: Any
     def __init__(self, fp, headers, url, code=...) -> None: ...
     def info(self): ...
     def getcode(self): ...

stdlib/2/urllib2.pyi

@@ -10,11 +10,11 @@ class HTTPError(URLError, addinfourl):
     headers = ...  # type: Dict[str, str]
 
 class Request(object):
-    host = ... # type: str
-    port = ... # type: str
-    data = ... # type: str
-    headers = ... # type: Dict[str, str]
-    unverifiable = ... # type: bool
+    host = ...  # type: str
+    port = ...  # type: str
+    data = ...  # type: str
+    headers = ...  # type: Dict[str, str]
+    unverifiable = ...  # type: bool
     type = ...
     origin_req_host= ...
     unredirected_hdrs = ...
@@ -48,7 +48,7 @@ def install_opener(opener): ...
 def build_opener(*handlers): ...
 
 class BaseHandler:
-    handler_order = ... # int
+    handler_order = ...  # int
 
     def add_parent(self, parent) -> None: ...
     def close(self) -> None: ...
@@ -61,14 +61,14 @@ class HTTPDefaultErrorHandler(BaseHandler):
     def http_error_default(self, req, fp, code, msg, hdrs): ...
 
 class HTTPRedirectHandler(BaseHandler):
-    max_repeats = ... # int
-    max_redirections = ... # int
+    max_repeats = ...  # int
+    max_redirections = ...  # int
     def redirect_request(self, req, fp, code, msg, headers, newurl): ...
     def http_error_301(self, req, fp, code, msg, headers): ...
     def http_error_302(self, req, fp, code, msg, headers): ...
     def http_error_303(self, req, fp, code, msg, headers): ...
     def http_error_307(self, req, fp, code, msg, headers): ...
-    inf_msg = ... # type: str
+    inf_msg = ...  # type: str
 
 
 class ProxyHandler(BaseHandler):
@@ -91,11 +91,11 @@ class AbstractBasicAuthHandler:
     def retry_http_basic_auth(self, host, req, realm): ...
 
 class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
-    auth_header = ... # type: str
+    auth_header = ...  # type: str
     def http_error_401(self, req, fp, code, msg, headers): ...
 
 class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
-    auth_header = ... # type: str
+    auth_header = ...  # type: str
     def http_error_407(self, req, fp, code, msg, headers): ...
 
 class AbstractDigestAuthHandler:
@@ -109,13 +109,13 @@ class AbstractDigestAuthHandler:
     def get_entity_digest(self, data, chal): ...
 
 class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
-    auth_header = ... # str
-    handler_order = ... # int
+    auth_header = ...  # str
+    handler_order = ...  # int
     def http_error_401(self, req, fp, code, msg, headers): ...
 
 class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
-    auth_header = ... # str
-    handler_order = ... # int
+    auth_header = ...  # str
+    handler_order = ...  # int
     def http_error_407(self, req, fp, code, msg, headers): ...
 
 class AbstractHTTPHandler(BaseHandler):

stdlib/2/uuid.pyi

@@ -4,25 +4,25 @@ _int_type = int
 
 class _UUIDFields(NamedTuple('_UUIDFields',
                              [('time_low', int), ('time_mid', int), ('time_hi_version', int), ('clock_seq_hi_variant', int), ('clock_seq_low', int), ('node', int)])):
-    time = ... # type: int
-    clock_seq = ... # type: int
+    time = ...  # type: int
+    clock_seq = ...  # type: int
 
 class UUID:
     def __init__(self, hex: str = ..., bytes: str = ..., bytes_le: str = ...,
                   fields: Tuple[int, int, int, int, int, int] = ..., int: int = ..., version: Any = ...) -> None: ...
-    bytes = ... # type: str
-    bytes_le = ... # type: str
-    fields = ... # type: _UUIDFields
-    hex = ... # type: str
-    int = ... # type: _int_type
-    urn = ... # type: str
-    variant = ... # type: _int_type
-    version = ... # type: _int_type
+    bytes = ...  # type: str
+    bytes_le = ...  # type: str
+    fields = ...  # type: _UUIDFields
+    hex = ...  # type: str
+    int = ...  # type: _int_type
+    urn = ...  # type: str
+    variant = ...  # type: _int_type
+    version = ...  # type: _int_type
 
-RESERVED_NCS = ... # type: int
-RFC_4122 = ... # type: int
-RESERVED_MICROSOFT = ... # type: int
-RESERVED_FUTURE = ... # type: int
+RESERVED_NCS = ...  # type: int
+RFC_4122 = ...  # type: int
+RESERVED_MICROSOFT = ...  # type: int
+RESERVED_FUTURE = ...  # type: int
 
 def getnode() -> int: ...
 def uuid1(node: int = ..., clock_seq: int = ...) -> UUID: ...
@@ -30,7 +30,7 @@ def uuid3(namespace: UUID, name: str) -> UUID: ...
 def uuid4() -> UUID: ...
 def uuid5(namespace: UUID, name: str) -> UUID: ...
 
-NAMESPACE_DNS = ... # type: UUID
-NAMESPACE_URL = ... # type: UUID
-NAMESPACE_OID = ... # type: UUID
-NAMESPACE_X500 = ... # type: UUID
+NAMESPACE_DNS = ...  # type: UUID
+NAMESPACE_URL = ...  # type: UUID
+NAMESPACE_OID = ...  # type: UUID
+NAMESPACE_X500 = ...  # type: UUID

stdlib/2/weakref.pyi

@@ -7,7 +7,7 @@ from _weakref import (getweakrefcount, getweakrefs, ref, proxy,
                       CallableProxyType, ProxyType, ReferenceType)
 from _weakrefset import WeakSet
 
-ProxyTypes = ... # type: Any
+ProxyTypes = ...  # type: Any
 
 _KT = TypeVar('_KT')
 _VT = TypeVar('_VT')
@@ -42,6 +42,6 @@ class WeakKeyDictionary(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
 
 # TODO: make generic
 class KeyedRef(ReferenceType):
-    key = ... # type: Any
+    key = ...  # type: Any
     def __new__(type, ob, callback, key): ...
     def __init__(self, ob, callback, key): ...

stdlib/2/wsgiref/validate.pyi

@@ -9,7 +9,7 @@ class WSGIWarning(Warning): ...
 def validator(application): ...
 
 class InputWrapper:
-    input = ... # type: Any
+    input = ...  # type: Any
     def __init__(self, wsgi_input): ...
     def read(self, *args): ...
     def readline(self): ...
@@ -18,7 +18,7 @@ class InputWrapper:
     def close(self): ...
 
 class ErrorWrapper:
-    errors = ... # type: Any
+    errors = ...  # type: Any
     def __init__(self, wsgi_errors): ...
     def write(self, s): ...
     def flush(self): ...
@@ -26,20 +26,20 @@ class ErrorWrapper:
     def close(self): ...
 
 class WriteWrapper:
-    writer = ... # type: Any
+    writer = ...  # type: Any
     def __init__(self, wsgi_writer): ...
     def __call__(self, s): ...
 
 class PartialIteratorWrapper:
-    iterator = ... # type: Any
+    iterator = ...  # type: Any
     def __init__(self, wsgi_iterator): ...
     def __iter__(self): ...
 
 class IteratorWrapper:
-    original_iterator = ... # type: Any
-    iterator = ... # type: Any
-    closed = ... # type: Any
-    check_start_response = ... # type: Any
+    original_iterator = ...  # type: Any
+    iterator = ...  # type: Any
+    closed = ...  # type: Any
+    check_start_response = ...  # type: Any
     def __init__(self, wsgi_iterator, check_start_response): ...
     def __iter__(self): ...
     def next(self): ...

stdlib/2/xml/etree/ElementInclude.pyi

@@ -5,9 +5,9 @@
 from typing import Union, Optional, Callable
 from xml.etree.ElementTree import Element
 
-XINCLUDE = ... # type: str
-XINCLUDE_INCLUDE = ... # type: str
-XINCLUDE_FALLBACK = ... # type: str
+XINCLUDE = ...  # type: str
+XINCLUDE_INCLUDE = ...  # type: str
+XINCLUDE_FALLBACK = ...  # type: str
 
 class FatalIncludeError(SyntaxError): ...
 

stdlib/2/xml/etree/ElementPath.pyi

@@ -5,7 +5,7 @@
 from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional
 from xml.etree.ElementTree import Element
 
-xpath_tokenizer_re = ... # type: Pattern
+xpath_tokenizer_re = ...  # type: Pattern
 
 _token = Tuple[str, str]
 _next = Callable[[], _token]
@@ -20,11 +20,11 @@ def prepare_descendant(next: _next, token: _token) -> _callback: ...
 def prepare_parent(next: _next, token: _token) -> _callback: ...
 def prepare_predicate(next: _next, token: _token) -> _callback: ...
 
-ops = ... # type: Dict[str, Callable[[_next, _token], _callback]]
+ops = ...  # type: Dict[str, Callable[[_next, _token], _callback]]
 
 class _SelectorContext:
-    parent_map = ... # type: Dict[Element, Element]
-    root = ... # type: Element
+    parent_map = ...  # type: Dict[Element, Element]
+    root = ...  # type: Element
     def __init__(self, root: Element) -> None: ...
 
 _T = TypeVar('_T')

stdlib/2/xml/etree/ElementTree.pyi

@@ -5,7 +5,7 @@
 from typing import Any, AnyStr, Union, IO, Callable, Dict, List, Tuple, Sequence, Iterator, TypeVar, Optional, Generator
 import io
 
-VERSION = ... # type: str
+VERSION = ...  # type: str
 
 _Ss = TypeVar('_Ss', str, bytes)
 _T = TypeVar('_T')
@@ -22,10 +22,10 @@ class ParseError(SyntaxError): ...
 def iselement(element: 'Element') -> bool: ...
 
 class Element(Sequence['Element']):
-    tag = ... # type: _str_or_bytes
-    attrib = ... # type: Dict[_str_or_bytes, _str_or_bytes]
-    text = ... # type: Optional[_str_or_bytes]
-    tail = ... # type: Optional[_str_or_bytes]
+    tag = ...  # type: _str_or_bytes
+    attrib = ...  # type: Dict[_str_or_bytes, _str_or_bytes]
+    text = ...  # type: Optional[_str_or_bytes]
+    tail = ...  # type: Optional[_str_or_bytes]
     def __init__(self, tag: Union[AnyStr, Callable[..., 'Element']], attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> None: ...
     def append(self, element: 'Element') -> None: ...
     def clear(self) -> None: ...
@@ -56,10 +56,10 @@ def SubElement(parent: Element, tag: AnyStr, attrib: Dict[AnyStr, AnyStr]=..., *
 def Comment(text: _str_or_bytes=...) -> Element: ...
 def ProcessingInstruction(target: str, text: str=...) -> Element: ...
 
-PI = ... # type: Callable[..., Element]
+PI = ...  # type: Callable[..., Element]
 
 class QName:
-    text = ... # type: str
+    text = ...  # type: str
     def __init__(self, text_or_uri: str, tag: str=...) -> None: ...
 
 
@@ -86,7 +86,7 @@ def parse(source: _file_or_filename, parser: 'XMLParser'=...) -> ElementTree: ..
 def iterparse(source: _file_or_filename, events: Sequence[str]=..., parser: 'XMLParser'=...) -> Iterator[Tuple[str, Element]]: ...
 
 class _IterParseIterator:
-    root = ... # type: Any
+    root = ...  # type: Any
     def __init__(self, source: _file_or_filename, events: Sequence[str], parser: 'XMLParser', close_source: bool=...) -> None: ...
     def next(self) -> Tuple[str, Element]: ...
     def __iter__(self) -> _IterParseIterator: ...
@@ -94,7 +94,7 @@ class _IterParseIterator:
 def XML(text: AnyStr, parser: 'XMLParser'=...) -> Element: ...
 def XMLID(text: AnyStr, parser: 'XMLParser'=...) -> Tuple[Element, Dict[str, Element]]: ...
 # TODO-improve this type
-fromstring = ... # type: Callable[..., Element]
+fromstring = ...  # type: Callable[..., Element]
 def fromstringlist(sequence: Sequence[AnyStr], parser: 'XMLParser'=...) -> Element: ...
 
 class TreeBuilder:
@@ -105,11 +105,11 @@ class TreeBuilder:
     def end(self, tag: AnyStr) -> Element: ...
 
 class XMLParser:
-    parser = ... # type: Any
-    target = ... # type: TreeBuilder
+    parser = ...  # type: Any
+    target = ...  # type: TreeBuilder
     # TODO-what is entity used for???
-    entity = ... # type: Any
-    version = ... # type: str
+    entity = ...  # type: Any
+    version = ...  # type: str
     def __init__(self, html: int=..., target: TreeBuilder=..., encoding: str=...) -> None: ...
     def doctype(self, name: str, pubid: str, system: str) -> None: ...
     def close(self) -> Any: ...  # TODO-most of the time, this will be Element, but it can be anything target.close() returns

stdlib/2/zlib.pyi

@@ -1,19 +1,19 @@
 # Stubs for zlib (Python 2.7)
 
-DEFLATED = ... # type: int
-DEF_MEM_LEVEL = ... # type: int
-MAX_WBITS = ... # type: int
-ZLIB_VERSION = ... # type: str
-Z_BEST_COMPRESSION = ... # type: int
-Z_BEST_SPEED = ... # type: int
-Z_DEFAULT_COMPRESSION = ... # type: int
-Z_DEFAULT_STRATEGY = ... # type: int
-Z_FILTERED = ... # type: int
-Z_FINISH = ... # type: int
-Z_FULL_FLUSH = ... # type: int
-Z_HUFFMAN_ONLY = ... # type: int
-Z_NO_FLUSH = ... # type: int
-Z_SYNC_FLUSH = ... # type: int
+DEFLATED = ...  # type: int
+DEF_MEM_LEVEL = ...  # type: int
+MAX_WBITS = ...  # type: int
+ZLIB_VERSION = ...  # type: str
+Z_BEST_COMPRESSION = ...  # type: int
+Z_BEST_SPEED = ...  # type: int
+Z_DEFAULT_COMPRESSION = ...  # type: int
+Z_DEFAULT_STRATEGY = ...  # type: int
+Z_FILTERED = ...  # type: int
+Z_FINISH = ...  # type: int
+Z_FULL_FLUSH = ...  # type: int
+Z_HUFFMAN_ONLY = ...  # type: int
+Z_NO_FLUSH = ...  # type: int
+Z_SYNC_FLUSH = ...  # type: int
 
 
 class error(Exception): ...

stdlib/2and3/errno.pyi

@@ -3,7 +3,7 @@
 from typing import Mapping
 import sys
 
-errorcode = ... # type: Mapping[int, str]
+errorcode = ...  # type: Mapping[int, str]
 
 EPERM = ...  # type: int
 ENOENT = ...  # type: int

stdlib/2and3/logging/__init__.pyi

@@ -25,8 +25,8 @@ class Logger:
     level = ...  # type: int
     parent = ...  # type: Union[Logger, PlaceHolder]
     propagate = ...  # type: bool
-    handlers = ... # type: List[Handler]
-    disabled = ... # type: int
+    handlers = ...  # type: List[Handler]
+    disabled = ...  # type: int
     def setLevel(self, lvl: Union[int, str]) -> None: ...
     def isEnabledFor(self, lvl: int) -> bool: ...
     def getEffectiveLevel(self) -> int: ...

stdlib/2and3/mmap.pyi

@@ -18,19 +18,19 @@ class _ContextManager(Generic[_C]):
                  exc_tb: Optional[TracebackType]) -> bool: ...
 
 
-ACCESS_READ = ... # type: int
-ACCESS_WRITE = ... # type: int
-ACCESS_COPY = ... # type: int
+ACCESS_READ = ...  # type: int
+ACCESS_WRITE = ...  # type: int
+ACCESS_COPY = ...  # type: int
 
-ALLOCATIONGRANULARITY = ... # type: int
+ALLOCATIONGRANULARITY = ...  # type: int
 
 if sys.platform != 'win32':
-    MAP_PRIVATE = ... # type: int
-    MAP_SHARED = ... # type: int
-    PROT_READ = ... # type: int
-    PROT_WRITE = ... # type: int
+    MAP_PRIVATE = ...  # type: int
+    MAP_SHARED = ...  # type: int
+    PROT_READ = ...  # type: int
+    PROT_WRITE = ...  # type: int
 
-    PAGESIZE = ... # type: int
+    PAGESIZE = ...  # type: int
 
 class _mmap(Generic[_T]):
     if sys.platform == 'win32':
@@ -61,7 +61,7 @@ class _mmap(Generic[_T]):
 if sys.version_info >= (3,):
     class mmap(_mmap, _ContextManager[mmap], Iterable[bytes], Container[bytes],
                Sized, Reversible[bytes]):
-        closed = ... # type: bool
+        closed = ...  # type: bool
         def rfind(self, sub: bytes, start: int = ..., stop: int = ...) -> int: ...
         @overload
         def __getitem__(self, index: int) -> int: ...

stdlib/2and3/termios.pyi

@@ -6,237 +6,237 @@ _FD = Union[int, IO[str]]
 _Attr = List[Union[int, List[bytes]]]
 
 # TODO constants not really documented
-B0 = ... # type: int
-B1000000 = ... # type: int
-B110 = ... # type: int
-B115200 = ... # type: int
-B1152000 = ... # type: int
-B1200 = ... # type: int
-B134 = ... # type: int
-B150 = ... # type: int
-B1500000 = ... # type: int
-B1800 = ... # type: int
-B19200 = ... # type: int
-B200 = ... # type: int
-B2000000 = ... # type: int
-B230400 = ... # type: int
-B2400 = ... # type: int
-B2500000 = ... # type: int
-B300 = ... # type: int
-B3000000 = ... # type: int
-B3500000 = ... # type: int
-B38400 = ... # type: int
-B4000000 = ... # type: int
-B460800 = ... # type: int
-B4800 = ... # type: int
-B50 = ... # type: int
-B500000 = ... # type: int
-B57600 = ... # type: int
-B576000 = ... # type: int
-B600 = ... # type: int
-B75 = ... # type: int
-B921600 = ... # type: int
-B9600 = ... # type: int
-BRKINT = ... # type: int
-BS0 = ... # type: int
-BS1 = ... # type: int
-BSDLY = ... # type: int
-CBAUD = ... # type: int
-CBAUDEX = ... # type: int
-CDSUSP = ... # type: int
-CEOF = ... # type: int
-CEOL = ... # type: int
-CEOT = ... # type: int
-CERASE = ... # type: int
-CFLUSH = ... # type: int
-CIBAUD = ... # type: int
-CINTR = ... # type: int
-CKILL = ... # type: int
-CLNEXT = ... # type: int
-CLOCAL = ... # type: int
-CQUIT = ... # type: int
-CR0 = ... # type: int
-CR1 = ... # type: int
-CR2 = ... # type: int
-CR3 = ... # type: int
-CRDLY = ... # type: int
-CREAD = ... # type: int
-CRPRNT = ... # type: int
-CRTSCTS = ... # type: int
-CS5 = ... # type: int
-CS6 = ... # type: int
-CS7 = ... # type: int
-CS8 = ... # type: int
-CSIZE = ... # type: int
-CSTART = ... # type: int
-CSTOP = ... # type: int
-CSTOPB = ... # type: int
-CSUSP = ... # type: int
-CWERASE = ... # type: int
-ECHO = ... # type: int
-ECHOCTL = ... # type: int
-ECHOE = ... # type: int
-ECHOK = ... # type: int
-ECHOKE = ... # type: int
-ECHONL = ... # type: int
-ECHOPRT = ... # type: int
-EXTA = ... # type: int
-EXTB = ... # type: int
-FF0 = ... # type: int
-FF1 = ... # type: int
-FFDLY = ... # type: int
-FIOASYNC = ... # type: int
-FIOCLEX = ... # type: int
-FIONBIO = ... # type: int
-FIONCLEX = ... # type: int
-FIONREAD = ... # type: int
-FLUSHO = ... # type: int
-HUPCL = ... # type: int
-ICANON = ... # type: int
-ICRNL = ... # type: int
-IEXTEN = ... # type: int
-IGNBRK = ... # type: int
-IGNCR = ... # type: int
-IGNPAR = ... # type: int
-IMAXBEL = ... # type: int
-INLCR = ... # type: int
-INPCK = ... # type: int
-IOCSIZE_MASK = ... # type: int
-IOCSIZE_SHIFT = ... # type: int
-ISIG = ... # type: int
-ISTRIP = ... # type: int
-IUCLC = ... # type: int
-IXANY = ... # type: int
-IXOFF = ... # type: int
-IXON = ... # type: int
-NCC = ... # type: int
-NCCS = ... # type: int
-NL0 = ... # type: int
-NL1 = ... # type: int
-NLDLY = ... # type: int
-NOFLSH = ... # type: int
-N_MOUSE = ... # type: int
-N_PPP = ... # type: int
-N_SLIP = ... # type: int
-N_STRIP = ... # type: int
-N_TTY = ... # type: int
-OCRNL = ... # type: int
-OFDEL = ... # type: int
-OFILL = ... # type: int
-OLCUC = ... # type: int
-ONLCR = ... # type: int
-ONLRET = ... # type: int
-ONOCR = ... # type: int
-OPOST = ... # type: int
-PARENB = ... # type: int
-PARMRK = ... # type: int
-PARODD = ... # type: int
-PENDIN = ... # type: int
-TAB0 = ... # type: int
-TAB1 = ... # type: int
-TAB2 = ... # type: int
-TAB3 = ... # type: int
-TABDLY = ... # type: int
-TCFLSH = ... # type: int
-TCGETA = ... # type: int
-TCGETS = ... # type: int
-TCIFLUSH = ... # type: int
-TCIOFF = ... # type: int
-TCIOFLUSH = ... # type: int
-TCION = ... # type: int
-TCOFLUSH = ... # type: int
-TCOOFF = ... # type: int
-TCOON = ... # type: int
-TCSADRAIN = ... # type: int
-TCSAFLUSH = ... # type: int
-TCSANOW = ... # type: int
-TCSBRK = ... # type: int
-TCSBRKP = ... # type: int
-TCSETA = ... # type: int
-TCSETAF = ... # type: int
-TCSETAW = ... # type: int
-TCSETS = ... # type: int
-TCSETSF = ... # type: int
-TCSETSW = ... # type: int
-TCXONC = ... # type: int
-TIOCCONS = ... # type: int
-TIOCEXCL = ... # type: int
-TIOCGETD = ... # type: int
-TIOCGICOUNT = ... # type: int
-TIOCGLCKTRMIOS = ... # type: int
-TIOCGPGRP = ... # type: int
-TIOCGSERIAL = ... # type: int
-TIOCGSOFTCAR = ... # type: int
-TIOCGWINSZ = ... # type: int
-TIOCINQ = ... # type: int
-TIOCLINUX = ... # type: int
-TIOCMBIC = ... # type: int
-TIOCMBIS = ... # type: int
-TIOCMGET = ... # type: int
-TIOCMIWAIT = ... # type: int
-TIOCMSET = ... # type: int
-TIOCM_CAR = ... # type: int
-TIOCM_CD = ... # type: int
-TIOCM_CTS = ... # type: int
-TIOCM_DSR = ... # type: int
-TIOCM_DTR = ... # type: int
-TIOCM_LE = ... # type: int
-TIOCM_RI = ... # type: int
-TIOCM_RNG = ... # type: int
-TIOCM_RTS = ... # type: int
-TIOCM_SR = ... # type: int
-TIOCM_ST = ... # type: int
-TIOCNOTTY = ... # type: int
-TIOCNXCL = ... # type: int
-TIOCOUTQ = ... # type: int
-TIOCPKT = ... # type: int
-TIOCPKT_DATA = ... # type: int
-TIOCPKT_DOSTOP = ... # type: int
-TIOCPKT_FLUSHREAD = ... # type: int
-TIOCPKT_FLUSHWRITE = ... # type: int
-TIOCPKT_NOSTOP = ... # type: int
-TIOCPKT_START = ... # type: int
-TIOCPKT_STOP = ... # type: int
-TIOCSCTTY = ... # type: int
-TIOCSERCONFIG = ... # type: int
-TIOCSERGETLSR = ... # type: int
-TIOCSERGETMULTI = ... # type: int
-TIOCSERGSTRUCT = ... # type: int
-TIOCSERGWILD = ... # type: int
-TIOCSERSETMULTI = ... # type: int
-TIOCSERSWILD = ... # type: int
-TIOCSER_TEMT = ... # type: int
-TIOCSETD = ... # type: int
-TIOCSLCKTRMIOS = ... # type: int
-TIOCSPGRP = ... # type: int
-TIOCSSERIAL = ... # type: int
-TIOCSSOFTCAR = ... # type: int
-TIOCSTI = ... # type: int
-TIOCSWINSZ = ... # type: int
-TOSTOP = ... # type: int
-VDISCARD = ... # type: int
-VEOF = ... # type: int
-VEOL = ... # type: int
-VEOL2 = ... # type: int
-VERASE = ... # type: int
-VINTR = ... # type: int
-VKILL = ... # type: int
-VLNEXT = ... # type: int
-VMIN = ... # type: int
-VQUIT = ... # type: int
-VREPRINT = ... # type: int
-VSTART = ... # type: int
-VSTOP = ... # type: int
-VSUSP = ... # type: int
-VSWTC = ... # type: int
-VSWTCH = ... # type: int
-VT0 = ... # type: int
-VT1 = ... # type: int
-VTDLY = ... # type: int
-VTIME = ... # type: int
-VWERASE = ... # type: int
-XCASE = ... # type: int
-XTABS = ... # type: int
+B0 = ...  # type: int
+B1000000 = ...  # type: int
+B110 = ...  # type: int
+B115200 = ...  # type: int
+B1152000 = ...  # type: int
+B1200 = ...  # type: int
+B134 = ...  # type: int
+B150 = ...  # type: int
+B1500000 = ...  # type: int
+B1800 = ...  # type: int
+B19200 = ...  # type: int
+B200 = ...  # type: int
+B2000000 = ...  # type: int
+B230400 = ...  # type: int
+B2400 = ...  # type: int
+B2500000 = ...  # type: int
+B300 = ...  # type: int
+B3000000 = ...  # type: int
+B3500000 = ...  # type: int
+B38400 = ...  # type: int
+B4000000 = ...  # type: int
+B460800 = ...  # type: int
+B4800 = ...  # type: int
+B50 = ...  # type: int
+B500000 = ...  # type: int
+B57600 = ...  # type: int
+B576000 = ...  # type: int
+B600 = ...  # type: int
+B75 = ...  # type: int
+B921600 = ...  # type: int
+B9600 = ...  # type: int
+BRKINT = ...  # type: int
+BS0 = ...  # type: int
+BS1 = ...  # type: int
+BSDLY = ...  # type: int
+CBAUD = ...  # type: int
+CBAUDEX = ...  # type: int
+CDSUSP = ...  # type: int
+CEOF = ...  # type: int
+CEOL = ...  # type: int
+CEOT = ...  # type: int
+CERASE = ...  # type: int
+CFLUSH = ...  # type: int
+CIBAUD = ...  # type: int
+CINTR = ...  # type: int
+CKILL = ...  # type: int
+CLNEXT = ...  # type: int
+CLOCAL = ...  # type: int
+CQUIT = ...  # type: int
+CR0 = ...  # type: int
+CR1 = ...  # type: int
+CR2 = ...  # type: int
+CR3 = ...  # type: int
+CRDLY = ...  # type: int
+CREAD = ...  # type: int
+CRPRNT = ...  # type: int
+CRTSCTS = ...  # type: int
+CS5 = ...  # type: int
+CS6 = ...  # type: int
+CS7 = ...  # type: int
+CS8 = ...  # type: int
+CSIZE = ...  # type: int
+CSTART = ...  # type: int
+CSTOP = ...  # type: int
+CSTOPB = ...  # type: int
+CSUSP = ...  # type: int
+CWERASE = ...  # type: int
+ECHO = ...  # type: int
+ECHOCTL = ...  # type: int
+ECHOE = ...  # type: int
+ECHOK = ...  # type: int
+ECHOKE = ...  # type: int
+ECHONL = ...  # type: int
+ECHOPRT = ...  # type: int
+EXTA = ...  # type: int
+EXTB = ...  # type: int
+FF0 = ...  # type: int
+FF1 = ...  # type: int
+FFDLY = ...  # type: int
+FIOASYNC = ...  # type: int
+FIOCLEX = ...  # type: int
+FIONBIO = ...  # type: int
+FIONCLEX = ...  # type: int
+FIONREAD = ...  # type: int
+FLUSHO = ...  # type: int
+HUPCL = ...  # type: int
+ICANON = ...  # type: int
+ICRNL = ...  # type: int
+IEXTEN = ...  # type: int
+IGNBRK = ...  # type: int
+IGNCR = ...  # type: int
+IGNPAR = ...  # type: int
+IMAXBEL = ...  # type: int
+INLCR = ...  # type: int
+INPCK = ...  # type: int
+IOCSIZE_MASK = ...  # type: int
+IOCSIZE_SHIFT = ...  # type: int
+ISIG = ...  # type: int
+ISTRIP = ...  # type: int
+IUCLC = ...  # type: int
+IXANY = ...  # type: int
+IXOFF = ...  # type: int
+IXON = ...  # type: int
+NCC = ...  # type: int
+NCCS = ...  # type: int
+NL0 = ...  # type: int
+NL1 = ...  # type: int
+NLDLY = ...  # type: int
+NOFLSH = ...  # type: int
+N_MOUSE = ...  # type: int
+N_PPP = ...  # type: int
+N_SLIP = ...  # type: int
+N_STRIP = ...  # type: int
+N_TTY = ...  # type: int
+OCRNL = ...  # type: int
+OFDEL = ...  # type: int
+OFILL = ...  # type: int
+OLCUC = ...  # type: int
+ONLCR = ...  # type: int
+ONLRET = ...  # type: int
+ONOCR = ...  # type: int
+OPOST = ...  # type: int
+PARENB = ...  # type: int
+PARMRK = ...  # type: int
+PARODD = ...  # type: int
+PENDIN = ...  # type: int
+TAB0 = ...  # type: int
+TAB1 = ...  # type: int
+TAB2 = ...  # type: int
+TAB3 = ...  # type: int
+TABDLY = ...  # type: int
+TCFLSH = ...  # type: int
+TCGETA = ...  # type: int
+TCGETS = ...  # type: int
+TCIFLUSH = ...  # type: int
+TCIOFF = ...  # type: int
+TCIOFLUSH = ...  # type: int
+TCION = ...  # type: int
+TCOFLUSH = ...  # type: int
+TCOOFF = ...  # type: int
+TCOON = ...  # type: int
+TCSADRAIN = ...  # type: int
+TCSAFLUSH = ...  # type: int
+TCSANOW = ...  # type: int
+TCSBRK = ...  # type: int
+TCSBRKP = ...  # type: int
+TCSETA = ...  # type: int
+TCSETAF = ...  # type: int
+TCSETAW = ...  # type: int
+TCSETS = ...  # type: int
+TCSETSF = ...  # type: int
+TCSETSW = ...  # type: int
+TCXONC = ...  # type: int
+TIOCCONS = ...  # type: int
+TIOCEXCL = ...  # type: int
+TIOCGETD = ...  # type: int
+TIOCGICOUNT = ...  # type: int
+TIOCGLCKTRMIOS = ...  # type: int
+TIOCGPGRP = ...  # type: int
+TIOCGSERIAL = ...  # type: int
+TIOCGSOFTCAR = ...  # type: int
+TIOCGWINSZ = ...  # type: int
+TIOCINQ = ...  # type: int
+TIOCLINUX = ...  # type: int
+TIOCMBIC = ...  # type: int
+TIOCMBIS = ...  # type: int
+TIOCMGET = ...  # type: int
+TIOCMIWAIT = ...  # type: int
+TIOCMSET = ...  # type: int
+TIOCM_CAR = ...  # type: int
+TIOCM_CD = ...  # type: int
+TIOCM_CTS = ...  # type: int
+TIOCM_DSR = ...  # type: int
+TIOCM_DTR = ...  # type: int
+TIOCM_LE = ...  # type: int
+TIOCM_RI = ...  # type: int
+TIOCM_RNG = ...  # type: int
+TIOCM_RTS = ...  # type: int
+TIOCM_SR = ...  # type: int
+TIOCM_ST = ...  # type: int
+TIOCNOTTY = ...  # type: int
+TIOCNXCL = ...  # type: int
+TIOCOUTQ = ...  # type: int
+TIOCPKT = ...  # type: int
+TIOCPKT_DATA = ...  # type: int
+TIOCPKT_DOSTOP = ...  # type: int
+TIOCPKT_FLUSHREAD = ...  # type: int
+TIOCPKT_FLUSHWRITE = ...  # type: int
+TIOCPKT_NOSTOP = ...  # type: int
+TIOCPKT_START = ...  # type: int
+TIOCPKT_STOP = ...  # type: int
+TIOCSCTTY = ...  # type: int
+TIOCSERCONFIG = ...  # type: int
+TIOCSERGETLSR = ...  # type: int
+TIOCSERGETMULTI = ...  # type: int
+TIOCSERGSTRUCT = ...  # type: int
+TIOCSERGWILD = ...  # type: int
+TIOCSERSETMULTI = ...  # type: int
+TIOCSERSWILD = ...  # type: int
+TIOCSER_TEMT = ...  # type: int
+TIOCSETD = ...  # type: int
+TIOCSLCKTRMIOS = ...  # type: int
+TIOCSPGRP = ...  # type: int
+TIOCSSERIAL = ...  # type: int
+TIOCSSOFTCAR = ...  # type: int
+TIOCSTI = ...  # type: int
+TIOCSWINSZ = ...  # type: int
+TOSTOP = ...  # type: int
+VDISCARD = ...  # type: int
+VEOF = ...  # type: int
+VEOL = ...  # type: int
+VEOL2 = ...  # type: int
+VERASE = ...  # type: int
+VINTR = ...  # type: int
+VKILL = ...  # type: int
+VLNEXT = ...  # type: int
+VMIN = ...  # type: int
+VQUIT = ...  # type: int
+VREPRINT = ...  # type: int
+VSTART = ...  # type: int
+VSTOP = ...  # type: int
+VSUSP = ...  # type: int
+VSWTC = ...  # type: int
+VSWTCH = ...  # type: int
+VT0 = ...  # type: int
+VT1 = ...  # type: int
+VTDLY = ...  # type: int
+VTIME = ...  # type: int
+VWERASE = ...  # type: int
+XCASE = ...  # type: int
+XTABS = ...  # type: int
 
 def tcgetattr(fd: _FD) -> _Attr: ...
 def tcsetattr(fd: _FD, when: int, attributes: _Attr) -> None: ...

stdlib/2and3/webbrowser.pyi

@@ -14,18 +14,18 @@ def open_new(url: str) -> bool: ...
 def open_new_tab(url: str) -> bool: ...
 
 class BaseBrowser:
-    args = ... # type: List[str]
-    name = ... # type: str
-    basename = ... # type: str
+    args = ...  # type: List[str]
+    name = ...  # type: str
+    basename = ...  # type: str
     def __init__(self, name: str=...) -> None: ...
     def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
     def open_new(self, url: str) -> bool: ...
     def open_new_tab(self, url: str) -> bool: ...
 
 class GenericBrowser(BaseBrowser):
-    args = ... # type: List[str]
-    name = ... # type: str
-    basename = ... # type: str
+    args = ...  # type: List[str]
+    name = ...  # type: str
+    basename = ...  # type: str
     def __init__(self, name: str) -> None: ...
     def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
 
@@ -33,53 +33,53 @@ class BackgroundBrowser(GenericBrowser):
     def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
 
 class UnixBrowser(BaseBrowser):
-    raise_opts = ... # type: List[str]
-    background = ... # type: bool
-    redirect_stdout = ... # type: bool
-    remote_args = ... # type: List[str]
-    remote_action = ... # type: str
-    remote_action_newwin = ... # type: str
-    remote_action_newtab = ... # type: str
+    raise_opts = ...  # type: List[str]
+    background = ...  # type: bool
+    redirect_stdout = ...  # type: bool
+    remote_args = ...  # type: List[str]
+    remote_action = ...  # type: str
+    remote_action_newwin = ...  # type: str
+    remote_action_newtab = ...  # type: str
     def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
 
 class Mozilla(UnixBrowser):
-    raise_opts = ... # type: List[str]
-    remote_args = ... # type: List[str]
-    remote_action = ... # type: str
-    remote_action_newwin = ... # type: str
-    remote_action_newtab = ... # type: str
-    background = ... # type: bool
+    raise_opts = ...  # type: List[str]
+    remote_args = ...  # type: List[str]
+    remote_action = ...  # type: str
+    remote_action_newwin = ...  # type: str
+    remote_action_newtab = ...  # type: str
+    background = ...  # type: bool
 
 class Galeon(UnixBrowser):
-    raise_opts = ... # type: List[str]
-    remote_args = ... # type: List[str]
-    remote_action = ... # type: str
-    remote_action_newwin = ... # type: str
-    background = ... # type: bool
+    raise_opts = ...  # type: List[str]
+    remote_args = ...  # type: List[str]
+    remote_action = ...  # type: str
+    remote_action_newwin = ...  # type: str
+    background = ...  # type: bool
 
 if sys.version_info[:2] == (2, 7) or sys.version_info >= (3, 3):
     class Chrome(UnixBrowser):
-        remote_args = ... # type: List[str]
-        remote_action = ... # type: str
-        remote_action_newwin = ... # type: str
-        remote_action_newtab = ... # type: str
-        background = ... # type: bool
+        remote_args = ...  # type: List[str]
+        remote_action = ...  # type: str
+        remote_action_newwin = ...  # type: str
+        remote_action_newtab = ...  # type: str
+        background = ...  # type: bool
 
 class Opera(UnixBrowser):
-    raise_opts = ... # type: List[str]
-    remote_args = ... # type: List[str]
-    remote_action = ... # type: str
-    remote_action_newwin = ... # type: str
-    remote_action_newtab = ... # type: str
-    background = ... # type: bool
+    raise_opts = ...  # type: List[str]
+    remote_args = ...  # type: List[str]
+    remote_action = ...  # type: str
+    remote_action_newwin = ...  # type: str
+    remote_action_newtab = ...  # type: str
+    background = ...  # type: bool
 
 class Elinks(UnixBrowser):
-    remote_args = ... # type: List[str]
-    remote_action = ... # type: str
-    remote_action_newwin = ... # type: str
-    remote_action_newtab = ... # type: str
-    background = ... # type: bool
-    redirect_stdout = ... # type: bool
+    remote_args = ...  # type: List[str]
+    remote_action = ...  # type: str
+    remote_action_newwin = ...  # type: str
+    remote_action_newtab = ...  # type: str
+    background = ...  # type: bool
+    redirect_stdout = ...  # type: bool
 
 class Konqueror(BaseBrowser):
     def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
@@ -91,7 +91,7 @@ class WindowsDefault(BaseBrowser):
     def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
 
 class MacOSX(BaseBrowser):
-    name = ... # type: str
+    name = ...  # type: str
     def __init__(self, name: str) -> None: ...
     def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
 

stdlib/2and3/xml/sax/handler.pyi

@@ -4,7 +4,7 @@
 
 from typing import Any
 
-version = ... # type: Any
+version = ...  # type: Any
 
 class ErrorHandler:
     def error(self, exception): ...
@@ -34,17 +34,17 @@ class DTDHandler:
 class EntityResolver:
     def resolveEntity(self, publicId, systemId): ...
 
-feature_namespaces = ... # type: Any
-feature_namespace_prefixes = ... # type: Any
-feature_string_interning = ... # type: Any
-feature_validation = ... # type: Any
-feature_external_ges = ... # type: Any
-feature_external_pes = ... # type: Any
-all_features = ... # type: Any
-property_lexical_handler = ... # type: Any
-property_declaration_handler = ... # type: Any
-property_dom_node = ... # type: Any
-property_xml_string = ... # type: Any
-property_encoding = ... # type: Any
-property_interning_dict = ... # type: Any
-all_properties = ... # type: Any
+feature_namespaces = ...  # type: Any
+feature_namespace_prefixes = ...  # type: Any
+feature_string_interning = ...  # type: Any
+feature_validation = ...  # type: Any
+feature_external_ges = ...  # type: Any
+feature_external_pes = ...  # type: Any
+all_features = ...  # type: Any
+property_lexical_handler = ...  # type: Any
+property_declaration_handler = ...  # type: Any
+property_dom_node = ...  # type: Any
+property_xml_string = ...  # type: Any
+property_encoding = ...  # type: Any
+property_interning_dict = ...  # type: Any
+all_properties = ...  # type: Any

stdlib/3.2/xml/etree/ElementInclude.pyi

@@ -5,9 +5,9 @@
 from typing import Union, Optional, Callable
 from .ElementTree import Element
 
-XINCLUDE = ... # type: str
-XINCLUDE_INCLUDE = ... # type: str
-XINCLUDE_FALLBACK = ... # type: str
+XINCLUDE = ...  # type: str
+XINCLUDE_INCLUDE = ...  # type: str
+XINCLUDE_FALLBACK = ...  # type: str
 
 class FatalIncludeError(SyntaxError): ...
 

stdlib/3.2/xml/etree/ElementPath.pyi

@@ -5,7 +5,7 @@
 from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional
 from .ElementTree import Element
 
-xpath_tokenizer_re = ... # type: Pattern
+xpath_tokenizer_re = ...  # type: Pattern
 
 _token = Tuple[str, str]
 _next = Callable[[], _token]
@@ -20,11 +20,11 @@ def prepare_descendant(next: _next, token: _token) -> _callback: ...
 def prepare_parent(next: _next, token: _token) -> _callback: ...
 def prepare_predicate(next: _next, token: _token) -> _callback: ...
 
-ops = ... # type: Dict[str, Callable[[_next, _token], _callback]]
+ops = ...  # type: Dict[str, Callable[[_next, _token], _callback]]
 
 class _SelectorContext:
-    parent_map = ... # type: Dict[Element, Element]
-    root = ... # type: Element
+    parent_map = ...  # type: Dict[Element, Element]
+    root = ...  # type: Element
     def __init__(self, root: Element) -> None: ...
 
 _T = TypeVar('_T')

stdlib/3.2/xml/etree/ElementTree.pyi

@@ -5,7 +5,7 @@
 from typing import Any, AnyStr, Union, IO, Callable, Dict, List, Tuple, Sequence, Iterator, TypeVar, Optional, KeysView, ItemsView, Generator
 import io
 
-VERSION = ... # type: str
+VERSION = ...  # type: str
 
 _Ss = TypeVar('_Ss', str, bytes)
 _T = TypeVar('_T')
@@ -22,10 +22,10 @@ class ParseError(SyntaxError): ...
 def iselement(element: 'Element') -> bool: ...
 
 class Element(Sequence['Element']):
-    tag = ... # type: _str_or_bytes
-    attrib = ... # type: Dict[_str_or_bytes, _str_or_bytes]
-    text = ... # type: Optional[_str_or_bytes]
-    tail = ... # type: Optional[_str_or_bytes]
+    tag = ...  # type: _str_or_bytes
+    attrib = ...  # type: Dict[_str_or_bytes, _str_or_bytes]
+    text = ...  # type: Optional[_str_or_bytes]
+    tail = ...  # type: Optional[_str_or_bytes]
     def __init__(self, tag: Union[AnyStr, Callable[..., 'Element']], attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> None: ...
     def append(self, subelement: 'Element') -> None: ...
     def clear(self) -> None: ...
@@ -56,10 +56,10 @@ def SubElement(parent: Element, tag: AnyStr, attrib: Dict[AnyStr, AnyStr]=..., *
 def Comment(text: _str_or_bytes=...) -> Element: ...
 def ProcessingInstruction(target: str, text: str=...) -> Element: ...
 
-PI = ... # type: Callable[..., Element]
+PI = ...  # type: Callable[..., Element]
 
 class QName:
-    text = ... # type: str
+    text = ...  # type: str
     def __init__(self, text_or_uri: str, tag: str=...) -> None: ...
 
 
@@ -88,7 +88,7 @@ def iterparse(source: _file_or_filename, events: Sequence[str]=..., parser: 'XML
 
 
 class _IterParseIterator:
-    root = ... # type: Any
+    root = ...  # type: Any
     def __init__(self, source: _file_or_filename, events: Sequence[str], parser: 'XMLParser', close_source: bool=...) -> None: ...
     def __next__(self) -> Tuple[str, Element]: ...
     def __iter__(self) -> _IterParseIterator: ...
@@ -97,7 +97,7 @@ def XML(text: AnyStr, parser: 'XMLParser'=...) -> Element: ...
 def XMLID(text: AnyStr, parser: 'XMLParser'=...) -> Tuple[Element, Dict[str, Element]]: ...
 
 # TODO-improve this type
-fromstring = ... # type: Callable[..., Element]
+fromstring = ...  # type: Callable[..., Element]
 
 def fromstringlist(sequence: Sequence[AnyStr], parser: 'XMLParser'=...) -> Element: ...
 
@@ -109,11 +109,11 @@ class TreeBuilder:
     def end(self, tag: AnyStr) -> Element: ...
 
 class XMLParser:
-    parser = ... # type: Any
-    target = ... # type: TreeBuilder
+    parser = ...  # type: Any
+    target = ...  # type: TreeBuilder
     # TODO-what is entity used for???
-    entity = ... # type: Any
-    version = ... # type: str
+    entity = ...  # type: Any
+    version = ...  # type: str
     def __init__(self, html: int=..., target: TreeBuilder=..., encoding: str=...) -> None: ...
     def doctype(self, name: str, pubid: str, system: str) -> None: ...
     def close(self) -> Any: ...  # TODO-most of the time, this will be Element, but it can be anything target.close() returns

stdlib/3.3/ipaddress.pyi

@@ -4,8 +4,8 @@
 
 from typing import Any
 
-IPV4LENGTH = ... # type: Any
-IPV6LENGTH = ... # type: Any
+IPV4LENGTH = ...  # type: Any
+IPV6LENGTH = ...  # type: Any
 
 class AddressValueError(ValueError): ...
 class NetmaskValueError(ValueError): ...
@@ -112,9 +112,9 @@ class IPv4Address(_BaseV4, _BaseAddress):
     def is_link_local(self): ...
 
 class IPv4Interface(IPv4Address):
-    network = ... # type: Any
-    netmask = ... # type: Any
-    hostmask = ... # type: Any
+    network = ...  # type: Any
+    netmask = ...  # type: Any
+    hostmask = ...  # type: Any
     def __init__(self, address) -> None: ...
     def __eq__(self, other): ...
     def __lt__(self, other): ...
@@ -129,9 +129,9 @@ class IPv4Interface(IPv4Address):
     def with_hostmask(self): ...
 
 class IPv4Network(_BaseV4, _BaseNetwork):
-    network_address = ... # type: Any
-    netmask = ... # type: Any
-    hosts = ... # type: Any
+    network_address = ...  # type: Any
+    netmask = ...  # type: Any
+    hosts = ...  # type: Any
     def __init__(self, address, strict=...) -> None: ...
     @property
     def is_global(self): ...
@@ -171,9 +171,9 @@ class IPv6Address(_BaseV6, _BaseAddress):
     def sixtofour(self): ...
 
 class IPv6Interface(IPv6Address):
-    network = ... # type: Any
-    netmask = ... # type: Any
-    hostmask = ... # type: Any
+    network = ...  # type: Any
+    netmask = ...  # type: Any
+    hostmask = ...  # type: Any
     def __init__(self, address) -> None: ...
     def __eq__(self, other): ...
     def __lt__(self, other): ...
@@ -192,8 +192,8 @@ class IPv6Interface(IPv6Address):
     def is_loopback(self): ...
 
 class IPv6Network(_BaseV6, _BaseNetwork):
-    network_address = ... # type: Any
-    netmask = ... # type: Any
+    network_address = ...  # type: Any
+    netmask = ...  # type: Any
     def __init__(self, address, strict=...) -> None: ...
     def hosts(self): ...
     @property

stdlib/3.3/xml/etree/ElementInclude.pyi

@@ -5,9 +5,9 @@
 from typing import Union, Optional, Callable
 from .ElementTree import Element
 
-XINCLUDE = ... # type: str
-XINCLUDE_INCLUDE = ... # type: str
-XINCLUDE_FALLBACK = ... # type: str
+XINCLUDE = ...  # type: str
+XINCLUDE_INCLUDE = ...  # type: str
+XINCLUDE_FALLBACK = ...  # type: str
 
 class FatalIncludeError(SyntaxError): ...
 

stdlib/3.3/xml/etree/ElementPath.pyi

@@ -5,7 +5,7 @@
 from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional
 from .ElementTree import Element
 
-xpath_tokenizer_re = ... # type: Pattern
+xpath_tokenizer_re = ...  # type: Pattern
 
 _token = Tuple[str, str]
 _next = Callable[[], _token]
@@ -20,11 +20,11 @@ def prepare_descendant(next: _next, token: _token) -> _callback: ...
 def prepare_parent(next: _next, token: _token) -> _callback: ...
 def prepare_predicate(next: _next, token: _token) -> _callback: ...
 
-ops = ... # type: Dict[str, Callable[[_next, _token], _callback]]
+ops = ...  # type: Dict[str, Callable[[_next, _token], _callback]]
 
 class _SelectorContext:
-    parent_map = ... # type: Dict[Element, Element]
-    root = ... # type: Element
+    parent_map = ...  # type: Dict[Element, Element]
+    root = ...  # type: Element
     def __init__(self, root: Element) -> None: ...
 
 _T = TypeVar('_T')

stdlib/3.3/xml/etree/ElementTree.pyi

@@ -5,7 +5,7 @@
 from typing import Any, AnyStr, Union, IO, Callable, Dict, List, Tuple, Sequence, Iterator, TypeVar, Optional, KeysView, ItemsView, Generator
 import io
 
-VERSION = ... # type: str
+VERSION = ...  # type: str
 
 class ParseError(SyntaxError): ...
 
@@ -16,10 +16,10 @@ _T = TypeVar('_T')
 _str_or_bytes = Union[str, bytes]
 
 class Element(Sequence['Element']):
-    tag = ... # type: _str_or_bytes
-    attrib = ... # type: Dict[_str_or_bytes, _str_or_bytes]
-    text = ... # type: Optional[_str_or_bytes]
-    tail = ... # type: Optional[_str_or_bytes]
+    tag = ...  # type: _str_or_bytes
+    attrib = ...  # type: Dict[_str_or_bytes, _str_or_bytes]
+    text = ...  # type: Optional[_str_or_bytes]
+    tail = ...  # type: Optional[_str_or_bytes]
     def __init__(self, tag: Union[AnyStr, Callable[..., 'Element']], attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> None: ...
     def append(self, subelement: 'Element') -> None: ...
     def clear(self) -> None: ...
@@ -50,10 +50,10 @@ def SubElement(parent: Element, tag: AnyStr, attrib: Dict[AnyStr, AnyStr]=..., *
 def Comment(text: _str_or_bytes=...) -> Element: ...
 def ProcessingInstruction(target: str, text: str=...) -> Element: ...
 
-PI = ... # type: Callable[..., Element]
+PI = ...  # type: Callable[..., Element]
 
 class QName:
-    text = ... # type: str
+    text = ...  # type: str
     def __init__(self, text_or_uri: str, tag: str=...) -> None: ...
 
 
@@ -81,7 +81,7 @@ def iterparse(source: _file_or_filename, events: Sequence[str]=..., parser: 'XML
 
 
 class _IterParseIterator:
-    root = ... # type: Any
+    root = ...  # type: Any
     def __init__(self, source: _file_or_filename, events: Sequence[str], parser: 'XMLParser', close_source: bool=...) -> None: ...
     def __next__(self) -> Tuple[str, Element]: ...
     def __iter__(self) -> _IterParseIterator: ...
@@ -90,7 +90,7 @@ def XML(text: AnyStr, parser: 'XMLParser'=...) -> Element: ...
 def XMLID(text: AnyStr, parser: 'XMLParser'=...) -> Tuple[Element, Dict[str, Element]]: ...
 
 # TODO-improve this type
-fromstring = ... # type: Callable[..., Element]
+fromstring = ...  # type: Callable[..., Element]
 
 def fromstringlist(sequence: Sequence[AnyStr], parser: 'XMLParser'=...) -> Element: ...
 
@@ -102,11 +102,11 @@ class TreeBuilder:
     def end(self, tag: AnyStr) -> Element: ...
 
 class XMLParser:
-    parser = ... # type: Any
-    target = ... # type: TreeBuilder
+    parser = ...  # type: Any
+    target = ...  # type: TreeBuilder
     # TODO-what is entity used for???
-    entity = ... # type: Any
-    version = ... # type: str
+    entity = ...  # type: Any
+    version = ...  # type: str
     def __init__(self, html: int=..., target: TreeBuilder=..., encoding: str=...) -> None: ...
     def doctype(self, name: str, pubid: str, system: str) -> None: ...
     def close(self) -> Any: ...  # TODO-most of the time, this will be Element, but it can be anything target.close() returns

stdlib/3.4/asyncio/__init__.pyi

@@ -94,4 +94,4 @@ DefaultEventLoopPolicy = ...  # type: Type[AbstractEventLoopPolicy]
 
 # TODO: AbstractChildWatcher (UNIX only)
 
-__all__ = ... # type: str
+__all__ = ...  # type: str

stdlib/3.4/asyncio/coroutines.pyi

@@ -1,6 +1,6 @@
 from typing import Any, Callable, Generator, TypeVar
 
-__all__ = ... # type: str
+__all__ = ...  # type: str
 
 _F = TypeVar('_F', bound=Callable[..., Any])
 

stdlib/3.4/asyncio/events.pyi

@@ -3,7 +3,7 @@ from abc import ABCMeta, abstractmethod
 from asyncio.futures import Future
 from asyncio.coroutines import coroutine
 
-__all__ = ... # type: str
+__all__ = ...  # type: str
 
 _T = TypeVar('_T')
 
@@ -14,7 +14,7 @@ AI_PASSIVE = 0
 
 class Handle:
     _cancelled = False
-    _args = ... # type: List[Any]
+    _args = ...  # type: List[Any]
     def __init__(self, callback: Callable[..., Any], args: List[Any],
         loop: AbstractEventLoop) -> None: ...
     def __repr__(self) -> str: ...
@@ -30,7 +30,7 @@ class AbstractEventLoop(metaclass=ABCMeta):
     @abstractmethod
     def run_forever(self) -> None: ...
 
-    # Can't use a union, see mypy issue #1873.
+    # Can't use a union, see mypy issue  #1873.
     @overload
     @abstractmethod
     def run_until_complete(self, future: Generator[Any, Any, _T]) -> _T: ...
@@ -127,11 +127,11 @@ class AbstractEventLoop(metaclass=ABCMeta):
     def remove_writer(self, fd: int) -> None: ...
     # Completion based I/O methods returning Futures.
     @abstractmethod
-    def sock_recv(self, sock: Any, nbytes: int) -> Any: ... #TODO
+    def sock_recv(self, sock: Any, nbytes: int) -> Any: ...  #TODO
     @abstractmethod
-    def sock_sendall(self, sock: Any, data: bytes) -> None: ... #TODO
+    def sock_sendall(self, sock: Any, data: bytes) -> None: ...  #TODO
     @abstractmethod
-    def sock_connect(self, sock: Any, address: str) -> Any: ... #TODO
+    def sock_connect(self, sock: Any, address: str) -> Any: ...  #TODO
     @abstractmethod
     def sock_accept(self, sock: Any) -> Any: ...
     # Signal handling.
@@ -163,7 +163,7 @@ class AbstractEventLoopPolicy(metaclass=ABCMeta):
     @abstractmethod
     def get_child_watcher(self) -> Any: ...  # TODO: unix_events.AbstractChildWatcher
     @abstractmethod
-    def set_child_watcher(self, watcher: Any) -> None: ... # TODO: unix_events.AbstractChildWatcher
+    def set_child_watcher(self, watcher: Any) -> None: ...  # TODO: unix_events.AbstractChildWatcher
 
 class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy):
     def __init__(self) -> None: ...
@@ -179,4 +179,4 @@ def set_event_loop(loop: AbstractEventLoop) -> None: ...
 def new_event_loop() -> AbstractEventLoop: ...
 
 def get_child_watcher() -> Any: ...  # TODO: unix_events.AbstractChildWatcher
-def set_child_watcher(watcher: Any) -> None: ... # TODO: unix_events.AbstractChildWatcher
+def set_child_watcher(watcher: Any) -> None: ...  # TODO: unix_events.AbstractChildWatcher

stdlib/3.4/asyncio/futures.pyi

@@ -1,7 +1,7 @@
 from typing import Any, Union, Callable, TypeVar, List, Generic, Iterable, Generator, Awaitable
 from .events import AbstractEventLoop
 
-__all__ = ... # type: str
+__all__ = ...  # type: str
 
 _T = TypeVar('_T')
 
@@ -16,7 +16,7 @@ class InvalidStateError(Error): ...
 
 class _TracebackLogger:
     exc = ...  # type: BaseException
-    tb = ... # type: List[str]
+    tb = ...  # type: List[str]
     def __init__(self, exc: Any, loop: AbstractEventLoop) -> None: ...
     def activate(self) -> None: ...
     def clear(self) -> None: ...
@@ -24,7 +24,7 @@ class _TracebackLogger:
 
 class Future(Iterable[_T], Awaitable[_T], Generic[_T]):
     _state = ...  # type: str
-    _exception = ... # type: BaseException
+    _exception = ...  # type: BaseException
     _blocking = False
     _log_traceback = False
     _tb_logger = _TracebackLogger

stdlib/3.4/asyncio/protocols.pyi

@@ -1,6 +1,6 @@
 from typing import AnyStr
 
-__all__ = ... # type: str
+__all__ = ...  # type: str
 
 from asyncio import transports
 

stdlib/3.4/asyncio/queues.pyi

@@ -1,6 +1,6 @@
 from typing import TypeVar, Generic
 
-__all__ = ... # type: str
+__all__ = ...  # type: str
 
 from asyncio.events import AbstractEventLoop
 from .coroutines import coroutine

stdlib/3.4/asyncio/streams.pyi

@@ -8,7 +8,7 @@ from . import events
 from . import protocols
 from . import transports
 
-__all__ = ... # type: str
+__all__ = ...  # type: str
 
 class IncompleteReadError(EOFError):
     def __init__(self, partial: str, expected: int) -> None: ...

stdlib/3.4/asyncio/subprocess.pyi

@@ -1,6 +1,6 @@
 from typing import Any, AnyStr, Tuple, Union
 
-__all__ = ... # type: str
+__all__ = ...  # type: str
 
 from asyncio import events
 from asyncio import protocols
@@ -9,9 +9,9 @@ from asyncio import transports
 from asyncio.coroutines import coroutine
 
 
-PIPE = ... # type: int
-STDOUT = ... # type: int
-DEVNULL = ... # type: int
+PIPE = ...  # type: int
+STDOUT = ...  # type: int
+DEVNULL = ...  # type: int
 
 class SubprocessStreamProtocol(streams.FlowControlMixin,
                                protocols.SubprocessProtocol):
@@ -40,7 +40,7 @@ class Process:
 
 @coroutine
 def create_subprocess_shell(
-        *Args: Union[str, bytes],  # Union used instead of AnyStr due to mypy issue #1236
+        *Args: Union[str, bytes],  # Union used instead of AnyStr due to mypy issue  #1236
         stdin: int = ...,
         stdout: int = ...,
         stderr: int = ...,
@@ -50,7 +50,7 @@ def create_subprocess_shell(
 
 @coroutine
 def create_subprocess_exec(
-        program: Union[str, bytes],  # Union used instead of AnyStr due to mypy issue #1236
+        program: Union[str, bytes],  # Union used instead of AnyStr due to mypy issue  #1236
         *args: Any,
         stdin: int = ...,
         stdout: int = ...,

stdlib/3.4/asyncio/tasks.pyi

@@ -3,7 +3,7 @@ from typing import (Any, TypeVar, Set, Dict, List, TextIO, Union, Tuple, Generic
                     Optional)
 import concurrent.futures
 
-__all__ = ... # type: str
+__all__ = ...  # type: str
 
 from .events import AbstractEventLoop
 from .futures import Future
@@ -41,7 +41,7 @@ class Task(Future[_T], Generic[_T]):
     @classmethod
     def all_tasks(cls, loop: AbstractEventLoop = ...) -> Set[Task]: ...
 
-    # Can't use a union, see mypy issue #1873.
+    # Can't use a union, see mypy issue  #1873.
     @overload
     def __init__(self, coro: Generator[Any, None, _T],
                  *, loop: AbstractEventLoop = ...) -> None: ...

stdlib/3.4/asyncio/transports.pyi

@@ -1,6 +1,6 @@
 from typing import Dict, Any, TypeVar, Mapping, List
 
-__all__ = ... # type: str
+__all__ = ...  # type: str
 
 class BaseTransport:
     def __init__(self, extra: Mapping[Any, Any] = ...) -> None: ...

stdlib/3.4/xml/etree/ElementInclude.pyi

@@ -5,9 +5,9 @@
 from typing import Union, Optional, Callable
 from .ElementTree import Element
 
-XINCLUDE = ... # type: str
-XINCLUDE_INCLUDE = ... # type: str
-XINCLUDE_FALLBACK = ... # type: str
+XINCLUDE = ...  # type: str
+XINCLUDE_INCLUDE = ...  # type: str
+XINCLUDE_FALLBACK = ...  # type: str
 
 class FatalIncludeError(SyntaxError): ...
 

stdlib/3.4/xml/etree/ElementPath.pyi

@@ -5,7 +5,7 @@
 from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional
 from .ElementTree import Element
 
-xpath_tokenizer_re = ... # type: Pattern
+xpath_tokenizer_re = ...  # type: Pattern
 
 _token = Tuple[str, str]
 _next = Callable[[], _token]
@@ -20,11 +20,11 @@ def prepare_descendant(next: _next, token: _token) -> _callback: ...
 def prepare_parent(next: _next, token: _token) -> _callback: ...
 def prepare_predicate(next: _next, token: _token) -> _callback: ...
 
-ops = ... # type: Dict[str, Callable[[_next, _token], _callback]]
+ops = ...  # type: Dict[str, Callable[[_next, _token], _callback]]
 
 class _SelectorContext:
-    parent_map = ... # type: Dict[Element, Element]
-    root = ... # type: Element
+    parent_map = ...  # type: Dict[Element, Element]
+    root = ...  # type: Element
     def __init__(self, root: Element) -> None: ...
 
 _T = TypeVar('_T')

stdlib/3.4/xml/etree/ElementTree.pyi

@@ -5,7 +5,7 @@
 from typing import Any, AnyStr, Union, IO, Callable, Dict, List, Tuple, Sequence, Iterator, TypeVar, Optional, KeysView, ItemsView, Generator
 import io
 
-VERSION = ... # type: str
+VERSION = ...  # type: str
 
 class ParseError(SyntaxError): ...
 
@@ -16,10 +16,10 @@ _T = TypeVar('_T')
 _str_or_bytes = Union[str, bytes]
 
 class Element(Sequence['Element']):
-    tag = ... # type: _str_or_bytes
-    attrib = ... # type: Dict[_str_or_bytes, _str_or_bytes]
-    text = ... # type: Optional[_str_or_bytes]
-    tail = ... # type: Optional[_str_or_bytes]
+    tag = ...  # type: _str_or_bytes
+    attrib = ...  # type: Dict[_str_or_bytes, _str_or_bytes]
+    text = ...  # type: Optional[_str_or_bytes]
+    tail = ...  # type: Optional[_str_or_bytes]
     def __init__(self, tag: Union[AnyStr, Callable[..., 'Element']], attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> None: ...
     def append(self, subelement: 'Element') -> None: ...
     def clear(self) -> None: ...
@@ -50,10 +50,10 @@ def SubElement(parent: Element, tag: AnyStr, attrib: Dict[AnyStr, AnyStr]=..., *
 def Comment(text: _str_or_bytes=...) -> Element: ...
 def ProcessingInstruction(target: str, text: str=...) -> Element: ...
 
-PI = ... # type: Callable[..., Element]
+PI = ...  # type: Callable[..., Element]
 
 class QName:
-    text = ... # type: str
+    text = ...  # type: str
     def __init__(self, text_or_uri: str, tag: str=...) -> None: ...
 
 
@@ -86,7 +86,7 @@ class XMLPullParser:
     def read_events(self) -> Iterator[Tuple[str, Element]]: ...
 
 class _IterParseIterator:
-    root = ... # type: Any
+    root = ...  # type: Any
     def __init__(self, source: _file_or_filename, events: Sequence[str], parser: 'XMLParser', close_source: bool=...) -> None: ...
     def __next__(self) -> Tuple[str, Element]: ...
     def __iter__(self) -> _IterParseIterator: ...
@@ -95,7 +95,7 @@ def XML(text: AnyStr, parser: 'XMLParser'=...) -> Element: ...
 def XMLID(text: AnyStr, parser: 'XMLParser'=...) -> Tuple[Element, Dict[str, Element]]: ...
 
 # TODO-improve this type
-fromstring = ... # type: Callable[..., Element]
+fromstring = ...  # type: Callable[..., Element]
 
 def fromstringlist(sequence: Sequence[AnyStr], parser: 'XMLParser'=...) -> Element: ...
 
@@ -107,11 +107,11 @@ class TreeBuilder:
     def end(self, tag: AnyStr) -> Element: ...
 
 class XMLParser:
-    parser = ... # type: Any
-    target = ... # type: TreeBuilder
+    parser = ...  # type: Any
+    target = ...  # type: TreeBuilder
     # TODO-what is entity used for???
-    entity = ... # type: Any
-    version = ... # type: str
+    entity = ...  # type: Any
+    version = ...  # type: str
     def __init__(self, html: int=..., target: TreeBuilder=..., encoding: str=...) -> None: ...
     def doctype(self, name: str, pubid: str, system: str) -> None: ...
     def close(self) -> Any: ...  # TODO-most of the time, this will be Element, but it can be anything target.close() returns

stdlib/3.5/xml/etree/ElementInclude.pyi

@@ -5,9 +5,9 @@
 from typing import Union, Optional, Callable
 from .ElementTree import Element
 
-XINCLUDE = ... # type: str
-XINCLUDE_INCLUDE = ... # type: str
-XINCLUDE_FALLBACK = ... # type: str
+XINCLUDE = ...  # type: str
+XINCLUDE_INCLUDE = ...  # type: str
+XINCLUDE_FALLBACK = ...  # type: str
 
 class FatalIncludeError(SyntaxError): ...
 

stdlib/3.5/xml/etree/ElementPath.pyi

@@ -5,7 +5,7 @@
 from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional
 from .ElementTree import Element
 
-xpath_tokenizer_re = ... # type: Pattern
+xpath_tokenizer_re = ...  # type: Pattern
 
 _token = Tuple[str, str]
 _next = Callable[[], _token]
@@ -20,11 +20,11 @@ def prepare_descendant(next: _next, token: _token) -> _callback: ...
 def prepare_parent(next: _next, token: _token) -> _callback: ...
 def prepare_predicate(next: _next, token: _token) -> _callback: ...
 
-ops = ... # type: Dict[str, Callable[[_next, _token], _callback]]
+ops = ...  # type: Dict[str, Callable[[_next, _token], _callback]]
 
 class _SelectorContext:
-    parent_map = ... # type: Dict[Element, Element]
-    root = ... # type: Element
+    parent_map = ...  # type: Dict[Element, Element]
+    root = ...  # type: Element
     def __init__(self, root: Element) -> None: ...
 
 _T = TypeVar('_T')

stdlib/3.5/xml/etree/ElementTree.pyi

@@ -5,7 +5,7 @@
 from typing import Any, AnyStr, Union, IO, Callable, Dict, List, Tuple, Sequence, Iterator, TypeVar, Optional, KeysView, ItemsView, Generator
 import io
 
-VERSION = ... # type: str
+VERSION = ...  # type: str
 
 class ParseError(SyntaxError): ...
 
@@ -16,10 +16,10 @@ _T = TypeVar('_T')
 _str_or_bytes = Union[str, bytes]
 
 class Element(Sequence['Element']):
-    tag = ... # type: _str_or_bytes
-    attrib = ... # type: Dict[_str_or_bytes, _str_or_bytes]
-    text = ... # type: Optional[_str_or_bytes]
-    tail = ... # type: Optional[_str_or_bytes]
+    tag = ...  # type: _str_or_bytes
+    attrib = ...  # type: Dict[_str_or_bytes, _str_or_bytes]
+    text = ...  # type: Optional[_str_or_bytes]
+    tail = ...  # type: Optional[_str_or_bytes]
     def __init__(self, tag: Union[AnyStr, Callable[..., 'Element']], attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> None: ...
     def append(self, subelement: 'Element') -> None: ...
     def clear(self) -> None: ...
@@ -50,10 +50,10 @@ def SubElement(parent: Element, tag: AnyStr, attrib: Dict[AnyStr, AnyStr]=..., *
 def Comment(text: _str_or_bytes=...) -> Element: ...
 def ProcessingInstruction(target: str, text: str=...) -> Element: ...
 
-PI = ... # type: Callable[..., Element]
+PI = ...  # type: Callable[..., Element]
 
 class QName:
-    text = ... # type: str
+    text = ...  # type: str
     def __init__(self, text_or_uri: str, tag: str=...) -> None: ...
 
 
@@ -86,7 +86,7 @@ class XMLPullParser:
     def read_events(self) -> Iterator[Tuple[str, Element]]: ...
 
 class _IterParseIterator:
-    root = ... # type: Any
+    root = ...  # type: Any
     def __init__(self, source: _file_or_filename, events: Sequence[str], parser: 'XMLParser', close_source: bool=...) -> None: ...
     def __next__(self) -> Tuple[str, Element]: ...
     def __iter__(self) -> _IterParseIterator: ...
@@ -95,7 +95,7 @@ def XML(text: AnyStr, parser: 'XMLParser'=...) -> Element: ...
 def XMLID(text: AnyStr, parser: 'XMLParser'=...) -> Tuple[Element, Dict[str, Element]]: ...
 
 # TODO-improve this type
-fromstring = ... # type: Callable[..., Element]
+fromstring = ...  # type: Callable[..., Element]
 
 def fromstringlist(sequence: Sequence[AnyStr], parser: 'XMLParser'=...) -> Element: ...
 
@@ -107,11 +107,11 @@ class TreeBuilder:
     def end(self, tag: AnyStr) -> Element: ...
 
 class XMLParser:
-    parser = ... # type: Any
-    target = ... # type: TreeBuilder
+    parser = ...  # type: Any
+    target = ...  # type: TreeBuilder
     # TODO-what is entity used for???
-    entity = ... # type: Any
-    version = ... # type: str
+    entity = ...  # type: Any
+    version = ...  # type: str
     def __init__(self, html: int=..., target: TreeBuilder=..., encoding: str=...) -> None: ...
     def doctype(self, name: str, pubid: str, system: str) -> None: ...
     def close(self) -> Any: ...  # TODO-most of the time, this will be Element, but it can be anything target.close() returns

stdlib/3/_ast.pyi

@@ -2,13 +2,13 @@
 import typing
 from typing import Any, Optional, Union
 
-PyCF_ONLY_AST = ... # type: int
+PyCF_ONLY_AST = ...  # type: int
 
 identifier = str
 
 class AST:
-    _attributes = ... # type: typing.Tuple[str, ...]
-    _fields = ... # type: typing.Tuple[str, ...]
+    _attributes = ...  # type: typing.Tuple[str, ...]
+    _fields = ...  # type: typing.Tuple[str, ...]
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
 
 class mod(AST):

stdlib/3/_compression.pyi

@@ -5,7 +5,7 @@
 from typing import Any
 import io
 
-BUFFER_SIZE = ... # type: Any
+BUFFER_SIZE = ...  # type: Any
 
 class BaseStream(io.BufferedIOBase): ...
 

stdlib/3/_curses.pyi

@@ -4,218 +4,218 @@
 
 from typing import Any
 
-ALL_MOUSE_EVENTS = ... # type: int
-A_ALTCHARSET = ... # type: int
-A_ATTRIBUTES = ... # type: int
-A_BLINK = ... # type: int
-A_BOLD = ... # type: int
-A_CHARTEXT = ... # type: int
-A_COLOR = ... # type: int
-A_DIM = ... # type: int
-A_HORIZONTAL = ... # type: int
-A_INVIS = ... # type: int
-A_LEFT = ... # type: int
-A_LOW = ... # type: int
-A_NORMAL = ... # type: int
-A_PROTECT = ... # type: int
-A_REVERSE = ... # type: int
-A_RIGHT = ... # type: int
-A_STANDOUT = ... # type: int
-A_TOP = ... # type: int
-A_UNDERLINE = ... # type: int
-A_VERTICAL = ... # type: int
-BUTTON1_CLICKED = ... # type: int
-BUTTON1_DOUBLE_CLICKED = ... # type: int
-BUTTON1_PRESSED = ... # type: int
-BUTTON1_RELEASED = ... # type: int
-BUTTON1_TRIPLE_CLICKED = ... # type: int
-BUTTON2_CLICKED = ... # type: int
-BUTTON2_DOUBLE_CLICKED = ... # type: int
-BUTTON2_PRESSED = ... # type: int
-BUTTON2_RELEASED = ... # type: int
-BUTTON2_TRIPLE_CLICKED = ... # type: int
-BUTTON3_CLICKED = ... # type: int
-BUTTON3_DOUBLE_CLICKED = ... # type: int
-BUTTON3_PRESSED = ... # type: int
-BUTTON3_RELEASED = ... # type: int
-BUTTON3_TRIPLE_CLICKED = ... # type: int
-BUTTON4_CLICKED = ... # type: int
-BUTTON4_DOUBLE_CLICKED = ... # type: int
-BUTTON4_PRESSED = ... # type: int
-BUTTON4_RELEASED = ... # type: int
-BUTTON4_TRIPLE_CLICKED = ... # type: int
-BUTTON_ALT = ... # type: int
-BUTTON_CTRL = ... # type: int
-BUTTON_SHIFT = ... # type: int
-COLOR_BLACK = ... # type: int
-COLOR_BLUE = ... # type: int
-COLOR_CYAN = ... # type: int
-COLOR_GREEN = ... # type: int
-COLOR_MAGENTA = ... # type: int
-COLOR_RED = ... # type: int
-COLOR_WHITE = ... # type: int
-COLOR_YELLOW = ... # type: int
-ERR = ... # type: int
-KEY_A1 = ... # type: int
-KEY_A3 = ... # type: int
-KEY_B2 = ... # type: int
-KEY_BACKSPACE = ... # type: int
-KEY_BEG = ... # type: int
-KEY_BREAK = ... # type: int
-KEY_BTAB = ... # type: int
-KEY_C1 = ... # type: int
-KEY_C3 = ... # type: int
-KEY_CANCEL = ... # type: int
-KEY_CATAB = ... # type: int
-KEY_CLEAR = ... # type: int
-KEY_CLOSE = ... # type: int
-KEY_COMMAND = ... # type: int
-KEY_COPY = ... # type: int
-KEY_CREATE = ... # type: int
-KEY_CTAB = ... # type: int
-KEY_DC = ... # type: int
-KEY_DL = ... # type: int
-KEY_DOWN = ... # type: int
-KEY_EIC = ... # type: int
-KEY_END = ... # type: int
-KEY_ENTER = ... # type: int
-KEY_EOL = ... # type: int
-KEY_EOS = ... # type: int
-KEY_EXIT = ... # type: int
-KEY_F0 = ... # type: int
-KEY_F1 = ... # type: int
-KEY_F10 = ... # type: int
-KEY_F11 = ... # type: int
-KEY_F12 = ... # type: int
-KEY_F13 = ... # type: int
-KEY_F14 = ... # type: int
-KEY_F15 = ... # type: int
-KEY_F16 = ... # type: int
-KEY_F17 = ... # type: int
-KEY_F18 = ... # type: int
-KEY_F19 = ... # type: int
-KEY_F2 = ... # type: int
-KEY_F20 = ... # type: int
-KEY_F21 = ... # type: int
-KEY_F22 = ... # type: int
-KEY_F23 = ... # type: int
-KEY_F24 = ... # type: int
-KEY_F25 = ... # type: int
-KEY_F26 = ... # type: int
-KEY_F27 = ... # type: int
-KEY_F28 = ... # type: int
-KEY_F29 = ... # type: int
-KEY_F3 = ... # type: int
-KEY_F30 = ... # type: int
-KEY_F31 = ... # type: int
-KEY_F32 = ... # type: int
-KEY_F33 = ... # type: int
-KEY_F34 = ... # type: int
-KEY_F35 = ... # type: int
-KEY_F36 = ... # type: int
-KEY_F37 = ... # type: int
-KEY_F38 = ... # type: int
-KEY_F39 = ... # type: int
-KEY_F4 = ... # type: int
-KEY_F40 = ... # type: int
-KEY_F41 = ... # type: int
-KEY_F42 = ... # type: int
-KEY_F43 = ... # type: int
-KEY_F44 = ... # type: int
-KEY_F45 = ... # type: int
-KEY_F46 = ... # type: int
-KEY_F47 = ... # type: int
-KEY_F48 = ... # type: int
-KEY_F49 = ... # type: int
-KEY_F5 = ... # type: int
-KEY_F50 = ... # type: int
-KEY_F51 = ... # type: int
-KEY_F52 = ... # type: int
-KEY_F53 = ... # type: int
-KEY_F54 = ... # type: int
-KEY_F55 = ... # type: int
-KEY_F56 = ... # type: int
-KEY_F57 = ... # type: int
-KEY_F58 = ... # type: int
-KEY_F59 = ... # type: int
-KEY_F6 = ... # type: int
-KEY_F60 = ... # type: int
-KEY_F61 = ... # type: int
-KEY_F62 = ... # type: int
-KEY_F63 = ... # type: int
-KEY_F7 = ... # type: int
-KEY_F8 = ... # type: int
-KEY_F9 = ... # type: int
-KEY_FIND = ... # type: int
-KEY_HELP = ... # type: int
-KEY_HOME = ... # type: int
-KEY_IC = ... # type: int
-KEY_IL = ... # type: int
-KEY_LEFT = ... # type: int
-KEY_LL = ... # type: int
-KEY_MARK = ... # type: int
-KEY_MAX = ... # type: int
-KEY_MESSAGE = ... # type: int
-KEY_MIN = ... # type: int
-KEY_MOUSE = ... # type: int
-KEY_MOVE = ... # type: int
-KEY_NEXT = ... # type: int
-KEY_NPAGE = ... # type: int
-KEY_OPEN = ... # type: int
-KEY_OPTIONS = ... # type: int
-KEY_PPAGE = ... # type: int
-KEY_PREVIOUS = ... # type: int
-KEY_PRINT = ... # type: int
-KEY_REDO = ... # type: int
-KEY_REFERENCE = ... # type: int
-KEY_REFRESH = ... # type: int
-KEY_REPLACE = ... # type: int
-KEY_RESET = ... # type: int
-KEY_RESIZE = ... # type: int
-KEY_RESTART = ... # type: int
-KEY_RESUME = ... # type: int
-KEY_RIGHT = ... # type: int
-KEY_SAVE = ... # type: int
-KEY_SBEG = ... # type: int
-KEY_SCANCEL = ... # type: int
-KEY_SCOMMAND = ... # type: int
-KEY_SCOPY = ... # type: int
-KEY_SCREATE = ... # type: int
-KEY_SDC = ... # type: int
-KEY_SDL = ... # type: int
-KEY_SELECT = ... # type: int
-KEY_SEND = ... # type: int
-KEY_SEOL = ... # type: int
-KEY_SEXIT = ... # type: int
-KEY_SF = ... # type: int
-KEY_SFIND = ... # type: int
-KEY_SHELP = ... # type: int
-KEY_SHOME = ... # type: int
-KEY_SIC = ... # type: int
-KEY_SLEFT = ... # type: int
-KEY_SMESSAGE = ... # type: int
-KEY_SMOVE = ... # type: int
-KEY_SNEXT = ... # type: int
-KEY_SOPTIONS = ... # type: int
-KEY_SPREVIOUS = ... # type: int
-KEY_SPRINT = ... # type: int
-KEY_SR = ... # type: int
-KEY_SREDO = ... # type: int
-KEY_SREPLACE = ... # type: int
-KEY_SRESET = ... # type: int
-KEY_SRIGHT = ... # type: int
-KEY_SRSUME = ... # type: int
-KEY_SSAVE = ... # type: int
-KEY_SSUSPEND = ... # type: int
-KEY_STAB = ... # type: int
-KEY_SUNDO = ... # type: int
-KEY_SUSPEND = ... # type: int
-KEY_UNDO = ... # type: int
-KEY_UP = ... # type: int
-OK = ... # type: int
-REPORT_MOUSE_POSITION = ... # type: int
-_C_API = ... # type: Any
-version = ... # type: bytes
+ALL_MOUSE_EVENTS = ...  # type: int
+A_ALTCHARSET = ...  # type: int
+A_ATTRIBUTES = ...  # type: int
+A_BLINK = ...  # type: int
+A_BOLD = ...  # type: int
+A_CHARTEXT = ...  # type: int
+A_COLOR = ...  # type: int
+A_DIM = ...  # type: int
+A_HORIZONTAL = ...  # type: int
+A_INVIS = ...  # type: int
+A_LEFT = ...  # type: int
+A_LOW = ...  # type: int
+A_NORMAL = ...  # type: int
+A_PROTECT = ...  # type: int
+A_REVERSE = ...  # type: int
+A_RIGHT = ...  # type: int
+A_STANDOUT = ...  # type: int
+A_TOP = ...  # type: int
+A_UNDERLINE = ...  # type: int
+A_VERTICAL = ...  # type: int
+BUTTON1_CLICKED = ...  # type: int
+BUTTON1_DOUBLE_CLICKED = ...  # type: int
+BUTTON1_PRESSED = ...  # type: int
+BUTTON1_RELEASED = ...  # type: int
+BUTTON1_TRIPLE_CLICKED = ...  # type: int
+BUTTON2_CLICKED = ...  # type: int
+BUTTON2_DOUBLE_CLICKED = ...  # type: int
+BUTTON2_PRESSED = ...  # type: int
+BUTTON2_RELEASED = ...  # type: int
+BUTTON2_TRIPLE_CLICKED = ...  # type: int
+BUTTON3_CLICKED = ...  # type: int
+BUTTON3_DOUBLE_CLICKED = ...  # type: int
+BUTTON3_PRESSED = ...  # type: int
+BUTTON3_RELEASED = ...  # type: int
+BUTTON3_TRIPLE_CLICKED = ...  # type: int
+BUTTON4_CLICKED = ...  # type: int
+BUTTON4_DOUBLE_CLICKED = ...  # type: int
+BUTTON4_PRESSED = ...  # type: int
+BUTTON4_RELEASED = ...  # type: int
+BUTTON4_TRIPLE_CLICKED = ...  # type: int
+BUTTON_ALT = ...  # type: int
+BUTTON_CTRL = ...  # type: int
+BUTTON_SHIFT = ...  # type: int
+COLOR_BLACK = ...  # type: int
+COLOR_BLUE = ...  # type: int
+COLOR_CYAN = ...  # type: int
+COLOR_GREEN = ...  # type: int
+COLOR_MAGENTA = ...  # type: int
+COLOR_RED = ...  # type: int
+COLOR_WHITE = ...  # type: int
+COLOR_YELLOW = ...  # type: int
+ERR = ...  # type: int
+KEY_A1 = ...  # type: int
+KEY_A3 = ...  # type: int
+KEY_B2 = ...  # type: int
+KEY_BACKSPACE = ...  # type: int
+KEY_BEG = ...  # type: int
+KEY_BREAK = ...  # type: int
+KEY_BTAB = ...  # type: int
+KEY_C1 = ...  # type: int
+KEY_C3 = ...  # type: int
+KEY_CANCEL = ...  # type: int
+KEY_CATAB = ...  # type: int
+KEY_CLEAR = ...  # type: int
+KEY_CLOSE = ...  # type: int
+KEY_COMMAND = ...  # type: int
+KEY_COPY = ...  # type: int
+KEY_CREATE = ...  # type: int
+KEY_CTAB = ...  # type: int
+KEY_DC = ...  # type: int
+KEY_DL = ...  # type: int
+KEY_DOWN = ...  # type: int
+KEY_EIC = ...  # type: int
+KEY_END = ...  # type: int
+KEY_ENTER = ...  # type: int
+KEY_EOL = ...  # type: int
+KEY_EOS = ...  # type: int
+KEY_EXIT = ...  # type: int
+KEY_F0 = ...  # type: int
+KEY_F1 = ...  # type: int
+KEY_F10 = ...  # type: int
+KEY_F11 = ...  # type: int
+KEY_F12 = ...  # type: int
+KEY_F13 = ...  # type: int
+KEY_F14 = ...  # type: int
+KEY_F15 = ...  # type: int
+KEY_F16 = ...  # type: int
+KEY_F17 = ...  # type: int
+KEY_F18 = ...  # type: int
+KEY_F19 = ...  # type: int
+KEY_F2 = ...  # type: int
+KEY_F20 = ...  # type: int
+KEY_F21 = ...  # type: int
+KEY_F22 = ...  # type: int
+KEY_F23 = ...  # type: int
+KEY_F24 = ...  # type: int
+KEY_F25 = ...  # type: int
+KEY_F26 = ...  # type: int
+KEY_F27 = ...  # type: int
+KEY_F28 = ...  # type: int
+KEY_F29 = ...  # type: int
+KEY_F3 = ...  # type: int
+KEY_F30 = ...  # type: int
+KEY_F31 = ...  # type: int
+KEY_F32 = ...  # type: int
+KEY_F33 = ...  # type: int
+KEY_F34 = ...  # type: int
+KEY_F35 = ...  # type: int
+KEY_F36 = ...  # type: int
+KEY_F37 = ...  # type: int
+KEY_F38 = ...  # type: int
+KEY_F39 = ...  # type: int
+KEY_F4 = ...  # type: int
+KEY_F40 = ...  # type: int
+KEY_F41 = ...  # type: int
+KEY_F42 = ...  # type: int
+KEY_F43 = ...  # type: int
+KEY_F44 = ...  # type: int
+KEY_F45 = ...  # type: int
+KEY_F46 = ...  # type: int
+KEY_F47 = ...  # type: int
+KEY_F48 = ...  # type: int
+KEY_F49 = ...  # type: int
+KEY_F5 = ...  # type: int
+KEY_F50 = ...  # type: int
+KEY_F51 = ...  # type: int
+KEY_F52 = ...  # type: int
+KEY_F53 = ...  # type: int
+KEY_F54 = ...  # type: int
+KEY_F55 = ...  # type: int
+KEY_F56 = ...  # type: int
+KEY_F57 = ...  # type: int
+KEY_F58 = ...  # type: int
+KEY_F59 = ...  # type: int
+KEY_F6 = ...  # type: int
+KEY_F60 = ...  # type: int
+KEY_F61 = ...  # type: int
+KEY_F62 = ...  # type: int
+KEY_F63 = ...  # type: int
+KEY_F7 = ...  # type: int
+KEY_F8 = ...  # type: int
+KEY_F9 = ...  # type: int
+KEY_FIND = ...  # type: int
+KEY_HELP = ...  # type: int
+KEY_HOME = ...  # type: int
+KEY_IC = ...  # type: int
+KEY_IL = ...  # type: int
+KEY_LEFT = ...  # type: int
+KEY_LL = ...  # type: int
+KEY_MARK = ...  # type: int
+KEY_MAX = ...  # type: int
+KEY_MESSAGE = ...  # type: int
+KEY_MIN = ...  # type: int
+KEY_MOUSE = ...  # type: int
+KEY_MOVE = ...  # type: int
+KEY_NEXT = ...  # type: int
+KEY_NPAGE = ...  # type: int
+KEY_OPEN = ...  # type: int
+KEY_OPTIONS = ...  # type: int
+KEY_PPAGE = ...  # type: int
+KEY_PREVIOUS = ...  # type: int
+KEY_PRINT = ...  # type: int
+KEY_REDO = ...  # type: int
+KEY_REFERENCE = ...  # type: int
+KEY_REFRESH = ...  # type: int
+KEY_REPLACE = ...  # type: int
+KEY_RESET = ...  # type: int
+KEY_RESIZE = ...  # type: int
+KEY_RESTART = ...  # type: int
+KEY_RESUME = ...  # type: int
+KEY_RIGHT = ...  # type: int
+KEY_SAVE = ...  # type: int
+KEY_SBEG = ...  # type: int
+KEY_SCANCEL = ...  # type: int
+KEY_SCOMMAND = ...  # type: int
+KEY_SCOPY = ...  # type: int
+KEY_SCREATE = ...  # type: int
+KEY_SDC = ...  # type: int
+KEY_SDL = ...  # type: int
+KEY_SELECT = ...  # type: int
+KEY_SEND = ...  # type: int
+KEY_SEOL = ...  # type: int
+KEY_SEXIT = ...  # type: int
+KEY_SF = ...  # type: int
+KEY_SFIND = ...  # type: int
+KEY_SHELP = ...  # type: int
+KEY_SHOME = ...  # type: int
+KEY_SIC = ...  # type: int
+KEY_SLEFT = ...  # type: int
+KEY_SMESSAGE = ...  # type: int
+KEY_SMOVE = ...  # type: int
+KEY_SNEXT = ...  # type: int
+KEY_SOPTIONS = ...  # type: int
+KEY_SPREVIOUS = ...  # type: int
+KEY_SPRINT = ...  # type: int
+KEY_SR = ...  # type: int
+KEY_SREDO = ...  # type: int
+KEY_SREPLACE = ...  # type: int
+KEY_SRESET = ...  # type: int
+KEY_SRIGHT = ...  # type: int
+KEY_SRSUME = ...  # type: int
+KEY_SSAVE = ...  # type: int
+KEY_SSUSPEND = ...  # type: int
+KEY_STAB = ...  # type: int
+KEY_SUNDO = ...  # type: int
+KEY_SUSPEND = ...  # type: int
+KEY_UNDO = ...  # type: int
+KEY_UP = ...  # type: int
+OK = ...  # type: int
+REPORT_MOUSE_POSITION = ...  # type: int
+_C_API = ...  # type: Any
+version = ...  # type: bytes
 
 def baudrate(*args, **kwargs): ...
 def beep(*args, **kwargs): ...

stdlib/3/_importlib_modulespec.pyi

@@ -14,22 +14,22 @@ if sys.version_info >= (3, 4):
         def __init__(self, name: str, loader: Optional['Loader'], *,
                      origin: str = None, loader_state: Any = None,
                      is_package: bool = None) -> None: ...
-        name = ... # type: str
-        loader = ... # type: Optional[Loader]
-        origin = ... # type: Optional[str]
-        submodule_search_locations = ... # type: Optional[List[str]]
-        loader_state = ... # type: Any
-        cached = ... # type: Optional[str]
-        parent = ... # type: Optional[str]
-        has_location = ... # type: bool
+        name = ...  # type: str
+        loader = ...  # type: Optional[Loader]
+        origin = ...  # type: Optional[str]
+        submodule_search_locations = ...  # type: Optional[List[str]]
+        loader_state = ...  # type: Any
+        cached = ...  # type: Optional[str]
+        parent = ...  # type: Optional[str]
+        has_location = ...  # type: bool
 
 class ModuleType:
-    __name__ = ... # type: str
+    __name__ = ...  # type: str
     __file__ = ...  # type: str
     if sys.version_info >= (3, 4):
-        __loader__ = ... # type: Optional[Loader]
-        __package__ = ... # type: Optional[str]
-        __spec__ = ... # type: Optional[ModuleSpec]
+        __loader__ = ...  # type: Optional[Loader]
+        __package__ = ...  # type: Optional[str]
+        __spec__ = ...  # type: Optional[ModuleSpec]
     def __init__(self, name: str, doc: str) -> None: ...
 
 class Loader(metaclass=ABCMeta):

stdlib/3/ast.pyi

@@ -36,4 +36,4 @@ def iter_fields(node: AST) -> Iterator[typing.Tuple[str, Any]]: ...
 def literal_eval(node_or_string: Union[str, AST]) -> Any: ...
 def walk(node: AST) -> Iterator[AST]: ...
 
-PyCF_ONLY_AST = ... # type: int
+PyCF_ONLY_AST = ...  # type: int

stdlib/3/builtins.pyi

@@ -426,13 +426,13 @@ class bytearray(MutableSequence[int], ByteString):
 
 
 class memoryview(Sized, Container[bytes]):
-    format = ... # type: str
-    itemsize = ... # type: int
-    shape = ... # type: Optional[Tuple[int, ...]]
-    strides = ... # type: Optional[Tuple[int, ...]]
-    suboffsets = ... # type: Optional[Tuple[int, ...]]
-    readonly = ... # type: bool
-    ndim = ... # type: int
+    format = ...  # type: str
+    itemsize = ...  # type: int
+    shape = ...  # type: Optional[Tuple[int, ...]]
+    strides = ...  # type: Optional[Tuple[int, ...]]
+    suboffsets = ...  # type: Optional[Tuple[int, ...]]
+    readonly = ...  # type: bool
+    ndim = ...  # type: int
 
     def __init__(self, obj: Union[str, bytes, bytearray, memoryview]) -> None: ...
 
@@ -495,7 +495,7 @@ class function:
     __name__ = ...  # type: str
     __qualname__ = ...  # type: str
     __module__ = ...  # type: str
-    __code__ = ... # type: Any
+    __code__ = ...  # type: Any
 
 class list(MutableSequence[_T], Generic[_T]):
     @overload
@@ -786,7 +786,7 @@ def zip(iter1: Iterable[_T1], iter2: Iterable[_T2],
 @overload
 def zip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],
         iter4: Iterable[_T4]) -> Iterator[Tuple[_T1, _T2,
-                                               _T3, _T4]]: ... # TODO more than four iterables
+                                               _T3, _T4]]: ...  # TODO more than four iterables
 def __import__(name: str, globals: Dict[str, Any] = {}, locals: Dict[str, Any] = {},
                fromlist: List[str] = [], level: int = -1) -> Any: ...
 
@@ -801,9 +801,9 @@ Ellipsis = ...  # type: ellipsis
 
 class BaseException:
     args = ...  # type: Tuple[Any, ...]
-    __cause__ = ... # type: BaseException
-    __context__ = ... # type: BaseException
-    __traceback__ = ... # type: TracebackType
+    __cause__ = ...  # type: BaseException
+    __context__ = ...  # type: BaseException
+    __traceback__ = ...  # type: TracebackType
     def __init__(self, *args: Any) -> None: ...
     def with_traceback(self, tb: Any) -> BaseException: ...
 
@@ -872,19 +872,19 @@ class TypeError(Exception): ...
 class UnboundLocalError(NameError): ...
 class UnicodeError(ValueError): ...
 class UnicodeDecodeError(UnicodeError):
-    encoding = ... # type: str
-    object = ... # type: bytes
-    start = ... # type: int
-    end = ... # type: int
-    reason = ... # type: str
+    encoding = ...  # type: str
+    object = ...  # type: bytes
+    start = ...  # type: int
+    end = ...  # type: int
+    reason = ...  # type: str
     def __init__(self, __encoding: str, __object: bytes, __start: int, __end: int,
                  __reason: str) -> None: ...
 class UnicodeEncodeError(UnicodeError):
-    encoding = ... # type: str
-    object = ... # type: str
-    start = ... # type: int
-    end = ... # type: int
-    reason = ... # type: str
+    encoding = ...  # type: str
+    object = ...  # type: str
+    start = ...  # type: int
+    end = ...  # type: int
+    reason = ...  # type: str
     def __init__(self, __encoding: str, __object: str, __start: int, __end: int,
                  __reason: str) -> None: ...
 class UnicodeTranslateError(UnicodeError): ...

stdlib/3/codecs.pyi

@@ -24,12 +24,12 @@ _encoded = bytes
 
 # TODO: It is not possible to specify these signatures correctly, because
 # they have an optional positional or keyword argument for errors=.
-_encode_type = Callable[[_decoded], _encoded] # signature of Codec().encode
-_decode_type = Callable[[_encoded], _decoded] # signature of Codec().decode
-_stream_reader_type = Callable[[BinaryIO], 'StreamReader'] # signature of StreamReader __init__
-_stream_writer_type = Callable[[BinaryIO], 'StreamWriter'] # signature of StreamWriter __init__
-_incremental_encoder_type = Callable[[], 'IncrementalEncoder'] # signature of IncrementalEncoder __init__
-_incremental_decode_type = Callable[[], 'IncrementalDecoder'] # signature of IncrementalDecoder __init__
+_encode_type = Callable[[_decoded], _encoded]  # signature of Codec().encode
+_decode_type = Callable[[_encoded], _decoded]  # signature of Codec().decode
+_stream_reader_type = Callable[[BinaryIO], 'StreamReader']  # signature of StreamReader __init__
+_stream_writer_type = Callable[[BinaryIO], 'StreamWriter']  # signature of StreamWriter __init__
+_incremental_encoder_type = Callable[[], 'IncrementalEncoder']  # signature of IncrementalEncoder __init__
+_incremental_decode_type = Callable[[], 'IncrementalDecoder']  # signature of IncrementalDecoder __init__
 
 
 def encode(obj: _decoded, encoding: str = ..., errors: str = ...) -> _encoded:

stdlib/3/collections/__init__.pyi

@@ -38,7 +38,7 @@ class MutableString(UserString, MutableSequence): ...
 # Technically, deque only derives from MutableSequence in 3.5.
 # But in practice it's not worth losing sleep over.
 class deque(MutableSequence[_T], Generic[_T]):
-    maxlen = ... # type: Optional[int] # TODO readonly
+    maxlen = ...  # type: Optional[int] # TODO readonly
     def __init__(self, iterable: Iterable[_T] = ...,
                  maxlen: int = ...) -> None: ...
     def append(self, x: _T) -> None: ...

stdlib/3/concurrent/futures/_base.pyi

@@ -1,15 +1,15 @@
 from typing import TypeVar, Generic, Any, Iterable, Iterator, Callable, Tuple, Optional, Set
 from collections import namedtuple
 
-FIRST_COMPLETED = ... # type: Any
-FIRST_EXCEPTION = ... # type: Any
-ALL_COMPLETED = ... # type: Any
-PENDING = ... # type: Any
-RUNNING = ... # type: Any
-CANCELLED = ... # type: Any
-CANCELLED_AND_NOTIFIED = ... # type: Any
-FINISHED = ... # type: Any
-LOGGER = ... # type: Any
+FIRST_COMPLETED = ...  # type: Any
+FIRST_EXCEPTION = ...  # type: Any
+ALL_COMPLETED = ...  # type: Any
+PENDING = ...  # type: Any
+RUNNING = ...  # type: Any
+CANCELLED = ...  # type: Any
+CANCELLED_AND_NOTIFIED = ...  # type: Any
+FINISHED = ...  # type: Any
+LOGGER = ...  # type: Any
 
 class Error(Exception): ...
 class CancelledError(Error): ...

stdlib/3/concurrent/futures/process.pyi

@@ -1,7 +1,7 @@
 from typing import Any, Callable, TypeVar, Iterable, Optional
 from ._base import Future, Executor
 
-EXTRA_QUEUED_CALLS = ... # type: Any
+EXTRA_QUEUED_CALLS = ...  # type: Any
 
 class BrokenProcessPool(RuntimeError): ...
 

stdlib/3/datetime.pyi

@@ -51,7 +51,7 @@ class date:
     def strftime(self, fmt: str) -> str: ...
     def __format__(self, fmt: str) -> str: ...
     def isoformat(self) -> str: ...
-    def timetuple(self) -> tuple: ... # TODO return type
+    def timetuple(self) -> tuple: ...  # TODO return type
     def toordinal(self) -> int: ...
     def replace(self, year: int = ..., month: int = ..., day: int = ...) -> date: ...
     def __le__(self, other: date) -> bool: ...
@@ -191,9 +191,9 @@ class datetime:
     def strftime(self, fmt: str) -> str: ...
     def __format__(self, fmt: str) -> str: ...
     def toordinal(self) -> int: ...
-    def timetuple(self) -> TimeTuple: ... # TODO return type
+    def timetuple(self) -> TimeTuple: ...  # TODO return type
     def timestamp(self) -> float: ...
-    def utctimetuple(self) -> TimeTuple: ... # TODO return type
+    def utctimetuple(self) -> TimeTuple: ...  # TODO return type
     def date(self) -> _date: ...
     def time(self) -> _time: ...
     def timetz(self) -> _time: ...

stdlib/3/decimal.pyi

@@ -31,7 +31,7 @@ def setcontext(c: Context) -> None: ...
 
 DecimalTuple = NamedTuple('DecimalTuple',
                           [('sign', int),
-                           ('digits', Sequence[int]), # TODO: Use Tuple[int, ...]
+                           ('digits', Sequence[int]),  # TODO: Use Tuple[int, ...]
                            ('exponent', int)])
 
 class _ContextManager:

stdlib/3/functools.pyi

@@ -24,7 +24,7 @@ class CacheInfo(NamedTuple('CacheInfo', [
      pass
 
 class _lru_cache_wrapper(Generic[_T]):
-    __wrapped__ = ... # type: Callable[..., _T]
+    __wrapped__ = ...  # type: Callable[..., _T]
     def __call__(self, *args: Any, **kwargs: Any) -> _T: ...
     def cache_info(self) -> CacheInfo: ...
 
@@ -34,8 +34,8 @@ class lru_cache():
     def __call__(self, f: Callable[..., _T]) -> _lru_cache_wrapper[_T]: ...
 
 
-WRAPPER_ASSIGNMENTS = ... # type: Sequence[str]
-WRAPPER_UPDATES = ... # type: Sequence[str]
+WRAPPER_ASSIGNMENTS = ...  # type: Sequence[str]
+WRAPPER_UPDATES = ...  # type: Sequence[str]
 
 def update_wrapper(wrapper: _AnyCallable, wrapped: _AnyCallable, assigned: Sequence[str] = ...,
                    updated: Sequence[str] = ...) -> None: ...

stdlib/3/gc.pyi

@@ -3,13 +3,13 @@
 from typing import Any, List, Tuple
 
 
-DEBUG_COLLECTABLE = ... # type: int
-DEBUG_LEAK = ... # type: int
-DEBUG_SAVEALL = ... # type: int
-DEBUG_STATS = ... # type: int
-DEBUG_UNCOLLECTABLE = ... # type: int
-callbacks = ... # type: List[Any]
-garbage = ... # type: List[Any]
+DEBUG_COLLECTABLE = ...  # type: int
+DEBUG_LEAK = ...  # type: int
+DEBUG_SAVEALL = ...  # type: int
+DEBUG_STATS = ...  # type: int
+DEBUG_UNCOLLECTABLE = ...  # type: int
+callbacks = ...  # type: List[Any]
+garbage = ...  # type: List[Any]
 
 def collect(generations: int = ...) -> int: ...
 def disable() -> None: ...

stdlib/3/gzip.pyi

@@ -8,7 +8,7 @@ import _compression
 def open(filename, mode='', compresslevel=9, encoding=None, errors=None, newline=None): ...
 
 class _PaddedFile:
-    file = ... # type: Any
+    file = ...  # type: Any
     def __init__(self, f, prepend=b''): ...
     def read(self, size): ...
     def prepend(self, prepend=b''): ...
@@ -16,17 +16,17 @@ class _PaddedFile:
     def seekable(self): ...
 
 class GzipFile(_compression.BaseStream):
-    myfileobj = ... # type: Any
-    mode = ... # type: Any
-    name = ... # type: Any
-    compress = ... # type: Any
-    fileobj = ... # type: Any
+    myfileobj = ...  # type: Any
+    mode = ...  # type: Any
+    name = ...  # type: Any
+    compress = ...  # type: Any
+    fileobj = ...  # type: Any
     def __init__(self, filename=None, mode=None, compresslevel=9, fileobj=None, mtime=None): ...
     @property
     def filename(self): ...
     @property
     def mtime(self): ...
-    crc = ... # type: Any
+    crc = ...  # type: Any
     def write(self, data): ...
     def read(self, size=-1): ...
     def read1(self, size=-1): ...

stdlib/3/html/entities.pyi

@@ -4,7 +4,7 @@
 
 from typing import Any
 
-name2codepoint = ... # type: Any
-html5 = ... # type: Any
-codepoint2name = ... # type: Any
-entitydefs = ... # type: Any
+name2codepoint = ...  # type: Any
+html5 = ...  # type: Any
+codepoint2name = ...  # type: Any
+entitydefs = ...  # type: Any