Ë
|
Iñúh` ã óÎ d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
|
Z
|
ddl Z ddl Z ddlmZ ddlmZ 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; dd1lm<Z< dd2lm=Z= dd3lm>Z> dd4lm?Z@ e r!d5ZAdd6lmBZC dd7lBmDZD dd8lBmEZE dd9lBmFZF dd:lBmGZG ne7rIdd;lmHZC dd<lImJZJ dd=lImKZK dd>lImLZL dd?lImMZM dd@lImNZN ddAlImOZO ddBlHmPZP ddClHmQZQ ddDlHmRZR ddElHmSZS ddFlHmTZT nLe rddGlmUZC nCerddHlmVZC n:e6rddIlmWZC ddJlWmXZX ddKlWmYZY d5ZAn#er ddLlmZZC d5ZAndMe j¶ dNZ\ e]e\« g dO¢Z^e^j¿ eCjÀ « eaeCjÄ dP« r^ddQlmcZc ed« ZedZf egec« D ]B ZfefjÑ dR« sefjÓ « s& ejecef« eeef< e^j× ef« D [e[feCjØ ZldSZmdTZn eodU enjá dV« D « « Zq eje dWe j « Zrdasdat eu« Zv ewenjñ dVdX« « ejeCjò dYd« k7 r¢dZeCjò jô d[Z\e\d\z Z\ eaeCjò dY« r>dVj÷ e| e}eCjò jü « « « Ze\d]e d^en d_z Z\n e\d`en d_z Z\ ejeCjò dadb« Ze\dce z Z\e\ddz Z\ e e\« eaeCde« reCj Zndf Zdg Zdh Z G di dj« Zb egeb« D ch c] } | jÑ dk« r| dlvs| c} Z
G dm dneb« Zdo Zdp Zi a e« ZddqZdr e_ dsej _ ddtZddvZddwZ e
|
j" « j$ e« iZ e
|
j" « j$ edu¬x« iZdy Zdz Zd{ Zdd|Zej5 « Zej5 « Zdd}Zd~ Z eaeCd« rddZe^j× d« eaed« s eaeCd« r5 eaed« rej@ Z n eCj@ Z e^j× d« d Z¡d Z¢d Z£dd
Z¤ddZ¥ ejL e@j d« e¥_ de¥j _ ddZ§ ejL e@j d« e§_ de§j _ ddZ¨d Z©d Zª eaeCd« rddZ«e^j× d« eaeCd« rd Z¬e^j× d« eaeCd« rd Ze^j× d« d Z®d Z¯e7rd Z°d Z±d Z²[>y# e $ r dZ Y w xY wc c} w # e$ r i ZY Õw xY w# e$ r i ZY ¼w xY w)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
|
|
Supported Python versions are cPython 3.6+ and PyPy.
|
é Né )Ú_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)Údebug)Úmemoize_when_activated)Ú wrap_numbersz/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 z is not supported)Gr. r/ r1 r- r0 Ú 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 ÚProcessÚPopenÚ
|
pid_existsÚpidsÚ process_iterÚ
|
wait_procsÚvirtual_memoryÚ swap_memoryÚ cpu_timesÚ cpu_percentÚcpu_times_percentÚ cpu_countÚ cpu_statsÚnet_io_countersÚnet_connectionsÚ net_if_addrsÚ net_if_statsÚdisk_io_countersÚdisk_partitionsÚ
|
disk_usageÚusersÚ boot_timeÚrlimit)Ú _psutil_posixÚRLIMzGiampaolo Rodola'z7.1.1c # ó2 K | ] }t |« y w©N)Úint)Ú.0Únums úBH:\Change_password\venv_build\Lib\site-packages\psutil/__init__.pyú <genexpr>rn Ñ s è ø Ò@ #SXÑ@ùó ú.Ú monotonicÚ Úversionzversion conflict: z C extension z.module was built for another version of psutilz (z instead of ú)z (different than Ú__file__z%the existing psutil install directoryz9; you may try to 'pip uninstall psutil', manually remove z1 or clean the virtual env somehow, then reinstallÚppid_mapc ó i } t « D ]) } t j |« j « | |< + | S # t t
|
f$ r Y ?w xY w)z{Return a {pid: ppid, ...} dict for all running processes in
|
one shot. Used to speed up Process.children().
|
)rR Ú _psplatformrO Úppidr/ r1 )ÚretÚpids rm Ú _ppid_mapr| ü s\ ð Ü6ò Cð Ü&×.Ñ.¨sÓ3×8Ñ8Ó:Cð ð
|
|
øô "¤=Ð1ò Ùð ús &;»A Á A c ó´ t j « }t || z
|
« }|dk rdnd}t j j | « j |« S )z(Format seconds in a human readable form.iQ z%H:%M:%Sz%Y-%m-%d %H:%M:%S)Útimerj ÚdatetimeÚ fromtimestampÚstrftime)ÚsecsÚnowÚsecs_agoÚfmts rm Ú _pprint_secsr sK ä
|
))+CÜ3:HØ <Ò/*Ð5HCÜ × Ñ × *Ñ *¨4Ó 0× 9Ñ 9¸#Ó >Ð>ó c ód t t j « }| |vrd| d| }t |« y)z+Check net_connections()'s `kind` parameter.zinvalid kind argument z; valid ones are: N)Útupler Ú conn_tmapÚ
|
ValueError)ÚkindÚkindsÚmsgs rm Ú_check_conn_kindr s< ä '×#Ñ#Ó $EØ 5ÑØ& t hÐ.@ÀÀÐHÜoÐ ð r c ó, e Zd ZdZdCdZdDdZd Zd ZeZd Z d Z
|
d Z d
|
Z e d « Zej d « ZdEd Zd Zd Zd Zed « Zd Zd Zd Zd Zd Z d Z d Z dCdZ e red « Z!d Z"d Z#d Z$ e%e&jN d « rd Z( e%e&jN d « rdEd!Z) e%e&jN d"« rdCd#Z* e%e&jN d$« rdCd%Z+ e%e&jN d&« rd' Z, e%e&jN d(« rd) Z-e.rd* Z/d+ Z0d, Z1 e%e&jN d-« rd. Z2dDd/Z3dCd0Z4ed1 « Z5ed2 « Z6d3 Z7dFd4Z8 e%e&jN d5« rdGd6Z9d7 Z:dHd8Z; e<jz d9¬:« dHd;« Z>e rd< Z?d= Z@d> ZAd? ZBd@ ZCdA ZDdCdBZEy)IrO 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 that
|
the PID of the process being queried has been reused. That means
|
that you may end up retrieving information for another process.
|
|
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.
|
Nc ó& | j |« y ri )Ú_init)Úselfr{ s rm Ú__init__zProcess.__init__: s Ø
|
|
3r c ó² |t j « }n6|dk rd| d}t |« t j j |« || _ d | _ d | _
|
d | _ d| _ d| _ d | _ t j « | _ d | _ t j& |« | _ d | _ d | _ t. | _ | j2 d f| _ | j7 « | _ y # t $ r}d}t ||¬« |d }~ww xY w# t8 $ r Y y t: $ r Y y t $ r |sd}t ||¬« d d| _ Y y w xY w) Nr z$pid must be a positive integer (got rt zprocess PID out of range©r Fzprocess PID not foundT) ÚosÚgetpidr rx ÚcextÚcheck_pid_rangeÚ OverflowErrorr/ Ú_pidÚ_nameÚ_exeÚ _create_timeÚ_goneÚ _pid_reusedÚ_hashÚ threadingÚRLockÚ_lockÚ_ppidrO Ú_procÚ_last_sys_cpu_timesÚ_last_proc_cpu_timesÚ _SENTINELÚ _exitcoder{ Ú_identÚ
|
_get_identr- r1 )r r{ Ú _ignore_nspr Úerrs rm r z Process._init= sP Ø ;Ü))+CàQwØ<¸S¸EÀÐCÜ oÐ%ð ;Ü× Ñ ×0Ñ0°Ô5ð
|
Ø
|
Ø Ø ÔØ
|
Ø ÔØ
|
Ü __Ó&
|
à
|
ô !×(Ñ(¨Ó-
|
Ø#'Ô Ø$(Ô!Ü"Øxx Ð& ð Ø //Ó+DKøô- !ò ;Ø0Ü# C¨SÔ1°sÐ:ûð ;ûô. ò ñ Ü ò ñ Ü ò Ù Ø-Ü# C¨SÔ1°tÐ;Ø DJð ús5 ¯ C< Ã&D Ã< DÄDÄDÄ EÄ(EÄ2!EÅEc ó, t r9| j j d¬« | _ | j | j fS t
|
s t st r(| j | j j d¬« fS | j | j « fS )aq Return a (pid, uid) tuple which is supposed to identify a
|
Process instance univocally over time. The PID alone is not
|
enough, as it can be assigned to a new process after this one
|
terminates, so we add process creation time to the mix. We need
|
this in order to prevent killing the wrong process later on.
|
This is also known as PID reuse or PID recycling problem.
|
|
The reliability of this strategy mostly depends on
|
create_time() precision, which is 0.01 secs on Linux. The
|
assumption is that, after a process terminates, the kernel
|
won't reuse the same PID after such a short period of time
|
(0.01 secs). Technically this is inherently racy, but
|
practically it should be good enough.
|
|
NOTE: unreliable on FreeBSD and OpenBSD as ctime is subject to
|
system clock updates.
|
T)Ú fast_only)rq )r, r§ Ú create_timer r{ r r r ©r s rm r zProcess._get_identl sz õ& ð !%§
|
¡
|
× 6Ñ 6ÀÐ 6Ó FDÔ ØHHd× /Ñ /Ð0Ð 0Ý f¥ð HHdjj× 4Ñ 4¸tÐ 4Ó DÐEÐ EàHHd× .Ñ .Ó 0Ð1Ð 1r c ó t j « }| j |d< | j r| j |d< | j « 5 | j
|
rd|d< n' | j « |d< | j « |d< | j t d hvr| j |d< | j t | j « |d< d j | j j" | j j$ d
|
j' |j) « D cg c] \ }}| d | c}}« « cd d d « S # t $ r d|d< Y Ðt $ r d|d< Y ßt $ r Y éw xY wc c}}w # 1 sw Y y xY w) Nr{ Únamezterminated + PID reusedÚstatusÚzombieÚ
|
terminatedÚexitcodeÚstartedz {}.{}({})ú, ú=)Ú collectionsÚ OrderedDictr{ r Úoneshotr¡ rµ r¶ r1 r/ r- r« rª r r ÚformatÚ __class__Ú
|
__module__Ú__name__ÚjoinÚitems)r ÚinfoÚkÚvs rm Ú__str__zProcess.__str__ sX Ü×&Ñ&Ó(ØhhU Ø ::Ø ::DLØ \\^ñ Ø× Ò Ø!:XðØ#'§9¡9£;DLØ%)§[¡[£]DNð ~~¤i°Ð%6Ñ6Ø#'§>¡>ZÑ Ø× Ñ Ð,Ü".¨t×/@Ñ/@Ó"AYà ×%Ñ%Ø×)Ñ)Ø×'Ñ'Ø °D·J±J³L×A©D¨A¨qaS ! <ÓAÓBó÷' ñ øô %ò .Ø%-DNÜ$ò 2Ø%1DNÜ#ò Ùðüó B÷- ð úsU ÁE<Á#&E  BE<Ä#E6Ä4 E<Å E3ÅE<Å E3Å&E<Å(E3Å0E<Å2E3Å3 E<Å<Fc ó t |t « st S t s t st
|
r?| j \ }}|j \ }}||k( r |r|s | j « t k( S | j |j k( S # t $ r Y $w xY wri )
|
Ú
|
isinstancerO ÚNotImplementedr r r+ r¬ r¶ r* r. )r ÚotherÚpid1Úident1Úpid2Úident2s rm Ú__eq__zProcess.__eq__¯ s ô %¤Ô)Ü!Ð !Ý f¥ð ;;LD&Ø <<LD&Øt|Ù¡&ð Ø #{{}´ Ñ =Ð=ð {{ellÑ*Ð*øô !ò Ù ð ús ÁB  B  B c ó | |k( S ri © )r rÍ s rm Ú__ne__zProcess.__ne__Ä s Ø5=Ð Ð r c óf | j t | j « | _ | j S ri )r¢ Úhashr¬ r³ s rm Ú__hash__zProcess.__hash__Ç s& Ø ::Ð Ü dkkÓ*DJØzzÐr c ó | j s | j « s1| j r$d}t | j | j |¬« yy)z9Raises NoSuchProcess in case process PID has been reused.z4process no longer exists and its PID has been reusedr N)r¡ Ú
|
is_runningr/ r{ r )r r s rm Ú_raise_if_pid_reusedz Process._raise_if_pid_reusedÌ sD à × Ò D§O¡OÔ$5¸$×:JÒ:Jð ICÜ §¡¨$¯*©*¸#Ô>Ð >ð ;KÐ$5r c ó | j S )zThe process PID.)r r³ s rm r{ z Process.pidØ s ð yyÐr c # óÎ K | j 5 t | d« rd n | j j | « | j j | « | j
|
j | « t r| j j | « | j j « d | j j | « | j j | « | j
|
j | « t r| j j | « | j j « ddd« y# | j j | « | j j | « | j
|
j | « t r| j j | « | j j « w xY w# 1 sw Y yxY ww)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¥ ÚhasattrrW Úcache_activateÚ memory_infory r Úuidsr§ Ú oneshot_enterÚcache_deactivateÚ oneshot_exitr³ s rm r¿ zProcess.oneshotß s] è ø ð6 ZZñ & .ÜtXÔ&õ ð.àNN×1Ñ1°$Ô7à×$Ñ$×3Ñ3°DÔ9àII×,Ñ,¨TÔ2å Ø ×0Ñ0°Ô6àJJ×,Ñ,Ô.ÛàNN×3Ñ3°DÔ9Ø×$Ñ$×5Ñ5°dÔ;ØII×.Ñ.¨tÔ4Ý Ø ×2Ñ2°4Ô8ØJJ×+Ñ+Ô-÷M& .ð & .øðB NN×3Ñ3°DÔ9Ø×$Ñ$×5Ñ5°dÔ;ØII×.Ñ.¨tÔ4Ý Ø ×2Ñ2°4Ô8ØJJ×+Ñ+Õ-ú÷M& .ð & .üs6 G%G£BEÂ3B GÄ? G%ÅBGÇGÇG"Ç G%c óJ t }|t |t t t t
|
f« sdt |« }t |« t |« }||z
|
}|rJdj t |« dkD rdnddj t t |« « « }t |« i }|xs |}| j « 5 |D ]- } |dk( r | j } nt! | |« }
|
|
|
« } | ||< / ddd« |S # t" t$ f$ r |} Y %t& $ r |r Y [w xY w# 1 sw Y |S xY w) 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 zinvalid attr name{} {}r Úsrr r» r{ )Ú_as_dict_attrnamesrË Úlistr ÚsetÚ frozensetÚtypeÚ TypeErrorrÀ ÚlenrÄ ÚmapÚreprr r¿ r{ Úgetattrr- r1 ÚNotImplementedError) r ÚattrsÚad_valueÚ valid_namesr Ú invalid_namesÚretdictÚlsrµ rz Úmeths rm Úas_dictzProcess.as_dict" s8 ô ) Ø Ð Ü e¤d¬E´3¼ Ð%BÔCØ+¬D°«K¨=Ð9Ü nÐ$ÜJEØ ! KÑ /MÙ Ø.×5Ñ5Ü }Ó-°Ò1C°rØIIc¤$¨ Ó 6Ó7óô ! oÐ%àØ Ò !kØ \\^ñ $Øò $ð Øu}Ø "hhä & t¨TÓ 2Ù "fð !$ ñ! $÷ $ð$ øô %¤mÐ4ò #Ø"CÜ*ò ñ Ø Ù ð ú÷ $ð$ ús< Â6DÂ=%C4Ã"DÃ4DÄDÄ DÄDÄDÄDÄD"c ó" t t n t « d }| j |k( ry| j « }|Et | j « j « } t |« }|j « |k r|S yy# t $ r Y yw xY w)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_PIDrR r{ ry rO r² r/ )r Ú
|
lowest_pidry Ú
|
proc_ctimeÚparents rm rÿ zProcess.parentQ s ô
|
%0Ð$;[ÄÃÈÁ
|
Ø 88zÒ !ØØyy{Ø Ð ô ! §¡Ó*×6Ñ6Ó8Jð Ü Ø×%Ñ%Ó'¨:Ò5Ø!Mð 6ð øô !ò Ùð ús Á B  B Bc óv g }| j « }|$|j |« |j « }|$|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 ÚparentsÚprocs rm r zProcess.parentsg s@ ð Ø{{}ØÐ Ø NN4Ô Ø;;=Dð Ñ ð r c ó2 | j s | j ry | t | j « k7 | _ | j r4t j | j « t | j « y# t $ r Y yt $ r
|
d| _ Y yw xY w)zãReturn whether this process is running.
|
|
It also checks if PID has been reused by another process, in
|
which case it will remove the process from `process_iter()`
|
internal cache and return False.
|
FT)r r¡ rO r{ Ú _pids_reusedÚaddr/ r1 r³ s rm rÚ zProcess.is_runningr s ð ::×)Ò)Øð ð
|
$¤w¨t¯x©xÓ'8Ñ 8DÔ Ø× Ò Ü × Ñ §¡Ô*Ü# D§H¡HÓ-Ð-ØøÜ ò ñ Ü ò Ø DJÙð ús A A9 Á9 BÂBÂBc óÔ | j « t r| j j « S | j xs | j j « | _ | j S )z`The process parent PID.
|
On Windows the return value is cached after first call.
|
)rÛ r r§ ry r¦ r³ s rm ry z Process.ppid sI ð ×!Ñ!Ô#Ý Ø::??Ó$Ð $à Ò8 t§z¡z§¡Ó'8DJØ::Ð r c ó t r| j | j S | j j « }t rWt |« dk\ rI | j « }|r6t j j |d « }|j |« r|} || _ || j _ |S # t t f$ r Y +w xY w)z>The process name. The return value is cached after first call.é r ) r, r r§ rµ r rî Úcmdliner ÚpathÚbasenameÚ
|
startswithr- r1 )r rµ r
|
Ú extended_names rm rµ z Process.name¢ sª õ
|
tzzÐ-Ø::Ð ØzzÓ Ý SY "_ð
|
-Ø ,,.ñ Ü$&§G¡G×$4Ñ$4°W¸Q±ZÓ$@MØ$×/Ñ/°Ô5Ø ,Ø
|
Ø
|
|
ÔØ øô !¤-Ð0ò ñ ð ús ÁB0 Â0CÃCc ó fd} j : j j « }|s
|
||¬« }| _ j S j S # t $ r Y *w xY w# t $ r} ||¬« cY d}~S d}~ww xY w)zThe process executable as an absolute path.
|
May also be an empty string.
|
The return value is cached after first call.
|
c ób j « }|rt t d« ryt t d« ri|d }t j j |« rEt j j |« r&t j |t j « r|S t | t « r| | S )NÚaccessÚX_OKr )
|
r
|
rß r r ÚisabsÚisfiler r rË r- )Úfallbackr
|
Úexer s rm Úguess_itz Process.exe.<locals>.guess_itÇ s{ ø ð llnGÙ7¤2 xÔ0´W¼RÀÔ5HØ ajô
|
GGMM #Ô&Ü sÔ+Ü #¤r§w¡wÔ/à JÜ(¤LÔ1Ø ØOr N)r )r r§ r r- )r r r r¯ s ` rm r z Process.exeÁ s ø ô ð& 99Ð ð ØjjnnÓ&ñ ð Ù &°Ô 4ð ØyyÐtyyÐøô (ò Ù ð ûô ò .Ù ¨Ô-Õ-ûð .ús. A( ± A Á A%Á$A%Á( BÁ1A?Á9BÁ?Bc ó6 | j j « S )z3The command line this process has been called with.)r§ r
|
r³ s rm r
|
zProcess.cmdlineë s àzz×!Ñ!Ó#Ð#r c ób | j j « S # t $ r t cY S w xY w)z2The process current status as a STATUS_* constant.)r§ r¶ r1 r* r³ s rm r¶ zProcess.statusï s/ ð !Ø::×$Ñ$Ó&Ð &øÜ ò !Ü Ò ð !ús ..c ó t rMt d}t |« | j « j } t j
|
|« j S | j j « S # t $ r t |« cY S w xY w)ztThe name of the user that owns the process.
|
On UNIX this is calculated by using *real* process uid.
|
z0requires pwd module shipped with standard python) r ÚpwdÚ ImportErrorrâ ÚrealÚgetpwuidÚpw_nameÚKeyErrorÚstrr§ Úusername)r r Úreal_uids rm r" zProcess.usernameö sw õ Ü{àHÜ! #Ó&Ð&Øyy{×'Ñ'Hð %Ü|| HÓ-×5Ñ5Ð5ð
|
::×&Ñ&Ó(Ð (øô ò %ä8}Ò$ð %ús µ A. Á.BÂBc óp | j | j j « | _ | j S )aw The process creation time as a floating point number
|
expressed in seconds since the epoch (seconds since January 1,
|
1970, at midnight UTC). The return value, which is cached after
|
first call, is based on the system clock, which means it may be
|
affected by changes such as manual adjustments or time
|
synchronization (e.g. NTP).
|
)r r§ r² r³ s rm r² zProcess.create_time s1 ð × Ñ Ð $Ø $§
|
¡
|
× 6Ñ 6Ó 8DÔ Ø× Ñ Ð r c ó6 | j j « S )z6Process current working directory as an absolute path.)r§ Úcwdr³ s rm r& z Process.cwd s àzz~~Ó Ð r c ó || j j « S | j « | j j |« y)z'Get or set process niceness (priority).N)r§ Únice_getrÛ Únice_set)r Úvalues rm Únicez Process.nice s8 à =Ø::×&Ñ&Ó(Ð (à × %Ñ %Ô 'Ø JJ× Ñ Õ &r c ó6 | j j « S )zVReturn process UIDs as a (real, effective, saved)
|
namedtuple.
|
)r§ râ r³ s rm râ z Process.uids" s ð
|
::??Ó$Ð $r c ó6 | j j « S )zVReturn process GIDs as a (real, effective, saved)
|
namedtuple.
|
)r§ Úgidsr³ s rm r. z Process.gids) s ð ::??Ó$Ð $r c ó6 | j j « S )zVThe terminal associated with this process, if any,
|
else None.
|
)r§ Úterminalr³ s rm r0 zProcess.terminal/ s ð ::×&Ñ&Ó(Ð (r c ó6 | j j « S )zcReturn the number of file descriptors opened by this
|
process (POSIX only).
|
)r§ Únum_fdsr³ s rm r2 zProcess.num_fds5 ó ð ::×%Ñ%Ó'Ð 'r Ú io_countersc ó6 | j 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 rm r4 zProcess.io_counters> s ð ::×)Ñ)Ó+Ð +r Ú
|
ionice_getc ó° |)| d}t |« | j j « S | j « | j 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.
|
z$'ioclass' argument must be specified)r r§ r6 rÛ Ú
|
ionice_set)r Úioclassr* r s rm ÚionicezProcess.ioniceJ sT ð ØÐ$Ø@CÜ$ S/Ð)Øzz×,Ñ,Ó.Ð.à×)Ñ)Ô+Øzz×,Ñ,¨W°eÓ<Ð<r re c ó^ || j « | j j ||« S )a- 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 and FreeBSD only.
|
)rÛ r§ re )r ÚresourceÚlimitss rm re zProcess.rlimitb s- ð Ð!Ø×)Ñ)Ô+Ø::×$Ñ$ X¨vÓ6Ð 6r Úcpu_affinity_getc ó |,t t | j j « « « S | j « |sXt | j d« r| j j « }n't t t t d¬« « « « }| j j t t |« « « y)a- 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]).
|
If an empty list is passed, all egible CPUs are assumed
|
(and set).
|
(Windows, Linux and BSD only).
|
NÚ_get_eligible_cpusT©Úpercpu) Úsortedrê r§ r> rÛ rß r@ r Úrangerî rW Úcpu_affinity_setré )r Úcpuss rm Ú cpu_affinityzProcess.cpu_affinitys s ð |Ü c $§*¡*×"=Ñ"=Ó"?Ó @ÓAÐAà×)Ñ)Ô+ÙÜ tzzÐ+?Ô@Ø #zz× <Ñ <Ó >ä $¤U¬3¬yÀÔ/EÓ+FÓ%GÓ HØ
|
|
×+Ñ+¬D´°T³«OÕ<r Úcpu_numc ó6 | j j « S )aZ Return what CPU this process is currently running on.
|
The returned number should be <= psutil.cpu_count()
|
and <= len(psutil.cpu_percent(percpu=True)).
|
It may be used in conjunction with
|
psutil.cpu_percent(percpu=True) to observe the system
|
workload distributed across CPUs.
|
)r§ rH r³ s rm rH zProcess.cpu_num s ð ::×%Ñ%Ó'Ð 'r Úenvironc ó6 | j j « S )zThe environment variables of the process as a dict. Note: this
|
might not reflect changes made after the process started.
|
)r§ rJ r³ s rm rJ zProcess.environ r3 r c ó6 | j j « S )z\Return the number of handles opened by this process
|
(Windows only).
|
)r§ Ú num_handlesr³ s rm rM zProcess.num_handles s ð ::×)Ñ)Ó+Ð +r c ó6 | j j « S )zkReturn the number of voluntary and involuntary context
|
switches performed by this process.
|
)r§ Únum_ctx_switchesr³ s rm rO zProcess.num_ctx_switches¤ s ð zz×*Ñ*Ó,Ð,r c ó6 | j j « S )z2Return the number of threads used by this process.)r§ Ú num_threadsr³ s rm rQ zProcess.num_threadsª s àzz×%Ñ%Ó'Ð'r Úthreadsc ó6 | j j « S )zï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§ rR r³ s rm rR zProcess.threads° s ð ::×%Ñ%Ó'Ð 'r c ó: | j « t « }t | j « j « }g }|sZ|j « D ]E \ }}|| j k( s t |« }||j « k r|j |« G |S t j t « }|j « D ] \ }}|| j |« t « } | j g}
|
|
|
rv|
|
j « }|| v r| j |« || D ]E } t | « }||j « k } | r"|j |« |
|
j | « G |
|
rv|S # t t f$ r Y 2w xY w# t t f$ r Y tw xY w)u( 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.
|
)rÛ r| rO r{ r² rÅ r r/ r1 r½ Ú defaultdictré rê Úpopr ) r Ú recursiverv rþ rz r{ ry ÚchildÚreverse_ppid_mapÚseenÚstackÚ child_pidÚintimes rm ÚchildrenzProcess.children¸ s ð4 ×!Ñ!Ô#Ü ;ô TXXÓ&×2Ñ2Ó4
|
ØÙØ %^^Ó -ò TØ488Ó#ð Ü '¨£ ð &¨×):Ñ):Ó)<Ò<Ø JJ uÔ -øð ðL
|
ô5 +× 6Ñ 6´tÓ <Ð Ø %^^Ó -ò 3 TØ Ñ&×-Ñ-¨cÕ2ð 3ô 5DØXXJEÙØiikØ$;ð Ø Ø!1°#Ñ!6ò
|
Ið Ü '¨ Ó 2ð ",¨u×/@Ñ/@Ó/BÑ!BÙ!Ø JJ uÔ -Ø !LL¨Ô 3øð
|
ò ð&
|
øô= *¬=Ð9ò Ú ð ûô8 *¬=Ð9ò Ù ð ús% Á)/E2Ä)AFÅ2FÆFÆFÆFc ó |duxr |dkD }||dk rd|d}t |« t « xs d fd}|rX |« }| j j « }t j
|
|« |« }| j j « }nL| j }| j } |« }| j j « }|||| _ || _ y|j |j z
|
|j |j z
|
z } ||z
|
}
|
|| _ || _ | |
|
z dz } | z } t | d« S # t $ r Y yw xY w) a 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.
|
|
A value > 100.0 can be returned in case of processes running
|
multiple threads on different CPU cores.
|
|
The returned value is explicitly NOT split evenly between
|
all available logical CPUs. This means that a busy loop process
|
running on a system with 2 logical CPUs will be reported as
|
having 100% CPU utilization instead of 50%.
|
|
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
|
>>>
|
Nç r ú interval is not positive (got rt r c ó t « z S ri )Ú_timer)Únum_cpuss rm Útimerz"Process.cpu_percent.<locals>.timer+ s ø Ü8hÑ&Ð &r éd ) r rZ r§ rW r~ Úsleepr¨ r© ÚuserÚsystemÚroundÚZeroDivisionError)r ÚintervalÚblockingr re Úst1Úpt1Úst2Úpt2Ú
|
delta_procÚ
|
delta_timeÚoverall_cpus_percentÚsingle_cpu_percentrd s @rm rX zProcess.cpu_percent s_ ø ðF 4Ð'Ò:¨H°s©NØ Ð H¨q¢LØ2°8°,¸aÐ@CÜ S/Ð !Ü ;Ò# !ô 'ñ Ù'CØ**×&Ñ&Ó(CÜ JJxÔ Ù'CØ**×&Ñ&Ó(Cà×*Ñ*CØ×+Ñ+CÙ'CØ**×&Ñ&Ó(CØ{ckØ+.Ô(Ø,/Ô)Øàhh §¡Ñ)¨c¯j©j¸3¿:¹:Ñ.EÑF
|
Ø3Y
|
à#&Ô Ø$'Ô!ð 0ð %/°Ñ$;¸sÑ#BÐ ð( "6¸Ñ!@Ð ÜÐ+¨QÓ/Ð /øô) !ò áð ús Ä%D> Ä> E
|
Å E
|
c ó6 | j j « S )a% Return a (user, system, children_user, children_system)
|
namedtuple representing the accumulated process time, in
|
seconds.
|
This is similar to os.times() but per-process.
|
On macOS and Windows children_user and children_system are
|
always set to 0.
|
)r§ rW r³ s rm rW zProcess.cpu_times_ s ð zz×#Ñ#Ó%Ð%r c ó6 | j j « S )a Return a namedtuple with variable fields depending on the
|
platform, representing memory information about the process.
|
|
The "portable" fields available on all platforms are `rss` and `vms`.
|
|
All numbers are expressed in bytes.
|
)r§ rá r³ s rm rá zProcess.memory_infoj s ð zz×%Ñ%Ó'Ð'r c ó6 | j j « S )a] This method returns the same information as memory_info(),
|
plus, on some platform (Linux, macOS, Windows), also provides
|
additional metrics (USS, PSS and swap).
|
The additional metrics provide a better representation of actual
|
process memory usage.
|
|
Namely USS is the memory which is unique to a process and which
|
would be freed if the process was terminated right now.
|
|
It does so by passing through the whole process address.
|
As such it usually requires higher user privileges than
|
memory_info() and is considerably slower.
|
)r§ Úmemory_full_infor³ s rm ry zProcess.memory_full_infou s ð zz×*Ñ*Ó,Ð,r c ó t t j j « }||vr d|dt |« }t |« |t j j v r | j n | j } |« }t ||« }t xs t « j }|dkD sd|d}t |« |t |« z dz S )aÏ Compare process memory to total physical system memory and
|
calculate process memory utilization as a percentage.
|
*memtype* argument is a string that dictates what type of
|
process memory you want to compare against (defaults to "rss").
|
The list of available strings can be obtained like this:
|
|
>>> psutil.Process().memory_info()._fields
|
('rss', 'vms', 'shared', 'text', 'lib', 'data', 'dirty', 'uss', 'pss')
|
zinvalid memtype z; valid types are r z]can't calculate process memory percent because total physical system memory is not positive (rt rf )ré rx ÚpfullmemÚ_fieldsr r Úpmemrá ry rñ Ú _TOTAL_PHYMEMrU ÚtotalÚfloat)r ÚmemtypeÚ valid_typesr ÚfunÚmetricsr* Ú total_phymems rm Úmemory_percentzProcess.memory_percent
sé ô ;×/Ñ/×7Ñ7Ó8 Ø +Ñ %à" 7 +ð .Ü+Ó&Ð)ð+ð ô S/Ð !ð +×*Ñ*×2Ñ2Ñ2ð × Ò à×&Ñ&ð ñ
|
%Ü Ó)ô %Ò>¬Ó(8×(>Ñ(> ØaÒ ð3Ø3?Ð2BÀ!ðEð ô S/Ð !ØlÓ+Ñ+¨sÑ2Ð2r Ú memory_mapsc ór | j j « }|r[i }|D ]* }|d }|dd } t t d || |« « ||< , t
|
j }|D cg c] } ||g|| ¢ c}S t
|
j }|D cg c] } || c}S # t $ r |||< Y w xY wc c}w c c}w )aü 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').
|
é é Nc ó | |z S ri rÔ )ÚxÚys rm ú<lambda>z%Process.memory_maps.<locals>.<lambda>½ s
|
¸¸A¹ r )r§ r ré rï r rx Ú pmmap_groupedÚ pmmap_ext) r ÚgroupedÚitÚdÚtuplr ÚnumsÚntr s rm r zProcess.memory_maps« sÑ ð ×'Ñ'Ó)BÙØØ ò 'DØ 7DØ 8Dð'Ü"&¤sÑ+=¸qÀ¹wÈÓ'MÓ"N$ð 'ô !×.Ñ.Ø78Ö9¨t4Ð* ! D¡'Ô*Ò9Ð9ä ×*Ñ*Ø(*Ö+ 1AÒ+Ð+øô $ò 'Ø"&$ð'üò :ùò ,s ¯ BÁ"B/ B4ÂB,Â+B,c ó6 | j j « S )zReturn files opened by process as a list of
|
(path, fd) namedtuples including the absolute file name
|
and file descriptor number.
|
)r§ Ú
|
open_filesr³ s rm r zProcess.open_filesÆ s ð
|
zz×$Ñ$Ó&Ð&r c óN t |« | j j |« S )aT Return socket 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 r§ r] ©r r s rm r] zProcess.net_connectionsÍ s! ô, Ô Øzz×)Ñ)¨$Ó/Ð/r r] )Ú replacementc ó& | j |¬« S )N©r )r] r s rm Ú connectionszProcess.connectionsæ s à×#Ñ#¨Ð#Ó.Ð.r c ó¸ | j dk rJ | j « | j « | j | j | j }}}|dk( r d}t |« t j ||« y # t $ r8}t rt |« rt |||« |d| _ t ||« |d }~wt $ r}t ||« |d }~ww xY w)Nr zpreventing 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 0T)r{ rÛ r¦ r r r ÚkillÚProcessLookupErrorr rQ r1 r r/ ÚPermissionErrorr- )r Úsigr{ ry rµ r r¯ s rm Ú _send_signalzProcess._send_signalî sÌ Øxx !|Ð - T§X¡XÓ -Ð#Ø × %Ñ %Ô 'à "hh¨¯
|
©
|
°D·J±JtCØaxðEð ô
|
! oÐ%ð
|
7ÜSÕ!øÜ%ò 8Ýz¨#ô (¨¨T°4Ó8¸cÐAØ !
|
Ü# C¨Ó.°CÐ7ûÜ"ò 7Ü" 3¨Ó-°3Ð6ûð 7ús$ Á(A? Á? CÂ3B;Â; Cà CÃCc ó t r| j |« y| j « |t j k7 r4| j « s$d}t | j | j |¬« | j j |« y)zÚSend a signal *sig* 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().
|
zprocess no longer existsr N) r r¤ rÛ ÚsignalÚSIGTERMrÚ r/ r{ r r§ Ú send_signal)r r£ r s rm r¨ zProcess.send_signal sd õ Ø × Ñ cÕ "à × %Ñ %Ô 'ØfnnÒ$¨T¯_©_Ô->Ø0Ü# D§H¡H¨d¯j©j¸cÔBÐBØ JJ× "Ñ " 3Õ 'r c ó¤ t r | j t j « y| j « | j
|
j « y)zµSuspend process execution with SIGSTOP pre-emptively checking
|
whether PID has been reused.
|
On Windows this has the effect of suspending all process threads.
|
N)r r¤ r¦ ÚSIGSTOPrÛ r§ Úsuspendr³ s rm r« zProcess.suspend s5 õ
|
Ø × Ñ fnnÕ -à × %Ñ %Ô 'Ø JJ× Ñ Õ r c ó¤ t r | j t j « y| j « | j
|
j « y)z²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¦ ÚSIGCONTrÛ r§ Úresumer³ s rm r® zProcess.resume! s5 õ
|
Ø × Ñ fnnÕ -à × %Ñ %Ô 'Ø JJ× Ñ Õ r c ó¤ t r | j t j « y| j « | j
|
j « y)zTerminate 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§ r r³ s rm Ú terminatezProcess.terminate, s3 õ
|
Ø × Ñ fnnÕ -à × %Ñ %Ô 'Ø JJOOÕ r c ó¤ t r | j t j « y| j « | j
|
j « y)zjKill the current process with SIGKILL pre-emptively checking
|
whether PID has been reused.
|
N)r r¤ r¦ ÚSIGKILLrÛ r§ r r³ s rm r z Process.kill7 s3 õ Ø × Ñ fnnÕ -à × %Ñ %Ô 'Ø JJOOÕ r c ó¾ ||dk\ s d}t |« | j t ur | j S | j j |« | _ | j S )aô Wait for process to terminate and, if process is a children
|
of os.getpid(), also return its exit code, else None.
|
On Windows there's no such limitation (exit code is always
|
returned).
|
|
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().
|
r z"timeout must be a positive integer)r r« rª r§ Úwait)r Útimeoutr s rm r´ z Process.waitA sS ð Ð w°!¢|Ø6CÜ S/Ð !Ø >>¤Ñ *Ø>>Ð !Ø ¨Ó1Ø~~Ð r ri ©F©NN)Úrss©T©Úinet)Frà rÂ Ú __qualname__Ú__doc__r r r rÉ Ú__repr__rÒ rÕ rØ rÛ Úpropertyr{ Ú
|
contextlibÚcontextmanagerr¿ rú rÿ r rÚ r3 ry rµ r r
|
r¶ r" r² r& r+ r râ r. r0 r2 rß rx rO r4 r: re rG rH rJ r, rM rO rQ rR r^ rX rW rá ry r r r r] r Údeprecated_methodr r¤ r¨ r« r® r° r r´ rÔ r rm rO rO sC ñó6ó- ò^!2òF ð< Hò+ò*!òò
|
|
?ð ñó ðð × Ñ ñ@.ó ð@.óD-ò^ò, òð: ñ ó ð ò$ ò>(òT$ò!ò)ò$
|
!ò ó'ñ à ñ %ó
|
ð %ò %ò )ò (ñ {×"Ñ" MÔ2ò ,ñ {×"Ñ" LÔ1ó =ñ, {×"Ñ" HÔ-ó 7ñ {×"Ñ"Ð$6Ô7ó =ñ( {×"Ñ" IÔ.ò (ñ {×"Ñ" IÔ.ò (ñ ò ,ò -ò (ñ {×"Ñ" IÔ.ò (óHóT[0ðz ñ&ó ð&ð ñ(ó ð(ò-ó "3ñH {×"Ñ" MÔ2ó ,ò6'ó0ð2 W× Ñ Ð+<Ô=ò/ó >ð/ñ
|
ò 7ò2 (ò !ò ò ò ô r rO Ú_> r r´ rÿ r® re rú r¿ r r« r^ r° rÚ r r¨ c óB e Zd ZdZd Zd Zd Zd Zd Zd fd Z xZ
|
S ) rP a Same as subprocess.Popen, but in addition it provides all
|
psutil.Process methods in a single class.
|
For the following methods which are common to both classes, psutil
|
implementation takes precedence:
|
|
* send_signal()
|
* terminate()
|
* kill()
|
|
This is done in order to avoid killing another process in case its
|
PID has been reused, fixing BPO-6973.
|
|
>>> 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
|
>>>
|
c ó t j |i |¤| _ | j | j j d¬« y )NT)r® )Ú
|
subprocessrP Ú_Popen__subprocr r{ ©r ÚargsÚkwargss rm r zPopen.__init__ s5 ô $×)Ñ)¨4Ð:°6Ñ:Ø
|
|
4>>×%Ñ%°4
|
Õ8r c óx t t t t « t t j « z « « S ri )rC rê ÚdirrP rÆ r³ s rm Ú__dir__z Popen.__dir__ s& Üc#e*¤s¬:×+;Ñ+;Ó'<Ñ<Ó=Ó>Ð>r c óf t | j d« r| j j « | S )NÚ __enter__)rß rÇ rÏ r³ s rm rÏ zPopen.__enter__ s% Ü 4>> ;Ô /Ø NN× $Ñ $Ô &Ø r c ó t | j d« r | j j |i |¤S | j r| j j « | j
|
r| j
|
j « | j r| j j « | j « y # | j « w xY w)NÚ__exit__)rß rÇ rÑ ÚstdoutÚcloseÚstderrÚstdinr´ rÈ s rm rÑ zPopen.__exit__ s Ü 4>> :Ô .Ø*4>>×*Ñ*¨DÐ;°FÑ;Ð ;à{{Ø ×!Ñ!Ô#Ø{{Ø ×!Ñ!Ô#ð à::ØJJ×$Ñ$Ô&ð ø ús  &B7 Â7C c óä t j | |« S # t $ rN t j | j |« cY S # t $ r | j d|}t |« d w xY ww xY w)Nz has no attribute )ÚobjectÚ__getattribute__ÚAttributeErrorrÇ rÁ )r rµ r s rm rØ zPopen.__getattribute__¥ sw ð 4Ü×*Ñ*¨4°Ó6Ð 6øÜ ò 4ð 4Ü ×.Ñ.¨t¯~©~¸tÓDÒDøÜ!ò 4Ø Ð*Ð*<¸T¸HÐEÜ$ SÓ)¨tÐ3ð 4úð 4ús A/¢ AÁA/Á'A+Á+A/c ó | j j | j j S t | |« }|| j _ |S ri )rÇ Ú
|
returncodeÚsuperr´ )r rµ rz rÁ s rm r´ z
|
Popen.wait¯ sB ø Ø >>× $Ñ $Ð 0Ø>>×,Ñ,Ð ,Ügl7Ó#Ø$'Ô!Ø
|
r ri ) rà r r¼ r½ r rÍ rÏ rÑ rØ r´ Ú __classcell__)rÁ s @rm rP rP h s+ ø ñò:9ò?òò
|
ò 4÷ñ r rP c óJ t t j « « } | d a| S )z&Return a list of current running PIDs.r )rC rx rR rü ©rz s rm rR rR ¼ s% ô ×!Ñ!Ó#Ó
|
$CØa&KØ Jr c óf | dk ry| dk( rt r | t « v S t j | « S )zReturn True if given PID exists in the current process list.
|
This is faster than doing "pid in psutil.pids()" and
|
should be preferred.
|
r F)r rR rx rQ )r{ s rm rQ rQ Ä s6 ð
|
QwØØ eð df}Ð ä×%Ñ% cÓ*Ð*r c # ó K fd} fd}t j « t t « « }t j « « }||z
|
}||z
|
}|D ]
|
} ||« t
|
r1t
|
j « }t d| « ||« t
|
r1 t t j « « t t j |« j « « z « } | D ]. \ }}
|
|
|
||« }
|
| |
|
j | |¬« |
|
_ |
|
0 a y# t $ r ||« Y Hw xY w# a w xY ww)a£ 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.
|
Cache can optionally be cleared via `process_iter.cache_clear()`.
|
|
The sorting order in which processes are yielded is based on
|
their PIDs.
|
|
*attrs* and *ad_value* have the same meaning as in
|
Process.as_dict(). If *attrs* is specified as_dict() is called
|
and the resulting dict is stored as a 'info' attribute attached
|
to returned Process instance.
|
If *attrs* is an empty list it will retrieve all process info
|
(slow).
|
c ó< t | « }||j < |S ri )rO r{ )r{ r Úpmaps rm r zprocess_iter.<locals>.addî s ø Üs|Ø TXXØ r c ó* j | d « y ri )rV )r{ rã s rm Úremovez process_iter.<locals>.removeó s ø Ø dÕr z+refreshing Process instance for reused PID N)ró rô )Ú_pmapÚcopyrê rR Úkeysr rV r2 rC ré rÅ ÚdictÚfromkeysrú rÆ r/ ) ró rô r rå ÚaÚbÚnew_pidsÚ gone_pidsr{ rø r rã s @rm rS rS Ú s/ øè ø ô(ô
|
ô ::<DÜ DF AÜ DIIKÓAØ1uHØAIØò Ùs ðå
|
Ü× Ñ Ó Ü Ð;¸C¸5ÐAÔBÙs ö ð Ü D Ó&¬¬d¯m©m¸HÓ.E×.KÑ.KÓ.MÓ)NÑNÓ OØò ICð Ø<Ù s8DØÐ$Ø $§ ¡ °5À8 Ó LDIØ
|
ñ ð øô !ò Ùs ð ûð üsC BEÂ AD< Ã7(D%Ä D< Ä"EÄ%D9Ä6D< Ä8D9Ä9D< Ä<E Å Ec ó* t j « S ri )ræ ÚclearrÔ r rm r r s ¤5§;¡;£= r z$Clear process_iter() internal cache.c óÒ fd}||dk\ sd| }t |« t « t | « } t « sdd}t |« | t « |z }|rX||dk rnP|D ]C }dt |« z }|(t t « z
|
|« }|dk r n |||« ; |||« E | z
|
}|rX|r|D ] } ||d« | z
|
}t « t |« fS )a, 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.
|
Differently from Process.wait() it will not raise TimeoutExpired if
|
*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 óÖ | j |¬« }|| j « s$|| _ j | « | « y y y # t t
|
j f$ r Y y w xY w)N)rµ )r´ rÚ rÛ r r0 rÆ )r rµ rÛ ÚcallbackÚgones rm Ú
|
check_gonez wait_procs.<locals>.check_gone9 sq ø ð
|
#Ø ¨7Ó3Jð Ð%¨T¯_©_Ô->à",ØØÐ'Ù TNð (ð .?øô ¤
|
× 9Ñ 9Ð:ò Ù ð ús A Á A(Á'A(r z(timeout must be a positive integer, got z callback z is not a callableg ð?)r rê Úcallablerí rc rî Úminré )
|
Úprocsrµ ró rõ r ÚaliveÚdeadliner Ú max_timeoutrô s
|
` @rm rT rT s) ù õJ #ð Ð 7¨a¢<Ø8¸¸ ÐBÜoÐ Ü 5DÜ JEØФH¨XÔ$6Ø( Ð%7Ð8ÜnÐ ØÐÜ8gÑ%á
|
Ø Ð 7¨a¢<Ø Øò .Dð ¤ E£
|
Ñ*KØÐ"Ü x¬&«(Ñ 2°[ÓAØa<ÙÙ4 Õ)á4 Õ-ð .ð ò% ñ( ð ò DÙ tQÕ ð à ä JU Ð $Ð$r Tc ón | rt j « }nt j « }||dk rd}|S )al Return the number of logical CPUs in the system (same as
|
os.cpu_count()).
|
|
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()
|
Nr )rx Úcpu_count_logicalÚcpu_count_cores)Úlogicalrz s rm rZ rZ t s8 ñ Ü×+Ñ+Ó-ä×)Ñ)Ó+Ø
|
3 7ØØ Jr c óV | st j « S t j « S )a 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.
|
)rx rW Ú per_cpu_timesrA s rm rW rW s% ñ, Ü×$Ñ$Ó&Ð&ä×(Ñ(Ó*Ð*r rA c óh t | « }t r |t | dd« z }|t | dd« z }|S )zWGiven a cpu_time() ntuple calculates the total CPU time
|
(including idle time).
|
Úguestr Ú
|
guest_nice)Úsumr rñ )ÚtimesÚtots rm Ú _cpu_tot_timer ¶ s= ô e*CÝ ð wug qÓ)Ñ)Ø wul¨AÓ.Ñ.Ø Jr c óZ t | « }|| j z }|t | dd« z }|S )zlGiven a cpu_time() ntuple calculates the busy CPU time.
|
We do so by subtracting all idle CPU times.
|
Úiowaitr )r Úidlerñ )r Úbusys rm Ú_cpu_busy_timer É s6 ô Ó DØEJJÑDð GE8 QÓ 'Ñ'DØ Kr c ó | j |j k( s J | |f« g }t j j D ]8 }t ||« t | |« z
|
}t d|« }|j |« : t j | S )Nr )r| rx Ú scputimesrñ Úmaxr )Út1Út2Ú field_deltasÚfieldÚ field_deltas rm Ú_cpu_times_deltasr Ù s Ø ::Ò #Ð- b¨" XÓ-Ð #ØLÜ ×&Ñ&×.Ñ.ò )Ü b %Ó(¬7°2°uÓ+=Ñ= ô ![Ó) Ø×ÑKÕ(ð )ô × Ñ ,Ð /Ð/r c óx t j « j }| duxr | dkD }| | dk rd| d}t |« d }|sd|r t « }t j | « n!t j |« xs
|
t « }t « t |< ||t | « S g }|r"t d¬« }t j | « n#t j |« xs t d¬« }t d¬« t |< t |t | « D ] \ }} |j ||| « « |S ) a¡ 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
|
>>>
|
Nr` r ra rt c ó t | |« }t |« }t |« } ||z dz }t |d« S # t $ r Y yw xY w)Nrf r r` )r r r rj rk )r r Ú times_deltaÚ all_deltaÚ
|
busy_deltaÚ busy_percs rm Ú calculatez cpu_percent.<locals>.calculate sY Ü'¨¨BÓ/ Ü! +Ó. Ü# KÓ0
|
ð 'Ø# iÑ/°3Ñ6Iô AÓ&Ð &øô !ò Ùð ús ¤8 ¸ AÁATrA ) r£ Úcurrent_threadÚidentr rW r~ rg Ú_last_cpu_timesÚgetÚ_last_per_cpu_timesÚzipr ©
|
rl rB Útidrm r r r rz Útot1r s
|
rm rX rX î s' ôF ×
|
"Ñ
|
"Ó
|
$×
|
*Ñ
|
*CØtÐ#Ò6¨°3©HØÐ ¨1¢ Ø.¨x¨j¸Ð:ÜoÐ ò
|
'ñ Ù ÜBÜ JJxÕ ä ×$Ñ$ SÓ)Ò8¬Y«[BÜ ({Ñ Ù_¨SÑ 1Ó2Ð2ð Ù Ü DÔ)DÜ JJxÕ ä&×*Ñ*¨3Ó/ÒI´9ÀDÔ3IDÜ#,°DÔ#9ÔCÑ Ü$Ô 3°CÑ 8Ó9ò *FBØ JJy RÓ(Õ )ð *à
|
r c óx t j « j }| duxr | dkD }| | dk rd| d}t |« d }|sd|r t « }t j | « n!t j |« xs
|
t « }t « t |< ||t | « S g }|r"t d¬« }t j | « n#t j |« xs t d¬« }t d¬« t |< t |t | « D ] \ }} |j ||| « « |S ) a· 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().
|
Nr` r ra rt c óô g }t | |« }t |« }dt d|« z }|D ]: }||z }t |d« }t t d|« d« }|j |« < t j | S )Ng Y@r r` )r r r rj r÷ r rx r )r r r r r Úscaler Ú
|
field_percs rm r z$cpu_times_percent.<locals>.calculateS s ØÜ'¨¨BÓ/ Ü! +Ó. ð
|
AyÓ)Ñ)Ø&ò $KØ$ uÑ,JÜ z¨1Ó-Jä S jÓ 1°5Ó9JØ KK
|
Õ #ð $ô ×$Ñ$ dÐ+Ð+r TrA ) r£ r r r rW r~ rg Ú_last_cpu_times_2r! Ú_last_per_cpu_times_2r# r r$ s
|
rm rY rY @ s( ô ×
|
"Ñ
|
"Ó
|
$×
|
*Ñ
|
*CØtÐ#Ò6¨°3©HØÐ ¨1¢ Ø.¨x¨l¸!Ð<ÜoÐ ò,ñ$ Ù ÜBÜ JJxÕ ä"×&Ñ& sÓ+Ò:¬y«{BÜ!*£Ô#Ñ ÙÔ .¨sÑ 3Ó4Ð4ð Ù Ü DÔ)DÜ JJxÕ ä(×,Ñ,¨SÓ1ÒK´YÀdÔ5KDÜ%.°dÔ%;Ô cÑ"Ü$Ô 5°cÑ :Ó;ò *FBØ JJy RÓ(Õ )ð *à
|
r c ó* t j « S )zReturn CPU statistics.)rx r[ rÔ r rm r[ r[ { s ä × Ñ Ó "Ð"r Úcpu_freqc óv t j « }| r|S t t |« « }|dk( ry|dk( r|d S d\ }}}d}|D ]D }||j z }t
|
r|j d}'||j z }||j z }F ||z }|rdx} }
|
n
|
||z } ||z }
|
t j || |
|
« S )a: Return CPU frequency as a namedtuple including current,
|
min and max frequency expressed in Mhz.
|
|
If *percpu* is True and the system supports per-cpu frequency
|
retrieval (Linux only) a list of frequencies is returned for
|
each CPU. If not a list with one element is returned.
|
r Nr )r` r` r` FT)
|
rx r. r rî Úcurrentr r÷ r r Úscpufreq) rB rz rd ÚcurrsÚminsÚmaxsÚset_noneÚcpur0 Úmin_Úmax_s rm r. r. sÞ ô ×"Ñ"Ó$Ù ØJä S XHØ1}ØØQ Ø1v à$1Ñ!tTØ Ø ò $CØS[[Ñ(Eõ §¡ Ø#'Ø ØCGGODØCGGODð$ð (Ñ*áØ"&Ð&D4à (?DØ (?Dä ×'Ñ'¨°°tÓ<Ð<r Ú
|
getloadavgc óF t j « } | j a| S )a Return statistics about system memory usage as a namedtuple
|
including the following fields, expressed in bytes:
|
|
- total:
|
total physical memory available.
|
|
- available:
|
the memory that can be given instantly to processes without the
|
system going into swap.
|
This is calculated by summing different memory values depending
|
on the platform 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:
|
macOS: active + 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, macOS):
|
cache for various things.
|
|
- wired (macOS, 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.
|
)rx rU r r~ rß s rm rU rU ½ s! ôj ×
|
$Ñ
|
$Ó
|
&CàIIMØ Jr c ó* t j « S )aå 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.
|
)rx rV rÔ r rm rV rV ø s ô × "Ñ "Ó $Ð$r c ó, t j | « S )z£Return disk usage statistics about the given *path* as a
|
namedtuple including total, used and free space expressed in bytes
|
plus the percentage usage.
|
)rx rb )r s rm rb rb s ô
|
× !Ñ ! $Ó 'Ð'r c ó, t j | « S )a3 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.
|
)rx ra )Úalls rm ra ra s ô × &Ñ & sÓ +Ð+r c óF t r t | ¬« ni }t j di |¤}|s| ri S dS |r t |d« }t t dt j « }| r"|j « D ] \ }} || ||< |S |d t |j « D « S )aØ 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 ms)
|
- write_time: time spent writing to disk (in ms)
|
|
Platform specific:
|
|
- busy_time: (Linux, FreeBSD) time spent doing actual I/Os (in ms)
|
- read_merged_count (Linux): number of merged reads
|
- write_merged_count (Linux): number of merged writes
|
|
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.
|
|
If *nowrap* is True it detects and adjust the numbers which overflow
|
and wrap (restart from 0) and add "old value" to "new value" so that
|
the returned numbers will always be increasing or remain the same,
|
but never decrease.
|
"disk_io_counters.cache_clear()" can be used to invalidate the
|
cache.
|
|
On recent Windows versions 'diskperf -y' command may need to be
|
executed first otherwise this function won't find any disk.
|
)ÚperdiskNúpsutil.disk_io_countersÚsdiskioc 3 ó2 K | ] }t |« y wri )r )rk r s rm rn z#disk_io_counters.<locals>.<genexpr>M s è ø Ò;qCFÑ;ùro rÔ ) r ré rx r` Ú _wrap_numbersrñ r rB rÅ r# Úvalues)r@ ÚnowraprÊ Úrawdictr ÚdiskÚfieldss rm r` r` ! s£ õ@ ',T'Õ "°FÜ×*Ñ*Ñ4¨VÑ4GÙ Ù rÐ& $Ð&Ù Ü Ð)BÓCÜ i¬¯ © Ó 9BÙØ #MMOò (LD&Ù KGDMð (àáÑ;¤C¨¯ © Ó)9Ð$:Ô;Ð<Ð<r rA z Clears nowrap argument cachec ó< t j « }|s| ri S dS |r t |d« }| r/|j « D ] \ }}t j
|
| ||< |S t j
|
t |j « D cg c] }t |« c} S c c}w )ac 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 macOS 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.
|
|
If *nowrap* is True it detects and adjust the numbers which overflow
|
and wrap (restart from 0) and add "old value" to "new value" so that
|
the returned numbers will always be increasing or remain the same,
|
but never decrease.
|
"net_io_counters.cache_clear()" can be used to invalidate the
|
cache.
|
Núpsutil.net_io_counters) rx r\ rD rÅ r Úsnetior# rE r )ÚpernicrF rG ÚnicrI r s rm r\ r\ [ s ô4 ×)Ñ)Ó+GÙ ÙrÐ% Ð%Ù Ü Ð)AÓBÙ Ø"==?ò 3KCÜ">>¨6Ð2GCLð 3àä~~´°W·^±^Ó5EÐ0FÖ G¨1¤ A¥Ò GÐHÐHùÒ Gs ÂBrK c óB t | « t j | « S )a Return system-wide socket 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 macOS this function requires root privileges.
|
)r rx r] r s rm r] r] s ô4 TÔÜ × &Ñ & tÓ ,Ð,r c ó| t j « } | j d ¬« t j t
|
« }| D ]í \ }}}}}} t j |« }|t j k( r;t rdnd}|j |« dk r || dz }|j |« dk r t j |||||« } t rM|t j t j" hv r+ t j$ | « }|| j' |¬
|
« || j- | « ï t/ |« S # t $ rS t r|dk( rt j }n3t t d« r#|t j k( rt j }Y 6w xY w# t( $ r}
|
t+ |
|
« Y d }
|
~
|
d }
|
~
|
ww xY w) a* 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: 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
|
(typically a VPN).
|
- broadcast: and *ptp* are mutually exclusive.
|
|
Note: you can have more than one address of the same family
|
associated with each interface.
|
c ó | d S )Nr rÔ ©r s rm r z net_if_addrs.<locals>.<lambda>¹ s
|
q t r )ÚkeyéÿÿÿÿrN ú:ú-é Ú00N)Ú broadcast)rx r^ Úsortr½ rU ré ÚsocketÚ AddressFamilyr r, rN rß r Úcountr ÚsnicaddrÚAF_INETÚAF_INET6Úbroadcast_addrÚ_replaceÚ Exceptionr2 r ré ) Úrawlistrz rµ ÚfamÚaddrÚmaskrY ÚptpÚ separatorr r¯ s rm r^ r^ ¦ s ô$ ×&Ñ&Ó(GØ LL^LÔ$Ü
|
×
|
!Ñ
|
!¤$Ó
|
'CØ18ò # Ñ-c4y¨#ð *Ü×&Ñ& sÓ+Cð +×%Ñ%Ò %õ %¨#IØ**YÓ'¨!Ò+Ø9+ RÐ(Ñ(ð **YÓ'¨!Ó+ô × Ñ c 4¨¨y¸#Ó >õ sv~~¬v¯©Ð ?Ñ?ð 5Ü #× 2Ñ 2°2Ó 6 ð Ð(ØKK¨)KÕ4à D ×ÑÕ ðG# ôJ 9ÐøôE ò *Ý3 "9Ü!×)Ñ)ä YÔ/°C¼;×;NÑ;NÒ4Nô
|
"×)Ñ)úð *ûô4 ò Üc
|
|
ûð ús+ ÁD>Ã3F Ä>AFÆFÆ F;Æ& F6Æ6F;c ó* t j « S )a 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.
|
)rx r_ rÔ r rm r_ r_ ã s ô × #Ñ #Ó %Ð%r Úsensors_temperaturesc ó fd}t j t « }t j « }|j « D ]p \ }}|s |j d« \ }}}} ||« } ||« } || « } |r| s|} n| r|s| }|| j t j |||| « « |rhr t |« S )a< Return hardware temperatures. Each entry is a namedtuple
|
representing a certain hardware sensor (it may be a CPU, an
|
hard disk or something else, depending on the OS and its
|
configuration).
|
All temperatures are expressed in celsius unless *fahrenheit*
|
is set to True.
|
c ó: | rt | « dz dz dz S | S y )Né rW é )r )ÚnÚ
|
fahrenheits rm Úconvertz%sensors_temperatures.<locals>.convert s, ø Ø}Ù2<a 1 qÑ(¨BÑ.ÐCÀ!ÐCð r r ) r½ rU ré rx rk rÅ rV r r Úshwtempré )
|
rq rr rz rG rµ rE Úlabelr0 ÚhighÚcriticals
|
` rm rk rk ú sÁ ø ô Dô ×%Ñ%¤dÓ+Ü ×2Ñ2Ó4à #MMOò LD&ÚØ17·±¸A³ Ñ.w hÙ! 'Ó*Ù t}Ù" 8Ó,á¡Ø #HÙ ¡dØ#DàD × Ñ ÜOO E¨7°D¸(ÓCôó ð ô CyÐr Ú sensors_fansc ó* t j « S )z¢Return fans speed. Each entry is a namedtuple
|
representing a certain hardware sensor.
|
All speed are expressed in RPM (rounds per minute).
|
)rx rw rÔ r rm rw rw " s ô
|
×'Ñ'Ó)Ð)r Úsensors_batteryc ó* t j « S )a Return battery information. If no battery is installed
|
returns None.
|
|
- percent: battery power left as a percentage.
|
- secsleft: a rough approximation of how many seconds are left
|
before the battery runs out of power. May be
|
POWER_TIME_UNLIMITED or POWER_TIME_UNLIMITED.
|
- power_plugged: True if the AC power cable is connected.
|
)rx ry rÔ r rm ry ry / s ô ×*Ñ*Ó,Ð,r c ó* t j « S )a! Return the system boot time expressed in seconds since the epoch
|
(seconds since January 1, 1970, at midnight UTC). The returned
|
value is based on the system clock, which means it may be affected
|
by changes such as manual adjustments or time synchronization (e.g.
|
NTP).
|
)rx rd rÔ r rm rd rd C s ô × Ñ Ó "Ð"r c ó* t j « S )a 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.
|
)rx rc rÔ r rm rc rc M s ô × Ñ Ó Ð r c ó* t j « S )zjReturn a generator yielding a WindowsService instance for all
|
Windows services installed.
|
)rx Úwin_service_iterrÔ r rm r~ r~ a s ô ×+Ñ+Ó-Ð-r c ó, t j | « S )zjGet a Windows service by *name*.
|
Raise NoSuchProcess if no service with such name exists.
|
)rx Úwin_service_get)rµ s rm r r g s ô ×*Ñ*¨4Ó0Ð0r c ó ddl }t | « |j _ t j
|
j t | « « y)zZEnable or disable PSUTIL_DEBUG option, which prints debugging
|
messages to stderr.
|
r N)Úpsutil._commonÚboolr Ú PSUTIL_DEBUGrx r Ú set_debug)r* Úpsutils rm Ú
|
_set_debugr q s/ ó ä"& u£+FNNÔ Ü×Ñ× Ñ t E{Õ+r r· r¹ r¶ )NF)FTrº )³r½ r½ rÀ r Ú functoolsr r¦ r[ rÆ Úsysr£ r~ r r rr 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 r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 rD Ú PROCFS_PATHr5 rx r6 r7 r8 r9 r: Ú_psutil_windowsr; r< r= r> r? r@ rA rB rC rD rE rF rG rH rI rJ rK Úplatformr rò Ú__all__ÚextendÚ__extra__all__rß rO rf ÚglobalsÚ_globalsr rÌ r Úisupperrñ r rN Ú
|
__author__rM r ÚsplitrL rc r~ rü r× rª rj Úreplacer ru rÄ ré r! rs rÈ Úwhatrv r| r r rè rP rR rQ ræ rê r rS Ú cache_clearrT rZ rW r r r rc r" r r r rX rç r+ r, rY r[ r. r9 rU rV rb ra r` Úpartialr\ r] r^ r_ rk rw ry rd rc r~ r r rR s 0rm ú<module>r sB ðñ
|
ó Û Û Û Û Û Û Û Û
|
Û Û ðÛõ Ý Ý Ý Ý $Ý !Ý %Ý #Ý #Ý "Ý Ý Ý "Ý "Ý #Ý Ý Ý Ý Ý $Ý $Ý 'Ý Ý Ý Ý 'Ý )Ý Ý &Ý Ý "Ý "Ý #Ý $Ý #Ý (Ý #Ý "Ý "Ý Ý Ý !Ý Ý "Ý #Ý "Ý Ý +Ý 2áð Kå)Ý)Ý+Ý+Þ)á Ý+Ý<Ý<Ý4Ý4Ý6Ý8Ý+Ý'Ý&Ý)Þ*á
|
Þ'áÞ'á
|
Ý)Ý$Ý#ð KáÝ'ð Kð cll^Ð#4Ð
|
5CÙ
|
cÓ
|
"Ð"ò- ðb {×)Ñ)Ô *ñ ;× Ñ Ô)å áyHØ EÙ]Ó#ò "Ø × Ñ FÕ #¨¯ © Ù % m°UÓ ;HUOØ NN5Õ !ð"ð %à
|
×
|
Ñ
|
à
|
Ø ÙÑ@¨×):Ñ):¸3Ó)?Ô@Ó@ á { D§I¡IÓ .Ø Ø Ù H ñ {×Ñ3 Ó#Ó$©Ø×Ñi ó)ò ð {× /Ñ /× 8Ñ 8Ð ;¸=Ð
|
ICØÐ ;Ñ;CÙ{× Ñ Ô+Ø HHT#k× .Ñ .× 6Ñ 6Ó7Ó8Ó 9Ø A3l ; -¨qÐ1Ñ1à Ð" ; -¨qÐ1Ñ1Ù Ø×ÑØØ/ó Dð
|
Ð FÀtÀfÐ MÑMCØÐ >Ñ>CÙ
|
cÓ
|
Ðñ ;
|
Ô#à×$Ò$Iò
|
ò?ò ÷w ñ w ñz! 7|öØ
|
1§<¡<°Õ#4¸ð ò: AòÐ ô LGô Lòhò+ð$ Ùu ó3ñl 1 Ô Ø#I × Ò Ô óX%ó@ó.+ð8Ø/y×/Ò/Ó1×7Ò7¹»ÐEOð
|
à × Ò Ó"×(Ò(©)¸4Ô*@ðÐòò& ò 0ó*Ið\ $×(Ò(Ó*Ð Ø+×0Ò0Ó2Ð ó8òv#ñ
|
;
|
Ô#ó&=ðP NN:Ô ñ 2|Ô ¡¨ °\Ô Bñ r<Ô Ø]]
|
à ×+Ò+
|
à NN<Ô ò8òv %ò*(ó ,ó,=ð^ 1y× 0Ò 0Ø× Ò Ð 8ó Ð Ô ð (FÐ × Ò Ô $ó$IðN 0i× /Ò /Ø× Ò Ð 7ó Ô ð 'E× Ò Ô #ó-ò<:òz &ñ* ;Ð.Ô/ó ðD NNÐ)Ô*ñ ;Ô'ò*ð NN>Ô"ñ ;Ð)Ô*ò
|
-ð NNÐ$Ô%ò#ò
|
ñ$ ò.ò 1ò,ñ øðqJ ò Ø
|
Cðüòn)øð^
|
ò àOðûð ò à Óð úsG °X8 Ï4YÐ YÐYÑ $Y Ò&Y Ø8YÙYÙ YÙYÙY$Ù#Y$
|
