fixes

Author: Max Rozentsveyg

stdlib/3.4/asyncio/tasks.pyi

@@ -8,6 +8,11 @@ from .futures import Future
 __all__: List[str]
 
 _T = TypeVar('_T')
+_T1 = TypeVar('_T1')
+_T2 = TypeVar('_T2')
+_T3 = TypeVar('_T3')
+_T4 = TypeVar('_T4')
+_T5 = TypeVar('_T5')
 _FutureT = Union[Future[_T], Generator[Any, None, _T], Awaitable[_T]]
 
 FIRST_EXCEPTION = 'FIRST_EXCEPTION'
@@ -19,10 +24,25 @@ def as_completed(fs: Sequence[_FutureT[_T]], *, loop: AbstractEventLoop = ...,
 def ensure_future(coro_or_future: _FutureT[_T],
                   *, loop: AbstractEventLoop = ...) -> Future[_T]: ...
 async = ensure_future
-# TODO: gather() should use variadic type vars instead of _TAny.
-_TAny = Any
-def gather(*coros_or_futures: _FutureT[_TAny],
-           loop: AbstractEventLoop = ..., return_exceptions: bool = False) -> Future[List[_TAny]]: ...
+@overload
+def gather(coro_or_future1: _FutureT[_T1],
+           *, loop: AbstractEventLoop = ..., return_exceptions: bool = False) -> Future[Tuple[_T1]]: ...
+@overload
+def gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2],
+           *, loop: AbstractEventLoop = ..., return_exceptions: bool = False) -> Future[Tuple[_T1, _T2]]: ...
+@overload
+def gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3],
+           coro_or_future4: _FutureT[_T4],
+           *, loop: AbstractEventLoop = ..., return_exceptions: bool = False) -> Future[Tuple[_T1, _T2, _T3, _T4]]: ...
+@overload
+def gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3],
+           coro_or_future4: _FutureT[_T4], coro_or_future5: _FutureT[_T5],
+           *, loop: AbstractEventLoop = ..., return_exceptions: bool = False) -> Future[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...
+@overload
+def gather(coro_or_future1: _FutureT[Any], coro_or_future2: _FutureT[Any], coro_or_future3: _FutureT[Any],
+           coro_or_future4: _FutureT[Any], coro_or_future5: _FutureT[Any], coro_or_future6: _FutureT[Any],
+           *coros_or_futures: _FutureT[Any],
+           loop: AbstractEventLoop = ..., return_exceptions: bool = False) -> Future[Tuple[Any, ...]]: ...
 def run_coroutine_threadsafe(coro: _FutureT[_T],
                              loop: AbstractEventLoop) -> concurrent.futures.Future[_T]: ...
 def shield(arg: _FutureT[_T], *, loop: AbstractEventLoop = ...) -> Future[_T]: ...

stdlib/3/fcntl.pyi

@@ -1,6 +1,6 @@
 # Stubs for fcntl
+from io import IOBase
 from typing import Any, IO, Union
-import typing
 
 FASYNC = ...  # type: int
 FD_CLOEXEC = ...  # type: int
@@ -75,7 +75,7 @@ LOCK_SH = ...  # type: int
 LOCK_UN = ...  # type: int
 LOCK_WRITE = ...  # type: int
 
-_AnyFile = Union[int, IO[Any]]
+_AnyFile = Union[int, IO[Any], IOBase]
 
 # TODO All these return either int or bytes depending on the value of
 # cmd (not on the type of arg).

stdlib/3/multiprocessing/__init__.pyi

@@ -1,8 +1,12 @@
 # Stubs for multiprocessing
 
-from typing import Any, Callable, Iterable, Mapping, Optional, Dict, List, Union, TypeVar
+from typing import (
+    Any, Callable, ContextManager, Iterable, Mapping, Optional, Dict, List,
+    Union, TypeVar,
+)
 
 from logging import Logger
+from multiprocessing import pool
 from multiprocessing.context import BaseContext
 from multiprocessing.managers import SyncManager
 from multiprocessing.pool import AsyncResult
@@ -12,11 +16,9 @@ import queue
 
 _T = TypeVar('_T')
 
-class Lock():
+class Lock(ContextManager[Lock]):
     def acquire(self, block: bool = ..., timeout: int = ...) -> None: ...
     def release(self) -> None: ...
-    def __enter__(self) -> 'Lock': ...
-    def __exit__(self, exc_type, exc_value, tb) -> None: ...
 
 class Event(object):
     def __init__(self, *, ctx: BaseContext) -> None: ...
@@ -25,54 +27,13 @@ class Event(object):
     def clear(self) -> None: ...
     def wait(self, timeout: Optional[int] = ...) -> bool: ...
 
-class Pool():
-    def __init__(self, processes: Optional[int] = ...,
-                 initializer: Optional[Callable[..., None]] = ...,
-                 initargs: Iterable[Any] = ...,
-                 maxtasksperchild: Optional[int] = ...,
-                 context: Optional[Any] = None) -> 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]] = None,
-                error_callback: Optional[Callable[[BaseException], None]] = 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]] = None,
-                  error_callback: Optional[Callable[[BaseException], None]] = None) -> AsyncResult: ...
-    def imap(self,
-             func: Callable[..., Any],
-             iterable: Iterable[Any] = ...,
-             chunksize: Optional[int] = None) -> Iterable[Any]: ...
-    def imap_unordered(self,
-                       func: Callable[..., Any],
-                       iterable: Iterable[Any] = ...,
-                       chunksize: Optional[int] = None) -> Iterable[Any]: ...
-    def starmap(self,
-                func: Callable[..., Any],
-                iterable: Iterable[Iterable[Any]] = ...,
-                chunksize: Optional[int] = None) -> List[Any]: ...
-    def starmap_async(self,
-                      func: Callable[..., Any],
-                      iterable: Iterable[Iterable[Any]] = ...,
-                      chunksize: Optional[int] = ...,
-                      callback: Optional[Callable[..., None]] = None,
-                      error_callback: Optional[Callable[[BaseException], None]] = None) -> AsyncResult: ...
-    def close(self) -> None: ...
-    def terminate(self) -> None: ...
-    def join(self) -> None: ...
-    def __enter__(self) -> 'Pool': ...
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None: ...
+# N.B. This is generated at runtime by partially applying
+# multiprocessing.context.BaseContext.Pool, so the two signatures should be
+# identical (modulo self).
+def Pool(processes: Optional[int] = ...,
+         initializer: Optional[Callable[..., Any]] = ...,
+         initargs: Iterable[Any] = ...,
+         maxtasksperchild: Optional[int] = ...) -> pool.Pool: ...
 
 class Process():
     name: str

stdlib/3/multiprocessing/context.pyi

@@ -3,7 +3,9 @@
 from logging import Logger
 import multiprocessing
 import sys
-from typing import Any, Callable, Optional, List, Sequence, Tuple, Type, Union
+from typing import (
+    Any, Callable, Iterable, Optional, List, Sequence, Tuple, Type, Union,
+)
 
 class ProcessError(Exception): ...
 
@@ -49,13 +51,16 @@ class BaseContext(object):
     def JoinableQueue(self, maxsize: int = ...) -> Any: ...
     # TODO: change return to SimpleQueue once a stub exists in multiprocessing.queues
     def SimpleQueue(self) -> Any: ...
+    # N.B. This method is partially applied at runtime to generate
+    # multiprocessing.Pool, so the two signatures should be identical (modulo
+    # self).
     def Pool(
         self,
         processes: Optional[int] = ...,
         initializer: Optional[Callable[..., Any]] = ...,
-        initargs: Tuple = ...,
+        initargs: Iterable[Any] = ...,
         maxtasksperchild: Optional[int] = ...
-    ) -> multiprocessing.Pool: ...
+    ) -> multiprocessing.pool.Pool: ...
     # TODO: typecode_or_type param is a ctype with a base class of _SimpleCData or array.typecode Need to figure out
     # how to handle the ctype
     # TODO: change return to RawValue once a stub exists in multiprocessing.sharedctypes

stdlib/3/multiprocessing/managers.pyi

@@ -5,7 +5,8 @@
 import queue
 import threading
 from typing import (
-    Any, Callable, Dict, Iterable, List, Mapping, Optional, Sequence, TypeVar
+    Any, Callable, ContextManager, Dict, Iterable, List, Mapping, Optional,
+    Sequence, TypeVar,
 )
 
 _T = TypeVar('_T')
@@ -16,13 +17,11 @@ class Namespace: ...
 
 _Namespace = Namespace
 
-class BaseManager:
+class BaseManager(ContextManager[BaseManager]):
     def register(self, typeid: str, callable: Any = ...) -> None: ...
     def shutdown(self) -> None: ...
     def start(self, initializer: Optional[Callable[..., Any]] = ...,
               initargs: Iterable[Any] = ...) -> None: ...
-    def __enter__(self) -> 'BaseManager': ...
-    def __exit__(self, exc_type, exc_value, tb) -> None: ...
 
 class SyncManager(BaseManager):
     def BoundedSemaphore(self, value: Any = ...) -> threading.BoundedSemaphore: ...

stdlib/3/multiprocessing/pool.pyi

@@ -2,18 +2,25 @@
 
 # NOTE: These are incomplete!
 
-from typing import Any, Callable, Iterable, Mapping, Optional, Dict, List
+from typing import (
+    Any, Callable, ContextManager, Iterable, Mapping, Optional, Dict, List,
+    TypeVar,
+)
+
+_T = TypeVar('_T', bound='Pool')
 
 class AsyncResult():
     def get(self, timeout: float = ...) -> Any: ...
     def wait(self, timeout: float = ...) -> None: ...
     def ready(self) -> bool: ...
     def successful(self) -> bool: ...
 
-class ThreadPool():
-    def __init__(self, processes: Optional[int] = None,
-                 initializer: Optional[Callable[..., Any]] = None,
-                 initargs: Iterable[Any] = ...) -> None: ...
+class Pool(ContextManager[Pool]):
+    def __init__(self, processes: Optional[int] = ...,
+                 initializer: Optional[Callable[..., None]] = ...,
+                 initargs: Iterable[Any] = ...,
+                 maxtasksperchild: Optional[int] = ...,
+                 context: Optional[Any] = None) -> None: ...
     def apply(self,
               func: Callable[..., Any],
               args: Iterable[Any] = ...,
@@ -30,7 +37,7 @@ class ThreadPool():
             chunksize: Optional[int] = None) -> List[Any]: ...
     def map_async(self, func: Callable[..., Any],
                   iterable: Iterable[Any] = ...,
-                  chunksize: Optional[Optional[int]] = None,
+                  chunksize: Optional[int] = None,
                   callback: Optional[Callable[..., None]] = None,
                   error_callback: Optional[Callable[[BaseException], None]] = None) -> AsyncResult: ...
     def imap(self,
@@ -54,5 +61,11 @@ class ThreadPool():
     def close(self) -> None: ...
     def terminate(self) -> None: ...
     def join(self) -> None: ...
-    def __enter__(self) -> 'ThreadPool': ...
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None: ...
+    def __enter__(self: _T) -> _T: ...
+
+
+class ThreadPool(Pool, ContextManager[ThreadPool]):
+
+    def __init__(self, processes: Optional[int] = None,
+                 initializer: Optional[Callable[..., Any]] = None,
+                 initargs: Iterable[Any] = ...) -> None: ...

stdlib/3/smtplib.pyi

@@ -1,25 +1,30 @@
-from typing import Any
+from email.message import Message as _Message
+from typing import (
+    Any, AnyStr, Dict, Generic, List, Optional, Sequence, Tuple, Union)
+
+_Reply = Tuple[int, bytes]
+_SendErrs = Dict[str, _Reply]
 
 class SMTPException(OSError): ...
 class SMTPServerDisconnected(SMTPException): ...
 
 class SMTPResponseException(SMTPException):
-    smtp_code = ...  # type: Any
-    smtp_error = ...  # type: Any
-    args = ...  # type: Any
-    def __init__(self, code, msg) -> None: ...
+    smtp_code = ...  # type: int
+    smtp_error = ...  # type: Union[bytes, str]
+    args = ...  # type: Union[Tuple[int, Union[bytes, str]], Tuple[int, bytes, str]]
+    def __init__(self, code: int, msg: Union[bytes, str]) -> None: ...
 
 class SMTPSenderRefused(SMTPResponseException):
-    smtp_code = ...  # type: Any
-    smtp_error = ...  # type: Any
-    sender = ...  # type: Any
-    args = ...  # type: Any
-    def __init__(self, code, msg, sender) -> None: ...
+    smtp_code = ...  # type: int
+    smtp_error = ...  # type: bytes
+    sender = ...  # type: str
+    args = ...  # type: Tuple[int, bytes, str]
+    def __init__(self, code: int, msg: bytes, sender: str) -> None: ...
 
 class SMTPRecipientsRefused(SMTPException):
-    recipients = ...  # type: Any
-    args = ...  # type: Any
-    def __init__(self, recipients) -> None: ...
+    recipients = ...  # type: _SendErrs
+    args = ...  # type: Tuple[_SendErrs]
+    def __init__(self, recipients: _SendErrs) -> None: ...
 
 class SMTPDataError(SMTPResponseException): ...
 class SMTPConnectError(SMTPResponseException): ...
@@ -30,49 +35,53 @@ def quoteaddr(addrstring): ...
 def quotedata(data): ...
 
 class SMTP:
-    debuglevel = ...  # type: Any
+    debuglevel = ...  # type: int
     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
+    timeout = ...  # type: float
     esmtp_features = ...  # type: Any
     source_address = ...  # type: Any
     local_hostname = ...  # type: Any
-    def __init__(self, host=..., port=..., local_hostname=..., timeout=...,
-                 source_address=...): ...
+    def __init__(self, host: str = ..., port: int = ...,
+                 local_hostname: Optional[str] = ..., timeout: float = ...,
+                 source_address: Tuple[str, int] = ...) -> None: ...
     def __enter__(self): ...
     def __exit__(self, *args): ...
-    def set_debuglevel(self, debuglevel): ...
+    def set_debuglevel(self, debuglevel: int) -> None: ...
     sock = ...  # type: Any
     def connect(self, host=..., port=..., source_address=...): ...
     def send(self, s): ...
     def putcmd(self, cmd, args=...): ...
-    def getreply(self): ...
+    def getreply(self) -> _Reply: ...
     def docmd(self, cmd, args=...): ...
     def helo(self, name=...): ...
     def ehlo(self, name=...): ...
     def has_extn(self, opt): ...
     def help(self, args=...): ...
-    def rset(self): ...
-    def noop(self): ...
-    def mail(self, sender, options=...): ...
-    def rcpt(self, recip, options=...): ...
+    def rset(self) -> _Reply: ...
+    def noop(self) -> _Reply: ...
+    def mail(self, sender: str, options: Sequence[str] = ...) -> _Reply: ...
+    def rcpt(self, recip: str, options: Sequence[str] = ...) -> _Reply: ...
     def data(self, msg): ...
     def verify(self, address): ...
     vrfy = ...  # type: Any
     def expn(self, address): ...
     def ehlo_or_helo_if_needed(self): ...
     def login(self, user, password): ...
     def starttls(self, keyfile=..., certfile=..., context=...): ...
-    def sendmail(self, from_addr, to_addrs, msg, mail_options=...,
-                 rcpt_options=...): ...
-    def send_message(self, msg, from_addr=..., to_addrs=..., mail_options=...,
-                     rcpt_options=...): ...
+    def sendmail(self, from_addr: str, to_addrs: Union[str, Sequence[str]],
+                 msg: Union[bytes, str], mail_options: Sequence[str] = ...,
+                 rcpt_options: List[str] = ...) -> _SendErrs: ...
+    def send_message(self, msg: _Message, from_addr: Optional[str] = ...,
+                     to_addrs: Optional[Union[str, Sequence[str]]] = ...,
+                     mail_options: List[str] = ...,
+                     rcpt_options: Sequence[str] = ...) -> _SendErrs: ...
     def close(self): ...
-    def quit(self): ...
+    def quit(self) -> _Reply: ...
 
 class SMTP_SSL(SMTP):
     default_port = ...  # type: Any
@@ -84,7 +93,9 @@ class SMTP_SSL(SMTP):
 
 class LMTP(SMTP):
     ehlo_msg = ...  # type: Any
-    def __init__(self, host=..., port=..., local_hostname=..., source_address=...) -> None: ...
+    def __init__(self, host: str = ..., port: int = ...,
+                 local_hostname: Optional[str] = ...,
+                 source_address: Optional[Tuple[str, int]] = ...) -> None: ...
     sock = ...  # type: Any
     file = ...  # type: Any
     def connect(self, host=..., port=..., source_address=...): ...