MhlCDddlZddlZddlZddlmZmZddlmZmZddl m Z m Z m Z m Z mZddl Z e jrddl mZmZgdZGddZGd d eZGd d ZGd dZGddeZGddeZGddZdS)N)genioloop)Future"future_set_result_unless_cancelled)UnionOptionalTypeAny Awaitable)DequeSet) ConditionEvent SemaphoreBoundedSemaphoreLockc"eZdZdZddZddZdS)_TimeoutGarbageCollectorzBase 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....') returnNcDtj|_d|_dS)Nr) collectionsdeque_waiters _timeoutsselfs M/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/tornado/locks.py__init__z!_TimeoutGarbageCollector.__init__)s#)++ c|xjdz c_|jdkr1d|_tjd|jD|_dSdS)Ndrc3BK|]}||VdSN)done).0ws r z<_TimeoutGarbageCollector._garbage_collect..2s/-W-WAaffhh-Wa-W-W-W-W-W-Wr)rrrrrs r_garbage_collectz)_TimeoutGarbageCollector._garbage_collect-sU ! >C  DN'--W-W-W-W-WWWDMMM rrN)__name__ __module__ __qualname____doc__rr)rrrrsLXXXXXXrrc~eZdZdZdefdZ d deeee j fde e fdZ d deddfd Zd d ZdS)raA 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`. rcld|jj}|jr|dt|jzz }|dzS)N) __class__r+rlen)rresults r__repr__zCondition.__repr__qsA.T^,.. = : ns4='9'99 9F|rNtimeoutc tj|rTdfd }tj||fdS)zWait for `.notify`. Returns a `.Future` that resolves ``True`` if the condition is notified, or ``False`` after a timeout. rNcxstddSNF)r%rr)rwaitersr on_timeoutz"Condition.wait..on_timeouts<{{}}F6vuEEE%%'''''rc.Sr$remove_timeout_io_looptimeout_handles rz Condition.wait..sw/E/En/U/Urr*)rrappendrIOLoopcurrent add_timeoutadd_done_callbackrr8r>rDrEr=s` @@@rwaitzCondition.waitws V$$$  W ( ( ( ( ( ( ( m++--G$00*EEN  $ $%U%U%U%U%U V V V rr!ncg}|rW|jrP|j}|s|dz}|||r|jP|D]}t |ddS)zWake ``n`` waiters.r!TN)rpopleftr%rGr)rrNwaitersr=s rnotifyzCondition.notifys 'DM ']**,,F;;== 'Qv&&&  'DM '  = =F .vt < < < < = =rcT|t|jdS)zWake all waiters.N)rRr5rrs r notify_allzCondition.notify_alls$ C &&'''''rr$r!r*)r+r,r-r.strr7rrfloatdatetime timedeltar boolrMintrRrTr/rrrr5s99v#EIeX-?&? @A 4, = = =D = = = =((((((rrceZdZdZd dZdefdZdefdZd dZ d dZ d d e e e ejfdedfd ZdS) raAn 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 rNc:d|_t|_dSr;)_valuesetrrs rrzEvent.__init__s  rcnd|jj|rdndS)Nz<{} {}>r_clear)formatr4r+is_setrs rr7zEvent.__repr__s6 N #[[]] /EE   rc|jS)z-Return ``True`` if the internal flag is true.r^rs rrcz Event.is_sets {rc|js:d|_|jD]-}|s|d,dSdS)zSet the internal flag to ``True``. All waiters are awakened. Calling `.wait` once the flag is set will not block. TN)r^rr% set_result)rfuts rr_z Event.sets] { )DK} ) )xxzz)NN4(((  ) ) ) )rcd|_dS)zkReset the internal flag to ``False``. Calls to `.wait` will block until `.set` is called. FNrers rraz Event.clears  rr8c(tjrdSjfd|St j|}|fd|S)zBlock until the internal flag is true. Returns an awaitable, which raises `tornado.util.TimeoutError` after a timeout. Nc8j|Sr$)rremove)rhrs rrFzEvent.wait..s$-*>*>s*C*CrcXsndSr$)r%cancel)tfrhs rrFzEvent.wait..s sxxzzC3::<<= 0)superr ValueErrorr^rrr4s rrzSemaphore.__init__s<  199CDD D rct}|jdkrdn d|j}|jr|dt |j}d|ddd|d S) Nrlockedzunlocked,value:z ,waiters:r2r!z [z]>)rr7r^rr5)rresextrar4s rr7zSemaphore.__repr__sgg   K1,,2QDK2Q2Q = <;;s4='9'9;;E)3qt9))))))rc|xjdz c_|jrj|j}|s4|xjdzc_|t |dS|jhdSdS)*Increment the counter and wake one waiter.r!N)r^rrPr%rgrtr<s rrzSemaphore.releases q m ]**,,F;;==  q !!":4"@"@AAAm     rr8ctjdkr3xjdzc_tnpj|rTdfd }t j || fdS)zDecrement the counter. Returns an awaitable. Block if the counter is zero and wait for a `.release`. The awaitable raises `.TimeoutError` after the deadline. rr!rNcs&tjdSr$)r% set_exceptionr TimeoutErrorr)r<srr>z%Semaphore.acquire..on_timeoutsI!;;==A,,S-=-?-?@@@))+++++rc.Sr$r@rBs rrFz#Semaphore.acquire..sg44^DDrr*) rr^rgrtrrGrrHrIrJrKrLs` @@@racquirezSemaphore.acquires ;?? KK1 KK   6t<< = = = = M  ( ( ( ,,,,,,, !-//11!(!4!4Wj!I!I((DDDDD rc td)Nz0Use 'async with' instead of 'with' for Semaphore RuntimeErrorrs rryzSemaphore.__enter__sMNNNrtypr{ tracebackc.|dSr$ry)rrrrs rrzSemaphore.__exit__ rc>K|d{VdSr$rrs r __aenter__zSemaphore.__aenter__,llnnrtbc2K|dSr$rrrrrs r __aexit__zSemaphore.__aexit__ rrUr*r$)r+r,r-r.r[rrVr7rrrrWrXrYr rtrryrrrrrr __classcell__r4s@rrrsbbHc$*#******$EIeX-?&? @A + ,8OOOO , &E/0    , & U( )   rrc:eZdZdZddeddffd Zd fd ZxZS) ra: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!rrNcZt|||_dS)Nr)rr_initial_valuers rrzBoundedSemaphore.__init__s, u%%%#rc|j|jkrtdtdS)rz!Semaphore released too many timesN)r^rrrr)rr4s rrzBoundedSemaphore.releases< ;$- - -@AA A rrUr*)r+r,r-r.r[rrrrs@rrrsx$$c$$$$$$$$rrceZdZdZddZdefdZ ddeee e j fde e fdZddZdd Zd d d eed eejddfdZddZd d d eed eejddfdZdS)raA 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. rNc0td|_dS)Nr!r)r_blockrs rrz Lock.__init__ s&Q/// rc2d|jjd|jdS)Nr2z _block=r3)r4r+rrs rr7z Lock.__repr__ s"B4>*BBDKBBBBrr8c6|j|S)zAttempt to lock. Returns an awaitable. Returns an awaitable, which raises `tornado.util.TimeoutError` after a timeout. )rr)rr8s rrz Lock.acquires{""7+++rct |jdS#t$rtdwxYw)zUnlock. The first coroutine in line waiting for `acquire` gets the lock. If not locked, raise a `RuntimeError`. zrelease unlocked lockN)rrrrrs rrz Lock.releasesK 8 K   ! ! ! ! ! 8 8 8677 7 8s7c td)Nz+Use `async with` instead of `with` for Lockrrs rryzLock.__enter__&sHIIIrrr{rrc.|dSr$rrs rrz Lock.__exit__)rrc>K|d{VdSr$rrs rrzLock.__aenter__1rrc2K|dSr$rrs rrzLock.__aexit__4rrr*r$)r+r,r-r.rrVr7rrrWrXrYr rtrrryrrrrrrr/rrrrsi""H0000C#CCCCEI,,eX-?&? @A, + ,,,,, 8 8 8 8JJJJ , & U( )    , & U( )   rr)rrXrtornadorrtornado.concurrentrrtypingrrr r r TYPE_CHECKINGr r __all__rrrrtrrrr/rrrs  IIIIIIII88888888888888  "!!!!!!!! I I IXXXXXXXX,f(f(f(f(f((f(f(f(RaaaaaaaaH0ttttt(tttny(UUUUUUUUUUr