a
    õ£BeÌC  ã                   @   sî   d dl Z d dlZd dlZd dlmZmZ d dlmZmZ d dl	m
Z
mZmZmZmZ d dl	Z	e	jrrd dl	mZmZ g d¢ZG dd„ deƒZG d	d
„ d
eƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZdS )é    N)ÚgenÚioloop)ÚFutureÚ"future_set_result_unless_cancelled)ÚUnionÚOptionalÚTypeÚAnyÚ	Awaitable)ÚDequeÚSet)Ú	ConditionÚEventÚ	SemaphoreÚBoundedSemaphoreÚLockc                   @   s,   e Zd ZdZddœdd„Zddœdd„ZdS )Ú_TimeoutGarbageCollectorzáBase class for objects that periodically clean up timed-out waiters.

    Avoids memory leak in a common pattern like:

        while True:
            yield condition.wait(short_timeout)
            print('looping....')
    N©Úreturnc                 C   s   t  ¡ | _d| _d S )Nr   )ÚcollectionsÚdequeÚ_waitersÚ	_timeouts©Úself© r   úP/home/yuhw/wc/wire-cell-python/wcpy/lib/python3.9/site-packages/tornado/locks.pyÚ__init__)   s    
z!_TimeoutGarbageCollector.__init__c                 C   s:   |  j d7  _ | j dkr6d| _ t dd„ | jD ƒ¡| _d S )Né   éd   r   c                 s   s   | ]}|  ¡ s|V  qd S ©N)Údone)Ú.0Úwr   r   r   Ú	<genexpr>2   ó    z<_TimeoutGarbageCollector._garbage_collect.<locals>.<genexpr>)r   r   r   r   r   r   r   r   Ú_garbage_collect-   s    
z)_TimeoutGarbageCollector._garbage_collect)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r&   r   r   r   r   r      s   	r   c                   @   sb   e Zd ZdZedœdd„Zdeeee	j
f  ee dœdd„Zdedd
œdd„Zddœdd„ZdS )r   a£  A condition allows one or more coroutines to wait until notified.

    Like a standard `threading.Condition`, but does not need an underlying lock
    that is acquired and released.

    With a `Condition`, coroutines can wait to be notified by other coroutines:

    .. testcode::

        import asyncio
        from tornado import gen
        from tornado.locks import Condition

        condition = Condition()

        async def waiter():
            print("I'll wait right here")
            await condition.wait()
            print("I'm done waiting")

        async def notifier():
            print("About to notify")
            condition.notify()
            print("Done notifying")

        async def runner():
            # Wait for waiter() and notifier() in parallel
            await gen.multi([waiter(), notifier()])

        asyncio.run(runner())

    .. testoutput::

        I'll wait right here
        About to notify
        Done notifying
        I'm done waiting

    `wait` takes an optional ``timeout`` argument, which is either an absolute
    timestamp::

        io_loop = IOLoop.current()

        # Wait up to 1 second for a notification.
        await condition.wait(timeout=io_loop.time() + 1)

    ...or a `datetime.timedelta` for a timeout relative to the current time::

        # Wait up to 1 second.
        await condition.wait(timeout=datetime.timedelta(seconds=1))

    The method returns False if there's no notification before the deadline.

    .. versionchanged:: 5.0
       Previously, waiters could be notified synchronously from within
       `notify`. Now, the notification will always be received on the
       next iteration of the `.IOLoop`.
    r   c                 C   s.   d| j jf }| jr&|dt| jƒ 7 }|d S )Nz<%sz waiters[%s]ú>)Ú	__class__r'   r   Úlen)r   Úresultr   r   r   Ú__repr__q   s    zCondition.__repr__N©Útimeoutr   c                    sX   t ƒ ‰ˆj ˆ¡ |rTddœ‡‡fdd„}tj ¡ ‰ ˆ  ||¡‰ˆ ‡ ‡fdd„¡ ˆS )z”Wait for `.notify`.

        Returns a `.Future` that resolves ``True`` if the condition is notified,
        or ``False`` after a timeout.
        Nr   c                      s   ˆ  ¡ stˆdƒ ˆ  ¡  d S ©NF)r!   r   r&   r   ©r   Úwaiterr   r   Ú
on_timeoutƒ   s    
z"Condition.wait.<locals>.on_timeoutc                    s
   ˆ   ˆ¡S r    ©Zremove_timeout©Ú_©Úio_loopÚtimeout_handler   r   Ú<lambda>Š   r%   z Condition.wait.<locals>.<lambda>)r   r   Úappendr   ÚIOLoopÚcurrentÚadd_timeoutÚadd_done_callback©r   r1   r5   r   ©r:   r   r;   r4   r   Úwaitw   s    
zCondition.waitr   )Únr   c                 C   sL   g }|r4| j r4| j  ¡ }| ¡ s|d8 }| |¡ q|D ]}t|dƒ q8dS )zWake ``n`` waiters.r   TN)r   Úpopleftr!   r=   r   )r   rE   Úwaitersr4   r   r   r   Únotify�   s    

zCondition.notifyc                 C   s   |   t| jƒ¡ dS )zWake all waiters.N)rH   r-   r   r   r   r   r   Ú
notify_all™   s    zCondition.notify_all)N)r   )r'   r(   r)   r*   Ústrr/   r   r   ÚfloatÚdatetimeÚ	timedeltar
   ÚboolrD   ÚintrH   rI   r   r   r   r   r   5   s   ; ÿþr   c                   @   sz   e Zd ZdZddœdd„Zedœdd„Zedœdd	„Zddœd
d„Z	ddœdd„Z
deeeejf  ed dœdd„ZdS )r   až  An event blocks coroutines until its internal flag is set to True.

    Similar to `threading.Event`.

    A coroutine can wait for an event to be set. Once it is set, calls to
    ``yield event.wait()`` will not block unless the event has been cleared:

    .. testcode::

        import asyncio
        from tornado import gen
        from tornado.locks import Event

        event = Event()

        async def waiter():
            print("Waiting for event")
            await event.wait()
            print("Not waiting this time")
            await event.wait()
            print("Done")

        async def setter():
            print("About to set the event")
            event.set()

        async def runner():
            await gen.multi([waiter(), setter()])

        asyncio.run(runner())

    .. testoutput::

        Waiting for event
        About to set the event
        Not waiting this time
        Done
    Nr   c                 C   s   d| _ tƒ | _d S r2   )Ú_valueÚsetr   r   r   r   r   r   Æ   s    zEvent.__init__c                 C   s   d| j j|  ¡ rdndf S )Nz<%s %s>rQ   Úclear)r,   r'   Úis_setr   r   r   r   r/   Ê   s    þzEvent.__repr__c                 C   s   | j S )z-Return ``True`` if the internal flag is true.©rP   r   r   r   r   rS   Ð   s    zEvent.is_setc                 C   s.   | j s*d| _ | jD ]}| ¡ s| d¡ qdS )zƒSet the internal flag to ``True``. All waiters are awakened.

        Calling `.wait` once the flag is set will not block.
        TN)rP   r   r!   Ú
set_result)r   Úfutr   r   r   rQ   Ô   s
    
z	Event.setc                 C   s
   d| _ dS )zkReset the internal flag to ``False``.

        Calls to `.wait` will block until `.set` is called.
        FNrT   r   r   r   r   rR   à   s    zEvent.clearr0   c                    sj   t ƒ ‰ ˆjrˆ  d¡ ˆ S ˆj ˆ ¡ ˆ  ‡fdd„¡ |du rDˆ S t |ˆ ¡}| ‡ fdd„¡ |S dS )z�Block until the internal flag is true.

        Returns an awaitable, which raises `tornado.util.TimeoutError` after a
        timeout.
        Nc                    s   ˆ j  | ¡S r    )r   Úremove©rV   r   r   r   r<   ô   r%   zEvent.wait.<locals>.<lambda>c                    s   ˆ   ¡ sˆ  ¡ S d S r    )r!   Úcancel)ÚtfrX   r   r   r<   ý   r%   )r   rP   rU   r   ÚaddrA   r   Zwith_timeout)r   r1   Ztimeout_futr   )rV   r   r   rD   ç   s    

ÿz
Event.wait)N)r'   r(   r)   r*   r   rJ   r/   rN   rS   rQ   rR   r   r   rK   rL   rM   r
   rD   r   r   r   r   r   ž   s   ' ÿþr   c                   @   sL   e Zd ZdZeddœdd„Zddœdd„Zd	ee ee	j
 dd
œdd„ZdS )Ú_ReleasingContextManagerz§Releases a Lock or Semaphore at the end of a "with" statement.

    with (yield semaphore.acquire()):
        pass

    # Now semaphore.release() has been called.
    N)Úobjr   c                 C   s
   || _ d S r    )Ú_obj)r   r]   r   r   r   r     s    z!_ReleasingContextManager.__init__r   c                 C   s   d S r    r   r   r   r   r   Ú	__enter__  s    z"_ReleasingContextManager.__enter__úOptional[Type[BaseException]])Úexc_typeÚexc_valÚexc_tbr   c                 C   s   | j  ¡  d S r    )r^   Úrelease)r   ra   rb   rc   r   r   r   Ú__exit__  s    z!_ReleasingContextManager.__exit__)r'   r(   r)   r*   r	   r   r_   r   ÚBaseExceptionÚtypesÚTracebackTypere   r   r   r   r   r\     s   ûr\   c                       sÆ   e Zd ZdZdeddœ‡ fdd„Zedœ‡ fdd	„Zddœd
d„Zde	e
eejf  ee dœdd„Zddœdd„Zde	e e	ej ddœdd„Zddœdd„Zde	e e	ej ddœdd„Z‡  ZS )r   aÎ  A lock that can be acquired a fixed number of times before blocking.

    A Semaphore manages a counter representing the number of `.release` calls
    minus the number of `.acquire` calls, plus an initial value. The `.acquire`
    method blocks if necessary until it can return without making the counter
    negative.

    Semaphores limit access to a shared resource. To allow access for two
    workers at a time:

    .. testsetup:: semaphore

       from collections import deque

       from tornado import gen
       from tornado.ioloop import IOLoop
       from tornado.concurrent import Future

       inited = False

       async def simulator(futures):
           for f in futures:
               # simulate the asynchronous passage of time
               await gen.sleep(0)
               await gen.sleep(0)
               f.set_result(None)

       def use_some_resource():
           global inited
           global futures_q
           if not inited:
               inited = True
               # Ensure reliable doctest output: resolve Futures one at a time.
               futures_q = deque([Future() for _ in range(3)])
               IOLoop.current().add_callback(simulator, list(futures_q))

           return futures_q.popleft()

    .. testcode:: semaphore

        import asyncio
        from tornado import gen
        from tornado.locks import Semaphore

        sem = Semaphore(2)

        async def worker(worker_id):
            await sem.acquire()
            try:
                print("Worker %d is working" % worker_id)
                await use_some_resource()
            finally:
                print("Worker %d is done" % worker_id)
                sem.release()

        async def runner():
            # Join all workers.
            await gen.multi([worker(i) for i in range(3)])

        asyncio.run(runner())

    .. testoutput:: semaphore

        Worker 0 is working
        Worker 1 is working
        Worker 0 is done
        Worker 2 is working
        Worker 1 is done
        Worker 2 is done

    Workers 0 and 1 are allowed to run concurrently, but worker 2 waits until
    the semaphore has been released once, by worker 0.

    The semaphore can be used as an async context manager::

        async def worker(worker_id):
            async with sem:
                print("Worker %d is working" % worker_id)
                await use_some_resource()

            # Now the semaphore has been released.
            print("Worker %d is done" % worker_id)

    For compatibility with older versions of Python, `.acquire` is a
    context manager, so ``worker`` could also be written as::

        @gen.coroutine
        def worker(worker_id):
            with (yield sem.acquire()):
                print("Worker %d is working" % worker_id)
                yield use_some_resource()

            # Now the semaphore has been released.
            print("Worker %d is done" % worker_id)

    .. versionchanged:: 4.3
       Added ``async with`` support in Python 3.5.

    r   N©Úvaluer   c                    s$   t ƒ  ¡  |dk rtdƒ‚|| _d S )Nr   z$semaphore initial value must be >= 0)Úsuperr   Ú
ValueErrorrP   ©r   rj   ©r,   r   r   r     s    
zSemaphore.__init__r   c                    sP   t ƒ  ¡ }| jdkrdn
d | j¡}| jr<d |t| jƒ¡}d |dd… |¡S )Nr   Úlockedzunlocked,value:{0}z{0},waiters:{1}z<{0} [{1}]>r   éÿÿÿÿ)rk   r/   rP   Úformatr   r-   )r   ÚresÚextrarn   r   r   r/   †  s    
ÿzSemaphore.__repr__c                 C   sJ   |  j d7  _ | jrF| j ¡ }| ¡ s|  j d8  _ | t| ƒ¡ qFqdS )ú*Increment the counter and wake one waiter.r   N)rP   r   rF   r!   rU   r\   r3   r   r   r   rd   �  s    
zSemaphore.releaser0   c                    s€   t ƒ ‰ˆjdkr.ˆ jd8  _ˆ tˆƒ¡ nNˆj ˆ¡ |r|ddœ‡‡fdd„}tj ¡ ‰ ˆ  	||¡‰ˆ 
‡ ‡fdd„¡ ˆS )	z·Decrement the counter. Returns an awaitable.

        Block if the counter is zero and wait for a `.release`. The awaitable
        raises `.TimeoutError` after the deadline.
        r   r   Nr   c                      s"   ˆ  ¡ sˆ t ¡ ¡ ˆ  ¡  d S r    )r!   Úset_exceptionr   ÚTimeoutErrorr&   r   r3   r   r   r5   °  s    z%Semaphore.acquire.<locals>.on_timeoutc                    s
   ˆ   ˆ¡S r    r6   r7   r9   r   r   r<   ¸  r%   z#Semaphore.acquire.<locals>.<lambda>)r   rP   rU   r\   r   r=   r   r>   r?   r@   rA   rB   r   rC   r   Úacquire   s    

ÿzSemaphore.acquirec                 C   s   t dƒ‚d S )Nz0Use 'async with' instead of 'with' for Semaphore©ÚRuntimeErrorr   r   r   r   r_   ¼  s    zSemaphore.__enter__r`   )Útyprj   Ú	tracebackr   c                 C   s   |   ¡  d S r    ©r_   )r   rz   rj   r{   r   r   r   re   ¿  s    zSemaphore.__exit__c                 Ã   s   |   ¡ I d H  d S r    ©rw   r   r   r   r   Ú
__aenter__Ç  s    zSemaphore.__aenter__©rz   rj   Útbr   c                 Ã   s   |   ¡  d S r    ©rd   ©r   rz   rj   r€   r   r   r   Ú	__aexit__Ê  s    zSemaphore.__aexit__)r   )N)r'   r(   r)   r*   rO   r   rJ   r/   rd   r   r   rK   rL   rM   r
   r\   rw   r_   rf   rg   rh   re   r~   rƒ   Ú__classcell__r   r   rn   r   r     s*   d	 ÿþûûr   c                       s<   e Zd ZdZd
eddœ‡ fdd„Zddœ‡ fdd	„Z‡  ZS )r   a:  A semaphore that prevents release() being called too many times.

    If `.release` would increment the semaphore's value past the initial
    value, it raises `ValueError`. Semaphores are mostly used to guard
    resources with limited capacity, so a semaphore released too many times
    is a sign of a bug.
    r   Nri   c                    s   t ƒ j|d� || _d S )N©rj   )rk   r   Ú_initial_valuerm   rn   r   r   r   Ü  s    zBoundedSemaphore.__init__r   c                    s"   | j | jkrtdƒ‚tƒ  ¡  dS )rt   z!Semaphore released too many timesN)rP   r†   rl   rk   rd   r   rn   r   r   rd   à  s    zBoundedSemaphore.release)r   )r'   r(   r)   r*   rO   r   rd   r„   r   r   rn   r   r   Ó  s   r   c                   @   s¶   e Zd ZdZddœdd„Zedœdd„Zdeee	e
jf  ee dœd	d
„Zddœdd„Zddœdd„Zdee eej ddœdd„Zddœdd„Zdee eej ddœdd„ZdS )r   aÏ  A lock for coroutines.

    A Lock begins unlocked, and `acquire` locks it immediately. While it is
    locked, a coroutine that yields `acquire` waits until another coroutine
    calls `release`.

    Releasing an unlocked lock raises `RuntimeError`.

    A Lock can be used as an async context manager with the ``async
    with`` statement:

    >>> from tornado import locks
    >>> lock = locks.Lock()
    >>>
    >>> async def f():
    ...    async with lock:
    ...        # Do something holding the lock.
    ...        pass
    ...
    ...    # Now the lock is released.

    For compatibility with older versions of Python, the `.acquire`
    method asynchronously returns a regular context manager:

    >>> async def f2():
    ...    with (yield lock.acquire()):
    ...        # Do something holding the lock.
    ...        pass
    ...
    ...    # Now the lock is released.

    .. versionchanged:: 4.3
       Added ``async with`` support in Python 3.5.

    Nr   c                 C   s   t dd�| _d S )Nr   r…   )r   Ú_blockr   r   r   r   r     s    zLock.__init__c                 C   s   d| j j| jf S )Nz<%s _block=%s>)r,   r'   r‡   r   r   r   r   r/     s    zLock.__repr__r0   c                 C   s   | j  |¡S )z�Attempt to lock. Returns an awaitable.

        Returns an awaitable, which raises `tornado.util.TimeoutError` after a
        timeout.
        )r‡   rw   )r   r1   r   r   r   rw     s    zLock.acquirec                 C   s.   z| j  ¡  W n ty(   tdƒ‚Y n0 dS )zŠUnlock.

        The first coroutine in line waiting for `acquire` gets the lock.

        If not locked, raise a `RuntimeError`.
        zrelease unlocked lockN)r‡   rd   rl   ry   r   r   r   r   rd     s    zLock.releasec                 C   s   t dƒ‚d S )Nz+Use `async with` instead of `with` for Lockrx   r   r   r   r   r_   (  s    zLock.__enter__r`   r   c                 C   s   |   ¡  d S r    r|   r‚   r   r   r   re   +  s    zLock.__exit__c                 Ã   s   |   ¡ I d H  d S r    r}   r   r   r   r   r~   3  s    zLock.__aenter__c                 Ã   s   |   ¡  d S r    r�   r‚   r   r   r   rƒ   6  s    zLock.__aexit__)N)r'   r(   r)   r*   r   rJ   r/   r   r   rK   rL   rM   r
   r\   rw   rd   r_   rf   rg   rh   re   r~   rƒ   r   r   r   r   r   ç  s*   $ ÿþ
ûûr   )r   rL   rg   Útornador   r   Ztornado.concurrentr   r   Útypingr   r   r   r	   r
   ÚTYPE_CHECKINGr   r   Ú__all__Úobjectr   r   r   r\   r   r   r   r   r   r   r   Ú<module>   s"   id :