o 0׾g,@sdZddlmZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z gd Z e d d \ZZd d ZGdddeZGdddeZGdddee ZGdddee ZddZe[erreZ de _eZ de _GdddeZGdddeZdS)a' Locking primitives. These include semaphores with arbitrary bounds (:class:`Semaphore` and its safer subclass :class:`BoundedSemaphore`) and a semaphore with infinite bounds (:class:`DummySemaphore`), along with a reentrant lock (:class:`RLock`) with the same API as :class:`threading.RLock`. )absolute_import)print_function) getcurrent) PURE_PYTHON)monkey) Semaphore)BoundedSemaphore)rrDummySemaphoreRLock)_threadthread) allocate_lock get_identcsfdd}|S)Ncs:|j|g|RWdS1swYdSN)_atomic)selfargsmethU/var/www/html/backend_erp/backend_erp_env/lib/python3.10/site-packages/gevent/lock.pym0$zatomic..mr)rrrrratomic/s rc@sHeZdZdZddZeddZeddZdd Zd d Z d d Z dS)_GILLock)_owned_thread_id_gilr_recursion_depthcCs d|_t|_t|_d|_dSNr)r_allocate_lockrrrrrrr__init__Ds z_GILLock.__init__cCsrt}|j|kr|jd7_dS |jz |jW|jn|jw|jdur0nq||_d|_dS)NT) _get_identrrrreleaseracquirer current_tidrrrr%Js     z_GILLock.acquirecCsTt}||jkrtd|||jpdf|jd8_|js(d|_|jdSdS)Nz;%s: Releasing lock not owned by you. You: 0x%x; Owner: 0x%xrr")r#r RuntimeErrorrrr$r&rrrr$_s  z_GILLock.releasecC |dSrr%r rrr __enter__n z_GILLock.__enter__cCr)rr$)rtvtbrrr__exit__qr,z_GILLock.__exit__cCs |jSr)rlockedr rrrr2ts z_GILLock.lockedN) __name__ __module__ __qualname__ __slots__r!rr%r$r+r1r2rrrrr6s    rcsheZdZdZfddZddZddZfdd Zfd d Zdfdd Z e Z dfdd Z Z S)_AtomicSemaphoreMixinrcs"t|_tt|j|i|dSr)r _lock_locksuperr7r!)rrkwargs __class__rrr!sz_AtomicSemaphoreMixin.__init__cC|jdSr)r8r%r rrr_acquire_lock_for_switch_inz1_AtomicSemaphoreMixin._acquire_lock_for_switch_incCr=r)r8r$r rrr_drop_lock_for_switch_outr?z/_AtomicSemaphoreMixin._drop_lock_for_switch_outc:|jtt||WdS1swYdSr)r8r9r7 _notify_links)rarrived_while_waitingr;rrrBrz#_AtomicSemaphoreMixin._notify_linkscs8|jtt|WdS1swYdSr)r8r9r7r$r r;rrr$s $z_AtomicSemaphoreMixin.releaseTNcs<|jtt|||WdS1swYdSr)r8r9r7r%rblockingtimeoutr;rrr%s$z_AtomicSemaphoreMixin.acquirecrAr)r8r9r7waitrrFr;rrrGrz_AtomicSemaphoreMixin.waitTNr) r3r4r5r6r!r>r@rBr$r% _py3k_acquirerG __classcell__rrr;rr7ws   r7c@seZdZejZdZdS)_AtomicSemaphorer8N)r3r4r5r__doc__r6rrrrrLsrLcs&eZdZejZdZfddZZS)_AtomicBoundedSemaphorerMcstt|Sr)r9rOr$r r;rrr$sz_AtomicBoundedSemaphore.release)r3r4r5rrNr6r$rKrrr;rrOsrOcCslttfD]/}|jd}|jdrd|jvsJ|j|jks JdD]}t||}t||}|j|_q"qdS)NrAtomic)r%r$rG)rLrO__mro__r3endswithrNgetattr)cbrc_methb_methrrr_fixup_docstringss     rYrrc@sneZdZdZdddZddZddZd d Zd d Zd dZ ddZ dddZ dddZ ddZ ddZdS)r ac DummySemaphore(value=None) -> DummySemaphore An object with the same API as :class:`Semaphore`, initialized with "infinite" initial value. None of its methods ever block. This can be used to parameterize on whether or not to actually guard access to a potentially limited resource. If the resource is actually limited, such as a fixed-size thread pool, use a real :class:`Semaphore`, but if the resource is unbounded, use an instance of this class. In that way none of the supporting code needs to change. Similarly, it can be used to parameterize on whether or not to enforce mutual exclusion to some underlying object. If the underlying object is known to be thread-safe itself mutual exclusion is not needed and a ``DummySemaphore`` can be used, but if that's not true, use a real ``Semaphore``. NcCdS)z .. versionchanged:: 1.1rc3 Accept and ignore a *value* argument for compatibility with Semaphore. Nr)rvaluerrrr!zDummySemaphore.__init__cCs d|jjS)Nz<%s>)r<r3r rrr__str__r,zDummySemaphore.__str__cCrZ)z>A DummySemaphore is never locked so this always returns False.Frr rrrr2zDummySemaphore.lockedcCrZ)z=A DummySemaphore is never locked so this always returns True.Trr rrrreadyr^zDummySemaphore.readycCrZ)z)Releasing a dummy semaphore does nothing.Nrr rrrr$r\zDummySemaphore.releasecCdSrrrcallbackrrrrawlinkr^zDummySemaphore.rawlinkcCr`rrrarrrunlinkzDummySemaphore.unlinkcCrZ)z1Waiting for a DummySemaphore returns immediately.r"rrHrrrrGr^zDummySemaphore.waitTcCrZ)z A DummySemaphore can always be acquired immediately so this always returns True and ignores its arguments. .. versionchanged:: 1.1a1 Always return *true*. TrrDrrrr%s zDummySemaphore.acquirecCr`rrr rrrr+ rezDummySemaphore.__enter__cCr`rr)rtypvalr0rrrr1rezDummySemaphore.__exit__rrI)r3r4r5rNr!r]r2r_r$rcrdrGr%r+r1rrrrr s    r c@s`eZdZdZdZdddZddZdd d Zd d Zd dZ ddZ ddZ ddZ ddZ dS)r a A mutex that can be acquired more than once by the same greenlet. A mutex can only be locked by one greenlet at a time. A single greenlet can `acquire` the mutex as many times as desired, though. Each call to `acquire` must be paired with a matching call to `release`. It is an error for a greenlet that has not acquired the mutex to release it. Instances are context managers. )_block_owner_count __weakref__NcCstd||_d|_d|_dS)zQ .. versionchanged:: 20.5.1 Add the ``hub`` argument. r"Nr)rrhrirj)rhubrrrr!(s  zRLock.__init__cCs d|jjt||j|j|jfS)Nz+<%s at 0x%x _block=%s _count=%r _owner=%r)>)r<r3idrhrjrir rrr__repr__1szRLock.__repr__TcCsDt}|j|ur|jd7_dS|j||}|r ||_d|_|S)z Acquire the mutex, blocking if *blocking* is true, for up to *timeout* seconds. .. versionchanged:: 1.5a4 Added the *timeout* parameter. :return: A boolean indicating whether the mutex was acquired. r")rrirjrhr%)rrErFmercrrrr%9s z RLock.acquirecCs|Srr*r rrrr+MszRLock.__enter__cCsL|jturtd|jtf|jd|_}|s$d|_|jdSdS)zz Release the mutex. Only the greenlet that originally acquired the mutex can release it. z6cannot release un-acquired lock. Owner: %r Current: %rr"N)rirr(rjrhr$)rcountrrrr$Ps z RLock.releasecCr)rr-)rrfr[r0rrrr1`r,zRLock.__exit__cCs"|\}}|j||_||_dSr)rhr%rjri)r count_ownerrqownerrrr_acquire_restorees  zRLock._acquire_restorecCs*|j}d|_|j}d|_|j||fSr)rjrirhr$)rrqrsrrr _release_saveks  zRLock._release_savecCs |jtuSr)rirr rrr _is_ownedsr,zRLock._is_ownedrrI)r3r4r5rNr6r!rnr%r+r$r1rtrurvrrrrr s   r N)rN __future__rr gevent.hubrgevent._compatrgeventrgevent._semaphorerr__all__ get_originalrr#robjectrr7rLrOrYr3r r rrrrs8       A&  N