vKg%SSKJr SSKrSSKrSSKrSSKrSSKrSSKJr SSKJ r SSK J r J r J r JrJrJr SSKrSSKJrJr SSKJr SS KJrJrJr SS KJr SS KJrJr \ (a$SSK r SS K!J"r"J#r#J$r$J%r% SS K&J'r' SSK(J)r) SSK*J+r+J,r, \RZS:a)\\.\/\R`\.\R`\/4r1S\2S'O\\.\/SS4r1S\2S'S\2S'\ (aSS'jrDS>S(jrES)SSSS\RS*.S?S+jjrG\ (Gak\RpS,:XafSSSSSSSSSS-. S@S.jjrH\RSSSSSSSSSSSSSS/.SAS0jjrIg\SSSSSSSSSS1S2. SBS3jj5rH\SSSSSSSSSSS1S4. SCS5jj5rH\\RSSSSSSSSSSSSSS1S6.SDS7jj5rI\\RSSSSSSSSSSSSSSS1S8.SES9jj5rIg\CrHS:=\HlJ\HlK\GrIS;=\IlJ\IlKg!\7a \RpS:XalSSK9r9\9Rt"SSS9r;\9Rx\;Rzl>\9Rx\9Rx\9Rx/\;Rzl?Sr@S) returncoder\r^)r@rdstatuss r(__repr__Process.__repr__s[__  ( 3FA~. {m<.zl; }Bvha88r*c`URR5nUbUR5 U$)a?The exit status of the process (an integer), or ``None`` if it's still running. By convention, a return code of zero indicates success. On UNIX, negative values indicate termination due to a signal, e.g., -11 if terminated by signal 11 (``SIGSEGV``). On Windows, a process that exits due to a call to :meth:`Process.terminate` will have an exit status of 1. Unlike the standard library `subprocess.Popen.returncode`, you don't have to call `poll` or `wait` to update this attribute; it's automatically updated as needed, and will always give you the latest information. )rUpoll _close_pidfd)r@r9s r(rdProcess.returncodes+""       r*cURbY[RRURR 55 URR 5 SUlggr$)r[triolowlevelnotify_closingrAcloser?s r(rjProcess._close_pidfdsG ;; " MM ( (););)= > KK   DK #r*c# URIShvN UR5cURbc[R"[ 5 [ RRURR55IShvN SSS5 O[U5IShvN URR5 UR5 SSS5IShvN URRceURR$GNN!,(df  N|=fNNK!,IShvN (df  N`=f7f)zcBlock until the process exits. Returns: The exit status of the process; see :attr:`returncode`. N)rZrir[ contextlibsuppressr rmrn wait_readablerArrUwaitrjrdr?s r(rv Process.waits ???yy{";;*#,,+#mm99$++:L:L:NOOO -T222 !!!#!#?"zz$$000zz$$$%# P 3#???szE DE 9D/;D D DD/'D+(.D/ E !D-"4E D D( $D/-E /E5D8 6 EE cUR$)a[Returns the exit status of the process (an integer), or ``None`` if it's still running. Note that on Trio (unlike the standard library `subprocess.Popen`), ``process.poll()`` and ``process.returncode`` always give the same result. See `returncode` for more details. This method is only included to make it easier to port code from `subprocess`. )rdr?s r(ri Process.pollsr*c:URRU5 g)aSend signal ``sig`` to the process. On UNIX, ``sig`` may be any signal defined in the :mod:`signal` module, such as ``signal.SIGINT`` or ``signal.SIGTERM``. On Windows, it may be anything accepted by the standard library :meth:`subprocess.Popen.send_signal`. N)rU send_signal)r@sigs r(r{Process.send_signals s#r*c8URR5 g)a6Terminate the process, politely if possible. On UNIX, this is equivalent to ``send_signal(signal.SIGTERM)``; by convention this requests graceful termination, but a misbehaving or buggy process might ignore it. On Windows, :meth:`terminate` forcibly terminates the process in the same manner as :meth:`kill`. N)rU terminater?s r(rProcess.terminates r*c8URR5 g)aaImmediately terminate the process. On UNIX, this is equivalent to ``send_signal(signal.SIGKILL)``. On Windows, it calls ``TerminateProcess``. In both cases, the process cannot prevent itself from being killed, but the termination will be delivered asynchronously; use :meth:`wait` if you want to ensure the process is actually dead before proceeding. N)rUkillr?s r(r Process.kill%s r*) r[rUrZr^r\rXrVrYrW) r_zsubprocess.Popen[bytes]rVzSendStream | NonerWReceiveStream | NonerXrrDNone)rDstr)rDz int | NonerDrrC)r|zsignal.Signals | intrDr)rFrGrHrIrJrO__annotations__rPrQrSr`rfpropertyrdrjrvrir{rrrKr%r*r(rMrMhs(V!&%HeFE #'&#'&#'!#'% #' % #'  #'J 9* %4 $  r*rM) metaclassrVrWrXc J# SH(nURU5(dM[SUS35e [RS:Xax[ U[ [ 45(a!URS5(d [S5e[ U[ [ 45(d!URS5(a [S5eSnSnSn[5n [5n U[R:XaG[5upaU R[RU5 U RUR5 U[R:XaG[5uprU R[RU5 U RUR5 U[R:XaUbUnO[U[R:XaG[5upU R[RU5 U RUR5 [R R#[%[R&U4UUUS .UD65IShvN n U R)5 SSS5 SSS5 [*R-W XgU5$N;!,(df  N/=f!,(df  N8=f7f) a Execute a child program in a new process. After construction, you can interact with the child process by writing data to its `~trio.Process.stdin` stream (a `~trio.abc.SendStream`), reading data from its `~trio.Process.stdout` and/or `~trio.Process.stderr` streams (both `~trio.abc.ReceiveStream`\s), sending it signals using `~trio.Process.terminate`, `~trio.Process.kill`, or `~trio.Process.send_signal`, and waiting for it to exit using `~trio.Process.wait`. See `trio.Process` for details. Each standard stream is only available if you specify that a pipe should be created for it. For example, if you pass ``stdin=subprocess.PIPE``, you can write to the `~trio.Process.stdin` stream, else `~trio.Process.stdin` will be ``None``. Unlike `trio.run_process`, this function doesn't do any kind of automatic management of the child process. It's up to you to implement whatever semantics you want. Args: command: The command to run. Typically this is a sequence of strings or bytes such as ``['ls', '-l', 'directory with spaces']``, where the first element names the executable to invoke and the other elements specify its arguments. With ``shell=True`` in the ``**options``, or on Windows, ``command`` can be a string or bytes, which will be parsed following platform-dependent :ref:`quoting rules `. In all cases ``command`` can be a path or a sequence of paths. stdin: Specifies what the child process's standard input stream should connect to: output written by the parent (``subprocess.PIPE``), nothing (``subprocess.DEVNULL``), or an open file (pass a file descriptor or something whose ``fileno`` method returns one). If ``stdin`` is unspecified, the child process will have the same standard input stream as its parent. stdout: Like ``stdin``, but for the child process's standard output stream. stderr: Like ``stdin``, but for the child process's standard error stream. An additional value ``subprocess.STDOUT`` is supported, which causes the child's standard output and standard error messages to be intermixed on a single standard output stream, attached to whatever the ``stdout`` option says to attach it to. **options: Other :ref:`general subprocess options ` are also accepted. Returns: A new `trio.Process` object. Raises: OSError: if the process spawning fails, for example because the specified command could not be found. )rOtextrPrQbufsizezLtrio.Process only supports communicating over unbuffered byte streams; the 'z' option is not supportedposixshellzQcommand must be a sequence (not a string or bytes) if shell=False on UNIX systemszPcommand must be a string or bytes (not a sequence) if shell=True on UNIX systemsNr)get TypeErrorr7name isinstancerbytesr subprocessPIPErcallbackrprSTDOUTrm to_threadrun_syncrPopenpop_allrM_create) commandrVrWrXoptionskey trio_stdin trio_stdout trio_stderralways_cleanupcleanup_on_failr_s r( _open_processr2s2vO ;;s  1145NP O ww' gU| , ,W[[5I5I. 'C<00W[[5I5I-  -1J04K04K   JOO # : < J  # #BHHe 4  $ $Z%5%5 6 Z__ $"?"A K  # #BHHf 5  $ $[%6%6 7 Z&& &! z &"?"A K  # #BHHf 5  $ $[%6%6 7nn--             !G)4J ??5*; GG  1)4 sNJ#B-J# JE+JI?JJ J#?J J J J J#c # UR5 g![a0n[R"[ SU<SU<35SS9 SnAgSnAff=f7f)NzTerminateProcess on z failed with: r  stacklevel)rr6warningswarnRuntimeWarningpexcs r(_windows_deliver_cancelrsG    1!nSGL M  s*AA A&A A AAc N# UR5 [R"S5IShvN [R"[ SU<S35SS9 UR 5 gN8![a0n[R"[ SU<SU<35SS9 SnAgSnAff=f7f)Nzprocess z` ignored SIGTERM for 5 seconds. (Maybe you should pass a custom deliver_cancel?) Trying SIGKILL.r rztried to kill process z, but failed with: )rrmsleeprrrrr6rs r(_posix_deliver_cancelrs  jjm 1% ""         3A58KC7S T  s>B%)A(A&7A(%B%&A(( B"2&BB%B""B%r*)rVcapture_stdoutcapture_stderrcheckdeliver_cancel task_statuscB^^^^# [U[5(a [S5eU[RLaxU[ R La [S5eURS5[ R La [S5eURS5[ R La [S5e[U[[[45(aUm[ R US'OSmXS'U(a$SU;a [S 5e[ R US'U(a$SU;a [S 5e[ R US'Tc7[RS :Xa[mO[RS :Xde[m/n/n SU4S jjn SSjn [!U40UD6IShvN m[R""5IShvN n Tb9TR$ceU R'U TR$5 STlSTlU(a:TR*ceU R'U TR*U5 STlSTlU(a3TR,ceU R'U TR,U 5 STlUR/T5 TR15IShvN SSS5IShvN U(aSR9U5OSnU(aSR9U 5OSnTR:(a2U(a+[ R<"TR:TR>UUS9eTR:ce[ R@"TR>TR:X5$GNGNN![2a [R4"SS9 [R4"SS9mSUUU4Sjjn U R'U 5 TR15IShvN TR75 e!,(df  GNR=ff=fGNN!,IShvN (df  GNd=f7f)u$Run ``command`` in a subprocess and wait for it to complete. This function can be called in two different ways. One option is a direct call, like:: completed_process_info = await trio.run_process(...) In this case, it returns a :class:`subprocess.CompletedProcess` instance describing the results. Use this if you want to treat a process like a function call. The other option is to run it as a task using `Nursery.start` – the enhanced version of `~Nursery.start_soon` that lets a task pass back a value during startup:: process = await nursery.start(trio.run_process, ...) In this case, `~Nursery.start` returns a `Process` object that you can use to interact with the process while it's running. Use this if you want to treat a process like a background task. Either way, `run_process` makes sure that the process has exited before returning, handles cancellation, optionally checks for errors, and provides some convenient shorthands for dealing with the child's input/output. **Input:** `run_process` supports all the same ``stdin=`` arguments as `subprocess.Popen`. In addition, if you simply want to pass in some fixed data, you can pass a plain `bytes` object, and `run_process` will take care of setting up a pipe, feeding in the data you gave, and then sending end-of-file. The default is ``b""``, which means that the child will receive an empty stdin. If you want the child to instead read from the parent's stdin, use ``stdin=None``. **Output:** By default, any output produced by the subprocess is passed through to the standard output and error streams of the parent Trio process. When calling `run_process` directly, you can capture the subprocess's output by passing ``capture_stdout=True`` to capture the subprocess's standard output, and/or ``capture_stderr=True`` to capture its standard error. Captured data is collected up by Trio into an in-memory buffer, and then provided as the :attr:`~subprocess.CompletedProcess.stdout` and/or :attr:`~subprocess.CompletedProcess.stderr` attributes of the returned :class:`~subprocess.CompletedProcess` object. The value for any stream that was not captured will be ``None``. If you want to capture both stdout and stderr while keeping them separate, pass ``capture_stdout=True, capture_stderr=True``. If you want to capture both stdout and stderr but mixed together in the order they were printed, use: ``capture_stdout=True, stderr=subprocess.STDOUT``. This directs the child's stderr into its stdout, so the combined output will be available in the `~subprocess.CompletedProcess.stdout` attribute. If you're using ``await nursery.start(trio.run_process, ...)`` and want to capture the subprocess's output for further processing, then use ``stdout=subprocess.PIPE`` and then make sure to read the data out of the `Process.stdout` stream. If you want to capture stderr separately, use ``stderr=subprocess.PIPE``. If you want to capture both, but mixed together in the correct order, use ``stdout=subprocess.PIPE, stderr=subprocess.STDOUT``. **Error checking:** If the subprocess exits with a nonzero status code, indicating failure, :func:`run_process` raises a :exc:`subprocess.CalledProcessError` exception rather than returning normally. The captured outputs are still available as the :attr:`~subprocess.CalledProcessError.stdout` and :attr:`~subprocess.CalledProcessError.stderr` attributes of that exception. To disable this behavior, so that :func:`run_process` returns normally even if the subprocess exits abnormally, pass ``check=False``. Note that this can make the ``capture_stdout`` and ``capture_stderr`` arguments useful even when starting `run_process` as a task: if you only care about the output if the process fails, then you can enable capturing and then read the output off of the `~subprocess.CalledProcessError`. **Cancellation:** If cancelled, `run_process` sends a termination request to the subprocess, then waits for it to fully exit. The ``deliver_cancel`` argument lets you control how the process is terminated. .. note:: `run_process` is intentionally similar to the standard library `subprocess.run`, but some of the defaults are different. Specifically, we default to: - ``check=True``, because `"errors should never pass silently / unless explicitly silenced" `__. - ``stdin=b""``, because it produces less-confusing results if a subprocess unexpectedly tries to read from stdin. To get the `subprocess.run` semantics, use ``check=False, stdin=None``. Args: command (list or str): The command to run. Typically this is a sequence of strings such as ``['ls', '-l', 'directory with spaces']``, where the first element names the executable to invoke and the other elements specify its arguments. With ``shell=True`` in the ``**options``, or on Windows, ``command`` may alternatively be a string, which will be parsed following platform-dependent :ref:`quoting rules `. stdin (:obj:`bytes`, subprocess.PIPE, file descriptor, or None): The bytes to provide to the subprocess on its standard input stream, or ``None`` if the subprocess's standard input should come from the same place as the parent Trio process's standard input. As is the case with the :mod:`subprocess` module, you can also pass a file descriptor or an object with a ``fileno()`` method, in which case the subprocess's standard input will come from that file. When starting `run_process` as a background task, you can also use ``stdin=subprocess.PIPE``, in which case `Process.stdin` will be a `~trio.abc.SendStream` that you can use to send data to the child. capture_stdout (bool): If true, capture the bytes that the subprocess writes to its standard output stream and return them in the `~subprocess.CompletedProcess.stdout` attribute of the returned `subprocess.CompletedProcess` or `subprocess.CalledProcessError`. capture_stderr (bool): If true, capture the bytes that the subprocess writes to its standard error stream and return them in the `~subprocess.CompletedProcess.stderr` attribute of the returned `~subprocess.CompletedProcess` or `subprocess.CalledProcessError`. check (bool): If false, don't validate that the subprocess exits successfully. You should be sure to check the ``returncode`` attribute of the returned object if you pass ``check=False``, so that errors don't pass silently. deliver_cancel (async function or None): If `run_process` is cancelled, then it needs to kill the child process. There are multiple ways to do this, so we let you customize it. If you pass None (the default), then the behavior depends on the platform: - On Windows, Trio calls ``TerminateProcess``, which should kill the process immediately. - On Unix-likes, the default behavior is to send a ``SIGTERM``, wait 5 seconds, and send a ``SIGKILL``. Alternatively, you can customize this behavior by passing in an arbitrary async function, which will be called with the `Process` object as an argument. For example, the default Unix behavior could be implemented like this:: async def my_deliver_cancel(process): process.send_signal(signal.SIGTERM) await trio.sleep(5) process.send_signal(signal.SIGKILL) When the process actually exits, the ``deliver_cancel`` function will automatically be cancelled – so if the process exits after ``SIGTERM``, then we'll never reach the ``SIGKILL``. In any case, `run_process` will always wait for the child process to exit before raising `Cancelled`. **options: :func:`run_process` also accepts any :ref:`general subprocess options ` and passes them on to the :class:`~trio.Process` constructor. This includes the ``stdout`` and ``stderr`` options, which provide additional redirection possibilities such as ``stderr=subprocess.STDOUT``, ``stdout=subprocess.DEVNULL``, or file descriptors. Returns: When called normally – a `subprocess.CompletedProcess` instance describing the return code and outputs. When called via `Nursery.start` – a `trio.Process` instance. Raises: UnicodeError: if ``stdin`` is specified as a Unicode string, rather than bytes ValueError: if multiple redirections are specified for the same stream, e.g., both ``capture_stdout=True`` and ``stdout=subprocess.DEVNULL`` subprocess.CalledProcessError: if ``check=False`` is not passed and the process exits with a nonzero exit status OSError: if an error is encountered starting or communicating with the process ExceptionGroup: if exceptions occur in ``deliver_cancel``, or when exceptions occur when communicating with the subprocess. If strict_exception_groups is set to false in the global context, which is deprecated, then single exceptions will be collapsed. .. note:: The child process runs in the same process group as the parent Trio process, so a Ctrl+C will be delivered simultaneously to both parent and child. If you don't want this behavior, consult your platform's documentation for starting child processes in a different process group. z$process stdin must be bytes, not strzstdout=subprocess.PIPE is only valid with nursery.start, since that's the only way to access the pipe; use nursery.start or pass the data you want to write directlyrWzestdout=subprocess.PIPE is only valid with nursery.start, since that's the only way to access the piperXzestderr=subprocess.PIPE is only valid with nursery.start, since that's the only way to access the piperVNz,can't specify both stdout and capture_stdoutz,can't specify both stderr and capture_stderrntrc># UIShvN TceURT5IShvN SSS5IShvN gN4N![Ra N+f=fN#!,IShvN (df  g=f7fr$)send_allrmBrokenResourceError)streaminput_s r( feed_input _run_process..feed_inputs_6 )))oof---66.++   666smA9?A9AAAA A9AA9AAAAAA9A6%A( & A62A9c# UIShvN UShvN nURU5 MN"N SSS5IShvN g!,IShvN (df  g=f7fr$)append)rchunkschunks r( read_output!_run_process..read_outputs=6% %e e$ %v66666sXA,AA0.0AA0A A?AA A AAT)shieldcj># T T"T5IShvN SSS5 gN !,(df  g=f7fr$r%)r killer_cscopeprocsr(killer_run_process..killers(&,T222'2's 3 " " 3" 03r*)outputrX)rrrDr)rrrzlist[bytes | bytearray]rDrr)!rr UnicodeErrorrmTASK_STATUS_IGNOREDrr ValueErrorrr bytearray memoryviewr7rrr open_process open_nurseryrV start_soonrYrWrXstartedrv BaseException CancelScopecanceljoinrdCalledProcessErrorr^CompletedProcess)rrVrrrrrr stdout_chunks stderr_chunksrrnurseryrrWrXrrrs ` @@@r( _run_processrsz^%ABBd... JOO #>  ;;x JOO 3?  ;;x JOO 3? %%J788%??   w KL L&OO w KL L&OO 77d?4N77g% %%2N-/M-/M%%'% %g11 1D  ""g !zz---"":tzz:! ! {{...""; ]K" ! {{...""; ]K"    %))+  ##">)7SXXm $DF(6SXXm $DF 5++ OO II   *****499doovVVY 2""  !!. $ 0 0 = 33""6*iik!!$$&/. %#"""sFP$M*%PM-PPCM2#M0$M2( P3P4B7P-P0M22O>AO*O O** O: 4O>7P:O>>PPP P PPwin32) rVrWrX close_fdsrcwdenv startupinfo creationflagsc  # g7f)a Execute a child program in a new process. After construction, you can interact with the child process by writing data to its `~trio.Process.stdin` stream (a `~trio.abc.SendStream`), reading data from its `~trio.Process.stdout` and/or `~trio.Process.stderr` streams (both `~trio.abc.ReceiveStream`\s), sending it signals using `~trio.Process.terminate`, `~trio.Process.kill`, or `~trio.Process.send_signal`, and waiting for it to exit using `~trio.Process.wait`. See `trio.Process` for details. Each standard stream is only available if you specify that a pipe should be created for it. For example, if you pass ``stdin=subprocess.PIPE``, you can write to the `~trio.Process.stdin` stream, else `~trio.Process.stdin` will be ``None``. Unlike `trio.run_process`, this function doesn't do any kind of automatic management of the child process. It's up to you to implement whatever semantics you want. Args: command (list or str): The command to run. Typically this is a sequence of strings such as ``['ls', '-l', 'directory with spaces']``, where the first element names the executable to invoke and the other elements specify its arguments. With ``shell=True`` in the ``**options``, or on Windows, ``command`` may alternatively be a string, which will be parsed following platform-dependent :ref:`quoting rules `. stdin: Specifies what the child process's standard input stream should connect to: output written by the parent (``subprocess.PIPE``), nothing (``subprocess.DEVNULL``), or an open file (pass a file descriptor or something whose ``fileno`` method returns one). If ``stdin`` is unspecified, the child process will have the same standard input stream as its parent. stdout: Like ``stdin``, but for the child process's standard output stream. stderr: Like ``stdin``, but for the child process's standard error stream. An additional value ``subprocess.STDOUT`` is supported, which causes the child's standard output and standard error messages to be intermixed on a single standard output stream, attached to whatever the ``stdout`` option says to attach it to. **options: Other :ref:`general subprocess options ` are also accepted. Returns: A new `trio.Process` object. Raises: OSError: if the process spawning fails, for example because the specified command could not be found. Nr%) rrVrWrXrrrrrrs r(rr s ~ )rrVrrrrrWrXrrrrrrc # g7f)u#Run ``command`` in a subprocess and wait for it to complete. This function can be called in two different ways. One option is a direct call, like:: completed_process_info = await trio.run_process(...) In this case, it returns a :class:`subprocess.CompletedProcess` instance describing the results. Use this if you want to treat a process like a function call. The other option is to run it as a task using `Nursery.start` – the enhanced version of `~Nursery.start_soon` that lets a task pass back a value during startup:: process = await nursery.start(trio.run_process, ...) In this case, `~Nursery.start` returns a `Process` object that you can use to interact with the process while it's running. Use this if you want to treat a process like a background task. Either way, `run_process` makes sure that the process has exited before returning, handles cancellation, optionally checks for errors, and provides some convenient shorthands for dealing with the child's input/output. **Input:** `run_process` supports all the same ``stdin=`` arguments as `subprocess.Popen`. In addition, if you simply want to pass in some fixed data, you can pass a plain `bytes` object, and `run_process` will take care of setting up a pipe, feeding in the data you gave, and then sending end-of-file. The default is ``b""``, which means that the child will receive an empty stdin. If you want the child to instead read from the parent's stdin, use ``stdin=None``. **Output:** By default, any output produced by the subprocess is passed through to the standard output and error streams of the parent Trio process. When calling `run_process` directly, you can capture the subprocess's output by passing ``capture_stdout=True`` to capture the subprocess's standard output, and/or ``capture_stderr=True`` to capture its standard error. Captured data is collected up by Trio into an in-memory buffer, and then provided as the :attr:`~subprocess.CompletedProcess.stdout` and/or :attr:`~subprocess.CompletedProcess.stderr` attributes of the returned :class:`~subprocess.CompletedProcess` object. The value for any stream that was not captured will be ``None``. If you want to capture both stdout and stderr while keeping them separate, pass ``capture_stdout=True, capture_stderr=True``. If you want to capture both stdout and stderr but mixed together in the order they were printed, use: ``capture_stdout=True, stderr=subprocess.STDOUT``. This directs the child's stderr into its stdout, so the combined output will be available in the `~subprocess.CompletedProcess.stdout` attribute. If you're using ``await nursery.start(trio.run_process, ...)`` and want to capture the subprocess's output for further processing, then use ``stdout=subprocess.PIPE`` and then make sure to read the data out of the `Process.stdout` stream. If you want to capture stderr separately, use ``stderr=subprocess.PIPE``. If you want to capture both, but mixed together in the correct order, use ``stdout=subprocess.PIPE, stderr=subprocess.STDOUT``. **Error checking:** If the subprocess exits with a nonzero status code, indicating failure, :func:`run_process` raises a :exc:`subprocess.CalledProcessError` exception rather than returning normally. The captured outputs are still available as the :attr:`~subprocess.CalledProcessError.stdout` and :attr:`~subprocess.CalledProcessError.stderr` attributes of that exception. To disable this behavior, so that :func:`run_process` returns normally even if the subprocess exits abnormally, pass ``check=False``. Note that this can make the ``capture_stdout`` and ``capture_stderr`` arguments useful even when starting `run_process` as a task: if you only care about the output if the process fails, then you can enable capturing and then read the output off of the `~subprocess.CalledProcessError`. **Cancellation:** If cancelled, `run_process` sends a termination request to the subprocess, then waits for it to fully exit. The ``deliver_cancel`` argument lets you control how the process is terminated. .. note:: `run_process` is intentionally similar to the standard library `subprocess.run`, but some of the defaults are different. Specifically, we default to: - ``check=True``, because `"errors should never pass silently / unless explicitly silenced" `__. - ``stdin=b""``, because it produces less-confusing results if a subprocess unexpectedly tries to read from stdin. To get the `subprocess.run` semantics, use ``check=False, stdin=None``. Args: command (list or str): The command to run. Typically this is a sequence of strings such as ``['ls', '-l', 'directory with spaces']``, where the first element names the executable to invoke and the other elements specify its arguments. With ``shell=True`` in the ``**options``, or on Windows, ``command`` may alternatively be a string, which will be parsed following platform-dependent :ref:`quoting rules `. stdin (:obj:`bytes`, subprocess.PIPE, file descriptor, or None): The bytes to provide to the subprocess on its standard input stream, or ``None`` if the subprocess's standard input should come from the same place as the parent Trio process's standard input. As is the case with the :mod:`subprocess` module, you can also pass a file descriptor or an object with a ``fileno()`` method, in which case the subprocess's standard input will come from that file. When starting `run_process` as a background task, you can also use ``stdin=subprocess.PIPE``, in which case `Process.stdin` will be a `~trio.abc.SendStream` that you can use to send data to the child. capture_stdout (bool): If true, capture the bytes that the subprocess writes to its standard output stream and return them in the `~subprocess.CompletedProcess.stdout` attribute of the returned `subprocess.CompletedProcess` or `subprocess.CalledProcessError`. capture_stderr (bool): If true, capture the bytes that the subprocess writes to its standard error stream and return them in the `~subprocess.CompletedProcess.stderr` attribute of the returned `~subprocess.CompletedProcess` or `subprocess.CalledProcessError`. check (bool): If false, don't validate that the subprocess exits successfully. You should be sure to check the ``returncode`` attribute of the returned object if you pass ``check=False``, so that errors don't pass silently. deliver_cancel (async function or None): If `run_process` is cancelled, then it needs to kill the child process. There are multiple ways to do this, so we let you customize it. If you pass None (the default), then the behavior depends on the platform: - On Windows, Trio calls ``TerminateProcess``, which should kill the process immediately. - On Unix-likes, the default behavior is to send a ``SIGTERM``, wait 5 seconds, and send a ``SIGKILL``. Alternatively, you can customize this behavior by passing in an arbitrary async function, which will be called with the `Process` object as an argument. For example, the default Unix behavior could be implemented like this:: async def my_deliver_cancel(process): process.send_signal(signal.SIGTERM) await trio.sleep(5) process.send_signal(signal.SIGKILL) When the process actually exits, the ``deliver_cancel`` function will automatically be cancelled – so if the process exits after ``SIGTERM``, then we'll never reach the ``SIGKILL``. In any case, `run_process` will always wait for the child process to exit before raising `Cancelled`. **options: :func:`run_process` also accepts any :ref:`general subprocess options ` and passes them on to the :class:`~trio.Process` constructor. This includes the ``stdout`` and ``stderr`` options, which provide additional redirection possibilities such as ``stderr=subprocess.STDOUT``, ``stdout=subprocess.DEVNULL``, or file descriptors. Returns: When called normally – a `subprocess.CompletedProcess` instance describing the return code and outputs. When called via `Nursery.start` – a `trio.Process` instance. Raises: UnicodeError: if ``stdin`` is specified as a Unicode string, rather than bytes ValueError: if multiple redirections are specified for the same stream, e.g., both ``capture_stdout=True`` and ``stdout=subprocess.DEVNULL`` subprocess.CalledProcessError: if ``check=False`` is not passed and the process exits with a nonzero exit status OSError: if an error is encountered starting or communicating with the process .. note:: The child process runs in the same process group as the parent Trio process, so a Ctrl+C will be delivered simultaneously to both parent and child. If you don't want this behavior, consult your platform's documentation for starting child processes in a different process group. Nr%)rrrVrrrrrWrXrrrrrrs r( run_processras b rr%) rVrWrXrrr preexec_fnrestore_signalsstart_new_sessionpass_fdsc  # g7fr$r% rrVrWrXrrrrrrrrs r(rr8 r) rVrWrXrrrrrrrrc  # g7fr$r%rs r(rrIrr)rrVrrrrrWrXrrrrrrrc # g7fr$r%rrrVrrrrrWrXrrrrrrrrs r(rrZ (25r)rrVrrrrrWrXrrrrrrrrc # g7fr$r%rs r(rrprrrr)r&rEr'rErDrE) r)StrOrBytesPath | Sequence[StrOrBytesPath]rVint | HasFileno | NonerWrrXrrrRrDrM)rrMrDr)rrrV7bytes | bytearray | memoryview | int | HasFileno | Nonerr!rr!rr!r-Callable[[Process], Awaitable[object]] | NonerTaskStatus[Process]rrRrD"subprocess.CompletedProcess[bytes])rrrVrrWrrXrrr!rr!rStrOrBytesPath | NonerMapping[str, str] | Nonersubprocess.STARTUPINFO | NonerrErD trio.Process) rrrrrVrrr!rr!rr!rrrWrrXrrr!rr!rrrrrrrrErDr)rr rVrrWrrXrrr!r Literal[True]rrrrrCallable[[], object] | Nonerr!rr!r Sequence[int]rDr)rSequence[StrOrBytesPath]rVrrWrrXrrr!rr!rrrrrrrr!rr!rrrDr)$rr rrrVrrr!rr!rr!rrrWrrXrrr!rrrrrrrrrr!rr!rrrDr)$rrrrrVrrr!rr!rr!rz+Callable[[Process], Awaitable[None]] | NonerWrrXrrr!rr!rrrrrrrr!rr!rrrDr)L __future__rrsr7rsysrr functoolsrtypingrrrr r r rm_corer r_highlevel_genericr_subprocess_platformrrr_syncr_utilrrsignalcollections.abcrrrriortyping_extensionsr_abcrr version_inforrPathLiker rr)r+r,r" ImportErrorplatformr4CDLLr1c_longr2restypeargtypesr3r<rMrrrrrrrrFrHr%r*r(rs"   KK 2- -FF +/v %c5"++c2BBKKPUDV&V WNIW %   !NI3OO&'!P!! F+FFX%)%)%) |H 6|H "|H # |H # |H  |H |H~  2FI  DH'+'?'?~W 6~W C~W ~W  ~W  ~WB~W%~W~W(~WX  ||w -1-1-1")-,09=!"? >? *? + ?  + ?   ? ? '? *? 7? ? ? H04/G/GMQ#(#(LP-1-1")-,09=!"!Q >Q -Q K Q  ! Q  ! Q Q JQ +Q +Q Q Q 'Q *Q 7Q  !Q "0#Q n -1-1-1")-,06:$(&+&( # * +   +     ! ' * 4 "  $ $     -1-1-1")-,06:$(&+&( - * +   +      ' * 4 "  $ $     04/G/GMQ#(#(LP-1-1")-,06:$(&+&(% 5# 5- 5K  5 !  5 !  5 5J 5+ 5+ 5 5! 5' 5* 54 5 "! 5" $# 5$$% 5&0' 5  5* 04/G/GMQ#(#(JN-1-1")-,06:$(&+&(% 5- 5- 5K  5 !  5 !  5 5H 5+ 5+ 5 5 5' 5* 54 5 "! 5" $# 5$$% 5&0' 5  5.!L8FFLL5K6CCK;3c" $' <<7 " #);;tt#D 39== ( ( 0   5 ( ( 1 "O "' I$'s1K--A?M5/M54M5