File: //opt/osm/venv/lib/python3.10/site-packages/psutil/tests/__pycache__/__init__.cpython-310.pyc
o
=i�� �
@ s� d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddlm Z ddlm Z ddlm Z zddl Z W n e!y� dZ Y nw ddl"Z"ddl"m#Z# ddl"m$Z$ ddl"m%Z% dd l"m&Z& dd
l"m'Z' dd l"m(Z( dd l"m)Z) dd
l"m*Z* ddl+m,Z, ddl+m-Z- ddl+m.Z. ddl+m/Z/ ddl+m0Z0 e(r�ddl1m2Z2 g d�Z3dej4v Z5de
j6v �pde
j6v Z7e7Z8de
j6v Z9de
j6v Z:ej;dkZ<e �=� �>� dv Z?e �=� d kZ@e.d d � �ZAe%�r7eA� d kZBeA� d kZCnd!ZBd!ZCd"ZDd#ZEd$ZFd%ZGe8�rVeDd&9 ZDeGd&9 ZGeEd'9 ZEeFd&9 ZFd(e
�H� � d)�ZId*ZJd+�Kd,d-�ZLe�M� �>� d.v ZNe
j6�Od/��p�e
jP�Qe
jP�Re
jP�SeT�d0d0��ZUe
jP�ReUd1�ZVe
jP�Qe
jP�SeT��ZWeXe"jYd2�ZZeXe"jYd3�Z[eXe"d4�Z\eXe"jYd5�Z]eXe"jYd6�Z^e(�o�e) Z_eXe"d7�Z`eXe"jYd8�ZaeXe"jYd9�ZbeXe"jYd:�ZceXe"d;�ZdeXe"d<�ZeeXe"d=�ZfeXe"jYd>�Zge%�s�e#�o�e
�h� dkZiz ed�o�eje"�k� �ZlW n em�y e�ne�oepe�q� �� d!ZlY nw zeXe"d?��o eje"�r� �ZsW n em�y9 e�ne�oepe�q� �� d!ZsY nw d@dA� Ztet� \ZuZvewe
jxdB�Zye�neyjz� dCdD� e{e"�D �Z|e}edEe~� �Ze�� Z�e�� Z�G dFdG� dG�Z�e�e�j�_me du �r�e�Z e�ej�dH< e���� G dIdJ� dJej��Z�dKdL� Z�e�d�dMdN��Z�e�dOdP� �Z�dQdR� Z�e�dSdT� �Z�e�dUdV� �Z�ej�eGfdWdX�Z�d�dYdZ�Z�d[d\� Z�d]d^� Z�G d_d`� d`�Z�e�e"j�deGdadb�dcdd� �Z�e�e�e�fdeGdadb�d�dfdg��Z�e�e�e j�jmfdeGdadb�dhdi� �Z�djdk� Z�dldm� Z�ej�dndo� �Z�dpdq� Z�d�drds�Z�d�dudv�Z�G dwdx� dxej��Z�e j�j�e5dydz�e j�j�d{d|�G d}d~� d~e����Z�dd�� Z�d�d�� Z�G d�d�� d��Z�G d�d�� d��Z�eDfd�d��Z�d�d�d��Z�d�d�d��Z�d�d�d��Z�e e dfd�d��Z�ej fd�d��Z�d�d�d��Z�d�d�� Z�ej�d�d�� �Z�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�e(�r�ej�d�d�d���Z�nej�d�d�d���Z�ejnd�d�� �Z�e(�r�e�ej�d�d�� � dS dS )�zTest utilities.� N)�AF_INET)�AF_INET6)� SOCK_STREAM)�AIX)�LINUX)�MACOS)�NETBSD)�OPENBSD)�POSIX)�SUNOS)�WINDOWS)� bytes2human)�debug)�memoize)� print_color)�
supports_ipv6)�wait_pid)J�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�HAS_NET_CONNECTIONS_UNIX� MACOS_11PLUS� MACOS_12PLUS�COVERAGE�AARCH64�PYTEST_PARALLEL�pyrun� terminate�
reap_children�
spawn_subproc� spawn_zombie�spawn_children_pair�
ThreadTask�unittest�skip_on_access_denied�skip_on_not_implemented�retry_on_failure�TestMemoryLeak�PsutilTestCase�process_namespace�system_namespace�is_win_secure_system_proc� fake_pytest�chdir� safe_rmpath�
create_py_exe� create_c_exe�
get_testfn�
get_winver�kernel_version�
call_until� wait_for_pid�
wait_for_file�check_net_address�filter_proc_net_connections�
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_RUNZPYTEST_XDIST_WORKERl > �aarch64�arm64�riscv64c C sn t �� d } ttt| �d�d d� ��}|dkr5tjtj dddgdd id
d �} ttt| �d�d d� ��}|S ) Nr �.� )�
� z-sS�-cz-import platform; print(platform.mac_ver()[0])�SYSTEM_VERSION_COMPAT�0T)�env�universal_newlines)
�platform�mac_ver�tuple�map�int�split�
subprocess� check_output�sys�
executable)� version_str�version� rv �C/opt/osm/venv/lib/python3.10/site-packages/psutil/tests/__init__.py�
macos_versionz s ��
rx )rc � )� r Frc i P i � � � � z@psutil-�-u -ƒőős f���utf8�surrogateescape> �asciizus-asciiZPSUTIL_ROOT_DIRz..�scripts� cpu_affinity�environ�
getloadavg�ionice� memory_maps�net_io_counters�cpu_num� io_counters�rlimit�sensors_battery� sensors_fans�sensors_temperatures�threads�cpu_freqc C s� dd� } t j�� }ttdd �}tr#tjdkr#|d ur#tj|d< ||fS tr*tj|fS t r[| tj�pP| t j
� tj��pP| t �
djtjd d� � ��pP| t�� �� �}|sWtd��||fS t j
� tj�}t j
�|�slJ |��||fS ) Nc S s6 zt j| dgt jt jd� W | S t jy Y d S w )Nz-V)�stdout�stderr)rp �
check_call�PIPE�CalledProcessError)�exerv rv rw �attempt� s ���z _get_py_exe.<locals>.attempt�_base_executable)r| � �__PYVENV_LAUNCHER__z python{}.{}rb z"can't find python exe real abspath)�osr� �copy�getattrrr r � version_infors r] r �path�realpath�shutil�which�format�psutil�Processr� �
ValueError�exists)r� rh �baser� rv rv rw � _get_py_exe� s0
����r� zr+c C � g | ] }|� d �rtt|��qS )ZSTATUS_��
startswithr� r� ��.0�xrv rv rw �
<listcomp> �
��r� �AF_UNIXc @ sn e Zd ZdZedd� �Zedd� �Zeddd��Zedd d
��Zedd d
��Z eddd��Z
G dd� d�Z dS )rE z�A class that mimics some basic pytest APIs. This is meant for
when unit tests are run in production, where pytest may not be
installed. Still, the user can test psutil installation via:
$ python3 -m psutil.tests
c C s dd� } t �| � d S )Nc S s t jdtdd� d S )Nz<Fake pytest module was used. Test results may be inaccurate.� ��
stacklevel��warningsrZ � UserWarningrv rv rv rw �
_warn_on_exit! s
�z0fake_pytest._warn_on_exit.<locals>._warn_on_exit)�atexit�register)r� rv rv rw r� s zfake_pytest._warn_on_exitc O s$ t �� �t�}t jdd��|� |S )z�Mimics pytest.main(). It has the same effect as running
`python3 -m unittest -v` from the project root directory.
rb )� verbosity)r< Z
TestLoader�discover�HEREZTextTestRunner�run)�args�kwZsuiterv rv rw �main* s zfake_pytest.mainNc s. G dd� d�� t jd� fdd� �}|| |d�S )zMimics `pytest.raises`.c @ s e Zd ZdZedd� �ZdS )z)fake_pytest.raises.<locals>.ExceptionInfoNc S s | j S �N)�_exc��selfrv rv rw �value: s z/fake_pytest.raises.<locals>.ExceptionInfo.value)�__name__�
__module__� __qualname__r� �propertyr� rv rv rv rw �
ExceptionInfo7 s r� Nc
3 s| � � � }z|V W n- | y6 } z!|r(t �|t|��s(d|� d|� d�}t|��||_W Y d }~d S d }~ww t| �d���)N�"z" does not match "z not raised)�re�search�str�AssertionErrorr� )�exc�matchZeinfo�err�msg�r� rv rw �context> s �
��z#fake_pytest.raises.<locals>.context)r� r� )�
contextlib�contextmanager)r� r� r� rv r� rw �raises3 s zfake_pytest.raisesc C s" |r
t �� �| |�S t �� �| �S )zMimics `pytest.warns`.)r< �TestCaseZassertWarnsRegexZ assertWarns)�warningr� rv rv rw �warnsM s zfake_pytest.warns� c C s
t �| ��)zMimics `unittest.SkipTest`.)r< ZSkipTest��reasonrv rv rw �skipT s
zfake_pytest.skipc C s t �� �| �S )zMimics `pytest.fail`.)r< r� �failr� rv rv rw r� Y s zfake_pytest.failc @ s( e Zd Zeddd��ZG dd� d�ZdS )zfake_pytest.markr� c C s t �| |�S )z'Mimics `@pytest.mark.skipif` decorator.)r< ZskipIf)� conditionr� rv rv rw �skipif` s zfake_pytest.mark.skipifc @ s" e Zd ZdZddd�Zdd� ZdS )z fake_pytest.mark.xdist_groupz4Mimics `@pytest.mark.xdist_group` decorator (no-op).Nc C s d S r� rv �r� �namerv rv rw �__init__h � z%fake_pytest.mark.xdist_group.__init__c C s |S r� rv )r� Z cls_or_methrv rv rw �__call__k r� z%fake_pytest.mark.xdist_group.__call__r� )r� r� r� �__doc__r� r� rv rv rv rw � xdist_groupe s
r� N�r� )r� r� r� � staticmethodr� r� rv rv rv rw �mark^ s r� r� r� ) r� r� r� r� r� r� r� r� r� r� r� r� rv rv rv rw rE s
rE �pytestc sP e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
� Z S )r; z6A thread task which does nothing expect staying alive.c s$ t � �� d| _d| _t�� | _d S )NF���MbP?)�superr� �_running� _interval� threading�Event�_flagr� �� __class__rv rw r� � s
zThreadTask.__init__c C s( | j j}d|� d| j� dt| �d�d�S )N�<z running=z at z#x�>)r� r� r� �idr� rv rv rw �__repr__� s zThreadTask.__repr__c C s | � � | S r� )�startr� rv rv rw � __enter__� s zThreadTask.__enter__c O s | � � d S r� )�stop)r� r� �kwargsrv rv rw �__exit__� s zThreadTask.__exit__c C s( | j rtd��tj�| � | j�� dS )zStart thread and keep it running until an explicit
stop() request. Polls for shutdown every 'timeout' seconds.
zalready startedN)r� r� r� �Threadr� r� �waitr� rv rv rw r� � s zThreadTask.startc C s0 d| _ | j�� | j rt�| j� | j s d S d S )NT)r� r� �set�time�sleepr� r� rv rv rw r� � s
�zThreadTask.runc C s | j std��d| _ | �� dS )z8Stop thread execution and and waits until it is stopped.zalready stoppedFN)r� r� �joinr� rv rv rw r� � s zThreadTask.stop) r� r� r� r� r� r� r� r r� r� r� �
__classcell__rv rv r� rw r; s r; c s t �� �� fdd��}|S )Nc s( z� | i |��W S t y t� � w r� )� Exceptionr7 �r� r ��funrv rw �wrapper� s �z&_reap_children_on_err.<locals>.wrapper�� functools�wraps�r r
rv r rw �_reap_children_on_err� s r c K s� |� dt� |� dt� |� dt�� � |� dt� tr$d}|� d|� | du r`tt�� d�}z+t|� d |� d
�}td |g} t j
| fi |��}t � |� t
|d d d
� W t|� |S t|� w t j
| fi |��}t � |� t|j� |S )a Create a python subprocess which does nothing for some 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� �cwdrh � �
creationflagsN��dirzimport time;open(r'z6', 'w').close();[time.sleep(0.1) for x in range(100)];re T��delete�empty)�
setdefaultr r� �getcwdr r rJ rG r rp �Popen�_subprocesses_started�addrO rN �pid)�cmd�kwdsZCREATE_NO_WINDOW�testfnZpyline�sprocrv rv rw r8 � s4
��
�
r8 c C s� d} t t�� d�}zLt�dtj�|�� dt� d��}tr%t |dd�\}} nt |�\}} t
� |j �}t
t|dd d
��}t�|� t
� |�}||fW t|� | durUt| � S S t|� | durct| � w w ) 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().
Nr zl import subprocess, os, sys, time
s = "import os, time;"
s += "f = open('z�', 'w');"
s += "f.write(str(os.getpid()));"
s += "f.close();"
s += "[time.sleep(0.1) for x in range(100 * 6)];"
p = subprocess.Popen([r'z.', '-c', s])
p.wait()
r )r TFr )rJ r� r �textwrap�dedentr� �basenamer r r5 r� r� r! rn rO �
_pids_startedr rG )�tfiler$ �s�subp�childZgrandchild_pidZ
grandchildrv rv rw r: � s0
�
�
��
�r: c s t jsJ �t� } t�d| � d��}d}t| �}zV|�t� t|�\}}|� � \}}z?t
�
|� � gg g t� t |�
d��}t�|� t �|�� t� fdd�� |� fW |�� W |�� t| � |durht|� S S |�� w |�� t| � |durt|� w w )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
with socket.socket(socket.AF_UNIX) as s:
s.connect('za')
pid = bytes(str(os.getpid()), 'ascii')
s.sendall(pid)
N� c s � � � tjkS r� )�statusr� �
STATUS_ZOMBIErv ��zombierv rw �<lambda>* s z spawn_zombie.<locals>.<lambda>)r� r
rJ r& r' rT �
settimeoutr r5 �accept�select�filenorn �recvr) r r� rM �closerG )Z unix_file�srcr* �sock�parent�conn�_Zzpidrv r1 rw r9 s<
�
�
�
�r9 c K s� |� dd� |� dd� t� }z/t|d��
}|�| � W d � n1 s%w Y tt|jgfi |��}t|j� ||fW S t yJ t
|� � w )z�Run 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 rJ �open�writer8 r r� rN r! r rG )r: r# �srcfile�fr, rv rv rw r5 5 s �
�r5 c K s� t rdnd}|�dtj� |�dtj� |�dd� |�d|� t| t�r*t�| �} tj| fi |��}t �
|� |j t d�\}}|j
dkrKt|| ��|rQt|� |�d �r\|d
d � }|S ) zURun cmd in a subprocess and return its output.
raises RuntimeError on error.
r r r� r� ri Tr ��timeout�
N���)r r rp r� �
isinstancer� �shlexro r r r � communicater �
returncode� RuntimeErrorrZ �endswith)r" r# �flags�pr� r� rv rv rw �shI s"
rP c
s� dd� �dd� � � ��fdd�}� ��fdd���fd d
�}d d � }| }z�t |t�rP|||�W t |tjtjf�r<||� t |t�rC|n|j}t�|�rOJ |��S t |tjtjf�r�||�W t |tjtjf�rk||� t |t�rr|n|j}t�|�r~J |��S t |tj�r�|||�W t |tjtjf�r�||� t |t�r�|n|j}t�|�r�J |��S td
|����t |tjtjf�r�||� t |t�r�|n|j}t�|�r�J |��w )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 sN | � |� tr#t| tj�r%z
t�| j�� |�W S tjy" Y d S w d S d S r� ) r r rH rp r r� r� r! �
NoSuchProcess��procrE rv rv rw r m s
��zterminate.<locals>.waitc S s6 t rtrtj}tr|tjkr| �tj� | �|� d S r� )r r] �signal�SIGKILLr
� send_signal�SIGCONT)rS �sigrv rv rw �sendsigv s
zterminate.<locals>.sendsigc
sT z� | �� W n t y Y n ty$ } z tr |jdkr � d }~ww �| |�S )N� )�ProcessLookupError�OSErrorr �winerror)rS rE r� �rY rX r rv rw �term_subprocess_proc� s ��
z'terminate.<locals>.term_subprocess_procc s. z� | �� W n
t jy Y nw �| |�S r� )r� rQ rR r^ rv rw �term_psutil_proc� s �
z#terminate.<locals>.term_psutil_procc sB zt �| �}W n t jy trt| |� Y S Y d S w � ||�S r� )r� r� rQ r
r )r! rE rS )r` rv rw �term_pid� s ��
zterminate.<locals>.term_pidc S s8 | j r| j �� | jr| j�� | jr| j�� d S d S r� )r� r9 r� r �rS rv rv rw � flush_popen� s
�z terminate.<locals>.flush_popenz wrong type ) rH rn rp r r� r! �
pid_existsr� � TypeError)Z proc_or_pidrX � wait_timeoutr_ ra rc rO r! rv )rY rX r` r rw r6 b s>
�
�
�r6 c C s� t �� j| d�}trt�� }t|� ts
tr t�� }t|� ts|rJ|D ]}t|dd� q$t j|td�\}}|D ]}t d|�d�� t|t
j d� q8dS dS )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)rf rD zcouldn't terminate process z; attempting kill())rX ) r� r� �childrenr �popr6 r) �
wait_procsr rZ rT rU )rh ri r, r! rO r> �aliverv rv rw r7 � s$
���r7 c C s� t std��d} t�� d }|D ]}|�� s|dkr | |7 } q | s)td|����d}d}| �d�}t|d �}t|�dkrDt|d �}t|�dkrPt|d �}|||fS ) z"Return a tuple such as (2, 6, 36).z not POSIXr� rb ra z can't parse r r� r| ) r
�NotImplementedErrorr� �uname�isdigitr� ro rn �len)r+ rn �c�minor�microZnums�majorrv rv rw rL � s&
rL c C s0 t std��t�� } | jpd}| d | d |fS )Nz not WINDOWSr r� )r rm rr �getwindowsversion�service_pack_major)Zwv�sprv rv rw rK � s
rK c @ s< e Zd ZdZeddddfdd�Zdd� Zdd � Zd
d � ZdS ) �retryzA retry decorator.Nr� c C s2 |r|rt d��|| _|| _|| _|| _|| _d S )Nz/timeout and retries args are mutually exclusive)r� � exceptionrE �retries�interval�logfun)r� ry rE rz r{ r| rv rv rw r� s
zretry.__init__c c sf � | j r t�� | j }t�� |k r d V t�� |k sd S d S | jr.t| j�D ]}d V q&d S d V q/r� )rE r rz �range)r� �stop_atr> rv rv rw �__iter__ s � ���zretry.__iter__c C s | j d ur
t�| j � d S d S r� )r{ r r r� rv rv rw r s
�z retry.sleepc s" t �� �� �fdd��}�|_|S )Nc sl d }�D ]/}z
� | i |��W S �j y3 } z|}�jd ur%��|� ��� W Y d }~qd }~ww |�r� )ry r| r )r� r r� r> �r r� rv rw r
$ s
��z retry.__call__.<locals>.wrapper)r r � decorator)r� r r
rv r� rw r� # s zretry.__call__) r� r� r� r� r r� r r r� rv rv rv rw rx s
� rx r� )ry r| rE r{ c C s$ | t �� vr t �| ��t �| � dS )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.
N)r� �pidsrQ r� �r! rv rv rw rN 9 s
rN Tc C sN t | d�� }|�� }W d � n1 sw Y |s |s J �|r%t| � |S )z8Wait for a file to be written on disk with some content.�rbN)r@ �readrG )�fnamer r rC �datarv rv rw rO H s
�rO c C s | � }|sJ �|S )z1Keep calling function until it evaluates to True.rv )r �retrv rv rw rM Y s rM c C sp dd� }z)t �| �}t�|j�rt�tj| �}nt�t j| �}t r'|� W dS ||� W dS t
y7 Y dS w )z?Convenience function for removing temporary test files or dirs.c
S s� t � � t }t � � |k r?z| � W S ty Y n ty3 } z|}td|� �� W Y d }~nd }~ww t �d� t � � |k s |�)Nz ignoring g{�G�z�?)r r �FileNotFoundErrorr\ rZ r )r r~ r> r� rv rv rw � retry_funn s ��
� z safe_rmpath.<locals>.retry_funN) r� �stat�S_ISDIR�st_moder �partialr� �rmtree�remover
r� )r� r� �str rv rv rw rG k s
�rG c C s& zt �| � W dS ty Y dS w )z.Convenience function for creating a directory.N)r� �mkdir�FileExistsErrorr rv rv rw �
safe_mkdir� s
�r� c c s8 � t �� }zt �| � dV W t �|� dS t �|� w )z@Context manager which temporarily changes the current directory.N)r� r rF )�dirname�curdirrv rv rw rF � s �
rF c C sR t j�| �r
J | ��t�t| � t�t| � t r't �
| �}t � | |j t
j
B � | S )z6Create a Python executable file in the given location.)r� r� r� r� r� rG r� �copyfiler r
r� �chmodr� �S_IEXEC)r� r� rv rv rw rH � s
rH c C s� t j�| �r
J | ��t�d�st�d�S |du r t�d�}n t |t
�s'J |��t � t
| � ttdd�d��
}|�|� W d � n1 sEw Y zt�d|jd| g� W t
|j� | S t
|j� w ) z5Create a compiled C executable in the given location.Zgcczgcc is not installedNz�
#include <unistd.h>
int main() {
pause();
return 1;
}
z.c��suffixr? z-o)r� r� r� r� r� r� r� r& r' rH r� r� r� rG r@ rJ rA rp r� r� )r� Zc_coderC rv rv rw rI � s
�
�rI r� c C s< t jt| |d�}tj�|�s tj�|�}t�t |� |S q)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.
T)�prefixr� r )
�tempfile�mktempr r� r� r� r� r� r� rG )r� r r� r� rv rv rw rJ � s �rJ c @ sj e Zd ZdZdd� Zddd�Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� ZdS )rA z�Test class providing auto-cleanup wrappers on top of process
test utilities. All test classes should derive from this one, even
if we use pytest.
c C s. | j j}|�d�s
d| }d�|| j j| j�S )Nzpsutil.z
psutil.tests.z{}.{}.{})r� r� r� r� r� Z_testMethodName)r� Zfqmodrv rv rw �__str__� s
�zPsutilTestCase.__str__r� Nc C s t ||d�}| �t|� |S )N)r� r )rJ �
addCleanuprG )r� r� r r� rv rv rw rJ � s zPsutilTestCase.get_testfnc O s t |i |��}| �t|� |S r� )r8 r� r6 )r� r� r# r% rv rv rw r8 � s z PsutilTestCase.spawn_subprocc O s> | j |i |��}zt�|j�W S tjy | �|j� � w r� )r8 r� r� r! rQ �assert_pid_gone)r� r� r r% rv rv rw � spawn_psproc� s �zPsutilTestCase.spawn_psprocc C �* t � \}}| �t|� | �t|� ||fS r� )r: r� r6 )r� Zchild1Zchild2rv rv rw r: � �
z"PsutilTestCase.spawn_children_pairc C r� r� )r9 r� r6 )r� r< r2 rv rv rw r9 r� zPsutilTestCase.spawn_zombiec O s. t |i |��\}}| �t|� | �t|� |S r� )r5 r� rG r6 )r� r� r# r% rB rv rv rw r5 s zPsutilTestCase.pyrunc C s� t |tj�sJ �|j|jksJ �|j|jksJ �|jr |js J �t |tj�r:|j|jks.J �|jd ur:|jdks:J �t |� t
|� d S �Nr ) rH r� �Errorr! r� �_name�
ZombieProcess�ppidZ_ppidr� �repr)r� rS r� rv rv rw �_check_proc_exc s
z PsutilTestCase._check_proc_excc
C s� zt �|�}W n, t jy td�� t jy3 } z|j|ks"J �|jd u s)J �W Y d }~n
d }~ww td|� d���t �|�rEJ |��|t �� vsMJ �|dd� t � � D �vsZJ �d S )Nz&wasn't supposed to raise ZombieProcessz did not raise NoSuchProcess (�)c S � g | ]}|j �qS rv r� r� rv rv rw r� ) � z2PsutilTestCase.assert_pid_gone.<locals>.<listcomp>)
r� r� r� r� rQ r! r� rd r� � process_iter)r� r! rS r� rv rv rw r� s �� z PsutilTestCase.assert_pid_gonec C s� | � |j� t|�}|j|jdd�D ]P\}}| jt|�|d��; z|� }W n! tjy. � tj yF } z | �
||� W Y d }~nd }~ww d|� d|��}t |��W d � n1 s]w Y q|j dd� d S )NT�� clear_cache�rS r� zProcess.z!() didn't raise NSP and returned r rD )
r� r! rB �iter�all�subTestr� r� r� rQ r� r� r )r� rS �nsr r� r� r� r� rv rv rw �assert_proc_gone+ s*
����� ��
z PsutilTestCase.assert_proc_gonec C s, dd� }t �|j�}||ksJ �ts ts ts t|�t|�ks J �|�� t jks)J �|� � s/J �t �
|j�s7J �|� � ||� t |�}|j
|jdd�D ]?\}}| jt|�|d��* z|� W n t jt jfyz } z | �||� W Y d }~nd }~ww W d � n1 s�w Y qKtr�t�t j�� }|�� W d � n1 s�w Y | �||j� t�t j�� }|�� W d � n1 s�w Y | �||j� t�t j�� }|�� W d � n1 s�w Y | �||j� |�� |� � |� � |� � |� � �sJ �t �
|j��sJ �||� d S )Nc S s\ t rd S | jt�� v s
J �| jdd� t�� D �v sJ �i t_| jdd� t�� D �v s,J �d S )Nc S r� rv r� r� rv rv rw r� D r� zMPsutilTestCase.assert_proc_zombie.<locals>.assert_in_pids.<locals>.<listcomp>c S r� rv r� r� rv rv rw r� F r� )r r! r� r� r� Z_pmaprb rv rv rw �assert_in_pids? s z9PsutilTestCase.assert_proc_zombie.<locals>.assert_in_pidsTr� r� ) r� r� r! r r r �hashr/ r0 �
is_runningrd �as_dictrB r� r� r� r� r� � AccessDeniedr� r r� r� �cmdliner� r� r� �suspend�resumer6 �kill) r� rS r� �cloner� r r� r� �cmrv rv rw �assert_proc_zombie> sT
��� ��
�
�
� z!PsutilTestCase.assert_proc_zombie�r� N)r� r� r� r� r� rJ r8 r� r: r9 r5 r� r� r� r� rv rv rv rw rA � s
rA zunreliable on PYPYr� �serial)r� c @ s� e Zd ZdZdZdZdZerdndZdZ e
� � Z e
e�d��Zedd � �Zed
d � �Zd d
� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Z d dd �Zd d � Z dS ) r@ 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)
�� rc r r{ TZ PSUTIL_DEBUGc C s t �d� d S )NF)r� �
_set_debug��clsrv rv rw �
setUpClass� � zTestMemoryLeak.setUpClassc C s t �| j� d S r� )r� r� �_psutil_debug_origr� rv rv rw �
tearDownClass� s z TestMemoryLeak.tearDownClassc C s | j �� }t|d|j�S )NZuss)� _thisproc�memory_full_infor� Zrss)r� �memrv rv rw �_get_mem� s
zTestMemoryLeak._get_memc C s t r| j�� S | j�� S r� )r
r� �num_fds� num_handlesr� rv rv rw � _get_num_fds� s
zTestMemoryLeak._get_num_fdsc C s | j r
t|dtjd� d S d S )N�yellow)�color�file)�verboser rr r� )r� r� rv rv rw �_log� s �zTestMemoryLeak._logc C s� | � � }| �|� | � � }|| }|dk r d|�d�}t�|�S |dkrAtr(dnd}|dkr2|d7 }|� d|� d |��}t�|�S 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 znegative diff z8 (gc probably collected a resource from a previous test)�fd�handler� r+ z
unclosed z after calling N)r� �callr� r� r
)r� r �before�after�diffr� �type_rv rv rw �
_check_fds� s
�
�zTestMemoryLeak._check_fdsc C s^ t jdd� | �� }t|�D ] }| �|�}~~qt jdd� | �� }t jg ks)J �|| }|S )z�Get 2 distinct memory samples, before and after having
called fun repeatedly, and return the memory difference.
r� )Z
generation)�gcZcollectr� r} r� �garbage)r� r �timesZmem1r� r� Zmem2r� rv rv rw � _call_ntimes� s
zTestMemoryLeak._call_ntimesc C s� g }d}|}t d|d �D ]C}| �||�} d�|t| �t| | �|�}
|�|
� | |kp/| |k} | r>|dkr;| �|
� d S |dkrEt� | �|
� ||7 }| }q
t�d� |��S )Nr r� z,Run #{}: extra-mem={}, per-call={}, calls={}z. )
r} r� r� r
�appendr� �printr� r� r ) r� r r� rz � tolerance�messagesZprev_memZincrease�idxr� r� �successrv rv rw �
_check_mem� s.
�
zTestMemoryLeak._check_memc C s |� S r� rv )r� r rv rv rw r� s zTestMemoryLeak.callNc
C s� |dur|n| j }|dur|n| j}|dur|n| j}|dur!|n| j}z"|dks-J d��|dks5J d��|dks=J d��|dksEJ d��W n tyX } ztt|���d}~ww | �||� | �|� | j ||||d� dS ) zTest a callable.Nr� ztimes must be >= 1r zwarmup_times must be >= 0zretries must be >= 0ztolerance must be >= 0)r� rz r� )
r� � warmup_timesrz r� r� r� r� r� r� r� )r� r r� r� rz r� r� rv rv rw �execute s" � ��
zTestMemoryLeak.executec s$ � �fdd�}| j |fi |�� dS )znConvenience method to test a callable while making sure it
raises an exception on every call.
c s4 z�� W n
� y Y d S w t ��� d� � ��S )Nz did not raise )r� r� rv �r� r rv rw r� & s
�z*TestMemoryLeak.execute_w_exc.<locals>.callN)r� )r� r� r r r� rv r� rw �
execute_w_exc! s z TestMemoryLeak.execute_w_exc)NNNN) r� r� r� r� r� r� r� r rz r� r� r� r� �boolr� �getenvr� � classmethodr� r� r� r� r� r� r� r� r� r� r� rv rv rv rw r@ � s.
� r@ c C s2 t dd� �}z|� | dkW S ty Y dS w )Nc S sX i } t d�}|�� dd � D ]}dd� |�d�D �}|d t|d �}}|| |< q| S )Nztasklist.exe /NH /FO csvr� c S s g | ]}|� d d��qS )r� r� )�replacer� rv rv rw r� 8 s z@is_win_secure_system_proc.<locals>.get_procs.<locals>.<listcomp>�,r )rP �
splitlinesro rn )r� �out�line�bitsr� r! rv rv rw � get_procs3 s
z,is_win_secure_system_proc.<locals>.get_procsz
Secure SystemF)r �KeyError)r! r� rv rv rw rD 1 s
�rD c C s6 t �� } t| d�r
| �� S t| d�rt�| �� �S dS )Nr� r� r )r� r� �hasattrr� �random�choicer� )rO rv rv rw �_get_eligible_cpuC s
r� c @ s0 e Zd ZdZddi fddi fgZddi fddddifd di fd
di fd di fd di fd
di fddi fddi fg Zddi fddi fddi fddi fddi fddi fddi fddi fddddifd di fd di fd di fd di fd di fd!di fd"di fd#di fgZer�ed$di fg7 Zed%di fg7 Zed&di fg7 Zed'di fg7 Zer�ed(di fg7 Ze r�ed)di fg7 Ze
r�ed*e j fi fg7 Ze
r�ed+di fg7 Zer�ed,di fg7 Zer�ed-di fg7 Zer�ed.di fg7 Zer�ed/dd0d1ifg7 Zg Ze�red di fg7 Zn
ed e jfi fg7 Ze
�r ed*e j d2fi fg7 Ze �r8e�r.ed)e jd3fi fg7 Zn
ed)e jfi fg7 Ze
�rFed+e� gfi fg7 Zd4ejfi fd5di fd6di fd7di fd8di fgZe�rued4ejfi fg7 Zed4ej fi fg7 Zee e e Z d9d:� Z dDd;d<�Z d=d>� Z e!d?d@� �Z"e!dAdB� �Z#dCS )ErB 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_percentrv Zmemory_percentr� ri rh T� connectionsr� Zoneshotr< �parentsr! r �r r� � cpu_timesZ create_timer r� r� Z memory_infor� �net_connections�kindr� �niceZnum_ctx_switchesZ num_threadsZ
open_filesr� r/ r� �usernameZuids�gidsZterminalr� r� r� r� r� r� r� r� r� �groupedF)r. i r rV r� r� r6 r� c C s
|| _ d S r� )�_proc)r� rS rv rv rw r� � �
zprocess_namespace.__init__c c sb � t |�}t�|� |D ]"\}}}|r| �� t| j|�}tj|g|�R i |��}||fV q dS �z_Given a list of tuples yields a set of (fun, fun_name) tuples
in random order.
N)�listr� �shuffler� r� r r r� )r� �lsr� �fun_namer� r# r rv rv rw r� � s �
�zprocess_namespace.iterc C s | j j| j jdd� dS )z&Clear the cache of a Process instance.T)Z _ignore_nspN)r �_initr! r� rv rv rw r� � s z process_namespace.clear_cachec C sB |D ] \}}}d| }t ||�s |jj�d|�d�}t|��qdS )z}Given a TestCase instance and a list of tuples checks that
the class defines the required test method names.
Ztest_z class should define a z methodN)r� r� r� �AttributeError)r� Z
test_classr r r> � meth_namer� rv rv rw �test_class_coverage� s
����z%process_namespace.test_class_coveragec C sV dd� | j D �}dd� | jD �}dd� ttj�D �}||B |A }|r)td|����d S )Nc S � h | ]}|d �qS r rv r� rv rv rw � <setcomp>� � z)process_namespace.test.<locals>.<setcomp>c S r r rv r� rv rv rw r � r c S s h | ]
}|d dkr|�qS )r r> rv r� rv rv rw r � s z uncovered Process class names: )r� �ignoredr r� r� r� )r� �thisr �klassZleftoutrv rv rw �test� s �zprocess_namespace.testN)T)$r� r� r� r� �utilsr �gettersr
r& r' r* r� Z
RLIMIT_NOFILEr# r) r% r r( ZsettersZNORMAL_PRIORITY_CLASSr ZIOPRIO_CLASS_NONEZ
IOPRIO_NORMALr� rT �SIGTERMZkillersZ CTRL_C_EVENTZCTRL_BREAK_EVENTr� r� r� r� r� r r rv rv rv rw rB L s� �
� �
rB c @ s� e Zd ZdZddi fddddifddddifddi fd dd
difd dd
difd dd difd
dddifde�� fi fddddifddi fddi fddddifde�� fi fddi fddi fddi fddi fgZerwe rme
rmn
eddd
difg7 Ze r�ed di fg7 Ze r�ed di fg7 Ze
r�ed di fg7 Zer�ed di fg7 Zer�ed di fg7 Zed!d"i fg7 Zd#di fd$e�� gfi fd%di fd&di fgZeZed'd(� �ZejZd)S )*rC 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()
Z boot_timerv � cpu_countZlogicalFTZ cpu_statsr ZpercpuZdisk_io_countersZperdiskZdisk_partitionsr� �
disk_usager r Z net_if_addrsZ net_if_statsr� Zpernicrd r� Z swap_memoryZusersZvirtual_memoryr� r� r� r� r� Zwin_service_iterZwin_service_get)�algr� rk r Zcpu_times_percentc c sT � t | �} t�| � | D ]\}}}tt|�}tj|g|�R i |��}||fV q dS r
)r r� r r� r� r r� )r r r� r# r rv rv rw r� s �
�zsystem_namespace.iterN)r� r� r� r� r� r �getpidr r$ r r3 �HAS_GETLOADAVGr. r- r+ r r� r� r r� r� r� rB r rv rv rv rw rC � sZ ��
rC c C s dd� }t ttjjfd| |d�S )zZDecorator which runs a test function and retries N times before
actually failing.
c S s t | �d�tjd� d S )Nz
, retrying)r� )r� rr r� )r� rv rv rw r| s z retry_on_failure.<locals>.logfunN)ry rE rz r| )rx r� r� r� r )rz r| rv rv rw r? s
�r? c � � fdd�}|S )z,Decorator to Ignore AccessDenied exceptions.c � t �� �� �fdd��}|S )Nc s> z� | i |��W S t jy �d ur�s� t�d� Y S w )Nzraises AccessDenied)r� r� r� r� r
�r �only_ifrv rw r
/ s �z9skip_on_access_denied.<locals>.decorator.<locals>.wrapperr r �r( r rw r� . s z(skip_on_access_denied.<locals>.decoratorrv �r( r� rv r) rw r= + s
r= c r% )z3Decorator to Ignore NotImplementedError exceptions.c r& )Nc sH z� | i |��W S t y# �d ur�s� � j�d�}t�|� Y S w )Nz2 was skipped because it raised NotImplementedError)rm r� r� r� )r� r r� r' rv rw r
B s
��z;skip_on_not_implemented.<locals>.decorator.<locals>.wrapperr r r) r rw r� A s
z*skip_on_not_implemented.<locals>.decoratorrv r* rv r) rw r> > s r> � 127.0.0.1c C sF t � � �}|�| df� |�� d W d � S 1 s w Y dS )z6Return an unused TCP port. Subject to race conditions.r r� N)�socket�bind� getsockname)�hostr; rv rv rw rR [ s
$�rR c C s~ |du r | t thv r d}t�| |�}z tjdvr!|�tjtjd� |�|� |tj kr0|�
d� |W S t y> |� � � w )zBinds a generic socket.N�r� r > �cygwin�ntr� r{ )
r r r, r� r� �
setsockopt�
SOL_SOCKET� SO_REUSEADDRr- r �listenr r9 )�family�type�addrr; rv rv rw rS b s
�rS c C sp t jsJ �tj�| �rJ | ��t�tj|�}z|�| � |tjkr)|� d� W |S W |S t
y7 |� � � w )zBind a UNIX socket.r{ ) r� r
r� r� r� r, r� r- r r6 r r9 )r� r8 r; rv rv rw rT s s
� ��rT r0 c C s� t � | t��G}|�|� |�d� |�� }t � | t�}z%|�|� |�� } |�� \}}||kr<||fW W d � S |�� q& tyL |�� � w 1 sPw Y dS )z^Build a pair of TCP sockets connected to each other.
Return a (server, client) tuple.
r{ TN) r, r r- r6 r. �connectr5 r9 r\ )r7 r9 Zllrq Zcaddr�arv rv rw rU � s(
�
� ��rU c C s� t jsJ �d }}z#t| tjd�}|�d� t�tjtj�}|�d� |�| � W ||fS tyD |dur;|� � |durC|� � � w )z�Build a pair of UNIX sockets connected to each other through
the same UNIX file name.
Return a (server, client) tuple.
N�r8 r )
r� r
rT r, r � setblockingr� r: r r9 )r� �server�clientrv rv rw rV � s
��rV c c s � g } d }}zg| � ttjtj�ttjtj�f� t� r-| � ttjtj�ttjtj�f� trQt rQt
� }t
� }t |�\}}t |tjd�}|||fD ]}| �
|� qI| V W | D ]}|�� qW||fD ]
}|durlt|� qbdS | D ]}|�� qq||fD ]
}|dur�t|� q|w )z1Open as many socket families / types as possible.Nr< )�extendrS r, r r �
SOCK_DGRAMr r r
r/ rJ rV rT r� r9 rG )�socksZfname1Zfname2�s1�s2Zs3r+ r� rv rv rw rW � sF � � �
���
��rW c C s� t |tj�s
J |��|tjkrAdd� | �d�D �}t|�dks#J | ��|D ]}d| kr4dks9J | �� J | ��q%t�| � dS |tj krVt | t
�sOJ | ��t� | � dS |t j
krit�d| �dusgJ | ��dS td |����)
z[Check a net address validity. Supported families are IPv4,
IPv6 and MAC addresses.
c S s g | ]}t |��qS rv )rn r� rv rv rw r� � r z%check_net_address.<locals>.<listcomp>ra r} r � z([a-fA-F0-9]{2}[:|\-]?){6}Nzunknown family )rH �enum�IntEnumr, r ro rp � ipaddress� IPv4Addressr r� � IPv6Addressr� ZAF_LINKr� r� r� )r9 r7 Zocts�numrv rv rw rP � s
&
rP c C sT dd� }dd� }dd� }dd� }d d
� }|| � || � || � || � || � d S ) z*Check validity of a connection namedtuple.c S s� t | �dk}t | �dv sJ t | ���| d | jks J | j��| d | jks*J | j��| d | jks6J | j��| d | jksBJ | j��| d | jksNJ | j��| d | jksZJ | j��|rh| d | jksjJ | j��d S d S )
Nr� > rZ r� r r� rb r| r} r{ rZ )rp r� r7 r8 �laddr�raddrr/ r! )r= Zhas_pidrv rv rw � check_ntuple� s �z-check_connection_ntuple.<locals>.check_ntuplec S s� | j ttthv s
J | j ��t| j tj�sJ | ��| j tkrft�| j | j��7}z |� | j
d df� W n t yK } z
|j t j
krA� W Y d }~n
d }~ww W d � d S W d � d S 1 s_w Y d S | j tkrv| jtjksxJ | j��d S d S r� )r7 r r r� rH rF rG r, r8 r- rL r\ �errnoZ
EADDRNOTAVAILr/ r� � CONN_NONE)r= r+ r� rv rv rw � check_family� s(
�����"�
�z-check_connection_ntuple.<locals>.check_familyc S sl t tdt� �}| jtjtj|hv sJ | j��t| jtj�s!J | ��| jtjkr2| j t
j ks4J | j ��d S d S )N�SOCK_SEQPACKET) r� r, �objectr8 r rA rH rF rG r/ r� rP )r= rR rv rv rw �
check_type s �� �z+check_connection_ntuple.<locals>.check_typec S s� | j | jfD ]M}| jtthv rCt|t�sJ t|���|s qt|jt �s*J t|j���d|j kr5dks;n J |j��t
|j | j� q| jt krSt|t
�sSJ t|���qd S )Nr i�� )rL rM r7 r r rH rl r8 �portrn rP �ipr� r� )r= r9 rv rv rw � check_addrs s "
��z,check_connection_ntuple.<locals>.check_addrsc S s� t | jt�s J | j��dd� tt�D �}| j|v s J | j��| jtthv r7| jt kr7| jtj
ks5J | j��d S | jtj
ksBJ | j��d S )Nc S r� )ZCONN_r� r� rv rv rw r� r� zAcheck_connection_ntuple.<locals>.check_status.<locals>.<listcomp>) rH r/ r� r r� r7 r r r8 r rP )r= Zvalidsrv rv rw � check_status s �z-check_connection_ntuple.<locals>.check_statusNrv )r= rN rQ rT rW rX rv rv rw �check_connection_ntuple� s
rY c C sJ g }| D ] }t r |jtjkr tr d|jv r td|� �� q|�|� q|S )ztOur process may start with some open UNIX sockets which are not
initialized by us, invalidating unit tests.
z/syslogz skipping )r
r7 r, r� r rM r r� )Zcons�newr= rv rv rw rQ . s rQ c C �
t �| �S r� )� importlib�reload)�modulerv rv rw rX A r rX c C sB t j�t j�| ��d }tj�|| �}tj�|�}|j� |� |S r� )
r� r� �splitextr( r\ �util�spec_from_file_location�module_from_spec�loader� exec_module)r� r� �spec�modrv rv rw rY E s
rY c C s t j| tdd� dS )zRaise a warning msg.rb r� Nr� )r� rv rv rw rZ R s rZ c C sV t | �}|j}t|�dks|d turdS t|dd�}t|t�s"dS tdd� |D ��S )z-Check if object is an instance of namedtuple.r� r F�_fieldsNc s s � | ]}t |t�V qd S r� )rH r� )r� �nrv rv rw � <genexpr>` s � z is_namedtuple.<locals>.<genexpr>)r8 � __bases__rp rl r� rH r� )r� �t�brC rv rv rw r\ W s
r\ c # s| � t rdnd� d�t| � d�}� �fdd�t�� �� D �}t�|�}t�||� zt �
|� |V W t |� dS t |� w )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.
�pypy�pythonz.sor� c s6 g | ]}t j�|j�d �kr� |j�� v r|j�qS )r� )r� r� r_ �lowerr� �r� �extrv rw r� n s
$��'copyload_shared_lib.<locals>.<listcomp>N) r rJ r� r� r� r� r� r� r� �ctypes�CDLLrG )r� �dst�libsr: rv rp rw r[ e s �
�
r[ c # s � ddl m} ddl m} d� t| � d�}� fdd�t�� �� D �}tr2|s2dd� t�� �� D �}t� |�}t
� ||� d }z)t � |�}|V W |d urct j
jj}|jg|_||j�}|dkrc|� �t|� d S |d ur�t j
jj}|jg|_||j�}|dkr�|� �t|� w )
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.dllr� c sF g | ] }|j �� �� �r!d tj �|j ��� v r!d|j �� vr|j �qS )rn Zwow64)r� ro rM r� r( r� �rq rv rw r� � s ��rr c S s( g | ]}d t j�|j��� v r|j�qS )rm )r� r� r( ro r� rv rv rw r� � s
�N)rs rw rx rJ r� r� r� r r� r� r� r� ZWinDLLZwindllZkernel32� FreeLibraryZHMODULE�argtypesZ_handlerG ) r� rw rx ru rv r: �cfilerz r� rv ry rw r[ } s@ �
�
�
�
c C s t dd� d S )NTrg )r7 rv rv rv rw �cleanup_test_procs� r� r} c C r[ r� )rr �exit)rX r> rv rv rw r3 � s
r3 r� )F)TFr� )r+ )r0 r� )�r� r� r� rs rF rO r r� r\ rH r� rj r� r� r6 rI r� rT r, r� rp rr r� r& r� r � tracebackr< r� r r r r� � ImportErrorr� r r r r r r
r r Zpsutil._commonr
r r r r Zpsutil._psposixr �__all__�builtin_module_namesr r� r] r r2 r4 �maxsizer" �machinero r3 ZRISCV64rx r0 r1 r r r! r r# r r �decoder �getfilesystemencodingZASCII_FS�getr� r� r r� �__file__r r r� r� r� r# r% r$ r' r( r/ ZHAS_NET_IO_COUNTERSr) r& r* r+ r- r. Z HAS_THREADS�getuidZ SKIP_SYSCONSr� r� r, r r� r� r� �
format_excr� r$ r� r r r@ �devnullr r9 r r r� rS r� r r r) rE r� r� �modulesr� r r; r r8 r: r9 r5 rP r r6 r7 rL rK rx rQ rN r� rO rM rG r� r� rF rH rI rJ r� rA r� r� r� r@ rD r� rB rC r? r= r> rR rS rT rU rV rW rP rY rQ rX rY rZ r\ r[ r} rv rv rv rw �<module> s� �
-
�
� �
, �Y
0 )
&)
T%
9�
�
�
"
. +
F
K
3
�