o
    #6d$                     @  sN  U d dl m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	m
Z
 d dl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'de(d< e!dZ)de(d< e!dZ*de(d< dddd+d"d#Z+d,d%d&Z,d-d(d)Z-e.d*kre-  dS dS ).    )annotationsN)deque)module_from_specspec_from_file_location)Callable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_workerszRunVar[set[Process]]_process_pool_idle_workersz$RunVar[deque[tuple[Process, float]]]_default_process_limiterzRunVar[CapacityLimiter]F)cancellablelimiterfuncCallable[..., T_Retval]argsobjectr   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$   r!   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+   )sendZreceive_untilsplitRuntimeErrorZreceive_exactlyintBaseExceptiondiscardkillr   acloseProcessLookupError
isinstancer   r   pickleloads)r%   responsestatuslengthZpickled_responseexcretvalbufferedprocessstdinworkers gC:\Users\jesus\OneDrive\Desktop\erpjis_fastapi\backend\jisbackend\Lib\site-packages\anyio/to_process.pysend_raw_command4   s>   

z"run_sync.<locals>.send_raw_commandNrun)protocolr   r	   Tr-   z-uz-m)rC   stdout         READY
r,   __main____file__initz*Error during worker process initialization)r%   r&   r$   r!   )-r   r9   dumpsHIGHEST_PROTOCOLr   getr   LookupErrorsetr   r   Z#setup_process_pool_exit_at_shutdowncurrent_default_process_limiterpop
returncoder   r   rC   r   r   rJ   r
   WORKER_MAX_IDLE_TIMEpopleftr5   removeappendr   r6   sys
executable__name__r   
subprocessPIPEr   Zreceiver   getattrmodulespathr   r3   addr   )r   r   r   r    rG   requestZidle_workersZ
idle_sincenowZkilled_processescommandmessagemain_module_pathpickledr>   rE   r@   rF   run_sync   s   !





	








F0rl   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   rS   rT   r   os	cpu_countrU   )r   rE   rE   rF   rV      s   

rV   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 }~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wrM   TrH   rP   rN   __mp_main__r+   r*   s   %s %d
)r]   rC   rJ   openrn   devnullbufferwriter9   loadEOFErrorr3   rd   rc   r   loaderr   exec_modulerQ   rR   lenr8   
SystemExit)rC   rJ   r?   	exceptionrh   r    r>   r   rj   specmainr<   rk   rE   rE   rF   process_worker   sp   




r   rN   )
r   r   r    r!   r   r"   r   r#   r$   r   )r$   r   )r$   rp   )/
__future__r   rn   r9   r`   r]   collectionsr   importlib.utilr   r   typingr   r   r   Z_core._eventloopr
   r   r   Z_core._exceptionsr   Z_core._subprocessesr   Z_core._synchronizationr   Z_core._tasksr   r   abcr   r   r   Zlowlevelr   r   Zstreams.bufferedr   rY   r   r   __annotations__r   r   rl   rV   r   r_   rE   rE   rE   rF   <module>   s@     

<
