U
    +È-e<ö  ã                E   @   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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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mZ ddlmZ ddlmZ ddlZddlm Z  ddlm!Z! 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-m0Z0 ddl-m1Z1 ddl-m2Z2 ddl-m3Z3 ddl-m4Z4 ddl-m5Z5 zddlm6Z6 W n< e7k
r@   e 8¡  e 9d¡ ddl6Z6W 5 Q R X Y nX e.rRddl:Z:ndZ:e%rhddl;m<Z< ddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbgEZ=dcej>kZ?de
j@kZAdde
j@kpdee
j@kZBeAp(eBZCdfe
j@kZDejEdgkZFe*dhdi„ ƒZGe"rfeGƒ djkZHeGƒ dkkZIndlZHdlZIdmZJdnZKdoZLdpZMeCr¤eJdq9 ZJeMdq9 ZMeKdr9 ZKeLdq9 ZLe
jNdskr¾dte
 O¡  ZPndue
 O¡  ZPe3dvƒZQe.rædw Rdxdy¡ZSndzZSe T¡  U¡ d{kZVe
jW Xe
jW Ye
jW Ze[¡d|d|¡¡Z\e
j@ ]d}e
jW Ye\d~¡¡Z^e
jW Xe
jW Ze[¡¡Z_e%oPe& Z`eaejbdƒZceaed€ƒZdeaedƒZeeaejbd‚ƒZfeaejbdƒƒZgeaejbd„ƒZheaed…ƒZieaejbd†ƒZjeaejbd‡ƒZkeaejbdˆƒZleaed‰ƒZmzemoàene o¡ ƒZpW n eqk
rþ   dlZpY nX eaedŠƒZreaed‹ƒZseaejbdŒƒZte"s,e o6e
 u¡ dkZvddŽ„ Zwewƒ \ZxZyeze
j{dƒZ|e }e|j~¡ dd‘„ eeƒD ƒZ€eed’e‚ƒ ƒZƒe„ƒ Z…e„ƒ Z†G d“dD„ dDej‡ƒZˆd”d•„ Z‰e‰dÓd–dA„ƒZŠe‰d—dC„ ƒZ‹d˜dB„ ZŒe‰d™d>„ ƒZe‰dšd›„ ƒZŽejeMfdœd?„ZdÔdd@„Z‘dždS„ Z’dŸdR„ Z“G d d¡„ d¡ƒZ”e”ej•deMd¢d£d¤dU„ ƒZ–e”e0e—fdeMd¢d£dÕd¦dV„ƒZ˜e”e—deMd¢d£d§dT„ ƒZ™d¨dO„ Zšd©dª„ Z›ejœd«dN„ ƒZdÖd¬dP„Zžd×d®dQ„ZŸG d¯d°„ d°ej ƒZ e e_ G d±dJ„ dJe ƒZ¡e ¢e?d²¡G d³dI„ dIe¡ƒƒZ£d´dM„ Z¤dµd¶„ Z¥G d·dK„ dKƒZ¦G d¸dL„ dLƒZ§d¹dº„ Z¨eJfd»dH„Z©dØd¼dF„ZªdÙd½dG„Z«dÚd¿dX„Z¬eedfdÀdY„Z­ejfdÁdZ„Z®dÛdÃd[„Z¯dÄd\„ Z°ejœdÅd]„ ƒZ±dÆdW„ Z²dÇdÈ„ Z³dÉd^„ Z´dÊd_„ ZµdËd`„ Z¶dÌdb„ Z·e%rÄejœdÜdÍda„ƒZ¸nejœdÝdÎda„ƒZ¸ej}dÏdÐ„ ƒZ¹e%rúe ejdÑdÒ„ ¡ dS )ÞzTest utilities.é    )Úprint_functionN)ÚAF_INET)ÚAF_INET6)ÚSOCK_STREAM)ÚAIX)ÚLINUX)ÚMACOS)ÚNETBSD)ÚOPENBSD)ÚPOSIX)ÚSUNOS)ÚWINDOWS)Úbytes2human)Úmemoize)Úprint_color)Úsupports_ipv6)ÚPY3)ÚFileExistsError)ÚFileNotFoundError)Úrange)Úsuper)Úu)Úunicode)Úwhich)ÚmockÚignore)Úwait_pidÚAPPVEYORÚDEVNULLÚGLOBAL_TIMEOUTÚTOLERANCE_SYS_MEMÚ
NO_RETRIESÚPYPYÚ
PYTHON_EXEÚPYTHON_EXE_ENVÚROOT_DIRÚSCRIPTS_DIRÚTESTFN_PREFIXÚUNICODE_SUFFIXÚINVALID_UNICODE_SUFFIXÚ
CI_TESTINGÚVALID_PROC_STATUSESÚTOLERANCE_DISK_USAGEÚIS_64BITÚHAS_CPU_AFFINITYÚHAS_CPU_FREQÚHAS_ENVIRONÚHAS_PROC_IO_COUNTERSÚ
HAS_IONICEÚHAS_MEMORY_MAPSÚHAS_PROC_CPU_NUMÚ
HAS_RLIMITÚHAS_SENSORS_BATTERYÚHAS_BATTERYÚHAS_SENSORS_FANSÚHAS_SENSORS_TEMPERATURESÚMACOS_11PLUSÚMACOS_12PLUSÚCOVERAGEÚpyrunÚ	terminateÚreap_childrenÚspawn_testprocÚspawn_zombieÚspawn_children_pairÚ
ThreadTaskÚunittestÚskip_on_access_deniedÚskip_on_not_implementedÚretry_on_failureÚTestMemoryLeakÚPsutilTestCaseÚprocess_namespaceÚsystem_namespaceÚprint_sysinfoÚchdirÚsafe_rmpathÚ
create_exeÚ
get_testfnÚ
get_winverÚkernel_versionÚ
call_untilÚwait_for_pidÚwait_for_fileÚcheck_net_addressÚget_free_portÚbind_socketÚbind_unix_socketÚtcp_socketpairÚunix_socketpairÚcreate_socketsÚreload_moduleÚimport_module_by_pathÚwarnÚcopyload_shared_libÚis_namedtupleZ__pypy__ÚGITHUB_ACTIONSZCIBUILDWHEELZCOVERAGE_RUNl        c                  C   sn   t  ¡ d } ttt|  d¡d d… ƒƒ}|dkrjtjtj	dddgdd	id
d} ttt|  d¡d d… ƒƒ}|S )Nr   Ú.é   )é
   é   z-sSú-cz-import platform; print(platform.mac_ver()[0])ZSYSTEM_VERSION_COMPATÚ0T)ÚenvÚuniversal_newlines)
ÚplatformÚmac_verÚtupleÚmapÚintÚsplitÚ
subprocessÚcheck_outputÚsysÚ
executable)Úversion_strÚversion© rw   úV/var/www/html/Darija-Ai-Train/env/lib/python3.8/site-packages/psutil/tests/__init__.pyÚmacos_version„   s    üø
ry   )re   é   )é   r   Fre   i  P i    é   é   é   Újavaz$psutil-%s-z@psutil-%s-u   -Æ’Å‘Å‘s   fÀ€Úutf8Úsurrogateescapeu   fÃ€Â€)Úasciizus-asciiz..ZPSUTIL_SCRIPTS_DIRÚscriptsÚcpu_affinityÚcpu_freqÚ
getloadavgÚenvironÚioniceÚmemory_mapsÚnet_io_countersÚcpu_numÚio_countersÚrlimitÚsensors_batteryÚsensors_fansÚsensors_temperaturesÚthreadsc                  C   sà   dd„ } t j ¡ }ttdd ƒ}trFtjdkrF|d k	rFtj|d< ||fS trTtj|fS t	r²| tjƒpœ| t j
 tj¡ƒpœ| tdtjd d…  ƒƒpœ| t ¡  ¡ ƒ}|sªtdƒ‚||fS t j
 tj¡}t j
 |¡sÔt|ƒ‚||fS d S )	Nc                 S   s<   zt j| dgt jt jd W n tk
r2   Y d S X | S d S )Nz-V)ÚstdoutÚstderr)rq   Ú
check_callÚPIPEÚ	Exception)Úexerw   rw   rx   Úattemptæ   s      ÿ
z_get_py_exe.<locals>.attemptÚ_base_executable)r}   é   Ú__PYVENV_LAUNCHER__zpython%s.%srd   z"can't find python exe real abspath)Úosr‡   ÚcopyÚgetattrrs   r   Úversion_infort   rb   r   ÚpathÚrealpathr   ÚpsutilÚProcessr—   Ú
ValueErrorÚexistsÚAssertionError)r˜   ri   Úbaser—   rw   rw   rx   Ú_get_py_exeå   s,    	



ÿþür¨   zr+c                 C   s    g | ]}|  d ¡rtt|ƒ‘qS )ZSTATUS_©Ú
startswithrž   r¢   ©Ú.0Úxrw   rw   rx   Ú
<listcomp>  s    
ÿr®   ÚAF_UNIXc                       sP   e Zd ZdZ‡ fdd„Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dd„ Z
‡  ZS )rC   z6A thread task which does nothing expect staying alive.c                    s$   t ƒ  ¡  d| _d| _t ¡ | _d S )NFçü©ñÒMbP?)r   Ú__init__Ú_runningÚ	_intervalÚ	threadingÚEventÚ_flag©Úself©Ú	__class__rw   rx   r±   !  s    
zThreadTask.__init__c                 C   s   | j j}d|| jt| ƒf S )Nz<%s running=%s at %#x>)rº   Ú__name__r²   Úid)r¸   Únamerw   rw   rx   Ú__repr__'  s    zThreadTask.__repr__c                 C   s   |   ¡  | S ©N)Ústartr·   rw   rw   rx   Ú	__enter__+  s    zThreadTask.__enter__c                 O   s   |   ¡  d S r¿   )Ústop)r¸   ÚargsÚkwargsrw   rw   rx   Ú__exit__/  s    zThreadTask.__exit__c                 C   s(   | j rtdƒ‚tj | ¡ | j ¡  dS )zStart thread and keep it running until an explicit
        stop() request. Polls for shutdown every 'timeout' seconds.
        zalready startedN)r²   r¤   r´   ÚThreadrÀ   r¶   Úwaitr·   rw   rw   rx   rÀ   2  s    zThreadTask.startc                 C   s(   d| _ | j ¡  | j r$t | j¡ qd S )NT)r²   r¶   ÚsetÚtimeÚsleepr³   r·   rw   rw   rx   Úrun;  s    
zThreadTask.runc                 C   s    | j stdƒ‚d| _ |  ¡  dS )z8Stop thread execution and and waits until it is stopped.zalready stoppedFN)r²   r¤   Újoinr·   rw   rw   rx   rÂ   A  s    zThreadTask.stop)r»   Ú
__module__Ú__qualname__Ú__doc__r±   r¾   rÁ   rÅ   rÀ   rË   rÂ   Ú__classcell__rw   rw   r¹   rx   rC     s   	c                    s   t  ˆ ¡‡ fdd„ƒ}|S )Nc                     s.   zˆ | |ŽW S  t k
r(   tƒ  ‚ Y nX d S r¿   )r–   r?   ©rÃ   rÄ   ©Úfunrw   rx   ÚwrapperO  s
    z&_reap_children_on_err.<locals>.wrapper©Ú	functoolsÚwraps©rÓ   rÔ   rw   rÒ   rx   Ú_reap_children_on_errN  s    rÙ   c                 K   sÖ   |  dt¡ |  dt¡ |  dt ¡ ¡ |  dt¡ trHd}|  d|¡ | dkr°tƒ }zLt|ƒ dd	|  d
 }td|g} t	j
| f|Ž}t |¡ t|ddd W 5 t|ƒ X n"t	j
| f|Ž}t |¡ t|jƒ |S )a~  Creates a python subprocess which does nothing for 60 secs and
    return it as a subprocess.Popen instance.
    If "cmd" is specified that is used instead of python.
    By default stdin and stdout are redirected to /dev/null.
    It also attempts to make sure the process is in a reasonably
    initialized state.
    The process is registered for cleanup on reap_children().
    Ústdinr’   Úcwdri   é   ÚcreationflagsNzfrom time import sleep;zopen(r'%s', 'w').close();z
sleep(60);rg   T©ÚdeleteÚempty)Ú
setdefaultr   rœ   Úgetcwdr$   r   rP   rN   r#   rq   ÚPopenÚ_subprocesses_startedÚaddrU   rT   Úpid)ÚcmdÚkwdsZCREATE_NO_WINDOWÚtestfnZpylineÚsprocrw   rw   rx   r@   Y  s4    
ÿþÿ



c                  C   s¬   d} t t ¡ d}zzt dtj |¡tf ¡}t	rDt
|dd\}} nt
|ƒ\}} t |j¡}tt|dddƒ}t |¡ t |¡}||fW ¢S t|ƒ | dk	r¦t| ƒ X dS )	a  Create a subprocess which creates another one as in:
    A (us) -> B (child) -> C (grandchild).
    Return a (child, grandchild) tuple.
    The 2 processes are fully initialized and will live for 60 secs
    and are registered for cleanup on reap_children().
    N©Údira;              import subprocess, os, sys, time
            s = "import os, time;"
            s += "f = open('%s', 'w');"
            s += "f.write(str(os.getpid()));"
            s += "f.close();"
            s += "time.sleep(60);"
            p = subprocess.Popen([r'%s', '-c', s])
            p.wait()
            r   )rÝ   TFrÞ   )rP   rœ   râ   rN   ÚtextwrapÚdedentr    Úbasenamer#   r   r=   r¢   r£   ræ   ro   rU   Ú_pids_startedrå   )Útfileré   ÚsÚsubpÚchildZgrandchild_pidZ
grandchildrw   rw   rx   rB   ƒ  s"    	÷

c            	      C   sØ   t js
t‚tƒ } t d|  ¡}d}t| ƒ}z†| 	t
¡ t|ƒ\}}| ¡ \}}zTt | ¡ gg g t
¡ t| d¡ƒ}t |¡ t  |¡}t|jdƒ ||fW ¢W ¢S | ¡  X W 5 | ¡  t| ƒ |dk	rÒt|ƒ X dS )z±Create a zombie process and return a (parent, zombie) process tuple.
    In order to kill the zombie parent must be terminate()d first, then
    zombie must be wait()ed on.
    a          import os, sys, time, socket, contextlib
        child_pid = os.fork()
        if child_pid > 0:
            time.sleep(3000)
        else:
            # this is the zombie process
            s = socket.socket(socket.AF_UNIX)
            with contextlib.closing(s):
                s.connect('%s')
                if sys.version_info < (3, ):
                    pid = str(os.getpid())
                else:
                    pid = bytes(str(os.getpid()), 'ascii')
                s.sendall(pid)
        Né   zret == psutil.STATUS_ZOMBIE)r¢   r   r¦   rP   rí   rî   rY   ÚcloserN   Ú
settimeoutr   r=   ÚacceptÚselectÚfilenoro   Úrecvrð   rå   r£   rS   Ústatus)	Z	unix_fileÚsrcrñ   ÚsockÚparentÚconnÚ_ZzpidÚzombierw   rw   rx   rA   ª  s.    
ñ


c              	   K   sˆ   |  dd¡ |  dd¡ tƒ }zFt|dƒ}| | ¡ W 5 Q R X tt|jgf|Ž}t|jƒ ||fW S  t	k
r‚   t
|ƒ ‚ Y nX dS )zRun python 'src' code string in a separate interpreter.
    Returns a subprocess.Popen instance and the test file where the source
    code was written.
    r’   Nr“   Úw)rá   rP   ÚopenÚwriter@   r#   r½   rT   ræ   r–   rN   )rý   rè   ÚsrcfileÚfró   rw   rw   rx   r=   ×  s    

c                 K   sÆ   t rdnd}| dtj¡ | dtj¡ | dd¡ | d|¡ t| tƒrTt | ¡} tj| f|Ž}t	 
|¡ tr‚|jtd\}}n| ¡ \}}|jdkr t|ƒ‚|r¬t|ƒ | d	¡rÂ|d
d… }|S )zURun cmd in a subprocess and return its output.
    raises RuntimeError on error.
    rÜ   r   r’   r“   rj   TrÝ   ©ÚtimeoutÚ
Néÿÿÿÿ)r   rá   rq   r•   Ú
isinstanceÚstrÚshlexrp   rã   rä   rå   r   Úcommunicater   Ú
returncodeÚRuntimeErrorr_   Úendswith)rç   rè   ÚflagsÚpr’   r“   rw   rw   rx   Úshë  s&    




r  c              
      sò   dd„ ‰dd„ ‰ ‡ ‡‡fdd„}‡ ‡‡fdd„‰‡fd	d
„}dd„ }| }zbt |tƒrb|||ƒW ¢LS t |tjtjfƒr‚ˆ||ƒW ¢,S t |tjƒrœ|||ƒW ¢S t	d| ƒ‚W 5 t |tjtjfƒrÆ||ƒ t |tƒrÔ|n|j}t |¡rìt|ƒ‚X dS )a˜  Terminate a process and wait() for it.
    Process can be a PID or an instance of psutil.Process(),
    subprocess.Popen() or psutil.Popen().
    If it's a subprocess.Popen() or psutil.Popen() instance also closes
    its stdin / stdout / stderr fds.
    PID is wait()ed even if the process is already gone (kills zombies).
    Does nothing if the process does not exist.
    Return process exit status.
    c                 S   sd   t | tjƒrts|  ¡  n
|  |¡ tr`t | tjƒr`zt | j¡ |¡W S  tj	k
r^   Y nX d S r¿   )
r  rq   rã   r   rÇ   r   r¢   r£   ræ   ÚNoSuchProcess©Úprocr	  rw   rw   rx   rÇ     s    

zterminate.<locals>.waitc                 S   s6   t rtrtj}tr(|tjkr(|  tj¡ |  |¡ d S r¿   )r   rb   ÚsignalÚSIGKILLr   Úsend_signalÚSIGCONT)r  Úsigrw   rw   rx   Úsendsig  s
    zterminate.<locals>.sendsigc              
      sZ   zˆ | ˆƒ W n@ t k
rN } z"tr0|jdkr0n|jtjkr>‚ W 5 d }~X Y nX ˆ| |ƒS )Né   )ÚOSErrorr   ÚwinerrorÚerrnoZESRCH)r  r	  Úerr©r  r  rÇ   rw   rx   Úterm_subprocess_proc'  s    z'terminate.<locals>.term_subprocess_procc                    s0   zˆ | ˆƒ W n t jk
r$   Y nX ˆ| |ƒS r¿   )r¢   r  r  r$  rw   rx   Úterm_psutil_proc1  s
    z#terminate.<locals>.term_psutil_procc                    sF   zt  | ¡}W n( t jk
r6   tr2t| |ƒ Y S Y nX ˆ ||ƒS d S r¿   )r¢   r£   r  r   r   )ræ   r	  r  )r&  rw   rx   Úterm_pid8  s    zterminate.<locals>.term_pidc                 S   s4   | j r| j  ¡  | jr | j ¡  | jr0| j ¡  d S r¿   )r’   rö   r“   rÚ   )r  rw   rw   rx   Úflush_popenB  s    

zterminate.<locals>.flush_popenzwrong type %rN)
r  rq   rã   r¢   ro   ræ   Ú
pid_existsr¦   r£   Ú	TypeError)Zproc_or_pidr  Úwait_timeoutr%  r'  r(  r  ræ   rw   )r  r  r&  rÇ   rx   r>     s&    



	
c                 C   s   t  ¡ j| d}tr&t ¡ }t|ƒ qtr<t ¡ }t|ƒ q&|rŒ|D ]}t|dd qDt j|td\}}|D ]}t	d| ƒ t|t
jd qldS )a  Terminate and wait() any subprocess started by this test suite
    and any children currently running, ensuring that no processes stick
    around to hog resources.
    If recursive is True it also tries to terminate and wait()
    all grandchildren started by this process.
    ©Ú	recursiveN)r+  r  z0couldn't terminate process %r; attempting kill())r  )r¢   r£   Úchildrenrä   Úpopr>   rð   Ú
wait_procsr   r_   r  r  )r-  r.  ró   ræ   r  r  Úaliverw   rw   rx   r?   \  s    


c                  C   s¬   t stdƒ‚d} t ¡ d }|D ]"}| ¡ s4|dkr>| |7 } q  qDq | sTtd| ƒ‚d}d}|  d¡}t|d ƒ}t|ƒdkrŠt|d ƒ}t|ƒdkr¢t|d ƒ}|||fS )	z"Return a tuple such as (2, 6, 36).z	not POSIXÚ rd   rc   zcan't parse %rr   é   r}   )	r   ÚNotImplementedErrorrœ   ÚunameÚisdigitr¤   rp   ro   Úlen)rò   r5  ÚcÚminorÚmicroÚnumsÚmajorrw   rw   rx   rR     s&    

c                  C   sb   t stdƒ‚t ¡ } t| dƒr*| jp&d}n&t d| d ¡}|rLt| 	d¡ƒnd}| d | d |fS )Nznot WINDOWSÚservice_pack_majorr   z\s\d$r~   r3  )
r   r4  rs   ÚgetwindowsversionÚhasattrr=  ÚreÚsearchro   Úgroup)ZwvÚspÚrrw   rw   rx   rQ   ™  s    
c                   @   s<   e Zd ZdZeddddfdd„Zdd„ Zdd	„ Zd
d„ ZdS )ÚretryzA retry decorator.Nr°   c                 C   s2   |r|rt dƒ‚|| _|| _|| _|| _|| _d S )Nz/timeout and retries args are mutually exclusive)r¤   Ú	exceptionr	  ÚretriesÚintervalÚlogfun)r¸   rF  r	  rG  rH  rI  rw   rw   rx   r±   ­  s    zretry.__init__c                 c   sT   | j r*t ¡ | j  }t ¡ |k rPd V  qn&| jrHt| jƒD ]
}d V  q:nd V  qHd S r¿   )r	  rÉ   rG  r   )r¸   Ústop_atr  rw   rw   rx   Ú__iter__¼  s    

zretry.__iter__c                 C   s   | j d k	rt | j ¡ d S r¿   )rH  rÉ   rÊ   r·   rw   rw   rx   rÊ   È  s    
zretry.sleepc                    s"   t  ˆ ¡‡ ‡fdd„ƒ}ˆ|_|S )Nc                     s|   d }ˆD ]b}zˆ | |ŽW   S  ˆj k
rh } z,|}ˆjd k	rHˆ |¡ ˆ ¡  W Y ¢qW 5 d }~X Y qX qtrv|‚n‚ d S r¿   )rF  rI  rÊ   r   )rÃ   rÄ   Úexcr  ©rÓ   r¸   rw   rx   rÔ   Í  s    

zretry.__call__.<locals>.wrapper)rÖ   r×   Ú	decorator)r¸   rÓ   rÔ   rw   rM  rx   Ú__call__Ì  s    zretry.__call__)	r»   rÍ   rÎ   rÏ   r–   r±   rK  rÊ   rO  rw   rw   rw   rx   rE  ª  s   û
rE  r°   )rF  rI  r	  rH  c                 C   s   t  | ¡ trt d¡ dS )z„Wait for pid to show up in the process list then return.
    Used in the test suite to give time the sub process to initialize.
    ç{®Gáz„?N)r¢   r£   r   rÉ   rÊ   ©ræ   rw   rw   rx   rT   ä  s    
Tc              	   C   s:   t | dƒ}| ¡ }W 5 Q R X |s*|s*t‚|r6t| ƒ |S )z8Wait for a file to be written on disk with some content.Úrb)r  Úreadr¦   rN   )Úfnamerß   rà   r  Údatarw   rw   rx   rU   ð  s    c                 C   s   | ƒ }t |ƒst‚|S )zVKeep calling function for timeout secs and exit if eval()
    expression is True.
    )Úevalr¦   )rÓ   ÚexprÚretrw   rw   rx   rS   ý  s    c                 C   sn   dd„ }zLt  | ¡}t |j¡r0t tj| ¡}nt t j| ¡}t	rJ|ƒ  n||ƒ W n t
k
rh   Y nX dS )z?Convenience function for removing temporary test files or dirs.c              
   S   s~   t   ¡ t }t   ¡ |k rvz| ƒ W S  tk
r4   Y n6 tk
rh } z|}tdt|ƒ ƒ W 5 d }~X Y nX t  d¡ q|‚d S )Nzignoring %srP  )rÉ   r   r   ZWindowsErrorr_   r  rÊ   )rÓ   rJ  r  r#  rw   rw   rx   Ú	retry_fun  s    "zsafe_rmpath.<locals>.retry_funN)rœ   ÚstatÚS_ISDIRÚst_moderÖ   ÚpartialÚshutilÚrmtreeÚremover   r   )r    rY  ÚstrÓ   rw   rw   rx   rN     s    
c                 C   s(   zt  | ¡ W n tk
r"   Y nX dS )z.Convenience function for creating a directory.N)rœ   Úmkdirr   rë   rw   rw   rx   Ú
safe_mkdir.  s    rc  c              	   c   s.   t  ¡ }zt  | ¡ dV  W 5 t  |¡ X dS )z@Context manager which temporarily changes the current directory.N)rœ   râ   rM   )ÚdirnameÚcurdirrw   rw   rx   rM   6  s
    

c              	   C   sÐ   t j | ¡rt| ƒ‚|ržtdƒs*t d¡‚t|tƒr>t	 
d¡}t|tƒsPt|ƒ‚ttdddƒ}| |¡ W 5 Q R X zt d|jd| g¡ W 5 t|jƒ X n.t t| ¡ trÌt  | ¡}t  | |jtjB ¡ dS )	z1Creates an executable file in the given location.Úgcczgcc is not installedzŸ
                #include <unistd.h>
                int main() {
                    pause();
                    return 1;
                }
                z.c©Úsuffixr  z-oN)rœ   r    r¥   r¦   r   rD   ÚSkipTestr  Úboolrí   rî   r  r  rP   r  rN   r½   rq   r”   r^  Úcopyfiler#   r   rZ  Úchmodr\  ÚS_IEXEC)ZoutpathZc_coder  ra  rw   rw   rx   rO   A  s$    

ÿ
r2  c                 C   s.   t jt| |d}tj |¡s tj |¡S q dS )zîReturn an absolute pathname of a file or dir that did not
    exist at the time this call is made. Also schedule it for safe
    deletion at interpreter exit. It's technically racy but probably
    not really due to the time variant.
    )Úprefixrh  rì   N)ÚtempfileÚmktempr'   rœ   r    r¥   r¡   )rh  rì   r½   rw   rw   rx   rP   _  s    c                   @   sB   e Zd Zdd„ Zeejdƒs$ejjZe	s>dd„ Z
ejdd„ ƒZdS )	ÚTestCasec                 C   s.   | j j}| d¡sd| }d|| j j| jf S )Nzpsutil.zpsutil.tests.z%s.%s.%s)rº   rÍ   rª   r»   Z_testMethodName)r¸   Zfqmodrw   rw   rx   Ú__str__t  s    
  ÿzTestCase.__str__ÚassertRaisesRegexc                 C   s   d S r¿   rw   r·   rw   rw   rx   ÚrunTest‚  s    zTestCase.runTestc                 o   s
   d V  d S r¿   rw   )r¸   rÃ   Úkwrw   rw   rx   ÚsubTest…  s    zTestCase.subTestN)r»   rÍ   rÎ   rr  r?  rD   rq  ZassertRaisesRegexprs  r   rt  Ú
contextlibÚcontextmanagerrv  rw   rw   rw   rx   rq  p  s   	rq  c                   @   sZ   e Zd ZdZddd„Zdd„ Zdd	„ Zd
d„ Zdd„ Zdd„ Z	dd„ Z
dd„ Zdd„ ZdS )rI   zUTest class providing auto-cleanup wrappers on top of process
    test utilities.
    r2  Nc                 C   s   t ||d}|  t|¡ |S )N)rh  rì   )rP   Ú
addCleanuprN   )r¸   rh  rì   rT  rw   rw   rx   rP   ”  s    zPsutilTestCase.get_testfnc                 O   s   t ||Ž}|  t|¡ |S r¿   )r@   ry  r>   )r¸   rÃ   rè   rê   rw   rw   rx   r@   ™  s    
zPsutilTestCase.spawn_testprocc                 C   s*   t ƒ \}}|  t|¡ |  t|¡ ||fS r¿   )rB   ry  r>   )r¸   Zchild1Zchild2rw   rw   rx   rB   ž  s    
z"PsutilTestCase.spawn_children_pairc                 C   s*   t ƒ \}}|  t|¡ |  t|¡ ||fS r¿   )rA   ry  r>   )r¸   rÿ   r  rw   rw   rx   rA   ¤  s    
zPsutilTestCase.spawn_zombiec                 O   s*   t ||Ž\}}|  t|¡ |  t|¡ |S r¿   )r=   ry  rN   r>   )r¸   rÃ   rè   rê   r  rw   rw   rx   r=   ª  s    zPsutilTestCase.pyrunc                 C   sŠ   |   |tj¡ |  |j|j¡ |  |j|j¡ |jrB|  |jd¡ t|tj	ƒrv|  |j
|j¡ |j
d k	rv|  |j
d¡ t|ƒ t|ƒ d S )Nr2  r   )ZassertIsInstancer¢   ÚErrorÚassertEqualræ   r½   Ú_nameZassertNotEqualr  ÚZombieProcessÚppidZ_ppidZassertGreaterEqualr  Úrepr)r¸   r  rL  rw   rw   rx   Ú_check_proc_exc°  s    
zPsutilTestCase._check_proc_excc              	   C   s¦   |   tj¡4}zt |¡ W n tjk
r:   tdƒ‚Y nX W 5 Q R X |  |jj|¡ |  |jj	d ¡ t 
|¡rxt|ƒ‚|  |t ¡ ¡ |  |dd„ t ¡ D ƒ¡ d S )Nz&wasn't supposed to raise ZombieProcessc                 S   s   g | ]
}|j ‘qS rw   rQ  r«   rw   rw   rx   r®   È  s     z0PsutilTestCase.assertPidGone.<locals>.<listcomp>)ÚassertRaisesr¢   r  r£   r}  r¦   r{  rF  ræ   r½   r)  ZassertNotInÚpidsÚprocess_iter)r¸   ræ   Úcmrw   rw   rx   ÚassertPidGone½  s    ÿzPsutilTestCase.assertPidGonec                 C   s¾   |   |j¡ t|ƒ}|j|jddD ]ˆ\}}| j||dl z
|ƒ }W nF tjk
r^   ‚ Y nD tjk
rŒ } z|  	||¡ W 5 d }~X Y nX d||f }t
|ƒ‚W 5 Q R X q$|jdd d S )NT©Úclear_cache©r  r½   z-Process.%s() didn't raise NSP and returned %rr   r  )r…  ræ   rJ   ÚiterÚallrv  r¢   r}  r  r€  r¦   rÇ   )r¸   r  ÚnsrÓ   r½   rX  rL  Úmsgrw   rw   rx   ÚassertProcessGoneÊ  s     
 ÿz PsutilTestCase.assertProcessGonec                 C   s^  t  |j¡}|  ||¡ ts4ts4|  t|ƒt|ƒ¡ |  | ¡ t j¡ | 	¡ sRt
‚t  |j¡sbt
‚| ¡  |  |jt  ¡ ¡ |  |jdd„ t  ¡ D ƒ¡ i t _|  |jdd„ t  ¡ D ƒ¡ t|ƒ}|j|jddD ]f\}}| j||dJ z
|ƒ  W n8 t jt jfk
r, } z|  ||¡ W 5 d }~X Y nX W 5 Q R X qÒtrÊ|  t j¡}| ¡  W 5 Q R X |  ||j¡ |  t j¡}| ¡  W 5 Q R X |  ||j¡ |  t j¡}| ¡  W 5 Q R X |  ||j¡ | ¡  | ¡  |  ¡  | !¡  | 	¡ søt
‚t  |j¡s
t
‚|  |jt  ¡ ¡ |  |jdd„ t  ¡ D ƒ¡ i t _|  |jdd„ t  ¡ D ƒ¡ d S )	Nc                 S   s   g | ]
}|j ‘qS rw   rQ  r«   rw   rw   rx   r®   ì  s     z6PsutilTestCase.assertProcessZombie.<locals>.<listcomp>c                 S   s   g | ]
}|j ‘qS rw   rQ  r«   rw   rw   rx   r®   î  s     Tr†  rˆ  c                 S   s   g | ]
}|j ‘qS rw   rQ  r«   rw   rw   rx   r®   
  s     c                 S   s   g | ]
}|j ‘qS rw   rQ  r«   rw   rw   rx   r®     s     )"r¢   r£   ræ   r{  r
   r	   Úhashrü   ZSTATUS_ZOMBIEÚ
is_runningr¦   r)  Úas_dictZassertInr‚  rƒ  Z_pmaprJ   r‰  rŠ  rv  r}  ÚAccessDeniedr€  r   r  ÚcmdlinerF  r—   r‰   ÚsuspendÚresumer>   Úkill)r¸   r  Úcloner‹  rÓ   r½   rL  r„  rw   rw   rx   ÚassertProcessZombieÛ  sN    
*z"PsutilTestCase.assertProcessZombie)r2  N)r»   rÍ   rÎ   rÏ   rP   r@   rB   rA   r=   r€  r…  r  r—  rw   rw   rw   rx   rI     s   
zunreliable on PYPYc                   @   s¤   e Zd ZdZdZdZdZer dndZdZ	e
 ¡ Zee d¡ƒZedd	„ ƒZed
d„ ƒZdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zddd„Zdd„ ZdS ) rH   aç  Test framework class for detecting function memory leaks,
    typically functions implemented in C which forgot to free() memory
    from the heap. It does so by checking whether the process memory
    usage increased before and after calling the function many times.

    Note that this is hard (probably impossible) to do reliably, due
    to how the OS handles memory, the GC and so on (memory can even
    decrease!). In order to avoid false positives, in case of failure
    (mem > 0) we retry the test for up to 5 times, increasing call
    repetitions each time. If the memory keeps increasing then it's a
    failure.

    If available (Linux, OSX, Windows), USS memory is used for comparison,
    since it's supposed to be more precise, see:
    https://gmpy.dev/blog/2016/real-process-memory-and-environ-in-python
    If not, RSS memory is used. mallinfo() on Linux and _heapwalk() on
    Windows may give even more precision, but at the moment are not
    implemented.

    PyPy appears to be completely unstable for this framework, probably
    because of its JIT, so tests on PYPY are skipped.

    Usage:

        class TestLeaks(psutil.tests.TestMemoryLeak):

            def test_fun(self):
                self.execute(some_function)
    éÈ   re   r   r|   TZPSUTIL_DEBUGc                 C   s   t  d¡ d S )NF)r¢   Ú
_set_debug©Úclsrw   rw   rx   Ú
setUpClassF  s    zTestMemoryLeak.setUpClassc                 C   s   t  | j¡ d S r¿   )r¢   r™  Ú_psutil_debug_origrš  rw   rw   rx   ÚtearDownClassJ  s    zTestMemoryLeak.tearDownClassc                 C   s   | j  ¡ }t|d|jƒS )NZuss)Ú	_thisprocÚmemory_full_inforž   Zrss)r¸   Úmemrw   rw   rx   Ú_get_memN  s    
zTestMemoryLeak._get_memc                 C   s   t r| j ¡ S | j ¡ S d S r¿   )r   rŸ  Únum_fdsÚnum_handlesr·   rw   rw   rx   Ú_get_num_fdsT  s    
zTestMemoryLeak._get_num_fdsc                 C   s   | j rt|dtjd d S )NÚyellow)ÚcolorÚfile)Úverboser   rs   r“   )r¸   rŒ  rw   rw   rx   Ú_logZ  s    zTestMemoryLeak._logc                 C   sx   |   ¡ }|  |¡ |   ¡ }|| }|dk r8|  d| ¡‚|dkrttrHdnd}|dkr\|d7 }d|||f }|  |¡‚dS )	z»Makes sure num_fds() (POSIX) or num_handles() (Windows) does
        not increase after calling a function.  Used to discover forgotten
        close(2) and CloseHandle syscalls.
        r   zHnegative diff %r (gc probably collected a resource from a previous test)ÚfdÚhandler3  rò   z%s unclosed %s after calling %rN)r¥  ÚcallÚfailr   )r¸   rÓ   ÚbeforeÚafterÚdiffÚtype_rŒ  rw   rw   rx   Ú
_check_fds^  s    
ÿzTestMemoryLeak._check_fdsc                 C   s^   t jdd |  ¡ }t|ƒD ]}|  |¡}~~qt jdd |  ¡ }|  t jg ¡ || }|S )z€Get 2 distinct memory samples, before and after having
        called fun repeatedly, and return the memory difference.
        r3  )Z
generation)ÚgcZcollectr¢  r   r­  r{  Úgarbage)r¸   rÓ   ÚtimesZmem1r­   rX  Zmem2r±  rw   rw   rx   Ú_call_ntimesq  s    
zTestMemoryLeak._call_ntimesc                 C   s¶   g }d}|}t d|d ƒD ]†}|  ||¡}	d|t|	ƒt|	| ƒ|f }
| |
¡ |	|kp^|	|k}|r||dkrv|  |
¡  d S |dkrŠtƒ  |  |
¡ ||7 }|	}q|  d |¡¡‚d S )Nr   r3  z,Run #%s: extra-mem=%s, per-call=%s, calls=%sz. )r   r·  r   Úappendrª  Úprintr®  rÌ   )r¸   rÓ   r¶  rG  Ú	toleranceÚmessagesZprev_memZincreaseÚidxr¡  rŒ  Úsuccessrw   rw   rx   Ú
_check_mem€  s.      
 ÿ


zTestMemoryLeak._check_memc                 C   s   |ƒ S r¿   rw   )r¸   rÓ   rw   rw   rx   r­  ˜  s    zTestMemoryLeak.callNc              
   C   sè   |dk	r|n| j }|dk	r|n| j}|dk	r0|n| j}|dk	rB|n| j}zD|dksZtdƒ‚|dksjtdƒ‚|dksztdƒ‚|dksŠtdƒ‚W n. tk
rº } ztt|ƒƒ‚W 5 d}~X Y nX |  ||¡ |  |¡ | j	||||d dS )	zTest a callable.Nr3  ztimes must be >= 1r   zwarmup_times must be >= 0zretries must be >= 0ztolerance must be >= 0)r¶  rG  rº  )
r¶  Úwarmup_timesrG  rº  r¦   r¤   r  r·  r³  r¾  )r¸   rÓ   r¶  r¿  rG  rº  r#  rw   rw   rx   Úexecute›  s     ÿ
zTestMemoryLeak.executec                    s"   ‡ ‡‡fdd„}ˆj |f|Ž dS )znConvenience method to test a callable while making sure it
        raises an exception on every call.
        c                      s   ˆ  ˆ ˆ¡ d S r¿   )r  rw   ©rL  rÓ   r¸   rw   rx   r­  ³  s    z*TestMemoryLeak.execute_w_exc.<locals>.callN)rÀ  )r¸   rL  rÓ   rÄ   r­  rw   rÁ  rx   Úexecute_w_exc¯  s    zTestMemoryLeak.execute_w_exc)NNNN)r»   rÍ   rÎ   rÏ   r¶  r¿  rº  r*   rG  r©  r¢   r£   rŸ  rj  rœ   Úgetenvr  Úclassmethodrœ  rž  r¢  r¥  rª  r³  r·  r¾  r­  rÀ  rÂ  rw   rw   rw   rx   rH     s.   

  ÿ
c                  C   s¤  dd l } dd l}dd l}dd l}dd l}zdd l}W n tk
rL   d }Y nX zdd l}W n tk
rr   d }Y nX |  ¡ }t	j
r˜tdƒr˜tdƒ|d< nzt	jr´dt ¡ d  |d< n^t	jrúdd ttt ¡ ƒ¡ |d< ttdƒrø|d  d	t ¡  7  < nd
t ¡ t ¡ f |d< d	 tt ¡ ƒt ¡ g ¡|d< t	jrJt ¡ d |d< d	 t ¡ t ¡ t  ¡ g¡|d< t!|ddƒ|d< |d k	rš|d  d|j" 7  < t	jròtdƒrÐtddgƒ}t|ƒ #d¡d |d< nd|d< t $¡ d }	|	rò|	|d< t% &¡ |d< | '¡ }
d|
d |
d f |d< |j (t	 )¡ ¡ *d¡|d< |j +¡  *d¡|d< | ,¡ |d< t-j. /d¡|d < t- 0¡ |d!< t1|d"< t 2¡ |d#< t- 3¡ |d$< t	 4¡ |d%< d&t5d'd(„ t	 6¡ D ƒƒ |d)< t	 7¡ }d*t8|j9ƒt:|j;ƒt:|j<ƒf |d+< t	 =¡ }d*t8|j9ƒt:|j;ƒt:|j<ƒf |d,< t>t	 ?¡ ƒ|d-< t	 @¡  A¡ }| Bd.d ¡ | C|¡|d/< tDd0t%jEd1 | F¡ D ]$\}}tDd2|d3 |f t%jEd1 qbtDd0t%jEd1 t%jG H¡  d S )4Nr   Úlsb_releasezlsb_release -d -sZOSz	Darwin %szWindows ú Úwin32_editionz, z%s %sÚarchrd   ZkernelÚpythonÚ__version__znot installedÚpipz (wheel=%s)rf  z	--versionr
  r3  Úglibczfs-encodingz%s, %sÚlangz%Y-%m-%d %H:%M:%Sz	boot-timerÉ   Úuserú~ÚhomerÛ   ZpyexeÚhostnameZPIDZcpusz%.1f%%, %.1f%%, %.1f%%c                 S   s   g | ]}|t  ¡  d  ‘qS )éd   )r¢   Ú	cpu_countr«   rw   rw   rx   r®      s     z!print_sysinfo.<locals>.<listcomp>Zloadavgz%s%%, used=%s, total=%sZmemoryÚswapr‚  r‰   r  zF======================================================================©r¨  z%-17s %sú:)IÚcollectionsÚdatetimeÚgetpassÚlocaleÚpprintrË  ÚImportErrorÚwheelÚOrderedDictr¢   r   r   r  ZOSXrk   rl   r   rÌ   rn   r  Ú	win32_verr?  rÇ  Úsystemrv   ÚlistÚarchitectureÚmachiner   r5  Úpython_implementationÚpython_versionÚpython_compilerrž   rÊ  rp   Úlibc_verrs   ÚgetfilesystemencodingÚ	getlocaleÚfromtimestampÚ	boot_timeÚstrftimeÚnowÚgetuserrœ   r    Ú
expanduserrâ   r#   ÚnodeÚgetpidrÓ  rm   r†   Úvirtual_memoryro   Úpercentr   ÚusedÚtotalÚswap_memoryr7  r‚  r£   r  r/  Úpformatr¹  r“   Úitemsr’   Úflush)r×  rØ  rÙ  rÚ  rÛ  rË  rÝ  ÚinfoÚoutrò   rÍ  r¡  rÔ  ZpinfoÚkÚvrw   rw   rx   rL   ¹  s¬    

ÿ

ÿý


ÿÿÿ  ÿ
  ÿ
c                  C   s6   t  ¡ } t| dƒr|  ¡ S t| dƒr2t |  ¡ ¡S dS )Nr‹   r„   r   )r¢   r£   r?  r‹   ÚrandomÚchoicer„   )r  rw   rw   rx   Ú_get_eligible_cpu  s    

r   c                   @   sB  e Zd ZdZddi fddi fgZddi fddddifd	di fd
di fddi fddi fddi fddi fddi fg	Zddi fddddifddi fddi fddi fddi fddi fddi fddi fddi fddi fddi fddi fd di fd!di fd"di fd#di fgZerFed$di fg7 Zed%di fg7 Zed&di fg7 Zed'di fg7 Zer\ed(di fg7 Ze	rred)di fg7 Ze
rŒed*ejfi fg7 Zer¢ed+di fg7 Zer¸ed,di fg7 ZerÎed-di fg7 Zeräed.di fg7 Zerþed/dd0d1ifg7 Zg Zereddi fg7 Znedejfi fg7 Ze
rJed*ejd2fi fg7 Ze	r‚erned)ejd3fi fg7 Zned)ejfi fg7 Zeržed+eƒ gfi fg7 Zd4ejfi fd5di fd6di fd7di fd8di fgZerüed4ejfi fg7 Zed4ejfi fg7 Zee e e Zd9d:„ ZdDd;d<„Zd=d>„ Z e!d?d@„ ƒZ"e!dAdB„ ƒZ#dCS )ErJ   a  A container that lists all Process class method names + some
    reasonable parameters to be called with. Utility methods (parent(),
    children(), ...) are excluded.

    >>> ns = process_namespace(psutil.Process())
    >>> for fun, name in ns.iter(ns.getters):
    ...    fun()
    Úcpu_percentrw   Zmemory_percentr  r.  r-  Tr  Zmemory_info_exZoneshotrÿ   Úparentsræ   rÇ   ©r   r’  ÚconnectionsÚkindrŠ  Ú	cpu_timesZcreate_timerÛ   r—   r   Zmemory_infor½   ÚniceZnum_ctx_switchesZnum_threadsZ
open_filesr~  rü   r‘   ÚusernameZuidsZgidsZterminalr£  rŒ   rˆ   r   r„   r‹   r‡   r¤  r‰   ÚgroupedF)rõ   i   r   r  r“  r”  r>   r•  c                 C   s
   || _ d S r¿   )Ú_proc)r¸   r  rw   rw   rx   r±   |  s    zprocess_namespace.__init__c                 c   sZ   t |ƒ}t |¡ |D ]>\}}}|r,|  ¡  t| j|ƒ}tj|f|ž|Ž}||fV  qdS ©z_Given a list of tuples yields a set of (fun, fun_name) tuples
        in random order.
        N)rá  rþ  Úshuffler‡  rž   r
  rÖ   r]  )r¸   Úlsr‡  Úfun_namerÃ   rè   rÓ   rw   rw   rx   r‰    s    
zprocess_namespace.iterc                 C   s   | j j| j jdd dS )z&Clear the cache of a Process instance.T)Z_ignore_nspN)r
  Ú_initræ   r·   rw   rw   rx   r‡  Œ  s    zprocess_namespace.clear_cachec                 C   s>   |D ]4\}}}d| }t ||ƒsd|jj|f }t|ƒ‚qdS )z}Given a TestCase instance and a list of tuples checks that
        the class defines the required test method names.
        Ztest_z$%r class should define a '%s' methodN)r?  rº   r»   ÚAttributeError)r›  Z
test_classr  r  r  Ú	meth_namerŒ  rw   rw   rx   Útest_class_coverage  s    
 ÿz%process_namespace.test_class_coveragec                 C   s`   t dd„ | jD ƒƒ}t dd„ | jD ƒƒ}t dd„ ttjƒD ƒƒ}||B |A }|r\td| ƒ‚d S )Nc                 S   s   g | ]}|d  ‘qS r  rw   r«   rw   rw   rx   r®   ž  s     z*process_namespace.test.<locals>.<listcomp>c                 S   s   g | ]}|d  ‘qS r  rw   r«   rw   rw   rx   r®   Ÿ  s     c                 S   s   g | ]}|d  dkr|‘qS )r   r  rw   r«   rw   rw   rx   r®      s      z!uncovered Process class names: %r)rÈ   rŠ  Úignoredrì   r¢   r£   r¤   )r›  Úthisr  ÚklassZleftoutrw   rw   rx   Útestœ  s    zprocess_namespace.testN)T)$r»   rÍ   rÎ   rÏ   Úutilsr  Úgettersr   r1   r2   r5   r¢   ZRLIMIT_NOFILEr.   r4   r0   r   r3   ÚsettersZNORMAL_PRIORITY_CLASSr   ZIOPRIO_CLASS_NONEZIOPRIO_NORMALr   r  ÚSIGTERMZkillersZCTRL_C_EVENTZCTRL_BREAK_EVENTrŠ  r±   r‰  r‡  rÄ  r  r  rw   rw   rw   rx   rJ     s¤   
þ÷ïû

c                   @   s¦  e Zd ZdZddi fddddifddddifddi fd	dd
difd	dd
difddddifddddifde ¡ fi fddddifddi fddi fddddifde ¡ fi fddi fddi fddi fddi fgZeräeddd
difg7 Ze	røeddi fg7 Ze
reddi fg7 Zer$eddi fg7 Zer:eddi fg7 Zer`ed di fg7 Zed!d"i fg7 Zd#di fd$e ¡ gfi fd%di fd&di fgZeZed'd(„ ƒZejZd)S )*rK   zÝA container that lists all the module-level, system-related APIs.
    Utilities such as cpu_percent() are excluded. Usage:

    >>> ns = system_namespace
    >>> for fun, name in ns.iter(ns.getters):
    ...    fun()
    rë  rw   rÓ  ZlogicalFTZ	cpu_statsr  ZpercpuZdisk_io_countersZperdiskZdisk_partitionsrŠ  Ú
disk_usageZnet_connectionsr  Znet_if_addrsZnet_if_statsrŠ   Zpernicr)  r‚  rö  Zusersrò  r…   r†   r   r   rŽ   Zwin_service_iterZwin_service_get)Úalgrƒ  r0  r  Zcpu_times_percentc                 c   sL   t | ƒ} t | ¡ | D ]0\}}}tt|ƒ}tj|f|ž|Ž}||fV  qdS r  )rá  rþ  r  rž   r¢   rÖ   r]  )r  r  rÃ   rè   rÓ   rw   rw   rx   r‰  Ú  s    

zsystem_namespace.iterN)r»   rÍ   rÎ   rÏ   rœ   râ   rñ  r  r/   ÚHAS_GETLOADAVGr9   r8   r6   r   r¢   r£   r  rŠ  Ústaticmethodr‰  rJ   r  rw   rw   rw   rx   rK   ¦  sT   	îü
c                 C   s   t  | ¡st| ƒ‚d| _| S )zA decorator to mark a TestCase class. When running parallel tests,
    class' unit tests will be run serially (1 process).
    T)ÚinspectÚisclassr¦   Z
_serialrun)r  rw   rw   rx   Ú	serialruné  s    r!  c                 C   s   dd„ }t td| |dS )zZDecorator which runs a test function and retries N times before
    actually failing.
    c                 S   s   t d|  tjd d S )Nz%r, retryingrÕ  )r¹  rs   r“   )rL  rw   rw   rx   rI  ÷  s    z retry_on_failure.<locals>.logfunN)rF  r	  rG  rI  )rE  r¦   )rG  rI  rw   rw   rx   rG   ó  s    ÿc                    s   ‡ fdd„}|S )z,Decorator to Ignore AccessDenied exceptions.c                    s   t  ˆ ¡‡ ‡fdd„ƒ}|S )Nc                     s@   zˆ | |ŽW S  t jk
r:   ˆd k	r,ˆs,‚ t d¡‚Y nX d S )Nzraises AccessDenied)r¢   r‘  rD   ri  rÑ   ©rÓ   Úonly_ifrw   rx   rÔ     s    z9skip_on_access_denied.<locals>.decorator.<locals>.wrapperrÕ   rØ   ©r#  rÒ   rx   rN     s    z(skip_on_access_denied.<locals>.decoratorrw   ©r#  rN  rw   r$  rx   rE   þ  s    c                    s   ‡ fdd„}|S )z3Decorator to Ignore NotImplementedError exceptions.c                    s   t  ˆ ¡‡ ‡fdd„ƒ}|S )Nc                     sH   zˆ | |ŽW S  t k
rB   ˆd k	r*ˆs*‚ dˆ j }t |¡‚Y nX d S )Nz4%r was skipped because it raised NotImplementedError)r4  r»   rD   ri  )rÃ   rÄ   rŒ  r"  rw   rx   rÔ     s    ÿz;skip_on_not_implemented.<locals>.decorator.<locals>.wrapperrÕ   rØ   r$  rÒ   rx   rN    s    
z*skip_on_not_implemented.<locals>.decoratorrw   r%  rw   r$  rx   rF     s    ú	127.0.0.1c              
   C   s@   t  t ¡ ¡(}| | df¡ | ¡ d W  5 Q R £ S Q R X dS )z6Return an unused TCP port. Subject to race conditions.r   r3  N)rw  ÚclosingÚsocketÚbindÚgetsockname)Úhostrþ   rw   rw   rx   rW   &  s    c                 C   sˆ   |dkr| t tfkrd}t | |¡}z@tjdkrB| tjtjd¡ | |¡ |tj	kr`| 
d¡ |W S  tk
r‚   | ¡  ‚ Y nX dS )zBinds a generic socket.N©r2  r   )ÚntÚcygwinr3  r|   )r   r   r(  rœ   r½   Ú
setsockoptÚ
SOL_SOCKETÚSO_REUSEADDRr)  r   Úlistenr–   rö   )ÚfamilyÚtypeÚaddrrþ   rw   rw   rx   rX   -  s    



c                 C   sr   t js
t‚tj | ¡rt| ƒ‚t tj|¡}z"| | ¡ |tj	krL| 
d¡ W n tk
rl   | ¡  ‚ Y nX |S )zBind a UNIX socket.r|   )r¢   r   r¦   rœ   r    r¥   r(  r¯   r)  r   r2  r–   rö   )r½   r4  rþ   rw   rw   rx   rY   >  s    


r,  c              
   C   s´   t  t | t¡¡˜}| |¡ | d¡ | ¡ }t | t¡}zJ| |¡ | ¡ }| ¡ \}}||krz||fW W  5 Q R £ S | 	¡  qPW n t
k
r¤   | 	¡  ‚ Y nX W 5 Q R X dS )z^Build a pair of TCP sockets connected to each other.
    Return a (server, client) tuple.
    r|   N)rw  r'  r(  r   r)  r2  r*  Úconnectrø   rö   r   )r3  r5  Úllr8  ZcaddrÚarw   rw   rx   rZ   M  s    


c                 C   s’   t js
t‚d }}z@t| tjd}| d¡ t tjtj¡}| d¡ | | ¡ W n6 t	k
rˆ   |dk	rr| 
¡  |dk	r‚| 
¡  ‚ Y nX ||fS )zƒBuild a pair of UNIX sockets connected to each other through
    the same UNIX file name.
    Return a (server, client) tuple.
    N©r4  r   )r¢   r   r¦   rY   r(  r   Úsetblockingr¯   r6  r–   rö   )r½   ÚserverÚclientrw   rw   rx   r[   d  s    


c               	   c   sì   g } d }}z¨|  ttjtjƒ¡ |  ttjtjƒ¡ tƒ rd|  ttj	tjƒ¡ |  ttj	tjƒ¡ t
r¬tr¬tƒ }tƒ }t|ƒ\}}t|tjd}|||fD ]}|  |¡ qœ| V  W 5 | D ]}|  ¡  qº||fD ]}|dk	rÐt|ƒ qÐX dS )z1Open as many socket families / types as possible.Nr9  )rö   rN   r¸  rX   r(  r   r   Ú
SOCK_DGRAMr   r   r   ÚHAS_CONNECTIONS_UNIXrP   r[   rY   )ÚsocksZfname1Zfname2rò   rT  Ús1Ús2Zs3rw   rw   rx   r\   {  s*    

c                 C   s  ddl }tr(tr(ts(t|tjƒs(t|ƒ‚|tjkršdd„ |  	d¡D ƒ}t
|ƒdksZt| ƒ‚|D ]"}d|  krvdks^n t| ƒ‚q^tsŽt| ƒ} | | ¡ nd|tjkrÎt| tƒs¶t| ƒ‚tsÂt| ƒ} | | ¡ n0|tjkròt d| ¡dk	sþt| ƒ‚ntd	| ƒ‚dS )
z[Check a net address validity. Supported families are IPv4,
    IPv6 and MAC addresses.
    r   Nc                 S   s   g | ]}t |ƒ‘qS rw   )ro   r«   rw   rw   rx   r®   ž  s     z%check_net_address.<locals>.<listcomp>rc   r~   éÿ   z([a-fA-F0-9]{2}[:|\-]?){6}zunknown family %r)Ú	ipaddressÚenumr   r"   r  ÚIntEnumr¦   r(  r   rp   r7  r   ÚIPv4Addressr   r  ÚIPv6Addressr¢   ZAF_LINKr@  Úmatchr¤   )r5  r3  rC  ZoctsÚnumrw   rw   rx   rV   –  s&    
 

c                 C   sT   dd„ }dd„ }dd„ }dd„ }d	d
„ }|| ƒ || ƒ || ƒ || ƒ || ƒ dS )z*Check validity of a connection namedtuple.c                 S   sÔ   t | ƒdk}t | ƒdks$tt | ƒƒ‚| d | jks<t| jƒ‚| d | jksTt| jƒ‚| d | jkslt| jƒ‚| d | jks„t| jƒ‚| d | jksœt| jƒ‚| d | jks´t| jƒ‚|rÐ| d	 | jksÐt| jƒ‚d S )
Nrš   )r  rš   r   r3  rd   r}   r~   r|   r  )	r7  r¦   r«  r3  r4  ÚladdrÚraddrrü   ræ   )r   Zhas_pidrw   rw   rx   Úcheck_ntuple²  s    z-check_connection_ntuple.<locals>.check_ntuplec                 S   sð   | j tttfkst| j ƒ‚td k	r:t| j tjƒsNt| ƒ‚nt| j tƒsNt| ƒ‚| j tkrÌt	 	| j | j
¡}t |¡R z| | jd df¡ W n2 t	jk
r¾ } z|jtjkr®‚ W 5 d }~X Y nX W 5 Q R X n | j tkrì| jtjksìt| jƒ‚d S )Nr   )r3  r   r   r¯   r¦   rD  r  rE  ro   r(  r4  rw  r'  r)  rJ  Úerrorr"  ZEADDRNOTAVAILrü   r¢   Ú	CONN_NONE)r   rò   r#  rw   rw   rx   Úcheck_family¾  s    
 
z-check_connection_ntuple.<locals>.check_familyc                 S   s†   t tdtƒ ƒ}| jtjtj|fks,t| jƒ‚td k	rLt| jtj	ƒs`t| ƒ‚nt| jt
ƒs`t| ƒ‚| jtjkr‚| jtjks‚t| jƒ‚d S )NÚSOCK_SEQPACKET)rž   r(  Úobjectr4  r   r=  r¦   rD  r  rE  ro   rü   r¢   rN  )r   rP  rw   rw   rx   Ú
check_typeÓ  s    ÿÿz+check_connection_ntuple.<locals>.check_typec                 S   s¬   | j | jfD ]š}| jttfkr†t|tƒs4tt|ƒƒ‚|s:qt|j	t
ƒsTtt|j	ƒƒ‚d|j	  krjdksvn t|j	ƒ‚t|j| jƒ q| jtkrt|tƒstt|ƒƒ‚qd S )Nr   iÿÿ  )rJ  rK  r3  r   r   r  rm   r¦   r4  Úportro   rV   Úipr¯   r  )r   r5  rw   rw   rx   Úcheck_addrsß  s    "
z,check_connection_ntuple.<locals>.check_addrsc                 S   s†   t | jtƒst| jƒ‚dd„ ttƒD ƒ}| j|ks<t| jƒ‚| jttfkrl| j	t
krl| jtjks‚t| jƒ‚n| jtjks‚t| jƒ‚d S )Nc                 S   s    g | ]}|  d ¡rtt|ƒ‘qS )ZCONN_r©   r«   rw   rw   rx   r®   î  s    
ÿzAcheck_connection_ntuple.<locals>.check_status.<locals>.<listcomp>)r  rü   r  r¦   rì   r¢   r3  r   r   r4  r   rN  )r   Zvalidsrw   rw   rx   Úcheck_statusì  s    z-check_connection_ntuple.<locals>.check_statusNrw   )r   rL  rO  rR  rU  rV  rw   rw   rx   Úcheck_connection_ntuple°  s    
rW  c                 C   sP   zddl }t|dƒst‚W n& tk
r@   ddl}| | ¡ Y S X | | ¡S dS )z,Backport of importlib.reload of Python 3.3+.r   NÚreload)Ú	importlibr?  rÜ  ÚimprX  )ÚmodulerY  rZ  rw   rw   rx   r]     s    
c                 C   sp   t j t j | ¡¡d }tjd dkr:dd l}| || ¡S dd l}|j	 
|| ¡}|j	 |¡}|j |¡ |S d S )Nr   rd   )rœ   r    Úsplitextrï   rs   rŸ   rZ  Zload_sourceÚimportlib.utilÚutilÚspec_from_file_locationÚmodule_from_specÚloaderÚexec_module)r    r½   rZ  rY  ÚspecÚmodrw   rw   rx   r^     s    c                 C   s   t j| tdd dS )zRaise a warning msg.rd   )Ú
stacklevelN)Úwarningsr_   ÚUserWarning)rŒ  rw   rw   rx   r_   !  s    c                 C   sV   t | ƒ}|j}t|ƒdks&|d tkr*dS t|ddƒ}t|tƒsDdS tdd„ |D ƒƒS )z-Check if object is an instance of namedtuple.r3  r   FÚ_fieldsNc                 s   s   | ]}t |tƒV  qd S r¿   )r  r  )r¬   Únrw   rw   rx   Ú	<genexpr>/  s     z is_namedtuple.<locals>.<genexpr>)r4  Ú	__bases__r7  rm   rž   r  rŠ  )r­   ÚtÚbr  rw   rw   rx   ra   &  s    
c                 #   st   t rdnd‰ d‰t| ˆ d}‡ ‡fdd„t ¡  ¡ D ƒ}t |¡}t ||¡ zt
 |¡ |V  W 5 t	|ƒ X dS )zÂCtx manager which picks up a random shared CO lib used
        by this process, copies it in another location and loads it
        in memory via ctypes. Return the new absolutized path.
        ÚpypyrÉ  z.sorg  c                    s6   g | ].}t j |j¡d  ˆkrˆ |j ¡ kr|j‘qS )r3  )rœ   r    r\  Úlowerr«   ©r—   Úextrw   rx   r®   <  s    þú'copyload_shared_lib.<locals>.<listcomp>N)r"   rP   r¢   r£   r‰   rþ  rÿ  r^  rk  rN   ÚctypesÚCDLL)rh  ÚdstÚlibsrý   rw   rp  rx   r`   3  s    


c           	      #   sÔ   ddl m} ddl m} d‰ t| ˆ  d}‡ fdd„t ¡  ¡ D ƒ}trb|sbdd„ t ¡  ¡ D ƒ}t 	|¡}t
 ||¡ d	}zt  |¡}|V  W 5 |d	k	rÆt jjj}|jg|_||jƒ}|dkrÆ|ƒ  t|ƒ X d	S )
zÖCtx manager which picks up a random shared DLL lib used
        by this process, copies it in another location and loads it
        in memory via ctypes.
        Return the new absolutized, normcased path.
        r   )ÚWinError)Úwintypesz.dllrg  c                    sF   g | ]>}|j  ¡  ˆ ¡rd tj  |j ¡ ¡ krd|j  ¡ kr|j ‘qS )rÉ  Zwow64)r    ro  r  rœ   rï   r«   ©rq  rw   rx   r®   R  s
    ýrr  c                 S   s(   g | ] }d t j |j¡ ¡ kr|j‘qS )rn  )rœ   r    rï   ro  r«   rw   rw   rx   r®   W  s    ÿN)rs  rw  rx  rP   r¢   r£   r‰   r"   rþ  rÿ  r^  rk  ÚwindllÚkernel32ÚFreeLibraryZHMODULEZargtypesZ_handlerN   ZWinDLL)	rh  rw  rx  ru  rv  rý   Úcfiler|  rX  rw   ry  rx   r`   G  s(    





c                   C   s   t dd d S )NTr,  )r?   rw   rw   rw   rx   Úcleanup_test_procst  s    r~  c                 C   s
   t  | ¡S r¿   )rs   Úexit)r  r  rw   rw   rx   Ú<lambda>~  ó    r€  )N)F)TF)N)r2  N)N)N)r&  )r,  )r2  )r2  )ºrÏ   Ú
__future__r   Úatexitrw  rs  r"  rÖ   r´  r  rœ   rk   rþ  r@  rù   r  r^  r  r(  rZ  rq   rs   ro  rí   r´   rÉ   rD   rf  r   r   r   r¢   r   r   r   r	   r
   r   r   r   Zpsutil._commonr   r   r   r   Zpsutil._compatr   r   r   r   r   r   r   r   r   rÜ  Úcatch_warningsÚsimplefilterrD  Zpsutil._psposixr   Ú__all__Úbuiltin_module_namesr"   r‡   r   rb   r*   r<   Úmaxsizer-   ry   r:   r;   r!   r    r,   r   r½   rñ  r'   r(   Údecoder)   rè  ro  ZASCII_FSr    r¡   rÌ   rd  Ú__file__r%   Úgetr&   ZHEREr>  r?  r£   r.   r/   r  r0   r2   r3   ZHAS_NET_IO_COUNTERSr4   r1   r5   r6   rj  rŽ   r7   r–   r8   r9   ZHAS_THREADSÚgetuidZSKIP_SYSCONSr¨   r#   r$   r  Údevnullr   Úregisterrö   rì   r+   rž   rQ  r¯   rÈ   rä   rð   rÆ   rC   rÙ   r@   rB   rA   r=   r  r  r>   r?   rR   rQ   rE  r  rT   r¦   rU   rS   rN   rc  rx  rM   rO   rP   rq  rI   ZskipIfrH   rL   r   rJ   rK   r!  rG   rE   rF   rW   rX   rY   rZ   r[   r\   rV   rW  r]   r^   r_   ra   r`   r~  rw   rw   rw   rx   Ú<module>   s  


                                              ß+






ÿþ






(
0)
&-

U
%:
ÿ


 ÿÿ
!



 
 Z	 C





R,
