layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/asyncio/base_events.pyi

@@ -0,0 +1,498 @@
+import ssl
+import sys
+from _typeshed import FileDescriptorLike, ReadableBuffer, WriteableBuffer
+from asyncio import _AwaitableLike, _CoroutineLike
+from asyncio.events import AbstractEventLoop, AbstractServer, Handle, TimerHandle, _TaskFactory
+from asyncio.futures import Future
+from asyncio.protocols import BaseProtocol
+from asyncio.tasks import Task
+from asyncio.transports import BaseTransport, DatagramTransport, ReadTransport, SubprocessTransport, Transport, WriteTransport
+from collections.abc import Callable, Iterable, Sequence
+from concurrent.futures import Executor, ThreadPoolExecutor
+from contextvars import Context
+from socket import AddressFamily, AddressInfo, SocketKind, _Address, _RetAddress, socket
+from typing import IO, Any, Literal, TypeAlias, TypeVar, overload
+from typing_extensions import TypeVarTuple, Unpack
+
+# Keep asyncio.__all__ updated with any changes to __all__ here
+__all__ = ("BaseEventLoop", "Server")
+
+_T = TypeVar("_T")
+_Ts = TypeVarTuple("_Ts")
+_ProtocolT = TypeVar("_ProtocolT", bound=BaseProtocol)
+_Context: TypeAlias = dict[str, Any]
+_ExceptionHandler: TypeAlias = Callable[[AbstractEventLoop, _Context], object]
+_ProtocolFactory: TypeAlias = Callable[[], BaseProtocol]
+_SSLContext: TypeAlias = bool | None | ssl.SSLContext
+
+class Server(AbstractServer):
+    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,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            loop: AbstractEventLoop,
+            sockets: Iterable[socket],
+            protocol_factory: _ProtocolFactory,
+            ssl_context: _SSLContext,
+            backlog: int,
+            ssl_handshake_timeout: float | None,
+        ) -> None: ...
+
+    if sys.version_info >= (3, 13):
+        def close_clients(self) -> None: ...
+        def abort_clients(self) -> None: ...
+
+    def get_loop(self) -> AbstractEventLoop: ...
+    def is_serving(self) -> bool: ...
+    async def start_serving(self) -> None: ...
+    async def serve_forever(self) -> None: ...
+    @property
+    def sockets(self) -> tuple[socket, ...]: ...
+    def close(self) -> None: ...
+    async def wait_closed(self) -> None: ...
+
+class BaseEventLoop(AbstractEventLoop):
+    def run_forever(self) -> None: ...
+    def run_until_complete(self, future: _AwaitableLike[_T]) -> _T: ...
+    def stop(self) -> None: ...
+    def is_running(self) -> bool: ...
+    def is_closed(self) -> bool: ...
+    def close(self) -> None: ...
+    async def shutdown_asyncgens(self) -> None: ...
+    # Methods scheduling callbacks.  All these return Handles.
+    def call_soon(
+        self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> Handle: ...
+    def call_later(
+        self, delay: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> TimerHandle: ...
+    def call_at(
+        self, when: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> TimerHandle: ...
+    def time(self) -> float: ...
+    # Future methods
+    def create_future(self) -> Future[Any]: ...
+    # Tasks methods
+    if sys.version_info >= (3, 14):
+        def create_task(
+            self,
+            coro: _CoroutineLike[_T],
+            *,
+            name: object = None,
+            context: Context | None = None,
+            eager_start: bool | None = None,
+        ) -> Task[_T]: ...
+    elif sys.version_info >= (3, 11):
+        def create_task(self, coro: _CoroutineLike[_T], *, name: object = None, context: Context | None = None) -> Task[_T]: ...
+    else:
+        def create_task(self, coro: _CoroutineLike[_T], *, name: object = None) -> Task[_T]: ...
+
+    def set_task_factory(self, factory: _TaskFactory | None) -> None: ...
+    def get_task_factory(self) -> _TaskFactory | None: ...
+    # Methods for interacting with threads
+    def call_soon_threadsafe(
+        self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> Handle: ...
+    def run_in_executor(self, executor: Executor | None, func: Callable[[Unpack[_Ts]], _T], *args: Unpack[_Ts]) -> Future[_T]: ...
+    def set_default_executor(self, executor: ThreadPoolExecutor) -> None: ...  # type: ignore[override]
+    # Network I/O methods returning Futures.
+    async def getaddrinfo(
+        self,
+        host: bytes | str | None,
+        port: bytes | str | int | None,
+        *,
+        family: int = 0,
+        type: int = 0,
+        proto: int = 0,
+        flags: int = 0,
+    ) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes]]]: ...
+    async def getnameinfo(self, sockaddr: tuple[str, int] | tuple[str, int, int, int], flags: int = 0) -> tuple[str, str]: ...
+
+    if sys.version_info >= (3, 12):
+        @overload
+        async def create_connection(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            host: str = ...,
+            port: int = ...,
+            *,
+            ssl: _SSLContext = None,
+            family: int = 0,
+            proto: int = 0,
+            flags: int = 0,
+            sock: None = None,
+            local_addr: tuple[str, int] | None = None,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            happy_eyeballs_delay: float | None = None,
+            interleave: int | None = None,
+            all_errors: bool = False,
+        ) -> tuple[Transport, _ProtocolT]: ...
+        @overload
+        async def create_connection(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            host: None = None,
+            port: None = None,
+            *,
+            ssl: _SSLContext = None,
+            family: int = 0,
+            proto: int = 0,
+            flags: int = 0,
+            sock: socket,
+            local_addr: None = None,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            happy_eyeballs_delay: float | None = None,
+            interleave: int | None = None,
+            all_errors: bool = False,
+        ) -> tuple[Transport, _ProtocolT]: ...
+    elif sys.version_info >= (3, 11):
+        @overload
+        async def create_connection(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            host: str = ...,
+            port: int = ...,
+            *,
+            ssl: _SSLContext = None,
+            family: int = 0,
+            proto: int = 0,
+            flags: int = 0,
+            sock: None = None,
+            local_addr: tuple[str, int] | None = None,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            happy_eyeballs_delay: float | None = None,
+            interleave: int | None = None,
+        ) -> tuple[Transport, _ProtocolT]: ...
+        @overload
+        async def create_connection(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            host: None = None,
+            port: None = None,
+            *,
+            ssl: _SSLContext = None,
+            family: int = 0,
+            proto: int = 0,
+            flags: int = 0,
+            sock: socket,
+            local_addr: None = None,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            happy_eyeballs_delay: float | None = None,
+            interleave: int | None = None,
+        ) -> tuple[Transport, _ProtocolT]: ...
+    else:
+        @overload
+        async def create_connection(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            host: str = ...,
+            port: int = ...,
+            *,
+            ssl: _SSLContext = None,
+            family: int = 0,
+            proto: int = 0,
+            flags: int = 0,
+            sock: None = None,
+            local_addr: tuple[str, int] | None = None,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            happy_eyeballs_delay: float | None = None,
+            interleave: int | None = None,
+        ) -> tuple[Transport, _ProtocolT]: ...
+        @overload
+        async def create_connection(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            host: None = None,
+            port: None = None,
+            *,
+            ssl: _SSLContext = None,
+            family: int = 0,
+            proto: int = 0,
+            flags: int = 0,
+            sock: socket,
+            local_addr: None = None,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            happy_eyeballs_delay: float | None = None,
+            interleave: int | None = None,
+        ) -> tuple[Transport, _ProtocolT]: ...
+
+    if sys.version_info >= (3, 13):
+        # 3.13 added `keep_alive`.
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str | Sequence[str] | None = None,
+            port: int = ...,
+            *,
+            family: int = 0,
+            flags: int = 1,
+            sock: None = None,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            keep_alive: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = None,
+            port: None = None,
+            *,
+            family: int = 0,
+            flags: int = 1,
+            sock: socket = ...,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            keep_alive: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+    elif sys.version_info >= (3, 11):
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str | Sequence[str] | None = None,
+            port: int = ...,
+            *,
+            family: int = AddressFamily.AF_UNSPEC,
+            flags: int = AddressInfo.AI_PASSIVE,
+            sock: None = None,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = None,
+            port: None = None,
+            *,
+            family: int = AddressFamily.AF_UNSPEC,
+            flags: int = AddressInfo.AI_PASSIVE,
+            sock: socket = ...,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+    else:
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: str | Sequence[str] | None = None,
+            port: int = ...,
+            *,
+            family: int = AddressFamily.AF_UNSPEC,
+            flags: int = AddressInfo.AI_PASSIVE,
+            sock: None = None,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+        @overload
+        async def create_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            host: None = None,
+            port: None = None,
+            *,
+            family: int = AddressFamily.AF_UNSPEC,
+            flags: int = AddressInfo.AI_PASSIVE,
+            sock: socket = ...,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            ssl_handshake_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+
+    if sys.version_info >= (3, 11):
+        async def start_tls(
+            self,
+            transport: BaseTransport,
+            protocol: BaseProtocol,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_side: bool = False,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> Transport | None: ...
+        async def connect_accepted_socket(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            sock: socket,
+            *,
+            ssl: _SSLContext = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> tuple[Transport, _ProtocolT]: ...
+    else:
+        async def start_tls(
+            self,
+            transport: BaseTransport,
+            protocol: BaseProtocol,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_side: bool = False,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+        ) -> Transport | None: ...
+        async def connect_accepted_socket(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            sock: socket,
+            *,
+            ssl: _SSLContext = None,
+            ssl_handshake_timeout: float | None = None,
+        ) -> tuple[Transport, _ProtocolT]: ...
+
+    async def sock_sendfile(
+        self, sock: socket, file: IO[bytes], offset: int = 0, count: int | None = None, *, fallback: bool | None = True
+    ) -> int: ...
+    async def sendfile(
+        self, transport: WriteTransport, file: IO[bytes], offset: int = 0, count: int | None = None, *, fallback: bool = True
+    ) -> int: ...
+    if sys.version_info >= (3, 11):
+        async def create_datagram_endpoint(  # type: ignore[override]
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            local_addr: tuple[str, int] | str | None = None,
+            remote_addr: tuple[str, int] | str | None = None,
+            *,
+            family: int = 0,
+            proto: int = 0,
+            flags: int = 0,
+            reuse_port: bool | None = None,
+            allow_broadcast: bool | None = None,
+            sock: socket | None = None,
+        ) -> tuple[DatagramTransport, _ProtocolT]: ...
+    else:
+        async def create_datagram_endpoint(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            local_addr: tuple[str, int] | str | None = None,
+            remote_addr: tuple[str, int] | str | None = None,
+            *,
+            family: int = 0,
+            proto: int = 0,
+            flags: int = 0,
+            reuse_address: bool | None = ...,
+            reuse_port: bool | None = None,
+            allow_broadcast: bool | None = None,
+            sock: socket | None = None,
+        ) -> tuple[DatagramTransport, _ProtocolT]: ...
+    # Pipes and subprocesses.
+    async def connect_read_pipe(
+        self, protocol_factory: Callable[[], _ProtocolT], pipe: Any
+    ) -> tuple[ReadTransport, _ProtocolT]: ...
+    async def connect_write_pipe(
+        self, protocol_factory: Callable[[], _ProtocolT], pipe: Any
+    ) -> tuple[WriteTransport, _ProtocolT]: ...
+    async def subprocess_shell(
+        self,
+        protocol_factory: Callable[[], _ProtocolT],
+        cmd: bytes | str,
+        *,
+        stdin: int | IO[Any] | None = -1,
+        stdout: int | IO[Any] | None = -1,
+        stderr: int | IO[Any] | None = -1,
+        universal_newlines: Literal[False] = False,
+        shell: Literal[True] = True,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        **kwargs: Any,
+    ) -> tuple[SubprocessTransport, _ProtocolT]: ...
+    async def subprocess_exec(
+        self,
+        protocol_factory: Callable[[], _ProtocolT],
+        program: Any,
+        *args: Any,
+        stdin: int | IO[Any] | None = -1,
+        stdout: int | IO[Any] | None = -1,
+        stderr: int | IO[Any] | None = -1,
+        universal_newlines: Literal[False] = False,
+        shell: Literal[False] = False,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        **kwargs: Any,
+    ) -> tuple[SubprocessTransport, _ProtocolT]: ...
+    def add_reader(self, fd: FileDescriptorLike, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
+    def remove_reader(self, fd: FileDescriptorLike) -> bool: ...
+    def add_writer(self, fd: FileDescriptorLike, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> 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.
+    async def sock_recv(self, sock: socket, nbytes: int) -> bytes: ...
+    async def sock_recv_into(self, sock: socket, buf: WriteableBuffer) -> int: ...
+    async def sock_sendall(self, sock: socket, data: ReadableBuffer) -> None: ...
+    async def sock_connect(self, sock: socket, address: _Address) -> None: ...
+    async def sock_accept(self, sock: socket) -> tuple[socket, _RetAddress]: ...
+    if sys.version_info >= (3, 11):
+        async def sock_recvfrom(self, sock: socket, bufsize: int) -> tuple[bytes, _RetAddress]: ...
+        async def sock_recvfrom_into(self, sock: socket, buf: WriteableBuffer, nbytes: int = 0) -> tuple[int, _RetAddress]: ...
+        async def sock_sendto(self, sock: socket, data: ReadableBuffer, address: _Address) -> int: ...
+    # Signal handling.
+    def add_signal_handler(self, sig: int, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
+    def remove_signal_handler(self, sig: int) -> bool: ...
+    # Error handlers.
+    def set_exception_handler(self, handler: _ExceptionHandler | None) -> None: ...
+    def get_exception_handler(self) -> _ExceptionHandler | None: ...
+    def default_exception_handler(self, context: _Context) -> None: ...
+    def call_exception_handler(self, context: _Context) -> None: ...
+    # Debug flag management.
+    def get_debug(self) -> bool: ...
+    def set_debug(self, enabled: bool) -> None: ...
+    if sys.version_info >= (3, 12):
+        async def shutdown_default_executor(self, timeout: float | None = None) -> None: ...
+    else:
+        async def shutdown_default_executor(self) -> None: ...
+
+    def __del__(self) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/asyncio/base_futures.pyi

@@ -0,0 +1,17 @@
+from _asyncio import Future
+from collections.abc import Callable, Sequence
+from contextvars import Context
+from typing import Any, Final
+from typing_extensions import TypeIs
+
+from . import futures
+
+__all__ = ()
+
+_PENDING: Final = "PENDING"  # undocumented
+_CANCELLED: Final = "CANCELLED"  # undocumented
+_FINISHED: Final = "FINISHED"  # undocumented
+
+def isfuture(obj: object) -> TypeIs[Future[Any]]: ...
+def _format_callbacks(cb: Sequence[tuple[Callable[[futures.Future[Any]], None], Context]]) -> str: ...  # undocumented
+def _future_repr_info(future: futures.Future[Any]) -> list[str]: ...  # undocumented

package/analyzers/project-map-python/typeshed/stdlib/asyncio/base_subprocess.pyi

@@ -0,0 +1,62 @@
+import subprocess
+from collections import deque
+from collections.abc import Callable, Sequence
+from typing import IO, Any, TypeAlias
+
+from . import events, futures, protocols, transports
+
+_File: TypeAlias = int | IO[Any] | None
+
+class BaseSubprocessTransport(transports.SubprocessTransport):
+    _closed: bool  # undocumented
+    _protocol: protocols.SubprocessProtocol  # undocumented
+    _loop: events.AbstractEventLoop  # undocumented
+    _proc: subprocess.Popen[Any] | None  # undocumented
+    _pid: int | None  # undocumented
+    _returncode: int | None  # undocumented
+    _exit_waiters: list[futures.Future[Any]]  # 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: str | bytes | Sequence[str | bytes],
+        shell: bool,
+        stdin: _File,
+        stdout: _File,
+        stderr: _File,
+        bufsize: int,
+        waiter: futures.Future[Any] | None = None,
+        extra: Any | None = None,
+        **kwargs: Any,
+    ) -> None: ...
+    def _start(
+        self,
+        args: str | bytes | Sequence[str | bytes],
+        shell: bool,
+        stdin: _File,
+        stdout: _File,
+        stderr: _File,
+        bufsize: int,
+        **kwargs: Any,
+    ) -> None: ...  # undocumented
+    def get_pid(self) -> int | None: ...  # type: ignore[override]
+    def get_pipe_transport(self, fd: int) -> _File: ...  # type: ignore[override]
+    def _check_proc(self) -> None: ...  # undocumented
+    def send_signal(self, signal: int) -> None: ...
+    async def _connect_pipes(self, waiter: futures.Future[Any] | None) -> None: ...  # undocumented
+    def _call(self, cb: Callable[..., object], *data: Any) -> None: ...  # undocumented
+    def _pipe_connection_lost(self, fd: int, exc: BaseException | None) -> 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: BaseException | None) -> None: ...  # undocumented
+    def __del__(self) -> None: ...
+
+class WriteSubprocessPipeProto(protocols.BaseProtocol):  # undocumented
+    def __init__(self, proc: BaseSubprocessTransport, fd: int) -> None: ...
+
+class ReadSubprocessPipeProto(WriteSubprocessPipeProto, protocols.Protocol): ...  # undocumented

package/analyzers/project-map-python/typeshed/stdlib/asyncio/base_tasks.pyi

@@ -0,0 +1,17 @@
+import sys
+from _typeshed import StrOrBytesPath
+from types import FrameType
+from typing import Any
+
+from .tasks import Task
+
+def _task_repr_info(task: Task[Any]) -> list[str]: ...  # undocumented
+
+if sys.version_info >= (3, 13):
+    def _task_repr(task: Task[Any]) -> str: ...  # undocumented
+
+elif sys.version_info >= (3, 11):
+    def _task_repr(self: Task[Any]) -> str: ...  # undocumented
+
+def _task_get_stack(task: Task[Any], limit: int | None) -> list[FrameType]: ...  # undocumented
+def _task_print_stack(task: Task[Any], limit: int | None, file: StrOrBytesPath) -> None: ...  # undocumented

package/analyzers/project-map-python/typeshed/stdlib/asyncio/constants.pyi

@@ -0,0 +1,20 @@
+import enum
+import sys
+from typing import Final
+
+LOG_THRESHOLD_FOR_CONNLOST_WRITES: Final = 5
+ACCEPT_RETRY_DELAY: Final = 1
+DEBUG_STACK_DEPTH: Final = 10
+SSL_HANDSHAKE_TIMEOUT: float
+SENDFILE_FALLBACK_READBUFFER_SIZE: Final = 262144
+if sys.version_info >= (3, 11):
+    SSL_SHUTDOWN_TIMEOUT: float
+    FLOW_CONTROL_HIGH_WATER_SSL_READ: Final = 256
+    FLOW_CONTROL_HIGH_WATER_SSL_WRITE: Final = 512
+if sys.version_info >= (3, 12):
+    THREAD_JOIN_TIMEOUT: Final = 300
+
+class _SendfileMode(enum.Enum):
+    UNSUPPORTED = 1
+    TRY_NATIVE = 2
+    FALLBACK = 3

package/analyzers/project-map-python/typeshed/stdlib/asyncio/coroutines.pyi

@@ -0,0 +1,45 @@
+import sys
+from collections.abc import Awaitable, Callable, Coroutine
+from typing import Any, ParamSpec, TypeGuard, TypeVar, overload
+from typing_extensions import TypeIs, deprecated
+
+# Keep asyncio.__all__ updated with any changes to __all__ here
+if sys.version_info >= (3, 11):
+    __all__ = ("iscoroutinefunction", "iscoroutine")
+else:
+    __all__ = ("coroutine", "iscoroutinefunction", "iscoroutine")
+
+_T = TypeVar("_T")
+_FunctionT = TypeVar("_FunctionT", bound=Callable[..., Any])
+_P = ParamSpec("_P")
+
+if sys.version_info < (3, 11):
+    @deprecated("Deprecated since Python 3.8; removed in Python 3.11. Use `async def` instead.")
+    def coroutine(func: _FunctionT) -> _FunctionT: ...
+
+def iscoroutine(obj: object) -> TypeIs[Coroutine[Any, Any, Any]]: ...
+
+if sys.version_info >= (3, 11):
+    @overload
+    @deprecated("Deprecated since Python 3.14. Use `inspect.iscoroutinefunction()` instead.")
+    def iscoroutinefunction(func: Callable[..., Coroutine[Any, Any, Any]]) -> bool: ...
+    @overload
+    @deprecated("Deprecated since Python 3.14. Use `inspect.iscoroutinefunction()` instead.")
+    def iscoroutinefunction(func: Callable[_P, Awaitable[_T]]) -> TypeGuard[Callable[_P, Coroutine[Any, Any, _T]]]: ...
+    @overload
+    @deprecated("Deprecated since Python 3.14. Use `inspect.iscoroutinefunction()` instead.")
+    def iscoroutinefunction(func: Callable[_P, object]) -> TypeGuard[Callable[_P, Coroutine[Any, Any, Any]]]: ...
+    @overload
+    @deprecated("Deprecated since Python 3.14. Use `inspect.iscoroutinefunction()` instead.")
+    def iscoroutinefunction(func: object) -> TypeGuard[Callable[..., Coroutine[Any, Any, Any]]]: ...
+else:
+    # Sometimes needed in Python < 3.11 due to the fact that it supports @coroutine
+    # which was removed in 3.11 which the inspect version doesn't support.
+    @overload
+    def iscoroutinefunction(func: Callable[..., Coroutine[Any, Any, Any]]) -> bool: ...
+    @overload
+    def iscoroutinefunction(func: Callable[_P, Awaitable[_T]]) -> TypeGuard[Callable[_P, Coroutine[Any, Any, _T]]]: ...
+    @overload
+    def iscoroutinefunction(func: Callable[_P, object]) -> TypeGuard[Callable[_P, Coroutine[Any, Any, Any]]]: ...
+    @overload
+    def iscoroutinefunction(func: object) -> TypeGuard[Callable[..., Coroutine[Any, Any, Any]]]: ...