.config/coc/extensions/node_modules/coc-pyright/node_modules/pyright/dist/typeshed-fallback/stdlib/asyncio/base_events.pyi

   1 import ssl
   2 import sys
   3 from _typeshed import FileDescriptorLike
   4 from abc import ABCMeta
   5 from asyncio.events import AbstractEventLoop, AbstractServer, Handle, TimerHandle
   6 from asyncio.futures import Future
   7 from asyncio.protocols import BaseProtocol
   8 from asyncio.tasks import Task
   9 from asyncio.transports import BaseTransport
  10 from collections.abc import Iterable
  11 from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket
  12 from typing import IO, Any, Awaitable, Callable, Dict, Generator, Sequence, Tuple, TypeVar, Union, overload
  13 from typing_extensions import Literal
  14
  15 if sys.version_info >= (3, 7):
  16     from contextvars import Context
  17
  18 _T = TypeVar("_T")
  19 _Context = Dict[str, Any]
  20 _ExceptionHandler = Callable[[AbstractEventLoop, _Context], Any]
  21 _ProtocolFactory = Callable[[], BaseProtocol]
  22 _SSLContext = Union[bool, None, ssl.SSLContext]
  23 _TransProtPair = Tuple[BaseTransport, BaseProtocol]
  24
  25 class Server(AbstractServer):
  26     if sys.version_info >= (3, 7):
  27         def __init__(
  28             self,
  29             loop: AbstractEventLoop,
  30             sockets: Iterable[socket],
  31             protocol_factory: _ProtocolFactory,
  32             ssl_context: _SSLContext,
  33             backlog: int,
  34             ssl_handshake_timeout: float | None,
  35         ) -> None: ...
  36     else:
  37         def __init__(self, loop: AbstractEventLoop, sockets: list[socket]) -> None: ...
  38     if sys.version_info >= (3, 8):
  39         @property
  40         def sockets(self) -> Tuple[socket, ...]: ...
  41     elif sys.version_info >= (3, 7):
  42         @property
  43         def sockets(self) -> list[socket]: ...
  44     else:
  45         sockets: list[socket] | None
  46
  47 class BaseEventLoop(AbstractEventLoop, metaclass=ABCMeta):
  48     def run_forever(self) -> None: ...
  49     # Can't use a union, see mypy issue  # 1873.
  50     @overload
  51     def run_until_complete(self, future: Generator[Any, None, _T]) -> _T: ...
  52     @overload
  53     def run_until_complete(self, future: Awaitable[_T]) -> _T: ...
  54     def stop(self) -> None: ...
  55     def is_running(self) -> bool: ...
  56     def is_closed(self) -> bool: ...
  57     def close(self) -> None: ...
  58     async def shutdown_asyncgens(self) -> None: ...
  59     # Methods scheduling callbacks.  All these return Handles.
  60     if sys.version_info >= (3, 7):
  61         def call_soon(self, callback: Callable[..., Any], *args: Any, context: Context | None = ...) -> Handle: ...
  62         def call_later(
  63             self, delay: float, callback: Callable[..., Any], *args: Any, context: Context | None = ...
  64         ) -> TimerHandle: ...
  65         def call_at(
  66             self, when: float, callback: Callable[..., Any], *args: Any, context: Context | None = ...
  67         ) -> TimerHandle: ...
  68     else:
  69         def call_soon(self, callback: Callable[..., Any], *args: Any) -> Handle: ...
  70         def call_later(self, delay: float, callback: Callable[..., Any], *args: Any) -> TimerHandle: ...
  71         def call_at(self, when: float, callback: Callable[..., Any], *args: Any) -> TimerHandle: ...
  72     def time(self) -> float: ...
  73     # Future methods
  74     def create_future(self) -> Future[Any]: ...
  75     # Tasks methods
  76     if sys.version_info >= (3, 8):
  77         def create_task(self, coro: Awaitable[_T] | Generator[Any, None, _T], *, name: object = ...) -> Task[_T]: ...
  78     else:
  79         def create_task(self, coro: Awaitable[_T] | Generator[Any, None, _T]) -> Task[_T]: ...
  80     def set_task_factory(self, factory: Callable[[AbstractEventLoop, Generator[Any, None, _T]], Future[_T]] | None) -> None: ...
  81     def get_task_factory(self) -> Callable[[AbstractEventLoop, Generator[Any, None, _T]], Future[_T]] | None: ...
  82     # Methods for interacting with threads
  83     if sys.version_info >= (3, 7):
  84         def call_soon_threadsafe(self, callback: Callable[..., Any], *args: Any, context: Context | None = ...) -> Handle: ...
  85     else:
  86         def call_soon_threadsafe(self, callback: Callable[..., Any], *args: Any) -> Handle: ...
  87     def run_in_executor(self, executor: Any, func: Callable[..., _T], *args: Any) -> Future[_T]: ...
  88     def set_default_executor(self, executor: Any) -> None: ...
  89     # Network I/O methods returning Futures.
  90     async def getaddrinfo(
  91         self, host: str | None, port: str | int | None, *, family: int = ..., type: int = ..., proto: int = ..., flags: int = ...
  92     ) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int]]]: ...
  93     async def getnameinfo(self, sockaddr: tuple[str, int] | tuple[str, int, int, int], flags: int = ...) -> tuple[str, str]: ...
  94     if sys.version_info >= (3, 8):
  95         @overload
  96         async def create_connection(
  97             self,
  98             protocol_factory: _ProtocolFactory,
  99             host: str = ...,
 100             port: int = ...,
 101             *,
 102             ssl: _SSLContext = ...,
 103             family: int = ...,
 104             proto: int = ...,
 105             flags: int = ...,
 106             sock: None = ...,
 107             local_addr: tuple[str, int] | None = ...,
 108             server_hostname: str | None = ...,
 109             ssl_handshake_timeout: float | None = ...,
 110             happy_eyeballs_delay: float | None = ...,
 111             interleave: int | None = ...,
 112         ) -> _TransProtPair: ...
 113         @overload
 114         async def create_connection(
 115             self,
 116             protocol_factory: _ProtocolFactory,
 117             host: None = ...,
 118             port: None = ...,
 119             *,
 120             ssl: _SSLContext = ...,
 121             family: int = ...,
 122             proto: int = ...,
 123             flags: int = ...,
 124             sock: socket,
 125             local_addr: None = ...,
 126             server_hostname: str | None = ...,
 127             ssl_handshake_timeout: float | None = ...,
 128             happy_eyeballs_delay: float | None = ...,
 129             interleave: int | None = ...,
 130         ) -> _TransProtPair: ...
 131     elif sys.version_info >= (3, 7):
 132         @overload
 133         async def create_connection(
 134             self,
 135             protocol_factory: _ProtocolFactory,
 136             host: str = ...,
 137             port: int = ...,
 138             *,
 139             ssl: _SSLContext = ...,
 140             family: int = ...,
 141             proto: int = ...,
 142             flags: int = ...,
 143             sock: None = ...,
 144             local_addr: tuple[str, int] | None = ...,
 145             server_hostname: str | None = ...,
 146             ssl_handshake_timeout: float | None = ...,
 147         ) -> _TransProtPair: ...
 148         @overload
 149         async def create_connection(
 150             self,
 151             protocol_factory: _ProtocolFactory,
 152             host: None = ...,
 153             port: None = ...,
 154             *,
 155             ssl: _SSLContext = ...,
 156             family: int = ...,
 157             proto: int = ...,
 158             flags: int = ...,
 159             sock: socket,
 160             local_addr: None = ...,
 161             server_hostname: str | None = ...,
 162             ssl_handshake_timeout: float | None = ...,
 163         ) -> _TransProtPair: ...
 164     else:
 165         @overload
 166         async def create_connection(
 167             self,
 168             protocol_factory: _ProtocolFactory,
 169             host: str = ...,
 170             port: int = ...,
 171             *,
 172             ssl: _SSLContext = ...,
 173             family: int = ...,
 174             proto: int = ...,
 175             flags: int = ...,
 176             sock: None = ...,
 177             local_addr: tuple[str, int] | None = ...,
 178             server_hostname: str | None = ...,
 179         ) -> _TransProtPair: ...
 180         @overload
 181         async def create_connection(
 182             self,
 183             protocol_factory: _ProtocolFactory,
 184             host: None = ...,
 185             port: None = ...,
 186             *,
 187             ssl: _SSLContext = ...,
 188             family: int = ...,
 189             proto: int = ...,
 190             flags: int = ...,
 191             sock: socket,
 192             local_addr: None = ...,
 193             server_hostname: str | None = ...,
 194         ) -> _TransProtPair: ...
 195     if sys.version_info >= (3, 7):
 196         async def sock_sendfile(
 197             self, sock: socket, file: IO[bytes], offset: int = ..., count: int | None = ..., *, fallback: bool | None = ...
 198         ) -> int: ...
 199         @overload
 200         async def create_server(
 201             self,
 202             protocol_factory: _ProtocolFactory,
 203             host: str | Sequence[str] | None = ...,
 204             port: int = ...,
 205             *,
 206             family: int = ...,
 207             flags: int = ...,
 208             sock: None = ...,
 209             backlog: int = ...,
 210             ssl: _SSLContext = ...,
 211             reuse_address: bool | None = ...,
 212             reuse_port: bool | None = ...,
 213             ssl_handshake_timeout: float | None = ...,
 214             start_serving: bool = ...,
 215         ) -> Server: ...
 216         @overload
 217         async def create_server(
 218             self,
 219             protocol_factory: _ProtocolFactory,
 220             host: None = ...,
 221             port: None = ...,
 222             *,
 223             family: int = ...,
 224             flags: int = ...,
 225             sock: socket = ...,
 226             backlog: int = ...,
 227             ssl: _SSLContext = ...,
 228             reuse_address: bool | None = ...,
 229             reuse_port: bool | None = ...,
 230             ssl_handshake_timeout: float | None = ...,
 231             start_serving: bool = ...,
 232         ) -> Server: ...
 233         async def connect_accepted_socket(
 234             self,
 235             protocol_factory: _ProtocolFactory,
 236             sock: socket,
 237             *,
 238             ssl: _SSLContext = ...,
 239             ssl_handshake_timeout: float | None = ...,
 240         ) -> _TransProtPair: ...
 241         async def sendfile(
 242             self, transport: BaseTransport, file: IO[bytes], offset: int = ..., count: int | None = ..., *, fallback: bool = ...
 243         ) -> int: ...
 244         async def start_tls(
 245             self,
 246             transport: BaseTransport,
 247             protocol: BaseProtocol,
 248             sslcontext: ssl.SSLContext,
 249             *,
 250             server_side: bool = ...,
 251             server_hostname: str | None = ...,
 252             ssl_handshake_timeout: float | None = ...,
 253         ) -> BaseTransport: ...
 254     else:
 255         @overload
 256         async def create_server(
 257             self,
 258             protocol_factory: _ProtocolFactory,
 259             host: str | Sequence[str] | None = ...,
 260             port: int = ...,
 261             *,
 262             family: int = ...,
 263             flags: int = ...,
 264             sock: None = ...,
 265             backlog: int = ...,
 266             ssl: _SSLContext = ...,
 267             reuse_address: bool | None = ...,
 268             reuse_port: bool | None = ...,
 269         ) -> Server: ...
 270         @overload
 271         async def create_server(
 272             self,
 273             protocol_factory: _ProtocolFactory,
 274             host: None = ...,
 275             port: None = ...,
 276             *,
 277             family: int = ...,
 278             flags: int = ...,
 279             sock: socket,
 280             backlog: int = ...,
 281             ssl: _SSLContext = ...,
 282             reuse_address: bool | None = ...,
 283             reuse_port: bool | None = ...,
 284         ) -> Server: ...
 285         async def connect_accepted_socket(
 286             self, protocol_factory: _ProtocolFactory, sock: socket, *, ssl: _SSLContext = ...
 287         ) -> _TransProtPair: ...
 288     async def create_datagram_endpoint(
 289         self,
 290         protocol_factory: _ProtocolFactory,
 291         local_addr: tuple[str, int] | None = ...,
 292         remote_addr: tuple[str, int] | None = ...,
 293         *,
 294         family: int = ...,
 295         proto: int = ...,
 296         flags: int = ...,
 297         reuse_address: bool | None = ...,
 298         reuse_port: bool | None = ...,
 299         allow_broadcast: bool | None = ...,
 300         sock: socket | None = ...,
 301     ) -> _TransProtPair: ...
 302     # Pipes and subprocesses.
 303     async def connect_read_pipe(self, protocol_factory: _ProtocolFactory, pipe: Any) -> _TransProtPair: ...
 304     async def connect_write_pipe(self, protocol_factory: _ProtocolFactory, pipe: Any) -> _TransProtPair: ...
 305     async def subprocess_shell(
 306         self,
 307         protocol_factory: _ProtocolFactory,
 308         cmd: bytes | str,
 309         *,
 310         stdin: int | IO[Any] | None = ...,
 311         stdout: int | IO[Any] | None = ...,
 312         stderr: int | IO[Any] | None = ...,
 313         universal_newlines: Literal[False] = ...,
 314         shell: Literal[True] = ...,
 315         bufsize: Literal[0] = ...,
 316         encoding: None = ...,
 317         errors: None = ...,
 318         text: Literal[False, None] = ...,
 319         **kwargs: Any,
 320     ) -> _TransProtPair: ...
 321     async def subprocess_exec(
 322         self,
 323         protocol_factory: _ProtocolFactory,
 324         program: Any,
 325         *args: Any,
 326         stdin: int | IO[Any] | None = ...,
 327         stdout: int | IO[Any] | None = ...,
 328         stderr: int | IO[Any] | None = ...,
 329         universal_newlines: Literal[False] = ...,
 330         shell: Literal[True] = ...,
 331         bufsize: Literal[0] = ...,
 332         encoding: None = ...,
 333         errors: None = ...,
 334         **kwargs: Any,
 335     ) -> _TransProtPair: ...
 336     def add_reader(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
 337     def remove_reader(self, fd: FileDescriptorLike) -> None: ...
 338     def add_writer(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
 339     def remove_writer(self, fd: FileDescriptorLike) -> None: ...
 340     # Completion based I/O methods returning Futures prior to 3.7
 341     if sys.version_info >= (3, 7):
 342         async def sock_recv(self, sock: socket, nbytes: int) -> bytes: ...
 343         async def sock_recv_into(self, sock: socket, buf: bytearray) -> int: ...
 344         async def sock_sendall(self, sock: socket, data: bytes) -> None: ...
 345         async def sock_connect(self, sock: socket, address: _Address) -> None: ...
 346         async def sock_accept(self, sock: socket) -> tuple[socket, _RetAddress]: ...
 347     else:
 348         def sock_recv(self, sock: socket, nbytes: int) -> Future[bytes]: ...
 349         def sock_sendall(self, sock: socket, data: bytes) -> Future[None]: ...
 350         def sock_connect(self, sock: socket, address: _Address) -> Future[None]: ...
 351         def sock_accept(self, sock: socket) -> Future[tuple[socket, _RetAddress]]: ...
 352     # Signal handling.
 353     def add_signal_handler(self, sig: int, callback: Callable[..., Any], *args: Any) -> None: ...
 354     def remove_signal_handler(self, sig: int) -> bool: ...
 355     # Error handlers.
 356     def set_exception_handler(self, handler: _ExceptionHandler | None) -> None: ...
 357     def get_exception_handler(self) -> _ExceptionHandler | None: ...
 358     def default_exception_handler(self, context: _Context) -> None: ...
 359     def call_exception_handler(self, context: _Context) -> None: ...
 360     # Debug flag management.
 361     def get_debug(self) -> bool: ...
 362     def set_debug(self, enabled: bool) -> None: ...
 363     if sys.version_info >= (3, 9):
 364         async def shutdown_default_executor(self) -> None: ...