python · JelleZijlstra · May 18, 2022 · May 17, 2022 · May 17, 2022 · May 17, 2022
diff --git a/stdlib/VERSIONS b/stdlib/VERSIONS
@@ -70,6 +70,7 @@ asyncio.runners: 3.7-
 asyncio.staggered: 3.8-
 asyncio.taskgroups: 3.11-
 asyncio.threads: 3.9-
+asyncio.timeouts: 3.11-
 asyncio.trsock: 3.8-
 asyncore: 2.7-
 atexit: 2.7-

diff --git a/stdlib/asyncio/__init__.pyi b/stdlib/asyncio/__init__.pyi
@@ -24,6 +24,7 @@ if sys.version_info >= (3, 9):
 
 if sys.version_info >= (3, 11):
     from .taskgroups import *
+    from .timeouts import *
 
 if sys.platform == "win32":
     from .windows_events import *

diff --git a/stdlib/asyncio/base_events.pyi b/stdlib/asyncio/base_events.pyi
@@ -1,6 +1,6 @@
 import ssl
 import sys
-from _typeshed import FileDescriptorLike
+from _typeshed import FileDescriptorLike, WriteableBuffer
 from asyncio.events import AbstractEventLoop, AbstractServer, Handle, TimerHandle
 from asyncio.futures import Future
 from asyncio.protocols import BaseProtocol
@@ -29,7 +29,18 @@ _ProtocolFactory: TypeAlias = Callable[[], BaseProtocol]
 _SSLContext: TypeAlias = bool | None | ssl.SSLContext
 
 class Server(AbstractServer):
-    if sys.version_info >= (3, 7):
+    if sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            loop: AbstractEventLoop,
+            sockets: Iterable[socket],
+            protocol_factory: _ProtocolFactory,
+            ssl_context: _SSLContext,
+            backlog: int,
+            ssl_handshake_timeout: float | None,
+            ssl_shutdown_timeout: float | None = ...,
+        ) -> None: ...
+    elif sys.version_info >= (3, 7):
         def __init__(
             self,
             loop: AbstractEventLoop,
@@ -39,12 +50,13 @@ class Server(AbstractServer):
             backlog: int,
             ssl_handshake_timeout: float | None,
         ) -> None: ...
+    else:
+        def __init__(self, loop: AbstractEventLoop, sockets: list[socket]) -> None: ...
+    if sys.version_info >= (3, 7):
         def get_loop(self) -> AbstractEventLoop: ...
         def is_serving(self) -> bool: ...
         async def start_serving(self) -> None: ...
         async def serve_forever(self) -> None: ...
-    else:
-        def __init__(self, loop: AbstractEventLoop, sockets: list[socket]) -> None: ...
     if sys.version_info >= (3, 8):
         @property
         def sockets(self) -> tuple[socket, ...]: ...
@@ -86,7 +98,11 @@ class BaseEventLoop(AbstractEventLoop):
     # Future methods
     def create_future(self) -> Future[Any]: ...
     # Tasks methods
-    if sys.version_info >= (3, 8):
+    if sys.version_info >= (3, 11):
+        def create_task(
+            self, coro: Coroutine[Any, Any, _T] | Generator[Any, None, _T], *, name: object = ..., context: Context | None = ...
+        ) -> Task[_T]: ...
+    elif sys.version_info >= (3, 8):
         def create_task(self, coro: Coroutine[Any, Any, _T] | Generator[Any, None, _T], *, name: object = ...) -> Task[_T]: ...
     else:
         def create_task(self, coro: Coroutine[Any, Any, _T] | Generator[Any, None, _T]) -> Task[_T]: ...
@@ -113,7 +129,46 @@ class BaseEventLoop(AbstractEventLoop):
         flags: int = ...,
     ) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int]]]: ...
     async def getnameinfo(self, sockaddr: tuple[str, int] | tuple[str, int, int, int], flags: int = ...) -> tuple[str, str]: ...
-    if sys.version_info >= (3, 8):
+    if sys.version_info >= (3, 11):
+        @overload
+        async def create_connection(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            host: str = ...,
+            port: int = ...,
+            *,
+            ssl: _SSLContext = ...,
+            family: int = ...,
+            proto: int = ...,
+            flags: int = ...,
+            sock: None = ...,
+            local_addr: tuple[str, int] | None = ...,
+            server_hostname: str | None = ...,
+            ssl_handshake_timeout: float | None = ...,
+            ssl_shutdown_timeout: float | None = ...,
+            happy_eyeballs_delay: float | None = ...,
+            interleave: int | None = ...,
+        ) -> tuple[BaseTransport, _ProtocolT]: ...
+        @overload
+        async def create_connection(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            host: None = ...,
+            port: None = ...,
+            *,
+            ssl: _SSLContext = ...,
+            family: int = ...,
+            proto: int = ...,
+            flags: int = ...,
+            sock: socket,
+            local_addr: None = ...,
+            server_hostname: str | None = ...,
+            ssl_handshake_timeout: float | None = ...,
+            ssl_shutdown_timeout: float | None = ...,
+            happy_eyeballs_delay: float | None = ...,
+            interleave: int | None = ...,
+        ) -> tuple[BaseTransport, _ProtocolT]: ...
+    elif sys.version_info >= (3, 8):
         @overload
         async def create_connection(
             self,
@@ -214,10 +269,7 @@ class BaseEventLoop(AbstractEventLoop):
             local_addr: None = ...,
             server_hostname: str | None = ...,
         ) -> tuple[BaseTransport, _ProtocolT]: ...
-    if sys.version_info >= (3, 7):
-        async def sock_sendfile(
-            self, sock: socket, file: IO[bytes], offset: int = ..., count: int | None = ..., *, fallback: bool | None = ...
-        ) -> int: ...
+    if sys.version_info >= (3, 11):
         @overload
         async def create_server(
             self,
@@ -233,6 +285,7 @@ class BaseEventLoop(AbstractEventLoop):
             reuse_address: bool | None = ...,
             reuse_port: bool | None = ...,
             ssl_handshake_timeout: float | None = ...,
+            ssl_shutdown_timeout: float | None = ...,
             start_serving: bool = ...,
         ) -> Server: ...
         @overload
@@ -250,19 +303,64 @@ class BaseEventLoop(AbstractEventLoop):
             reuse_address: bool | None = ...,
             reuse_port: bool | None = ...,
             ssl_handshake_timeout: float | None = ...,
+            ssl_shutdown_timeout: float | None = ...,
             start_serving: bool = ...,
         ) -> Server: ...
+        async def start_tls(
+            self,
+            transport: BaseTransport,
+            protocol: BaseProtocol,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_side: bool = ...,
+            server_hostname: str | None = ...,
+            ssl_handshake_timeout: float | None = ...,
+            ssl_shutdown_timeout: float | None = ...,
+        ) -> BaseTransport: ...
         async def connect_accepted_socket(
             self,
             protocol_factory: Callable[[], _ProtocolT],
             sock: socket,
             *,
             ssl: _SSLContext = ...,
             ssl_handshake_timeout: float | None = ...,
+            ssl_shutdown_timeout: float | None = ...,
         ) -> tuple[BaseTransport, _ProtocolT]: ...
-        async def sendfile(
-            self, transport: BaseTransport, file: IO[bytes], offset: int = ..., count: int | None = ..., *, fallback: bool = ...
-        ) -> int: ...
+    elif sys.version_info >= (3, 7):
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str | Sequence[str] | None = ...,
+            port: int = ...,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: None = ...,
+            backlog: int = ...,
+            ssl: _SSLContext = ...,
+            reuse_address: bool | None = ...,
+            reuse_port: bool | None = ...,
+            ssl_handshake_timeout: float | None = ...,
+            start_serving: bool = ...,
+        ) -> Server: ...
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = ...,
+            port: None = ...,
+            *,
+            family: int = ...,
+            flags: int = ...,
+            sock: socket = ...,
+            backlog: int = ...,
+            ssl: _SSLContext = ...,
+            reuse_address: bool | None = ...,
+            reuse_port: bool | None = ...,
+            ssl_handshake_timeout: float | None = ...,
+            start_serving: bool = ...,
+        ) -> Server: ...
         async def start_tls(
             self,
             transport: BaseTransport,
@@ -273,6 +371,14 @@ class BaseEventLoop(AbstractEventLoop):
             server_hostname: str | None = ...,
             ssl_handshake_timeout: float | None = ...,
         ) -> BaseTransport: ...
+        async def connect_accepted_socket(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            sock: socket,
+            *,
+            ssl: _SSLContext = ...,
+            ssl_handshake_timeout: float | None = ...,
+        ) -> tuple[BaseTransport, _ProtocolT]: ...
     else:
         @overload
         async def create_server(
@@ -307,6 +413,13 @@ class BaseEventLoop(AbstractEventLoop):
         async def connect_accepted_socket(
             self, protocol_factory: Callable[[], _ProtocolT], sock: socket, *, ssl: _SSLContext = ...
         ) -> tuple[BaseTransport, _ProtocolT]: ...
+    if sys.version_info >= (3, 7):
+        async def sock_sendfile(
+            self, sock: socket, file: IO[bytes], offset: int = ..., count: int | None = ..., *, fallback: bool | None = ...
+        ) -> int: ...
+        async def sendfile(
+            self, transport: BaseTransport, file: IO[bytes], offset: int = ..., count: int | None = ..., *, fallback: bool = ...
+        ) -> int: ...
     if sys.version_info >= (3, 11):
         async def create_datagram_endpoint(  # type: ignore[override]
             self,
@@ -378,10 +491,12 @@ class BaseEventLoop(AbstractEventLoop):
     def remove_reader(self, fd: FileDescriptorLike) -> bool: ...
     def add_writer(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
     def remove_writer(self, fd: FileDescriptorLike) -> bool: ...
+    # The sock_* methods (and probably some others) are not actually implemented on
+    # BaseEventLoop, only on subclasses. We list them here for now for convenience.
     # Completion based I/O methods returning Futures prior to 3.7
     if sys.version_info >= (3, 7):
         async def sock_recv(self, sock: socket, nbytes: int) -> bytes: ...
-        async def sock_recv_into(self, sock: socket, buf: bytearray) -> int: ...
+        async def sock_recv_into(self, sock: socket, buf: WriteableBuffer) -> int: ...
         async def sock_sendall(self, sock: socket, data: bytes) -> None: ...
         async def sock_connect(self, sock: socket, address: _Address) -> None: ...
         async def sock_accept(self, sock: socket) -> tuple[socket, _RetAddress]: ...
@@ -390,6 +505,10 @@ class BaseEventLoop(AbstractEventLoop):
         def sock_sendall(self, sock: socket, data: bytes) -> Future[None]: ...
         def sock_connect(self, sock: socket, address: _Address) -> Future[None]: ...
         def sock_accept(self, sock: socket) -> Future[tuple[socket, _RetAddress]]: ...
+    if sys.version_info >= (3, 11):
+        async def sock_recvfrom(self, sock: socket, bufsize: int) -> bytes: ...
+        async def sock_recvfrom_into(self, sock: socket, buf: WriteableBuffer, nbytes: int = ...) -> int: ...
+        async def sock_sendto(self, sock: socket, data: bytes, address: _Address) -> None: ...
     # Signal handling.
     def add_signal_handler(self, sig: int, callback: Callable[..., Any], *args: Any) -> None: ...
     def remove_signal_handler(self, sig: int) -> bool: ...

diff --git a/stdlib/asyncio/constants.pyi b/stdlib/asyncio/constants.pyi
@@ -8,6 +8,10 @@ DEBUG_STACK_DEPTH: Literal[10]
 if sys.version_info >= (3, 7):
     SSL_HANDSHAKE_TIMEOUT: float
     SENDFILE_FALLBACK_READBUFFER_SIZE: Literal[262144]
+if sys.version_info >= (3, 11):
+    SSL_SHUTDOWN_TIMEOUT: float
+    FLOW_CONTROL_HIGH_WATER_SSL_READ: Literal[256]
+    FLOW_CONTROL_HIGH_WATER_SSL_WRITE: Literal[512]
 
 class _SendfileMode(enum.Enum):
     UNSUPPORTED: int