o 'h(@sdZddlmZddlZddlZddlmZmZddlm Z m Z m Z e Z GdddZGdd d ZGd d d eeZ Gd d d eeZdS)zLock and Condition classes vendored from https://github.com/python/cpython/blob/main/Lib/asyncio/locks.py to port 3.13 fixes to older versions of Python. Can be removed once we drop Python 3.12 support.) annotationsN)events exceptions)Any CoroutineOptionalc@seZdZdZdddZdS)_LoopBoundMixinNreturnrcCsbt}|jdur#t|jdur||_Wdn1swY||jur/t|d|S)Nz# is bound to a different event loop)r_get_running_loop_loop _global_lock RuntimeError)selflooprQ/var/www/html/olx_land/venv/lib/python3.10/site-packages/pymongo/_asyncio_lock.py _get_loops   z_LoopBoundMixin._get_loop)r r)__name__ __module__ __qualname__r rrrrrrsrc@s eZdZd ddZd d d Zd S)_ContextManagerMixinr Nonecs|IdHdSN)acquirerrrr __aenter__!sz_ContextManagerMixin.__aenter__exc_typerexctbcs|dSr)release)rrrrrrr __aexit__'s z_ContextManagerMixin.__aexit__Nr r)rrrrrrr r)rrrrr rrrrr s rcsTeZdZdZdddZdfdd Zdd d Zdd d ZdddZdddZ Z S)Locka5Primitive lock objects. A primitive lock is a synchronization primitive that is not owned by a particular task 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 task 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 task is blocked in acquire() waiting for the state to turn to unlocked, only one task proceeds when a release() call resets the state to unlocked; successive release() calls will unblock tasks in FIFO order. 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 ... r rcCsd|_d|_dS)NF)_waiters_lockedrrrr__init___s z Lock.__init__strcsLt}|jr dnd}|jr|dt|j}d|ddd|dS Nlockedunlockedz , waiters:<z [z]>)super__repr__r$r#lenrresextra __class__rrr.cs z Lock.__repr__boolcCs|jS)z Return True if lock is acquired.)r$rrrrr(jsz Lock.lockedc s|js|jdustdd|jDrd|_dS|jdur"t|_|}|j|zz |IdHW|j|n|j|wWnt j yU|jsT| wd|_dS)zAcquire a lock. This method blocks until the lock is unlocked, then sets it to locked and returns True. Ncss|]}|VqdSr) cancelled).0wrrr wszLock.acquire..T) r$r#all collectionsdequer create_futureappendremoverCancelledError_wake_up_firstrfutrrrrns(       z Lock.acquirecCs |jr d|_|dStd)aBRelease a lock. When the lock is locked, reset it to unlocked, and return. If any other tasks 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 acquiredN)r$rAr rrrrrs  z Lock.releasecCsL|jsdSz tt|j}Wn tyYdSw|s$|ddSdS)z*Ensure that the first waiter will wake up.NT)r#nextiter StopIterationdone set_resultrBrrrrAs zLock._wake_up_firstr!r r&r r5) rrr__doc__r%r.r(rrrA __classcell__rrr3rr"+s 3   &r"csbeZdZdZddddZdfd d Zd d dZd!ddZd"d#ddZd#ddZ d$ddZ Z S)% ConditionaAsynchronous equivalent to threading.Condition. This class implements condition variable objects. A condition variable allows one or more tasks to wait until they are notified by another task. A new Lock object is created and used as the underlying lock. NlockOptional[Lock]r rcCs:|durt}||_|j|_|j|_|j|_t|_dSr)r"_lockr(rrr;r<r#)rrNrrrr%szCondition.__init__r&csNt}|r dnd}|jr|dt|j}d|ddd|dSr')r-r.r(r#r/r0r3rrr.s zCondition.__repr__r5cs6|s td|}|zzzK|j|z=|IdHW|j|Wd} z |IdHWnt j yJ}z|}WYd}~nd}~wwq,|durVz|d}wWdS|j|wd} z |IdHWnt j y}z|}WYd}~nd}~wwqc|durz|d}wwt y| dw)a&Wait until notified. If the calling task 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 task. Once awakened, it re-acquires the lock and returns True. This method may return spuriously, which is why the caller should always re-check the state and be prepared to wait() again. zcannot wait on un-acquired lockNTr+) r(r rr=rr#r>r?rrr@ BaseException_notify)rrCerrerrrwaits\     zCondition.wait predicaterrcs(|}|s|IdH|}|r|S)aWait until a predicate becomes true. The predicate should be a callable whose result will be interpreted as a boolean value. The method will repeatedly wait() until it evaluates to true. The final predicate value is the return value. N)rU)rrVresultrrrwait_forszCondition.wait_forr+nintcCs|std||dS)aBy default, wake up one task waiting on this condition, if any. If the calling task has not acquired the lock when this method is called, a RuntimeError is raised. This method wakes up n of the tasks waiting for the condition variable; if fewer than n are waiting, they are all awoken. Note: an awakened task 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 lockN)r(r rR)rrYrrrnotifys zCondition.notifycCs<d}|jD]}||krdS|s|d7}|dqdS)Nrr+F)r#rGrH)rrYidxrCrrrrR%s  zCondition._notifycCs|t|jdS)aWake up all tasks waiting on this condition. This method acts like notify(), but wakes up all waiting tasks instead of one. If the calling task has not acquired the lock when this method is called, a RuntimeError is raised. N)r[r/r#rrrr notify_all/szCondition.notify_allr)rNrOr rrIrJ)rVrr r)r+)rYrZr rr!) rrrrKr%r.rUrXr[rRr]rLrrr3rrMs   7   rM)rK __future__rr; threadingasynciorrtypingrrrr"r rrrMrrrrs