jaclang 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/subprocess.pyi

@@ -0,0 +1,2638 @@
+import sys
+from _typeshed import ReadableBuffer, StrOrBytesPath
+from collections.abc import Callable, Collection, Iterable, Mapping, Sequence
+from types import TracebackType
+from typing import IO, Any, AnyStr, Generic, Literal, TypeVar, overload
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = [
+    "Popen",
+    "PIPE",
+    "STDOUT",
+    "call",
+    "check_call",
+    "getstatusoutput",
+    "getoutput",
+    "check_output",
+    "run",
+    "CalledProcessError",
+    "DEVNULL",
+    "SubprocessError",
+    "TimeoutExpired",
+    "CompletedProcess",
+]
+
+if sys.platform == "win32":
+    __all__ += [
+        "CREATE_NEW_CONSOLE",
+        "CREATE_NEW_PROCESS_GROUP",
+        "STARTF_USESHOWWINDOW",
+        "STARTF_USESTDHANDLES",
+        "STARTUPINFO",
+        "STD_ERROR_HANDLE",
+        "STD_INPUT_HANDLE",
+        "STD_OUTPUT_HANDLE",
+        "SW_HIDE",
+        "ABOVE_NORMAL_PRIORITY_CLASS",
+        "BELOW_NORMAL_PRIORITY_CLASS",
+        "CREATE_BREAKAWAY_FROM_JOB",
+        "CREATE_DEFAULT_ERROR_MODE",
+        "CREATE_NO_WINDOW",
+        "DETACHED_PROCESS",
+        "HIGH_PRIORITY_CLASS",
+        "IDLE_PRIORITY_CLASS",
+        "NORMAL_PRIORITY_CLASS",
+        "REALTIME_PRIORITY_CLASS",
+    ]
+
+# We prefer to annotate inputs to methods (eg subprocess.check_call) with these
+# union types.
+# For outputs we use laborious literal based overloads to try to determine
+# which specific return types to use, and prefer to fall back to Any when
+# this does not work, so the caller does not have to use an assertion to confirm
+# which type.
+#
+# For example:
+#
+# try:
+#    x = subprocess.check_output(["ls", "-l"])
+#    reveal_type(x)  # bytes, based on the overloads
+# except TimeoutError as e:
+#    reveal_type(e.cmd)  # Any, but morally is _CMD
+_FILE: TypeAlias = None | int | IO[Any]
+_InputString: TypeAlias = ReadableBuffer | str
+_CMD: TypeAlias = StrOrBytesPath | Sequence[StrOrBytesPath]
+if sys.platform == "win32":
+    _ENV: TypeAlias = Mapping[str, str]
+else:
+    _ENV: TypeAlias = Mapping[bytes, StrOrBytesPath] | Mapping[str, StrOrBytesPath]
+
+_T = TypeVar("_T")
+
+# These two are private but documented
+if sys.version_info >= (3, 11):
+    _USE_VFORK: bool
+_USE_POSIX_SPAWN: bool
+
+class CompletedProcess(Generic[_T]):
+    # morally: _CMD
+    args: Any
+    returncode: int
+    # These can both be None, but requiring checks for None would be tedious
+    # and writing all the overloads would be horrific.
+    stdout: _T
+    stderr: _T
+    def __init__(
+        self,
+        args: _CMD,
+        returncode: int,
+        stdout: _T | None = None,
+        stderr: _T | None = None,
+    ) -> None: ...
+    def check_returncode(self) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+if sys.version_info >= (3, 11):
+    # 3.11 adds "process_group" argument
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: str | None = None,
+        text: Literal[True],
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str,
+        errors: str | None = None,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        *,
+        universal_newlines: Literal[True],
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        # where the *real* keyword only args start
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: Literal[False] | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: None = None,
+        errors: None = None,
+        input: ReadableBuffer | None = None,
+        text: Literal[False] | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> CompletedProcess[bytes]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: _InputString | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> CompletedProcess[Any]: ...
+
+elif sys.version_info >= (3, 10):
+    # 3.10 adds "pipesize" argument
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: str | None = None,
+        text: Literal[True],
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str,
+        errors: str | None = None,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        *,
+        universal_newlines: Literal[True],
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        # where the *real* keyword only args start
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: Literal[False] | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: None = None,
+        errors: None = None,
+        input: ReadableBuffer | None = None,
+        text: Literal[False] | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> CompletedProcess[bytes]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: _InputString | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> CompletedProcess[Any]: ...
+
+elif sys.version_info >= (3, 9):
+    # 3.9 adds arguments "user", "group", "extra_groups" and "umask"
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: str | None = None,
+        text: Literal[True],
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str,
+        errors: str | None = None,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        *,
+        universal_newlines: Literal[True],
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        # where the *real* keyword only args start
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: Literal[False] | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: None = None,
+        errors: None = None,
+        input: ReadableBuffer | None = None,
+        text: Literal[False] | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> CompletedProcess[bytes]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: _InputString | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> CompletedProcess[Any]: ...
+
+else:
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: str | None = None,
+        text: Literal[True],
+        timeout: float | None = None,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str,
+        errors: str | None = None,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        *,
+        universal_newlines: Literal[True],
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        # where the *real* keyword only args start
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: str | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+    ) -> CompletedProcess[str]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: Literal[False] | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: None = None,
+        errors: None = None,
+        input: ReadableBuffer | None = None,
+        text: Literal[False] | None = None,
+        timeout: float | None = None,
+    ) -> CompletedProcess[bytes]: ...
+    @overload
+    def run(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        capture_output: bool = False,
+        check: bool = False,
+        encoding: str | None = None,
+        errors: str | None = None,
+        input: _InputString | None = None,
+        text: bool | None = None,
+        timeout: float | None = None,
+    ) -> CompletedProcess[Any]: ...
+
+# Same args as Popen.__init__
+if sys.version_info >= (3, 11):
+    # 3.11 adds "process_group" argument
+    def call(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> int: ...
+
+elif sys.version_info >= (3, 10):
+    # 3.10 adds "pipesize" argument
+    def call(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> int: ...
+
+elif sys.version_info >= (3, 9):
+    # 3.9 adds arguments "user", "group", "extra_groups" and "umask"
+    def call(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> int: ...
+
+else:
+    def call(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        text: bool | None = None,
+    ) -> int: ...
+
+# Same args as Popen.__init__
+if sys.version_info >= (3, 11):
+    # 3.11 adds "process_group" argument
+    def check_call(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        timeout: float | None = ...,
+        *,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> int: ...
+
+elif sys.version_info >= (3, 10):
+    # 3.10 adds "pipesize" argument
+    def check_call(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        timeout: float | None = ...,
+        *,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> int: ...
+
+elif sys.version_info >= (3, 9):
+    # 3.9 adds arguments "user", "group", "extra_groups" and "umask"
+    def check_call(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        timeout: float | None = ...,
+        *,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> int: ...
+
+else:
+    def check_call(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        timeout: float | None = ...,
+        *,
+        text: bool | None = None,
+    ) -> int: ...
+
+if sys.version_info >= (3, 11):
+    # 3.11 adds "process_group" argument
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: Literal[True],
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str,
+        errors: str | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        *,
+        universal_newlines: Literal[True],
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        # where the real keyword only ones start
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: Literal[False] | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> bytes: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+        process_group: int | None = None,
+    ) -> Any: ...  # morally: -> str | bytes
+
+elif sys.version_info >= (3, 10):
+    # 3.10 adds "pipesize" argument
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: Literal[True],
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str,
+        errors: str | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        *,
+        universal_newlines: Literal[True],
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        # where the real keyword only ones start
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: Literal[False] | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> bytes: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> Any: ...  # morally: -> str | bytes
+
+elif sys.version_info >= (3, 9):
+    # 3.9 adds arguments "user", "group", "extra_groups" and "umask"
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: Literal[True],
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str,
+        errors: str | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        *,
+        universal_newlines: Literal[True],
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        # where the real keyword only ones start
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: Literal[False] | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> bytes: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+    ) -> Any: ...  # morally: -> str | bytes
+
+else:
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: Literal[True],
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str,
+        errors: str | None = None,
+        text: bool | None = None,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str,
+        text: bool | None = None,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        *,
+        universal_newlines: Literal[True],
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        # where the real keyword only ones start
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: bool | None = None,
+    ) -> str: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: Literal[False] | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+    ) -> bytes: ...
+    @overload
+    def check_output(
+        args: _CMD,
+        bufsize: int = -1,
+        executable: StrOrBytesPath | None = None,
+        stdin: _FILE = None,
+        stderr: _FILE = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        shell: bool = False,
+        cwd: StrOrBytesPath | None = None,
+        env: _ENV | None = None,
+        universal_newlines: bool | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        *,
+        timeout: float | None = None,
+        input: _InputString | None = ...,
+        encoding: str | None = None,
+        errors: str | None = None,
+        text: bool | None = None,
+    ) -> Any: ...  # morally: -> str | bytes
+
+PIPE: int
+STDOUT: int
+DEVNULL: int
+
+class SubprocessError(Exception): ...
+
+class TimeoutExpired(SubprocessError):
+    def __init__(
+        self,
+        cmd: _CMD,
+        timeout: float,
+        output: str | bytes | None = None,
+        stderr: str | bytes | None = None,
+    ) -> None: ...
+    # morally: _CMD
+    cmd: Any
+    timeout: float
+    # morally: str | bytes | None
+    output: Any
+    stdout: bytes | None
+    stderr: bytes | None
+
+class CalledProcessError(SubprocessError):
+    returncode: int
+    # morally: _CMD
+    cmd: Any
+    # morally: str | bytes | None
+    output: Any
+
+    # morally: str | bytes | None
+    stdout: Any
+    stderr: Any
+    def __init__(
+        self,
+        returncode: int,
+        cmd: _CMD,
+        output: str | bytes | None = None,
+        stderr: str | bytes | None = None,
+    ) -> None: ...
+
+class Popen(Generic[AnyStr]):
+    args: _CMD
+    stdin: IO[AnyStr] | None
+    stdout: IO[AnyStr] | None
+    stderr: IO[AnyStr] | None
+    pid: int
+    returncode: int | Any
+    universal_newlines: bool
+
+    if sys.version_info >= (3, 11):
+        # process_group is added in 3.11
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+            process_group: int | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+            process_group: int | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            *,
+            universal_newlines: Literal[True],
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            # where the *real* keyword only args start
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+            process_group: int | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: Literal[True],
+            encoding: str | None = None,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+            process_group: int | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[bytes],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: Literal[False] | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: Literal[False] | None = None,
+            encoding: None = None,
+            errors: None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+            process_group: int | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[Any],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+            process_group: int | None = None,
+        ) -> None: ...
+    elif sys.version_info >= (3, 10):
+        # pipesize is added in 3.10
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            *,
+            universal_newlines: Literal[True],
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            # where the *real* keyword only args start
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: Literal[True],
+            encoding: str | None = None,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[bytes],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: Literal[False] | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: Literal[False] | None = None,
+            encoding: None = None,
+            errors: None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[Any],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+            pipesize: int = -1,
+        ) -> None: ...
+    elif sys.version_info >= (3, 9):
+        # user, group, extra_groups, umask were added in 3.9
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            *,
+            universal_newlines: Literal[True],
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            # where the *real* keyword only args start
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: Literal[True],
+            encoding: str | None = None,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[bytes],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: Literal[False] | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: Literal[False] | None = None,
+            encoding: None = None,
+            errors: None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[Any],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str,
+            errors: str | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            *,
+            universal_newlines: Literal[True],
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            # where the *real* keyword only args start
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[str],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: Literal[True],
+            encoding: str | None = None,
+            errors: str | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[bytes],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: Literal[False] | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: Literal[False] | None = None,
+            encoding: None = None,
+            errors: None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: Popen[Any],
+            args: _CMD,
+            bufsize: int = -1,
+            executable: StrOrBytesPath | None = None,
+            stdin: _FILE | None = None,
+            stdout: _FILE | None = None,
+            stderr: _FILE | None = None,
+            preexec_fn: Callable[[], Any] | None = None,
+            close_fds: bool = True,
+            shell: bool = False,
+            cwd: StrOrBytesPath | None = None,
+            env: _ENV | None = None,
+            universal_newlines: bool | None = None,
+            startupinfo: Any | None = None,
+            creationflags: int = 0,
+            restore_signals: bool = True,
+            start_new_session: bool = False,
+            pass_fds: Collection[int] = (),
+            *,
+            text: bool | None = None,
+            encoding: str | None = None,
+            errors: str | None = None,
+        ) -> None: ...
+
+    def poll(self) -> int | None: ...
+    def wait(self, timeout: float | None = None) -> int: ...
+    # morally the members of the returned tuple should be optional
+    # TODO this should allow ReadableBuffer for Popen[bytes], but adding
+    # overloads for that runs into a mypy bug (python/mypy#14070).
+    def communicate(
+        self, input: AnyStr | None = None, timeout: float | None = None
+    ) -> tuple[AnyStr, AnyStr]: ...
+    def send_signal(self, sig: int) -> None: ...
+    def terminate(self) -> None: ...
+    def kill(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None: ...
+    def __del__(self) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+# The result really is always a str.
+if sys.version_info >= (3, 11):
+    def getstatusoutput(
+        cmd: str | bytes, *, encoding: str | None = None, errors: str | None = None
+    ) -> tuple[int, str]: ...
+    def getoutput(
+        cmd: str | bytes, *, encoding: str | None = None, errors: str | None = None
+    ) -> str: ...
+
+else:
+    def getstatusoutput(cmd: str | bytes) -> tuple[int, str]: ...
+    def getoutput(cmd: str | bytes) -> str: ...
+
+def list2cmdline(seq: Iterable[StrOrBytesPath]) -> str: ...  # undocumented
+
+if sys.platform == "win32":
+    class STARTUPINFO:
+        def __init__(
+            self,
+            *,
+            dwFlags: int = 0,
+            hStdInput: Any | None = None,
+            hStdOutput: Any | None = None,
+            hStdError: Any | None = None,
+            wShowWindow: int = 0,
+            lpAttributeList: Mapping[str, Any] | None = None,
+        ) -> None: ...
+        dwFlags: int
+        hStdInput: Any | None
+        hStdOutput: Any | None
+        hStdError: Any | None
+        wShowWindow: int
+        lpAttributeList: Mapping[str, Any]
+        def copy(self) -> STARTUPINFO: ...
+
+    from _winapi import (
+        ABOVE_NORMAL_PRIORITY_CLASS as ABOVE_NORMAL_PRIORITY_CLASS,
+        BELOW_NORMAL_PRIORITY_CLASS as BELOW_NORMAL_PRIORITY_CLASS,
+        CREATE_BREAKAWAY_FROM_JOB as CREATE_BREAKAWAY_FROM_JOB,
+        CREATE_DEFAULT_ERROR_MODE as CREATE_DEFAULT_ERROR_MODE,
+        CREATE_NEW_CONSOLE as CREATE_NEW_CONSOLE,
+        CREATE_NEW_PROCESS_GROUP as CREATE_NEW_PROCESS_GROUP,
+        CREATE_NO_WINDOW as CREATE_NO_WINDOW,
+        DETACHED_PROCESS as DETACHED_PROCESS,
+        HIGH_PRIORITY_CLASS as HIGH_PRIORITY_CLASS,
+        IDLE_PRIORITY_CLASS as IDLE_PRIORITY_CLASS,
+        NORMAL_PRIORITY_CLASS as NORMAL_PRIORITY_CLASS,
+        REALTIME_PRIORITY_CLASS as REALTIME_PRIORITY_CLASS,
+        STARTF_USESHOWWINDOW as STARTF_USESHOWWINDOW,
+        STARTF_USESTDHANDLES as STARTF_USESTDHANDLES,
+        STD_ERROR_HANDLE as STD_ERROR_HANDLE,
+        STD_INPUT_HANDLE as STD_INPUT_HANDLE,
+        STD_OUTPUT_HANDLE as STD_OUTPUT_HANDLE,
+        SW_HIDE as SW_HIDE,
+    )