diff --git a/python/helpers/typeshed/stdlib/2/dircache.pyi b/python/helpers/typeshed/stdlib/2/dircache.pyi
new file mode 100644
index 000000000000..ac6732b6c16a
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/dircache.pyi
@@ -0,0 +1,10 @@
+# Source: https://hg.python.org/cpython/file/2.7/Lib/dircache.py
+
+from typing import List, MutableSequence, Text, Union
+
+def reset() -> None: ...
+def listdir(path: Text) -> List[str]: ...
+
+opendir = listdir
+
+def annotate(head: Text, list: Union[MutableSequence[str], MutableSequence[Text], MutableSequence[Union[str, Text]]]) -> None: ...
diff --git a/python/helpers/typeshed/stdlib/2/email/base64mime.pyi b/python/helpers/typeshed/stdlib/2/email/base64mime.pyi
new file mode 100644
index 000000000000..f05003b8d5a7
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/base64mime.pyi
@@ -0,0 +1,8 @@
+def base64_len(s: bytes) -> int: ...
+def header_encode(header, charset=..., keep_eols=..., maxlinelen=..., eol=...): ...
+def encode(s, binary=..., maxlinelen=..., eol=...): ...
+body_encode = encode
+encodestring = encode
+def decode(s, convert_eols=...): ...
+body_decode = decode
+decodestring = decode
diff --git a/python/helpers/typeshed/stdlib/2/email/charset.pyi b/python/helpers/typeshed/stdlib/2/email/charset.pyi
new file mode 100644
index 000000000000..82ba6c0bbbc5
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/charset.pyi
@@ -0,0 +1,22 @@
+def add_charset(charset, header_enc=..., body_enc=..., output_charset=...) -> None: ...
+def add_alias(alias, canonical) -> None: ...
+def add_codec(charset, codecname) -> None: ...
+
+class Charset:
+    input_charset = ...
+    header_encoding = ...
+    body_encoding = ...
+    output_charset = ...
+    input_codec = ...
+    output_codec = ...
+    def __init__(self, input_charset=...) -> None: ...
+    def __eq__(self, other): ...
+    def __ne__(self, other): ...
+    def get_body_encoding(self): ...
+    def convert(self, s): ...
+    def to_splittable(self, s): ...
+    def from_splittable(self, ustr, to_output: bool = ...): ...
+    def get_output_charset(self): ...
+    def encoded_header_len(self, s): ...
+    def header_encode(self, s, convert: bool = ...): ...
+    def body_encode(self, s, convert: bool = ...): ...
diff --git a/python/helpers/typeshed/stdlib/2/email/encoders.pyi b/python/helpers/typeshed/stdlib/2/email/encoders.pyi
new file mode 100644
index 000000000000..5670cbaf08ed
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/encoders.pyi
@@ -0,0 +1,4 @@
+def encode_base64(msg) -> None: ...
+def encode_quopri(msg) -> None: ...
+def encode_7or8bit(msg) -> None: ...
+def encode_noop(msg) -> None: ...
diff --git a/python/helpers/typeshed/stdlib/2/email/feedparser.pyi b/python/helpers/typeshed/stdlib/2/email/feedparser.pyi
new file mode 100644
index 000000000000..51f825939347
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/feedparser.pyi
@@ -0,0 +1,18 @@
+class BufferedSubFile:
+    def __init__(self) -> None: ...
+    def push_eof_matcher(self, pred) -> None: ...
+    def pop_eof_matcher(self): ...
+    def close(self) -> None: ...
+    def readline(self): ...
+    def unreadline(self, line) -> None: ...
+    def push(self, data): ...
+    def pushlines(self, lines) -> None: ...
+    def is_closed(self): ...
+    def __iter__(self): ...
+    def next(self): ...
+
+
+class FeedParser:
+    def __init__(self, _factory=...) -> None: ...
+    def feed(self, data) -> None: ...
+    def close(self): ...
diff --git a/python/helpers/typeshed/stdlib/2/email/generator.pyi b/python/helpers/typeshed/stdlib/2/email/generator.pyi
new file mode 100644
index 000000000000..96cfe2d214a5
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/generator.pyi
@@ -0,0 +1,9 @@
+class Generator:
+    def __init__(self, outfp, mangle_from_: bool = ..., maxheaderlen: int = ...) -> None: ...
+    def write(self, s) -> None: ...
+    def flatten(self, msg, unixfrom: bool = ...) -> None: ...
+    def clone(self, fp): ...
+
+
+class DecodedGenerator(Generator):
+    def __init__(self, outfp, mangle_from_: bool = ..., maxheaderlen: int = ..., fmt=...) -> None: ...
diff --git a/python/helpers/typeshed/stdlib/2/email/header.pyi b/python/helpers/typeshed/stdlib/2/email/header.pyi
new file mode 100644
index 000000000000..69c936300cce
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/header.pyi
@@ -0,0 +1,11 @@
+def decode_header(header): ...
+def make_header(decoded_seq, maxlinelen=..., header_name=..., continuation_ws=...): ...
+
+class Header:
+    def __init__(self, s=..., charset=..., maxlinelen=..., header_name=..., continuation_ws=...,
+                 errors=...) -> None: ...
+    def __unicode__(self): ...
+    def __eq__(self, other): ...
+    def __ne__(self, other): ...
+    def append(self, s, charset=..., errors=...) -> None: ...
+    def encode(self, splitchars=...): ...
diff --git a/python/helpers/typeshed/stdlib/2/email/iterators.pyi b/python/helpers/typeshed/stdlib/2/email/iterators.pyi
new file mode 100644
index 000000000000..48aaf06a6f67
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/iterators.pyi
@@ -0,0 +1,5 @@
+from typing import Generator
+
+def walk(self) -> Generator: ...
+def body_line_iterator(msg, decode: bool = ...) -> Generator: ...
+def typed_subpart_iterator(msg, maintype=..., subtype=...) -> Generator: ...
diff --git a/python/helpers/typeshed/stdlib/2/email/message.pyi b/python/helpers/typeshed/stdlib/2/email/message.pyi
new file mode 100644
index 000000000000..bd3c6220d6e1
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/message.pyi
@@ -0,0 +1,45 @@
+from typing import Generator
+
+class Message:
+    preamble = ...
+    epilogue = ...
+    defects = ...
+    def __init__(self): ...
+    def as_string(self, unixfrom=...): ...
+    def is_multipart(self) -> bool: ...
+    def set_unixfrom(self, unixfrom) -> None: ...
+    def get_unixfrom(self): ...
+    def attach(self, payload) -> None: ...
+    def get_payload(self, i=..., decode: bool = ...): ...
+    def set_payload(self, payload, charset=...) -> None: ...
+    def set_charset(self, charset): ...
+    def get_charset(self): ...
+    def __len__(self): ...
+    def __getitem__(self, name): ...
+    def __setitem__(self, name, val) -> None: ...
+    def __delitem__(self, name) -> None: ...
+    def __contains__(self, name): ...
+    def has_key(self, name) -> bool: ...
+    def keys(self): ...
+    def values(self): ...
+    def items(self): ...
+    def get(self, name, failobj=...): ...
+    def get_all(self, name, failobj=...): ...
+    def add_header(self, _name, _value, **_params) -> None: ...
+    def replace_header(self, _name, _value) -> None: ...
+    def get_content_type(self): ...
+    def get_content_maintype(self): ...
+    def get_content_subtype(self): ...
+    def get_default_type(self): ...
+    def set_default_type(self, ctype) -> None: ...
+    def get_params(self, failobj=..., header=..., unquote: bool = ...): ...
+    def get_param(self, param, failobj=..., header=..., unquote: bool = ...): ...
+    def set_param(self, param, value, header=..., requote: bool = ..., charset=..., language=...) -> None: ...
+    def del_param(self, param, header=..., requote: bool = ...): ...
+    def set_type(self, type, header=..., requote: bool = ...): ...
+    def get_filename(self, failobj=...): ...
+    def get_boundary(self, failobj=...): ...
+    def set_boundary(self, boundary) -> None: ...
+    def get_content_charset(self, failobj=...): ...
+    def get_charsets(self, failobj=...): ...
+    def walk(self) -> Generator: ...
diff --git a/python/helpers/typeshed/stdlib/2/email/mime/audio.pyi b/python/helpers/typeshed/stdlib/2/email/mime/audio.pyi
new file mode 100644
index 000000000000..406ade11b362
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/mime/audio.pyi
@@ -0,0 +1,5 @@
+from email.mime.nonmultipart import MIMENonMultipart
+
+
+class MIMEAudio(MIMENonMultipart):
+    def __init__(self, _audiodata, _subtype=..., _encoder=..., **_params) -> None: ...
diff --git a/python/helpers/typeshed/stdlib/2/email/mime/image.pyi b/python/helpers/typeshed/stdlib/2/email/mime/image.pyi
new file mode 100644
index 000000000000..2dfb098b8567
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/mime/image.pyi
@@ -0,0 +1,5 @@
+from email.mime.nonmultipart import MIMENonMultipart
+
+
+class MIMEImage(MIMENonMultipart):
+    def __init__(self, _imagedata, _subtype=..., _encoder=..., **_params) -> None: ...
diff --git a/python/helpers/typeshed/stdlib/2/email/mime/message.pyi b/python/helpers/typeshed/stdlib/2/email/mime/message.pyi
new file mode 100644
index 000000000000..33552faf2ca6
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/mime/message.pyi
@@ -0,0 +1,5 @@
+from email.mime.nonmultipart import MIMENonMultipart
+
+
+class MIMEMessage(MIMENonMultipart):
+    def __init__(self, _msg, _subtype=...) -> None: ...
diff --git a/python/helpers/typeshed/stdlib/2/email/parser.pyi b/python/helpers/typeshed/stdlib/2/email/parser.pyi
new file mode 100644
index 000000000000..5c80f1a538ac
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/parser.pyi
@@ -0,0 +1,8 @@
+class Parser:
+    def __init__(self, *args, **kws) -> None: ...
+    def parse(self, fp, headersonly: bool = ...): ...
+    def parsestr(self, text, headersonly: bool = ...): ...
+
+class HeaderParser(Parser):
+    def parse(self, fp, headersonly: bool = ...): ...
+    def parsestr(self, text, headersonly: bool = ...): ...
diff --git a/python/helpers/typeshed/stdlib/2/email/quoprimime.pyi b/python/helpers/typeshed/stdlib/2/email/quoprimime.pyi
new file mode 100644
index 000000000000..3f2963c06e6d
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/email/quoprimime.pyi
@@ -0,0 +1,18 @@
+def header_quopri_check(c): ...
+def body_quopri_check(c): ...
+def header_quopri_len(s): ...
+def body_quopri_len(str): ...
+def unquote(s): ...
+def quote(c): ...
+def header_encode(header, charset: str = ..., keep_eols: bool = ..., maxlinelen: int = ..., eol=...): ...
+def encode(body, binary: bool = ..., maxlinelen: int = ..., eol=...): ...
+
+body_encode = encode
+encodestring = encode
+
+def decode(encoded, eol=...): ...
+
+body_decode = decode
+decodestring = decode
+
+def header_decode(s): ...
diff --git a/python/helpers/typeshed/stdlib/2/multiprocessing/pool.pyi b/python/helpers/typeshed/stdlib/2/multiprocessing/pool.pyi
new file mode 100644
index 000000000000..57a628d332b9
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2/multiprocessing/pool.pyi
@@ -0,0 +1,58 @@
+# Stubs for multiprocessing.pool (Python 2)
+
+from typing import (
+    Any, Callable, ContextManager, Iterable, Mapping, Optional, Dict, List,
+    TypeVar,
+)
+
+_T = TypeVar('_T', bound='Pool')
+
+class AsyncResult():
+    def get(self, timeout: Optional[float] = ...) -> Any: ...
+    def wait(self, timeout: Optional[float] = ...) -> None: ...
+    def ready(self) -> bool: ...
+    def successful(self) -> bool: ...
+
+class IMapIterator(Iterable[Any]):
+    def next(self, timeout: Optional[float] = ...) -> Any: ...
+
+class Pool(ContextManager[Pool]):
+    def __init__(self, processes: Optional[int] = ...,
+                 initializer: Optional[Callable[..., None]] = ...,
+                 initargs: Iterable[Any] = ...,
+                 maxtasksperchild: Optional[int] = ...) -> None: ...
+    def apply(self,
+              func: Callable[..., Any],
+              args: Iterable[Any] = ...,
+              kwds: Dict[str, Any] = ...) -> Any: ...
+    def apply_async(self,
+                func: Callable[..., Any],
+                args: Iterable[Any] = ...,
+                kwds: Dict[str, Any] = ...,
+                callback: Optional[Callable[..., None]] = ...) -> AsyncResult: ...
+    def map(self,
+            func: Callable[..., Any],
+            iterable: Iterable[Any] = ...,
+            chunksize: Optional[int] = ...) -> List[Any]: ...
+    def map_async(self, func: Callable[..., Any],
+                  iterable: Iterable[Any] = ...,
+                  chunksize: Optional[int] = ...,
+                  callback: Optional[Callable[..., None]] = ...) -> AsyncResult: ...
+    def imap(self,
+             func: Callable[..., Any],
+             iterable: Iterable[Any] = ...,
+             chunksize: Optional[int] = ...) -> IMapIterator: ...
+    def imap_unordered(self,
+                       func: Callable[..., Any],
+                       iterable: Iterable[Any] = ...,
+                       chunksize: Optional[int] = ...) -> IMapIterator: ...
+    def close(self) -> None: ...
+    def terminate(self) -> None: ...
+    def join(self) -> None: ...
+    def __enter__(self: _T) -> _T: ...
+
+class ThreadPool(Pool, ContextManager[ThreadPool]):
+
+    def __init__(self, processes: Optional[int] = ...,
+                 initializer: Optional[Callable[..., Any]] = ...,
+                 initargs: Iterable[Any] = ...) -> None: ...
diff --git a/python/helpers/typeshed/stdlib/2and3/ctypes/__init__.pyi b/python/helpers/typeshed/stdlib/2and3/ctypes/__init__.pyi
new file mode 100644
index 000000000000..b82f6f490ba0
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2and3/ctypes/__init__.pyi
@@ -0,0 +1,255 @@
+# Stubs for ctypes
+
+from typing import (
+    Any, Callable, ClassVar, Iterable, List, Mapping, Optional, Sequence, Sized, Text, Tuple, Type,
+    Generic, TypeVar, overload,
+)
+from typing import Union as _UnionT
+import sys
+
+_T = TypeVar('_T')
+_DLLT = TypeVar('_DLLT', bound=CDLL)
+_CT = TypeVar('_CT', bound=_CData)
+
+
+RTLD_GLOBAL: int = ...
+RTLD_LOCAL: int = ...
+DEFAULT_MODE: int = ...
+
+
+class CDLL(object):
+    _func_flags_: ClassVar[int] = ...
+    _func_restype_: ClassVar[_CData] = ...
+    _name: str = ...
+    _handle: int = ...
+    _FuncPtr: Type[_FuncPointer] = ...
+    def __init__(self, name: str, mode: int = ..., handle: Optional[int] = ...,
+                 use_errno: bool = ..., use_last_error: bool = ...) -> None: ...
+    def __getattr__(self, name: str) -> _FuncPointer: ...
+    def __getitem__(self, name: str) -> _FuncPointer: ...
+if sys.platform == 'win32':
+    class OleDLL(CDLL): ...
+    class WinDLL(CDLL): ...
+class PyDLL(CDLL): ...
+
+class LibraryLoader(Generic[_DLLT]):
+    def __init__(self, dlltype: Type[_DLLT]) -> None: ...
+    def __getattr__(self, name: str) -> _DLLT: ...
+    def __getitem__(self, name: str) -> _DLLT: ...
+    def LoadLibrary(self, name: str) -> _DLLT: ...
+
+cdll: LibraryLoader[CDLL] = ...
+if sys.platform == 'win32':
+    windll: LibraryLoader[WinDLL] = ...
+    oledll: LibraryLoader[OleDLL] = ...
+pydll: LibraryLoader[PyDLL] = ...
+pythonapi: PyDLL = ...
+
+class _CDataMeta(type):
+    # TODO The return type is not accurate. The method definition *should* look like this:
+    # def __mul__(cls: Type[_CT], other: int) -> Type[Array[_CT]]: ...
+    # but that is not valid, because technically a _CDataMeta might not be a Type[_CT].
+    # This can never actually happen, because all _CDataMeta instances are _CData subclasses, but a typechecker doesn't know that.
+    def __mul__(cls: _CDataMeta, other: int) -> Type[Array[_CT]]: ...
+    def __rmul__(cls: _CDataMeta, other: int) -> Type[Array[_CT]]: ...
+class _CData(metaclass=_CDataMeta):
+    _b_base: int = ...
+    _b_needsfree_: bool = ...
+    _objects: Optional[Mapping[Any, int]] = ...
+    @classmethod
+    def from_buffer(cls: Type[_CT], source: bytearray, offset: int = ...) -> _CT: ...
+    @classmethod
+    def from_buffer_copy(cls: Type[_CT], source: bytearray, offset: int = ...) -> _CT: ...
+    @classmethod
+    def from_address(cls: Type[_CT], address: int) -> _CT: ...
+    @classmethod
+    def from_param(cls: Type[_CT], obj: Any) -> _UnionT[_CT, _cparam]: ...
+    @classmethod
+    def in_dll(cls: Type[_CT], library: CDLL, name: str) -> _CT: ...
+
+class _PointerLike(_CData): pass
+
+_ECT = Callable[[Optional[Type[_CData]],
+                 _FuncPointer,
+                 Tuple[_CData, ...]],
+                _CData]
+_PF = _UnionT[
+    Tuple[int],
+    Tuple[int, str],
+    Tuple[int, str, Any]
+]
+class _FuncPointer(_PointerLike, _CData):
+    restype: _UnionT[Type[_CData], Callable[[int], None], None] = ...
+    argtypes: Tuple[Type[_CData], ...] = ...
+    errcheck: _ECT = ...
+    @overload
+    def __init__(self, address: int) -> None: ...
+    @overload
+    def __init__(self, callable: Callable[..., Any]) -> None: ...
+    @overload
+    def __init__(self, func_spec: Tuple[_UnionT[str, int], CDLL],
+                 paramflags: Tuple[_PF, ...] = ...) -> None: ...
+    @overload
+    def __init__(self, vtlb_index: int, name: str,
+                 paramflags: Tuple[_PF, ...] = ...,
+                 iid: _Pointer[c_int] = ...) -> None: ...
+    def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
+
+class ArgumentError(Exception): ...
+
+
+def CFUNCTYPE(restype: Type[_CData],
+              *argtypes: Type[_CData],
+              use_errno: bool = ...,
+              use_last_error: bool = ...) -> Type[_FuncPointer]: ...
+if sys.platform == 'win32':
+    def WINFUNCTYPE(restype: Type[_CData],
+                    *argtypes: Type[_CData],
+                    use_errno: bool = ...,
+                    use_last_error: bool = ...) -> Type[_FuncPointer]: ...
+def PYFUNCTYPE(restype: Type[_CData],
+               *argtypes: Type[_CData]) -> Type[_FuncPointer]: ...
+
+class _cparam: ...
+
+def addressof(obj: _CData) -> int: ...
+def alignment(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ...
+def byref(obj: _CData, offset: int = ...) -> _cparam: ...
+_PT = TypeVar('_PT', bound=_PointerLike)
+def cast(obj: _UnionT[_CData, _cparam], type: Type[_PT]) -> _PT: ...
+def create_string_buffer(init_or_size: _UnionT[int, bytes],
+                         size: Optional[int] = ...) -> Array[c_char]: ...
+c_buffer = create_string_buffer
+def create_unicode_buffer(init_or_size: _UnionT[int, Text],
+                          size: Optional[int] = ...) -> Array[c_wchar]: ...
+if sys.platform == 'win32':
+    def DllCanUnloadNow() -> int: ...
+    def DllGetClassObject(rclsid: Any, riid: Any, ppv: Any) -> int: ...  # TODO not documented
+    def FormatError(code: int) -> str: ...
+    def GetLastError() -> int: ...
+def get_errno() -> int: ...
+if sys.platform == 'win32':
+    def get_last_error() -> int: ...
+def memmove(dst: _UnionT[int, _CData],
+            src: _UnionT[int, _CData],
+            count: int) -> None: ...
+def memset(dst: _UnionT[int, _CData],
+           c: int, count: int) -> None: ...
+def POINTER(type: Type[_CT]) -> Type[_Pointer[_CT]]: ...
+def pointer(obj: _CT) -> _Pointer[_CT]: ...
+def resize(obj: _CData, size: int) -> None: ...
+if sys.version_info < (3,):
+    def set_conversion_mode(encoding: str, errors: str) -> Tuple[str, str]: ...
+def set_errno(value: int) -> int: ...
+if sys.platform == 'win32':
+    def set_last_error(value: int) -> int: ...
+def sizeof(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ...
+def string_at(address: int, size: int = ...) -> bytes: ...
+if sys.platform == 'win32':
+    def WinError(code: Optional[int] = ...,
+                 desc: Optional[str] = ...) -> OSError: ...
+def wstring_at(address: int, size: int = ...) -> str: ...
+
+class _SimpleCData(Generic[_T], _CData):
+    value: _T = ...
+    def __init__(self, value: _T = ...) -> None: ...
+
+class c_byte(_SimpleCData[int]): ...
+
+class c_char(_SimpleCData[bytes]):
+    def __init__(self, value: _UnionT[int, bytes] = ...) -> None: ...
+class c_char_p(_PointerLike, _SimpleCData[Optional[bytes]]):
+    def __init__(self, value: Optional[_UnionT[int, bytes]] = ...) -> None: ...
+
+class c_double(_SimpleCData[float]): ...
+class c_longdouble(_SimpleCData[float]): ...
+class c_float(_SimpleCData[float]): ...
+
+class c_int(_SimpleCData[int]): ...
+class c_int8(_SimpleCData[int]): ...
+class c_int16(_SimpleCData[int]): ...
+class c_int32(_SimpleCData[int]): ...
+class c_int64(_SimpleCData[int]): ...
+
+class c_long(_SimpleCData[int]): ...
+class c_longlong(_SimpleCData[int]): ...
+
+class c_short(_SimpleCData[int]): ...
+
+class c_size_t(_SimpleCData[int]): ...
+class c_ssize_t(_SimpleCData[int]): ...
+
+class c_ubyte(_SimpleCData[int]): ...
+
+class c_uint(_SimpleCData[int]): ...
+class c_uint8(_SimpleCData[int]): ...
+class c_uint16(_SimpleCData[int]): ...
+class c_uint32(_SimpleCData[int]): ...
+class c_uint64(_SimpleCData[int]): ...
+
+class c_ulong(_SimpleCData[int]): ...
+class c_ulonglong(_SimpleCData[int]): ...
+
+class c_ushort(_SimpleCData[int]): ...
+
+class c_void_p(_PointerLike, _SimpleCData[Optional[int]]): ...
+
+class c_wchar(_SimpleCData[Text]): ...
+class c_wchar_p(_PointerLike, _SimpleCData[Optional[Text]]):
+    def __init__(self, value: Optional[_UnionT[int, Text]] = ...) -> None: ...
+
+class c_bool(_SimpleCData[bool]):
+    def __init__(self, value: bool) -> None: ...
+
+if sys.platform == 'win32':
+    class HRESULT(_SimpleCData[Any]): ...  # TODO undocumented
+
+class py_object(_SimpleCData[_T]): ...
+
+class _CField:
+    offset: int = ...
+    size: int = ...
+class _StructUnionMeta(_CDataMeta):
+    _fields_: Sequence[_UnionT[Tuple[str, Type[_CData]], Tuple[str, Type[_CData], int]]] = ...
+    _pack_: int = ...
+    _anonymous_: Sequence[str] = ...
+    def __getattr__(self, name: str) -> _CField: ...
+class _StructUnionBase(_CData, metaclass=_StructUnionMeta):
+    def __init__(self, *args: Any, **kw: Any) -> None: ...
+    def __getattr__(self, name: str) -> Any: ...
+    def __setattr__(self, name: str, value: Any) -> None: ...
+
+class Union(_StructUnionBase): pass
+class Structure(_StructUnionBase): pass
+class BigEndianStructure(Structure): pass
+class LittleEndianStructure(Structure): pass
+
+class Array(Generic[_T], Sized, _CData):
+    _length_: ClassVar[int] = ...
+    _type_: ClassVar[Type[_T]] = ...
+    raw: bytes = ...  # TODO only available with _T == c_char
+    value: bytes = ...  # TODO only available with _T == c_char
+    def __init__(self, *args: _T) -> None: ...
+    @overload
+    def __getitem__(self, i: int) -> _T: ...
+    @overload
+    def __getitem__(self, s: slice) -> List[_T]: ...
+    @overload
+    def __setitem__(self, i: int, o: _T) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
+    def __iter__(self) -> Iterable[_T]: ...
+
+
+class _Pointer(Generic[_T], _PointerLike, _CData):
+    _type_: ClassVar[Type[_T]] = ...
+    contents: _T = ...
+    def __init__(self, arg: _T = ...) -> None: ...
+    @overload
+    def __getitem__(self, i: int) -> _T: ...
+    @overload
+    def __getitem__(self, s: slice) -> List[_T]: ...
+    @overload
+    def __setitem__(self, i: int, o: _T) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
diff --git a/python/helpers/typeshed/stdlib/2and3/ctypes/util.pyi b/python/helpers/typeshed/stdlib/2and3/ctypes/util.pyi
new file mode 100644
index 000000000000..7077d9d2f1e9
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2and3/ctypes/util.pyi
@@ -0,0 +1,8 @@
+# Stubs for ctypes.util
+
+from typing import Optional
+import sys
+
+def find_library(name: str) -> Optional[str]: ...
+if sys.platform == 'win32':
+    def find_msvcrt() -> Optional[str]: ...
diff --git a/python/helpers/typeshed/stdlib/2and3/time.pyi b/python/helpers/typeshed/stdlib/2and3/time.pyi
new file mode 100644
index 000000000000..7d46ade8ad43
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/2and3/time.pyi
@@ -0,0 +1,96 @@
+"""Stub file for the 'time' module."""
+# See https://docs.python.org/3/library/time.html
+
+import sys
+from typing import Any, NamedTuple, Tuple, Union, Optional
+if sys.version_info >= (3, 3):
+    from types import SimpleNamespace
+
+_TimeTuple = Tuple[int, int, int, int, int, int, int, int, int]
+
+if sys.version_info < (3, 3):
+    accept2dyear: bool
+altzone: int
+daylight: int
+timezone: int
+tzname: Tuple[str, str]
+
+if sys.version_info >= (3, 3) and sys.platform != 'win32':
+    CLOCK_HIGHRES: int = ...  # Solaris only
+    CLOCK_MONOTONIC: int = ...  # Unix only
+    CLOCK_MONOTONIC_RAW: int = ...  # Linux 2.6.28 or later
+    CLOCK_PROCESS_CPUTIME_ID: int = ...  # Unix only
+    CLOCK_REALTIME: int = ...  # Unix only
+    CLOCK_THREAD_CPUTIME_ID: int = ...  # Unix only
+
+
+if sys.version_info >= (3, 3):
+    class struct_time(
+        NamedTuple(
+            '_struct_time',
+            [('tm_year', int), ('tm_mon', int), ('tm_mday', int),
+             ('tm_hour', int), ('tm_min', int), ('tm_sec', int),
+             ('tm_wday', int), ('tm_yday', int), ('tm_isdst', int),
+             ('tm_zone', str), ('tm_gmtoff', int)]
+        )
+    ):
+        def __init__(
+            self,
+            o: Union[
+                Tuple[int, int, int, int, int, int, int, int, int],
+                Tuple[int, int, int, int, int, int, int, int, int, str],
+                Tuple[int, int, int, int, int, int, int, int, int, str, int]
+            ],
+            _arg: Any = ...,
+        ) -> None: ...
+        def __new__(
+            cls,
+            o: Union[
+                Tuple[int, int, int, int, int, int, int, int, int],
+                Tuple[int, int, int, int, int, int, int, int, int, str],
+                Tuple[int, int, int, int, int, int, int, int, int, str, int]
+            ],
+            _arg: Any = ...,
+        ) -> struct_time: ...
+else:
+    class struct_time(
+        NamedTuple(
+            '_struct_time',
+            [('tm_year', int), ('tm_mon', int), ('tm_mday', int),
+             ('tm_hour', int), ('tm_min', int), ('tm_sec', int),
+             ('tm_wday', int), ('tm_yday', int), ('tm_isdst', int)]
+        )
+    ):
+        def __init__(self, o: _TimeTuple, _arg: Any = ...) -> None: ...
+        def __new__(cls, o: _TimeTuple, _arg: Any = ...) -> struct_time: ...
+
+def asctime(t: Union[_TimeTuple, struct_time] = ...) -> str: ...
+def clock() -> float: ...
+def ctime(secs: Optional[float] = ...) -> str: ...
+def gmtime(secs: Optional[float] = ...) -> struct_time: ...
+def localtime(secs: Optional[float] = ...) -> struct_time: ...
+def mktime(t: Union[_TimeTuple, struct_time]) -> float: ...
+def sleep(secs: float) -> None: ...
+def strftime(format: str, t: Union[_TimeTuple, struct_time] = ...) -> str: ...
+def strptime(string: str, format: str = ...) -> struct_time: ...
+def time() -> float: ...
+if sys.platform != 'win32':
+    def tzset() -> None: ...  # Unix only
+
+if sys.version_info >= (3, 3):
+    def get_clock_info(name: str) -> SimpleNamespace: ...
+    def monotonic() -> float: ...
+    def perf_counter() -> float: ...
+    def process_time() -> float: ...
+    if sys.platform != 'win32':
+        def clock_getres(clk_id: int) -> float: ...  # Unix only
+        def clock_gettime(clk_id: int) -> float: ...  # Unix only
+        def clock_settime(clk_id: int, time: float) -> None: ...  # Unix only
+
+if sys.version_info >= (3, 7):
+    def clock_gettime_ns(clock_id: int) -> int: ...
+    def clock_settime_ns(clock_id: int, time: int) -> int: ...
+    def monotonic_ns() -> int: ...
+    def perf_counter_ns() -> int: ...
+    def process_time_ns() -> int: ...
+    def time_ns() -> int: ...
diff --git a/python/helpers/typeshed/stdlib/3.7/contextvars.pyi b/python/helpers/typeshed/stdlib/3.7/contextvars.pyi
new file mode 100644
index 000000000000..b5c8082aa083
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/3.7/contextvars.pyi
@@ -0,0 +1,27 @@
+from typing import Any, Callable, ClassVar, Generic, Mapping, TypeVar, Union
+
+_T = TypeVar('_T')
+
+class ContextVar(Generic[_T]):
+    def __init__(self, name: str, *, default: _T = ...) -> None: ...
+    @property
+    def name(self) -> str: ...
+    def get(self, default: _T = ...) -> _T: ...
+    def set(self, value: _T) -> Token[_T]: ...
+    def reset(self, token: Token[_T]) -> None: ...
+
+class Token(Generic[_T]):
+    @property
+    def var(self) -> ContextVar[_T]: ...
+    @property
+    def old_value(self) -> Any: ...  # returns either _T or MISSING, but that's hard to express
+    MISSING: ClassVar[object]
+
+def copy_context() -> Context: ...
+
+# It doesn't make sense to make this generic, because for most Contexts each ContextVar will have
+# a different value.
+class Context(Mapping[ContextVar[Any], Any]):
+    def __init__(self) -> None: ...
+    def run(self, callable: Callable[..., _T], *args: Any, **kwargs: Any) -> _T: ...
+    def copy(self) -> Context: ...
diff --git a/python/helpers/typeshed/stdlib/3/multiprocessing/queues.pyi b/python/helpers/typeshed/stdlib/3/multiprocessing/queues.pyi
new file mode 100644
index 000000000000..c6dd0f20d631
--- /dev/null
+++ b/python/helpers/typeshed/stdlib/3/multiprocessing/queues.pyi
@@ -0,0 +1,30 @@
+from typing import Any, Generic, Optional, TypeVar
+
+import queue
+
+_T = TypeVar('_T')
+
+class Queue(queue.Queue[_T]):
+    # FIXME: `ctx` is a circular dependency and it's not actually optional.
+    # It's marked as such to be able to use the generic Queue in __init__.pyi.
+    def __init__(self, maxsize: int = ..., *, ctx: Any = ...) -> None: ...
+    def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ...
+    def put(self, obj: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ...
+    def qsize(self) -> int: ...
+    def empty(self) -> bool: ...
+    def full(self) -> bool: ...
+    def put_nowait(self, item: _T) -> None: ...
+    def get_nowait(self) -> _T: ...
+    def close(self) -> None: ...
+    def join_thread(self) -> None: ...
+    def cancel_join_thread(self) -> None: ...
+
+class JoinableQueue(Queue[_T]):
+    def task_done(self) -> None: ...
+    def join(self) -> None: ...
+
+class SimpleQueue(Generic[_T]):
+    def __init__(self, *, ctx: Any = ...) -> None: ...
+    def empty(self) -> bool: ...
+    def get(self) -> _T: ...
+    def put(self, item: _T) -> None: ...
diff --git a/python/helpers/typeshed/third_party/2/google/protobuf/internal/containers.pyi b/python/helpers/typeshed/third_party/2/google/protobuf/internal/containers.pyi
new file mode 100644
index 000000000000..c78fadf55d47
--- /dev/null
+++ b/python/helpers/typeshed/third_party/2/google/protobuf/internal/containers.pyi
@@ -0,0 +1,35 @@
+from google.protobuf.descriptor import Descriptor
+from google.protobuf.internal.message_listener import MessageListener
+from google.protobuf.message import Message
+from typing import (
+    MutableSequence, Sequence, TypeVar, Generic, Any, Iterator, Iterable,
+    Union, Optional, Callable
+)
+
+_T = TypeVar('_T')
+class BaseContainer(Generic[_T], MutableSequence[_T]):
+    def __init__(self, message_listener: MessageListener) -> None: ...
+    def __len__(self) -> int: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __repr__(self) -> str: ...
+    def sort(self, *, key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ...) -> None: ...
+
+class RepeatedScalarFieldContainer(Generic[_T], BaseContainer[_T]):
+    def __init__(self, message_listener: MessageListener, message_descriptor: Descriptor) -> None: ...
+    def MergeFrom(self, other: RepeatedScalarFieldContainer[_T]) -> None: ...
+
+class RepeatedCompositeFieldContainer(Generic[_T], BaseContainer[_T]):
+    def __init__(self, message_listener: MessageListener, type_checker: Any) -> None: ...
+    def add(self, **kwargs: Any) -> _T: ...
+    def MergeFrom(self, other: RepeatedCompositeFieldContainer[_T]) -> None: ...
+
+# Classes not yet typed
+class Mapping(Any):
+    pass
+class MutableMapping(Mapping):
+    pass
+class ScalarMap(MutableMapping):
+    pass
+class MessageMap(MutableMapping):
+    pass
diff --git a/python/helpers/typeshed/third_party/2/google/protobuf/internal/message_listener.pyi b/python/helpers/typeshed/third_party/2/google/protobuf/internal/message_listener.pyi
new file mode 100644
index 000000000000..e8d33a5a1a47
--- /dev/null
+++ b/python/helpers/typeshed/third_party/2/google/protobuf/internal/message_listener.pyi
@@ -0,0 +1,5 @@
+class MessageListener(object):
+    def Modified(self) -> None: ...
+
+class NullMessageListener(MessageListener):
+    def Modified(self) -> None: ...
diff --git a/python/helpers/typeshed/third_party/2/tornado/process.pyi b/python/helpers/typeshed/third_party/2/tornado/process.pyi
new file mode 100644
index 000000000000..c467454986d0
--- /dev/null
+++ b/python/helpers/typeshed/third_party/2/tornado/process.pyi
@@ -0,0 +1,24 @@
+from typing import Any, Optional
+
+long = int
+CalledProcessError: Any
+
+def cpu_count() -> int: ...
+def fork_processes(num_processes, max_restarts: int = ...) -> Optional[int]: ...
+def task_id() -> int: ...
+
+class Subprocess:
+    STREAM: Any = ...
+    io_loop: Any = ...
+    stdin: Any = ...
+    stdout: Any = ...
+    stderr: Any = ...
+    proc: Any = ...
+    returncode: Any = ...
+    def __init__(self, *args, **kwargs) -> None: ...
+    def set_exit_callback(self, callback): ...
+    def wait_for_exit(self, raise_error: bool = ...): ...
+    @classmethod
+    def initialize(cls, io_loop: Optional[Any] = ...): ...
+    @classmethod
+    def uninitialize(cls): ...
diff --git a/python/helpers/typeshed/third_party/2and3/attr/__init__.pyi b/python/helpers/typeshed/third_party/2and3/attr/__init__.pyi
new file mode 100644
index 000000000000..3422fc89d23f
--- /dev/null
+++ b/python/helpers/typeshed/third_party/2and3/attr/__init__.pyi
@@ -0,0 +1,372 @@
+from typing import Any, Callable, Dict, Generic, List, Optional, Sequence, Mapping, Tuple, Type, TypeVar, Union, overload
+# `import X as X` is required to make these public
+from . import exceptions as exceptions
+from . import filters as filters
+from . import converters as converters
+from . import validators as validators
+
+_T = TypeVar('_T')
+_C = TypeVar('_C', bound=type)
+
+_ValidatorType = Callable[[Any, Attribute, _T], Any]
+_ConverterType = Callable[[Any], _T]
+_FilterType = Callable[[Attribute, Any], bool]
+# FIXME: in reality, if multiple validators are passed they must be in a list or tuple,
+# but those are invariant and so would prevent subtypes of _ValidatorType from working
+# when passed in a list or tuple.
+_ValidatorArgType = Union[_ValidatorType[_T], Sequence[_ValidatorType[_T]]]
+
+# _make --
+
+NOTHING: object
+
+# NOTE: Factory lies about its return type to make this possible: `x: List[int] = Factory(list)`
+# Work around mypy issue #4554 by using an overload vs a Union.
+@overload
+def Factory(factory: Callable[[], _T], takes_self: bool = ...) -> _T: ...
+@overload
+def Factory(factory: Callable[[Any], _T], takes_self: bool = ...) -> _T: ...
+
+class Attribute(Generic[_T]):
+    name: str
+    default: Optional[_T]
+    validator: Optional[_ValidatorType[_T]]
+    repr: bool
+    cmp: bool
+    hash: Optional[bool]
+    init: bool
+    converter: Optional[_ConverterType[_T]]
+    metadata: Dict[Any, Any]
+    type: Optional[Type[_T]]
+    def __lt__(self, x: Attribute) -> bool: ...
+    def __le__(self, x: Attribute) -> bool: ...
+    def __gt__(self, x: Attribute) -> bool: ...
+    def __ge__(self, x: Attribute) -> bool: ...
+
+
+# NOTE: We had several choices for the annotation to use for type arg:
+# 1) Type[_T]
+#   - Pros: works in PyCharm without plugin support
+#   - Cons: produces less informative error in the case of conflicting TypeVars
+#     e.g. `attr.ib(default='bad', type=int)`
+# 2) Callable[..., _T]
+#   - Pros: more informative errors than #1
+#   - Cons: validator tests results in confusing error.
+#     e.g. `attr.ib(type=int, validator=validate_str)`
+# 3) type (and do all of the work in the mypy plugin)
+#   - Pros: in mypy, the behavior of type argument is exactly the same as with
+#     annotations.
+#   - Cons: completely disables type inspections in PyCharm when using the
+#     type arg.
+# We chose option #1 until either PyCharm adds support for attrs, or python 2
+# reaches EOL.
+
+# NOTE: If you update these, update `ib` and `attr` below.
+
+# `attr` lies about its return type to make the following possible:
+#     attr()    -> Any
+#     attr(8)   -> int
+#     attr(validator=<some callable>)  -> Whatever the callable expects.
+# This makes this type of assignments possible:
+#     x: int = attr(8)
+
+# This form catches an explicit None or no default and infers the type from the other arguments.
+@overload
+def attrib(default: None = ...,
+           validator: Optional[_ValidatorArgType[_T]] = ...,
+           repr: bool = ...,
+           cmp: bool = ...,
+           hash: Optional[bool] = ...,
+           init: bool = ...,
+           convert: Optional[_ConverterType[_T]] = ...,
+           metadata: Optional[Mapping[Any, Any]] = ...,
+           type: Optional[Type[_T]] = ...,
+           converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
+# This form catches an explicit default argument.
+@overload
+def attrib(default: _T,
+           validator: Optional[_ValidatorArgType[_T]] = ...,
+           repr: bool = ...,
+           cmp: bool = ...,
+           hash: Optional[bool] = ...,
+           init: bool = ...,
+           convert: Optional[_ConverterType[_T]] = ...,
+           metadata: Optional[Mapping[Any, Any]] = ...,
+           type: Optional[Type[_T]] = ...,
+           converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
+# This form catches explicit None or no default but with no other arguments returns Any.
+@overload
+def attrib(default: None = ...,
+           validator: None = ...,
+           repr: bool = ...,
+           cmp: bool = ...,
+           hash: Optional[bool] = ...,
+           init: bool = ...,
+           convert: None = ...,
+           metadata: Optional[Mapping[Any, Any]] = ...,
+           type: None = ...,
+           converter: None = ...) -> Any: ...
+# This form covers type=non-Type: e.g. forward references (str), Any
+@overload
+def attrib(default: Optional[_T] = ...,
+           validator: Optional[_ValidatorArgType[_T]] = ...,
+           repr: bool = ...,
+           cmp: bool = ...,
+           hash: Optional[bool] = ...,
+           init: bool = ...,
+           convert: Optional[_ConverterType[_T]] = ...,
+           metadata: Optional[Mapping[Any, Any]] = ...,
+           type: object = ...,
+           converter: Optional[_ConverterType[_T]] = ...) -> Any: ...
+
+
+# NOTE: If you update these, update `s` and `attributes` below.
+@overload
+def attrs(maybe_cls: _C,
+          these: Optional[Dict[str, Any]] = ...,
+          repr_ns: Optional[str] = ...,
+          repr: bool = ...,
+          cmp: bool = ...,
+          hash: Optional[bool] = ...,
+          init: bool = ...,
+          slots: bool = ...,
+          frozen: bool = ...,
+          str: bool = ...,
+          auto_attribs: bool = ...) -> _C: ...
+@overload
+def attrs(maybe_cls: None = ...,
+          these: Optional[Dict[str, Any]] = ...,
+          repr_ns: Optional[str] = ...,
+          repr: bool = ...,
+          cmp: bool = ...,
+          hash: Optional[bool] = ...,
+          init: bool = ...,
+          slots: bool = ...,
+          frozen: bool = ...,
+          str: bool = ...,
+          auto_attribs: bool = ...) -> Callable[[_C], _C]: ...
+
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+class _Fields(Tuple[Attribute, ...]):
+    def __getattr__(self, name: str) -> Attribute: ...
+
+def fields(cls: type) -> _Fields: ...
+def validate(inst: Any) -> None: ...
+
+# TODO: add support for returning a proper attrs class from the mypy plugin
+# we use Any instead of _CountingAttr so that e.g. `make_class('Foo', [attr.ib()])` is valid
+def make_class(name: str,
+               attrs: Union[List[str], Tuple[str, ...], Dict[str, Any]],
+               bases: Tuple[type, ...] = ...,
+               repr_ns: Optional[str] = ...,
+               repr: bool = ...,
+               cmp: bool = ...,
+               hash: Optional[bool] = ...,
+               init: bool = ...,
+               slots: bool = ...,
+               frozen: bool = ...,
+               str: bool = ...,
+               auto_attribs: bool = ...) -> type: ...
+
+# _funcs --
+
+# TODO: add support for returning TypedDict from the mypy plugin
+# FIXME: asdict/astuple do not honor their factory args.  waiting on one of these:
+# https://github.com/python/mypy/issues/4236
+# https://github.com/python/typing/issues/253
+def asdict(inst: Any,
+           recurse: bool = ...,
+           filter: Optional[_FilterType] = ...,
+           dict_factory: Type[Mapping[Any, Any]] = ...,
+           retain_collection_types: bool = ...) -> Dict[str, Any]: ...
+# TODO: add support for returning NamedTuple from the mypy plugin
+def astuple(inst: Any,
+            recurse: bool = ...,
+            filter: Optional[_FilterType] = ...,
+            tuple_factory: Type[Sequence] = ...,
+            retain_collection_types: bool = ...) -> Tuple[Any, ...]: ...
+def has(cls: type) -> bool: ...
+def assoc(inst: _T, **changes: Any) -> _T: ...
+def evolve(inst: _T, **changes: Any) -> _T: ...
+
+# _config --
+
+def set_run_validators(run: bool) -> None: ...
+def get_run_validators() -> bool: ...
+
+
+# aliases --
+
+# FIXME: there is a bug in PyCharm with creating aliases to overloads.
+# Use the aliases instead of the duplicated overloads when the bug is fixed:
+# https://youtrack.jetbrains.com/issue/PY-27788
+
+# s = attributes = attrs
+# ib = attr = attrib
+# dataclass = attrs # Technically, partial(attrs, auto_attribs=True) ;)
+
+
+@overload
+def ib(default: None = ...,
+       validator: Optional[_ValidatorArgType[_T]] = ...,
+       repr: bool = ...,
+       cmp: bool = ...,
+       hash: Optional[bool] = ...,
+       init: bool = ...,
+       convert: Optional[_ConverterType[_T]] = ...,
+       metadata: Optional[Mapping[Any, Any]] = ...,
+       type: Optional[Type[_T]] = ...,
+       converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
+@overload
+def ib(default: _T,
+       validator: Optional[_ValidatorArgType[_T]] = ...,
+       repr: bool = ...,
+       cmp: bool = ...,
+       hash: Optional[bool] = ...,
+       init: bool = ...,
+       convert: Optional[_ConverterType[_T]] = ...,
+       metadata: Optional[Mapping[Any, Any]] = ...,
+       type: Optional[Type[_T]] = ...,
+       converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
+@overload
+def ib(default: None = ...,
+       validator: None = ...,
+       repr: bool = ...,
+       cmp: bool = ...,
+       hash: Optional[bool] = ...,
+       init: bool = ...,
+       convert: None = ...,
+       metadata: Optional[Mapping[Any, Any]] = ...,
+       type: None = ...,
+       converter: None = ...) -> Any: ...
+@overload
+def ib(default: Optional[_T] = ...,
+       validator: Optional[_ValidatorArgType[_T]] = ...,
+       repr: bool = ...,
+       cmp: bool = ...,
+       hash: Optional[bool] = ...,
+       init: bool = ...,
+       convert: Optional[_ConverterType[_T]] = ...,
+       metadata: Optional[Mapping[Any, Any]] = ...,
+       type: object = ...,
+       converter: Optional[_ConverterType[_T]] = ...) -> Any: ...
+
+@overload
+def attr(default: None = ...,
+         validator: Optional[_ValidatorArgType[_T]] = ...,
+         repr: bool = ...,
+         cmp: bool = ...,
+         hash: Optional[bool] = ...,
+         init: bool = ...,
+         convert: Optional[_ConverterType[_T]] = ...,
+         metadata: Optional[Mapping[Any, Any]] = ...,
+         type: Optional[Type[_T]] = ...,
+         converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
+@overload
+def attr(default: _T,
+         validator: Optional[_ValidatorArgType[_T]] = ...,
+         repr: bool = ...,
+         cmp: bool = ...,
+         hash: Optional[bool] = ...,
+         init: bool = ...,
+         convert: Optional[_ConverterType[_T]] = ...,
+         metadata: Optional[Mapping[Any, Any]] = ...,
+         type: Optional[Type[_T]] = ...,
+         converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
+@overload
+def attr(default: None = ...,
+         validator: None = ...,
+         repr: bool = ...,
+         cmp: bool = ...,
+         hash: Optional[bool] = ...,
+         init: bool = ...,
+         convert: None = ...,
+         metadata: Optional[Mapping[Any, Any]] = ...,
+         type: None = ...,
+         converter: None = ...) -> Any: ...
+@overload
+def attr(default: Optional[_T] = ...,
+         validator: Optional[_ValidatorArgType[_T]] = ...,
+         repr: bool = ...,
+         cmp: bool = ...,
+         hash: Optional[bool] = ...,
+         init: bool = ...,
+         convert: Optional[_ConverterType[_T]] = ...,
+         metadata: Optional[Mapping[Any, Any]] = ...,
+         type: object = ...,
+         converter: Optional[_ConverterType[_T]] = ...) -> Any: ...
+
+@overload
+def attributes(maybe_cls: _C,
+               these: Optional[Dict[str, Any]] = ...,
+               repr_ns: Optional[str] = ...,
+               repr: bool = ...,
+               cmp: bool = ...,
+               hash: Optional[bool] = ...,
+               init: bool = ...,
+               slots: bool = ...,
+               frozen: bool = ...,
+               str: bool = ...,
+               auto_attribs: bool = ...) -> _C: ...
+@overload
+def attributes(maybe_cls: None = ...,
+               these: Optional[Dict[str, Any]] = ...,
+               repr_ns: Optional[str] = ...,
+               repr: bool = ...,
+               cmp: bool = ...,
+               hash: Optional[bool] = ...,
+               init: bool = ...,
+               slots: bool = ...,
+               frozen: bool = ...,
+               str: bool = ...,
+               auto_attribs: bool = ...) -> Callable[[_C], _C]: ...
+
+@overload
+def s(maybe_cls: _C,
+      these: Optional[Dict[str, Any]] = ...,
+      repr_ns: Optional[str] = ...,
+      repr: bool = ...,
+      cmp: bool = ...,
+      hash: Optional[bool] = ...,
+      init: bool = ...,
+      slots: bool = ...,
+      frozen: bool = ...,
+      str: bool = ...,
+      auto_attribs: bool = ...) -> _C: ...
+@overload
+def s(maybe_cls: None = ...,
+      these: Optional[Dict[str, Any]] = ...,
+      repr_ns: Optional[str] = ...,
+      repr: bool = ...,
+      cmp: bool = ...,
+      hash: Optional[bool] = ...,
+      init: bool = ...,
+      slots: bool = ...,
+      frozen: bool = ...,
+      str: bool = ...,
+      auto_attribs: bool = ...) -> Callable[[_C], _C]: ...
+
+# same as above, but with auto_attrib=True
+@overload
+def dataclass(maybe_cls: _C,
+              these: Optional[Dict[str, Any]] = ...,
+              repr_ns: Optional[str] = ...,
+              repr: bool = ...,
+              cmp: bool = ...,
+              hash: Optional[bool] = ...,
+              init: bool = ...,
+              slots: bool = ...,
+              frozen: bool = ...,
+              str: bool = ...) -> _C: ...
+@overload
+def dataclass(maybe_cls: None = ...,
+              these: Optional[Dict[str, Any]] = ...,
+              repr_ns: Optional[str] = ...,
+              repr: bool = ...,
+              cmp: bool = ...,
+              hash: Optional[bool] = ...,
+              init: bool = ...,
+              slots: bool = ...,
+              frozen: bool = ...,
+              str: bool = ...) -> Callable[[_C], _C]: ...
diff --git a/python/helpers/typeshed/third_party/2and3/attr/converters.pyi b/python/helpers/typeshed/third_party/2and3/attr/converters.pyi
new file mode 100644
index 000000000000..9e31677e79c3
--- /dev/null
+++ b/python/helpers/typeshed/third_party/2and3/attr/converters.pyi
@@ -0,0 +1,6 @@
+from typing import TypeVar, Optional
+from . import _ConverterType
+
+_T = TypeVar('_T')
+
+def optional(converter: _ConverterType[_T]) -> _ConverterType[Optional[_T]]: ...
diff --git a/python/helpers/typeshed/third_party/2and3/attr/exceptions.pyi b/python/helpers/typeshed/third_party/2and3/attr/exceptions.pyi
new file mode 100644
index 000000000000..4a2904fc25b1
--- /dev/null
+++ b/python/helpers/typeshed/third_party/2and3/attr/exceptions.pyi
@@ -0,0 +1,6 @@
+class FrozenInstanceError(AttributeError):
+    msg: str = ...
+class AttrsAttributeNotFoundError(ValueError): ...
+class NotAnAttrsClassError(ValueError): ...
+class DefaultAlreadySetError(RuntimeError): ...
+class UnannotatedAttributeError(RuntimeError): ...
diff --git a/python/helpers/typeshed/third_party/2and3/attr/filters.pyi b/python/helpers/typeshed/third_party/2and3/attr/filters.pyi
new file mode 100644
index 000000000000..a618140c2d1b
--- /dev/null
+++ b/python/helpers/typeshed/third_party/2and3/attr/filters.pyi
@@ -0,0 +1,5 @@
+from typing import Union
+from . import Attribute, _FilterType
+
+def include(*what: Union[type, Attribute]) -> _FilterType: ...
+def exclude(*what: Union[type, Attribute]) -> _FilterType: ...
diff --git a/python/helpers/typeshed/third_party/2and3/attr/validators.pyi b/python/helpers/typeshed/third_party/2and3/attr/validators.pyi
new file mode 100644
index 000000000000..3fc34377c2c6
--- /dev/null
+++ b/python/helpers/typeshed/third_party/2and3/attr/validators.pyi
@@ -0,0 +1,10 @@
+from typing import Container, List, Union, TypeVar, Type, Any, Optional, Tuple
+from . import _ValidatorType
+
+_T = TypeVar('_T')
+
+def instance_of(type: Union[Tuple[Type[_T], ...], Type[_T]]) -> _ValidatorType[_T]: ...
+def provides(interface: Any) -> _ValidatorType[Any]: ...
+def optional(validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]]) -> _ValidatorType[Optional[_T]]: ...
+def in_(options: Container[_T]) -> _ValidatorType[_T]: ...
+def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ...
diff --git a/python/helpers/typeshed/third_party/2and3/termcolor.pyi b/python/helpers/typeshed/third_party/2and3/termcolor.pyi
new file mode 100644
index 000000000000..e1ad18b8a58c
--- /dev/null
+++ b/python/helpers/typeshed/third_party/2and3/termcolor.pyi
@@ -0,0 +1,21 @@
+# Stub for termcolor: https://pypi.python.org/pypi/termcolor
+from typing import Any, Iterable, Optional, Text
+
+
+def colored(
+    text: Text,
+    color: Optional[Text] = ...,
+    on_color: Optional[Text] = ...,
+    attrs: Optional[Iterable[Text]] = ...,
+) -> Text:
+    ...
+
+
+def cprint(
+    text: Text,
+    color: Optional[Text] = ...,
+    on_color: Optional[Text] = ...,
+    attrs: Optional[Iterable[Text]] = ...,
+    **kwargs: Any,
+) -> None:
+    ...