
    ,h                       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	 d dl
mZ d dlmZmZmZ ddlmZmZ dd	lmZ dd
lmZ ddlmZ ej2                  dk\  r	d dlmZmZ nd dlmZmZ dZded<   d Zded<   dZ ded<   dZ!ded<   dZ" ed      Z# ed      Z$ eed      d      Z% ee   d      Z& G d d      Z'd dZ(dd	 	 	 	 	 	 	 d!dZ)d"dZ*y)#    )annotationsN)deque)Callable)dedent)AnyFinalTypeVar   )current_time	to_thread)BrokenWorkerIntepreter)CapacityLimiter)RunVar)      )TypeVarTupleUnpack   r   UNBOUNDFMT_UNPICKLEDFMT_PICKLED   DEFAULT_CPU_COUNT   T_RetvalPosArgsTWorker_available_workers_default_interpreter_limiterc                      e Zd ZU  e ed      dd      ZdZded<   dZded	<   d
ed<   d
ed<   ddZ	ddZ
	 	 	 	 	 	 ddZ	 	 	 	 	 	 	 	 ddZy)r   a  
        import _interpqueues as queues
        import _interpreters as interpreters
        from pickle import loads, dumps, HIGHEST_PROTOCOL

        item = queues.get(queue_id)[0]
        try:
            func, args = loads(item)
            retval = func(*args)
        except BaseException as exc:
            is_exception = True
            retval = exc
        else:
            is_exception = False

        try:
            queues.put(queue_id, (retval, is_exception), FMT_UNPICKLED, UNBOUND)
        except interpreters.NotShareableError:
            retval = dumps(retval, HIGHEST_PROTOCOL)
            queues.put(queue_id, (retval, is_exception), FMT_PICKLED, UNBOUND)
        z<string>execr   float	last_usedFbool_initializedint_interpreter_id	_queue_idc                    dd l }dd l}|j                         | _        |j                  dt        t
              | _        d| _        |j                  | j                  | j                  t        t        t
        d       y )Nr   r   T)queue_idr   r   r   )
_interpqueues_interpreterscreater'   r   r   r(   r%   set___main___attrsr   selfqueuesinterpreterss      V/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/anyio/to_interpreter.py
initializezWorker.initializeF   sa    &,+224q-A ''   NN*!."		
    c                    dd l }dd l}| j                  r7|j                  | j                         |j                  | j
                         y y )Nr   )r+   r,   r%   destroyr'   r(   r/   s      r3   r7   zWorker.destroyW   s:    &,  !5!56NN4>>* r5   c                   dd l }dd l}| j                  s| j                          t	        j
                  ||ft        j                        }|j                  | j                  |t        t               |j                  | j                  | j                        x}rt        |      |j                  | j                        d d \  \  }}}	|	t        k(  rt	        j                   |      }||fS )Nr   r   )r+   r,   r%   r4   pickledumpsHIGHEST_PROTOCOLputr(   r   r   r!   r'   	_run_funcr   getloads)
r0   funcargsr1   r2   payloadexc_inforesis_exceptionfmts
             r3   _callzWorker._call_   s    
 	',  OO,,d|V-D-DE

4>>7KA $(()=)=t~~NN8N(22#)::dnn#=bq#A lS+,,s#CL  r5   c                v   K   t        j                  | j                  |||       d {   \  }}|r||S 7 w)Nlimiter)r   run_syncrG   )r0   r@   rA   rJ   resultrE   s         r3   callzWorker.callx   sF      &/%7%7JJ	&
  
 L 
s   '979N)returnNone)r@   Callable[..., T_Retval]rA   
tuple[Any]rN   ztuple[Any, bool])r@   rP   rA   rQ   rJ   r   rN   r   )__name__
__module____qualname__compiler   r=   r#   __annotations__r%   r4   r7   rG   rM    r5   r3   r   r   %   s      	* 	/I4 IuL$N
"+!%! ! 
	!2%  !	
 
r5   c                R    | D ]  }|j                           | j                          y )N)r7   clear)workersworkers     r3   _stop_workersr\      s&      MMOr5   rI   c               ,  K   t         j                  dk  rt        d      |
t               }	 t        j                         }|4 d{    	 |j                         }ddd      d{    	 j                  | ||       d{   t!               }|rT||d   j"                  z
  t$        k  rn:t'        j(                  |j+                         j,                  |       d{    |rTt!               |_        |j/                  |       S # t        $ r= t               }t        j                  |       t        j                  t        |       Y w xY w7 # t        $ r t               }Y w xY w7 # 1 d{  7  sw Y   xY w7 7 # t!               }|rU||d   j"                  z
  t$        k  rn;t'        j(                  |j+                         j,                  |       d{  7   |rUt!               _        |j/                  |       w xY ww)aF  
    Call the given function with the given arguments in a subinterpreter.

    If the ``cancellable`` option is enabled and the task waiting for its completion is
    cancelled, the call will still run its course but its return value (or any raised
    exception) will be ignored.

    .. warning:: This feature is **experimental**. The upstream interpreter API has not
        yet been finalized or thoroughly tested, so don't rely on this for anything
        mission critical.

    :param func: a callable
    :param args: positional arguments for the callable
    :param limiter: capacity limiter to use to limit the total amount of subinterpreters
        running (if omitted, the default limiter is used)
    :return: the result of the call
    :raises BrokenWorkerIntepreter: if there's an internal error in a subinterpreter

    )r      z,subinterpreters require at least Python 3.13Nr   rI   )sysversion_infoRuntimeError#current_default_interpreter_limiter_idle_workersr>   LookupErrorr   setatexitregisterr\   pop
IndexErrorr   rM   r   r#   MAX_WORKER_IDLE_TIMEr   rK   popleftr7   append)r@   rJ   rA   idle_workersr[   nows         r3   rK   rK      s    0 7"IJJ575$((*   	!%%'F $[[tW55 n\!_...2FF$$\%9%9%;%C%CWUUU	  (>F#/  5w,'|45
  	XF	    6 V n\!_...2FF$$\%9%9%;%C%CWUUU	  (>F#s   +HD
 HE	HE3EH)E0*H/F F	F 	AH!F"H)!H
AEHEHE-)E3,E--E30H3F9E<:FH	F HAH'G*(H0!HHc                     	 t         j                         S # t        $ r? t        t	        j
                         xs t              } t         j                  |        | cY S w xY w)z
    Return the capacity limiter that is used by default to limit the number of
    concurrently running subinterpreters.

    Defaults to the number of CPU cores.

    :return: a capacity limiter object

    )r   r>   rd   r   os	cpu_countr   re   rI   s    r3   rb   rb      sN    +//11 !",,."E4EF$((1s    AAA)rZ   zdeque[Worker]rN   rO   )r@   z&Callable[[Unpack[PosArgsT]], T_Retval]rA   zUnpack[PosArgsT]rJ   zCapacityLimiter | NonerN   r   )rN   r   )+
__future__r   rf   rp   r9   r_   collectionsr   collections.abcr   textwrapr   typingr   r   r	    r   r   _core._exceptionsr   _core._synchronizationr   lowlevelr   r`   r   r   typing_extensionsr   rV   r   r   r   rj   r   r   rc   r   r   r\   rK   rb   rW   r5   r3   <module>r|      s    "  	  
  $  & & % 5 3 w++6 u U  5   :
#'uX'(<=6vo67UV b bJ '+7$
07$7$ $7$ 	7$tr5   