o
     d$                     @   s  U 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mZ d dl	m
Z
mZmZmZmZmZmZmZ ddlmZmZmZ ddlmZ ddlmZ dd	lmZ dd
lmZmZ ddlm Z m!Z!m"Z" ddl#m$Z$m%Z% ddl&m'Z' dZ(edZ)e$dZ*e$ee"  e+d< e$dZ,e$eee"e-f   e+d< e$dZ.e$e e+d< dddde
de)f de/de0dee de)f
ddZ1defddZ2d"dd Z3e4d!kre3  dS dS )#    N)deque)module_from_specspec_from_file_location)CallableDequeListOptionalSetTupleTypeVarcast   )current_timeget_asynclibget_cancelled_exc_class)BrokenWorkerProcess)open_process)CapacityLimiter)CancelScope
fail_after)ByteReceiveStreamByteSendStreamProcess)RunVarcheckpoint_if_cancelled)BufferedByteReceiveStreami,  T_Retval_process_pool_workers_process_pool_idle_workers_default_process_limiterF)cancellablelimiterfunc.argsr    r!   returnc                   sb  dt dtf fdd}t I dH  tjd| |ftjd}z
t t }W n t	yI   t
 t }t
 t
| t  Y nw |pNt 4 I dH O |r| \}jdu rttjtttj t }g }	|r||d d	  tk rn| \}   |	 |swtd
d |	D ]	 I dH  qW d   n1 sw   Y  n |sWtj ddt!g}
t"|
t#j$t#j$dI dH zTttjtttj t%d  &dI dH }W d   n1 sw   Y  |dkrt'd|t(tj)d dd}tjdtj*|ftjd}||I dH  W n! t't+ fy4     t,yI } z	  t'd|d}~ww - t| d: z)tt.||I dH W v rn|t f W  d   W  d  I dH  S v r|t f w w 1 sw   Y  W d  I dH  dS 1 I dH sw   Y  dS )a  
    Call the given function with the given arguments in a worker process.

    If the ``cancellable`` option is enabled and the task waiting for its completion is cancelled,
    the worker process running it will be abruptly terminated using SIGKILL (or
    ``terminateProcess()`` on Windows).

    :param func: a callable
    :param args: positional arguments for the callable
    :param cancellable: ``True`` to allow cancellation of the operation while it's running
    :param limiter: capacity limiter to use to limit the total amount of processes running
        (if omitted, the default limiter is used)
    :return: an awaitable that yields the return value of the function.

    pickled_cmdr$   c                    s  z/ | I d H   ddI d H }|d\}}|dvr%td| t|I d H }W nG tyw } z; z"  t	dd 
 I d H  W d    n1 sYw   Y  W n	 tyh   Y nw t|t rp t|d }~ww t|}|dkrt|tsJ ||S )	N   
2       )   RETURN	   EXCEPTION-Worker process returned unexpected response: Tshieldr*   )sendreceive_untilsplitRuntimeErrorreceive_exactlyintBaseExceptiondiscardkillr   acloseProcessLookupError
isinstancer   r   pickleloads)r%   responsestatuslengthpickled_responseexcretvalbufferedprocessstdinworkers ;/usr/local/lib/python3.10/dist-packages/anyio/to_process.pysend_raw_command2   s>   

z"run_sync.<locals>.send_raw_commandNrun)protocolr   r   Tr,   z-uz-m)rE   stdout         READY
r+   __main____file__initz*Error during worker process initialization)/bytesobjectr   r:   dumpsHIGHEST_PROTOCOLr   getr   LookupErrorsetr   r   #setup_process_pool_exit_at_shutdowncurrent_default_process_limiterpop
returncoder   r   rE   r   r   rL   r   WORKER_MAX_IDLE_TIMEpopleftr6   removeappendr   r7   sys
executable__name__r   
subprocessPIPEr   receiver   getattrmodulespathr   r4   addr   )r"   r    r!   r#   rI   requestidle_workers
idle_sincenowkilled_processescommandmessagemain_module_pathpickledr@   rG   rB   rH   run_sync   s   !





	








F0ru   c                  C   s<   zt  W S  ty   tt pd} t |  |  Y S w )z
    Return the capacity limiter that is used by default to limit the number of worker processes.

    :return: a capacity limiter object

       )r   rW   rX   r   os	cpu_countrY   )r!   rG   rG   rH   r[      s   

r[   c               
   C   s  t j} t j}ttjt _ttjdt _|jd 	 d  }}z
t	| j^}}W n t
y2   Y d S  tyE } z|}W Y d }~ngd }~ww |dkri|\}}z|| }W nS tyh } z|}W Y d }~nDd }~ww |dkr|\t _}t jd= |rztd|}	|	r|	jrt|	}
|	j|
 |
t jd< W n ty } z|}W Y d }~nd }~ww z|d urd}t|tj}n	d	}t|tj}W n ty } z|}d}t|tj}W Y d }~nd }~ww |jd
|t|f  |j| t|tr|q)NwrO   TrJ   rR   rP   __mp_main__r*   r)   s   %s %d
)rb   rE   rL   openrw   devnullbufferwriter:   loadEOFErrorr4   rj   ri   r   loaderr   exec_modulerU   rV   lenr9   
SystemExit)rE   rL   rA   	exceptionrq   r#   r@   r"   rs   specmainr=   rt   rG   rG   rH   process_worker   sp   




r   rP   )r$   N)5rw   r:   re   rb   collectionsr   importlib.utilr   r   typingr   r   r   r   r	   r
   r   r   _core._eventloopr   r   r   _core._exceptionsr   _core._subprocessesr   _core._synchronizationr   _core._tasksr   r   abcr   r   r   lowlevelr   r   streams.bufferedr   r^   r   r   __annotations__r   floatr   rT   boolru   r[   r   rd   rG   rG   rG   rH   <module>   sR   
 (

 
<
