ˀ6 f d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
n
# e$ r dZ
Y nw xY wddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddlm Z ddlm!Z! ddlm"Z" ddlm#Z# ddlm$Z$ ddlm%Z% ddlm&Z& dd lm'Z' dd lm(Z( dd lm)Z) dd lm*Z* dd lm+Z+ dd!lm,Z, dd"lm-Z- dd#lm.Z. dd$lm/Z/ dd%lm0Z0 dd&lm1Z1 dd'lm2Z2 dd(lm3Z3 dd)lm4Z4 dd*lm5Z5 dd+lm6Z6 dd,lm7Z7 dd-lm8Z8 dd.lm9Z9 dd/lm:Z: dd0lm;Z; dd1lmZ> dd4lm?Z@ dd5lAmBZC dd6lAmDZD dd7lAmEZE dd8lAmFZG dd9lAmHZH e r!d:ZIdd;lmJZK ddlJmNZN dd?lJmOZO ne8rIdd@lmPZK ddAlQmRZR ddBlQmSZS ddClQmTZT ddDlQmUZU ddElQmVZV ddFlQmWZW ddGlPmXZX ddHlPmYZY ddIlPmZZZ ddJlPm[Z[ ddKlPm\Z\ nGe!rddLlm]ZK n>erddMlm^ZK n5e7rddNlm_ZK ddOl_m`Z` ddPl_maZa d:ZIn er ddQlmbZK d:ZIn ecdRe
jd z g dSZeeef eKjg eheKji dT roddUlmjZj ek ZldZm enej D ]OZmemo dV r8emp r$ eqejem elem< eer em P[l[meKjs ZsdWZtdXZu evdY euw dZ D Zx eqe d[e j Zydazda{ e| Z} e~eu dZd\ eqeKj d]d k rd^eKj j z Z eheKj d] r=ed_dZ d` eeKj j D daeudbz
Znedceuz z
Zedd eqeKj dedf z z
Zedgz
Z ee eheKdh reKj Zndi Zdj Zdk Z G dl dme| Zi edn enei D Z G do dpei Zdq Zdr Zi addsZddtZddvZddxZ e an
# e$ r daY nw xY w eduy an
# e$ r daY nw xY wdz Zd{ Zd| Zdd}Zt( at, add~Zd Z eheKd rddZeer d ehed s eheKd r0 ehed rej ZneKj Zeer d d Zd Zd ZddZddZ ej e@j d e_ dej _ ddZ ej e@j d e_ dej _ ddZd Zd Z eheKd rddZeer d eheKd rd Zeer d eheKd rd Zeer d d Zd Ze8rd Zd Zd Zd Z[>[e
jx d dk r[[edk r e dS dS )a/ psutil is a cross-platform library for retrieving information on
running processes and system utilization (CPU, memory, disks, network,
sensors) in Python. Supported platforms:
- Linux
- Windows
- macOS
- FreeBSD
- OpenBSD
- NetBSD
- Sun Solaris
- AIX
Works with Python versions 2.7 and 3.4+.
)divisionN )_common)AIX)BSD)
CONN_CLOSE)CONN_CLOSE_WAIT) CONN_CLOSING)CONN_ESTABLISHED)CONN_FIN_WAIT1)CONN_FIN_WAIT2)
CONN_LAST_ACK) CONN_LISTEN) CONN_NONE)
CONN_SYN_RECV)
CONN_SYN_SENT)CONN_TIME_WAIT)FREEBSD)LINUX)MACOS)NETBSD)NIC_DUPLEX_FULL)NIC_DUPLEX_HALF)NIC_DUPLEX_UNKNOWN)OPENBSD)OSX)POSIX)POWER_TIME_UNKNOWN)POWER_TIME_UNLIMITED) STATUS_DEAD)STATUS_DISK_SLEEP) STATUS_IDLE)
STATUS_LOCKED)
STATUS_PARKED)STATUS_RUNNING)STATUS_SLEEPING)STATUS_STOPPED)STATUS_TRACING_STOP)STATUS_WAITING)
STATUS_WAKING)
STATUS_ZOMBIE)SUNOS)WINDOWS) AccessDenied)Error)
NoSuchProcess)TimeoutExpired)
ZombieProcess)memoize_when_activated) wrap_numbers)PY3)PermissionError)ProcessLookupError)SubprocessTimeoutExpired)longz/proc)_pslinux)IOPRIO_CLASS_BE)IOPRIO_CLASS_IDLE)IOPRIO_CLASS_NONE)IOPRIO_CLASS_RT)
_pswindows)ABOVE_NORMAL_PRIORITY_CLASS)BELOW_NORMAL_PRIORITY_CLASS)HIGH_PRIORITY_CLASS)IDLE_PRIORITY_CLASS)NORMAL_PRIORITY_CLASS)REALTIME_PRIORITY_CLASS)CONN_DELETE_TCB) IOPRIO_HIGH)
IOPRIO_LOW)
IOPRIO_NORMAL)IOPRIO_VERYLOW)_psosx)_psbsd)_pssunos)
CONN_BOUND) CONN_IDLE)_psaixz platform %s is not supported)Gr/ r0 r2 r. r1 version_info __version__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 AF_LINKr r r r r r r r r r r r r r, r- r ProcessPopen
pid_existspids process_iter
wait_procsvirtual_memory swap_memory cpu_times cpu_percentcpu_times_percent cpu_count cpu_statsnet_io_countersnet_connections net_if_addrs net_if_statsdisk_io_countersdisk_partitions
disk_usageusers boot_timerlimit)
_psutil_posixRLIMzGiampaolo Rodola'z5.9.5c , g | ]}t | S )int).0nums c/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib64/python3.11/site-packages/psutil/__init__.py
rs s AAA3c#hhAAA . monotonic versionzOversion conflict: %r C extension module was built for another version of psutilz (c g | ]}|S rn rn rp xs rr rs rs s ???Aa???rt z instead of )z (different than %s)z;; you may try to 'pip uninstall psutil', manually remove %s__file__z%the existing psutil install directoryz1 or clean the virtual env somehow, then reinstallppid_mapc i } t D ]C} t j | | |< -# t t
f$ r Y @w xY w| S )z{Return a {pid: ppid, ...} dict for all running processes in
one shot. Used to speed up Process.children().
)rW _psplatformrT ppidr0 r2 )retpids rr _ppid_mapr sm 66 C
&.s3388::C!=1
s )>AAc F t j fd }|S )zpDecorator which raises NoSuchProcess in case a process is no
longer running or its PID has been reused.
c | s(| j rd}nd }t | j | j | | g|R i |S )Nz4process no longer exists and its PID has been reusedmsg)
is_running _pid_reusedr0 r _name)selfargskwargsr funs rr wrapperz'_assert_pid_not_reused..wrapper se ?
L $*#>>> >s4)$)))&)))rt ) functoolswraps)r r s ` rr _assert_pid_not_reusedr
s: _S* * * * * Nrt c t j }t || z
}|dk rd}nd}t j | | S )z(Format seconds in a human readable form.iQ z%H:%M:%Sz%Y-%m-%d %H:%M:%S)timero datetime
fromtimestampstrftime)secsnowsecs_agofmts rr _pprint_secsr sX
)++C3:H, ! * *4 0 0 9 9# > >>rt c | e Zd ZdZdEdZdFdZd ZeZd Zd Z d Z
e d
Z e
j d ZdGd Zd
Zd Zd Zed Zd Zd Zd Zd Zd Zd Zd Z dEdZ e red Z d Z d Z!d Z" e#e$j% d rd Z& e#e$j% d rdGd Z' e#e$j% d! rdEd"Z( e#e$j% d# rdEd$Z) e#e$j% d% rd& Z* e#e$j% d' rd( Z+e,rd) Z-d* Z.d+ Z/ e#e$j% d, rd- Z0e1dFd. Z2dEd/Z3ed0 Z4ed1 Z5 e6j7 d23 d4 Z8d5 Z9dHd7Z: e#e$j% d8 rdId:Z;d; Z Z>e1d? Z?e1d@ Z@e1dA ZAe1dB ZBe1dC ZCdEdDZDdS )KrT a) 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
Nc 0 | | d S N)_init)r r s rr __init__zProcess.__init__K s
3rt Fc |t j }nMt s.t |t t
f st
d|z |dk rt d|z || _ d | _ d | _
d | _ d| _ d| _
d | _ t j | _ d | _ t' j | | _ d | _ d | _ t0 | _ | n@# t6 $ r Y n4t8 $ r Y n)t: $ r |st; |d d| _ Y nw xY w| j | j f| _ d S )Nz pid must be an integer (got %r)r z'pid must be a positive integer (got %s)Fzprocess PID not foundr T) osgetpid_PY3
isinstancero r9 TypeError
ValueError_pidr _exe _create_time_goner _hash threadingRLock_lock_ppidr rT _proc_last_sys_cpu_times_last_proc_cpu_times _SENTINEL _exitcode create_timer. r2 r0 r _ident)r r _ignore_nsps rr r z
Process._initN s ;)++CC
I
3d < <
I AC GHHHQww !J#&"' ( ( (
_&&
!(--
#' $(!" "
D
D " " "
"#C-DEEEE !
" x!23 s (C= =
D: D:#D:9D:c
t j }| j |d< | j r
| j |d< | 5 | |d< | |d< n0# t $ r d|d< Y n t $ r d|d< Y nt $ r Y nw xY w| j
t d fvr
| j
|d< | j rt | j |d< | j j d| j j d d
d | D d cd d d S # 1 swxY w Y d S )
Nr namestatuszombie
terminatedexitcodestartedru (, c " g | ] \ }}|d |
S )=rn )rp kvs rr rs z#Process.__str__.. s' EEE1aaa+EEErt r| ) collections OrderedDictr r oneshotr r r2 r0 r. r r r r __class__
__module____name__joinitems)r infos rr __str__zProcess.__str__~ s &((hU : & :DL
\\^^ H H
#yy{{V !% X
*
*
*!)X
.
.
.!-X
~i%666#'>Z
B".t/@"A"AY)))''' EE
EEEFFFFH H H H H H H H H H H H H H H H H H HsO D6.A43D64B!D6B!D6 B! D6 B!!BD66D:=D:c Z t |t st S | j |j k S r )r rT NotImplementedr r others rr __eq__zProcess.__eq__ s+ %)) "! !{el**rt c | |k S r rn r s rr __ne__zProcess.__ne__ s 5= rt c P | j t | j | _ | j S r )r hashr r s rr __hash__zProcess.__hash__ s# : dk**DJzrt c | j S )zThe process PID.)r r s rr r z Process.pid s yrt c # K | j 5 t | d rdV n | j | | j | | j | t r| j | | j dV | j
| | j
| | j
| t r| j
| | j n# | j
| | j
| | j
| t r| j
| | j w xY wddd dS # 1 swxY w Y dS )a# Utility context manager which considerably speeds up the
retrieval of multiple process information at the same time.
Internally different process info (e.g. name, ppid, uids,
gids, ...) may be fetched by using the same routine, but
only one information is returned and the others are discarded.
When using this context manager the internal routine is
executed once (in the example below on name()) and the
other info are cached.
The cache is cleared when exiting the context manager block.
The advice is to use this every time you retrieve more than
one information about the process. If you're lucky, you'll
get a hell of a speedup.
>>> import psutil
>>> p = psutil.Process()
>>> with p.oneshot():
... p.name() # collect multiple info
... p.cpu_times() # return cached value
... p.cpu_percent() # return cached value
... p.create_time() # return cached value
...
>>>
_cacheN) r hasattrr\ cache_activate memory_infor r uidsr
oneshot_entercache_deactivate oneshot_exitr s rr r zProcess.oneshot s
6 Z & . & .tX&& %
. .N11$777$33D999I,,T222 7 00666J,,...EEEN33D999$55d;;;I..t444 9 224888J++---- N33D999$55d;;;I..t444 9 224888J++----M& . & . & . & . & . & . & . & . & . & . & . & . & . & . & . & . & . & .s+ GB D7.B G7B
GGGGc t }|t |t t t t
f s t
dt | z t | }||z
}|rPt dt | dk rdnddd
t t | i }|p|}|
5 |D ]X} |d k r| j }nt | | } | }n'# t t" f$ r |}Y nt$ $ r |r Y Ow xY w|||< Y ddd n # 1 swxY w Y |S )
a 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.
Nzinvalid attrs type %szinvalid attr namer srw r r )_as_dict_attrnamesr listtupleset frozensetr typer lenr mapreprr r getattrr. r2 NotImplementedError)
r attrsad_value valid_names
invalid_namesretdictlsr r meths
rr as_dictzProcess.as_dict s ) edE3 %BCC
G 7$u++ EFFFJJE !K /M
: j }--11CCr99IIc$
6 6777"9 : : :
!k
\\^^ $ $
$
$ u}} "h &tT 2 2 "dff$m4 # # #"CCC* H
!$
!
$ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $$ sB D:(D ?D: D$D: D$!D:#D$$ D::D>D>c 2 t t nt d }| j |k rdS | }|Q| } t | }| |k r|S dS # t $ r Y dS w xY wdS )zReturn the parent process as a Process object pre-emptively
checking whether PID has been reused.
If no parent is known return None.
Nr ) _LOWEST_PIDrW r r r rT r0 )r
lowest_pidr ctimeparents rr r zProcess.parent s
%0$;[[
8z ! !4yy{{ $$&&E
%%''500!M 10 !
s (B
BBc g }| }|+| | | }|+|S )zReturn the parents of this process as a list of Process
instances. If no parents are known return an empty list.
)r append)r parentsprocs rr r zProcess.parents0 sJ {{}} NN4 ;;==D rt c | j s| j rdS | t | j k | _ | j S # t $ r Y dS t
$ r d| _ Y dS w xY w)zReturn whether this process is running.
It also checks if PID has been reused by another process in
which case return False.
FT)r r rT r r2 r0 r s rr r zProcess.is_running; s
: ) 5 $wtx'8'8 8D '' ' 44 DJ55 s $7
AAAc t r| j S | j p| j | _ | j S )z`The process parent PID.
On Windows the return value is cached after first call.
)r r r r r s rr r z Process.ppidT s@ :??$$ $ 8tz'8'8DJ: rt c t r| j | j S | j }t r~t | dk rk | }|rThe process name. The return value is cached after first call.N r )
r- r r r r r cmdliner pathbasename
startswithr. r2 )r r r
extended_names rr r z Process.namef s
tz-: z -SYY"__
- ,,.. -$&G$4$4WQZ$@$@M$//55 - , !-0
s
B B10B1c fd} j e j }|s || }n# t $ r Y nw xY w| _ n## t $ r} || cY d}~S d}~ww xY w j S )zThe process executable as an absolute path.
May also be an empty string.
The return value is cached after first call.
c }|rt t d r|t t d rg|d }t j | r@t j | r!t j |t j r|S t | t r| | S )NaccessX_OKr )
r
r r r isabsisfiler r r r. )fallbackr
exer s rr guess_itz Process.exe..guess_it s llnnG
72x00
WR5H5H
aj GMM#&& s++ #rw// J(L11
Ort N)r )r r r r. )r r r errs ` rr r z Process.exe s
" 9
jnn&& &h 4 4 4'
.
.
. x---------
. ys, A 8
AA
A0 A+%A0+A0c 4 | j S )z3The command line this process has been called with.)r r
r s rr r
zProcess.cmdline s z!!###rt c d | j S # t $ r
t cY S w xY w)z2The process current status as a STATUS_* constant.)r r r2 r+ r s rr r zProcess.status sB !:$$&& & ! ! ! !s //c t rht t d | j } t j | j S # t $ r t | cY S w xY w| j
S )ztThe name of the user that owns the process.
On UNIX this is calculated by using *real* process uid.
Nz0requires pwd module shipped with standard python) r pwd ImportErrorr realgetpwuidpw_nameKeyErrorstrr username)r real_uids rr r# zProcess.username s ){!FH H Hyy{{'H
%|H--55
%
%
%8}}$$$
% :&&(( (s A A-,A-c Z | j | j | _ | j S )zThe process creation time as a floating point number
expressed in seconds since the epoch.
The return value is cached after first call.
)r r r r s rr r zProcess.create_time s,
$ $
6 6 8 8D rt c 4 | j S )z6Process current working directory as an absolute path.)r cwdr s rr r' z Process.cwd s z~~ rt c || j S | st | j | j | j | dS )z'Get or set process niceness (priority).N)r nice_getr r0 r r nice_set)r values rr nicez Process.nice s] =:&&(( (??$$
:#DHdj999 J & & & & &rt c 4 | j S )zVReturn process UIDs as a (real, effective, saved)
namedtuple.
)r r r s rr r z Process.uids s
:??$$ $rt c 4 | j S )zVReturn process GIDs as a (real, effective, saved)
namedtuple.
)r gidsr s rr r/ z Process.gids s :??$$ $rt c 4 | j S )zVThe terminal associated with this process, if any,
else None.
)r terminalr s rr r1 zProcess.terminal s :&&(( (rt c 4 | j S )zcReturn the number of file descriptors opened by this
process (POSIX only).
)r num_fdsr s rr r3 zProcess.num_fds s :%%'' 'rt io_countersc 4 | j S )a
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 r4 r s rr r4 zProcess.io_counters s :))++ +rt
ionice_getc |*|t d | j S | j || S )a 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.
Nz$'ioclass' argument must be specified)r r r6
ionice_set)r ioclassr+ s rr ionicezProcess.ionice sJ $$%KLLLz,,...z,,We<<