shell bypass 403
�
�?�Vc 8 @ s� d Z d d l m Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l
Z
d d l Z y d d l Z Wn e
k
r� e Z n Xd d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d
l m Z d d l m Z d d l m Z d d
l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m! Z! d d l m" Z" d d l m# Z# d d l m$ Z$ d d l m% Z% d d l m& Z& d d l m' Z' d d l m( Z( d d l m) Z) d d l m* Z* d d l m+ Z+ d d l m, Z, d d l m- Z- d d! l m. Z. d d" l m/ Z/ d d# l m0 Z0 e j1 j2 d$ � r�d% Z3 d d& l m4 Z5 d d' l4 m6 Z6 d d( l4 m7 Z7 d d) l4 m8 Z8 d d* l4 m9 Z9 e5 j: r�d d+ l; m< Z< d d, l; m= Z= d d- l; m> Z> d d. l; m? Z? d d/ l; m@ Z@ d d0 l; mA ZA d d1 l; mB ZB d d2 l; mC ZC d d3 l; mD ZD d d4 l; mE ZE d d5 l; mF ZF d d6 l; mG ZG d d7 l m; Z; y
e; jH ZH Wn eI k
r�n Xy
e; jJ ZJ Wn eI k
r n Xy
e; jK ZK Wn eI k
r?n Xy
e; jL ZL Wn eI k
r`n Xy
e; jM ZM Wn eI k
r�n Xn nae j1 j2 d8 � r d d9 l mN Z5 d d: lO mP ZP d d; lO mQ ZQ d d< lO mR ZR d d= lO mS ZS d d> lO mT ZT d d? lO mU ZU d d@ lN mV ZV n� e j1 j2 dA � rBd dB l mW Z5 n� e j1 j2 dC � pue j1 j2 dD � pue j1 j2 dE � r�d dF l mX Z5 n^ e j1 j2 dG � r�d dH l mY Z5 d dI lY mZ ZZ d dJ lY m[ Z[ d% Z3 n e\ dK e j1 � � dL dM dN dO dP dQ dR dS dT dU dV dW dX dY dZ d[ d\ d] d\ d^ d_ d` da db dc dd de df dg dh di dj dk dl dm dn do dp dq dr ds dt du dv dw dx dy dz d{ d| d} d~ d d� d� d� g8 Z] e] j^ e5 j_ � d� Z` d� Za eb g ea jc d� � D] Zd ee ed � ^ q�� Zf e5 jg Zg e ah e ji d� k Zj e ji d� k Zk e j1 j2 dD � Zl em e
d� e
j
� Zn ee ea jo d� d� � � em e5 jp d� e � k r�d� e5 jp jq ea f Zr e
er � � n dL es f d� � � YZt dM et f d� � � YZu dN eu f d� � � YZv dO et f d� � � YZw dP et f d� � � YZx eu e5 _u ev e5 _v ew e5 _w ex e5 _x d� � Zy dn ez f d� � � YZ{ do e{ f d� � � YZ| d� � Z} d� � Z~ i Z d� � Z� e e d� � Z� e e� d� � � Z� e� d� � Z� y
e� � a� Wn! es k
r�e a� e j� � n Xy e� d� e� � a� Wn! es k
r e a� e j� � n Xe e� d� � Z� t� a� t� a� e e� d� � Z� d� � Z� d� � Z� d� � Z� e� d� � Z� e� d� � Z� e� d� � Z� d� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� [ [ e jf d� d� f k r� [d n e� d� k r� e� � n d S(� s� psutil is a cross-platform library for retrieving information on
running processes and system utilization (CPU, memory, disks, network)
in Python.
i����( t divisionNi ( t _common( t memoize( t callable( t long( t PY3( t STATUS_DEAD( t STATUS_DISK_SLEEP( t STATUS_IDLE( t
STATUS_LOCKED( t STATUS_RUNNING( t STATUS_SLEEPING( t STATUS_STOPPED( t STATUS_TRACING_STOP( t STATUS_WAITING( t
STATUS_WAKING( t
STATUS_ZOMBIE( t
CONN_CLOSE( t CONN_CLOSE_WAIT( t CONN_CLOSING( t CONN_ESTABLISHED( t CONN_FIN_WAIT1( t CONN_FIN_WAIT2( t
CONN_LAST_ACK( t CONN_LISTEN( t CONN_NONE( t
CONN_SYN_RECV( t
CONN_SYN_SENT( t CONN_TIME_WAIT( t NIC_DUPLEX_FULL( t NIC_DUPLEX_HALF( t NIC_DUPLEX_UNKNOWNt linuxs /proc( t _pslinux( t IOPRIO_CLASS_BE( t IOPRIO_CLASS_IDLE( t IOPRIO_CLASS_NONE( t IOPRIO_CLASS_RT( t
RLIM_INFINITY( t RLIMIT_AS( t RLIMIT_CORE( t
RLIMIT_CPU( t RLIMIT_DATA( t RLIMIT_FSIZE( t RLIMIT_LOCKS( t RLIMIT_MEMLOCK( t
RLIMIT_NOFILE( t RLIMIT_NPROC( t
RLIMIT_RSS( t RLIMIT_STACK( t
_psutil_linuxt win32( t
_pswindows( t ABOVE_NORMAL_PRIORITY_CLASS( t BELOW_NORMAL_PRIORITY_CLASS( t HIGH_PRIORITY_CLASS( t IDLE_PRIORITY_CLASS( t NORMAL_PRIORITY_CLASS( t REALTIME_PRIORITY_CLASS( t CONN_DELETE_TCBt darwin( t _psosxt freebsdt openbsdt netbsd( t _psbsdt sunos( t _pssunos( t
CONN_BOUND( t CONN_IDLEs platform %s is not supportedt Errort
NoSuchProcesst
ZombieProcesst AccessDeniedt TimeoutExpiredt version_infot __version__R
R R R R R
R R R R R R R R R R R R R R R R R t AF_LINKR R R t Processt Popent
pid_existst pidst process_itert
wait_procst virtual_memoryt swap_memoryt cpu_timest cpu_percentt cpu_times_percentt cpu_countt net_io_counterst net_connectionst net_if_addrst net_if_statst disk_io_counterst disk_partitionst
disk_usaget userst boot_times Giampaolo Rodola's 3.4.2t .t posixt ntt monotonict t versionsc version conflict: %r C extension module was built for another version of psutil (different than %s)c B s) e Z d Z d d � Z d � Z e Z RS( sQ Base exception class. All other psutil exceptions inherit
from this one.
Rg c C s
| | _ d S( N( t msg( t selfRi ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt __init__� s c C s, d | j j | j j | j f } | j � S( Ns %s.%s %s( t __class__t
__module__t __name__Ri t strip( Rj t ret( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt __repr__� s ( Rn Rm t __doc__Rk Rq t __str__( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRF � s c B s e Z d Z d d d � Z RS( sX Exception raised when a process with a certain PID doesn't
or no longer exists.
c C s} t j | | � | | _ | | _ | | _ | d k ry | r\ d | j t | j � f } n
d | j } d | | _ n d S( Ns (pid=%s, name=%s)s (pid=%s)s process no longer exists ( RF Rk t pidt nameRi t Nonet repr( Rj Rt Ru Ri t details( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRk � s
N( Rn Rm Rr Rv Rk ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRG � s c B s e Z d Z d d d d � Z RS( s/ Exception raised when querying a zombie process. This is
raised on OSX, BSD and Solaris only, and not always: depending
on the query the OS may be able to succeed anyway.
On Linux all zombie processes are querable (hence this is never
raised). Windows doesn't have zombie processes.
c C s� t j | | � | | _ | | _ | | _ | | _ | d k r� | rq | rq d | j t | j � | j f } n2 | r� d | j t | j � f } n
d | j } d | | _ n d S( Ns (pid=%s, name=%s, ppid=%s)s (pid=%s, name=%s)s (pid=%s)s' process still exists but it's a zombie ( RF Rk Rt t ppidRu Ri Rv Rw ( Rj Rt Ru Ry Ri Rx ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRk � s "
N( Rn Rm Rr Rv Rk ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRH � s c B s e Z d Z d d d d � Z RS( s@ Exception raised when permission to perform an action is denied.c C s� t j | | � | | _ | | _ | | _ | d k r� | d k rk | d k rk d | t | � f | _ q� | d k r� d | j | _ q� d | _ n d S( Ns (pid=%s, name=%s)s (pid=%s)Rg ( RF Rk Rt Ru Ri Rv Rw ( Rj Rt Ru Ri ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRk s N( Rn Rm Rr Rv Rk ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRI s c B s e Z d Z d d d � Z RS( sW Raised on Process.wait(timeout) if timeout expires and process
is still alive.
c C s� t j | d | � | | _ | | _ | | _ | d k ri | d k ri | j d | t | � f 7_ n% | d k r� | j d | j 7_ n d S( Ns timeout after %s secondss (pid=%s, name=%s)s (pid=%s)( RF Rk t secondsRt Ru Rv Ri Rw ( Rj Rz Rt Ru ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRk s " N( Rn Rm Rr Rv Rk ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRJ s c s" t j � � � f d � � } | S( sp Decorator which raises NoSuchProcess in case a process is no
longer running or its PID has been reused.
c s4 | j � s$ t | j | j � � n � | | | � S( N( t
is_runningRG Rt t _name( Rj t argst kwargs( t fun( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt wrapper3 s ( t functoolst wraps( R R� ( ( R sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt _assert_pid_not_reused/ s c B s� e Z d Z d7 d � Z e d � Z d � Z d � Z d � Z d � Z
d � Z d7 d7 d � Z d � Z
d
� Z e d � � Z d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d7 d � Z e rd � Z d � Z d � Z d � Z n e e j! d � r d � Z" n e e j! d � rDd7 d7 d � Z# n e e j! d � red7 d � Z$ n e e j! d � r�d7 d � Z% n e& r�d! � Z' n d" � Z( d# � Z) d$ � Z* e+ e d% � � Z, d7 d& � Z- d' � Z. d( � Z/ d) � Z0 d* � Z1 e e j! d+ � re2 d, � Z3 n d- � Z4 d. d/ � Z5 e r=d0 � Z6 n e+ d1 � � Z7 e+ d2 � � Z8 e+ d3 � � Z9 e+ d4 � � Z: e+ d5 � � Z; d7 d6 � Z< RS(8 s- Represents an OS process with the given PID.
If PID is omitted current process PID (os.getpid()) is used.
Raise NoSuchProcess if PID does not exist.
Note that most of the methods of this class do not make sure
the PID of the process being queried has been reused over time.
That means you might end up retrieving an information referring
to another process in case the original one this instance
refers to is gone in the meantime.
The only exceptions for which process identity is pre-emptively
checked and guaranteed are:
- parent()
- children()
- nice() (set)
- ionice() (set)
- rlimit() (set)
- cpu_affinity (set)
- suspend()
- resume()
- send_signal()
- terminate()
- kill()
To prevent this problem for all other methods you can:
- use is_running() before querying the process
- if you're continuously iterating over a set of Process
instances use process_iter() which pre-emptively checks
process identity for every yielded instance
c C s | j | � d S( N( t _init( Rj Rt ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRk \ s c C sV | d k r t j � } nO t rK t | t t f � rK t d | � � n | d k rj t d | � � n | | _ d | _
d | _ d | _ t
| _ d | _ d | _ t j | � | _ d | _ d | _ y | j � Wn_ t k
r� nO t k
r� n? t k
r<| s0d | } t | d | � � q=t | _ n X| j | j f | _ d S( Ns pid must be an integer (got %r)i s' pid must be a positive integer (got %s)s no process found with pid %s( Rv t ost getpidt _PY3t
isinstancet intR t TypeErrort
ValueErrort _pidR| t _exet _create_timet Falset _gonet _hasht _ppidt _psplatformRN t _proct _last_sys_cpu_timest _last_proc_cpu_timest create_timeRI RH RG t TrueRt t _ident( Rj Rt t _ignore_nspRi ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� _ s:
c C s� y | j } t | j � � } WnX t k
r? d | j } nK t k
r\ d | j } n. t k
ry d | j } n Xd | | f } d | j j | j j | f S( Ns (pid=%s (zombie))s (pid=%s (terminated))s (pid=%s)s (pid=%s, name=%s)s %s.%s%s( Rt Rw Ru RH RG RI Rl Rm Rn ( Rj Rt Ru Rx ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRs � s
c C s d | j � t | � f S( Ns
<%s at %s>( Rs t id( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRq � s c C s# t | t � s t S| j | j k S( N( R� RN t NotImplementedR� ( Rj t other( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt __eq__� s c C s | | k S( N( ( Rj R� ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt __ne__� s c C s+ | j d k r$ t | j � | _ n | j S( N( R� Rv t hashR� ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt __hash__� s c
C s t d d d d d d d d d d
d g � } t � } t | p[ g t | � D] } | ^ qL � } x� | D]� } | j d � r� qh n | | k r� qh n y1 t | | � } t | � r� | � } n | } Wn< t t f k
r� | } n t k
r| rh � qh qh n X| | | <qh W| S(
s� Utility method returning process information as a
hashable dictionary.
If 'attrs' is specified it must be a list of strings
reflecting available Process class' attribute names
(e.g. ['cpu_times', 'name']) else all public (read
only) attributes are assumed.
'ad_value' is the value which gets assigned in case
AccessDenied or ZombieProcess exception is raised when
retrieving that particular process information.
t send_signalt suspendt resumet terminatet killt waitR{ t as_dictt parentt childrent rlimitt _( t sett dictt dirt
startswitht getattrR RI RH t NotImplementedError(
Rj t attrst ad_valuet excluded_namest retdictt xt lsRu t attrRp ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s.
+
c C se | j � } | d k ra | j � } y& t | � } | j � | k rI | SWqa t k
r] qa Xn d S( s� Return the parent process as a Process object pre-emptively
checking whether PID has been reused.
If no parent is known return None.
N( Ry Rv R� RN RG ( Rj Ry t ctimeR� ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s
c C sW | j r
t Sy | t | j � k SWn, t k
r8 t St k
rR t | _ t SXd S( s� Return whether this process is running.
It also checks if PID has been reused by another process in
which case return False.
N( R� R� RN Rt RH R� RG ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR{ � s
c C s | j S( s The process PID.( R� ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRt s c C s9 t r | j j � S| j p( | j j � | _ | j Sd S( s` The process parent PID.
On Windows the return value is cached after first call.
N( t _POSIXR� Ry R� ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRy s
c C s� t r | j d k r | j S| j j � } t r� t | � d k r� y | j � } Wn t k
rf q� X| r� t j
j | d � } | j | � r� | } q� q� n | | _ | | j _ | S( s> The process name. The return value is cached after first call.i i N(
t _WINDOWSR| Rv R� Ru R� t lent cmdlineRI R� t patht basenameR� ( Rj Ru R� t
extended_name( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRu s
c s� � f d � } � j d k r� y � j j � } Wn t k
rP } | d | � SX| s� y | d | � } Wq� t k
r} q� Xn | � _ n � j S( s� The process executable as an absolute path.
May also be an empty string.
The return value is cached after first call.
c s� � j � } | rz t t d � rz t t d � rz | d } t j j | � rz t j j | � rz t j | t j � rz | Sn t | t � r� | � n | S( Nt accesst X_OKi (
R� t hasattrR� R� t isabst isfileR� R� R� RI ( t fallbackR� t exe( Rj ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt guess_it7 s $
R� N( R� Rv R� R� RI ( Rj R� R� t err( ( Rj sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� 2 s
c C s
| j j � S( s3 The command line this process has been called with.( R� R� ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� Y s c C s* y | j j � SWn t k
r% t SXd S( s2 The process current status as a STATUS_* constant.N( R� t statusRH R ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� ] s
c C ss t rb t d k r! t d � � n | j � j } y t j | � j SWqo t k
r^ t | � SXn
| j
j � Sd S( st The name of the user that owns the process.
On UNIX this is calculated by using *real* process uid.
s0 requires pwd module shipped with standard pythonN( R� t pwdRv t ImportErrort uidst realt getpwuidt pw_namet KeyErrort strR� t username( Rj t real_uid( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� d s
c C s+ | j d k r$ | j j � | _ n | j S( s� The process creation time as a floating point number
expressed in seconds since the epoch, in UTC.
The return value is cached after first call.
N( R� Rv R� R� ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� v s c C s
| j j � S( s6 Process current working directory as an absolute path.( R� t cwd( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� s c C sQ | d k r | j j � S| j � s= t | j | j � � n | j j | � d S( s' Get or set process niceness (priority).N( Rv R� t nice_getR{ RG Rt R| t nice_set( Rj t value( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt nice� s
c C s
| j j � S( sV Return process UIDs as a (real, effective, saved)
namedtuple.
( R� R� ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s c C s
| j j � S( sV Return process GIDs as a (real, effective, saved)
namedtuple.
( R� t gids( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s c C s
| j j � S( sV The terminal associated with this process, if any,
else None.
( R� t terminal( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s c C s
| j j � S( sc Return the number of file descriptors opened by this
process (POSIX only).
( R� t num_fds( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s t io_countersc C s
| j j � S( s
Return process I/O statistics as a
(read_count, write_count, read_bytes, write_bytes)
namedtuple.
Those are the number of read/write calls performed and the
amount of bytes read and written by the process.
( R� R� ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s t
ionice_getc C sK | d k r4 | d k r' t d � � n | j j � S| j j | | � Sd S( s� Get or set process I/O niceness (priority).
On Linux 'ioclass' is one of the IOPRIO_CLASS_* constants.
'value' is a number which goes from 0 to 7. The higher the
value, the lower the I/O priority of the process.
On Windows only 'ioclass' is used and it can be set to 2
(normal), 1 (low) or 0 (very low).
Available on Linux and Windows > Vista only.
s$ 'ioclass' argument must be specifiedN( Rv R� R� R� t
ionice_set( Rj t ioclassR� ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt ionice� s
R� c C s3 | d k r | j j | � S| j j | | � Sd S( s" Get or set process resource limits as a (soft, hard)
tuple.
'resource' is one of the RLIMIT_* constants.
'limits' is supposed to be a (soft, hard) tuple.
See "man prlimit" for further info.
Available on Linux only.
N( Rv R� R� ( Rj t resourcet limits( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s
t cpu_affinity_getc C sE | d k r% t t | j j � � � S| j j t t | � � � d S( s� Get or set process CPU affinity.
If specified 'cpus' must be a list of CPUs for which you
want to set the affinity (e.g. [0, 1]).
(Windows, Linux and BSD only).
N( Rv t listR� R� R� t cpu_affinity_set( Rj t cpus( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt cpu_affinity� s c C s
| j j � S( s\ Return the number of handles opened by this process
(Windows only).
( R� t num_handles( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s c C s
| j j � S( sk Return the number of voluntary and involuntary context
switches performed by this process.
( R� t num_ctx_switches( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s c C s
| j j � S( s2 Return the number of threads used by this process.( R� t num_threads( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s c C s
| j j � S( s� Return threads opened by process as a list of
(id, user_time, system_time) namedtuples representing
thread id and thread CPU times (user/system).
On OpenBSD this method requires root access.
( R� t threads( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s c C s� t t d � r t j � } n d } g } | s5| d k r� x� t � D]d } yD | j � | j k r� | j � | j � k r� | j | � q� n WqF t t
f k
r� qF XqF Wq�x�| j � D]p \ } } | | j k r� y8 t | � } | j � | j � k r| j | � n Wq.t t
f k
r*q.Xq� q� Wn_t
j t � } | d k r�x� t � D]; } y | | j � j | � WqZt t
f k
r�qZXqZWnX xU | j � D]G \ } } y! t | � } | | j | � Wq�t t
f k
r�q�Xq�W| j g } x� | D]� } x� | | D]t } y | j � | j � k }
Wn t t
f k
rSqX|
r| j | � | j | k r�| j | j � q�qqWqW| S( s& Return the children of this process as a list of Process
instances, pre-emptively checking whether PID has been reused.
If recursive is True return all the parent descendants.
Example (A == this process):
A ─┐
│
├─ B (child) ─┐
│ └─ X (grandchild) ─┐
│ └─ Y (great grandchild)
├─ C (child)
└─ D (child)
>>> import psutil
>>> p = psutil.Process()
>>> p.children()
B, C, D
>>> p.children(recursive=True)
B, X, Y, C, D
Note that in the example above if process X disappears
process Y won't be listed as the reference to process A
is lost.
t ppid_mapN( R� R� R� Rv RR Ry Rt R� t appendRG RH t itemsRN t collectionst defaultdictR� ( Rj t recursiveR� Rp t pRt Ry t childt tablet checkpidst intime( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� s\
c sV | d k o | d k } t � � t r9 � f d � } n d � } | r� | � } | j j � } t j | � | � } | j j � } nX | j } | j } | � } | j j � } | d k s� | d k r� | | _ | | _ d S| j | j | j
| j
} | | } | | _ | | _ y | | d � }
Wn t k
rDd SXt |
d � Sd S( s� Return a float representing the current process CPU
utilization as a percentage.
When interval is 0.0 or None (default) compares process times
to system CPU times elapsed since last call, returning
immediately (non-blocking). That means that the first time
this is called it will return a meaningful 0.0 value.
When interval is > 0.0 compares process times to system CPU
times elapsed before and after the interval (blocking).
In this case is recommended for accuracy that this function
be called with at least 0.1 seconds between calls.
Examples:
>>> import psutil
>>> p = psutil.Process(os.getpid())
>>> # blocking
>>> p.cpu_percent(interval=1)
2.0
>>> # non-blocking (percentage since last call)
>>> p.cpu_percent(interval=None)
2.9
>>>
g c s t � � S( N( t _timer( ( t num_cpus( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt timer� s c S s
t t � � S( N( t sumRV ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s id i N(
Rv RY R� R� RV t timet sleepR� R� t usert systemt ZeroDivisionErrort round( Rj t intervalt blockingR� t st1t pt1t st2t pt2t
delta_proct
delta_timet overall_percent( ( R� sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRW e s8
c C s
| j j � S( s� Return a (user, system) namedtuple representing the
accumulated process time, in seconds.
This is the same as os.times() but per-process.
( R� RV ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRV � s c C s
| j j � S( s Return a tuple representing RSS (Resident Set Size) and VMS
(Virtual Memory Size) in bytes.
On UNIX RSS and VMS are the same values shown by 'ps'.
On Windows RSS and VMS refer to "Mem Usage" and "VM Size"
columns of taskmgr.exe.
( R� t memory_info( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR � s c C s
| j j � S( s� Return a namedtuple with variable fields depending on the
platform representing extended memory information about
this process. All numbers are expressed in bytes.
( R� t memory_info_ex( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR
� s c C sT | j j � d } t p" t � j } y | t | � d SWn t k
rO d SXd S( s� Compare physical system memory to process resident memory
(RSS) and calculate process memory utilization as a percentage.
i id g N( R� R t
_TOTAL_PHYMEMRT t totalt floatR ( Rj t rsst total_phymem( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt memory_percent� s
t memory_mapsc C s� | j j � } | r� i } xa | D]Y } | d } | d } y! t d � | | | � | | <Wq" t k
rz | | | <q" Xq" Wt j } g | D] } | | | | � ^ q� St j } g | D] } | | � ^ q� Sd S( s� Return process' mapped memory regions as a list of namedtuples
whose fields are variable depending on the platform.
If 'grouped' is True the mapped regions with the same 'path'
are grouped together and the different memory fields are summed.
If 'grouped' is False every mapped region is shown as a single
entity and the namedtuple will also include the mapped region's
address space ('addr') and permission set ('perms').
i i c S s | | S( N( ( R� t y( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt <lambda>� Rg N( R� R t mapR� R� t
pmmap_groupedt pmmap_ext( Rj t groupedt itt dt tuplR� t numsRe R� ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR � s
!
$ c C s
| j j � S( s� Return files opened by process as a list of
(path, fd) namedtuples including the absolute file name
and file descriptor number.
( R� t
open_files( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR � s t inetc C s | j j | � S( s� Return connections opened by process as a list of
(fd, family, type, laddr, raddr, status) namedtuples.
The 'kind' parameter filters for connections that match the
following criteria:
Kind Value Connections using
inet IPv4 and IPv6
inet4 IPv4
inet6 IPv6
tcp TCP
tcp4 TCP over IPv4
tcp6 TCP over IPv6
udp UDP
udp4 UDP over IPv4
udp6 UDP over IPv6
unix UNIX socket (both UDP and TCP protocols)
all the sum of all the possible families and protocols
( R� t connections( Rj t kind( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR! � s c C s� | j d k r t d � � n y t j | j | � Wn� t k
r� } | j t j k r� t r� t | j � r� t | j | j
| j � � q� t | _
t | j | j
� � n | j t j t j f k r� t | j | j
� � n � n Xd S( Ni s� preventing sending signal to process with PID 0 as it would affect every process in the process group of the calling process (os.getpid()) instead of PID 0( Rt R� R� R� t OSErrort errnot ESRCHt _OPENBSDRP RH R| R� R� R� RG t EPERMt EACCESRI ( Rj t sigR� ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt _send_signal s c C s� t r | j | � nn | t j k r5 | j j � nO | t t d t � � t t d t � � f k rx | j j | � n t d � � d S( s� Send a signal to process pre-emptively checking whether
PID has been reused (see signal module constants) .
On Windows only SIGTERM is valid and is treated as an alias
for kill().
t CTRL_C_EVENTt CTRL_BREAK_EVENTsP only SIGTERM, CTRL_C_EVENT and CTRL_BREAK_EVENT signals are supported on WindowsN(
R� R* t signalt SIGTERMR� R� R� t objectR� R� ( Rj R) ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� " s c C s* t r | j t j � n
| j j � d S( s� Suspend process execution with SIGSTOP pre-emptively checking
whether PID has been reused.
On Windows this has the effect ot suspending all process threads.
N( R� R* R- t SIGSTOPR� R� ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� 7 s c C s* t r | j t j � n
| j j � d S( s� Resume process execution with SIGCONT pre-emptively checking
whether PID has been reused.
On Windows this has the effect of resuming all process threads.
N( R� R* R- t SIGCONTR� R� ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� B s c C s* t r | j t j � n
| j j � d S( s� Terminate the process with SIGTERM pre-emptively checking
whether PID has been reused.
On Windows this is an alias for kill().
N( R� R* R- R. R� R� ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� M s c C s* t r | j t j � n
| j j � d S( sj Kill the current process with SIGKILL pre-emptively checking
whether PID has been reused.
N( R� R* R- t SIGKILLR� R� ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� X s c C s8 | d k r( | d k r( t d � � n | j j | � S( s� Wait for process to terminate and, if process is a children
of os.getpid(), also return its exit code, else None.
If the process is already terminated immediately return None
instead of raising NoSuchProcess.
If timeout (in seconds) is specified and process is still alive
raise TimeoutExpired.
To wait for multiple Process(es) use psutil.wait_procs().
i s" timeout must be a positive integerN( Rv R� R� R� ( Rj t timeout( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� b s N(= Rn Rm Rr Rv Rk R� R� Rs Rq R� R� R� R� R� R{ t propertyRt Ry Ru R� R� R� R� R� R� R� R� R� R� R� R� R� R� RN R� R� R� R� R� R� R� R� R� R� R� RW RV R R
R R� R R R! R* R� R� R� R� R� R� ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRN ; st / ) '
_ G
c B s5 e Z d Z d � Z d � Z d � Z d d � Z RS( sy A more convenient interface to stdlib subprocess.Popen class.
It starts a sub process and deals with it exactly as when using
subprocess.Popen class but in addition also provides all the
properties and methods of psutil.Process class as a unified
interface:
>>> import psutil
>>> from subprocess import PIPE
>>> p = psutil.Popen(["python", "-c", "print 'hi'"], stdout=PIPE)
>>> p.name()
'python'
>>> p.uids()
user(real=1000, effective=1000, saved=1000)
>>> p.username()
'giampaolo'
>>> p.communicate()
('hi
', None)
>>> p.terminate()
>>> p.wait(timeout=2)
0
>>>
For method names common to both classes such as kill(), terminate()
and wait(), psutil.Process implementation takes precedence.
Unlike subprocess.Popen this class pre-emptively checks wheter PID
has been reused on send_signal(), terminate() and kill() so that
you don't accidentally terminate another process, fixing
http://bugs.python.org/issue6973.
For a complete documentation refer to:
http://docs.python.org/library/subprocess.html
c O s2 t j | | � | _ | j | j j d t �d S( NR� ( t
subprocessRO t _Popen__subprocR� Rt R� ( Rj R} R~ ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRk � s c C s# t t t t � t t j � � � S( N( t sortedR� R� RO R5 ( Rj ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt __dir__� s c C ss y t j | | � SWnX t k
rn y t j | j | � SWqo t k
rj t d | j j | f � � qo Xn Xd S( Ns! %s instance has no attribute '%s'( R/ t __getattribute__t AttributeErrorR6 Rl Rn ( Rj Ru ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR9 � s
c C sD | j j d k r | j j St t | � j | � } | | j _ | S( N( R6 t
returncodeRv t superRO R� ( Rj R3 Rp ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR� � s
N( Rn Rm Rr Rk R8 R9 Rv R� ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRO x s
!
c C s
t j � S( s& Return a list of current running PIDs.( R� RQ ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRQ � s c C s@ | d k r t S| d k r/ t r/ | t � k St j | � Sd S( s� Return True if given PID exists in the current process list.
This is faster than doing "pid in psutil.pids()" and
should be preferred.
i N( R� R� RQ R� RP ( Rt ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRP � s
c c sR d � } d � } t t � � } t t j � � } | | } | | } x | D] } | | � qN Wx� t t t j � � t t j | � j � � � D]� \ } } y= | d k r� | | � Vn | j
� r� | Vn | | � VWq� t k
r� | | � q� t k
rI| d k rC| t k rCy
t | VWqFt
k
r?qFXqJ� q� Xq� Wd S( s� Return a generator yielding a Process instance for all
running processes.
Every new Process instance is only created once and then cached
into an internal table which is updated every time this is used.
Cached Process instances are checked for identity so that you're
safe in case a PID has been reused by another process, in which
case the cached instance is updated.
The sorting order in which processes are yielded is based on
their PIDs.
c S s t | � } | t | j <| S( N( RN t _pmapRt ( Rt t proc( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt add� s
c S s t j | d � d S( N( R= t popRv ( Rt ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt remove� s N( R� RQ R= t keysR7 R� R� R� t fromkeysRv R{ RG RI R� ( R? RA t at bt new_pidst gone_pidsRt R> ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRR � s2
)
c s� � � f d � } | d k rD | d k rD d | } t | � � n t � � t | � } � d k r� t � � r� t d t � � n | d k r� t � | } n x� | rC| d k r� | d k r� Pn xm | D]e } d t | � } | d k r%t | t � | � } | d k rPn | | | � q� | | | � q� W| � } q� W| rux | D] } | | d � qQW| � } n t � � t | � f S( s� Convenience function which waits for a list of processes to
terminate.
Return a (gone, alive) tuple indicating which processes
are gone and which ones are still alive.
The gone ones will have a new 'returncode' attribute indicating
process exit status (may be None).
'callback' is a function which gets called every time a process
terminates (a Process instance is passed as callback argument).
Function will return as soon as all processes terminate or when
timeout occurs.
Typical use case is:
- send SIGTERM to a list of processes
- give them some time to terminate
- send SIGKILL to those ones which are still alive
Example:
>>> def on_terminate(proc):
... print("process {} terminated".format(proc))
...
>>> for p in procs:
... p.terminate()
...
>>> gone, alive = wait_procs(procs, timeout=3, callback=on_terminate)
>>> for p in alive:
... p.kill()
c sy y | j d | � } Wn t k
r) nL X| d k sC | j � ru | | _ � j | � � d k ru � | � qu n d S( NR3 ( R� RJ Rv R{ R; R? ( R> R3 R; ( t callbackt gone( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt
check_gone2 s
i s* timeout must be a positive integer, got %ss callback %r is not a callableg �?N( Rv R� R� R R� R� R� t minR� ( t procsR3 RH RJ Ri t alivet deadlineR> t max_timeout( ( RH RI sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRS s6 "
c C s | r t j � St j � Sd S( sx Return the number of logical CPUs in the system (same as
os.cpu_count() in Python 3.4).
If logical is False return the number of physical cores only
(e.g. hyper thread CPUs are excluded).
Return None if undetermined.
The return value is cached after first call.
If desired cache can be cleared like this:
>>> psutil.cpu_count.cache_clear()
N( R� t cpu_count_logicalt cpu_count_physical( t logical( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRY k s
c C s | s t j � St j � Sd S( s� Return system-wide CPU times as a namedtuple.
Every CPU time represents the seconds the CPU has spent in the given mode.
The namedtuple's fields availability varies depending on the platform:
- user
- system
- idle
- nice (UNIX)
- iowait (Linux)
- irq (Linux, FreeBSD)
- softirq (Linux)
- steal (Linux >= 2.6.11)
- guest (Linux >= 2.6.24)
- guest_nice (Linux >= 3.2.0)
When percpu is True return a list of namedtuples for each CPU.
First element of the list refers to first CPU, second element
to second CPU and so on.
The order of the list is consistent across calls.
N( R� RV t
per_cpu_times( t percpu( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRV � s
RT c C s | d k o | d k } d � } | sz | rF t � } t j | � n t } | d k rd t � } n t � a | | t � Sg } | r� t d t � } t j | � n$ t } | d k r� t d t � } n t d t � a x3 t | t � D]" \ } } | j | | | � � q� W| Sd S( s� Return a float representing the current system-wide CPU
utilization as a percentage.
When interval is > 0.0 compares system CPU times elapsed before
and after the interval (blocking).
When interval is 0.0 or None compares system CPU times elapsed
since last call or module import, returning immediately (non
blocking). That means the first time this is called it will
return a meaningless 0.0 value which you should ignore.
In this case is recommended for accuracy that this function be
called with at least 0.1 seconds between calls.
When percpu is True returns a list of floats representing the
utilization as a percentage for each CPU.
First element of the list refers to first CPU, second element
to second CPU and so on.
The order of the list is consistent across calls.
Examples:
>>> # blocking, system-wide
>>> psutil.cpu_percent(interval=1)
2.0
>>>
>>> # blocking, per-cpu
>>> psutil.cpu_percent(interval=1, percpu=True)
[2.0, 1.0]
>>>
>>> # non-blocking (percentage since last call)
>>> psutil.cpu_percent(interval=None)
2.9
>>>
g c S sq t | � } | | j } t | � } | | j } | | k rB d S| | } | | } | | d } t | d � S( Ng id i ( R� t idleR ( t t1t t2t t1_allt t1_busyt t2_allt t2_busyt
busy_deltat all_deltat busy_perc( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt calculate� s
RT N( Rv RV R� R� t _last_cpu_timesR� t _last_per_cpu_timest zipR� ( R RT R R_ RV Rp t tot1RW ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRW � s, %
c C s | d k o | d k } d � } | sz | rF t � } t j | � n t } | d k rd t � } n t � a | | t � Sg } | r� t d t � } t j | � n$ t } | d k r� t d t � } n t d t � a x3 t | t � D]" \ } } | j | | | � � q� W| Sd S( s� Same as cpu_percent() but provides utilization percentages
for each specific CPU time as is returned by cpu_times().
For instance, on Linux we'll get:
>>> cpu_times_percent()
cpupercent(user=4.8, nice=0.0, system=4.8, idle=90.5, iowait=0.0,
irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
>>>
interval and percpu arguments have the same meaning as in
cpu_percent().
g c S s� g } t | � t | � } x� | j D]� } t | | � t | | � } y d | | } Wn t k
rs d } n Xt | d � } | d k r� d } n | d k r� d } n | j | � q& Wt j | � S( Nid g i g Y@( R� t _fieldsR� R R R� R� t scputimes( RV RW R R] t fieldt field_deltat
field_perc( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR_ s
RT N( Rv RV R� R� t _last_cpu_times_2R� t _last_per_cpu_times_2Rb R� ( R RT R R_ RV Rp Rc RW ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRX s,
c C s t j � } | j a | S( s� Return statistics about system memory usage as a namedtuple
including the following fields, expressed in bytes:
- total:
total physical memory available.
- available:
the actual amount of available memory that can be given
instantly to processes that request more memory in bytes; this
is calculated by summing different memory values depending on
the platform (e.g. free + buffers + cached on Linux) and it is
supposed to be used to monitor actual memory usage in a cross
platform fashion.
- percent:
the percentage usage calculated as (total - available) / total * 100
- used:
memory used, calculated differently depending on the platform and
designed for informational purposes only:
OSX: active + inactive + wired
BSD: active + wired + cached
LINUX: total - free
- free:
memory not being used at all (zeroed) that is readily available;
note that this doesn't reflect the actual memory available
(use 'available' instead)
Platform-specific fields:
- active (UNIX):
memory currently in use or very recently used, and so it is in RAM.
- inactive (UNIX):
memory that is marked as not used.
- buffers (BSD, Linux):
cache for things like file system metadata.
- cached (BSD, OSX):
cache for various things.
- wired (OSX, BSD):
memory that is marked to always stay in RAM. It is never moved to disk.
- shared (BSD):
memory that may be simultaneously accessed by multiple processes.
The sum of 'used' and 'available' does not necessarily equal total.
On Windows 'available' and 'free' are the same.
( R� RT R R ( Rp ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRT Z s 6 c C s
t j � S( s� Return system swap memory statistics as a namedtuple including
the following fields:
- total: total swap memory in bytes
- used: used swap memory in bytes
- free: free swap memory in bytes
- percent: the percentage usage
- sin: no. of bytes the system has swapped in from disk (cumulative)
- sout: no. of bytes the system has swapped out from disk (cumulative)
'sin' and 'sout' on Windows are meaningless and always set to 0.
( R� RU ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRU � s
c C s
t j | � S( s� Return disk usage statistics about the given path as a namedtuple
including total, used and free space expressed in bytes plus the
percentage usage.
( R� R` ( R� ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR` � s c C s
t j | � S( s3 Return mounted partitions as a list of
(device, mountpoint, fstype, opts) namedtuple.
'opts' field is a raw string separated by commas indicating mount
options which may vary depending on the platform.
If "all" parameter is False return physical devices only and ignore
all others.
( R� R_ ( t all( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR_ � s c C s� t j � } | s! t d � � n | r[ x- | j � D] \ } } t j | � | | <q4 W| St j g t | j � � D] } t | � ^ qt � Sd S( s� Return system disk I/O statistics as a namedtuple including
the following fields:
- read_count: number of reads
- write_count: number of writes
- read_bytes: number of bytes read
- write_bytes: number of bytes written
- read_time: time spent reading from disk (in milliseconds)
- write_time: time spent writing to disk (in milliseconds)
If perdisk is True return the same information for every
physical disk installed on the system as a dictionary
with partition names as the keys and the namedtuple
described above as the values.
On recent Windows versions 'diskperf -y' command may need to be
executed first otherwise this function won't find any disk.
s couldn't find any physical diskN( R� R^ t RuntimeErrorR� R t sdiskioRb t valuesR� ( t perdiskt rawdictt diskt fieldsR� ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR^ � s c C s� t j � } | s! t d � � n | r[ x- | j � D] \ } } t j | � | | <q4 W| St j g t | j � � D] } t | � ^ qt � Sd S( s Return network I/O statistics as a namedtuple including
the following fields:
- bytes_sent: number of bytes sent
- bytes_recv: number of bytes received
- packets_sent: number of packets sent
- packets_recv: number of packets received
- errin: total number of errors while receiving
- errout: total number of errors while sending
- dropin: total number of incoming packets which were dropped
- dropout: total number of outgoing packets which were dropped
(always 0 on OSX and BSD)
If pernic is True return the same information for every
network interface installed on the system as a dictionary
with network interface names as the keys and the namedtuple
described above as the values.
s# couldn't find any network interfaceN( R� RZ Rl R� R t snetioRb Rn R� ( t pernicRp t nicRr R� ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRZ � s R c C s
t j | � S( s
Return system-wide connections as a list of
(fd, family, type, laddr, raddr, status, pid) namedtuples.
In case of limited privileges 'fd' and 'pid' may be set to -1
and None respectively.
The 'kind' parameter filters for connections that fit the
following criteria:
Kind Value Connections using
inet IPv4 and IPv6
inet4 IPv4
inet6 IPv6
tcp TCP
tcp4 TCP over IPv4
tcp6 TCP over IPv6
udp UDP
udp4 UDP over IPv4
udp6 UDP over IPv6
unix UNIX socket (both UDP and TCP protocols)
all the sum of all the possible families and protocols
On OSX this function requires root privileges.
( R� R[ ( R" ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR[ s c
C s& t j d k } | r$ d d l } n t j � } | j d d � � t j t � } x� | D]� \ } } } } } } | r� y | j | � } Wq� t
k
r� t j d k r� | d k r� t j
} q� t t d � r� t j
| k r� t j
} q� q� Xn | | j t j | | | | | � � qY Wt | � S(
sJ Return the addresses associated to each NIC (network interface
card) installed on the system as a dictionary whose keys are the
NIC names and value is a list of namedtuples for each address
assigned to the NIC. Each namedtuple includes 5 fields:
- family
- address
- netmask
- broadcast
- ptp
'family' can be either socket.AF_INET, socket.AF_INET6 or
psutil.AF_LINK, which refers to a MAC address.
'address' is the primary address and it is always set.
'netmask' and 'broadcast' and 'ptp' may be None.
'ptp' stands for "point to point" and references the destination
address on a point to point interface (tipically a VPN).
'broadcast' and 'ptp' are mutually exclusive.
Note: you can have more than one address of the same family
associated with each interface.
i i i����Nt keyc S s | d S( Ni ( ( R� ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR 5 Rg Re RM ( i i ( t sysRK t socketR� R\ t sortR� R� R� t
AddressFamilyR� R� Ru RM R� R� R t snicR� (
t has_enumsRx t rawlistRp Ru t famt addrt maskt broadcastt ptp( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR\ s$
*c C s
t j � S( s Return information about each NIC (network interface card)
installed on the system as a dictionary whose keys are the
NIC names and value is a namedtuple with the following fields:
- isup: whether the interface is up (bool)
- duplex: can be either NIC_DUPLEX_FULL, NIC_DUPLEX_HALF or
NIC_DUPLEX_UNKNOWN
- speed: the NIC speed expressed in mega bits (MB); if it can't
be determined (e.g. 'localhost') it will be set to 0.
- mtu: the maximum transmission unit expressed in bytes.
( R� R] ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyR] H s c C s
t j � S( sA Return the system boot time expressed in seconds since the epoch.( R� Rb ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRb \ s c C s
t j � S( s� Return users currently connected on the system as a list of
namedtuples including the following fields.
- user: the name of the user
- terminal: the tty or pseudo-tty associated with the user, if any.
- host: the host name associated with the entry, if any.
- started: the creation time as a floating point number expressed in
seconds since the epoch.
( R� Ra ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyRa c s
c
C sF d d l } | j j � } d } d d d d d d d
g } t r_ | j d � | j d � n | d! GHx�t � D]�} y | j | d d �} Wn t k
r� qr X| d r� | j j | d � } | j � | k r� | j d � } q| j d � } n d } t
j d t
j t | d � � � } y | j
� } Wn t k
rOd } n Xt rxd | k rx| j d � d } n | d
r�t | d
j d � p�d } | d
r�t | d
j d � p�d }
| d r�t | d d � p�d } | | d | d | d | | |
| j d d � p d | | | d j � p8d f
GHqr Wd S(" sN List info of all currently running processes emulating ps aux
output.
i����Ns+ %-10s %5s %4s %4s %7s %7s %-13s %5s %7s %sRt RW R Ru RV R� R R� R� t USERt PIDs %CPUs %MEMt VSZt RSSt TTYt STARTt TIMEt COMMANDR� Rg s %H:%Ms %b%ds %M:%Ss \i i t ?i
(
R� R� s %CPUs %MEMR� R� R� R� R� R� ( t datetimet datet todayR� R� RR R� RG t
fromtimestampt strftimeR� t localtimeR� R� RF R� t splitR� t vmsR R t getRo ( R� t today_dayt templR� R� t pinfoR� t cputimeR� R� R t memp( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt testp s\
i i t __main__(� Rr t
__future__R R� R$ R� R� R- R5 Rw R� t tracebackR� R� Rv Rg R R t _compatR R R R� R R R R R
R R R
R R R R R R R R R R R R R R R R R R t platformR� t PROCFS_PATHR! R� R" R# R$ R% t HAS_PRLIMITR2 R& R' R( R) R* R+ R, R- R. R/ R0 R1 t RLIMIT_MSGQUEUER: t RLIMIT_NICEt
RLIMIT_RTPRIOt
RLIMIT_RTTIMEt RLIMIT_SIGPENDINGR4 t _psutil_windowsR5 R6 R7 R8 R9 R: R; R= RA RC RD RE R� t __all__t extendt __extra__all__t
__author__RL t tupleR� t numR� RK RM R Ru R� R� R& R� R� t replacet cextt __file__Ri t ExceptionRF RG RH RI RJ R� R/ RN RO RQ RP R= RR RS R� RY R� RV R` t print_excRa RW Ri Rj RX RT RU R` R_ R^ RZ R[ R\ R] Rb Ra R� Rn ( ( ( sQ C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\psutil3\__init__.pyt <module>
s�
.
� � � @D :[
[R < # .
8