From 342ce69f889c4ab0041fd409e387ab47947e98cd Mon Sep 17 00:00:00 2001 From: Rune Tynan Date: Sun, 31 May 2020 20:05:16 -0400 Subject: [PATCH] Add missing asyncio modules (#4149) --- stdlib/3/asyncio/base_futures.pyi | 18 ++++ stdlib/3/asyncio/base_subprocess.pyi | 59 ++++++++++++ stdlib/3/asyncio/base_tasks.pyi | 16 ++++ stdlib/3/asyncio/compat.pyi | 10 ++ stdlib/3/asyncio/format_helpers.pyi | 25 +++++ stdlib/3/asyncio/log.pyi | 4 + stdlib/3/asyncio/sslproto.pyi | 135 +++++++++++++++++++++++++++ stdlib/3/asyncio/staggered.pyi | 7 ++ stdlib/3/asyncio/trsock.pyi | 78 ++++++++++++++++ tests/stubtest_whitelists/py35.txt | 5 + tests/stubtest_whitelists/py36.txt | 3 + tests/stubtest_whitelists/py37.txt | 5 +- tests/stubtest_whitelists/py38.txt | 3 +- tests/stubtest_whitelists/py39.txt | 3 +- 14 files changed, 368 insertions(+), 3 deletions(-) create mode 100644 stdlib/3/asyncio/base_futures.pyi create mode 100644 stdlib/3/asyncio/base_subprocess.pyi create mode 100644 stdlib/3/asyncio/base_tasks.pyi create mode 100644 stdlib/3/asyncio/compat.pyi create mode 100644 stdlib/3/asyncio/format_helpers.pyi create mode 100644 stdlib/3/asyncio/log.pyi create mode 100644 stdlib/3/asyncio/sslproto.pyi create mode 100644 stdlib/3/asyncio/staggered.pyi create mode 100644 stdlib/3/asyncio/trsock.pyi diff --git a/stdlib/3/asyncio/base_futures.pyi b/stdlib/3/asyncio/base_futures.pyi new file mode 100644 index 000000000..f91c886ef --- /dev/null +++ b/stdlib/3/asyncio/base_futures.pyi @@ -0,0 +1,18 @@ + +import sys +import contextvars +from typing import List, Tuple, Callable, Sequence +from . import futures + +if sys.version_info >= (3, 8): + from typing import Literal +else: + from typing_extensions import Literal + +_PENDING: Literal["PENDING"] # undocumented +_CANCELLED: Literal["CANCELLED"] # undocumented +_FINISHED: Literal["FINISHED"] # undocumented + +def isfuture(obj: object) -> bool: ... +def _format_callbacks(cb: Sequence[Tuple[Callable[[futures.Future], None], contextvars.Context]]) -> str: ... # undocumented +def _future_repr_info(future: futures.Future) -> List[str]: ... # undocumented diff --git a/stdlib/3/asyncio/base_subprocess.pyi b/stdlib/3/asyncio/base_subprocess.pyi new file mode 100644 index 000000000..31cf24860 --- /dev/null +++ b/stdlib/3/asyncio/base_subprocess.pyi @@ -0,0 +1,59 @@ + +from typing import Optional, Union, Sequence, IO, Any, List, Deque, Dict, Tuple, Callable +import subprocess + +from . import events +from . import protocols +from . import futures +from . import transports + +_File = Optional[Union[int, IO[Any]]] + +class BaseSubprocessTransport(transports.SubprocessTransport): + + _closed: bool # undocumented + _protocol: protocols.SubprocessProtocol # undocumented + _loop: events.AbstractEventLoop # undocumented + _proc: Optional[subprocess.Popen] # undocumented + _pid: Optional[int] # undocumented + _returncode: Optional[int] # undocumented + _exit_waiters: List[futures.Future] # undocumented + _pending_calls: Deque[Tuple[Callable[..., Any], Tuple[Any, ...]]] # undocumented + _pipes: Dict[int, _File] # undocumented + _finished: bool # undocumented + + def __init__(self, loop: events.AbstractEventLoop, protocol: protocols.SubprocessProtocol, args: Union[str, bytes, Sequence[Union[str, bytes]]], + shell: bool, stdin: _File, stdout: _File, stderr: _File, bufsize: int, waiter: Optional[futures.Future] = ..., extra: Optional[Any] = ..., **kwargs: Any) -> None: ... + + def _start(self, args: Union[str, bytes, Sequence[Union[str, bytes]]], shell: bool, stdin: _File, stdout: _File, stderr: _File, bufsize: int, **kwargs: Any): ... # undocumented + def set_protocol(self, protocol: protocols.BaseProtocol) -> None: ... + def get_protocol(self) -> protocols.BaseProtocol: ... + def is_closing(self) -> bool: ... + def close(self) -> None: ... + def get_pid(self) -> Optional[int]: ... # type: ignore + def get_returncode(self) -> Optional[int]: ... + def get_pipe_transport(self, fd: int) -> _File: ... # type: ignore + def _check_proc(self) -> None: ... # undocumented + def send_signal(self, signal: int) -> None: ... # type: ignore + def terminate(self) -> None: ... + def kill(self) -> None: ... + async def _connect_pipes(self, waiter: Optional[futures.Future]) -> None: ... # undocumented + def _call(self, cb: Callable[..., Any], *data: Any) -> None: ... # undocumented + def _pipe_connection_lost(self, fd: int, exc: Optional[BaseException]) -> None: ... # undocumented + def _pipe_data_received(self, fd: int, data: bytes) -> None: ... # undocumented + def _process_exited(self, returncode: int) -> None: ... # undocumented + async def _wait(self) -> int: ... # undocumented + def _try_finish(self) -> None: ... # undocumented + def _call_connection_lost(self, exc: Optional[BaseException]) -> None: ... # undocumented + +class WriteSubprocessPipeProto(protocols.BaseProtocol): # undocumented + + def __init__(self, proc: BaseSubprocessTransport, fd: int) -> None: ... + def connection_made(self, transport: transports.BaseTransport) -> None: ... + def connection_lost(self, exc: Optional[BaseException]) -> None: ... + def pause_writing(self) -> None: ... + def resume_writing(self) -> None: ... + +class ReadSubprocessPipeProto(WriteSubprocessPipeProto, protocols.Protocol): # undocumented + + def data_received(self, data: bytes) -> None: ... diff --git a/stdlib/3/asyncio/base_tasks.pyi b/stdlib/3/asyncio/base_tasks.pyi new file mode 100644 index 000000000..8f8e55548 --- /dev/null +++ b/stdlib/3/asyncio/base_tasks.pyi @@ -0,0 +1,16 @@ + +import sys + +from typing import List, Optional, Union +from types import FrameType +from . import tasks + +if sys.version_info >= (3, 6): + from builtins import _PathLike + _PathType = Union[bytes, str, _PathLike] +else: + _PathType = Union[bytes, str] + +def _task_repr_info(task: tasks.Task) -> List[str]: ... # undocumented +def _task_get_stack(task: tasks.Task, limit: Optional[int]) -> List[FrameType]: ... # undocumented +def _task_print_stack(task: tasks.Task, limit: Optional[int], file: _PathType): ... # undocumented diff --git a/stdlib/3/asyncio/compat.pyi b/stdlib/3/asyncio/compat.pyi new file mode 100644 index 000000000..24d448f49 --- /dev/null +++ b/stdlib/3/asyncio/compat.pyi @@ -0,0 +1,10 @@ + +import sys +from typing import List + +if sys.version_info < (3, 7): + PY34: bool + PY35: bool + PY352: bool + + def flatten_list_bytes(list_of_data: List[bytes]) -> bytes: ... diff --git a/stdlib/3/asyncio/format_helpers.pyi b/stdlib/3/asyncio/format_helpers.pyi new file mode 100644 index 000000000..a1b2d09bf --- /dev/null +++ b/stdlib/3/asyncio/format_helpers.pyi @@ -0,0 +1,25 @@ + +import sys +import functools +import traceback + +from typing import Optional, Tuple, Union, Iterable, Dict, Any, overload +from types import FunctionType, FrameType + +class _HasWrapper: + __wrapper__: Union[_HasWrapper, FunctionType] + +_FuncType = Union[FunctionType, _HasWrapper, functools.partial, functools.partialmethod] + +if sys.version_info >= (3, 7): + + @overload + def _get_function_source(func: _FuncType) -> Tuple[str, int]: ... + @overload + def _get_function_source(func: object) -> Optional[Tuple[str, int]]: ... + + def _format_callback_source(func: object, args: Iterable[Any]) -> str: ... + def _format_args_and_kwargs(args: Iterable[Any], kwargs: Dict[str, Any]) -> str: ... + def _format_callback(func: object, args: Iterable[Any], kwargs: Dict[str, Any], suffix: str = ...) -> str: ... + + def extract_stack(f: Optional[FrameType] = ..., limit: Optional[int] = ...) -> traceback.StackSummary: ... diff --git a/stdlib/3/asyncio/log.pyi b/stdlib/3/asyncio/log.pyi new file mode 100644 index 000000000..5534ebda5 --- /dev/null +++ b/stdlib/3/asyncio/log.pyi @@ -0,0 +1,4 @@ + +import logging + +logger: logging.Logger diff --git a/stdlib/3/asyncio/sslproto.pyi b/stdlib/3/asyncio/sslproto.pyi new file mode 100644 index 000000000..a86a1b17b --- /dev/null +++ b/stdlib/3/asyncio/sslproto.pyi @@ -0,0 +1,135 @@ + +import sys +import ssl + +from typing import ClassVar, Optional, List, Tuple, Callable, Dict, Any, Deque + +from . import transports +from . import constants +from . import events +from . import protocols +from . import futures + +if sys.version_info >= (3, 8): + from typing import Literal +else: + from typing_extensions import Literal + +def _create_transport_context(server_side: bool, server_hostname: Optional[str]) -> ssl.SSLContext: ... + +_UNWRAPPED: Literal["UNWRAPPED"] +_DO_HANDSHAKE: Literal["DO_HANDSHAKE"] +_WRAPPED: Literal["WRAPPED"] +_SHUTDOWN: Literal["SHUTDOWN"] + +class _SSLPipe: + + max_size: ClassVar[int] + + _context: ssl.SSLContext + _server_side: bool + _server_hostname: Optional[str] + _state: str + _incoming: ssl.MemoryBIO + _outgoing: ssl.MemoryBIO + _sslobj: Optional[ssl.SSLObject] + _need_ssldata: bool + _handshake_cb: Optional[Callable[[Optional[BaseException]], None]] + _shutdown_cb: Optional[Callable[[], None]] + + def __init__(self, context: ssl.SSLContext, server_side: bool, server_hostname: Optional[str] = ...) -> None: ... + + @property + def context(self) -> ssl.SSLContext: ... + @property + def ssl_object(self) -> Optional[ssl.SSLObject]: ... + @property + def need_ssldata(self) -> bool: ... + @property + def wrapped(self) -> bool: ... + + def do_handshake(self, callback: Optional[Callable[[Optional[BaseException]], None]] = ...) -> List[bytes]: ... + def shutdown(self, callback: Optional[Callable[[], None]] = ...) -> List[bytes]: ... + def feed_eof(self) -> None: ... + def feed_ssldata(self, data: bytes, only_handshake: bool = ...) -> Tuple[List[bytes], List[bytes]]: ... + def feed_appdata(self, data: bytes, offset: int = ...) -> Tuple[List[bytes], int]: ... + +class _SSLProtocolTransport(transports._FlowControlMixin, transports.Transport): + + _sendfile_compatible: ClassVar[constants._SendfileMode] + + _loop: events.AbstractEventLoop + _ssl_protocol: SSLProtocol + _closed: bool + + if sys.version_info >= (3, 6): + def __init__(self, loop: events.AbstractEventLoop, ssl_protocol: SSLProtocol) -> None: ... + else: + def __init__(self, loop: events.AbstractEventLoop, ssl_protocol: SSLProtocol, app_protocol: protocols.BaseProtocol) -> None: ... + + def get_extra_info(self, name: str, default: Optional[Any] = ...) -> Dict[str, Any]: ... + def set_protocol(self, protocol: protocols.BaseProtocol) -> None: ... + def get_protocol(self) -> protocols.BaseProtocol: ... + def is_closing(self) -> bool: ... + def close(self) -> None: ... + if sys.version_info >= (3, 7): + def is_reading(self) -> bool: ... + def pause_reading(self) -> None: ... + def resume_reading(self) -> None: ... + def set_write_buffer_limits(self, high: Optional[int] = ..., low: Optional[int] = ...) -> None: ... + def get_write_buffer_size(self) -> int: ... + if sys.version_info >= (3, 7): + @property + def _protocol_paused(self) -> bool: ... + def write(self, data: bytes) -> None: ... + def can_write_eof(self) -> Literal[False]: ... + def abort(self) -> None: ... + +class SSLProtocol(protocols.Protocol): + + _server_side: bool + _server_hostname: Optional[str] + _sslcontext: ssl.SSLContext + _extra: Dict[str, Any] + _write_backlog: Deque[Tuple[bytes, int]] + _write_buffer_size: int + _waiter: futures.Future + _loop: events.AbstractEventLoop + _app_transport: _SSLProtocolTransport + _sslpipe: Optional[_SSLPipe] + _session_established: bool + _in_handshake: bool + _in_shutdown: bool + _transport: Optional[transports.BaseTransport] + _call_connection_made: bool + _ssl_handshake_timeout: Optional[int] + _app_protocol: protocols.BaseProtocol + _app_protocol_is_buffer: bool + + if sys.version_info >= (3, 7): + def __init__(self, loop: events.AbstractEventLoop, app_protocol: protocols.BaseProtocol, sslcontext: ssl.SSLContext, waiter: futures.Future, + server_side: bool = ..., server_hostname: Optional[str] = ..., call_connection_made: bool = ..., ssl_handshake_timeout: Optional[int] = ...) -> None: ... + else: + def __init__(self, loop: events.AbstractEventLoop, app_protocol: protocols.BaseProtocol, sslcontext: ssl.SSLContext, waiter: futures.Future, + server_side: bool = ..., server_hostname: Optional[str] = ..., call_connection_made: bool = ...) -> None: ... + + if sys.version_info >= (3, 7): + def _set_app_protocol(self, app_protocol: protocols.BaseProtocol) -> None: ... + def _wakeup_waiter(self, exc: Optional[BaseException] = ...) -> None: ... + def connection_made(self, transport: transports.BaseTransport) -> None: ... + def connection_lost(self, exc: Optional[BaseException]) -> None: ... + def pause_writing(self) -> None: ... + def resume_writing(self) -> None: ... + def data_received(self, data: bytes) -> None: ... + def eof_received(self) -> None: ... + def _get_extra_info(self, name: str, default: Optional[Any] = ...) -> Any: ... + def _start_shutdown(self) -> None: ... + def _write_appdata(self, data: bytes) -> None: ... + def _start_handshake(self) -> None: ... + if sys.version_info >= (3, 7): + def _check_handshake_timeout(self) -> None: ... + def _on_handshake_complete(self, handshake_exc: Optional[BaseException]) -> None: ... + def _process_write_backlog(self) -> None: ... + def _fatal_error(self, exc: BaseException, message: str = ...) -> None: ... + def _finalize(self) -> None: ... + def _abort(self) -> None: ... diff --git a/stdlib/3/asyncio/staggered.pyi b/stdlib/3/asyncio/staggered.pyi new file mode 100644 index 000000000..3ba73b11b --- /dev/null +++ b/stdlib/3/asyncio/staggered.pyi @@ -0,0 +1,7 @@ + +import sys +from typing import Iterable, Callable, Awaitable, Optional, Tuple, Any, List +from . import events + +if sys.version_info >= (3, 8): + async def staggered_race(coro_fns: Iterable[Callable[[], Awaitable]], delay: Optional[float], *, loop: Optional[events.AbstractEventLoop] = ...) -> Tuple[Any, Optional[int], List[Optional[Exception]]]: ... diff --git a/stdlib/3/asyncio/trsock.pyi b/stdlib/3/asyncio/trsock.pyi new file mode 100644 index 000000000..9dbefbe8c --- /dev/null +++ b/stdlib/3/asyncio/trsock.pyi @@ -0,0 +1,78 @@ + +import sys +import socket +from typing import Union, NoReturn, Tuple, Optional, Iterable, List, Any, BinaryIO, Type, overload +from types import TracebackType + +if sys.version_info >= (3, 8): + # These are based in socket, maybe move them out into _typeshed.pyi or such + _Address = Union[tuple, str] + _RetAddress = Any + _WriteBuffer = Union[bytearray, memoryview] + _CMSG = Tuple[int, int, bytes] + + class TransportSocket: + def __init__(self, sock: socket.socket) -> None: ... + def _na(self, what: str) -> None: ... + @property + def family(self) -> int: ... + @property + def type(self) -> int: ... + @property + def proto(self) -> int: ... + def __getstate__(self) -> NoReturn: ... + def fileno(self) -> int: ... + def dup(self) -> socket.socket: ... + def get_inheritable(self) -> bool: ... + def shutdown(self, how: int) -> None: ... + @overload + def getsockopt(self, level: int, optname: int) -> int: ... + @overload + def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ... + @overload + def setsockopt(self, level: int, optname: int, value: Union[int, bytes]) -> None: ... + @overload + def setsockopt(self, level: int, optname: int, value: None, optlen: int) -> None: ... + def getpeername(self) -> _RetAddress: ... + def getsockname(self) -> _RetAddress: ... + def getsockbyname(self) -> NoReturn: ... # This method doesn't exist on socket, yet is passed through? + def accept(self) -> Tuple[socket.socket, _RetAddress]: ... + def connect(self, address: Union[_Address, bytes]) -> None: ... + def connect_ex(self, address: Union[_Address, bytes]) -> int: ... + def bind(self, address: Union[_Address, bytes]) -> None: ... + if sys.platform == 'win32': + def ioctl(self, control: int, option: Union[int, Tuple[int, int, int], bool]) -> None: ... + else: + def ioctl(self, control: int, option: Union[int, Tuple[int, int, int], bool]) -> NoReturn: ... + def listen(self, __backlog: int = ...) -> None: ... + def makefile(self) -> BinaryIO: ... + def sendfile(self, file, offset: int = ..., count: Optional[int] = ...) -> int: ... + def close(self) -> None: ... + def detach(self) -> int: ... + if sys.platform == "linux": + def sendmsg_afalg(self, msg=..., *, op, iv=..., assoclen=..., flags=...) -> int: ... + else: + def sendmsg_afalg(self, msg=..., *, op, iv=..., assoclen=..., flags=...) -> NoReturn: ... + def sendmsg(self, __buffers: Iterable[bytes], __ancdata: Iterable[_CMSG] = ..., __flags: int = ..., __address: _Address = ...) -> int: ... + @overload + def sendto(self, data: bytes, address: _Address) -> int: ... + @overload + def sendto(self, data: bytes, flags: int, address: _Address) -> int: ... + def send(self, data: bytes, flags: int = ...) -> int: ... + def sendall(self, data: bytes, flags: int = ...) -> None: ... + def set_inheritable(self, inheritable: bool) -> None: ... + if sys.platform == 'win32': + def share(self, process_id: int) -> bytes: ... + else: + def share(self, process_id: int) -> NoReturn: ... + def recv_into(self, buffer: _WriteBuffer, nbytes: int = ..., flags: int = ...) -> int: ... + def recvfrom_into(self, buffer: _WriteBuffer, nbytes: int = ..., flags: int = ...) -> Tuple[int, _RetAddress]: ... + def recvmsg_into(self, __buffers: Iterable[_WriteBuffer], __ancbufsize: int = ..., __flags: int = ...) -> Tuple[int, List[_CMSG], int, Any]: ... + def recvmsg(self, __bufsize: int, __ancbufsize: int = ..., __flags: int = ...) -> Tuple[bytes, List[_CMSG], int, Any]: ... + def recvfrom(self, bufsize: int, flags: int = ...) -> Tuple[bytes, _RetAddress]: ... + def recv(self, bufsize: int, flags: int = ...) -> bytes: ... + def settimeout(self, value: Optional[float]) -> None: ... + def gettimeout(self) -> Optional[float]: ... + def setblocking(self, flag: bool) -> None: ... + def __enter__(self) -> socket.socket: ... + def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]) -> None: ... diff --git a/tests/stubtest_whitelists/py35.txt b/tests/stubtest_whitelists/py35.txt index 0e67c489f..726102dba 100644 --- a/tests/stubtest_whitelists/py35.txt +++ b/tests/stubtest_whitelists/py35.txt @@ -4,16 +4,21 @@ asyncio.Future._loop asyncio.Future._tb_logger asyncio.Task.__init__ asyncio.Task._wakeup +asyncio.base_futures # Added in Python 3.6 +asyncio.base_tasks # Added in Python 3.6 asyncio.exceptions # Added in Python 3.8 +asyncio.format_helpers # Added in Python 3.7 asyncio.futures.Future._callbacks asyncio.futures.Future._exception asyncio.futures.Future._loop asyncio.futures.Future._tb_logger asyncio.futures._TracebackLogger.__init__ asyncio.runners +asyncio.staggered # Added in Python 3.8 asyncio.tasks.Task.__init__ asyncio.tasks.Task._wakeup asyncio.threads # Added in Python 3.9 +asyncio.trsock # Added in Python 3.8 bdb.GENERATOR_AND_COROUTINE_FLAGS builtins.str.maketrans cmath.log diff --git a/tests/stubtest_whitelists/py36.txt b/tests/stubtest_whitelists/py36.txt index b87900181..54dc70ae7 100644 --- a/tests/stubtest_whitelists/py36.txt +++ b/tests/stubtest_whitelists/py36.txt @@ -1,9 +1,12 @@ asyncio.Future.__init__ asyncio.exceptions # Added in Python 3.8 +asyncio.format_helpers # Added in Python 3.7 asyncio.futures.Future.__init__ asyncio.futures._TracebackLogger.__init__ asyncio.runners +asyncio.staggered # Added in Python 3.8 asyncio.threads # Added in Python 3.9 +asyncio.trsock # Added in Python 3.8 builtins.str.maketrans cmath.log codecs.StreamRecoder.seek diff --git a/tests/stubtest_whitelists/py37.txt b/tests/stubtest_whitelists/py37.txt index 6eb951799..9bbc39d91 100644 --- a/tests/stubtest_whitelists/py37.txt +++ b/tests/stubtest_whitelists/py37.txt @@ -1,4 +1,5 @@ asyncio.AbstractEventLoop.sock_sendfile +asyncio.compat # Removed in 3.7 asyncio.Future.__init__ asyncio.Future._callbacks asyncio.Handle.__init__ @@ -9,7 +10,9 @@ asyncio.events.TimerHandle.__init__ asyncio.exceptions # Added in Python 3.8 asyncio.futures.Future.__init__ asyncio.futures.Future._callbacks +asyncio.staggered # Added in Python 3.8 asyncio.threads # Added in Python 3.9 +asyncio.trsock # Added in Python 3.8 builtins.dict.get builtins.reversed builtins.str.maketrans @@ -38,7 +41,7 @@ importlib.metadata ipaddress._BaseNetwork.__init__ json.loads logging.handlers.MemoryHandler.__init__ -macurl2path +macurl2path # removed in 3.7 multiprocessing.shared_memory nntplib._NNTPBase.starttls os.utime diff --git a/tests/stubtest_whitelists/py38.txt b/tests/stubtest_whitelists/py38.txt index 951b13f19..c1c85db29 100644 --- a/tests/stubtest_whitelists/py38.txt +++ b/tests/stubtest_whitelists/py38.txt @@ -6,6 +6,7 @@ ast.NameConstant.__new__ ast.Num.__new__ ast.Str.__new__ asyncio.AbstractEventLoop.sock_sendfile +asyncio.compat # removed in 3.7 asyncio.Future.__init__ asyncio.Future._callbacks asyncio.Handle.__init__ @@ -61,7 +62,7 @@ ipaddress._BaseNetwork.broadcast_address ipaddress._BaseNetwork.hostmask logging.handlers.MemoryHandler.__init__ macpath -macurl2path +macurl2path # removed in 3.7 mmap.MADV_[A-Z_]+ multiprocessing.managers.SharedMemoryServer.__init__ multiprocessing.pool.CLOSE diff --git a/tests/stubtest_whitelists/py39.txt b/tests/stubtest_whitelists/py39.txt index 6d49e6151..2a867afbe 100644 --- a/tests/stubtest_whitelists/py39.txt +++ b/tests/stubtest_whitelists/py39.txt @@ -14,6 +14,7 @@ ast.NameConstant.__new__ ast.Num.__new__ ast.Str.__new__ asyncio.AbstractEventLoop.sock_sendfile +asyncio.compat # removed in 3.7 asyncio.Future.__init__ asyncio.Future._callbacks asyncio.Handle.__init__ @@ -121,7 +122,7 @@ logging.handlers.WatchedFileHandler.__init__ lzma.LZMACompressor.compress lzma.is_check_supported macpath -macurl2path +macurl2path # removed in 3.7 mmap.MADV_AUTOSYNC mmap.MADV_CORE mmap.MADV_NOCORE