яПН !A?hFJяПНяПНbяПНdZdZddlZddlZddlmZddlmZddlmZGdяПНd яПНяПНZGd яПНdeej яПНяПНZ GdяПНd ej яПНяПНZGdяПНdeej яПНяПНZGdяПНdeej яПНяПНZ GdяПНde яПНяПНZGdяПНdejяПНяПНZGdяПНdej яПНяПНZdS)zSynchronization primitives.)яПНLockяПНEventяПН ConditionяПН SemaphoreяПНBoundedSemaphoreяПНBarrierяПНNяПН)яПН exceptions)яПНmixins)яПНtaskscяПНяПНeZdZdяПНZdяПНZdS)яПН_ContextManagerMixincяПНяПН>KяПН|яПНяПНяПНяПНd{VяПНяПНdSяПНN)яПНacquireяПНяПНselfs яПН:/opt/alt/python-internal/lib64/python3.11/asyncio/locks.pyяПН __aenter__z_ContextManagerMixin.__aenter__s-яПНяПНяПНяПНяПНlяПНlяПНnяПНnяПНяПНяПНяПНяПНяПНяПНяПНяПНtяПНcяПНяПН2KяПН|яПНяПНяПНdSr)яПНrelease)rяПНexc_typeяПНexcяПНtbs rяПН __aexit__z_ContextManagerMixin.__aexit__sяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНrN)яПН__name__яПН __module__яПН__qualname__rrяПНrrrr s2яПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНrrcяПН@яПНяПНeZdZdZdяПНZяПНfdяПНZdяПНZdяПНZdяПНZdяПНZ яПНxZ S)raяПНPrimitive lock objects. A primitive lock is a synchronization primitive that is not owned by a particular coroutine when locked. A primitive lock is in one of two states, 'locked' or 'unlocked'. It is created in the unlocked state. It has two basic methods, acquire() and release(). When the state is unlocked, acquire() changes the state to locked and returns immediately. When the state is locked, acquire() blocks until a call to release() in another coroutine changes it to unlocked, then the acquire() call resets it to locked and returns. The release() method should only be called in the locked state; it changes the state to unlocked and returns immediately. If an attempt is made to release an unlocked lock, a RuntimeError will be raised. When more than one coroutine is blocked in acquire() waiting for the state to turn to unlocked, only one coroutine proceeds when a release() call resets the state to unlocked; first coroutine which is blocked in acquire() is being processed. acquire() is a coroutine and should be called with 'await'. Locks also support the asynchronous context management protocol. 'async with lock' statement should be used. Usage: lock = Lock() ... await lock.acquire() try: ... finally: lock.release() Context manager usage: lock = Lock() ... async with lock: ... Lock objects can be tested for locking state: if not lock.locked(): await lock.acquire() else: # lock is acquired ... cяПН"яПНd|_d|_dSяПНNF)яПН_waitersяПН_lockedrs rяПН__init__z Lock.__init__NsяПНяПНяПНяПН яПНяПНяПНяПНяПНrcяПНяПНяПНtяПНяПНяПНяПНяПН}|jrdnd}|jr|яПНdt |jяПНяПНяПНяПН}d|ddяПНяПНd|яПНdяПНSяПН NяПНlockedяПНunlockedяПН , waiters:яПН)яПНsuperяПН__repr__r%r$яПНlenяПНrяПНresяПНextraяПН __class__s яПНrr1z Lock.__repr__RspяПНяПНяПНяПНgяПНgяПНяПНяПН яПН яПНяПН яПНLяПН8яПНяПНяПНjяПНяПНяПН=яПН =яПНяПН<яПН<яПНяПНDяПНMяПН(:яПН(:яПН<яПН<яПНEяПН)яПН3яПНqяПНяПНtяПН9яПН)яПН)яПНяПН)яПН)яПН)яПН)rcяПНяПН|jS)z Return True if lock is acquired.)r%rs rr)zLock.lockedYs яПНяПНяПН|яПНrcяПНяПН(KяПН|js.|jяПНtdяПН|jDяПНяПНяПНяПНr d|_dS|jяПНtjяПНяПН|_|яПНяПНяПНяПНяПНяПН}|jяПН|яПНяПН |яПНd{VяПНяПН|jяПН|яПНяПНn#|jяПН|яПНяПНwxYwn/#tj $r|js|яПНяПНяПНяПНwxYwd|_dS)zяПНAcquire a lock. This method blocks until the lock is unlocked, then sets it to locked and returns True. Nc3яПН>KяПН|]}|яПНяПНяПНVяПНяПНdSrяПНяПН cancelledяПНяПН.0яПНws rяПН zLock.acquire..ds*яПНяПНяПНяПН9яПН9яПНaяПНAяПНKяПНKяПНMяПНMяПН9яПН9яПН9яПН9яПН9яПН9rT)r%r$яПНallяПНcollectionsяПНdequeяПН _get_loopяПН create_futureяПНappendяПНremover яПНCancelledErrorяПН_wake_up_firstяПНrяПНfuts rrzLock.acquire]s-яПНяПНяПНяПНяПНяПН яПН$яПН-яПН"7яПНяПН9яПН9яПН4яПН=яПН9яПН9яПН9яПН9яПН9яПН#8яПНяПНDяПНLяПНяПН4яПНяПН=яПН яПН'яПН-яПН/яПН/яПНDяПНMяПНяПНnяПНnяПНяПНяПН,яПН,яПН.яПН.яПНяПНяПН яПНяПНяПНSяПН!яПН!яПН!яПН яПН *яПНяПН яПН яПН яПН яПН яПН яПН яПНяПН яПН$яПН$яПНSяПН)яПН)яПН)яПН)яПНяПНяПН яПН$яПН$яПНSяПН)яПН)яПН)яПН)яПНяПНяПНяПН)яПНяПНяПН(яПН яПН яПН яПНяПН<яПН &яПНяПН#яПН#яПН%яПН%яПН%яПНяПН яПНяПНяПНяПН яПНяПНяПНяПНtsяПНB<яПН!CяПН<CяПНCяПН,DcяПНhяПН|jrd|_|яПНяПНяПНdStdяПНяПНяПН)aGRelease a lock. When the lock is locked, reset it to unlocked, and return. If any other coroutines are blocked waiting for the lock to become unlocked, allow exactly one of them to proceed. When invoked on an unlocked lock, a RuntimeError is raised. There is no return value. FzLock is not acquired.N)r%rHяПНRuntimeErrorrs rrzLock.release}s<яПНяПНяПН<яПН 8яПН яПНDяПНLяПНяПНяПНяПН!яПН!яПН!яПН!яПН!яПНяПН6яПН7яПН7яПН7rcяПНяПНяПН|jsdS tt|jяПНяПНяПНяПН}n#t$rYdSwxYw|яПНяПНяПНs|яПНdяПНяПНdSdS)z*Wake up the first waiter if it isn't done.NT)r$яПНnextяПНiterяПН StopIterationяПНdoneяПН set_resultrIs rrHzLock._wake_up_firstяПНsяПНяПНяПНяПН}яПН яПНяПНFяПН яПНяПНtяПНDяПНMяПН*яПН*яПН+яПН+яПНCяПНCяПНяПНяПН яПН яПН яПНяПНFяПНFяПН яПНяПНяПНяПНяПНxяПНxяПНzяПНzяПН !яПНяПНNяПНNяПН4яПН яПН яПН яПН яПН яПН !яПН !sяПН!-яПН ;яПН;)rrrяПН__doc__r&r1r)rrrHяПН __classcell__яПНr6s@rrrsяПНяПНяПНяПНяПНяПНяПНяПН3яПН3яПНjяПНяПНяПН*яПН*яПН*яПН*яПН*яПНяПНяПНяПНяПНяПНяПН@8яПН8яПН8яПН" !яПН !яПН !яПН !яПН !яПН !яПН !rrcяПН@яПНяПНeZdZdZdяПНZяПНfdяПНZdяПНZdяПНZdяПНZdяПНZ яПНxZ S)ra#Asynchronous equivalent to threading.Event. Class implementing event objects. An event manages a flag that can be set to true with the set() method and reset to false with the clear() method. The wait() method blocks until the flag is true. The flag is initially false. cяПНDяПНtjяПНяПН|_d|_dSr#)rArBr$яПН_valuers rr&zEvent.__init__яПНsяПНяПН#яПН)яПН+яПН+яПНяПН яПНяПНяПНяПНяПНrcяПНяПНяПНtяПНяПНяПНяПНяПН}|jrdnd}|jr|яПНdt |jяПНяПНяПНяПН}d|ddяПНяПНd|яПНdяПНS) NяПНsetяПНunsetr+r,r r-r.r/)r0r1rXr$r2r3s яПНrr1zEvent.__repr__яПНspяПНяПНяПНяПНgяПНgяПНяПНяПН яПН яПНяПНяПНяПН1яПНяПНяПН'яПНяПНяПН=яПН =яПНяПН<яПН<яПНяПНDяПНMяПН(:яПН(:яПН<яПН<яПНEяПН)яПН3яПНqяПНяПНtяПН9яПН)яПН)яПНяПН)яПН)яПН)яПН)rcяПНяПН|jS)z5Return True if and only if the internal flag is true.яПНrXrs rяПНis_setzEvent.is_setяПНs яПНяПНяПН{яПНrcяПНяПН|js:d|_|jD]-}|яПНяПНяПНs|яПНdяПНяПНяПН,dSdS)zяПНSet the internal flag to true. All coroutines waiting for it to become true are awakened. Coroutine that call wait() once the flag is true will not block at all. TN)rXr$rQrRrIs rrZz Event.setяПНs]яПНяПН яПН{яПН )яПНяПНDяПНKяПНяПН}яПН )яПН )яПНяПНяПНxяПНxяПНzяПНzяПН)яПНяПНNяПНNяПН4яПН(яПН(яПН(яПНяПН )яПН )яПН )яПН )rcяПНяПНd|_dS)zяПНReset the internal flag to false. Subsequently, coroutines calling wait() will block until set() is called to set the internal flag to true again.FNr]rs rяПНclearzEvent.clearяПНsяПНяПНяПНяПНяПНяПНrcяПНяПН"KяПН|jrdS|яПНяПНяПНяПНяПНяПН}|jяПН|яПНяПН |яПНd{VяПНяПН |jяПН|яПНяПНdS#|jяПН|яПНяПНwxYw)zяПНBlock until the internal flag is true. If the internal flag is true on entry, return True immediately. Otherwise, block until another coroutine calls set() to set the flag to true, then return True. TN)rXrCrDr$rErFrIs rяПНwaitz Event.waitяПНsяПНяПНяПНяПНяПНяПН;яПН яПНяПН4яПНяПНnяПНnяПНяПНяПН,яПН,яПН.яПН.яПНяПНяПН яПНяПНяПНSяПН!яПН!яПН!яПН &яПНяПНIяПНIяПНIяПНIяПНIяПНIяПНIяПНяПНяПНMяПН яПН яПНяПН%яПН%яПН%яПН%яПН%яПНяПНDяПНMяПН яПН яПНяПН%яПН%яПН%яПН%яПНяПНяПНsяПН A2яПН2B)rrrrSr&r1r^rZrarcrTrUs@rrrяПНsяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПН*яПН*яПН*яПН*яПН*яПНяПНяПНяПН )яПН )яПН )яПНяПНяПНяПН&яПН&яПН&яПН&яПН&яПН&яПН&rrcяПНDяПНяПНeZdZdZd dяПНZяПНfdяПНZdяПНZdяПНZddяПНZd яПНZ яПНxZ S)raAsynchronous equivalent to threading.Condition. This class implements condition variable objects. A condition variable allows one or more coroutines to wait until they are notified by another coroutine. A new Lock object is created and used as the underlying lock. NcяПНяПН|яПНtяПНяПН}||_|j|_|j|_|j|_tjяПНяПН|_dSr)rяПН_lockr)rrrArBr$)rяПНlocks rr&zCondition.__init__яПНsFяПНяПНяПН<яПНяПН6яПН6яПНDяПНяПНяПН яПНяПНkяПНяПНяПНяПН|яПНяПНяПНяПН|яПНяПНяПН#яПН)яПН+яПН+яПНяПН яПН яПН rcяПНяПНяПНяПНtяПНяПНяПНяПНяПН}|яПНяПНяПНrdnd}|jr|яПНdt |jяПНяПНяПНяПН}d|ddяПНяПНd|яПНdяПНSr()r0r1r)r$r2r3s яПНrr1zCondition.__repr__яПНsvяПНяПНяПНяПНgяПНgяПНяПНяПН яПН яПНяПН яПНKяПНKяПНMяПНMяПН9яПНяПНяПНzяПНяПНяПН=яПН =яПНяПН<яПН<яПНяПНDяПНMяПН(:яПН(:яПН<яПН<яПНEяПН)яПН3яПНqяПНяПНtяПН9яПН)яПН)яПНяПН)яПН)яПН)яПН)rcяПНяПНKяПН|яПНяПНяПНstdяПНяПНяПН|яПНяПНяПН |яПНяПНяПНяПНяПНяПН}|jяПН|яПНяПН |яПНd{VяПНяПН |jяПН|яПНяПНd} |яПНяПНяПНяПНd{VяПНяПНn#tj $rd}YnwxYwяПН4|rtj яПНdS#|jяПН|яПНяПНwxYw#d} |яПНяПНяПНяПНd{VяПНяПНn#tj $rd}YnwxYwяПН4|rtj яПНwxYw)aяПНWait until notified. If the calling coroutine has not acquired the lock when this method is called, a RuntimeError is raised. This method releases the underlying lock, and then blocks until it is awakened by a notify() or notify_all() call for the same condition variable in another coroutine. Once awakened, it re-acquires the lock and returns True. zcannot wait on un-acquired lockNFT)r)rLrrCrDr$rErFrr rG)rrJr;s rrczCondition.waitяПНsяПНяПНяПНяПНяПНяПН{яПН{яПН}яПН}яПН BяПНяПН@яПНAяПНAяПНAяПНяПНяПНяПНяПНяПНяПН 0яПНяПН.яПН.яПН"яПН"яПН0яПН0яПН2яПН2яПНCяПНяПНMяПН яПН яПНяПН%яПН%яПН%яПН *яПНяПН яПН яПН яПН яПН яПН яПН яПНяПНяПН яПН$яПН$яПНSяПН)яПН)яПН)яПНяПНIяПН %яПН%яПНяПН,яПН,яПН.яПН.яПН(яПН(яПН(яПН(яПН(яПН(яПН(яПНяПНяПН!яПН0яПН%яПН%яПН%яПН $яПНIяПНIяПНIяПН%яПНяПНяПНяПН %яПНяПН 0яПН яПН/яПН/яПН 0яПН 0яПНяПНяПН яПН$яПН$яПНSяПН)яПН)яПН)яПН)яПНяПНяПНяПНяПНяПНIяПН %яПН%яПНяПН,яПН,яПН.яПН.яПН(яПН(яПН(яПН(яПН(яПН(яПН(яПНяПНяПН!яПН0яПН%яПН%яПН%яПН $яПНIяПНIяПНIяПН%яПНяПНяПНяПН %яПНяПН 0яПН яПН/яПН/яПН/яПН/яПН/яПН/sZяПНADяПН<C&яПНDяПН#B>яПН>CяПНCяПН&DяПНDяПНEяПН D%яПН$EяПН%D9яПН6EяПН8D9яПН9EcяПНяПНnKяПН|яПНяПН}|s&|яПНяПНяПНяПНd{VяПНяПН|яПНяПН}|яПН&|S)zяПНWait until a predicate becomes true. The predicate should be a callable which result will be interpreted as a boolean value. The final predicate value is the return value. NяПНrc)rяПН predicateяПНresults rяПНwait_forzCondition.wait_forsWяПНяПНяПНяПНяПНяПНяПНяПНяПНяПН !яПНяПН)яПН)яПН+яПН+яПНяПНяПНяПНяПНяПНяПНяПНяПНYяПН[яПН[яПНFяПНяПН !яПНяПН rr cяПНяПНяПН|яПНяПНяПНstdяПНяПНяПНd}|jD]9}||krdS|яПНяПНяПНs|dz }|яПНdяПНяПНяПН:dS)aBy default, wake up one coroutine waiting on this condition, if any. If the calling coroutine has not acquired the lock when this method is called, a RuntimeError is raised. This method wakes up at most n of the coroutines waiting for the condition variable; it is a no-op if no coroutines are waiting. Note: an awakened coroutine does not actually return from its wait() call until it can reacquire the lock. Since notify() does not release the lock, its caller should. z!cannot notify on un-acquired lockrr FN)r)rLr$rQrR)rяПНnяПНidxrJs rяПНnotifyzCondition.notify*sяПНяПНяПНяПН{яПН{яПН}яПН}яПН DяПНяПНBяПНCяПНCяПНCяПНяПНяПНяПН=яПН &яПН &яПНCяПНяПНaяПНxяПНxяПНяПНяПНяПНяПН8яПН8яПН:яПН:яПН &яПНяПНqяПНяПНяПНяПНяПНяПНuяПН%яПН%яПН%яПНяПН &яПН &rcяПНTяПН|яПНt|jяПНяПНяПНяПНdS)aWake up all threads waiting on this condition. This method acts like notify(), but wakes up all waiting threads instead of one. If the calling thread has not acquired the lock when this method is called, a RuntimeError is raised. N)rrr2r$rs rяПН notify_allzCondition.notify_allBs&яПНяПН яПНяПНяПНCяПНяПН яПН&яПН&яПН'яПН'яПН'яПН'яПН'rrяПНr )rrrrSr&r1rcrnrrrtrTrUs@rrrяПНsяПНяПНяПНяПНяПНяПНяПНяПНяПНяПН ,яПН ,яПН ,яПН ,яПН*яПН*яПН*яПН*яПН*яПН#0яПН#0яПН#0яПНJяПНяПНяПН&яПН&яПН&яПН&яПН0(яПН(яПН(яПН(яПН(яПН(яПН(rrcяПНBяПНяПНeZdZdZd dяПНZяПНfdяПНZdяПНZdяПНZdяПНZdяПНZ яПНxZ S) raA Semaphore implementation. A semaphore manages an internal counter which is decremented by each acquire() call and incremented by each release() call. The counter can never go below zero; when acquire() finds that it is zero, it blocks, waiting until some other thread calls release(). Semaphores also support the context management protocol. The optional argument gives the initial value for the internal counter; it defaults to 1. If the value given is less than 0, ValueError is raised. r cяПНLяПН|dkrtdяПНяПНяПНd|_||_dS)Nrz$Semaphore initial value must be >= 0)яПН ValueErrorr$rX)rяПНvalues rr&zSemaphore.__init__Zs,яПНяПНяПН1яПН9яПН9яПНяПНCяПНDяПНDяПНDяПНяПНяПН яПНяПНяПНяПНяПНrcяПНяПНяПНяПНtяПНяПНяПНяПНяПН}|яПНяПНяПНrdn d|jяПНяПН}|jr|яПНdt|jяПНяПНяПНяПН}d|ddяПНяПНd|яПНdяПНS) Nr)zunlocked, value:r+r,r r-r.r/)r0r1r)rXr$r2r3s яПНrr1zSemaphore.__repr__`sяПНяПНяПНяПНяПНgяПНgяПНяПНяПН яПН яПНяПН яПНKяПНKяПНMяПНMяПНOяПНяПНяПН/OяПН$яПН+яПН/OяПН/OяПНяПНяПН=яПН =яПНяПН<яПН<яПНяПНDяПНMяПН(:яПН(:яПН<яПН<яПНEяПН)яПН3яПНqяПНяПНtяПН9яПН)яПН)яПНяПН)яПН)яПН)яПН)rcяПНXяПН|jdkptdяПН|jpdDяПНяПНяПНяПНS)z9Returns True if semaphore cannot be acquired immediately.rc3яПН@KяПН|]}|яПНяПНяПНVяПНяПНdSrr:r<s rr?z#Semaphore.locked..js-яПНяПНяПНяПНAяПНAяПНaяПНAяПНKяПНKяПНMяПНMяПН!яПНAяПНAяПНAяПНAяПНAяПНArr )rXяПНanyr$rs rr)zSemaphore.lockedgs9яПНяПНяПН{яПНaяПНяПНCяПНяПНAяПНAяПНDяПНMяПН,?яПНRяПНAяПНAяПНAяПНAяПНAяПН CrcяПНяПНtKяПН|яПНяПНяПНs|xjdzc_dS|jяПНtjяПНяПН|_|яПНяПНяПНяПНяПНяПН}|jяПН|яПНяПН |яПНd{VяПНяПН|jяПН|яПНяПНn#|jяПН|яПНяПНwxYwnL#tj $r:|яПНяПНяПНs$|xjdz c_|яПНяПНяПНяПНwxYw|jdkr|яПНяПНяПНdS)a5Acquire a semaphore. If the internal counter is larger than zero on entry, decrement it by one and return True immediately. If it is zero on entry, block, waiting until some other coroutine has called release() to make it larger than 0, and then return True. r TNr) r)rXr$rArBrCrDrErFr rGr;яПН _wake_up_nextrIs rrzSemaphore.acquirels@яПНяПНяПНяПНяПН{яПН{яПН}яПН}яПН яПНяПНKяПНKяПН1яПНяПНKяПНKяПНяПН4яПНяПН=яПН яПН'яПН-яПН/яПН/яПНDяПНMяПНяПНnяПНnяПНяПНяПН,яПН,яПН.яПН.яПНяПНяПН яПНяПНяПНSяПН!яПН!яПН!яПН яПН *яПНяПН яПН яПН яПН яПН яПН яПН яПНяПН яПН$яПН$яПНSяПН)яПН)яПН)яПН)яПНяПНяПН яПН$яПН$яПНSяПН)яПН)яПН)яПН)яПНяПНяПНяПН)яПНяПНяПН(яПН яПН яПН яПНяПН=яПН=яПН?яПН?яПН %яПНяПНяПНяПНqяПН яПНяПНяПНяПН"яПН"яПН$яПН$яПН$яПНяПН яПНяПНяПНяПНяПН;яПНяПН?яПН?яПНяПНяПНяПН яПН яПН яПНяПНtsяПН B-яПНC яПН-C яПН C яПН A DcяПНNяПН|xjdz c_|яПНяПНяПНdS)zяПНRelease a semaphore, incrementing the internal counter by one. When it was zero on entry and another coroutine is waiting for it to become larger than zero again, wake up that coroutine. r N)rXrrs rrzSemaphore.releaseяПНs,яПНяПН яПНяПНяПНqяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНrcяПНяПН|jsdS|jD]>}|яПНяПНяПНs(|xjdzc_|яПНdяПНяПНdSяПН?dS)z)Wake up the first waiter that isn't done.Nr T)r$rQrXrRrIs rrzSemaphore._wake_up_nextяПНsjяПНяПНяПН}яПН яПНяПНFяПНяПН=яПН яПН яПНCяПНяПН8яПН8яПН:яПН:яПН яПНяПНяПНяПНqяПН яПНяПНяПНяПНяПНяПНtяПН$яПН$яПН$яПНяПНяПНяПН яПН яПН rru)rrrrSr&r1r)rrrrTrUs@rrrKsяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПН*яПН*яПН*яПН*яПН*яПНCяПНCяПНCяПН "яПН"яПН"яПНHяПНяПНяПН яПН яПН яПН яПН яПН яПН rrcяПН.яПНяПНeZdZdZdяПНfdяПН ZяПНfdяПНZяПНxZS)rzяПНA bounded semaphore implementation. This raises ValueError in release() if it would increase the value above the initial value. r cяПНXяПНяПН||_tяПНяПНяПН|яПНяПНdSr)яПН_bound_valuer0r&)rryr6s яПНrr&zBoundedSemaphore.__init__яПНs)яПНяПНяПН!яПНяПНяПН яПНяПНяПНяПНяПНяПНяПНяПНяПНяПНrcяПНяПНяПН|j|jkrtdяПНяПНяПНtяПНяПНяПНяПНяПНdS)Nz(BoundedSemaphore released too many times)rXrяПНrxr0r)rr6s яПНrrzBoundedSemaphore.releaseяПНs<яПНяПНяПНяПН;яПН$яПН+яПН+яПН+яПНяПНGяПНHяПНHяПНHяПН яПНяПНяПНяПНяПНяПНяПНяПНяПНrru)rrrrSr&rrTrUs@rrrяПНs`яПНяПНяПНяПНяПНяПНяПНяПНяПН яПН яПН яПН яПН яПН яПНяПНяПНяПНяПНяПНяПНяПНяПНrrcяПНяПНeZdZdZdZdZdZdS)яПН _BarrierStateяПНfillingяПНdrainingяПН resettingяПНbrokenN)rrrяПНFILLINGяПНDRAININGяПН RESETTINGяПНBROKENr rrrяПНrяПНяПНs"яПНяПНяПНяПНяПНяПНяПНGяПНяПНHяПНяПНIяПН яПНFяПНFяПНFrrяПНcяПНяПНяПНeZdZdZdяПНZяПНfdяПНZdяПНZdяПНZdяПНZdяПНZ dяПНZ d яПНZd яПНZdяПНZ dяПНZed яПНяПНяПНZedяПНяПНяПНZedяПНяПНяПНZяПНxZS)ra Asyncio equivalent to threading.Barrier Implements a Barrier primitive. Useful for synchronizing a fixed number of tasks at known synchronization points. Tasks block on 'wait()' and are simultaneously awoken once they have all made their call. cяПНяПН|dkrtdяПНяПНяПНtяПНяПН|_||_tj|_d|_dS)z1Create a barrier, initialised to 'parties' tasks.r zparties must be > 0rN)rxrяПН_condяПН_partiesrяПНrяПНяПН_stateяПН_count)rяПНpartiess rr&zBarrier.__init__яПНsAяПНяПНяПНQяПН;яПН;яПНяПН2яПН3яПН3яПН3яПНяПН[яПН[яПНяПН яПНяПНяПН яПН#яПН+яПНяПНяПНяПНяПНяПНяПНrcяПНяПНяПНtяПНяПНяПНяПНяПН}|jjяПН}|js|d|jяПНd|jяПНяПНz }d|ddяПНяПНd|яПНdяПНS)Nr+яПН/r,r r-r.r/)r0r1rяПНryrяПНяПН n_waitingrяПНr3s яПНrr1zBarrier.__repr__яПНspяПНяПНяПНяПНgяПНgяПНяПНяПН яПН яПНяПНяПН;яПН$яПН&яПНяПНяПН{яПН BяПНяПНAяПН$яПН.яПНAяПНAяПН4яПН<яПНAяПНAяПНAяПНEяПН)яПН3яПНqяПНяПНtяПН9яПН)яПН)яПНяПН)яПН)яПН)яПН)rcяПНяПН:KяПН|яПНяПНяПНяПНd{VяПНяПНSrrkrs rrzBarrier.__aenter__яПНs(яПНяПНяПНяПНяПНYяПНYяПН[яПН[яПН яПН яПН яПН яПН яПН яПН rcяПНяПН KяПНdSrr )rяПНargss rrzBarrier.__aexit__яПНsяПНяПНяПНяПНяПНrcяПНяПНяПНKяПН|j4яПНd{VяПНяПН|яПНяПНяПНяПНd{VяПНяПН |j}|xjdz c_|dz|jkr|яПНяПНяПНяПНd{VяПНяПНn|яПНяПНяПНяПНd{VяПНяПН||xjdzc_|яПНяПНяПНcdddяПНяПНяПНd{VяПНяПНS#|xjdzc_|яПНяПНяПНwxYw#1яПНd{VяПНяПНswxYwYdS)zяПНWait for the barrier. When the specified number of tasks have started waiting, they are all simultaneously awoken. Returns an unique and individual index number from 0 to 'parties-1'. Nr )rяПНяПН_blockrяПНrяПНяПН_releaseяПН_waitяПН_exit)rяПНindexs rrczBarrier.waitяПНsяПНяПНяПНяПНяПНяПН:яПН яПН яПН яПН яПН яПН яПН яПН яПНяПН+яПН+яПН-яПН-яПНяПНяПНяПНяПНяПНяПНяПН яПНяПНяПНяПНяПНяПНяПНqяПН яПНяПНяПНяПН1яПН9яПНяПН яПН-яПН-яПНяПН-яПН-яПН/яПН/яПН)яПН)яПН)яПН)яПН)яПН)яПН)яПН)яПНяПН*яПН*яПН,яПН,яПН&яПН&яПН&яПН&яПН&яПН&яПН&яПНяПНяПНяПНяПНqяПН яПНяПНяПНяПН яПН яПНяПНяПНяПН яПН яПН яПН яПН яПН яПН яПН яПН яПН яПН яПН яПН яПН яПНяПНяПНяПНяПНqяПН яПНяПНяПНяПН яПН яПНяПНяПНяПНяПНяПНяПНяПН яПН яПН яПН яПН яПН яПН яПН яПН яПН яПНяПНяПНяПН яПН яПН яПН яПН яПН s)яПНC'яПНAB>яПН$C'яПН>&C$яПН$C'яПН' C1яПН4C1cяПНяПНяПНKяПНяПНjяПНяПНfdяПНяПНяПНяПНd{VяПНяПНяПНjtjurtjdяПНяПНяПНdS)NcяПНBяПНяПНяПНjtjtjfvSr)rяПНrяПНrяПНrяПНrsяПНrяПНz Barrier._block..яПНsяПНяПНяПНDяПНKяПНяПН&яПН яПН(?яПН(яПНяПНrzBarrier aborted)rяПНrnrяПНrяПНrяПНr яПНBrokenBarrierErrorrs`rrяПНzBarrier._blockяПНsяПНяПНяПНяПНяПНяПНяПНjяПН!яПН!яПН яПН яПН яПН яПН яПН яПН яПН яПН яПН яПН яПН яПН яПНяПН;яПН-яПН.яПН.яПН.яПНяПН/яПН0AяПНBяПНBяПНBяПН/яПН.rcяПНяПН^KяПНtj|_|jяПНяПНяПНdSr)rяПНrяПНrяПНrяПНrtrs rrяПНzBarrier._releases,яПНяПНяПНяПН $яПН,яПНяПНяПНяПН яПНяПНяПНяПНяПНяПНяПНrcяПНяПНяПНKяПНяПНjяПНяПНfdяПНяПНяПНяПНd{VяПНяПНяПНjtjtjfvrt jdяПНяПНяПНdS)NcяПН*яПНяПНяПНjtjuSr)rяПНrяПНrяПНrsяПНrrяПНzBarrier._wait..sяПНяПНяПН$яПН+яПН]яПН=RяПН*RяПНrzAbort or reset of barrier)rяПНrnrяПНrяПНrяПНrяПНr rяПНrs`rrяПНz Barrier._waitsnяПНяПНяПНяПНяПНяПНjяПН!яПН!яПН"RяПН"RяПН"RяПН"RяПНSяПНSяПНSяПНSяПНSяПНSяПНSяПНSяПНSяПНяПН;яПН=яПН/яПНяПН1HяПНIяПНIяПНIяПНяПН/яПН0KяПНLяПНLяПНLяПНJяПНIrcяПНяПН|jdkrK|jtjtjfvrtj|_|jяПНяПНяПНdSdS)Nr)rяПНrяПНrяПНrяПНrяПНrяПНrяПНrtrs rrяПНz Barrier._exitsUяПНяПНяПН;яПН!яПНяПНяПНяПН{яПН}яПН6яПН яПН8NяПНOяПНOяПНOяПН+яПН3яПНяПНяПНяПНJяПН!яПН!яПН#яПН#яПН#яПН#яПН#яПНяПНrcяПНяПН"KяПН|j4яПНd{VяПНяПН|jdkr%|jtjurtj|_ntj|_|jяПНяПНяПНdddяПНяПНяПНd{VяПНяПНdS#1яПНd{VяПНяПНswxYwYdS)zяПНReset the barrier to the initial state. Any tasks currently waiting will get the BrokenBarrier exception raised. Nr)rяПНrяПНrяПНrяПНrяПНrяПНrtrs rяПНresetz Barrier.reset#sяПНяПНяПНяПНяПН:яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПНяПН{яПНQяПНяПНяПНяПН;яПНmяПН&=яПН=яПН=яПН"/яПН"9яПНDяПНKяПНяПН+яПН3яПНяПНяПНяПНJяПН!яПН!яПН#яПН#яПН#яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПНяПНяПНяПН $яПН $яПН $яПН $яПН $яПН $sяПНAA>яПН> BяПНBcяПНяПНяПНKяПН|j4яПНd{VяПНяПНtj|_|jяПНяПНяПНdddяПНяПНяПНd{VяПНяПНdS#1яПНd{VяПНяПНswxYwYdS)zяПНPlace the barrier into a 'broken' state. Useful in case of error. Any currently waiting tasks and tasks attempting to 'wait()' will have BrokenBarrierError raised. N)rяПНrяПНrяПНrяПНrtrs rяПНabortz Barrier.abort2sяПНяПНяПНяПНяПНяПН:яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН'яПН.яПНDяПНKяПНяПНJяПН!яПН!яПН#яПН#яПН#яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПН $яПНяПНяПНяПН $яПН $яПН $яПН $яПН $яПН $sяПН+AяПН AяПНAcяПНяПН|jS)z8Return the number of tasks required to trip the barrier.)rяПНrs rrяПНzBarrier.parties<sяПНяПНяПН}яПНrcяПН:яПН|jtjur|jSdS)zrяПНsяПНяПНяПН!яПН!яПН*яПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНC!яПНC!яПНC!яПНC!яПНC!яПНяПНяПН!7яПНC!яПНC!яПНC!яПНL:&яПН:&яПН:&яПН:&яПН:&яПНFяПН"яПН:&яПН:&яПН:&яПНzm(яПНm(яПНm(яПНm(яПНm(яПН$яПНfяПН&<яПНm(яПНm(яПНm(яПН`WяПНWяПНWяПНWяПНWяПН$яПНfяПН&<яПНWяПНWяПНWяПНtяПНяПНяПНяПНяПНyяПНяПНяПНяПН$яПНяПНяПНяПНяПНDяПНIяПНяПНяПНяПНM3яПНM3яПНM3яПНM3яПНM3яПНfяПН$яПНM3яПНM3яПНM3яПНM3яПНM3r