Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/tornado/__pycache__/locks.cpython-39.pyc
Ðазад
a _�h�F � @ s� d dl Z d dlmZ d dlZd dlZd dlmZmZ d dlm Z m Z d dl m Z m Z mZmZmZ d dl Z e jr~d dl mZmZ g d�ZG dd � d e�ZG d d � d e�ZG d d � d e�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�Z dS )� N)�CancelledError)�gen�ioloop)�Future�"future_set_result_unless_cancelled)�Union�Optional�Type�Any� Awaitable)�Deque�Set)� Condition�Event� Semaphore�BoundedSemaphore�Lockc @ s, e Zd ZdZdd�dd�Zdd�dd�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....') N��returnc C s t �� | _d| _d S )Nr )� collections�deque�_waiters� _timeouts��self� r �}/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/tornado/locks.py�__init__* s z!_TimeoutGarbageCollector.__init__c C s: | j d7 _ | j dkr6d| _ t�dd� | jD ��| _d S )N� �d r c s s | ]}|� � s|V qd S �N)�done)�.0�wr r r � <genexpr>3 � 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 st e Zd ZdZdd�� fdd� Zed�dd�Zdeee j f e e d�d d �Z dedd �d d�Zdd�dd�Z� ZS )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:: from tornado import gen from tornado.ioloop import IOLoop 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()]) IOLoop.current().run_sync(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`. Nr c s t t| ��� tj�� | _d S r! )�superr r r �IOLoop�current�io_loopr �� __class__r r r r s zCondition.__init__c C s. d| j jf }| jr&|dt| j� 7 }|d S )Nz<%sz waiters[%s]�>)r1 r( r �len)r �resultr r r �__repr__v s zCondition.__repr__��timeoutr c sX t � ��j��� |rTdd���fdd� }tj�� � � �||����� �fdd�� �S )z�Wait for `.notify`. Returns a `.Future` that resolves ``True`` if the condition is notified, or ``False`` after a timeout. Nr c s �� � st�d� � �� d S �NF)r" r r' r �r �waiterr r � on_timeout� s z"Condition.wait.<locals>.on_timeoutc s � � ��S r! �Zremove_timeout��_�r/ �timeout_handler r �<lambda>� r& z Condition.wait.<locals>.<lambda>)r r �appendr r- r. � add_timeout�add_done_callback�r r7 r; r �r/ r r@ r: r �wait| s zCondition.waitr )�nr c C sL g }|r4| j r4| j �� }|�� s|d8 }|�|� q|D ]}t|d� q8dS )zWake ``n`` waiters.r TN)r �popleftr" rB r )r rH �waitersr: r r r �notify� s zCondition.notifyc C s | � t| j�� dS )zWake all waiters.N)rK r3 r r r r r � notify_all� s zCondition.notify_all)N)r )r( r) r* r+ r �strr5 r �float�datetime� timedeltar �boolrG �intrK rL � __classcell__r r r0 r r 6 s ; r c @ sv e Zd ZdZdd�dd�Zed�dd�Zed�dd �Zdd�d d �Z dd�d d �Z de e e jf ed d�dd�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:: from tornado import gen from tornado.ioloop import IOLoop 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()]) IOLoop.current().run_sync(runner) .. testoutput:: Waiting for event About to set the event Not waiting this time Done Nr c C s d| _ t� | _d S r8 )�_value�setr r r r r r � s zEvent.__init__c C s d| j j| �� rdndf S )Nz<%s %s>rU �clear)r1 r( �is_setr r r r r5 � s �zEvent.__repr__c C s | j S )z-Return ``True`` if the internal flag is true.�rT r r r r rW � s z Event.is_setc C s. | j s*d| _ | jD ]}|�� s|�d� qdS )z�Set the internal flag to ``True``. All waiters are awakened. Calling `.wait` once the flag is set will not block. TN)rT r r" � set_result)r �futr r r rU � s z Event.setc C s d| _ dS )zkReset the internal flag to ``False``. Calls to `.wait` will block until `.set` is called. FNrX r r r r rV � s z Event.clearr6 c sp t � � �jr� �d� � S �j�� � � ��fdd�� |du rD� S tj|� tfd�}|�� fdd�� |S dS )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�rZ r r r rA � r& z Event.wait.<locals>.<lambda>)Zquiet_exceptionsc s � � � s� �� S d S r! )r" �cancel)�tfr\ r r rA r& ) r rT rY r �addrD r Z with_timeoutr )r r7 Z timeout_futr )rZ r r rG � s � �z Event.wait)N)r( r) r* r+ r rM r5 rQ rW rU rV r rN rO rP r rG r r r r r � s ' r c @ sL e Zd ZdZedd�dd�Zdd�dd�Zd ee ee j dd �d 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. N)�objr c C s || _ d S r! )�_obj)r ra 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! )rb �release)r re rf rg r r r �__exit__ s z!_ReleasingContextManager.__exit__) r( r) r* r+ r r rc r � BaseException�types� TracebackTyperi r r r r r` s �r` c s� e Zd ZdZdedd�� fdd� Zed�� fdd � Zdd�d d �Zde e e j f e e d �d d�Zdd�dd�Zdee eej dd�dd�Zdd�dd�Zdee eej dd�dd�Z� ZS ) r aS 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 # Ensure reliable doctest output: resolve Futures one at a time. futures_q = deque([Future() for _ in range(3)]) 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) IOLoop.current().add_callback(simulator, list(futures_q)) def use_some_resource(): return futures_q.popleft() .. testcode:: semaphore from tornado import gen from tornado.ioloop import IOLoop 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)]) IOLoop.current().run_sync(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 t| ��� |dk r td��|| _d S )Nr z$semaphore initial value must be >= 0)r, r r � ValueErrorrT �r rn r0 r r r } s zSemaphore.__init__r c sT t t| ��� }| jdkr dn d�| j�}| jr@d�|t| j��}d�|dd� |�S )Nr �lockedzunlocked,value:{0}z{0},waiters:{1}z <{0} [{1}]>r ���)r, r r5 rT �formatr r3 )r �res�extrar0 r r r5 � s �zSemaphore.__repr__c C sJ | j d7 _ | jrF| j�� }|�� s| j d8 _ |�t| �� qFqdS )�*Increment the counter and wake one waiter.r N)rT r rI r" rY r` r9 r r r rh � s zSemaphore.releaser6 c s� t � ��jdkr.� jd8 _��t��� nN�j��� |r|dd���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 Nr c s" �� � s��t�� � � �� d S r! )r" Z set_exceptionr � TimeoutErrorr' r r9 r r r; � s z%Semaphore.acquire.<locals>.on_timeoutc s � � ��S r! r< r= r? r r rA � r& z#Semaphore.acquire.<locals>.<lambda>) r rT rY r` r rB r r- r. rC rD rE r rF r �acquire� s �zSemaphore.acquirec C s t d��d S )Nz0Use 'async with' instead of 'with' for Semaphore�� RuntimeErrorr r r r rc � s zSemaphore.__enter__rd )�typrn � tracebackr c C s | � � d S r! �rc )r r{ rn r| r r r ri � s zSemaphore.__exit__c � s | � � I d H d S r! �rx r r r r � __aenter__� s zSemaphore.__aenter__�r{ rn �tbr c � s | � � d S r! �rh �r r{ rn r� r r r � __aexit__� s zSemaphore.__aexit__)r )N)r( r) r* r+ rR r rM r5 rh r rN rO rP r r` rx rc r rj rk rl ri r r� rS r r r0 r r s* _ � � � �r c s< e Zd ZdZd edd�� fdd� Zdd�� 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 Nrm c s t t| �j|d� || _d S )N�rn )r, r r �_initial_valuerp r0 r r r � s zBoundedSemaphore.__init__r c s& | j | jkrtd��tt| ��� dS )rv z!Semaphore released too many timesN)rT r� ro r, r rh r r0 r r rh � s zBoundedSemaphore.release)r )r( r) r* r+ rR r rh rS r r r0 r r � s r c @ s� e Zd ZdZdd�dd�Zed�dd�Zdeee j f e e d�d d �Z dd�d d �Zdd�d d�Zdee eej dd�dd�Zdd�dd�Zdee eej dd�dd�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. Nr c 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>)r1 r( r� r r r r r5 s z Lock.__repr__r6 c C s | j �|�S )z�Attempt to lock. Returns an awaitable. Returns an awaitable, which raises `tornado.util.TimeoutError` after a timeout. )r� rx )r r7 r r r rx s z Lock.acquirec C s. z| j �� W n ty( td��Y n0 dS )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 rz r r r r rh s z Lock.releasec C s t d��d S )Nz+Use `async with` instead of `with` for Lockry r r r r rc & s zLock.__enter__rd r� c C s | � � d S r! r} r� r r r ri ) s z Lock.__exit__c � s | � � I d H d S r! r~ r r r r r 1 s zLock.__aenter__c � s | � � d S r! r� r� r r r r� 4 s zLock.__aexit__)N)r( r) r* r+ r rM r5 r rN rO rP r r` rx rh rc r rj rk rl ri r r� r r r r r � s* $ � � � �r ) r �concurrent.futuresr rO rk �tornador r Ztornado.concurrentr r �typingr r r r r � TYPE_CHECKINGr r �__all__�objectr r r r` r r r r r r r �<module> s$ kd 5
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка