HEX
Server: Apache/2.4.52 (Ubuntu)
System: Linux spn-python 5.15.0-89-generic #99-Ubuntu SMP Mon Oct 30 20:42:41 UTC 2023 x86_64
User: arjun (1000)
PHP: 8.1.2-1ubuntu2.20
Disabled: NONE
Upload Files
File: //home/arjun/projects/env/lib/python3.10/site-packages/billiard/__pycache__/pool.cpython-310.pyc
o

!we��@sddlZddlZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZddlm
Z
ddlmZmZddlmZddlmZmZmZmZmZddlmZmZmZdd	lmZdd
lmZddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'ddlm(Z(dd
l)m*Z*m+Z+ddlm,Z,m-Z-m.Z.dZ/ej0ddkZ1e�2�dkr�ddl3m4Z5eZ6n	ddlm7Z5ej6Z6zej8Z8Wne9y�dZ8Ynwej0dkr�ej:Z;nej;Z;dZ<dZ=dZ>dZ?dZ@dZAdZBdZCdZDdZEdZFeGedd�ZHdZIeGedd�ZDdZJdZKe�L�ZMejNZNdd�ZOd d!�ZPd"d#�ZQd$d%�ZRdHd&d'�ZSGd(d)�d)e;�ZTGd*d+�d+eU�ZVGd,d-�d-eU�ZWd.d/�ZXGd0d1�d1�ZYGd2d3�d3e�ZZGd4d5�d5eZ�Z[Gd6d7�d7eZ�Z\Gd8d9�d9eZ�Z]Gd:d;�d;eZ�Z^Gd<d=�d=�Z_Gd>d?�d?�Z`Gd@dA�dAe`�ZaGdBdC�dC�ZbGdDdE�dEeb�ZcGdFdG�dGe_�ZddS)I�N)�deque)�partial�)�	cpu_count�get_context)�util)�TERM_SIGNAL�human_status�pickle_loads�
reset_signals�
restart_state)�	get_errno�mem_rss�send_offset)�
ExceptionInfo)�DummyProcess)�CoroStop�RestartFreqExceeded�SoftTimeLimitExceeded�
Terminated�TimeLimitExceeded�TimeoutError�WorkerLostError��	monotonic��Queue�Empty)�Finalize�debug�warningzEchild process exiting after exceeding memory limit ({0}KiB / {1}KiB)
��Windows)�kill_processtree)�killg _�B)r!r!����SIGUSR1g$@�EX_OKi,皙�����?cCs<z|j}Wntyd}Ynw|durtt|���S|S�N)r�AttributeErrorr�fileno)�
connection�native�r0�F/home/arjun/projects/env/lib/python3.10/site-packages/billiard/pool.py�_get_send_offsetxs
�r2cCstt|��Sr+)�list�map��argsr0r0r1�mapstar��r7cCstt�|d|d��S)Nrr)r3�	itertools�starmapr5r0r0r1�starmapstar�sr;cOs t��j|g|�Ri|��dSr+)r�
get_logger�error)�msgr6�kwargsr0r0r1r=�s r=cCs|t��ur
|�|�dSdSr+)�	threading�current_thread�stop)�thread�timeoutr0r0r1�stop_if_not_current�s�rEc@sdeZdZdZdd�Zerddd�Zdd	�Zd
d�Zdd
�Z	dSddd�Zdd	�Zdd�Zdd
�Z	dS)�LaxBoundedSemaphorez^Semaphore that checks that # release is <= # acquires,
    but ignores if # releases >= value.cCs|jd8_|��dS�Nr)�_initial_value�acquire��selfr0r0r1�shrink�szLaxBoundedSemaphore.shrinkrNcCst�||�||_dSr+��
_Semaphore�__init__rH�rK�value�verboser0r0r1rO�s
zLaxBoundedSemaphore.__init__cCsR|j�|jd7_|jd7_|j��Wd�dS1s"wYdSrG)�_condrH�_value�notifyrJr0r0r1�grow�s
"�zLaxBoundedSemaphore.growcC�b|j}|�"|j|jkr|jd7_|��Wd�dSWd�dS1s*wYdSrG)rSrTrH�
notify_all�rK�condr0r0r1�release��
�"�zLaxBoundedSemaphore.releasecC�*|j|jkrt�|�|j|jksdSdSr+)rTrHrNr[rJr0r0r1�clear��
�zLaxBoundedSemaphore.clearcCst�|||�||_dSr+rMrPr0r0r1rO�s
cCsT|j}|�|jd7_|jd7_|��Wd�dS1s#wYdSrG)�_Semaphore__condrH�_Semaphore__valuerUrYr0r0r1rV�s
"�cCrWrG)r`rarH�	notifyAllrYr0r0r1r[�r\cCr]r+)rarHrNr[rJr0r0r1r^�r_�rN)
�__name__�
__module__�__qualname__�__doc__rL�PY3rOrVr[r^r0r0r0r1rF�s

rFcs0eZdZdZ�fdd�Zdd�Zdd�Z�ZS)�MaybeEncodingErrorzVWraps possible unpickleable errors, so they can be
    safely sent through the socket.cs*t|�|_t|�|_t��|j|j�dSr+)�repr�excrQ�superrO)rKrkrQ��	__class__r0r1rO�s

zMaybeEncodingError.__init__cCsd|jjt|�fS)Nz<%s: %s>)rnrd�strrJr0r0r1�__repr__��zMaybeEncodingError.__repr__cCsd|j|jfS)Nz)Error sending result: '%r'. Reason: '%r'.)rQrkrJr0r0r1�__str__�s�zMaybeEncodingError.__str__)rdrerfrgrOrprr�
__classcell__r0r0rmr1ri�s
ric@seZdZdZdS)�
WorkersJoinedzAll workers have terminated.N)rdrerfrgr0r0r0r1rt�srtcCst��r+)r)�signum�framer0r0r1�soft_timeout_sighandler��rwc@s�eZdZ				ddd�Zdd�Zdd	�Zd
d�Zddd
�Zdd�Zdd�Z	e
edfdd�Zdd�Z
dd�Zdd�Zefdd�Zdd�ZdS) �WorkerNr0Tc

Csz|dust|�tkr|dksJ�||_||_||_||_||_||_|	|_||||_	|_
|_|
|_||_
|�|�dS�Nr)�type�int�initializer�initargs�maxtasks�max_memory_per_child�	_shutdown�on_exit�
sigprotection�inq�outq�synq�wrap_exception�on_ready_counter�contribute_to_object)
rKr�r�r�r}r~r�sentinelr�r�r�r�r�r0r0r1rO�s zWorker.__init__cCs�|j|j|j|_|_|_|jj��|_|jj��|_|jr5|jj��|_|jj��|_	t
|jj�|_n	d|_|_	|_|jjj
|_|jjj|_t
|jj�|_|Sr+)r�r�r��_writerr-�inqW_fd�_reader�outqR_fd�synqR_fd�synqW_fdr2�send_syn_offset�_send_syn_offset�send�
_quick_put�recv�
_quick_get�send_job_offset)rK�objr0r0r1r��szWorker.contribute_to_objectcCs6|j|j|j|j|j|j|j|j|j|j	|j
|jffSr+)rnr�r�r�r}r~rr�r�r�r�r�rJr0r0r1�
__reduce__
s
�zWorker.__reduce__cs�tj�dg�d��fdd�	}|t_t��}|��|��|j|d�zGzt�|j|d��Wn#tyR}zt	d||dd�|�
|�d|�WYd}~nd}~wwW|�
|�dd�dSW|�
|�dd�dS|�
|�dd�w)	Ncs|�d<�|�Srzr0)�status��_exit�	_exitcoder0r1�exitszWorker.__call__.<locals>.exit��pidzPool process %r error: %rr��exc_inforr+)�sysr��os�getpid�_make_child_methods�
after_fork�
on_loop_start�workloop�	Exceptionr=�_do_exit)rKr�r�rkr0r�r1�__call__s&����*zWorker.__call__c	Cs~|dur
|rtnt}|jdur|�||�tjdkr8z|j�t||ff�t�	d�Wt
�|�dSt
�|�wt
�|�dS)N�win32r)�
EX_FAILUREr)r�r��platformr��put�DEATH�time�sleepr�r�)rKr��exitcoderkr0r0r1r�*s

zWorker._do_exitcC�dSr+r0�rKr�r0r0r1r�:�zWorker.on_loop_startcCs|Sr+r0)rK�resultr0r0r1�prepare_result=r�zWorker.prepare_resultc
s@|pt��}�jj}�j}�j}�j}�jpd}�j}	�j	}
�j
���fdd�}d}z�|dus5|r�||kr�|
�}
|
r�|
\}}|tksDJ�|\}}}}}|t|||�||ff��r`||�}|s`q+z
d|	||i|���f}Wnt
y{dt�f}Ynwz|t||||ff�Wn9t
y�}z-t��\}}}zt||d�}tt||f�}|t||d|f|ff�W~n~wWYd}~nd}~ww|d7}|dkr�t�}|dkr�td�|dkr�||kr�tt�||��tW�j|d�S|dus5|r�||ks5|d	|�|�r||k�rtntW�j|d�StW�j|d�S�j|d�w)
Nrcs^d}	|dkrtd|�jj��dd���}|r*|\}}|tkr"dS|tks(J�dS|d7}q)Nrr�<z(!!!WAIT FOR ACK TIMEOUT: job:%r fd:%r!!!r�FT)r=r�r�r-�NACK�ACK)�jid�i�req�type_r6��
_wait_for_synrKr0r1�wait_for_synLs��z%Worker.workloop.<locals>.wait_for_synTFrz'worker unable to determine memory usage)�	completedzworker exiting after %d tasks)r�r�r�r�r�r�rr�r��wait_for_jobr��TASKr�r�r�READYr�r�rirr=r �MAXMEM_USED_FMT�format�
EX_RECYCLE�_ensure_messages_consumedr�r))rKr�nowr�r�r�r�rr�r�r�r�r�r�r��args_�jobr��funr6r?�confirmr�rk�_�tb�wrapped�einfo�used_kbr0r�r1r�@sv
����
��
%�zWorker.workloopcCsJ|jsdStt�D]}|jj|krtd|�dSt�t�q	td�dS)zr Returns true if all messages sent out have been received and
        consumed within a reasonable amount of time Fz*ensured messages consumed after %d retriesTz<could not ensure all messages were consumed prior to exiting)	r��range�)GUARANTEE_MESSAGE_CONSUMPTION_RETRY_LIMITrQrr�r��,GUARANTEE_MESSAGE_CONSUMPTION_RETRY_INTERVALr )rKr��retryr0r0r1r��s
z Worker._ensure_messages_consumedcCs�t|jd�r|jj��t|jd�r|jj��|jdur#|j|j�t|j	d�t
dur3t�t
t�zt�tj
tj�WdStyHYdSw)Nr�r�)�full)�hasattrr�r��closer�r�r}r~rr��SIG_SOFT_TIMEOUT�signalrw�SIGINT�SIG_IGNr,rJr0r0r1r��s
�zWorker.after_forkcsd|j�t|d�r*|jj�t|d�r!|jr!|j�tf�fdd�	}|S��fdd�}|S�fdd�}|S)Nr��get_payloadcsd|���fS�NTr0)rD�loads)r�r0r1�_recv��z'Worker._make_recv_method.<locals>._recvcs�|�r	d��fSdS�NT�FNr0�rD)�_poll�getr0r1r��s
cs(zd�|d�fWStjyYdSw�NTr�r�rr�)r�r0r1r��s
�)r�r�r��pollr�r
)rK�connr�r0)r�r�r�r1�_make_recv_method�s

�
�zWorker._make_recv_methodcCs0|�|j�|_|jr|�|j�|_dSd|_dSr+)�_make_protected_receiver�r�r�r�)rKr�r0r0r1r��s
��zWorker._make_child_methodscs2|�|��|jr|jjnd�tf��fdd�	}|S)Nc
s��r
��r
|d�tt��z
�d�\}}|sWdSWn(ttfyB}zt|�tjkr2WYd}~dS|dt|�j�tt	��d}~ww|durO|d�tt	��|S)Nzworker got sentinel -- exiting��?zworker got %s -- exiting)
�
SystemExitr)�EOFError�IOErrorr
�errno�EINTRr{rdr�)r�readyr�rk��_receive�should_shutdownr0r1�receive�s&
���z/Worker._make_protected_receive.<locals>.receive)r�r��is_setr)rKr�r�r0r�r1r��s
zWorker._make_protected_receive)
NNr0NNNTTNNr+)rdrerfrOr�r�r�r�r�r�rrr�r�r�r�r
r�r�r0r0r0r1ry�s$
�
MrycsNeZdZdd�Zdd�Z�fdd�Zdd�Zdd
d�Zdd
�Zdd�Z	�Z
S)�
PoolThreadcOs t�|�t|_d|_d|_dS�NFT)rrO�RUN�_state�_was_started�daemon�rKr6r?r0r0r1rO�s

zPoolThread.__init__c
Cs�z|��WSty.}ztdt|�j|dd�tt��t�t	�
�WYd}~dSd}~wtyP}ztdt|�j|dd�t�d�WYd}~dSd}~ww)NzThread %r crashed: %rrr�)
�bodyrr=r{rd�_killr�r�rr�r�r�r��rKrkr0r0r1�run�s 
�����zPoolThread.runcs d|_tt|�j|i|��dSr�)rrlr��startrrmr0r1rszPoolThread.startcCr�r+r0rJr0r0r1�on_stop_not_startedr�zPoolThread.on_stop_not_startedNcCs |jr
|�|�dS|��dSr+)r�joinr�rKrDr0r0r1rB	s
zPoolThread.stopcC�
t|_dSr+)�	TERMINATEr�rJr0r0r1�	terminate�
zPoolThread.terminatecCrr+)�CLOSEr�rJr0r0r1r�rzPoolThread.closer+)rdrerfrOrrrrBr
r�rsr0r0rmr1r��s

r�cs$eZdZ�fdd�Zdd�Z�ZS)�
Supervisorcs||_t���dSr+)�poolrlrO)rKrrmr0r1rOszSupervisor.__init__cCs�td�t�d�|j}zH|j}td|jd�|_td�D]}|jtkr2|jtkr2|�	�t�d�q||_|jtkrS|jtkrS|�	�t�d�|jtkrS|jtks@Wnt
yd|��|���wtd�dS)Nzworker handler startingg�������?�
rr*zworker handler exiting)
rr�r�rr�
_processesr�r�r��_maintain_poolrr�r	)rKr�
prev_stater�r0r0r1rs.

�
���zSupervisor.body)rdrerfrOrrsr0r0rmr1rsrcs4eZdZ�fdd�Zdd�Zdd�Zdd�Z�ZS)	�TaskHandlercs,||_||_||_||_||_t���dSr+)�	taskqueuer��outqueuer�cacherlrO)rKrr�rrrrmr0r1rO=�zTaskHandler.__init__c

Csf|j}|j}|j}t|jd�D]�\}}d}d}z^t|�D]H\}}|jr)td�nJz||�Wqty=td�Yn6t	yd|dd�\}}	z
||�
|	dt�f�Wn	tyaYnwYqw|rqtd�||d�WqWn7t	y�|r�|dd�nd\}}	||vr�||�
|	ddt�f�|r�t
�d�||d�Yqwtd	�|��dS)
N���z'task handler found thread._state != RUNzcould not put task on queuer%Fzdoing set_length()r)rrztask handler got sentinel)rrr��iterr��	enumerater�rr�r��_setr�KeyErrorr�tell_others)
rKrrr��taskseq�
set_length�taskr�r��indr0r0r1rEsR���
��zTaskHandler.bodycCsj|j}|j}|j}ztd�|�d�td�|D]}|d�qWn
ty.td�Ynwtd�dS)Nz/task handler sending sentinel to result handlerz(task handler sending sentinel to workersz/task handler got IOError when sending sentinelsztask handler exiting)rr�rrr�)rKrr�r�pr0r0r1r os

��zTaskHandler.tell_otherscCs|��dSr+)r rJr0r0r1r�r8zTaskHandler.on_stop_not_started)rdrerfrOrr rrsr0r0rmr1r;s
*rcsTeZdZ�fdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
�ZS)�TimeoutHandlercs,||_||_||_||_d|_t���dSr+)�	processesr�t_soft�t_hard�_itrlrO)rKr'rr(r)rmr0r1rO�rzTimeoutHandler.__init__c�t�fdd�t|j�D�d�S)Nc3�&�|]\}}|j�kr||fVqdSr+r���.0r��procr�r0r1�	<genexpr>���
��z1TimeoutHandler._process_by_pid.<locals>.<genexpr>�NN)�nextrr'r�r0r�r1�_process_by_pid��
��zTimeoutHandler._process_by_pidc
Csxtd|�|�|j�\}}|sdS|jdd�z	t|jt�WdSty;}zt|�tj	kr0�WYd}~dSd}~ww)Nzsoft time limit exceeded for %rT��soft)
rr4�_worker_pid�handle_timeoutrr��OSErrorr
r��ESRCH)rKr��process�_indexrkr0r0r1�on_soft_timeout�s
���zTimeoutHandler.on_soft_timeoutcCsz|��rdStd|�zt|j��ty#|�|jdt�f�Ynw|�|j�\}}|j	dd�|r;|�
|�dSdS)Nzhard time limit exceeded for %rFr6)r�rr�_timeoutr�_jobrr4r8r9�_trywaitkill)rKr�r<r=r0r0r1�on_hard_timeout�s

��zTimeoutHandler.on_hard_timeoutcCs�td|j�z!t�|j�|jkr"td|j�t�t�|j�tj�n|��Wn	t	y0Yn
w|j
jdd�r:dStd|j�z&t�|j�|jkr^td|j�t�t�|j�tj�WdSt
|jt�WdSt	ypYdSw)Nztimeout: sending TERM to %szIworker %s is a group leader. It is safe to kill (SIGTERM) the whole groupr*r�z/timeout: TERM timed-out, now sending KILL to %szIworker %s is a group leader. It is safe to kill (SIGKILL) the whole group)r�_namer��getpgidr��killpgr��SIGTERMr
r:�_popen�wait�SIGKILLr�rK�workerr0r0r1rA�s*���zTimeoutHandler._trywaitkillc#s��|j|j}}t�}|j}|j}dd�}|jtkrqt�|j��|r-t�fdd�|D��}��	�D]5\}}|j
}	|j}
|
durA|}
|j}|durJ|}||	|�rT||�q1||vrf||	|
�rf||�|�
|�q1dV|jtksdSdS)NcSs"|r|sdSt�||krdSdSr�r)rrDr0r0r1�
_timed_out�s
�z2TimeoutHandler.handle_timeouts.<locals>._timed_outc3s�|]	}|�vr|VqdSr+r0)r.�k�rr0r1r0���z1TimeoutHandler.handle_timeouts.<locals>.<genexpr>)r)r(�setr>rBr�r��copyr�items�_time_accepted�
_soft_timeoutr?�add)rKr)r(�dirtyr>rBrLr�r��ack_time�soft_timeout�hard_timeoutr0rNr1�handle_timeouts�s4�



��zTimeoutHandler.handle_timeoutscCsP|jtkr"z|��D]}t�d�q
Wn	tyYnw|jtkstd�dS)Nr�ztimeout handler exiting)r�r�rZr�r�rr�rKr�r0r0r1r�s
��
�zTimeoutHandler.bodycGs@|jdur
|��|_zt|j�WdStyd|_YdSwr+)r*rZr3�
StopIteration�rKr6r0r0r1�handle_events

�zTimeoutHandler.handle_event)rdrerfrOr4r>rBrArZrr^rsr0r0rmr1r&�s&	r&csVeZdZ	d�fdd�	Zdd�Zdd�Zdd	d
�Zddd�Zd
d�Zddd�Z	�Z
S)�
ResultHandlerNcs^||_||_||_||_||_||_||_d|_d|_||_	|	|_
|
|_|��t
���dS)NF)rr�rr��join_exited_workers�putlockrr*�_shutdown_complete�check_timeouts�on_job_ready�on_ready_counters�
_make_methodsrlrO)rKrr�rr�r`rarrcrdrermr0r1rOszResultHandler.__init__cCs|jdd�dS)NT)rZ)�finish_at_shutdownrJr0r0r1r�z!ResultHandler.on_stop_not_startedcsl�j��j��j��j���fdd�}����fdd�}dd�}t|t|t|i��_�fdd�}|�_dS)	Nc	s:d�_z
�|�||||�WdSttfyYdSwrz)�R�_ackrr,)r�r��
time_acceptedr�r�)rrr0r1�on_ack's�z+ResultHandler._make_methods.<locals>.on_ackcs��dur�||||�z�|}Wn
tyYdSw�jrOtt|���d�}|rO|�jvrO�j|}|���|jd7_Wd�n1sJwY|��s[�dur[���z	|�	||�WdStynYdSwrG)
rrer3r�worker_pids�get_lockrQr�r[r)r�r�r�r��item�
worker_pidr�)rrdrarKr0r1�on_ready/s,�

��z-ResultHandler._make_methods.<locals>.on_readyc
SsJz	t�|t�WdSty$}zt|�tjkr�WYd}~dSd}~wwr+)r�r$rr:r
r�r;)r�r�rkr0r0r1�on_deathFs���z-ResultHandler._make_methods.<locals>.on_deathcs<|\}}z	�||�WdStytd||�YdSw)NzUnknown job state: %s (args=%s))rr)r#�stater6)�state_handlersr0r1�on_state_changeQs�z4ResultHandler._make_methods.<locals>.on_state_change)	rrarrdr�r�r�rtru)rKrlrqrrrur0)rrdrarrKrtr1rf!s
�
zResultHandler._make_methodsr�c
cs��|j}|j}	z||�\}}Wnttfy&}ztd|�t��d}~ww|jr8|jtks1J�td�t��|rP|durEtd�t��||�|dkrOdSndSdVq)Nr� result handler got %r -- exitingz,result handler found thread._state=TERMINATEzresult handler got sentinelr)r�rur�r�rrr�r)rKrDr�rur�r#rkr0r0r1�_process_resultYs4�
����zResultHandler._process_resultc	CsT|jtkr(|jdur|�d�|_zt|j�WdSttfy'd|_YdSwdSrz)r�r�r*rwr3r\r)rKr-�eventsr0r0r1r^ts

��zResultHandler.handle_eventcCsztd�z3|jtkr*z
|�d�D]}qWn	tyYnw|jtks
W|��dSW|��dSW|��dS|��w)Nzresult handler startingr�)rr�r�rwrrgr[r0r0r1r}s 
�����zResultHandler.bodyFc
Cs�d|_|j}|j}|j}|j}|j}|j}|j}d}	|r�|jt	kr�|dur(|�z|d�\}
}Wnt
tfyJ}ztd|�WYd}~dSd}~ww|
rZ|durVtd�q||�z|dd�Wn+t
y�t�}
|	sp|
}	n|
|	dkr|td�Yntdtt|
|	dd	���Ynw|r�|jt	ks!t|d
�r�td�ztd�D]}|j��s�n|�q�Wnt
tfy�Ynwtd
t|�|j�dS)NTr�rvz&result handler ignoring extra sentinel)�shutdowng@z!result handler exiting: timed outz6result handler: all workers terminated, timeout in %ssrr�z"ensuring that outqueue is not fullrz7result handler exiting: len(cache)=%s, thread._state=%s)rbr�rrr�r`rcrur�rr�r�rrtr�abs�minr�r�r��len)rKrZr�rrr�r`rcru�time_terminater�r#rkr�r�r0r0r1rg�sj
������

��
�z ResultHandler.finish_at_shutdownr+)r�r2�F)rdrerfrOrrfrwr^rrgrsr0r0rmr1r_	s�
8
	r_c@sneZdZdZdZeZeZeZeZe	Z	e
Z
																	dwdd�Zd	d
�Zdd�Z
d
d�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd �Zdxd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Z d3d4�Z!dyd5d6�Z"dyd7d8�Z#d9d:�Z$d;d<�Z%d=d>�Z&d?d@�Z'dAdB�Z(dCdD�Z)dEdF�Z*dGdH�Z+dIdJ�Z,difdKdL�Z-dzdMdN�Z.		d{dOdP�Z/dzdQdR�Z0d|dSdT�Z1		d|dUdV�Z2diddddddddddfdWdX�Z3dYdZ�Z4dzd[d\�Z5		d{d]d^�Z6		d{d_d`�Z7e8dadb��Z9dcdd�Z:dedf�Z;dgdh�Z<e8didj��Z=dkdl�Z>dmdn�Z?e8dodp��Z@eAdqdr��ZBeAdsdt��ZCeDdudv��ZEdS)}�PoolzS
    Class which supports an async version of applying functions to arguments.
    TNr0rFcKs�|pt�|_||_|��t�|_i|_t|_||_	||_
||_||_||_
||_||_|p/t|_|
|_||_||_|
|_||_i|_||_t|pR|j	dupR|j
du�|_|rdtdurdt�td��d}|durl|��n||_ |pwt!|j d�|_"t#||	p~d�|_#|dur�t$|�s�t%d��|dur�t$|�s�t%d��|jj&|_'g|_(i|_)i|_*||_+|p�t,|j �|_-t.|j �D]}|�/|�q�|�0|�|_1|r�|j1�2�|�3|j|j4|j5|j(|j�|_6|r�|j6�2�d|_7|j�r
|�8|j(|j|j
|j	�|_9t:�|_;d|_<|�=�|�s	|j9j>|_7n	d|_9d|_<d|_;|�?�|_@|j@j>|_A|�r%|j@�2�tB||jC|j|jD|j5|j(|j1|j6|j@|j|j9|�E�f
dd�|_FdS)	N�WSoft timeouts are not supported: on this platform: It does not have the SIGUSR1 signal.�drzinitializer must be a callablez on_process_exit must be callableF�)r6�exitpriority)Gr�_ctx�synack�
_setup_queuesr�
_taskqueue�_cacher�r�rDrX�_maxtasksperchild�_max_memory_per_child�_initializer�	_initargs�_on_process_exit�LOST_WORKER_TIMEOUT�lost_worker_timeout�
on_process_up�on_process_down�on_timeout_set�on_timeout_cancel�threads�readers�
allow_restart�bool�enable_timeoutsr��warnings�warn�UserWarningrr�round�max_restartsr�callable�	TypeError�Process�_Process�_pool�	_poolctrl�_on_ready_counters�putlocksrF�_putlockr��_create_worker_processr�_worker_handlerrrr��	_outqueue�
_task_handlerrcr&�_timeout_handler�Lock�_timeout_handler_mutex�_timeout_handler_started�_start_timeout_handlerr^�create_result_handler�_result_handler�handle_result_eventr�_terminate_pool�_inqueue�_help_stuff_finish_args�
_terminate)rKr'r}r~�maxtasksperchildrDrXr�r��max_restart_freqr�r�r�r�r��	semaphorer�r�r��on_process_exit�contextr�r�r?r�r0r0r1rO�s�
���

�
�
�


��z
Pool.__init__cOs|j|i|��Sr+)r�)rKr6�kwdsr0r0r1r�H�zPool.ProcesscCs|�|j|d��S)N)�target)r�r�rJr0r0r1�
WorkerProcessK�zPool.WorkerProcessc
Ks:|j|j|j|j|j|j|j|j|j|j	f	d|j
i|��S)Nre)r_r�r�r��_poll_result�_join_exited_workersr�rrcrdr�)rK�extra_kwargsr0r0r1r�Ns���zPool.create_result_handlercCr�r+r0)rKr�r�r�r�r0r0r1rdWr�zPool.on_job_readycCs|j|j|jfSr+)r�r�r�rJr0r0r1r�Zr�zPool._help_stuff_finish_argscCszt�WStyYdSwrG)r�NotImplementedErrorrJr0r0r1r]s
�zPool.cpu_countcGs|jj|�Sr+)r�r^r]r0r0r1r�cr8zPool.handle_result_eventcCr�r+r0)rKrK�queuesr0r0r1�_process_register_queuesfr�zPool._process_register_queuescr+)Nc3r,r+r�r-r�r0r1r0jr1z'Pool._process_by_pid.<locals>.<genexpr>r2)r3rr�r�r0r�r1r4ir5zPool._process_by_pidcCs|j|jdfSr+)r�r�rJr0r0r1�get_process_queuesor�zPool.get_process_queuescCs�|jr|j��nd}|��\}}}|j�d�}|�|j||||j|j|j	||j
|j|j|j
|d��}|j�|�|�||||f�|j�dd�|_d|_||_|��||j|j<||j|j<|jrg|�|�|S)Nr�)r�r�r�r�r��
PoolWorkerT)r�r��Eventr��Valuer�ryr�r�r�r�r��_wrap_exceptionr�r��appendr��name�replacer�indexrr�r�r�r�)rKr�r�r�r�r�r��wr0r0r1r�rs,
�

zPool._create_worker_processcCr�r+r0rJr0r0r1�process_flush_queues�r�zPool.process_flush_queuescsld}dd�t|j���D�D]}|pt�}|j\}}|||jkr'|�||�q|r2t|j�s2t	��ii�}t
tt|j���D]]}|j|}|j}	|j
}
|
dusU|	dur�td|�|
durb|��td|�|�|j<|	||j<|	ttfvr�t|dd�s�td|j|jt|	�d	d
�|�|�|j|=|j|j=|j|j=q@��r4dd�|jD��t|j���D]d}t��fdd
�|��D�d�}|r�|�||�|��s�|�|�p�d	}	��|�}|r�t|dd�r�|�|	�q�|� |||	�q�|j!}
|j"}|
�r|
�#��s|�||
j�q�|�r|�#��s|�||j�q����D]}|j$�r,|�s'|�%|�|�$|��qt|���SgS)z�Cleanup after any worker processes which have exited due to
        reaching their specified lifetime. Returns True if any workers were
        cleaned up.
        NcSsg|]}|��s|jr|�qSr0)r��_worker_lost)r.r�r0r0r1�
<listcomp>�s
�
�z-Pool._join_exited_workers.<locals>.<listcomp>z!Supervisor: cleaning up worker %dzSupervisor: worked %d joined�_controlled_terminationFz Process %r pid:%r exited with %rrr�cSsg|]}|j�qSr0r��r.r�r0r0r1r��sc3s$�|]
}|�vs|�vr|VqdSr+r0�r.r���all_pids�cleanedr0r1r0�s���z,Pool._join_exited_workers.<locals>.<genexpr>�_job_terminated)&r3r��valuesrr��_lost_worker_timeout�mark_as_worker_lostr|r�rt�reversedr�r�rGrr	r�r)r��getattrr=r�r	r�r�r�r3rm�on_job_process_downr�r��_set_terminated�on_job_process_lost�	_write_to�_scheduled_for�	_is_aliver��_process_cleanup_queues)rKryr�r��	lost_time�lost_ret�	exitcodesr�rKr��popen�
acked_by_goner/�write_to�	sched_forr0r�r1r��s�

�






��


��
���

�zPool._join_exited_workerscCr�r+r0)rKr�rKr0r0r1�on_partial_read�r�zPool.on_partial_readcCr�r+r0rJr0r0r1r��r�zPool._process_cleanup_queuescCr�r+r0)rKr��pid_goner0r0r1r��r�zPool.on_job_process_downcCst�|f|_dSr+)rr�)rKr�r�r�r0r0r1r��r�zPool.on_job_process_lostcCs>ztd�t|�|j���ty|�ddt�f�YdSw)Nz(Worker exited prematurely: {0} Job: {1}.F)rr�r	r@rr)rKr�r�r0r0r1r��s
���zPool.mark_as_worker_lostcC�|Sr+r0rJr0r0r1�	__enter__�r�zPool.__enter__cGs|��Sr+)r
)rKr�r0r0r1�__exit__�sz
Pool.__exit__cCr�r+r0�rK�nr0r0r1�on_grow�r�zPool.on_growcCr�r+r0r�r0r0r1�	on_shrinkr�zPool.on_shrinkcCs`t|���D]%\}}|jd8_|jr|j��|��|�d�||dkr+dSqtd��)Nrz&Can't shrink pool. All processes busy!)r�
_iterinactiverr�rL�terminate_controlledr��
ValueError)rKr�r�rKr0r0r1rLs

�zPool.shrinkcCs:t|�D]}|jd7_|jr|j��q|�|�dSrG)r�rr�rVr�)rKr�r�r0r0r1rVs
�z	Pool.growccs"�|jD]
}|�|�s|VqdSr+)r��_worker_activerJr0r0r1r�s�

��zPool._iterinactivecCs(|j��D]}|j|��vrdSqdS)NTF)r�r�r�rm)rKrKr�r0r0r1r�s
�zPool._worker_activec	Cs�t|jt|j��D]5}|jtkrdSz|r$||ttfvr$|j�	�Wnt
y3|j�	�Ynw|�|���t
d�q
dS)z�Bring the number of pool processes up to the specified number,
        for use after reaping workers which have exited.
        Nzadded worker)r�rr|r�r�r�r)r�r�step�
IndexErrorr��_avail_indexr)rKr�r�r0r0r1�_repopulate_pool#s

��
�zPool._repopulate_poolcsDt|j�|jks
J�tdd�|jD���t�fdd�t|j�D��S)Ncss�|]}|jVqdSr+)r�)r.r%r0r0r1r04s�z$Pool._avail_index.<locals>.<genexpr>c3s�|]	}|�vr|VqdSr+r0)r.r���indicesr0r1r05rO)r|r�rrPr3r�rJr0r�r1r�2szPool._avail_indexcCs
|��Sr+)r�rJr0r0r1�did_start_ok7rzPool.did_start_okcCs<|��}|�|�tt|��D]}|jdur|j��qdS)zF"Clean up any exited workers and start replacements for them.
        N)r�r�r�r|r�r[)rK�joinedr�r0r0r1r:s


��zPool._maintain_poolc
Csz|jjtkr9|jtkr;z|��WdSty"|��|���ty8}zt|�t	j
kr3t|��d}~wwdSdSr+)r�r�r�rrr�r	r:r
r��ENOMEM�MemoryErrorrr0r0r1�
maintain_poolCs���zPool.maintain_poolcsF�j���_�j���_�jjj�_�jjj�_	�fdd�}|�_
dS)Ncs�jj�|�r
d���fSdSr�)r�r�r�r�r�rJr0r1r�Vsz(Pool._setup_queues.<locals>._poll_result)r��SimpleQueuer�r�r�r�r�r�r�r�r��rKr�r0rJr1r�Ps
zPool._setup_queuescCsj|jr1|jdur3|j�|jsd|_|j��Wd�dSWd�dS1s*wYdSdSdSr�)r�r�r�r�rrJr0r0r1r�\s�"��zPool._start_timeout_handlercC� |jtkr|�|||���SdS)z8
        Equivalent of `func(*args, **kwargs)`.
        N)r�r��apply_asyncr�)rK�funcr6r�r0r0r1�applyes
�z
Pool.applycCs"|jtkr|�||t|���SdS)z�
        Like `map()` method but the elements of the `iterable` are expected to
        be iterables as well and will be unpacked as arguments. Hence
        `func` and (a, b) becomes func(a, b).
        N)r�r��
_map_asyncr;r��rKr
�iterable�	chunksizer0r0r1r:ls
���zPool.starmapcCs"|jtkr|�||t|||�SdS)z=
        Asynchronous version of `starmap()` method.
        N)r�r�rr;�rKr
rr�callback�error_callbackr0r0r1�
starmap_asyncvs

��zPool.starmap_asynccCr)zx
        Apply `func` to each element in `iterable`, collecting the results
        in a list that is returned.
        N)r�r��	map_asyncr�r
r0r0r1r4s
�zPool.mapc�|jtkrdS|p|j}|dkr,t|j|d��|j���fdd�t|�D��jf��S|dks2J�t	�
�||�}t|j|d��|j��fdd�t|�D��jf�dd��D�S)zP
        Equivalent of `map()` -- can be MUCH slower than `Pool.map()`.
        Nr�r�c3�*�|]\}}t�j|�|fiffVqdSr+�r�r@�r.r��x�r
r�r0r1r0����zPool.imap.<locals>.<genexpr>c3�*�|]\}}t�j|t|fiffVqdSr+�r�r@r7r�r�r0r1r0�rcs��|]
}|D]}|VqqdSr+r0�r.�chunkror0r0r1r0���)r�r�r��IMapIteratorr�r�r�r�_set_lengthr�
_get_tasks�rKr
rrr��task_batchesr0rr1�imap�s4

����
��z	Pool.imapcr)zL
        Like `imap()` method but ordering of results is arbitrary.
        Nrrc3rr+rrrr0r1r0�rz&Pool.imap_unordered.<locals>.<genexpr>c3rr+rrrr0r1r0�rcsr r+r0r!r0r0r1r0�r#)r�r�r��IMapUnorderedIteratorr�r�r�rr%rr&r'r0rr1�imap_unordered�s4

����
��zPool.imap_unorderedcCs|jtkrdS|	p|j}	|
p|j}
|p|j}|	r%tdur%t�td��d}	|jtkr�|dur1|j	n|}|r?|j
dur?|j
��t|j
|||||	|
||j|j||jrT|jnd|
d�
}|
s]|	ra|��|jrw|j�t|jd|||ffgdf�|S|�t|jd|||ff�|SdS)a
        Asynchronous equivalent of `apply()` method.

        Callback is called when the functions return value is ready.
        The accept callback is called when the job is accepted to be executed.

        Simplified the flow is like this:

            >>> def apply_async(func, args, kwds, callback, accept_callback):
            ...     if accept_callback:
            ...         accept_callback()
            ...     retval = func(*args, **kwds)
            ...     if callback:
            ...         callback(retval)

        Nr�)r�r��callbacks_propagate�send_ack�correlation_id)r�r�rXrDr�r�r�r�r�r�r�rI�ApplyResultr�r�r�r�r-r�r�r�r�r�r@r�)rKr
r6r�rr�accept_callback�timeout_callback�waitforslotrXrDr�r,r.r�r0r0r1r	�sF



�


�	����zPool.apply_asynccCr�r+r0)rK�responser�r��fdr0r0r1r-�r�z
Pool.send_ackc
Cst|�|�\}}|dur8z	t||pt�Wnty/}zt|�tjkr$�WYd}~dSd}~wwd|_d|_dSdSr�)	r4rrr:r
r�r;r�r�)rKr��sigr/r�rkr0r0r1�
terminate_job�s���
�zPool.terminate_jobcCs|�||t|||�S)z<
        Asynchronous equivalent of `map()` method.
        )rr7rr0r0r1r	s�zPool.map_asyncc	s�|jtkrdSt|d�st|�}|dur(tt|�t|j�d�\}}|r(|d7}t|�dkr0d}t�|||�}t	|j
|t|�||d��|j���fdd�t
|�D�df��S)	zY
        Helper function to implement map, starmap and their async counterparts.
        N�__len__r&rr�rc3rr+rr��mapperr�r0r1r0&rz"Pool._map_async.<locals>.<genexpr>)r�r�r�r3�divmodr|r�rr&�	MapResultr�r�r�r)	rKr
rr:rrr�extrar(r0r9r1rs(

���zPool._map_asyncccs0�t|�}	tt�||��}|sdS||fVqr+)r�tupler9�islice)r
�it�sizerr0r0r1r&*s�
�zPool._get_taskscCstd��)Nz:pool objects cannot be passed between processes or pickled)r�rJr0r0r1r�3s�zPool.__reduce__cCsPtd�|jtkr&t|_|jr|j��|j��|j�	d�t
|j�dSdS)Nzclosing pool)rr�r�rr�r^r�r�r�r�rErJr0r0r1r�8s


�z
Pool.closecCs$td�t|_|j��|��dS)Nzterminating pool)rrr�r�r
r�rJr0r0r1r
Bs
zPool.terminatecCst|�dSr+)rE)�task_handlerr0r0r1�_stop_task_handlerHszPool._stop_task_handlercCs�|jttfvs	J�td�t|j�td�|�|j�td�t|j�td�t	|j
�D]\}}td|dt|j
�|�|jdurG|�
�q.td�dS)Nzjoining worker handler�joining task handler�joining result handlerzresult handler joinedzjoining worker %s/%s (%r)rzpool join complete)r�rrrrEr�rCr�r�rr�r|rGr	)rKr�r%r0r0r1r	Ls


�z	Pool.joincCs|j��D]}|��qdSr+)r�r�rP)rK�er0r0r1�restart[s
�zPool.restartcCsZtd�|j��|��r'|j��r+|j��t�d�|��r)|j��sdSdSdSdS)Nz7removing tasks from inqueue until task handler finishedr)	r�_rlockrI�is_aliver�r�r�r�r�)�inqueuerBr�r0r0r1�_help_stuff_finish_s


"�zPool._help_stuff_finishcCs|�d�dSr+)r�)�clsrrr0r0r1�_set_result_sentinelhszPool._set_result_sentinelcCs:td�|��|��|�d�td�|j|
�|��|�||�|	dur,|	��|rFt|dd�rFtd�|D]
}|��rE|��q;td�|�|�td�|��|	durdtd�|	�t	�|r�t|dd�r�td	�|D]}|�
�r�td
|j�|jdur�|�
�qstd�|r�|��|r�|��dSdS)Nzfinalizing poolz&helping task handler/workers to finishrr
zterminating workersrDrEzjoining timeout handlerzjoining pool workerszcleaning up worker %dzpool workers joined)rr
r�rKrMr�r�rCrB�TIMEOUT_MAXrIr�rGr	r�)rLrrJrr�worker_handlerrB�result_handlerr�timeout_handler�help_stuff_finish_argsr%r0r0r1r�lsJ

�


��zPool._terminate_poolcC�dd�|jD�S)NcSsg|]}|jj�qSr0)rGr�r�r0r0r1r���z*Pool.process_sentinels.<locals>.<listcomp>)r�rJr0r0r1�process_sentinels�rhzPool.process_sentinels)NNr0NNNNNrNNNNTNFFFNNNFr~)rr+)NNNrc)Frdrerfrgr�ryrrr&r_rrOr�r�r�rdr�rr�r�r4r�r�r�r�r�r�r�r�r�r�r�r�r�rLrVr�r�r�r�rrrr�r�rr:rr4r)r+r	r-r6rr�staticmethodr&r�r�r
rCr	rGrK�classmethodrMr��propertyrUr0r0r0r1r�s�
�z	
S

	
	


�
	

�
�8

�	
�





6rc@s�eZdZdZdZdZdddddedddddfdd�Zdd�Zdd�Z	d	d
�Z
dd�Zd
d�Zdd�Z
dd�Zd$dd�Zdd�Zd$dd�Zd$dd�Zdd�Zd%dd�Zd d!�Zd"d#�ZdS)&r/Nr0cCs�|
|_t�|_t��|_tt�|_||_	||_
||_||_||_
||_||_||_|	|_|
|_|p2d|_||_d|_d|_d|_d|_d|_|||j<dS)Nr0F)r.r��_mutexr@r��_eventr3�job_counterr@r��	_callback�_accept_callback�_error_callback�_timeout_callbackr?rTr��_on_timeout_set�_on_timeout_cancel�_callbacks_propagate�	_send_ack�	_accepted�
_cancelledr8rS�_terminated)rKrrr0r1rrXrDr�r�r�r,r-r.r0r0r1rO�s,


zApplyResult.__init__cCsdj|jj|j|j|��d�S)Nz&<{name}: {id} ack:{ack} ready:{ready}>)r��id�ackr�)r�rnrdr@rdr�rJr0r0r1rp�s�zApplyResult.__repr__cCs
|j��Sr+)rZr�rJr0r0r1r��rzApplyResult.readycC�|jSr+)rdrJr0r0r1�accepted�rxzApplyResult.acceptedcCs|��sJ�|jSr+)r��_successrJr0r0r1�
successful�szApplyResult.successfulcCs
d|_dS)zOnly works if synack is used.TN)rerJr0r0r1�_cancel�s
zApplyResult._cancelcCs|j�|jd�dSr+)r��popr@rJr0r0r1�discard�rqzApplyResult.discardcCs
||_dSr+)rf�rKrur0r0r1r
�rzApplyResult.terminatecCs6zt|pd��ty|�ddt�f�YdSw�NrF)rrrrpr0r0r1r��s
�zApplyResult._set_terminatedcCs|jr|jgSgSr+�r8rJr0r0r1rm�r�zApplyResult.worker_pidscCs|j�|�dSr+)rZrHr
r0r0r1rH�r�zApplyResult.waitcCs*|�|�|��st�|jr|jS|jj�r+)rHr�rrkrT�	exceptionr
r0r0r1r��s
zApplyResult.getc
Osb|r/z
||i|��WdS|jy�ty.}ztd|dd�WYd}~dSd}~wwdS)Nz"Pool callback raised exception: %rrr�)rbr�r=)rKr�r6r?rkr0r0r1�safe_apply_callback�s����zApplyResult.safe_apply_callbackFcCs0|jdur|j|j||r|jn|jd�dSdS)N)r7rD)r_rtrTr?)rKr7r0r0r1r9s

��zApplyResult.handle_timeoutcCs�|j�`|jr|�|�|\|_|_|j��|jr"|j�|j	d�|j
r0|jr0|�|j
|j�|jdurK|jrS|js[|�|j|j�Wd�dSWd�dSWd�dSWd�dS1sfwYdSr+)
rYrarkrTrZrPrdr�rnr@r\rtr^�rKr�r�r0r0r1rs4

�
������"�zApplyResult._setc
Cs�|j��|jr(|jr(d|_|r|�t||j|�Wd�S	Wd�dSd|_||_||_|��r=|j	�
|jd�|jrI|�||j|j
�t}|jr�z5z|�||�Wn|jybt}�tylt}YnwW|jr�|r�|�|||j|�Wd�Sn|jr�|r�|�|||j|�YWd�Sww|jr�|r�|�|||j|�Wd�dSWd�dSWd�dS1s�wYdSr�)rYrercrdr�r@rSr8r�r�rnr`rTr?r�r]�_propagate_errorsr�)rKr�rkr�r�r3r0r0r1rj$sZ����

���

��
��"�zApplyResult._ackr+r~)rdrerfr�r�r�r�rOrpr�rjrlrmror
r�rmrHr�rtr9rrjr0r0r0r1r/�s4
�


	

r/c@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)r<cCs�tj||||d�d|_||_dg||_dg||_dg||_dg||_||_|dkr<d|_	|j
��||j=dS||t
||�|_	dS)Nr8TFr)r/rOrk�_lengthrTrdr8rS�
_chunksize�_number_leftrZrPr@r�)rKrr�lengthrrr0r0r1rOLs�
zMapResult.__init__cCs�|\}}|r>||j||j|d|j�<|jd8_|jdkr<|jr*|�|j�|jr5|j�|jd�|j�	�dSdSd|_
||_|jrM|�|j�|jrX|j�|jd�|j�	�dS)NrrF)rTrxryr\rdr�rnr@rZrPrkr^)rKr��success_result�successr�r0r0r1r^s$
�zMapResult._setcGsn||j}t|d|j|j�}t||�D]}d|j|<||j|<||j|<q|��r5|j�	|j
d�dSdS�NrT)rxr{rwr�rdr8rSr�r�rnr@)rKr�rkr�r6rrB�jr0r0r1rjrs


�zMapResult._ackcCs
t|j�Sr+)�allrdrJr0r0r1rj|rzMapResult.acceptedcCrS)NcSsg|]}|r|�qSr0r0r�r0r0r1r��rTz)MapResult.worker_pids.<locals>.<listcomp>rrrJr0r0r1rmr�zMapResult.worker_pidsN)rdrerfrOrrjrjrmr0r0r0r1r<Js
r<c@sZeZdZdZefdd�Zdd�Zddd�ZeZdd	�Z	d
d�Z
dd
�Zdd�Zdd�Z
dS)r$NcCsZt�t���|_tt�|_||_t�|_	d|_
d|_d|_i|_
g|_||_|||j<dSrq)r@�	Conditionr�rSr3r[r@r�r�_itemsr=rw�_ready�	_unsorted�_worker_pidsr�)rKrr�r0r0r1rO�s
zIMapIterator.__init__cCr�r+r0rJr0r0r1�__iter__�r�zIMapIterator.__iter__cCs�|j�Fz|j��}Wn6tyA|j|jkrd|_t�|j�|�z|j��}Wnty>|j|jkr<d|_t�t	�wYnwWd�n1sLwY|\}}|rY|St
|��r�)rSr��popleftr�r=rwr�r\rHrr�)rKrDror|rQr0r0r1r3�s0�����zIMapIterator.nextcCs�|j�\|j|kr<|j�|�|jd7_|j|jvr6|j�|j�}|j�|�|jd7_|j|jvs|j��n||j|<|j|jkrWd|_|j	|j
=Wd�dSWd�dS1sbwYdSr})rSr=r�r�r�rnrUrwr�r�r@rur0r0r1r�s"
�
�"�zIMapIterator._setcCsh|j�'||_|j|jkr"d|_|j��|j|j=Wd�dSWd�dS1s-wYdSr�)rSrwr=r�rUr�r@)rKrzr0r0r1r%�s
�"�zIMapIterator._set_lengthcGs|j�|�dSr+)r�r�)rKr�rkr�r6r0r0r1rj�r�zIMapIterator._ackcCrir+)r�rJr0r0r1r��rxzIMapIterator.readycCrir+)r�rJr0r0r1rm�rxzIMapIterator.worker_pidsr+)rdrerfr�r�rOr�r3�__next__rr%rjr�rmr0r0r0r1r$�s
r$c@seZdZdd�ZdS)r*cCs||j�1|j�|�|jd7_|j��|j|jkr,d|_|j|j=Wd�dSWd�dS1s7wYdSr})	rSr�r�r=rUrwr�r�r@rur0r0r1r�s
�"�zIMapUnorderedIterator._setN)rdrerfrr0r0r0r1r*�sr*c@s:eZdZddlmZeZddd�Zdd�Zed	d
��Z	dS)�
ThreadPoolr)r�Nr0cCst�||||�dSr+)rrO)rKr'r}r~r0r0r1rO�rqzThreadPool.__init__cs:t��_t��_�jj�_�jj�_�fdd�}|�_dS)Ncs(z	d�j|d�fWStyYdSwr�)r�rr�rJr0r1r��s
�z.ThreadPool._setup_queues.<locals>._poll_result)rr�r�r�r�r�r�r�rr0rJr1r��s


zThreadPool._setup_queuescCsV|j�|j��|j�dgt|��|j��Wd�dS1s$wYdSr+)�	not_empty�queuer^�extendr|rX)rJrBrr0r0r1rK�s

"�zThreadPool._help_stuff_finish)NNr0)
rdrerf�dummyr�rrOr�rVrKr0r0r0r1r��s

r�r+)erQr�r9r�r�r�r�r@r�r��collectionsr�	functoolsr�rrr�commonrr	r
rr�compatr
rrr�rr�r�
exceptionsrrrrrrrrr�rrrrr r��version_inforh�system�_winr#rrIr$rNr,�	SemaphorerNr�rrr�r�r�r�r�r)r�r�r�r�r�r�r��countr[r�r2r7r;r=rErFr�rirtrwryr�rrr&r_rr/r<r$r*r�r0r0r0r1�<module>s�$	
�


;)%K:o=R