+ V@ilC0^RIt^RIt^RIt^RIHtHt^RIHtHt^RI H t H t H t H t Ht^RI t ] P'd ^RI HtHt.ROt!R R 4t!R R]4t!RR4t!RR4t!RR]4t!RR ]4t!RR 4tR#)N)genioloop)Future"future_set_result_unless_cancelled)UnionOptionalTypeAny Awaitable)DequeSet ConditionEvent SemaphoreBoundedSemaphoreLockcHa]tRt^toRtV3RlRltV3RlRltRtVtR#)_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....') c<V^8dQhRR/#returnN)format __classdict__s"//usr/lib/python3/dist-packages/tornado/locks.py __annotate__%_TimeoutGarbageCollector.__annotate__)s$cH\P!4Vn^VnR#)rN) collectionsdeque_waiters _timeoutsselfs&r__init__!_TimeoutGarbageCollector.__init__)s#))+ rc<V^8dQhRR/#rr)rrs"rrr-sXX$XrcV;P^, unVP^d8d6^Vn\P!RVP44VnR#R#)c3T"TFqP4'dKVxK R#5iN)done).0ws& r <_TimeoutGarbageCollector._garbage_collect..2s-WAffhaas( (N)r$r!r"r#r%s&r_garbage_collect)_TimeoutGarbageCollector._garbage_collect-sD ! >>C DN'---W-WWDM r)r$r#N) __name__ __module__ __qualname____firstlineno____doc__r'r3__static_attributes____classdictcell__rs@rrrs XXrrcta]tRt^5toRtV3RlRltR V3RlRlltR V3RlRlltV3R lR ltR t Vt R#)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`. c <V^8dQhRS[/#rrstr)rrs"rrCondition.__annotate__qs#rcRVPP 2pVP'd$VR\VP4,, pVR,#)) __class__r5r#len)r&results& r__repr__Condition.__repr__qsDT^^,,-. === ns4=='99 9F|rNcp<V^8dQhRS[S[S[S[P3,,RS[S[,/#rtimeoutr)rrfloatdatetime timedeltar bool)rrs"rrrBws6eX-?-?&? @A 4rc aaaa\4oSPPS4V'dPRVV3Rllp\PP 4oSP W4oSPVV3Rl4S#)z|Wait for `.notify`. Returns a `.Future` that resolves ``True`` if the condition is notified, or ``False`` after a timeout. cV^8dQhRR/#rr)rs"rr$Condition.wait..__annotate__s ( ( (rcl<SP4'g \SR4SP4R#FN)r.rr3r&waitersr on_timeout"Condition.wait..on_timeouts${{}}6vuE%%'rc&<SPS4#r-remove_timeout_io_looptimeout_handles&r Condition.wait..sw/E/En/Ur)rr#appendrIOLoopcurrent add_timeoutadd_done_callbackr&rMrYr`rarXsf& @@@rwaitCondition.waitwsc V$  ( ( mm++-G$00EN  $ $%U V rc$<V^8dQhRS[RR/#)rnrNint)rrs"rrrBs = = =D =rc .pV'daVP'dOVPP4pVP4'dKLV^,pVPV4KhVFp\ VR4K R#)zWake ``n`` waiters.TN)r#popleftr.rdr)r&rmwaitersrXs&& rnotifyCondition.notifysXDMMM]]**,F;;==Qv&F .vt <rc<V^8dQhRR/#rr)rrs"rrrBs((D(rc NVP\VP44R#)zWake all waiters.N)rsrGr#r%s&r notify_allCondition.notify_alls C &'rrr-r+) r5r6r7r8r9rIrjrsrwr:r;r<s@rrr5s39v , = =((rca]tRt^toRtV3RlRltV3RlRltV3RlRltV3RlR ltV3R lR lt RV3R lRllt Rt Vt R #)ra6An 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 c<V^8dQhRR/#rr)rrs"rrEvent.__annotate__s$rc2RVn\4VnR#rV)_valuesetr#r%s&rr'Event.__init__s  rc <V^8dQhRS[/#r?r@)rrs"rrr|s  # rcRPVPPVP4'dR4#R4#)z<{} {}>rclear)rrFr5is_setr%s&rrIEvent.__repr__s< NN # #[[]]E  (/  rc <V^8dQhRS[/#r?)rQ)rrs"rrr|src VP#)z-Return ``True`` if the internal flag is true.r~r%s&rr Event.is_sets {{rc<V^8dQhRR/#rr)rrs"rrr|s ) )T )rc VP'gFRVnVPF,pVP4'dKVPR4K. R#R#)zsSet the internal flag to ``True``. All waiters are awakened. Calling `.wait` once the flag is set will not block. TN)r~r#r. set_result)r&futs& rr Event.sets> {{{DK}}xxzzNN4(%rc<V^8dQhRR/#rr)rrs"rrr|strc RVnR#)z[Reset the internal flag to ``False``. Calls to `.wait` will block until `.set` is called. FNrr%s&rr Event.clears  rNcn<V^8dQhRS[S[S[S[P3,,RS[R,/#)rrMrN)rrrNrOrPr )rrs"rrr|s6eX-?-?&? @A 4rc ,aa\4oSP'dSPR4S#SPP S4SP V3Rl4VfS#\ P!VS4pVP V3Rl4V#)zxBlock until the internal flag is true. Returns an awaitable, which raises `tornado.util.TimeoutError` after a timeout. Nc:<SPPV4#r-)r#remove)rr&s&rrbEvent.wait..s$--*>*>s*CrcT<SP4'gSP4#R#r-)r.cancel)tfrs&rrbrssxxzz3::<CtCr)rr~rr#addrhr with_timeout)r&rM timeout_futrsf& @rrj Event.waits~h ;;; NN4 J # CD ?J**7C8K  ) )C  r)r~r#r-) r5r6r7r8r9r'rIrrrrjr:r;r<s@rrrsL%N   ) )rcZa]tRtRtoRtV3RlRltV3RlRltV3RlRltR tVt R #) _ReleasingContextManagerizReleases a Lock or Semaphore at the end of a "with" statement. with (yield semaphore.acquire()): pass # Now semaphore.release() has been called. c$<V^8dQhRS[RR/#)robjrN)r )rrs"rr%_ReleasingContextManager.__annotate__ sCDrcWnR#r-_obj)r&rs&&rr'!_ReleasingContextManager.__init__ s rc<V^8dQhRR/#rr)rrs"rrrs  4 rcR#r-rr%s&r __enter__"_ReleasingContextManager.__enter__s rcb<V^8dQhRRRS[S[,RS[S[P,RR/#)rexc_typeOptional[Type[BaseException]]exc_valexc_tbrNr BaseExceptiontypes TracebackType)rrs"rrrsC1-(,,-   rc:VPP4R#r-)rrelease)r&rrrs&&&&r__exit__!_ReleasingContextManager.__exit__s rrN) r5r6r7r8r9r'rrr:r;r<s@rrrs(  rrcaa]tRtRtoRtRV3RlV3RllltV3RlV3RlltV3RlRltRV3R lR lltV3R lR lt V3R lRlt V3RlRlt V3RlRlt Rt VtV;t#)ria 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. c$<V^8dQhRS[RR/#rvaluerNrn)rrs"rrSemaphore.__annotate__sc$rcT<\SV`4V^8d \R4hWnR#)rz$semaphore initial value must be >= 0N)superr' ValueErrorr~r&rrFs&&rr'Semaphore.__init__s&  19CD D rc <V^8dQhRS[/#r?r@)rrs"rrrs**#*rc<\SV`4pVP^8XdRMRVP 2pVP'dV R\ VP4 2pRV^R RV R2#)rlockedzunlocked,value:z ,waiters:rDz [z]>)rrIr~r#rG)r&resextrarFs& rrISemaphore.__repr__skg  KK1,ODKK=2Q ===gYs4=='9&:;E3q9+Rwb))rc<V^8dQhRR/#rr)rrs"rrrsrc *V;P^, unVP'dhVPP4pVP4'dKDV;P^,unVP \ V44R#R#)*Increment the counter and wake one waiter.N)r~r#rqr.rrrWs& rrSemaphore.releasesb q mmm]]**,F;;== q !!":4"@Arcp<V^8dQhRS[S[S[S[P3,,RS[S[,/#rLrrrNrOrPr r)rrs"rrrs8eX-?-?&? @A + ,rc aaaa\4oSP^8d6S;P^,unSP\S44S#SPP S4V'dPRVV3Rllp\ PP4oSPW4oSPVV3Rl4S#)zDecrement the counter. Returns an awaitable. Block if the counter is zero and wait for a `.release`. The awaitable raises `.TimeoutError` after the deadline. cV^8dQhRR/#rr)rs"rr'Semaphore.acquire..__annotate__s,,D,rc<SP4'g%SP\P!44SP 4R#r-)r. set_exceptionr TimeoutErrorr3rWsrrY%Semaphore.acquire..on_timeouts1!;;==,,S-=-=-?@))+rc&<SPS4#r-r\r^s&rrb#Semaphore.acquire..sg44^Dr) rr~rrr#rdrrerfrgrhrisf& @@@racquireSemaphore.acquires ;;? KK1 K   6t< =  MM  (,, !--//1!(!4!4W!I((D rc<V^8dQhRR/#rr)rrs"rrrsOO4Orc\R4h)z0Use 'async with' instead of 'with' for Semaphore RuntimeErrorr%s&rrSemaphore.__enter__sMNNrcb<V^8dQhRRRS[S[,RS[S[P,RR/#)rtyprr tracebackrNr)rrs"rrrsC , &E//0   rc&VP4R#r-r)r&rrrs&&&&rrSemaphore.__exit__ rc<V^8dQhRR/#rr)rrs"rrr$rcB"VP4GRjxL R#L5ir-rr%s&r __aenter__Semaphore.__aenter__lln cb<V^8dQhRRRS[S[,RS[S[P,RR/#rrrrtbrNr)rrs"rrrC , & U(( )   rc."VP4R#5ir-rr&rrrs&&&&r __aexit__Semaphore.__aexit__ rryr-)r5r6r7r8r9r'rIrrrrrrr:r; __classcell__rFrs@@rrrscbH**"8OOrc^aa]tRtRtoRtRV3RlV3RllltV3RlV3RlltRtVtV;t #) ria&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. c$<V^8dQhRS[RR/#rrn)rrs"rrBoundedSemaphore.__annotate__s$$c$$$rc4<\SV`VR7WnR#)rN)rr'_initial_valuers&&rr'BoundedSemaphore.__init__s u%#rc<V^8dQhRR/#rr)rrs"rrrsrc p<VPVP8d \R4h\SV`4R#)rz!Semaphore released too many timesN)r~rrrr)r&rFs&rrBoundedSemaphore.releases+ ;;$-- -@A A r)rry) r5r6r7r8r9r'rr:r;rrs@@rrrs#$$rca]tRtRtoRtV3RlRltV3RlRltRV3RlR lltV3R lR ltV3R lR lt V3RlRlt V3RlRlt V3RlRlt Rt VtR#)riagA 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. c<V^8dQhRR/#rr)rrs"rrLock.__annotate__ s00$0rc(\^R7VnR#)r+rN)r_blockr%s&rr' Lock.__init__ s&Q/ rc <V^8dQhRS[/#r?r@)rrs"rrr sCC#CrcPRVPP RVP R2#)rDz _block=rE)rFr5r r%s&rrI Lock.__repr__ s&4>>**+8DKK=BBrNcp<V^8dQhRS[S[S[S[P3,,RS[S[,/#rLr)rrs"rrrs8,,eX-?-?&? @A, + ,,rc 8VPPV4#)zxAttempt to lock. Returns an awaitable. Returns an awaitable, which raises `tornado.util.TimeoutError` after a timeout. )r r)r&rMs&&rr Lock.acquires{{""7++rc<V^8dQhRR/#rr)rrs"rrrs 8 8 8rc pVPP4R# \d \R4hi;i)zrUnlock. The first coroutine in line waiting for `acquire` gets the lock. If not locked, raise a `RuntimeError`. zrelease unlocked lockN)r rrrr%s&rr Lock.releases2 8 KK   ! 867 7 8s5c<V^8dQhRR/#rr)rrs"rrr&sJJ4Jrc\R4h)z+Use `async with` instead of `with` for Lockrr%s&rrLock.__enter__&sHIIrcb<V^8dQhRRRS[S[,RS[S[P,RR/#rr)rrs"rrr)sC , & U(( )   rc&VP4R#r-rrs&&&&rr Lock.__exit__)rrc<V^8dQhRR/#rr)rrs"rrr1rrcB"VP4GRjxL R#L5ir-rr%s&rrLock.__aenter__1rrcb<V^8dQhRRRS[S[,RS[S[P,RR/#rr)rrs"rrr4rrc."VP4R#5ir-rrs&&&&rrLock.__aexit__4rr)r r-)r5r6r7r8r9r'rIrrrrrrr:r;r<s@rrrs_"H00CC,, 8 8JJr)rrrrr)r!rOrtornadorrtornado.concurrentrrtypingrrr r r TYPE_CHECKINGr r __all__rrrrrrrrrrr%s I88  ! IXX,f((f(RaaH0t(tny(UUr