o
    +i%                     @  s  U d dl mZ d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mZ d dl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& ej'dkrd dlm(Z(m)Z) nd dl*m(Z(m)Z) dZ+edZ,e(dZ-e#dZ.de/d< e#dZ0de/d< e#dZ1de/d< dddd0d'd(Z2d1d*d+Z3d2d-d.Z4e5d/kre4  dS dS )3    )annotations)current_default_process_limiterprocess_workerrun_syncN)deque)Callable)module_from_specspec_from_file_location)TypeVarcast   )current_timeget_async_backendget_cancelled_exc_class)BrokenWorkerProcess)open_process)CapacityLimiter)CancelScope
fail_after)ByteReceiveStreamByteSendStreamProcess)RunVarcheckpoint_if_cancelled)BufferedByteReceiveStream)      )TypeVarTupleUnpacki,  T_RetvalPosArgsT_process_pool_workerszRunVar[set[Process]]_process_pool_idle_workersz$RunVar[deque[tuple[Process, float]]]_default_process_limiterzRunVar[CapacityLimiter]F)cancellablelimiterfunc&Callable[[Unpack[PosArgsT]], T_Retval]argsUnpack[PosArgsT]r$   boolr%   CapacityLimiter | Nonereturnc                  sZ  d fdd}t  I dH  tjd| |ftjd	}z
t t }W n tyE   t t	 }t t| t
  Y nw |pJt 4 I dH O |r| \}jdu rttjtttj t }g }	|r||d
 d  tk r~n| \}
}|
  |
 |	|
 |sstdd |	D ]	}| I dH  qW d   n1 sw   Y  n |sSt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y0     t*yE } z	  t%d|d}~ww + t| d: z)tt,||I dH W v rj|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_cmdbytesr,   objectc                   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shieldr4   )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 C/var/www/html/venv/lib/python3.10/site-packages/anyio/to_process.pysend_raw_commandC   s>   

z"run_sync.<locals>.send_raw_commandNrun)protocolr   r   Tr6   z-uz-m)rO   stdout         READY
r5   __main____file__initz*Error during worker process initialization)r-   r.   r,   r/   )-r   rD   dumpsHIGHEST_PROTOCOLr!   getr"   LookupErrorsetr   r   #setup_process_pool_exit_at_shutdownr   pop
returncoder   r   rO   r   r   rV   r   WORKER_MAX_IDLE_TIMEpopleftr@   removeappendr   rA   sys
executable__name__r   
subprocessPIPEr   receiver   getattrmodulespathr   r>   addr   )r&   r$   r%   r(   rS   requestidle_workers
idle_sincenowkilled_processesprocess_to_killkilled_processcommandmessagemain_module_pathpickledrJ   rQ   rL   rR   r   ,   s   !





	








F0r   r   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#   r_   r`   r   os	cpu_countra   )r%   rQ   rQ   rR   r      s   

r   Nonec               
   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 }~nmd }~ww |dkri|\}}z|| }W nY tyh } z|}W Y d }~nJd }~ww |dkr|\t _}t jd= |rtj|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wrY   TrT   r\   rZ   __mp_main__r4   r3   s   %s %d
)ri   rO   rV   openr   devnullbufferwriterD   loadEOFErrorr>   rq   rp   isfiler	   loaderr   exec_moduler]   r^   lenrC   
SystemExit)rO   rV   rK   	exceptionrz   r(   rJ   r&   r|   specmainrG   r}   rQ   rQ   rR   r      sp   




r   rZ   )
r&   r'   r(   r)   r$   r*   r%   r+   r,   r   )r,   r   )r,   r   )6
__future__r   __all__r   rD   rl   ri   collectionsr   collections.abcr   importlib.utilr   r	   typingr
   r   _core._eventloopr   r   r   _core._exceptionsr   _core._subprocessesr   _core._synchronizationr   _core._tasksr   r   abcr   r   r   lowlevelr   r   streams.bufferedr   version_infor   r   typing_extensionsre   r   r    r!   __annotations__r"   r#   r   r   r   rk   rQ   rQ   rQ   rR   <module>   sL    
 

;
