| Current File : //opt/imh-python/lib/python2.7/site-packages/sh.pyc |
�
�)�Tc @ sJ d Z d Z d Z d d l Z d e j � j � k rI e d e � � n d d l Z e j d d k Z d d l
Z
d d l Z d d l Z d d l
m
Z d d l Z d d
l m Z d d l m Z d d l Z d d l m Z d d
l m Z e � p d Z e r^d d l m Z d d l m Z d d l m Z m Z e! e" d � r[d � Z# n n6 d d l m Z d d l m$ Z d d l m Z m Z e j � d k Z% e j& j' e j& j( e) � � Z* d Z+ d d l, Z, d d l- Z- d d l. Z. d d l/ Z/ d d l0 Z0 d d l1 Z1 d d l2 Z2 d d l3 Z3 d d l4 Z4 d d l5 Z5 d d l6 Z6 d d l7 Z7 d d l8 m9 Z9 d d l: Z: d d l; Z; d � Z< e r�e= Z> e? Z@ e? ZA n eB eC e@ � � � ZD d � ZE d eF f d � � YZG d eG f d � � YZH d eF f d � � YZI e0 jJ e0 jK e0 jL e0 jM e0 jN e0 jO e0 jP e0 jQ e0 jR e0 jS e0 jT f ZU d eV f d! � � YZW e jX d" � ZY i ZZ d# � Z[ d$ � Z\ d% � Z] d& � Z^ d' � Z
d( e_ f d) � � YZ` d* � Za d+ e_ f d, � � YZb d- � Zc d. e_ f d/ � � YZd d0 � Ze d1 � Zf d2 � Zg d3 � Zh d4 e_ f d5 � � YZi d6 eF f d7 � � YZj d8 eF f d9 � � YZk d: � Zl d; � Zm d< � Zn d= � Zo d> � Zp d? � Zq d@ � Zr dA e_ f dB � � YZs dC � Zt dD � Zu dE � Zv dF � Zw dG � Zx dH e_ f dI � � YZy dJ e_ f dK � � YZz e dL � � Z{ e dM � � Z| dN e} f dO � � YZ~ dP � Z dQ e f dR � � YZ� e� dS k r&y e j� j� dT � Z� Wn
e� Z� n Xe� dU k r
d d l� Z� dV � Z� dW dX dY dZ d[ d\ f Z� d] d^ f Z� x, e� D]$ Z x e� D] Z� e� e� e � q�Wq�Wn e~ e� � � Z� e e� � n e j� e� Z� e� e� � e j� e� <d S(_ s
http://amoffat.github.io/sh/
s 1.11s https://github.com/amoffat/shi����Nt windowss� sh %s is currently only supported on linux and osx. please install pbs 0.110 (http://pypi.python.org/pypi/pbs) for windows support.i i ( t glob( t
ModuleType( t partial( t contextmanager( t getpreferredencodings UTF-8( t StringIO( t BytesIO( t Queuet Emptyt callablec C s
t | d � S( Nt __call__( t hasattr( t ob( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR
@ s ( t
OutputTypet Darwint sh( t dequec C s t j d j � d d �d S( Ns�
with contexts are deprecated because they are not thread safe. they will be removed in the next version. use subcommands instead http://amoffat.github.io/sh/#sub-commands. see https://github.com/amoffat/sh/issues/195
t
stackleveli ( t warningst warnt strip( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt with_context_warning_ s c C s� d } t rc t | t � r q� t | � } y t | t � } Wq� t k
r_ t | | � } q� Xn_ y t | t � } Wn t k
r� t | � } n Xy | j t � } Wn | j | � } n X| S( s� takes anything and attempts to return a py2 string or py3 bytes. this
is typically used when creating command + arguments to be executed via
os.exec* t utf8( t IS_PY3t
isinstancet bytest strt DEFAULT_ENCODINGt UnicodeEncodeErrort unicodet TypeErrort encode( t st fallback_encoding( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt encode_to_py3bytes_or_py2strr s$
t ErrorReturnCodec B s e Z d Z d Z d � Z RS( s� base class for all exceptions as a result of a command's exit status
being deemed an error. this base class is dynamically subclassed into
derived classes with the format: ErrorReturnCode_NNN where NNN is the exit
code number. the reason for this is it reduces boiler plate code when
testing error return codes:
try:
some_cmd()
except ErrorReturnCode_12:
print("couldn't do X")
vs:
try:
some_cmd()
except ErrorReturnCode as e:
if e.exit_code == 12:
print("couldn't do X")
it's not much of a savings, but i believe it makes the code easier to read i� c C s | | _ | | _ | | _ | j d k r3 d } nF | j | j } t | j � t | � } | ry | d | j � 7} n | j d k r� d } nF | j | j } t | j � t | � } | r� | d | j � 7} n d | | j t d � | j t d � f } t t
| � j | � d S( Ns <redirected>s" ... (%d more, please see e.stdout)s" ... (%d more, please see e.stderr)s'
RAN: %r
STDOUT:
%s
STDERR:
%st replace( t full_cmdt stdoutt stderrt Nonet truncate_capt lenR t decodeR t superR$ t __init__( t selfR& R' R( t
exc_stdoutt out_deltat
exc_stderrt err_deltat msg( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR. � s& ( t __name__t
__module__t __doc__R* R. ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR$ � s t SignalExceptionc B s e Z RS( ( R5 R6 ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR8 � s t TimeoutExceptionc B s e Z d Z d � Z RS( sf the exception thrown when a command is killed because a specified
timeout (via _timeout) was hit c C s | | _ t t | � j � d S( N( t exit_codeR- t ExceptionR. ( R/ R: ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR. � s ( R5 R6 R7 R. ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR9 � s t CommandNotFoundc B s e Z RS( ( R5 R6 ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR< � s s0 (ErrorReturnCode|SignalException)_((\d+)|SIG\w+)c C s� d } y t | SWn� t k
r� t j | � } | r� | j d � } | j d � } | d k r� y t | � } Wq� t k
r� t t | � } q� Xn t | � } t
| � } q� n X| S( s takes an exception name, like:
ErrorReturnCode_1
SignalException_9
SignalException_SIGHUP
and returns the corresponding exception. this is primarily used for
importing exceptions from sh into user code, for instance, to capture those
exceptions i i R8 N( R) t rc_exc_cachet KeyErrort rc_exc_regext matcht groupt intt
ValueErrort getattrt signalt
get_rc_exc( t namet exct mt baset rc_or_sig_namet rc( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt get_exc_from_name� s
c C s� y t | � } Wn! t k
r3 t t | � } n Xy t | SWn t k
rS n X| d k rs d | } t } n d t | � } t } t | | f i | d 6� } | t | <| S( sO takes a exit code, signal number, or signal name, and produces an
exception that corresponds to that return code. positive return codes yield
ErrorReturnCode exception, negative return codes yield SignalException
we also cache the generated exception so that only one signal of that type
exists, preserving identity i s ErrorReturnCode_%ds SignalException_%dR: (
RB RC RD RE R= R> R$ t absR8 t type( RK RL RG RJ RH ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyRF s
c C s� d � } t j j | � \ } } | r: | | � r� | Sn\ d t j k rM d SxF t j d j t j � D]+ } t j j | | � } | | � rg | Sqg Wd S( Nc S sC t j j | � oB t j | t j � oB t j j t j j | � � S( N( t ost patht existst accesst X_OKt isfilet realpath( t fpath( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt is_exe- s t PATH( RP RQ t splitt environR) t pathsept join( t programRX RW t fnameRQ t exe_file( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt which, s c C sJ t | � } | sF d | k r9 t | j d d � � } n | sF d Sn | S( Nt _t -( Ra R% R) ( R^ RQ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt resolve_program@ s c C s t | � p | S( N( t
original_glob( t arg( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR U s t Loggerc B sP e Z d Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z
RS( sO provides a memory-inexpensive logger. a gotcha about python's builtin
logger is that logger objects are never garbage collected. if you create a
thousand loggers with unique names, they'll sit there in memory until your
script is done. with sh, it's easy to create loggers with unique names if
we want our loggers to include our command arguments. for example, these
are all unique loggers:
ls -l
ls -l /tmp
ls /tmp
so instead of creating unique loggers, and without sacrificing logging
output, we use this class, which maintains as part of its state, the logging
"context", which will be the very unique name. this allows us to get a
logger with a very general name, eg: "command", and have a unique name
appended to it via the context, eg: "ls -l /tmp" c C sM | | _ | r$ | j d d � } n | | _ t j d t | f � | _ d S( Nt %s %%s %s.%s( RG R% t contextt loggingt getLoggert SH_LOGGER_NAMEt log( R/ RG Ri ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR. k s
c G s' | j r d | j | f } n | | S( Ns %s: %s( Ri ( R/ R4 t args( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt _format_msgr s c C s5 | j d | } | j d | } t | | � } | S( Nt .( RG Ri Rg ( R/ RG Ri t new_namet new_contextt l( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt get_childw s c G s | j j | j | | � � d S( N( Rm t infoRo ( R/ R4 Rn ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyRu } s c G s | j j | j | | � � d S( N( Rm t debugRo ( R/ R4 Rn ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyRv � s c G s | j j | j | | � � d S( N( Rm t errorRo ( R/ R4 Rn ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyRw � s c G s | j j | j | | � � d S( N( Rm t exceptionRo ( R/ R4 Rn ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyRx � s N( R5 R6 R7 R) R. Ro Rt Ru Rv Rw Rx ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyRg Z s c C s7 t | � | k r3 d | | t | � | f } n | S( Ns %s...(%d more)( R+ ( R! t max_len( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt friendly_truncate� s !t RunningCommandc B s� e Z d Z d � Z d � Z d � Z e d � � Z e d � � Z e d � � Z e d � � Z
d � Z d � Z d
� Z
d � Z e Z d � Z d
� Z d � Z d � Z d Z d � Z d � Z d � Z d � Z d � Z d � Z RS( s� this represents an executing Command object. it is returned as the
result of __call__() being executed on a Command instance. this creates a
reference to a OProc instance, which is a low-level wrapper around the
process that was exec'd
this is the class that gets manipulated the most by user code, and so it
implements various convenience methods and logical mechanisms for the
underlying process. for example, if a user tries to access a
backgrounded-process's stdout/err, the RunningCommand object is smart enough
to know to wait() on the process to finish first. and when the process
finishes, RunningCommand is smart enough to translate exit codes to
exceptions. c
C s( t r: d j g | D] } | j t d � ^ q � | _ n d j | � | _ t | j d � } t t | � d � } d | | f } t d | � | _ | | _ | | _
d | _ t
| _ t }
t } | d r� t
} t j j | � n | d s| d s| d rt
}
n | d
r"t
}
n | d r8t j } n t j } | d d k sa| d t k rmt j } n | d d
k r�t j } n | d d k s�| d t k r�t j } n | d d
k r�t j } n | r$| j j d � t | j | | | | | j | � | _ |
r$| j � q$n d S( Nt t ignorei s <Command %r call_args %s>t commandt witht pipedt itert iter_noblockt bgt
err_to_outt outt errs starting process( R R] R, R t ranRz R Rg Rm t call_argst cmdR) t processt Falset _process_completedt Truet Commandt _prepend_stackt appendt OProct STDOUTt STDERRRu t wait(
R/ R� R� t stdinR' R( Rf t friendly_cmdt friendly_call_argst
logger_strt should_waitt
spawn_processt pipe( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR. � sL 4
c C sr | j sn t | _ | j j � } | j j r= t | � � n
| j | � | j d rn | j d | � qn n | S( Nt done( R� R� R� R� t timed_outR9 t handle_command_exit_codeR� ( R/ R: ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s
c C s` | | j d k r\ | d k s, | t k r\ t | � } | | j | j j | j j � � n d S( s� here we determine if we had an exception, or an error code that we
weren't expecting to see. if we did, we create and raise an exception
t ok_codei N( R� t# SIGNALS_THAT_SHOULD_THROW_EXCEPTIONRF R� R� R' R( ( R/ t codeRH ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s # c C s | j � | j j S( N( R� R� R' ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR' s
c C s | j � | j j S( N( R� R� R( ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR(
s
c C s | j � | j j S( N( R� R� R: ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR: s
c C s
| j j S( N( R� t pid( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� s c C s t t | � � S( N( R+ R ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __len__ s c C s t � d S( s� we don't actually do anything here because anything that should have
been done would have been done in the Command.__call__ call.
essentially all that has to happen is the comand be pushed on the
prepend stack. N( R ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __enter__ s c C s | S( N( ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __iter__% s c C s� x� t r� y | j j j t d � } Wn% t k
rL | j d r� t j Sq X| d k ro | j � t
� � n y" | j | j d | j d � SWq t k
r� | SXq Wd S( s4 allow us to iterate over the output of our command g����MbP?R� t encodingt
decode_errorsN(
R� R� t _pipe_queuet getR R� t errnot EWOULDBLOCKR) R� t
StopIterationR, t UnicodeDecodeError( R/ t chunk( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt next( s
c C s* | j d r& t j r& t j j � n d S( NR ( R� R� R� t pop( R/ t typt valuet traceback( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __exit__@ s c C s. t r | j � St | � j | j d � Sd S( sY in python3, should return unicode. in python2, should return a
string of bytes R� N( R t __unicode__R R R� ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __str__D s
c C sK | j r3 | j r3 | j j | j d | j d � St r= d St d � Sd S( sj a magic method defined for python2. calling unicode() on a
RunningCommand object will call this R� R� t N( R� R' R, R� R R ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� L s c C s t | � t | � k S( N( R ( R/ t other( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __eq__W s c C s | t | � k S( N( R ( R/ t item( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __contains__[ s c C sW | d k r. | j r% t | j | � St � n | t k rM t t | � | � St � d S( NRE t terminatet kill( s signals terminates kill( R� RD t AttributeErrort _unicode_methodsR ( R/ t p( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __getattr__^ s c C sO y t | � SWn: t k
rJ | j r@ | j r@ t | j � Sn t d � SXd S( sY in python3, should return unicode. in python2, should return a
string of bytes R� N( R R� R� R' t repr( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __repr__q s
c C s t t | � j � � S( N( t longR R ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __long__| s c C s t t | � j � � S( N( t floatR R ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __float__ s c C s t t | � j � � S( N( RB R R ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __int__� s N( R5 R6 R7 R. R� R� t propertyR' R( R: R� R� R� R� R� t __next__R� R� R� R� R) t __hash__R� R� R� R� R� R� ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR{ � s0 K c C s7 | o6 t | � o6 t | d � o6 t | t t f � S( Nt write( R
R R t cStringIOR ( R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt output_redirect_is_filename� s
R� c B s� e Z d Z g Z i e d 6e d 6d9 d 6d9 d 6d9 d 6d9 d 6d d 6d d
6d d 6d d: d 6d9 d 6d9 d 6d9 d 6d9 d 6d d 6d9 d 6d d 6e d 6e d 6e d 6d d 6d d 6e j d 6e d 6e d 6e d! 6d9 d" 6d9 d# 6d; d& 6Z
d< d= d> d? f Z e d+ � � Z
d, � Z d- � Z e i d. � � Z e d/ � Z d0 � Z d1 � Z d2 � Z d3 � Z d9 Z d4 � Z d5 � Z d6 � Z d7 � Z d8 � Z RS(@ s� represents an un-run system program, like "ls" or "cd". because it
represents the program itself (and not a running instance of it), it should
hold very little state. in fact, the only state it does hold is baked
arguments.
when a Command object is called, the result that is returned is a
RunningCommand object, which represents the Command put into an execution
state. R� R t inR� R� R� i t
in_bufsizei t out_bufsizet err_bufsizei i i t internal_bufsizet envR� R� R� R� t cwdt =t long_sept tty_int tty_outR� t strictR� t timeoutt timeout_signalt no_outt no_errt no_pipet teeR� i iP t tty_sizes" Stderr is already being redirecteds3 You cannot iterate when this command is being pipeds; Using a pipe doesn't make sense if you've disabled the pipes4 You cannot iterate over output if there is no outputc K sI t | � } | s! t | � � n | | � } | rE | j | � } n | S( N( Rd R< t bake( t clsR^ t default_kwargsRQ R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt _create s c C s^ t | � } | s! t | � � n t | � | _ t | _ g | _ i | _ t | � | _ d S( N(
Ra R< R# t _pathR� t _partialt _partial_baked_argst _partial_call_argsR R5 ( R/ RQ t found( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR. s c C sm t t j | � } | j d � r+ | | � S| d k rA | d � S| j d � r] | d } n | d � | � S( NRb R� i����( R t objectt __getattribute__t
startswitht endswith( R/ RG RD ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� s
c C s� | j � } i } xh t j j � D]W \ } } d | } | | k r\ | | | | <| | =q" | | k r" | | | | <q" q" Wt | j � � } xQ t j D]F } t | � } | j � } | j | � r� t
d | | f � � q� q� W| | f S( NRb s Invalid special arguments %r: %s( t copyR� t
_call_argst itemst sett keyst _incompatible_call_argst listR� t
issupersetR ( t kwargst to_overrideR� t pargt defaultt keyt s1Rn Rw ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt _extract_call_args. s
c C s� g } x� | j � D]� \ } } t | � d k r| | t k r� | j t d | � � | t k ry | j t | � � qy q� q | s� | j d d � } n | t k r� | j t d | � � q | t k r� q t d | | | f � } | j | � q W| S( Ni Rc Rb s --s --%s%s%s( R� R+ R� R� R# R� R% ( R/ t keywordst sept rawt processedt kt vRf ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt _aggregate_keywordsG s c C s� g } x� | D]� } t | t t f � rr | sK t j d | j d d �n xe | D] } | j t | � � qR Wq
t | t � r� | | j | | d t
�7} q
| j t | � � q
W| | j | | � 7} | S( Nsb Empty list passed as an argument to %r. If you're using glob.glob(), please use sh.glob() instead.R i R ( R R� t tupleR R R� R� R# t dictR R� ( R/ Rn R� R� t processed_argsRf t sub_arg( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt
_compile_argsa s
c O s� t | j � } t | _ | j | � \ } } | } xR t j j � D]A \ } } y | | | k rl | | =n WqC t k
r� qC qC XqC W| j j | j � | j j | � | j
j | j
� | j d | j d � } | j
j | j
| | | � � | S( NR� ( R� R� R� R� R� R� R� R> R� t updateR� t extendR� R ( R/ Rn R� t fnR� t pruned_call_argsR R R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� x s
c C s' t r | j � S| j � j t � Sd S( sY in python3, should return unicode. in python2, should return a
string of bytes N( R R� R R ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s
c C s) y t | � t | � k SWn t SXd S( N( R R� ( R/ R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s c C s d t | � S( sY in python3, should return unicode. in python2, should return a
string of bytes s <Command %r>( R ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s c C sC d j d � | j D� � } | r/ d | } n | j j t � | S( sY a magic method defined for python2. calling unicode() on a
self will call this R| c s s | ] } | j t � Vq d S( N( R, R ( t .0R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pys <genexpr>� s ( R] R� R� R, R ( R/ t
baked_args( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s
c C s t � | d t � d S( Nt _with( R R� ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s c C s t j j � d S( N( R� R� R� ( R/ R� R� R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s c O s/ | j � } t | � } g } t j j � } xR | j D]G } | j j � } y | d =Wn n X| j | � | j | j � q7 W| j | j
� | j | | j � \ } } | j | � t
| d d d � s� | d g | d <n | d r� t | d <n | d } | r�| j d � } t | t � rq| j d rCt | d <n | j d d k rb| j } q�| j j } q�| j d | � n | j | | | d
� }
| j |
} | } | j | � | d }
t |
� r�t t |
� d � }
n | d
} t | � rt t | � d � } n t | | | |
| � S( NR R� R� R� R� R� i R� t directR� R� t wbR� ( R� R� R� R� R� R� R
R R� R� R� R� R� RD R) R� R� R R{ R� R� t insertR R� R� t openR ( R/ Rn R� R� R� t prependt
pcall_argst
tmp_call_argsR� t first_argR t
split_argst
final_argsR' R( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR � sP
Ni ( i iP ( s errs
err_to_outs" Stderr is already being redirected( s pipeds iters3 You cannot iterate when this command is being piped( s pipeds no_pipes; Using a pipe doesn't make sense if you've disabled the pipe( s no_outs iters4 You cannot iterate over output if there is no output( R5 R6 R7 R� R� R) R� R RE t SIGKILLR� R� t classmethodR� R. R� t staticmethodR� R R R� R� R� R� R� R� R� R� R ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � sl
c G s/ t j d | d | � } t | _ | j � | S( Nt targetRn ( t threadingt ThreadR� t daemont start( R Rn t thrd( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt _start_daemon_thread s
c C sP | \ } } t t d d � } t j d | | d d � } t j | | | � d S( sU set the terminal size of a tty file descriptor. borrowed logic
from pexpect.py t
TIOCSWINSZigt�t HHHHi N( RD t termiost structt packt fcntlt ioctl( t fdt rows_colst rowst colsR% R! ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt
setwinsize s c s8 d } d } � } t � t � r< t � j � } � j } n t j | � rl d } t t j | � j � } nK t j | � r� t t j | � j � } n! d } t t j | j � j � } | | | } d � | d k r� d � n | d k r� | j
f � n' | d k r"| j
t j | � f � n � � f d � } | S( s` here we're constructing a closure for our streamreader callback. this
is used in the case that we pass a callback into _out or _err, meaning we
want to our callback to handle each bit of output
we construct the closure based on how many arguments it takes. the reason
for this is to make it as easy as possible for people to use, without
limiting them. a new user will assume the callback takes 1 argument (the
data). as they get more advanced, they may want to terminate the process,
or pass some stdin back, and will realize that they can pass a callback of
more args i i i i c s? � } t | � d k r2 � d � d � f } n � | | � S( Ni i i ( R+ ( R� Rn ( t handlert handler_args( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR L s ( ( (
R R R+ Rn t funct inspectt ismethodt
getargspect
isfunctionR R� t weakreft ref( R� R1 t implied_argt partial_argst handler_to_inspectt num_argst net_argsR ( ( R1 R2 s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt construct_streamreader_callback s. c C sI t j | � r t j | � St j | � r9 t j | � St d � � d S( s= this should only ever be called once for each child process s Unknown child exit status!N( RP t WIFSIGNALEDt WTERMSIGt WIFEXITEDt WEXITSTATUSt RuntimeError( R: ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt handle_process_exit_codeX s
R� c B s� e Z d Z d d f Z d Z d Z d � Z d � Z d � Z d � Z d � Z
d
� Z d � Z e
d � � Z e
d
� � Z d � Z d � Z d � Z d � Z d � Z RS( s$ this class is instantiated by RunningCommand for a command to be exec'd.
it handles all the nasty business involved with correctly setting up the
input/output to the child process. it gets its name for subprocess.Popen
(process open) but we're calling ours OProc (open process) i iP i����i����c C s< | | _ | j d d k r, t | j d <n | j d oC | j d | _ | j r� t j � \ | _ | _ | j | _ | j | _ | j | _ | j | _
n� t | t � r� | j | _ d | _ n@ | j d r� t j � \ | _ | _ n t j � \ | _ | _ | j d r,t j � \ | _ | _ n t j � \ | _ | _ | t j k rnt j � \ | _ | _
n | j d } | d k r�t j j | � r�t j | � n t j � } | r�t j � n t j � | _ | j d k rz | j d t k rt j t j t j � n t r,t j d � n t j � | j d rVt! j" | j � n | j rrt j# | j � n | j s�t j# | j � | t j k r�t j# | j � q�n | r�t j | � n t j$ | j d � t j$ | j d � | t j k rt j$ | j d
� n t j$ | j
d
� t% j& t% j' � d }
t j( d |
� | j d r�t j) t j* d � t j+ � } t j# | � n | j d r�t, d | j d � n | j d
d k r�t j- | d | � n t j. | d | | j d
� Wd t j/ d � Xn2| rt j0 � n t | _1 t j � | _2 | | _3 d | _4 | pOt5 � | _6 t5 � | _7 t8 j9 � | _: t; d | j d � | _< t; d | j d � | _= | j d r�t, | j | j d � n | j> d t? | � � | _@ t j# | j � | j s2t j# | j � | t j k r2t j# | j
� q2n | j@ jA d � | j d r�tB jC | j � } | d c tB jD M<tB jE | j tB jF | � n d | _G t | j6 t � s�tH | j@ j> d d � | j | j6 | j d | j d | j d � | _G n d }
| t j k r&| j d r&| j7 }
n | j d oV| j d t d f k pV| d k } d | _I | j d d k r�tJ | � r�tK | | � } n tL | j@ j> d d � | j | | j< | j d | j d | j d |
d | �| _I n | t j k s| j rd | _M n� d } | t jN k r=| j d r=| j7 } n | j d! og| j d d& k pg| d k } tJ | � r�tK | | � } n tL tO d � | j | | j= | j d# | j d | j d | d | �| _M d | _P | jG r tQ | jR | jG � | _P n tQ | jS | jI | jM | j d$ | j2 | j d% � | _T d S(' s]
cmd is the full string that will be exec'd. it includes the program
name and all its arguments
stdin, stdout, stderr are what the child will use for standard
input/output/err
call_args is a mapping of all the special keyword arguments to apply
to the child process
R� R R� R� R� i R� g{�G�z�?i i i R� R� Ni� t maxlenR� R� s started processt streamwriterR� R� R� R� R� R� R� t streamreaderR' R� R� t save_dataR� R� R� R� R� ( s err(U R� R� t _single_ttyt ptyt openptyt _stdin_fdt _slave_stdin_fdt
_stdout_fdt _slave_stdout_fdt
_stderr_fdt _slave_stderr_fdR R� R) RP R� R� RQ RR t chdirt gct isenabledt disablet forkR� R� RE t SIGHUPt SIG_IGNt IS_OSXt timet sleept setsidt ttyt setrawt closet dup2t resourcet getrlimitt
RLIMIT_NOFILEt
closerangeR t ttynamet O_RDWRR0 t execvt execvet _exitt enableR� t startedR� R: R R� R� R t Lockt
_wait_lockR t _stdoutt _stderrRt R� Rm Rv R' t tcgetattrt ECHOt tcsetattrt TCSANOWt
_stdin_streamt StreamWritert _stdout_streamR
R? t StreamReadert _stderr_streamR� Rg t
_input_threadR$ t input_threadt
output_threadt _output_thread( R/ t
parent_logR� R� R' R( R� R� R� t
gc_enabledt max_fdt tmp_fdt attrt stdout_pipet save_stdoutt stderr_pipet save_stderr( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR. r s
"
%
c C s d | j | j d f S( Ns <Process %d %r>i� ( R� R� ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s c C s | j j j | � d S( N( Ru t stream_bufferert change_buffering( R/ t buf( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt change_in_bufsize� s c C s | j j j | � d S( N( Rw R� R� ( R/ R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt change_out_bufsize� s c C s | j j j | � d S( N( Ry R� R� ( R/ R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt change_err_bufsize� s c C sM t } x6 | r> | j � r> | j j d | � | j � } q W| j � d S( s� this is run in a separate thread. it writes into our process's
stdin (a streamwriter) and waits the process to end AND everything that
can be written to be written s %r ready for more inputN( R� t is_aliveRm Rv R� R` ( R/ R� R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR{ � s
c C s{ g } g } | d k r5 | j | � | j | � n | d k r^ | j | � | j | � n x� | r0t j | g | d � \ } } }
xC | D]; } | j j d | � | j � } | r� | j | � q� q� Wx |
D] } q� W| ra t j � }
|
| | k r-| j j d � t | _ | j
| � q-qa qa Wx | j � rPt j d � q4W| rd| j
� n | rw| j
� n d S( s� this function is run in a separate thread. it reads from the
process's stdout stream (a streamreader), and waits for it to claim that
its done g�������?s %r ready to be read froms we've been running too longg����MbP?N( R) R� t selectRm Rv t readt removeR[ R� R� RE R� R\ R` ( R/ R' R( R� Rl t timeout_exct readerst errorst outputst inputsR� t streamR� t now( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR| � s:
!
c C s d j | j d � j | j � S( NR� R� ( R R� R] Ro ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR' � s c C s d j | j d � j | j � S( NR� R� ( R R� R] Rp ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR( � s c C sB | j j d | � y t j | j | � Wn t k
r= n Xd S( Ns sending signal %d( Rm Rv RP R� R� t OSError( R/ t sig( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyRE � s
c C s$ | j j d � | j t j � d S( Nt killing( Rm Rv RE R ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� s c C s$ | j j d � | j t j � d S( Nt terminating( Rm Rv RE t SIGTERM( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� s c C s� | j d k r t S| j j t � } | sB | j d k r> t St Sza yD t j | j t j � \ } } | | j k r� t
| � | _ t SWn t k
r� t SXt SWd | j j � Xd S( s� polls if our child process has completed, without blocking. this
method has side-effects, such as setting our exit_code, if we happen to
see our child exit while this is running N(
R: R) R� Rn t acquireR� RP t waitpidR� t WNOHANGRE R� t release( R/ t acquiredR� R: ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� s"
c C s� | j j d � | j �� | j j d � | j d k rv | j j d � t j | j d � \ } } t | � | _ n | j j d | j � | j r� | j j
� n | j j
� | j SWd QXd S( s: waits for the process to complete, handles the exit code s* acquiring wait lock to wait for completions
got wait locks! exit code not set, waiting on pidi s+ exit code already set (%d), no need to waitN( Rm Rv Rn R: R) RP R� R� RE Rz R] R} ( R/ R� R: ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� 6 s
( R5 R6 R7 t _default_window_sizeR� R� R. R� R� R� R� R{ R| R� R' R( RE R� R� R� R� ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� f s& � ' @ +t DoneReadingForeverc B s e Z RS( ( R5 R6 ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� T s t NotYetReadyToReadc B s e Z RS( ( R5 R6 ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� U s c C s� d } t | t � r* d } t | � } n� t | � rK d } t | � } n` t | d � ro d } t | � } n< t | t � r� d } t | � } n d } t
t | � � } | | f S( s given some kind of input object, return a function that knows how to
read chunks of that input object.
each reader function should return a chunk and raise a DoneReadingForever
exception, or return None, when there's no more data to read
NOTE: the function returned does not need to care much about the requested
buffering type (eg, unbuffered vs newline-buffered). the StreamBufferer
will take care of that. these functions just need to return a
reasonably-sized chunk of data. t queueR
R� s file descriptort strings general iterableN( R) R R t get_queue_chunk_readerR
t get_callable_chunk_readerR t get_file_chunk_readert
basestringt get_iter_string_readert get_iter_chunk_readerR� ( t input_objt get_chunkt log_msg( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt determine_how_to_read_inputX s c s � f d � } | S( Nc sI y � j t d � } Wn t k
r/ t � n X| d k rE t � n | S( Ng{�G�z�?( R� R� R R� R) R� ( R� ( R� ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR � s
( ( R� R ( ( R� s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� s c s � f d � } | S( Nc s y � � SWn
t � n Xd S( N( R� ( ( R� ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR � s ( ( R� R ( ( R� s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s c s; d � � � f d � t d t � � � � D� } t | � S( s- return an iterator that returns a chunk of a string every time it is
called. notice that even though bufsize_type might be line buffered, we're
not doing any line buffering here. that's because our StreamBufferer
handles all buffering. we just need to return a reasonable-sized chunk. i c 3 s | ] } � | | � !Vq d S( N( ( R t i( t bufsizeR� ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pys <genexpr>� s i ( t rangeR+ R� ( R� t iter_str( ( R� R� s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s +c s � f d � } | S( Nc sG y) t r � j � } n � j � } | SWn t k
rB t � n Xd S( N( R R� R� R� R� ( R� ( R� ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR � s
( ( R� R ( ( R� s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s c s d � � � f d � } | S( Ni c s& � j � � } | s t � n | Sd S( N( R� R� ( R� ( R� R� ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR � s ( ( R� R ( ( R� R� s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s c C s4 | d k r d } n | d k r* d } n | } | S( s for a given bufsize type, return the actual bufsize we will read.
notice that although 1 means "newline-buffered", we're reading a chunk size
of 1024. this is because we have to read something. we let a
StreamBufferer instance handle splitting our chunk on newlines i i i ( ( t bf_typeR� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt bufsize_type_to_bufsize� s Rv c B s2 e Z d Z d � Z d � Z d � Z d � Z RS( s� StreamWriter reads from some input (the stdin param) and writes to a fd
(the stream param). the stdin may be a Queue, a callable, something with
the "read" method, a string, or an iterable c C sn | | _ | | _ | | _ | | _ | | _ t | | j � | _ t | � \ | _ } | j j d | � d S( Ns parsed stdin as a %s(
R� R� Rm R� R� t StreamBuffererR� R� R� Rv ( R/ Rm R� R� t bufsize_typeR� R� R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR. � s c C s | j S( sR defining this allows us to do select.select on an instance of this
class ( R� ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt fileno� s c C s~ y% | j � } | d
k r$ t � n Wn� t k
r� | j j d � | j r� y! t j | j � d t j } Wn t
d � j � } n Xt j
| j | � n t St k
r� | j j d � t SXt r� t | d � r� | j | j � } n x� | j j | � D]r } | j j d t | � | d � | j j d � y t j
| j | � Wqt k
ru| j j d � t SXqWd
S( s� attempt to get a chunk of data to write to our child process's
stdin, then write it. the return value answers the questions "are we
done writing forever?" s done readingi i s received no dataR s got chunk size %d: %ri s writing chunk to processs OSError writing stdin chunkN( R� R) R� Rm Rv R� R' Rq R� t VEOFt chrR RP R� R� R� R� R R R� R� R� R+ R� ( R/ R� t chart
proc_chunk( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s6
!
c C s� | j j d � | j j � } | j j d t | � | d � yL | r^ t j | j | � n | j s� | j j d � t j | j � n Wn t
k
r� n Xd S( Ns closing, but flushing firsts got chunk size %d to flush: %ri s$ we used a TTY, so closing the stream( Rm Rv R� t flushR+ RP R� R� R� R` R� ( R/ R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR` s
( R5 R6 R7 R. R� R� R` ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyRv � s
.c C s� t | � r' t | | | � \ } } n� t | t � rK t | � \ } } n` t | t � ru t | | | � \ } } n6 t | d � r� t | � \ } } n d � } d � } | | f S( NR� c S s t S( N( R� ( R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt <lambda>/ s c S s d S( N( R) ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� 0 s ( R
t get_callback_chunk_consumerR R� t get_cstringio_chunk_consumerR t get_stringio_chunk_consumerR t get_file_chunk_consumer( R1 R� R� R� t finish( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt determine_how_to_feed_output# s c s( � f d � } � f d � } | | f S( Nc s � j | � � j � t S( N( R� R� R� ( R� ( R1 ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� 6 s
c s t � d � r � j � n d S( NR� ( R R� ( ( R1 ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� = s ( ( R1 R� R� ( ( R1 s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� 5 s c s( � � � f d � } d � } | | f S( Nc s4 y | j � � � } Wn t k
r) n X� | � S( N( R, R� ( R� ( R� R� R1 ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� D s
c S s d S( N( ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� M s ( ( R1 R� R� R� R� ( ( R� R� R1 s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� C s c s" � f d � } d � } | | f S( Nc s � j | � t S( N( R� R� ( R� ( R1 ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� S s
c S s d S( N( ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� W s ( ( R1 R� R� ( ( R1 s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� R s c s( � � � f d � } d � } | | f S( Nc s � j | j � � � � t S( N( R� R, R� ( R� ( R� R� R1 ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� ^ s c S s d S( N( ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� b s ( ( R1 R� R� R� R� ( ( R� R� R1 s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� ] s Rx c B sA e Z d Z d e d � Z d � Z d � Z d � Z d � Z RS( sV reads from some output (the stream) and sends what it just read to the
handler. c
C s� | | _ | | _ | | _ | | _ | | _ d | _ | rQ t j | � | _ n | | _ t
| | j | j � | _ t | � | _
t | | | � \ | _ | _ t | _ d S( N( R� t bufferRI R� R� R) t
pipe_queueR8 R9 Rm R� R� R� R� R� t
process_chunkt finish_chunk_processorR� t should_quit(
R/ Rm R� R1 R� R� R� R� R� RI ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR. k s c C s | j S( sR defining this allows us to do select.select on an instance of this
class ( R� ( R/ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s c C s� | j j � } | j j d t | � | d � | rE | j | � n | j � | j rw | j rw | j � j d � n y t j | j
� Wn t k
r� n Xd S( Ns got chunk size %d to flush: %ri ( R� R� Rm Rv R+ t write_chunkR� R� RI t putR) RP R` R� R� ( R/ R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR` � s
c C st | j s | j | � | _ n | j rp | j j | � | j rp | j j d | d � | j � j | � qp n d S( Ns putting chunk onto pipe: %ri ( R� R� RI R� R� R� Rm Rv R� ( R/ R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s c C s� y t j | j | j � } Wn* t k
rH } | j j d | j � t SX| sc | j j d � t S| j j d t | � | d � x' | j
j | � D] } | j | � q� Wd S( Ns got errno %d, done readings got no chunk, done readings got chunk size %d: %ri (
RP R� R� R� R� Rm Rv R� R� R+ R� R� R� ( R/ R� t e( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s N(
R5 R6 R7 R) R� R. R� R` R� R� ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyRx h s R� c B s8 e Z d Z e d d � Z d � Z d � Z d � Z RS( s� this is used for feeding in chunks of stdout/stderr, and breaking it up
into chunks that will actually be put into the internal buffers. for
example, if you have two processes, one being piped to the other, and you
want that, first process to feed lines of data (instead of the chunks
however they come in), OProc will use an instance of this class to chop up
the data and feed it as lines to be sent down the pipe R� c C sX | | _ g | _ d | _ | | _ | | _ t | _ t j � | _ t
d � | _ d S( Ni R� ( RO R� t n_buffer_countR� R� R� t _use_up_buffer_firstR t RLockt _buffering_lockRg Rm ( R/ t buffer_typeR� R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR. � s c C sw | j j d � | j j � | j j d � z% | d k rH t | _ n | | _ Wd | j j � | j j d � Xd S( Ns/ acquiring buffering lock for changing bufferings) got buffering lock for changing bufferingi s. released buffering lock for changing buffering( Rm Rv R� R� R� R� RO R� ( R/ t new_type( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s
c C s� | j j d | j � | j j � | j j d | j � z�| j d k r� y | j | j | j � Wq� | j j d � | j d � q� Xn | j d k r� | j r� t
| _ | j } g | _ | j | � | S| g S| j d k rg } | j | j | j � } x� t
r�| j d � } | d k r/Pn | | d } | j r�d j | j � j | j � | j | j � } | j | j � } g | _ d | _ n | | d } | j | j | j � � q
W| r | j j | j | j � � | j t | � 7_ n | Sg } x� t
r�| j t | � | j } | d k r�d j | j � j | j � | } | | j } | | j } | j | � g | _ d | _ q
| j j | � | j t | � 7_ Pq
W| SWd | j j � | j j d
| j � Xd S( Ns9 acquiring buffering lock to process chunk (buffering: %d)s3 got buffering lock to process chunk (buffering: %d)i s( detected binary data, changing bufferingi i s
i����R� s< released buffering lock for processing chunk (buffering: %d)( Rm Rv RO R� R� R, R� R� R� R� R� R� R� R� t findR R] R� R+ R� ( R/ R� t to_writet total_to_writet newlinet chunk_to_writet overaget ret( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � sl
"
c C s� | j j d � | j j � | j j d � z/ d j | j � j | j � } g | _ | SWd | j j � | j j d � Xd S( Ns, acquiring buffering lock for flushing buffers& got buffering lock for flushing bufferR� s+ released buffering lock for flushing buffer( Rm Rv R� R� R R� R] R� R� ( R/ R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� < s
( R5 R6 R7 R R. R� R� R� ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s Sc c s t d | � �
d VWd QXd S( sd pushd is just a specialized form of args, where we're passing in the
current working directory t _cwdN( Rn ( RQ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt pushdJ s c o sa t j } | j � } x3 | j � D]% \ } } | j d � } | | | <q" Wd V| j | � d S( s\ allows us to temporarily override all the special keyword parameters in
a with context Rb N( R� R� R� R� t lstripR
( Rn R� R� t old_argsR� R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyRn R s t Environmentc B sq e Z d Z e d d d d d d d d d d
d d d
g
� Z i d � Z d � Z d � Z d � Z d � Z RS( s� this allows lookups to names that aren't found in the global scope to be
searched for as a program name. for example, if "ls" isn't found in this
module's scope, we consider it a system program and try to find it.
we use a dict instead of just a regular object as the base class because the
exec() statement used in this file requires the "globals" argument to be a
dictionary R� R< R R� R$ R� R8 R9 t __project_url__t __version__Rn R R� c C s | | _ | | _ t | _ d S( N( t globsR R� t disable_whitelist( R/ R� R ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR. � s c C s | | j | <d S( N( R� ( R/ R R ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __setitem__� s c C s | d k r t | _ d S| | j k s1 | j rW y | j | SWqW t k
rS qW Xn | d k rr t d � � n t | � } | r� | S| j d � r� | j d � r� t � n y t
j | SWn t k
r� n Xt | d | d � } | r� | St
j | | j � S( Nt _disable_whitelistt __all__sJ Cannot import * from sh. Please import sh or import programs individually.t __t b_( R� R� R) t whitelistR� R> R� RM R� R� RP R[ RD R� R� R ( R/ R RH t builtin( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt __getitem__� s0
c C s t j | � d S( N( RP RS ( R/ RQ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt b_cd� s c C s
t | � S( N( Ra ( R/ R^ ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt b_which� s (
R5 R6 R7 R� R� R. R� R� R� R� ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� b s( 8 c B s� d } | j d e � GHxu e r� y e d � } Wn e e f k
rJ Pn Xy e | d d � | | UWq e k
ry Pq e j � GHq Xq Wd GHd S( Ns3
>> sh v{version}
>> https://github.com/amoffat/sh
t versions sh> s <dummy>t singleR� (
t formatR� R� t raw_inputRC t EOFErrort compilet
SystemExitR� t
format_exc( R� t bannert line( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt run_repl� s
t SelfWrapperc B s/ e Z i d � Z d � Z d � Z d � Z RS( c C sd x6 d d d d g D]" } t | | t | | d � � q Wg | _ | | _ t t � | � | _ d S( Nt __builtins__R7 R5 t __package__( t setattrRD R) t __path__t _SelfWrapper__self_moduleR� t globalst _SelfWrapper__env( R/ t self_moduleR R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR. � s
c C s6 t | d � r | | j | <n t j | | | � d S( Nt __env( R R R t __setattr__( R/ RG R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR � s c C s | d k r t � n | j | S( NR ( R� R ( R/ RG ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s c K s t | j | � S( N( R� R� ( R/ R� ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR s ( R5 R6 R. R R� R ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyR� � s t __main__i t testc C s� d | } t | � } | r� d | j � | f GHt j j � } | | d <t j | t j j t d � g t
j d d | �} | j � } | d k r� t
d � q� n d | j � GHd S( Ns python%ss Testing %s, locale %rt LANGs test.pyi R� i s Couldn't find %s, skipping( Ra t
capitalizeRP R[ R� t
subprocesst PopenRQ R] t THIS_DIRt syst argvR� t exit( R� t localet
py_versiont py_binR� R� t return_code( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt run_test s
s 2.6s 2.7s 3.1s 3.2s 3.3s 3.4s en_US.UTF-8t C(� R7 R� R� t platformt systemt lowert ImportErrorR t version_infoR R� RP t reR Re R[ t typesR t functoolsR R4 t
contextlibR R R R t ioR R R� R� R R R R� R
R RZ RQ t dirnameRV t __file__R
Rl R� R RK R' RE RT R� R R^ R* R( Rb t collectionsR Rj R8 R t inputR� R R R� R� t dirR� R# R; R$ R8 R9 t SIGABRTt SIGBUSt SIGFPEt SIGILLt SIGINTR t SIGPIPEt SIGQUITt SIGSEGVR� t SIGSYSR� R� R< R� R? R= RM RF Ra Rd R� Rg Rz R{ R� R� R$ R0 R? RE R� R� R� R� R� R� R� R� R� R� Rv R� R� R� R� R� Rx R� R� Rn R R� R� R� R5 R R� Rf R) R R t versionst localesR� R� R� t modulesR/ ( ( ( s1 /opt/imh-python/lib/python2.7/site-packages/sh.pyt <module> s�
$3 0 � � q F � � '
Y S�g "