Update stubs for upstream updates we haven't taken yet: lowlevel.open…

…_process(), nursery.start(run_process, ...), run(strict_exception_groups=...), DTLS

trio-stubs/__init__.pyi

@@ -183,6 +183,7 @@ def run(
     clock: Optional[trio.abc.Clock] = ...,
     instruments: Sequence[trio.abc.Instrument] = ...,
     restrict_keyboard_interrupt_to_checkpoints: bool = ...,
+    strict_exception_groups: bool = ...,
 ) -> T: ...
 
 # _timeouts
@@ -336,6 +337,53 @@ class SocketListener(trio.abc.Listener[SocketStream]):
     async def accept(self) -> SocketStream: ...
     async def aclose(self) -> None: ...
 
+# _dtls
+class DTLSEndpoint:
+    socket: trio.socket.SocketType
+    incoming_packets_buffer: int
+    def __init__(self, socket: trio.socket.SocketType, *, incoming_packets_buffer: int = ...) -> None: ...
+    # ssl_context is an OpenSSL.SSL.Context from PyOpenSSL, but we can't
+    # import that name because we don't depend on PyOpenSSL
+    def connect(self, address: address: Union[Tuple[Any, ...], str, bytes], ssl_context: Any) -> DTLSChannel: ...
+    @takes_callable_and_args
+    async def serve(
+        self,
+        ssl_context: Any,
+        async_fn: Union[
+            Callable[..., Awaitable[Any]],
+            Callable[[DTLSChannel, VarArg()], Awaitable[Any]],
+        ],
+        *args: Any,
+        task_status: TaskStatus[None] = ...,
+    ) -> NoReturn: ...
+    def close(self) -> None: ...
+    def __enter__(self) -> DTLSEndpoint: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None: ...
+
+class DTLSChannel(_NotConstructible, trio.abc.Channel[bytes]):
+    endpoint: DTLSEndpoint
+    peer_address: Union[Tuple[Any, ...], str, bytes]
+    async def do_handshake(self, *, initial_retransmit_timeout: float = ...) -> None: ...
+    async def send(self, data: bytes) -> None: ...
+    async def receive(self) -> bytes: ...
+    def set_ciphertext_mtu(self, new_mtu: int) -> None: ...
+    def get_cleartext_mtu(self) -> int: ...
+    def statistics(self) -> Any: ...
+    async def aclose(self) -> None: ...
+    def close(self) -> None: ...
+    def __enter__(self) -> DTLSChannel: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None: ...
+
 # _file_io
 
 # The actual Trio I/O classes use metaprogramming to forward their methods
@@ -697,7 +745,7 @@ class _HasFileno(Protocol):
 
 _Redirect = Union[int, _HasFileno, None]
 
-class Process(trio.abc.AsyncResource, _NotConstructible, metaclass=ABCMeta):
+class Process(_NotConstructible, metaclass=ABCMeta):
     stdin: Optional[trio.abc.SendStream]
     stdout: Optional[trio.abc.ReceiveStream]
     stderr: Optional[trio.abc.ReceiveStream]
@@ -706,7 +754,6 @@ class Process(trio.abc.AsyncResource, _NotConstructible, metaclass=ABCMeta):
     pid: int
     @property
     def returncode(self) -> Optional[int]: ...
-    async def aclose(self) -> None: ...
     async def wait(self) -> int: ...
     def poll(self) -> Optional[int]: ...
     def send_signal(self, sig: signal.Signals) -> None: ...
@@ -725,22 +772,10 @@ class Process(trio.abc.AsyncResource, _NotConstructible, metaclass=ABCMeta):
 #   bytes as stdin
 
 if sys.platform == "win32":
-    async def open_process(
-        command: Union[StrOrBytesPath, Sequence[StrOrBytesPath]],
-        *,
-        stdin: _Redirect = ...,
-        stdout: _Redirect = ...,
-        stderr: _Redirect = ...,
-        close_fds: bool = ...,
-        shell: bool = ...,
-        cwd: Optional[StrOrBytesPath] = ...,
-        env: Optional[Mapping[str, str]] = ...,
-        startupinfo: subprocess.STARTUPINFO = ...,
-        creationflags: int = ...,
-    ) -> Process: ...
     async def run_process(
         command: Union[StrOrBytesPath, Sequence[StrOrBytesPath]],
         *,
+        task_status: TaskStatus[Process] = ...,
         stdin: Union[bytes, _Redirect] = ...,
         capture_stdout: bool = ...,
         capture_stderr: bool = ...,
@@ -757,42 +792,11 @@ if sys.platform == "win32":
     ) -> subprocess.CompletedProcess[bytes]: ...
 
 else:
-    @overload
-    async def open_process(
-        command: StrOrBytesPath,
-        *,
-        stdin: _Redirect = ...,
-        stdout: _Redirect = ...,
-        stderr: _Redirect = ...,
-        close_fds: bool = ...,
-        shell: Literal[True],
-        cwd: Optional[StrOrBytesPath] = ...,
-        env: Optional[Mapping[str, str]] = ...,
-        preexec_fn: Optional[Callable[[], Any]] = ...,
-        restore_signals: bool = ...,
-        start_new_session: bool = ...,
-        pass_fds: Sequence[int] = ...,
-    ) -> Process: ...
-    @overload
-    async def open_process(
-        command: Sequence[StrOrBytesPath],
-        *,
-        stdin: _Redirect = ...,
-        stdout: _Redirect = ...,
-        stderr: _Redirect = ...,
-        close_fds: bool = ...,
-        shell: bool = ...,
-        cwd: Optional[StrOrBytesPath] = ...,
-        env: Optional[Mapping[str, str]] = ...,
-        preexec_fn: Optional[Callable[[], Any]] = ...,
-        restore_signals: bool = ...,
-        start_new_session: bool = ...,
-        pass_fds: Sequence[int] = ...,
-    ) -> Process: ...
     @overload
     async def run_process(
         command: StrOrBytesPath,
         *,
+        task_status: TaskStatus[Process] = ...,
         stdin: Union[bytes, _Redirect] = ...,
         capture_stdout: bool = ...,
         capture_stderr: bool = ...,
@@ -813,6 +817,7 @@ else:
     async def run_process(
         command: Sequence[StrOrBytesPath],
         *,
+        task_status: TaskStatus[Process] = ...,
         stdin: Union[bytes, _Redirect] = ...,
         capture_stdout: bool = ...,
         capture_stderr: bool = ...,

trio-stubs/lowlevel.pyi

@@ -165,6 +165,68 @@ def start_thread_soon(
     fn: Callable[[], T], deliver: Callable[[outcome.Outcome[T]], None]
 ) -> None: ...
 
+# _subprocess
+
+# There's a lot of duplication here because mypy doesn't
+# have a good way to represent overloads that differ only
+# slightly. A cheat sheet:
+# - on Windows, command is Union[str, Sequence[str]];
+#   on Unix, command is str if shell=True and Sequence[str] otherwise
+# - on Windows, there are startupinfo and creationflags options;
+#   on Unix, there are preexec_fn, restore_signals, start_new_session, and pass_fds
+# - run_process() has the signature of open_process() plus arguments
+#   capture_stdout, capture_stderr, check, deliver_cancel, and the ability to pass
+#   bytes as stdin
+
+if sys.platform == "win32":
+    async def open_process(
+        command: Union[StrOrBytesPath, Sequence[StrOrBytesPath]],
+        *,
+        stdin: _Redirect = ...,
+        stdout: _Redirect = ...,
+        stderr: _Redirect = ...,
+        close_fds: bool = ...,
+        shell: bool = ...,
+        cwd: Optional[StrOrBytesPath] = ...,
+        env: Optional[Mapping[str, str]] = ...,
+        startupinfo: subprocess.STARTUPINFO = ...,
+        creationflags: int = ...,
+    ) -> Process: ...
+
+else:
+    @overload
+    async def open_process(
+        command: StrOrBytesPath,
+        *,
+        stdin: _Redirect = ...,
+        stdout: _Redirect = ...,
+        stderr: _Redirect = ...,
+        close_fds: bool = ...,
+        shell: Literal[True],
+        cwd: Optional[StrOrBytesPath] = ...,
+        env: Optional[Mapping[str, str]] = ...,
+        preexec_fn: Optional[Callable[[], Any]] = ...,
+        restore_signals: bool = ...,
+        start_new_session: bool = ...,
+        pass_fds: Sequence[int] = ...,
+    ) -> Process: ...
+    @overload
+    async def open_process(
+        command: Sequence[StrOrBytesPath],
+        *,
+        stdin: _Redirect = ...,
+        stdout: _Redirect = ...,
+        stderr: _Redirect = ...,
+        close_fds: bool = ...,
+        shell: bool = ...,
+        cwd: Optional[StrOrBytesPath] = ...,
+        env: Optional[Mapping[str, str]] = ...,
+        preexec_fn: Optional[Callable[[], Any]] = ...,
+        restore_signals: bool = ...,
+        start_new_session: bool = ...,
+        pass_fds: Sequence[int] = ...,
+    ) -> Process: ...
+
 # _unix_pipes
 class FdStream(trio.abc.Stream):
     def __init__(self, fd: int): ...