basedpyright 1.13.2 → 1.13.3

package/dist/typeshed-fallback/stdlib/asyncio/futures.pyi

@@ -20,6 +20,20 @@ _T = TypeVar("_T")
 def isfuture(obj: object) -> TypeIs[Future[Any]]: ...
 
 class Future(Awaitable[_T], Iterable[_T]):
+    """
+    This class is *almost* compatible with concurrent.futures.Future.
+
+    Differences:
+
+    - result() and exception() do not take a timeout argument and
+      raise an exception when the future isn't done yet.
+
+    - Callbacks registered with add_done_callback() are always called
+      via the event loop's call_soon_threadsafe().
+
+    - This class is not compatible with the wait() and as_completed()
+      methods in the concurrent.futures package.
+    """
     _state: str
     @property
     def _exception(self) -> BaseException | None: ...
@@ -31,27 +45,105 @@ class Future(Awaitable[_T], Iterable[_T]):
     _asyncio_future_blocking: bool  # is a part of duck-typing contract for `Future`
     def __init__(self, *, loop: AbstractEventLoop | None = ...) -> None: ...
     def __del__(self) -> None: ...
-    def get_loop(self) -> AbstractEventLoop: ...
+    def get_loop(self) -> AbstractEventLoop:
+        """Return the event loop the Future is bound to."""
+        ...
     @property
     def _callbacks(self) -> list[tuple[Callable[[Self], Any], Context]]: ...
-    def add_done_callback(self, fn: Callable[[Self], object], /, *, context: Context | None = None) -> None: ...
+    def add_done_callback(self, fn: Callable[[Self], object], /, *, context: Context | None = None) -> None:
+        """
+        Add a callback to be run when the future becomes done.
+
+        The callback is called with a single argument - the future object. If
+        the future is already done when this is called, the callback is
+        scheduled with call_soon.
+        """
+        ...
     if sys.version_info >= (3, 9):
-        def cancel(self, msg: Any | None = None) -> bool: ...
+        def cancel(self, msg: Any | None = None) -> bool:
+            """
+            Cancel the future and schedule callbacks.
+
+            If the future is already done or cancelled, return False.  Otherwise,
+            change the future's state to cancelled, schedule the callbacks and
+            return True.
+            """
+            ...
     else:
-        def cancel(self) -> bool: ...
-
-    def cancelled(self) -> bool: ...
-    def done(self) -> bool: ...
-    def result(self) -> _T: ...
-    def exception(self) -> BaseException | None: ...
-    def remove_done_callback(self, fn: Callable[[Self], object], /) -> int: ...
-    def set_result(self, result: _T, /) -> None: ...
-    def set_exception(self, exception: type | BaseException, /) -> None: ...
-    def __iter__(self) -> Generator[Any, None, _T]: ...
-    def __await__(self) -> Generator[Any, None, _T]: ...
+        def cancel(self) -> bool:
+            """
+            Cancel the future and schedule callbacks.
+
+            If the future is already done or cancelled, return False.  Otherwise,
+            change the future's state to cancelled, schedule the callbacks and
+            return True.
+            """
+            ...
+
+    def cancelled(self) -> bool:
+        """Return True if the future was cancelled."""
+        ...
+    def done(self) -> bool:
+        """
+        Return True if the future is done.
+
+        Done means either that a result / exception are available, or that the
+        future was cancelled.
+        """
+        ...
+    def result(self) -> _T:
+        """
+        Return the result this future represents.
+
+        If the future has been cancelled, raises CancelledError.  If the
+        future's result isn't yet available, raises InvalidStateError.  If
+        the future is done and has an exception set, this exception is raised.
+        """
+        ...
+    def exception(self) -> BaseException | None:
+        """
+        Return the exception that was set on this future.
+
+        The exception (or None if no exception was set) is returned only if
+        the future is done.  If the future has been cancelled, raises
+        CancelledError.  If the future isn't done yet, raises
+        InvalidStateError.
+        """
+        ...
+    def remove_done_callback(self, fn: Callable[[Self], object], /) -> int:
+        """
+        Remove all instances of a callback from the "call when done" list.
+
+        Returns the number of callbacks removed.
+        """
+        ...
+    def set_result(self, result: _T, /) -> None:
+        """
+        Mark the future done and set its result.
+
+        If the future is already done when this method is called, raises
+        InvalidStateError.
+        """
+        ...
+    def set_exception(self, exception: type | BaseException, /) -> None:
+        """
+        Mark the future done and set an exception.
+
+        If the future is already done when this method is called, raises
+        InvalidStateError.
+        """
+        ...
+    def __iter__(self) -> Generator[Any, None, _T]:
+        """Implement iter(self)."""
+        ...
+    def __await__(self) -> Generator[Any, None, _T]:
+        """Return an iterator to be used in await expression."""
+        ...
     @property
     def _loop(self) -> AbstractEventLoop: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """See PEP 585"""
+            ...
 
 def wrap_future(future: _ConcurrentFuture[_T] | Future[_T], *, loop: AbstractEventLoop | None = None) -> Future[_T]: ...

package/dist/typeshed-fallback/stdlib/asyncio/locks.pyi

@@ -114,8 +114,14 @@ if sys.version_info >= (3, 11):
         async def abort(self) -> None: ...
         async def reset(self) -> None: ...
         @property
-        def parties(self) -> int: ...
+        def parties(self) -> int:
+            """Return the number of tasks required to trip the barrier."""
+            ...
         @property
-        def n_waiting(self) -> int: ...
+        def n_waiting(self) -> int:
+            """Return the number of tasks currently waiting at the barrier."""
+            ...
         @property
-        def broken(self) -> bool: ...
+        def broken(self) -> bool:
+            """Return True if the barrier is in a broken state."""
+            ...

package/dist/typeshed-fallback/stdlib/asyncio/queues.pyi

@@ -31,7 +31,9 @@ class Queue(Generic[_T], _LoopBoundMixin):  # noqa: Y059
     def _format(self) -> str: ...
     def qsize(self) -> int: ...
     @property
-    def maxsize(self) -> int: ...
+    def maxsize(self) -> int:
+        """Number of items allowed in the queue."""
+        ...
     def empty(self) -> bool: ...
     def full(self) -> bool: ...
     async def put(self, item: _T) -> None: ...
@@ -41,7 +43,13 @@ class Queue(Generic[_T], _LoopBoundMixin):  # noqa: Y059
     async def join(self) -> None: ...
     def task_done(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, type: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, type: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...
 
 class PriorityQueue(Queue[_T]): ...
 class LifoQueue(Queue[_T]): ...

package/dist/typeshed-fallback/stdlib/asyncio/sslproto.pyi

@@ -50,13 +50,32 @@ if sys.version_info < (3, 11):
         _shutdown_cb: Callable[[], None] | None
         def __init__(self, context: ssl.SSLContext, server_side: bool, server_hostname: str | None = None) -> None: ...
         @property
-        def context(self) -> ssl.SSLContext: ...
+        def context(self) -> ssl.SSLContext:
+            """The SSL context passed to the constructor."""
+            ...
         @property
-        def ssl_object(self) -> ssl.SSLObject | None: ...
+        def ssl_object(self) -> ssl.SSLObject | None:
+            """
+            The internal ssl.SSLObject instance.
+
+            Return None if the pipe is not wrapped.
+            """
+            ...
         @property
-        def need_ssldata(self) -> bool: ...
+        def need_ssldata(self) -> bool:
+            """
+            Whether more record level data is needed to complete a handshake
+            that is currently in progress.
+            """
+            ...
         @property
-        def wrapped(self) -> bool: ...
+        def wrapped(self) -> bool:
+            """
+            Whether a security layer is currently in effect.
+
+            Return False during handshake.
+            """
+            ...
         def do_handshake(self, callback: Callable[[BaseException | None], object] | None = None) -> list[bytes]: ...
         def shutdown(self, callback: Callable[[], object] | None = None) -> list[bytes]: ...
         def feed_eof(self) -> None: ...

package/dist/typeshed-fallback/stdlib/asyncio/tasks.pyi

@@ -405,6 +405,7 @@ else:
 # since the only reason why `asyncio.Future` is invariant is the `set_result()` method,
 # and `asyncio.Task.set_result()` always raises.
 class Task(Future[_T_co]):  # type: ignore[type-var]  # pyright: ignore[reportInvalidTypeArguments]
+    """A coroutine wrapped in a Future."""
     if sys.version_info >= (3, 12):
         def __init__(
             self,
@@ -435,18 +436,82 @@ class Task(Future[_T_co]):  # type: ignore[type-var]  # pyright: ignore[reportIn
     if sys.version_info >= (3, 12):
         def get_context(self) -> Context: ...
 
-    def get_stack(self, *, limit: int | None = None) -> list[FrameType]: ...
-    def print_stack(self, *, limit: int | None = None, file: TextIO | None = None) -> None: ...
+    def get_stack(self, *, limit: int | None = None) -> list[FrameType]:
+        """
+        Return the list of stack frames for this task's coroutine.
+
+        If the coroutine is not done, this returns the stack where it is
+        suspended.  If the coroutine has completed successfully or was
+        cancelled, this returns an empty list.  If the coroutine was
+        terminated by an exception, this returns the list of traceback
+        frames.
+
+        The frames are always ordered from oldest to newest.
+
+        The optional limit gives the maximum number of frames to
+        return; by default all available frames are returned.  Its
+        meaning differs depending on whether a stack or a traceback is
+        returned: the newest frames of a stack are returned, but the
+        oldest frames of a traceback are returned.  (This matches the
+        behavior of the traceback module.)
+
+        For reasons beyond our control, only one stack frame is
+        returned for a suspended coroutine.
+        """
+        ...
+    def print_stack(self, *, limit: int | None = None, file: TextIO | None = None) -> None:
+        """
+        Print the stack or traceback for this task's coroutine.
+
+        This produces output similar to that of the traceback module,
+        for the frames retrieved by get_stack().  The limit argument
+        is passed to get_stack().  The file argument is an I/O stream
+        to which the output is written; by default output is written
+        to sys.stderr.
+        """
+        ...
     if sys.version_info >= (3, 11):
-        def cancelling(self) -> int: ...
-        def uncancel(self) -> int: ...
+        def cancelling(self) -> int:
+            """
+            Return the count of the task's cancellation requests.
+
+            This count is incremented when .cancel() is called
+            and may be decremented using .uncancel().
+            """
+            ...
+        def uncancel(self) -> int:
+            """
+            Decrement the task's count of cancellation requests.
+
+            This should be used by tasks that catch CancelledError
+            and wish to continue indefinitely until they are cancelled again.
+
+            Returns the remaining number of cancellation requests.
+            """
+            ...
     if sys.version_info < (3, 9):
         @classmethod
-        def current_task(cls, loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
+        def current_task(cls, loop: AbstractEventLoop | None = None) -> Task[Any] | None:
+            """
+            Return the currently running task in an event loop or None.
+
+            By default the current task for the current event loop is returned.
+
+            None is returned when called not in the context of a Task.
+            """
+            ...
         @classmethod
-        def all_tasks(cls, loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
+        def all_tasks(cls, loop: AbstractEventLoop | None = None) -> set[Task[Any]]:
+            """
+            Return a set of all tasks for an event loop.
+
+            By default all tasks for the current event loop are returned.
+            """
+            ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """See PEP 585"""
+            ...
 
 def all_tasks(loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
 
@@ -456,9 +521,27 @@ if sys.version_info >= (3, 11):
 else:
     def create_task(coro: _CoroutineLike[_T], *, name: str | None = None) -> Task[_T]: ...
 
-def current_task(loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
-def _enter_task(loop: AbstractEventLoop, task: Task[Any]) -> None: ...
-def _leave_task(loop: AbstractEventLoop, task: Task[Any]) -> None: ...
+def current_task(loop: AbstractEventLoop | None = None) -> Task[Any] | None:
+    """Return a currently executed task."""
+    ...
+def _enter_task(loop: AbstractEventLoop, task: Task[Any]) -> None:
+    """
+    Enter into task execution or resume suspended task.
+
+    Task belongs to loop.
+
+    Returns None.
+    """
+    ...
+def _leave_task(loop: AbstractEventLoop, task: Task[Any]) -> None:
+    """
+    Leave task execution or suspend a task.
+
+    Task belongs to loop.
+
+    Returns None.
+    """
+    ...
 
 if sys.version_info >= (3, 12):
     _TaskT_co = TypeVar("_TaskT_co", bound=Task[Any], covariant=True)
@@ -496,5 +579,17 @@ if sys.version_info >= (3, 12):
         context: Context | None = None,
     ) -> Task[_T_co]: ...
 
-def _register_task(task: Task[Any]) -> None: ...
-def _unregister_task(task: Task[Any]) -> None: ...
+def _register_task(task: Task[Any]) -> None:
+    """
+    Register a new task in asyncio as executed by loop.
+
+    Returns None.
+    """
+    ...
+def _unregister_task(task: Task[Any]) -> None:
+    """
+    Unregister a task.
+
+    Returns None.
+    """
+    ...

package/dist/typeshed-fallback/stdlib/asyncio/windows_events.pyi

@@ -1,86 +1,86 @@
-import socket
-import sys
-from _typeshed import Incomplete, ReadableBuffer, WriteableBuffer
-from collections.abc import Callable
-from typing import IO, Any, ClassVar, Literal, NoReturn
-
-from . import events, futures, proactor_events, selector_events, streams, windows_utils
-
-if sys.platform == "win32":
-    __all__ = (
-        "SelectorEventLoop",
-        "ProactorEventLoop",
-        "IocpProactor",
-        "DefaultEventLoopPolicy",
-        "WindowsSelectorEventLoopPolicy",
-        "WindowsProactorEventLoopPolicy",
-    )
-
-    NULL: Literal[0]
-    INFINITE: Literal[0xFFFFFFFF]
-    ERROR_CONNECTION_REFUSED: Literal[1225]
-    ERROR_CONNECTION_ABORTED: Literal[1236]
-    CONNECT_PIPE_INIT_DELAY: float
-    CONNECT_PIPE_MAX_DELAY: float
-
-    class PipeServer:
-        def __init__(self, address: str) -> None: ...
-        def __del__(self) -> None: ...
-        def closed(self) -> bool: ...
-        def close(self) -> None: ...
-
-    class _WindowsSelectorEventLoop(selector_events.BaseSelectorEventLoop): ...
-
-    class ProactorEventLoop(proactor_events.BaseProactorEventLoop):
-        def __init__(self, proactor: IocpProactor | None = None) -> None: ...
-        async def create_pipe_connection(
-            self, protocol_factory: Callable[[], streams.StreamReaderProtocol], address: str
-        ) -> tuple[proactor_events._ProactorDuplexPipeTransport, streams.StreamReaderProtocol]: ...
-        async def start_serving_pipe(
-            self, protocol_factory: Callable[[], streams.StreamReaderProtocol], address: str
-        ) -> list[PipeServer]: ...
-
-    class IocpProactor:
-        def __init__(self, concurrency: int = 0xFFFFFFFF) -> None: ...
-        def __del__(self) -> None: ...
-        def set_loop(self, loop: events.AbstractEventLoop) -> None: ...
-        def select(self, timeout: int | None = None) -> list[futures.Future[Any]]: ...
-        def recv(self, conn: socket.socket, nbytes: int, flags: int = 0) -> futures.Future[bytes]: ...
-        def recv_into(self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0) -> futures.Future[Any]: ...
-        def recvfrom(
-            self, conn: socket.socket, nbytes: int, flags: int = 0
-        ) -> futures.Future[tuple[bytes, socket._RetAddress]]: ...
-        def sendto(
-            self, conn: socket.socket, buf: ReadableBuffer, flags: int = 0, addr: socket._Address | None = None
-        ) -> futures.Future[int]: ...
-        def send(self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0) -> futures.Future[Any]: ...
-        def accept(self, listener: socket.socket) -> futures.Future[Any]: ...
-        def connect(
-            self,
-            conn: socket.socket,
-            address: tuple[Incomplete, Incomplete] | tuple[Incomplete, Incomplete, Incomplete, Incomplete],
-        ) -> futures.Future[Any]: ...
-        def sendfile(self, sock: socket.socket, file: IO[bytes], offset: int, count: int) -> futures.Future[Any]: ...
-        def accept_pipe(self, pipe: socket.socket) -> futures.Future[Any]: ...
-        async def connect_pipe(self, address: str) -> windows_utils.PipeHandle: ...
-        def wait_for_handle(self, handle: windows_utils.PipeHandle, timeout: int | None = None) -> bool: ...
-        def close(self) -> None: ...
-        if sys.version_info >= (3, 11):
-            def recvfrom_into(
-                self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0
-            ) -> futures.Future[tuple[int, socket._RetAddress]]: ...
-
-    SelectorEventLoop = _WindowsSelectorEventLoop
-
-    class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
-        _loop_factory: ClassVar[type[SelectorEventLoop]]
-        if sys.version_info < (3, 14):
-            def get_child_watcher(self) -> NoReturn: ...
-            def set_child_watcher(self, watcher: Any) -> NoReturn: ...
-
-    class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
-        _loop_factory: ClassVar[type[ProactorEventLoop]]
-        def get_child_watcher(self) -> NoReturn: ...
-        def set_child_watcher(self, watcher: Any) -> NoReturn: ...
-
-    DefaultEventLoopPolicy = WindowsSelectorEventLoopPolicy
+import socket
+import sys
+from _typeshed import Incomplete, ReadableBuffer, WriteableBuffer
+from collections.abc import Callable
+from typing import IO, Any, ClassVar, Literal, NoReturn
+
+from . import events, futures, proactor_events, selector_events, streams, windows_utils
+
+if sys.platform == "win32":
+    __all__ = (
+        "SelectorEventLoop",
+        "ProactorEventLoop",
+        "IocpProactor",
+        "DefaultEventLoopPolicy",
+        "WindowsSelectorEventLoopPolicy",
+        "WindowsProactorEventLoopPolicy",
+    )
+
+    NULL: Literal[0]
+    INFINITE: Literal[0xFFFFFFFF]
+    ERROR_CONNECTION_REFUSED: Literal[1225]
+    ERROR_CONNECTION_ABORTED: Literal[1236]
+    CONNECT_PIPE_INIT_DELAY: float
+    CONNECT_PIPE_MAX_DELAY: float
+
+    class PipeServer:
+        def __init__(self, address: str) -> None: ...
+        def __del__(self) -> None: ...
+        def closed(self) -> bool: ...
+        def close(self) -> None: ...
+
+    class _WindowsSelectorEventLoop(selector_events.BaseSelectorEventLoop): ...
+
+    class ProactorEventLoop(proactor_events.BaseProactorEventLoop):
+        def __init__(self, proactor: IocpProactor | None = None) -> None: ...
+        async def create_pipe_connection(
+            self, protocol_factory: Callable[[], streams.StreamReaderProtocol], address: str
+        ) -> tuple[proactor_events._ProactorDuplexPipeTransport, streams.StreamReaderProtocol]: ...
+        async def start_serving_pipe(
+            self, protocol_factory: Callable[[], streams.StreamReaderProtocol], address: str
+        ) -> list[PipeServer]: ...
+
+    class IocpProactor:
+        def __init__(self, concurrency: int = 0xFFFFFFFF) -> None: ...
+        def __del__(self) -> None: ...
+        def set_loop(self, loop: events.AbstractEventLoop) -> None: ...
+        def select(self, timeout: int | None = None) -> list[futures.Future[Any]]: ...
+        def recv(self, conn: socket.socket, nbytes: int, flags: int = 0) -> futures.Future[bytes]: ...
+        def recv_into(self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0) -> futures.Future[Any]: ...
+        def recvfrom(
+            self, conn: socket.socket, nbytes: int, flags: int = 0
+        ) -> futures.Future[tuple[bytes, socket._RetAddress]]: ...
+        def sendto(
+            self, conn: socket.socket, buf: ReadableBuffer, flags: int = 0, addr: socket._Address | None = None
+        ) -> futures.Future[int]: ...
+        def send(self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0) -> futures.Future[Any]: ...
+        def accept(self, listener: socket.socket) -> futures.Future[Any]: ...
+        def connect(
+            self,
+            conn: socket.socket,
+            address: tuple[Incomplete, Incomplete] | tuple[Incomplete, Incomplete, Incomplete, Incomplete],
+        ) -> futures.Future[Any]: ...
+        def sendfile(self, sock: socket.socket, file: IO[bytes], offset: int, count: int) -> futures.Future[Any]: ...
+        def accept_pipe(self, pipe: socket.socket) -> futures.Future[Any]: ...
+        async def connect_pipe(self, address: str) -> windows_utils.PipeHandle: ...
+        def wait_for_handle(self, handle: windows_utils.PipeHandle, timeout: int | None = None) -> bool: ...
+        def close(self) -> None: ...
+        if sys.version_info >= (3, 11):
+            def recvfrom_into(
+                self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0
+            ) -> futures.Future[tuple[int, socket._RetAddress]]: ...
+
+    SelectorEventLoop = _WindowsSelectorEventLoop
+
+    class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+        _loop_factory: ClassVar[type[SelectorEventLoop]]
+        if sys.version_info < (3, 14):
+            def get_child_watcher(self) -> NoReturn: ...
+            def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+
+    class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+        _loop_factory: ClassVar[type[ProactorEventLoop]]
+        def get_child_watcher(self) -> NoReturn: ...
+        def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+
+    DefaultEventLoopPolicy = WindowsSelectorEventLoopPolicy

package/dist/typeshed-fallback/stdlib/asyncio/windows_utils.pyi

@@ -1,49 +1,49 @@
-import subprocess
-import sys
-from collections.abc import Callable
-from types import TracebackType
-from typing import Any, AnyStr, Literal
-from typing_extensions import Self
-
-if sys.platform == "win32":
-    __all__ = ("pipe", "Popen", "PIPE", "PipeHandle")
-
-    BUFSIZE: Literal[8192]
-    PIPE = subprocess.PIPE
-    STDOUT = subprocess.STDOUT
-    def pipe(*, duplex: bool = False, overlapped: tuple[bool, bool] = (True, True), bufsize: int = 8192) -> tuple[int, int]: ...
-
-    class PipeHandle:
-        def __init__(self, handle: int) -> None: ...
-        def __del__(self) -> None: ...
-        def __enter__(self) -> Self: ...
-        def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
-        @property
-        def handle(self) -> int: ...
-        def fileno(self) -> int: ...
-        def close(self, *, CloseHandle: Callable[[int], object] = ...) -> None: ...
-
-    class Popen(subprocess.Popen[AnyStr]):
-        stdin: PipeHandle | None  # type: ignore[assignment]
-        stdout: PipeHandle | None  # type: ignore[assignment]
-        stderr: PipeHandle | None  # type: ignore[assignment]
-        # For simplicity we omit the full overloaded __new__ signature of
-        # subprocess.Popen. The arguments are mostly the same, but
-        # subprocess.Popen takes other positional-or-keyword arguments before
-        # stdin.
-        def __new__(
-            cls,
-            args: subprocess._CMD,
-            stdin: subprocess._FILE | None = ...,
-            stdout: subprocess._FILE | None = ...,
-            stderr: subprocess._FILE | None = ...,
-            **kwds: Any,
-        ) -> Self: ...
-        def __init__(
-            self,
-            args: subprocess._CMD,
-            stdin: subprocess._FILE | None = None,
-            stdout: subprocess._FILE | None = None,
-            stderr: subprocess._FILE | None = None,
-            **kwds: Any,
-        ) -> None: ...
+import subprocess
+import sys
+from collections.abc import Callable
+from types import TracebackType
+from typing import Any, AnyStr, Literal
+from typing_extensions import Self
+
+if sys.platform == "win32":
+    __all__ = ("pipe", "Popen", "PIPE", "PipeHandle")
+
+    BUFSIZE: Literal[8192]
+    PIPE = subprocess.PIPE
+    STDOUT = subprocess.STDOUT
+    def pipe(*, duplex: bool = False, overlapped: tuple[bool, bool] = (True, True), bufsize: int = 8192) -> tuple[int, int]: ...
+
+    class PipeHandle:
+        def __init__(self, handle: int) -> None: ...
+        def __del__(self) -> None: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
+        @property
+        def handle(self) -> int: ...
+        def fileno(self) -> int: ...
+        def close(self, *, CloseHandle: Callable[[int], object] = ...) -> None: ...
+
+    class Popen(subprocess.Popen[AnyStr]):
+        stdin: PipeHandle | None  # type: ignore[assignment]
+        stdout: PipeHandle | None  # type: ignore[assignment]
+        stderr: PipeHandle | None  # type: ignore[assignment]
+        # For simplicity we omit the full overloaded __new__ signature of
+        # subprocess.Popen. The arguments are mostly the same, but
+        # subprocess.Popen takes other positional-or-keyword arguments before
+        # stdin.
+        def __new__(
+            cls,
+            args: subprocess._CMD,
+            stdin: subprocess._FILE | None = ...,
+            stdout: subprocess._FILE | None = ...,
+            stderr: subprocess._FILE | None = ...,
+            **kwds: Any,
+        ) -> Self: ...
+        def __init__(
+            self,
+            args: subprocess._CMD,
+            stdin: subprocess._FILE | None = None,
+            stdout: subprocess._FILE | None = None,
+            stderr: subprocess._FILE | None = None,
+            **kwds: Any,
+        ) -> None: ...