File manager - Edit - /usr/local/CyberCP/lib/python3.10/site-packages/tornado/__pycache__/locks.cpython-310.pyc
Back
o �h�C � @ s� d dl Z d dlZd dlZd dlmZmZ d dlmZmZ d dl m Z m Z m Z m Z mZ d dl Z e jr9d dl mZmZ g d�ZG dd� de�ZG d d � d e�ZG d d � d e�ZG d d� de�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )� N)�gen�ioloop)�Future�"future_set_result_unless_cancelled)�Union�Optional�Type�Any� Awaitable)�Deque�Set)� Condition�Event� Semaphore�BoundedSemaphore�Lockc @ s$ e Zd ZdZddd�Zddd�ZdS ) �_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....') �returnNc C s t �� | _d| _d S )Nr )� collections�deque�_waiters� _timeouts��self� r �@/usr/local/CyberCP/lib/python3.10/site-packages/tornado/locks.py�__init__) s z!_TimeoutGarbageCollector.__init__c C s> | j d7 _ | j dkr d| _ t�dd� | jD ��| _d S d S )N� �d r c s s � | ] }|� � s|V qd S �N)�done)�.0�wr r r � <genexpr>2 s � z<_TimeoutGarbageCollector._garbage_collect.<locals>.<genexpr>)r r r r r r r r �_garbage_collect- s �z)_TimeoutGarbageCollector._garbage_collect�r N)�__name__� __module__� __qualname__�__doc__r r$ r r r r r s r c @ sd e Zd ZdZdefdd�Z ddeeee j f de e fdd�Z dd eddfd d �Zdd d�ZdS )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 jf }| jr|dt| j� 7 }|d S )Nz<%sz waiters[%s]�>)� __class__r& r �len)r �resultr r r �__repr__q s zCondition.__repr__N�timeoutc sT t � ��j��� |r(d��fdd� }tj�� � � �||����� �fdd�� �S )z�Wait for `.notify`. Returns a `.Future` that resolves ``True`` if the condition is notified, or ``False`` after a timeout. r Nc s �� � s t�d� � �� d S �NF)r r r$ r �r �waiterr r � on_timeout� s z"Condition.wait.<locals>.on_timeoutc � � � ��S r ��remove_timeout��_��io_loop�timeout_handler r �<lambda>� � z Condition.wait.<locals>.<lambda>r% )r r �appendr �IOLoop�current� add_timeout�add_done_callback�r r/ r3 r �r: r r; r2 r �waitw s zCondition.waitr �nc C sT g }|r | j r | j �� }|�� s|d8 }|�|� |r | j s|D ]}t|d� q dS )zWake ``n`` waiters.r TN)r �popleftr r> r )r rF �waitersr2 r r r �notify� s � �zCondition.notifyc C s | � t| j�� dS )zWake all waiters.N)rI r, r r r r r � notify_all� s zCondition.notify_allr �r r% )r& r' r( r) �strr. r r �float�datetime� timedeltar �boolrE �intrI rJ r r r r r 5 s ;�� � r c @ sr e Zd ZdZddd�Zdefdd�Zdefdd �Zdd d �Z dd d �Z dde e e ejf ded fdd�ZdS )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 r Nc C s d| _ t� | _d S r0 )�_value�setr r r r r r � s zEvent.__init__c C s d| j j| �� r df S df S )Nz<%s %s>rS �clear)r+ r& �is_setr r r r r. � s ��zEvent.__repr__c C s | j S )z-Return ``True`` if the internal flag is true.�rR r r r r rU � s z Event.is_setc C s2 | j sd| _ | jD ] }|�� s|�d� q dS dS )z�Set the internal flag to ``True``. All waiters are awakened. Calling `.wait` once the flag is set will not block. TN)rR r r � set_result)r �futr r r rS � s ��z Event.setc C s d| _ dS )zkReset the internal flag to ``False``. Calls to `.wait` will block until `.set` is called. FNrV r r r r rT � s z Event.clearr/ c sf t � � �jr � �d� � S �j�� � � ��fdd�� |du r"� S t�|� �}|�� fdd�� |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�rX r r r r< � s z Event.wait.<locals>.<lambda>c s � � � s� �� S d S r )r �cancel)�tfrZ r r r< � s )r rR rW r �addrB r � with_timeout)r r/ � timeout_futr )rX r r rE � s �z Event.waitr% r )r& r' r( r) r rL r. rP rU rS rT r r rM rN rO r rE r r r r r � s ' ���r c @ sP e Zd ZdZdeddfdd�Zddd�Zd d d ee d ee j ddfd d�Z dS )�_ReleasingContextManagerz�Releases a Lock or Semaphore at the end of a "with" statement. with (yield semaphore.acquire()): pass # Now semaphore.release() has been called. �objr Nc C s || _ d S r )�_obj)r ra r r r r s z!_ReleasingContextManager.__init__c C s d S r r r r r r � __enter__ s z"_ReleasingContextManager.__enter__�exc_type� Optional[Type[BaseException]]�exc_val�exc_tbc C s | j �� d S r )rb �release)r rd rf rg r r r �__exit__ s z!_ReleasingContextManager.__exit__r% ) r& r' r( r) r r rc r � BaseException�types� TracebackTyperi r r r r r` s ����r` c s� e Zd ZdZddeddf� fdd� Zdef� fdd � Zd d d �Z d d e e e e j f dee fd d�Zd dd�Zddde e de ej ddfdd�Zd dd�Zddde e de ej ddfdd�Z� ZS ) 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 �valuer Nc s$ t � �� |dk r td��|| _d S )Nr z$semaphore initial value must be >= 0)�superr � ValueErrorrR �r rm �r+ r r r s zSemaphore.__init__c sP t � �� }| jdkr dnd�| j�}| jr d�|t| j��}d�|dd� |�S )Nr �lockedzunlocked,value:{0}z{0},waiters:{1}z <{0} [{1}]>r ���)rn r. rR �formatr r, )r �res�extrarq r r r. � s �zSemaphore.__repr__c C sT | j d7 _ | jr(| j�� }|�� s#| j d8 _ |�t| �� dS | js dS dS )�*Increment the counter and wake one waiter.r N)rR r rG r rW r` r1 r r r rh � s �zSemaphore.releaser/ c s~ t � ��jdkr� jd8 _��t��� �S �j��� |r=d ��fdd� }tj�� � � � ||���� � �fdd�� �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 r Nc s" �� � s ��t�� � � �� d S r )r � set_exceptionr � TimeoutErrorr$ r r1 r r r3 � s z%Semaphore.acquire.<locals>.on_timeoutc r4 r r5 r7 r9 r r r< � r= z#Semaphore.acquire.<locals>.<lambda>r% ) r rR rW r` r r> r r? r@ rA rB rC r rD r �acquire� s � �zSemaphore.acquirec C � t d��)Nz0Use 'async with' instead of 'with' for Semaphore�� RuntimeErrorr r r r rc � � zSemaphore.__enter__�typre � tracebackc C � | � � d S r �rc )r r rm r� r r r ri � � zSemaphore.__exit__c � � �| � � I d H d S r �rz r r r r � __aenter__� � �zSemaphore.__aenter__�tbc � � �| � � d S r �rh �r r rm r� r r r � __aexit__� � � zSemaphore.__aexit__rK r% r )r& r' r( r) rQ r rL r. rh r r rM rN rO r r` rz rc rj rk rl ri r� r� � __classcell__r r rq r r s> d �� � ��� � ����r c s: e Zd ZdZd deddf� fdd� Zd � fdd � Z� ZS ) 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 rm r Nc s t � j|d� || _d S )N�rm )rn r �_initial_valuerp rq r r r � s zBoundedSemaphore.__init__c s" | j | jkr td��t� �� dS )rw z!Semaphore released too many timesN)rR r� ro rn rh r rq r r rh � s zBoundedSemaphore.releaserK r% )r& r' r( r) rQ r rh r� r r rq r r � s r c @ s� e Zd ZdZddd�Zdefdd�Z ddeee e j f de e fd d �Zdd d �Zdd d�Zdddee deej ddfdd�Zddd�Zdddee deej ddfdd�ZdS )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. r Nc C s t dd�| _d S )Nr r� )r �_blockr r r r r s z Lock.__init__c C s d| j j| jf S )Nz<%s _block=%s>)r+ r& r� r r r r r. s z Lock.__repr__r/ c C s | j �|�S )z�Attempt to lock. Returns an awaitable. Returns an awaitable, which raises `tornado.util.TimeoutError` after a timeout. )r� rz )r r/ r r r rz s z Lock.acquirec C s( z| j �� W dS ty td��w )z�Unlock. The first coroutine in line waiting for `acquire` gets the lock. If not locked, raise a `RuntimeError`. zrelease unlocked lockN)r� rh ro r} r r r r rh s �z Lock.releasec C r{ )Nz+Use `async with` instead of `with` for Lockr| r r r r rc ( r~ zLock.__enter__r re rm r� c C r� r r� r� r r r ri + r� z Lock.__exit__c � r� r r� r r r r r� 3 r� zLock.__aenter__c � r� r r� r� r r r r� 6 r� zLock.__aexit__r% r )r& r' r( r) r rL r. r r rM rN rO r r` rz rh rc rj rk rl ri r� r� r r r r r � s> $�� � ��� � ����r )r rN rk �tornador r �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$ id :
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings