o 3gB@s$ddlmZddlZddlmZmZddlmZddlmZddl Z ddl m Z m Z mZddlmZGdd d ZGd d d ZGd d d eZGdddeZGdddeZGdddeZGdddeZGdddeZGdddZGdddZeZeZeZeZeZeZ dS)) annotationsN)DEBUGINFO)select)PIPE)BY_TYPEProcessExecutionErrorrun_proc)read_fd_decode_safelyc@sZeZdZdZdddZddZddZeZd d Ze d d Z e d dZ e ddZ dS)FuturezRepresents a "future result" of a running process. It basically wraps a ``Popen`` object and the expected exit code, and provides poll(), wait(), returncode, stdout, and stderr. NcCs(||_||_||_d|_d|_d|_dSN)proc_expected_retcode_timeout _returncode_stdout_stderr)selfr expected_retcodetimeoutrR/home/garg/my-data/venv/lib/python3.10/site-packages/plumbum/commands/modifiers.py__init__s  zFuture.__init__cCs(|r|jnd}d|jjd|dS)Nrunningz)readyrr argv)rrrrr__repr__szFuture.__repr__cCs |jdur ||jduS)zsPolls the underlying process for termination; returns ``False`` if still running, or ``True`` if terminatedN)r pollwaitrrrrrrs z Future.pollcCs0|jdurdSt|j|j|j\|_|_|_dS)z{Waits for the process to terminate; will raise a :class:`plumbum.commands.ProcessExecutionError` in case of failureN)rr r rrrrrrrrr(s  z Future.waitcC||jS)zPThe process' stdout; accessing this property will wait for the process to finish)rrrrrrstdout1z Future.stdoutcCr )zPThe process' stderr; accessing this property will wait for the process to finish)rrrrrrstderr7r"z Future.stderrcCr )zTThe process' returncode; accessing this property will wait for the process to finish)rrrrrr returncode=r"zFuture.returncoder ) __name__ __module__ __qualname____doc__rrrrrpropertyr!r#r$rrrrr s   r c@s$eZdZdZddZeddZdS)ExecutionModifier) __weakref__cCsi}|jjD]"}t|dd}t|tr|f}|D]}|ddkr't||||<qqdd|D}d|}|jjd|d S) zgAutomatically creates a representation for given subclass with slots. Ignore hidden properties. __slots__rr_css"|] \}}|d|VqdS)z = Nr).0namevaluerrr Ws z-ExecutionModifier.__repr__..z, ()) __class____mro__getattr isinstancestritemsjoinr%)rslotscls slots_listpropmystrs mystrs_strrrrrLs     zExecutionModifier.__repr__cO||i|Sr rr<argskwargsrrr__call__[zExecutionModifier.__call__N)r%r&r'r,r classmethodrErrrrr*Is r*c@&eZdZdZdZd ddZddZdS) _BGa An execution modifier that runs the given command in the background, returning a :class:`Future ` object. In order to mimic shell syntax, it applies when you right-and it with a command. If you wish to expect a different return code (other than the normal success indicate by 0), use ``BG(retcode)``. Example:: future = sleep[5] & BG # a future expecting an exit code of 0 future = sleep[5] & BG(7) # a future expecting an exit code of 7 .. note:: When processes run in the **background** (either via ``popen`` or :class:`& BG `), their stdout/stderr pipes might fill up, causing them to hang. If you know a process produces output, be sure to consume it every once in a while, using a monitoring thread/reactor in the background. For more info, see `#48 `_ retcodekargsrrNcKs||_||_||_dSr rJ)rrKrrLrrrrus z _BG.__init__cCs t|jdi|j|j|jdS)N)rr)r popenrLrKrrcmdrrr__rand__zs z _BG.__rand__rNr%r&r'r(r,rrPrrrrrI`s   rIc@rH) _FGaY An execution modifier that runs the given command in the foreground, passing it the current process' stdin, stdout and stderr. Useful for interactive programs that require a TTY. There is no return value. In order to mimic shell syntax, it applies when you right-and it with a command. If you wish to expect a different return code (other than the normal success indicate by 0), use ``FG(retcode)``. Example:: vim & FG # run vim in the foreground, expecting an exit code of 0 vim & FG(7) # run vim in the foreground, expecting an exit code of 7 rKrrNcCs||_||_dSr rT)rrKrrrrrs z _FG.__init__cCs||jddd|jddS)NrKstdinr!r#rrTrNrrrrPs z _FG.__rand__rQrRrrrrrS~s   rSc@s&eZdZdZdZd ddZdd ZdS) _TEEa:Run a command, dumping its stdout/stderr to the current process's stdout and stderr, but ALSO return them. Useful for interactive programs that expect a TTY but also have valuable output. Use as: ls["-l"] & TEE Returns a tuple of (return code, stdout, stderr), just like ``run()``. rKbufferedrrTNcC||_||_||_dS)z`retcode` is the return code to expect to mean "success". Set `buffered` to False to disable line-buffering the output, which may cause stdout and stderr to become more entangled than usual. NrX)rrKrYrrrrrs z _TEE.__init__cCs:|j|jdtt|jd}g}g}|j}|j}||||i}|tj|tji}d} | sn|du} d} | rld} t||fdd\} } } | D]'} || }t | d\}}|sRqBd} ||  ||j sd||  | |qB| s3| r)|ddd|D}dd d|D}|j||fWdS1swYdS) NrUFTricSg|]}|dqSzutf-8decoder.xrrr z!_TEE.__rand__..cSr\r]r^r`rrrrbrc)bgrunrKrrr!r#sysrrr writerYflushappendrr:r$)rrOpoutbuferrbufouterrbufferstee_todoneprogressrr-fdbufdatatextr!r#rrrrPsL    % $z _TEE.__rand__)rTNrRrrrrrWs   rWc@s8eZdZdZdZ   d ddZedd Zd d ZdS) _TFa An execution modifier that runs the given command, but returns True/False depending on the retcode. This returns True if the expected exit code is returned, and false if it is not. This is useful for checking true/false bash commands. If you wish to expect a different return code (other than the normal success indicate by 0), use ``TF(retcode)``. If you want to run the process in the foreground, then use ``TF(FG=True)``. Example:: local['touch']['/root/test'] & TF * Returns False, since this cannot be touched local['touch']['/root/test'] & TF(1) # Returns True local['touch']['/root/test'] & TF(FG=True) * Returns False, will show error message rKFGrrFNcCrZ)zv`retcode` is the return code to expect to mean "success". Set `FG` to True to run in the foreground. Nrw)rrKrxrrrrrs  z _TF.__init__cOrAr rrBrrrrE rFz _TF.__call__cCsNz|jr||jddd|jdWdS||j|jdWdSty&YdSw)NrUrTTF)rxrKrrrNrrrrPs  z _TF.__rand__)rFN r%r&r'r(r,rrGrErPrrrrrvs   rvc@s6eZdZdZdZ  d ddZeddZd d ZdS) _RETCODEa An execution modifier that runs the given command, causing it to run and return the retcode. This is useful for working with bash commands that have important retcodes but not very useful output. If you want to run the process in the foreground, then use ``RETCODE(FG=True)``. Example:: local['touch']['/root/test'] & RETCODE # Returns 1, since this cannot be touched local['touch']['/root/test'] & RETCODE(FG=True) * Returns 1, will show error message  foregroundrFNcCs||_||_dS)z&`FG` to True to run in the foreground.Nr{)rrxrrrrr2s z_RETCODE.__init__cOrAr rrBrrrrE;rFz_RETCODE.__call__cCs8|jr|jdddd|jd}|dS|jd|jddS)NrUrrT)r|runr)rrOresultrrrrP?s  z_RETCODE.__rand__)FNryrrrrrz"s    rzc@s&eZdZdZdZd ddZd d ZdS) _NOHUPad An execution modifier that runs the given command in the background, disconnected from the current process, returning a standard popen object. It will keep running even if you close the current process. In order to slightly mimic shell syntax, it applies when you right-and it with a command. If you wish to use a different working directory or different stdout, stderr, you can use named arguments. The default is ``NOHUP( cwd=local.cwd, stdout='nohup.out', stderr=None)``. If stderr is None, stderr will be sent to stdout. Use ``os.devnull`` for null output. Will respect redirected output. Example:: sleep[5] & NOHUP # Outputs to nohup.out sleep[5] & NOHUP(stdout=os.devnull) # No output The equivalent bash command would be .. code-block:: bash nohup sleep 5 & cwdr!r#rh. nohup.outNTcCs||_||_||_||_dS)zuSet ``cwd``, ``stdout``, or ``stderr``. Runs as a forked process. You can set ``append=False``, too. Nr)rrr!r#rhrrrrbs z_NOHUP.__init__cCsdt|tjjjr|j}d}|j}nt|tjjjr"|j}d}|j}n|j}|j }| |j ||j |S)NFT) r7plumbumcommandsbaseStdoutRedirectionfilerOAppendingStdoutRedirectionr!rhnohuprr#)rrOr!rhrrrrPksz_NOHUP.__rand__)rrNTrRrrrrrIs   rc@seZdZddZddZdS)LogPipecCs"||_||_||_||_||_dSr ) line_timeoutkwlevelsprefixlog)rrrrrrrrrr{s  zLogPipe.__init__cCst|dr|n|}|jd|jtd|jD]$\}}|sq|j|}|D]}|jr5|jd|}| ||q(q|j S)N iter_lines)rmodez: r) hasattrrMrrrrr splitlinesrrr$)rrOrMtyplineslevellinerrrrPs  zLogPipe.__rand__N)r%r&r'rrPrrrrrzs rc@sLeZdZdZdZdZdZeZeZ dddZ ddd Z dd d Z d d Z dS)PipeToLoggerMixina This mixin allows piping plumbum commands' output into a logger. The logger must implement a ``log(level, msg)`` method, as in ``logging.Logger`` Example:: class MyLogger(logging.Logger, PipeToLoggerMixin): pass logger = MyLogger("example.app") Here we send the output of an install.sh script into our log:: local['./install.sh'] & logger We can choose the log-level for each stream:: local['./install.sh'] & logger.pipe(out_level=logging.DEBUG, err_level=logging.DEBUG) Or use a convenience method for it:: local['./install.sh'] & logger.pipe_debug() A prefix can be added to each line:: local['./install.sh'] & logger.pipe(prefix="install.sh: ") If the command fails, an exception is raised as usual. This can be modified:: local['install.sh'] & logger.pipe_debug(retcode=None) An exception is also raised if too much time (``DEFAULT_LINE_TIMEOUT``) passed between lines in the stream, This can also be modified:: local['install.sh'] & logger.pipe(line_timeout=10) If we happen to use logbook:: class MyLogger(logbook.Logger, PipeToLoggerMixin): from logbook import DEBUG, INFO # hook up with logbook's levels iXrrNcKsZt||jt||jd}|dur|j}|dur||d<|dur$||d<t|||||jS)a Pipe a command's stdout and stderr lines into this logger. :param out_level: the log level for lines coming from stdout :param err_level: the log level for lines coming from stderr Optionally use `prefix` for each line. )Nrr)r6DEFAULT_STDOUTDEFAULT_STDERRDEFAULT_LINE_TIMEOUTrr)r out_level err_levelrrrrrrrpipes zPipeToLoggerMixin.pipecK|j|j|jfd|i|S)z` Pipe a command's stdout and stderr lines into this logger (both at level INFO) r)rrrrrrrr pipe_infozPipeToLoggerMixin.pipe_infocKr)za Pipe a command's stdout and stderr lines into this logger (both at level DEBUG) r)rrrrrr pipe_debugrzPipeToLoggerMixin.pipe_debugcCs ||t||jt||j@S)z Pipe a command's stdout and stderr lines into this logger. Log levels for each stream are determined by ``DEFAULT_STDOUT`` and ``DEFAULT_STDERR``. )rr6rrrNrrrrPszPipeToLoggerMixin.__rand__)NNNNr ) r%r&r'r(rrrrrrrrrPrrrrrs+   r)! __future__rreloggingrrr subprocessrplumbum.commands.baserplumbum.commands.processesrrr plumbum.libr r r*rIrSrWrvrzrrrBGrxNOHUPRETCODETEETFrrrrs0    <Q5'1d