layermap 0.1.0

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

@@ -0,0 +1,124 @@
+import ssl
+import sys
+from _typeshed import ReadableBuffer, StrPath
+from collections.abc import Awaitable, Callable, Iterable, Sequence, Sized
+from types import ModuleType
+from typing import Any, Protocol, SupportsIndex, TypeAlias, type_check_only
+from typing_extensions import Self
+
+from . import events, protocols, transports
+from .base_events import Server
+
+# Keep asyncio.__all__ updated with any changes to __all__ here
+if sys.platform == "win32":
+    __all__ = ("StreamReader", "StreamWriter", "StreamReaderProtocol", "open_connection", "start_server")
+else:
+    __all__ = (
+        "StreamReader",
+        "StreamWriter",
+        "StreamReaderProtocol",
+        "open_connection",
+        "start_server",
+        "open_unix_connection",
+        "start_unix_server",
+    )
+
+_ClientConnectedCallback: TypeAlias = Callable[[StreamReader, StreamWriter], Awaitable[None] | None]
+
+@type_check_only
+class _ReaduntilBuffer(ReadableBuffer, Sized, Protocol): ...
+
+async def open_connection(
+    host: str | None = None,
+    port: int | str | None = None,
+    *,
+    limit: int = 65536,
+    ssl_handshake_timeout: float | None = None,
+    **kwds: Any,
+) -> tuple[StreamReader, StreamWriter]: ...
+async def start_server(
+    client_connected_cb: _ClientConnectedCallback,
+    host: str | Sequence[str] | None = None,
+    port: int | str | None = None,
+    *,
+    limit: int = 65536,
+    ssl_handshake_timeout: float | None = None,
+    **kwds: Any,
+) -> Server: ...
+
+if sys.platform != "win32":
+    async def open_unix_connection(
+        path: StrPath | None = None, *, limit: int = 65536, **kwds: Any
+    ) -> tuple[StreamReader, StreamWriter]: ...
+    async def start_unix_server(
+        client_connected_cb: _ClientConnectedCallback, path: StrPath | None = None, *, limit: int = 65536, **kwds: Any
+    ) -> Server: ...
+
+class FlowControlMixin(protocols.Protocol):
+    def __init__(self, loop: events.AbstractEventLoop | None = None) -> None: ...
+
+class StreamReaderProtocol(FlowControlMixin, protocols.Protocol):
+    def __init__(
+        self,
+        stream_reader: StreamReader,
+        client_connected_cb: _ClientConnectedCallback | None = None,
+        loop: events.AbstractEventLoop | None = None,
+    ) -> None: ...
+    def __del__(self) -> None: ...
+
+class StreamWriter:
+    def __init__(
+        self,
+        transport: transports.WriteTransport,
+        protocol: protocols.BaseProtocol,
+        reader: StreamReader | None,
+        loop: events.AbstractEventLoop,
+    ) -> None: ...
+    @property
+    def transport(self) -> transports.WriteTransport: ...
+    def write(self, data: bytes | bytearray | memoryview) -> None: ...
+    def writelines(self, data: Iterable[bytes | bytearray | memoryview]) -> None: ...
+    def write_eof(self) -> None: ...
+    def can_write_eof(self) -> bool: ...
+    def close(self) -> None: ...
+    def is_closing(self) -> bool: ...
+    async def wait_closed(self) -> None: ...
+    def get_extra_info(self, name: str, default: Any = None) -> Any: ...
+    async def drain(self) -> None: ...
+    if sys.version_info >= (3, 12):
+        async def start_tls(
+            self,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
+        async def start_tls(
+            self, sslcontext: ssl.SSLContext, *, server_hostname: str | None = None, ssl_handshake_timeout: float | None = None
+        ) -> None: ...
+
+    if sys.version_info >= (3, 13):
+        def __del__(self, warnings: ModuleType = ...) -> None: ...
+    elif sys.version_info >= (3, 11):
+        def __del__(self) -> None: ...
+
+class StreamReader:
+    def __init__(self, limit: int = 65536, loop: events.AbstractEventLoop | None = None) -> None: ...
+    def exception(self) -> Exception | None: ...
+    def set_exception(self, exc: Exception) -> None: ...
+    def set_transport(self, transport: transports.BaseTransport) -> None: ...
+    def feed_eof(self) -> None: ...
+    def at_eof(self) -> bool: ...
+    def feed_data(self, data: Iterable[SupportsIndex]) -> None: ...
+    async def readline(self) -> bytes: ...
+    if sys.version_info >= (3, 13):
+        async def readuntil(self, separator: _ReaduntilBuffer | tuple[_ReaduntilBuffer, ...] = b"\n") -> bytes: ...
+    else:
+        async def readuntil(self, separator: _ReaduntilBuffer = b"\n") -> bytes: ...
+
+    async def read(self, n: int = -1) -> bytes: ...
+    async def readexactly(self, n: int) -> bytes: ...
+    def __aiter__(self) -> Self: ...
+    async def __anext__(self) -> bytes: ...

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

@@ -0,0 +1,166 @@
+import subprocess
+import sys
+from _typeshed import StrOrBytesPath
+from asyncio import events, protocols, streams, transports
+from collections.abc import Callable, Collection
+from typing import IO, Any, Literal
+
+# Keep asyncio.__all__ updated with any changes to __all__ here
+__all__ = ("create_subprocess_exec", "create_subprocess_shell")
+
+PIPE: int
+STDOUT: int
+DEVNULL: int
+
+class SubprocessStreamProtocol(streams.FlowControlMixin, protocols.SubprocessProtocol):
+    stdin: streams.StreamWriter | None
+    stdout: streams.StreamReader | None
+    stderr: streams.StreamReader | None
+    def __init__(self, limit: int, loop: events.AbstractEventLoop) -> None: ...
+    def pipe_data_received(self, fd: int, data: bytes | str) -> None: ...
+
+class Process:
+    stdin: streams.StreamWriter | None
+    stdout: streams.StreamReader | None
+    stderr: streams.StreamReader | None
+    pid: int
+    def __init__(
+        self, transport: transports.BaseTransport, protocol: protocols.BaseProtocol, loop: events.AbstractEventLoop
+    ) -> None: ...
+    @property
+    def returncode(self) -> int | None: ...
+    async def wait(self) -> int: ...
+    def send_signal(self, signal: int) -> None: ...
+    def terminate(self) -> None: ...
+    def kill(self) -> None: ...
+    async def communicate(self, input: bytes | bytearray | memoryview | None = None) -> tuple[bytes, bytes]: ...
+
+if sys.version_info >= (3, 11):
+    async def create_subprocess_shell(
+        cmd: str | bytes,
+        stdin: int | IO[Any] | None = None,
+        stdout: int | IO[Any] | None = None,
+        stderr: int | IO[Any] | None = None,
+        limit: int = 65536,
+        *,
+        # These parameters are forced to these values by BaseEventLoop.subprocess_shell
+        universal_newlines: Literal[False] = False,
+        shell: Literal[True] = True,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        # These parameters are taken by subprocess.Popen, which this ultimately delegates to
+        executable: StrOrBytesPath | None = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        cwd: StrOrBytesPath | None = None,
+        env: subprocess._ENV | None = None,
+        startupinfo: Any | None = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = (),
+        group: None | str | int = None,
+        extra_groups: None | Collection[str | int] = None,
+        user: None | str | int = None,
+        umask: int = -1,
+        process_group: int | None = None,
+        pipesize: int = -1,
+    ) -> Process: ...
+    async def create_subprocess_exec(
+        program: StrOrBytesPath,
+        *args: StrOrBytesPath,
+        stdin: int | IO[Any] | None = None,
+        stdout: int | IO[Any] | None = None,
+        stderr: int | IO[Any] | None = None,
+        limit: int = 65536,
+        # These parameters are forced to these values by BaseEventLoop.subprocess_exec
+        universal_newlines: Literal[False] = False,
+        shell: Literal[False] = False,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        # These parameters are taken by subprocess.Popen, which this ultimately delegates to
+        executable: StrOrBytesPath | None = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        cwd: StrOrBytesPath | None = None,
+        env: subprocess._ENV | None = None,
+        startupinfo: Any | None = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = (),
+        group: None | str | int = None,
+        extra_groups: None | Collection[str | int] = None,
+        user: None | str | int = None,
+        umask: int = -1,
+        process_group: int | None = None,
+        pipesize: int = -1,
+    ) -> Process: ...
+
+else:
+    async def create_subprocess_shell(
+        cmd: str | bytes,
+        stdin: int | IO[Any] | None = None,
+        stdout: int | IO[Any] | None = None,
+        stderr: int | IO[Any] | None = None,
+        limit: int = 65536,
+        *,
+        # These parameters are forced to these values by BaseEventLoop.subprocess_shell
+        universal_newlines: Literal[False] = False,
+        shell: Literal[True] = True,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        # These parameters are taken by subprocess.Popen, which this ultimately delegates to
+        executable: StrOrBytesPath | None = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        cwd: StrOrBytesPath | None = None,
+        env: subprocess._ENV | None = None,
+        startupinfo: Any | None = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = (),
+        group: None | str | int = None,
+        extra_groups: None | Collection[str | int] = None,
+        user: None | str | int = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> Process: ...
+    async def create_subprocess_exec(
+        program: StrOrBytesPath,
+        *args: StrOrBytesPath,
+        stdin: int | IO[Any] | None = None,
+        stdout: int | IO[Any] | None = None,
+        stderr: int | IO[Any] | None = None,
+        limit: int = 65536,
+        # These parameters are forced to these values by BaseEventLoop.subprocess_exec
+        universal_newlines: Literal[False] = False,
+        shell: Literal[False] = False,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        # These parameters are taken by subprocess.Popen, which this ultimately delegates to
+        executable: StrOrBytesPath | None = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        cwd: StrOrBytesPath | None = None,
+        env: subprocess._ENV | None = None,
+        startupinfo: Any | None = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = (),
+        group: None | str | int = None,
+        extra_groups: None | Collection[str | int] = None,
+        user: None | str | int = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> Process: ...

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

@@ -0,0 +1,41 @@
+import sys
+from contextvars import Context
+from types import TracebackType
+from typing import Any, TypeVar
+from typing_extensions import Self
+
+from . import _CoroutineLike
+from .events import AbstractEventLoop
+from .tasks import Task
+
+# Keep asyncio.__all__ updated with any changes to __all__ here
+if sys.version_info >= (3, 12):
+    __all__ = ("TaskGroup",)
+else:
+    __all__ = ["TaskGroup"]
+
+_T = TypeVar("_T")
+
+class TaskGroup:
+    _loop: AbstractEventLoop | None
+    _tasks: set[Task[Any]]
+
+    async def __aenter__(self) -> Self: ...
+    async def __aexit__(self, et: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None) -> None: ...
+    if sys.version_info >= (3, 14):
+        def create_task(
+            self,
+            coro: _CoroutineLike[_T],
+            *,
+            name: str | None = None,
+            context: Context | None = None,
+            eager_start: bool | None = None,
+        ) -> Task[_T]: ...
+    else:
+        def create_task(
+            self, coro: _CoroutineLike[_T], *, name: str | None = None, context: Context | None = None
+        ) -> Task[_T]: ...
+
+    def _on_task_done(self, task: Task[object]) -> None: ...
+    if sys.version_info >= (3, 15):
+        def cancel(self) -> None: ...

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

@@ -0,0 +1,315 @@
+import concurrent.futures
+import sys
+from _asyncio import (
+    Task as Task,
+    _enter_task as _enter_task,
+    _leave_task as _leave_task,
+    _register_task as _register_task,
+    _unregister_task as _unregister_task,
+)
+from collections.abc import AsyncIterator, Awaitable, Coroutine, Generator, Iterable, Iterator
+from typing import Any, Final, Literal, Protocol, TypeAlias, TypeVar, overload, type_check_only
+
+from . import _CoroutineLike
+from .events import AbstractEventLoop
+from .futures import Future
+
+if sys.version_info >= (3, 11):
+    from contextvars import Context
+
+# Keep asyncio.__all__ updated with any changes to __all__ here
+if sys.version_info >= (3, 12):
+    __all__ = (
+        "Task",
+        "create_task",
+        "FIRST_COMPLETED",
+        "FIRST_EXCEPTION",
+        "ALL_COMPLETED",
+        "wait",
+        "wait_for",
+        "as_completed",
+        "sleep",
+        "gather",
+        "shield",
+        "ensure_future",
+        "run_coroutine_threadsafe",
+        "current_task",
+        "all_tasks",
+        "create_eager_task_factory",
+        "eager_task_factory",
+        "_register_task",
+        "_unregister_task",
+        "_enter_task",
+        "_leave_task",
+    )
+else:
+    __all__ = (
+        "Task",
+        "create_task",
+        "FIRST_COMPLETED",
+        "FIRST_EXCEPTION",
+        "ALL_COMPLETED",
+        "wait",
+        "wait_for",
+        "as_completed",
+        "sleep",
+        "gather",
+        "shield",
+        "ensure_future",
+        "run_coroutine_threadsafe",
+        "current_task",
+        "all_tasks",
+        "_register_task",
+        "_unregister_task",
+        "_enter_task",
+        "_leave_task",
+    )
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_T3 = TypeVar("_T3")
+_T4 = TypeVar("_T4")
+_T5 = TypeVar("_T5")
+_T6 = TypeVar("_T6")
+_FT = TypeVar("_FT", bound=Future[Any])
+if sys.version_info >= (3, 12):
+    _FutureLike: TypeAlias = Future[_T] | Awaitable[_T]
+else:
+    _FutureLike: TypeAlias = Future[_T] | Generator[Any, None, _T] | Awaitable[_T]
+
+_TaskYieldType: TypeAlias = Future[object] | None
+
+FIRST_COMPLETED: Final = concurrent.futures.FIRST_COMPLETED
+FIRST_EXCEPTION: Final = concurrent.futures.FIRST_EXCEPTION
+ALL_COMPLETED: Final = concurrent.futures.ALL_COMPLETED
+
+if sys.version_info >= (3, 13):
+    @type_check_only
+    class _SyncAndAsyncIterator(Iterator[Coroutine[Any, Any, _T]], AsyncIterator[Future[_T]], Protocol[_T]): ...
+
+    def as_completed(fs: Iterable[_FutureLike[_T]], *, timeout: float | None = None) -> _SyncAndAsyncIterator[_T]: ...
+
+else:
+    def as_completed(fs: Iterable[_FutureLike[_T]], *, timeout: float | None = None) -> Iterator[Future[_T]]: ...
+
+@overload
+def ensure_future(coro_or_future: _FT, *, loop: AbstractEventLoop | None = None) -> _FT: ...  # type: ignore[overload-overlap]
+@overload
+def ensure_future(coro_or_future: Awaitable[_T], *, loop: AbstractEventLoop | None = None) -> Task[_T]: ...
+
+# `gather()` actually returns a list with length equal to the number
+# of tasks passed; however, Tuple is used similar to the annotation for
+# zip() because typing does not support variadic type variables.  See
+# typing PR #1550 for discussion.
+#
+# N.B. Having overlapping overloads is the only way to get acceptable type inference in all edge cases.
+@overload
+def gather(coro_or_future1: _FutureLike[_T1], /, *, return_exceptions: Literal[False] = False) -> Future[tuple[_T1]]: ...  # type: ignore[overload-overlap]
+@overload
+def gather(  # type: ignore[overload-overlap]
+    coro_or_future1: _FutureLike[_T1], coro_or_future2: _FutureLike[_T2], /, *, return_exceptions: Literal[False] = False
+) -> Future[tuple[_T1, _T2]]: ...
+@overload
+def gather(  # type: ignore[overload-overlap]
+    coro_or_future1: _FutureLike[_T1],
+    coro_or_future2: _FutureLike[_T2],
+    coro_or_future3: _FutureLike[_T3],
+    /,
+    *,
+    return_exceptions: Literal[False] = False,
+) -> Future[tuple[_T1, _T2, _T3]]: ...
+@overload
+def gather(  # type: ignore[overload-overlap]
+    coro_or_future1: _FutureLike[_T1],
+    coro_or_future2: _FutureLike[_T2],
+    coro_or_future3: _FutureLike[_T3],
+    coro_or_future4: _FutureLike[_T4],
+    /,
+    *,
+    return_exceptions: Literal[False] = False,
+) -> Future[tuple[_T1, _T2, _T3, _T4]]: ...
+@overload
+def gather(  # type: ignore[overload-overlap]
+    coro_or_future1: _FutureLike[_T1],
+    coro_or_future2: _FutureLike[_T2],
+    coro_or_future3: _FutureLike[_T3],
+    coro_or_future4: _FutureLike[_T4],
+    coro_or_future5: _FutureLike[_T5],
+    /,
+    *,
+    return_exceptions: Literal[False] = False,
+) -> Future[tuple[_T1, _T2, _T3, _T4, _T5]]: ...
+@overload
+def gather(  # type: ignore[overload-overlap]
+    coro_or_future1: _FutureLike[_T1],
+    coro_or_future2: _FutureLike[_T2],
+    coro_or_future3: _FutureLike[_T3],
+    coro_or_future4: _FutureLike[_T4],
+    coro_or_future5: _FutureLike[_T5],
+    coro_or_future6: _FutureLike[_T6],
+    /,
+    *,
+    return_exceptions: Literal[False] = False,
+) -> Future[tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...
+@overload
+def gather(*coros_or_futures: _FutureLike[_T], return_exceptions: Literal[False] = False) -> Future[list[_T]]: ...  # type: ignore[overload-overlap]
+@overload
+def gather(coro_or_future1: _FutureLike[_T1], /, *, return_exceptions: bool) -> Future[tuple[_T1 | BaseException]]: ...
+@overload
+def gather(
+    coro_or_future1: _FutureLike[_T1], coro_or_future2: _FutureLike[_T2], /, *, return_exceptions: bool
+) -> Future[tuple[_T1 | BaseException, _T2 | BaseException]]: ...
+@overload
+def gather(
+    coro_or_future1: _FutureLike[_T1],
+    coro_or_future2: _FutureLike[_T2],
+    coro_or_future3: _FutureLike[_T3],
+    /,
+    *,
+    return_exceptions: bool,
+) -> Future[tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException]]: ...
+@overload
+def gather(
+    coro_or_future1: _FutureLike[_T1],
+    coro_or_future2: _FutureLike[_T2],
+    coro_or_future3: _FutureLike[_T3],
+    coro_or_future4: _FutureLike[_T4],
+    /,
+    *,
+    return_exceptions: bool,
+) -> Future[tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException, _T4 | BaseException]]: ...
+@overload
+def gather(
+    coro_or_future1: _FutureLike[_T1],
+    coro_or_future2: _FutureLike[_T2],
+    coro_or_future3: _FutureLike[_T3],
+    coro_or_future4: _FutureLike[_T4],
+    coro_or_future5: _FutureLike[_T5],
+    /,
+    *,
+    return_exceptions: bool,
+) -> Future[tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException, _T4 | BaseException, _T5 | BaseException]]: ...
+@overload
+def gather(
+    coro_or_future1: _FutureLike[_T1],
+    coro_or_future2: _FutureLike[_T2],
+    coro_or_future3: _FutureLike[_T3],
+    coro_or_future4: _FutureLike[_T4],
+    coro_or_future5: _FutureLike[_T5],
+    coro_or_future6: _FutureLike[_T6],
+    /,
+    *,
+    return_exceptions: bool,
+) -> Future[
+    tuple[
+        _T1 | BaseException,
+        _T2 | BaseException,
+        _T3 | BaseException,
+        _T4 | BaseException,
+        _T5 | BaseException,
+        _T6 | BaseException,
+    ]
+]: ...
+@overload
+def gather(*coros_or_futures: _FutureLike[_T], return_exceptions: bool) -> Future[list[_T | BaseException]]: ...
+
+# unlike some asyncio apis, This does strict runtime checking of actually being a coroutine, not of any future-like.
+def run_coroutine_threadsafe(coro: Coroutine[Any, Any, _T], loop: AbstractEventLoop) -> concurrent.futures.Future[_T]: ...
+def shield(arg: _FutureLike[_T]) -> Future[_T]: ...
+
+@overload
+async def sleep(delay: float) -> None: ...
+@overload
+async def sleep(delay: float, result: _T) -> _T: ...
+
+async def wait_for(fut: _FutureLike[_T], timeout: float | None) -> _T: ...
+
+if sys.version_info >= (3, 11):
+    async def wait(
+        fs: Iterable[_FT], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
+    ) -> tuple[set[_FT], set[_FT]]: ...
+
+else:
+    @overload
+    async def wait(  # type: ignore[overload-overlap]
+        fs: Iterable[_FT], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
+    ) -> tuple[set[_FT], set[_FT]]: ...
+    @overload
+    async def wait(
+        fs: Iterable[Awaitable[_T]], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
+    ) -> tuple[set[Task[_T]], set[Task[_T]]]: ...
+
+if sys.version_info >= (3, 12):
+    _TaskCompatibleCoro: TypeAlias = Coroutine[Any, Any, _T_co]
+else:
+    _TaskCompatibleCoro: TypeAlias = Generator[_TaskYieldType, None, _T_co] | Coroutine[Any, Any, _T_co]
+
+def all_tasks(loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
+
+if sys.version_info >= (3, 14):
+    def create_task(
+        coro: _CoroutineLike[_T], *, name: str | None = None, context: Context | None = None, eager_start: bool | None = None
+    ) -> Task[_T]: ...
+
+elif sys.version_info >= (3, 11):
+    def create_task(coro: _CoroutineLike[_T], *, name: str | None = None, context: Context | None = None) -> Task[_T]: ...
+
+else:
+    def create_task(coro: _CoroutineLike[_T], *, name: str | None = None) -> Task[_T]: ...
+
+if sys.version_info >= (3, 12):
+    from _asyncio import current_task as current_task
+else:
+    def current_task(loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
+
+if sys.version_info >= (3, 14):
+    def eager_task_factory(
+        loop: AbstractEventLoop | None,
+        coro: _TaskCompatibleCoro[_T_co],
+        *,
+        name: str | None = None,
+        context: Context | None = None,
+        eager_start: bool = True,
+    ) -> Task[_T_co]: ...
+
+elif sys.version_info >= (3, 12):
+    def eager_task_factory(
+        loop: AbstractEventLoop | None,
+        coro: _TaskCompatibleCoro[_T_co],
+        *,
+        name: str | None = None,
+        context: Context | None = None,
+    ) -> Task[_T_co]: ...
+
+if sys.version_info >= (3, 12):
+    _TaskT_co = TypeVar("_TaskT_co", bound=Task[Any], covariant=True)
+
+    @type_check_only
+    class _CustomTaskConstructor(Protocol[_TaskT_co]):
+        def __call__(
+            self,
+            coro: _TaskCompatibleCoro[Any],
+            /,
+            *,
+            loop: AbstractEventLoop,
+            name: str | None,
+            context: Context | None,
+            eager_start: bool,
+        ) -> _TaskT_co: ...
+
+    @type_check_only
+    class _EagerTaskFactoryType(Protocol[_TaskT_co]):
+        def __call__(
+            self,
+            loop: AbstractEventLoop,
+            coro: _TaskCompatibleCoro[Any],
+            *,
+            name: str | None = None,
+            context: Context | None = None,
+        ) -> _TaskT_co: ...
+
+    def create_eager_task_factory(
+        custom_task_constructor: _CustomTaskConstructor[_TaskT_co],
+    ) -> _EagerTaskFactoryType[_TaskT_co]: ...

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

@@ -0,0 +1,9 @@
+from collections.abc import Callable
+from typing import ParamSpec, TypeVar
+
+# Keep asyncio.__all__ updated with any changes to __all__ here
+__all__ = ("to_thread",)
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+async def to_thread(func: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...

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

@@ -0,0 +1,20 @@
+from types import TracebackType
+from typing import final
+from typing_extensions import Self
+
+# Keep asyncio.__all__ updated with any changes to __all__ here
+__all__ = ("Timeout", "timeout", "timeout_at")
+
+@final
+class Timeout:
+    def __init__(self, when: float | None) -> None: ...
+    def when(self) -> float | None: ...
+    def reschedule(self, when: float | None) -> None: ...
+    def expired(self) -> bool: ...
+    async def __aenter__(self) -> Self: ...
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+
+def timeout(delay: float | None) -> Timeout: ...
+def timeout_at(when: float | None) -> Timeout: ...