jB<dZddlmZgdZddlZddlZddlZddlZddlm Z ddl m Z m Z m Z mZmZddlmZmZmZmZmZmZmZmZddlmZdd lmZmZe r dd lmZm Z dd l!m"Z"dd l#m$Z$dd l%m&Z&ddl'm(Z(edZ)edZ*GddZ+GddZ,ddgZ-y)zIAsync wrapper around :class:`SoftReadWriteLock` for use with ``asyncio``.) annotations)asynciozfilelock._asynczfilelock._error functools threadingN)asynccontextmanager) TYPE_CHECKINGFinalLiteral ParamSpecTypeVar)_TASKS_THREAD_ID_BackendOutcome _capture_call _drain_future_future_result_raise_cancelled_error_task_owners_for_wait_until_done)Timeout)SoftReadWriteLock_lost_hold_error)AsyncGeneratorCallable)futures) TracebackType)AcquireReturnProxy)LeaseCompromise_P_Rc eZdZdZ dddddddddd ddZed dZed!d Zed"d Zed#d Z ed$d Z ed%d Z ed&dZ e d'ddd(dZe d'ddd(dZ d'dd d)dZ d'dd d)dZd*dZddd+dZd,dZd,dZd"dZd,dZd-dZ d.dZy)/AsyncSoftReadWriteLocka Async wrapper around :class:`SoftReadWriteLock` for ``asyncio`` applications. The sync class's blocking filesystem operations run on a thread pool via ``loop.run_in_executor()``. Each ``asyncio`` task owns its own hold. Tasks share a read lock, and a task asking for the write lock waits until the other holders release, with waiting writers ahead of new readers. Upgrading or downgrading a held lock raises :class:`RuntimeError`. The underlying :class:`SoftReadWriteLock` handles forks, the heartbeat, and stale eviction. Singleton wrappers share one sync lock and its task holds, and closing one ends only the holds taken through it. :param lock_file: path to the lock file; the protocol directory lives next to it as ``.rw`` :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately on contention :param is_singleton: if ``True``, reuse existing :class:`SoftReadWriteLock` instances per resolved path :param heartbeat_interval: seconds between heartbeat refreshes; default 30 s :param stale_threshold: seconds a holder record may stay unchanged before a contender evicts it; defaults to ``3 * heartbeat_interval`` :param poll_interval: seconds between acquire retries under contention; default 0.25 s :param on_compromise: called from the heartbeat thread with a :class:`~filelock.LeaseCompromise` when the hold is lost :param loop: event loop for ``run_in_executor``; ``None`` uses the running loop :param executor: executor for ``run_in_executor``; ``None`` uses the default executor .. versionadded:: 3.27.0 Tg>@Ng?)blocking is_singletonheartbeat_intervalstale_threshold poll_interval on_compromiseloopexecutorc tj|_d|_| |_t |_t|||||||||_t|j|_ | |_ | |_ y)NF)r"r#r$r%r&r') osgetpid _creator_pid_closed _owns_backendobject_viar_lockr_owners_loop _executor) self lock_filetimeoutr"r#r$r%r&r'r(r)s e/home/oem/CyberBrain26-unified/dev-env/.venv/lib/python3.12/site-packages/filelock/_soft_rw/_async.py__init__zAsyncSoftReadWriteLock.__init__BsqIIK !--!8 &  %1+''   ( 3  !c.|jjS)z4The path to the lock file passed to the constructor.)r2r7r6s r9r7z AsyncSoftReadWriteLock.lock_filecszz###r;c.|jjS)z\The default timeout applied when ``acquire_read`` / ``acquire_write`` is called without one.)r2r8r=s r9r8zAsyncSoftReadWriteLock.timeouthszz!!!r;c.|jjS)zYWhether ``acquire_*`` defaults to blocking; ``False`` makes contention raise immediately.)r2r"r=s r9r"zAsyncSoftReadWriteLock.blockingmszz"""r;c.|jjS)z_The generation the current hold was granted at, a fencing token; ``None`` when no lock is held.)r2 generationr=s r9rAz!AsyncSoftReadWriteLock.generationrzz$$$r;c.|jjS)zhHow the current hold was lost, or ``None`` while it stands; acquiring raises until the hold is released.)r2 compromiser=s r9rDz!AsyncSoftReadWriteLock.compromisewrBr;c|jS)zNThe event loop used for ``run_in_executor``, or ``None`` for the running loop.)r4r=s r9r(zAsyncSoftReadWriteLock.loop|szzr;c|jS)zPThe executor used for ``run_in_executor``, or ``None`` for the default executor.)r5r=s r9r)zAsyncSoftReadWriteLock.executors~~r;r"cK|j||d{ d|jd{y7#7#|jd{7wxYww)a Async context manager that acquires and releases a shared read lock. :param timeout: maximum wait time in seconds, or ``None`` to use the instance default :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default :raises RuntimeError: if the calling task already holds the write lock :raises Timeout: if the lock cannot be acquired within *timeout* seconds :raises TypeError: if *timeout* is a :class:`bool` or not a real number, or *blocking* is not a :class:`bool` :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1`` rGN) acquire_readreleaser6r8r"s r9 read_lockz AsyncSoftReadWriteLock.read_locksR(;;; ! ,,. < !$,,. >A=AAA?AAAAAAcK|j||d{ d|jd{y7#7#|jd{7wxYww)a Async context manager that acquires and releases an exclusive write lock. :param timeout: maximum wait time in seconds, or ``None`` to use the instance default :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default :raises RuntimeError: if the calling task already holds the read lock :raises Timeout: if the lock cannot be acquired within *timeout* seconds :raises TypeError: if *timeout* is a :class:`bool` or not a real number, or *blocking* is not a :class:`bool` :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1`` rGN) acquire_writerJrKs r9 write_lockz!AsyncSoftReadWriteLock.write_locksR  8 <<< ! ,,. = !$,,. rMc~K|j|jd||d{t|S7w)a! Acquire a shared read lock. See :meth:`SoftReadWriteLock.acquire_read` for reentrancy / upgrade / fork semantics. The blocking work runs inside ``run_in_executor`` so other coroutines on the same loop keep progressing while this call waits. :param timeout: maximum wait time in seconds, or ``None`` to use the instance default :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default :returns: a proxy usable as an async context manager to release the lock :raises RuntimeError: if the calling task already holds the write lock, if this instance was invalidated by :func:`os.fork`, or if :meth:`close` was called :raises Timeout: if the lock cannot be acquired within *timeout* seconds :raises TypeError: if *timeout* is a :class:`bool` or not a real number, or *blocking* is not a :class:`bool` :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1`` readrGNlock_raise_if_unusable_acquire$AsyncAcquireSoftReadWriteReturnProxyrKs r9rIz#AsyncSoftReadWriteLock.acquire_reads=* !mmFGhm???3>> @ (=;=c~K|j|jd||d{t|S7w)a Acquire an exclusive write lock. See :meth:`SoftReadWriteLock.acquire_write` for the writer-preferring semantics. The blocking work runs inside ``run_in_executor``. :param timeout: maximum wait time in seconds, or ``None`` to use the instance default :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default :returns: a proxy usable as an async context manager to release the lock :raises RuntimeError: if the calling task already holds the read lock, if this instance was invalidated by :func:`os.fork`, or if :meth:`close` was called :raises Timeout: if the lock cannot be acquired within *timeout* seconds :raises TypeError: if *timeout* is a :class:`bool` or not a real number, or *blocking* is not a :class:`bool` :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1`` writerGNrSrUrKs r9rOz$AsyncSoftReadWriteLock.acquire_writes=* !mmGWxm@@@3>> ArYc Kjjndfd }dfd }jj|jjn|j j ||d{y7w)Nc Kjjtjjj t |d{y7w)NrG)rV _run_acquirerpartialr2_acquire_level_ofr ) remainingr"moder6s r9enterz.AsyncSoftReadWriteLock._acquire..entersR  # # %##!!JJ00$%   sAA AA cjjjx}tj|j SN)rVr2rDrr7_backend_holds)rDrbr6s r9joinablez1AsyncSoftReadWriteLock._acquire..joinablesF  # # %"jj333 @&t~~tZHH&&( (r;)r8r"r7viarcrg)rafloatreturnNonerjbool)r2r"r3acquirer8r7r1)r6rbr8r"rcrgs`` ` r9rWzAsyncSoftReadWriteLock._acquiresw*2*:4::&&  ) ll"" *1/DJJ&&wnn #   sA;BBBF)forcec 0K|jtjk(ro|jj ||j |j tj|j|j|jd{yy7w)a Release one level of the calling task's hold. The wrapper releases the lock once no task holds it. :param force: if ``True``, end every level the calling task took through this wrapper. Levels taken through other wrappers on the same path stay. A wrapper that holds no level for the task releases nothing. :raises RuntimeError: if the calling task holds no level through this wrapper and *force* is ``False`` )ror7rhleave still_heldN) r-r+r,r3rJr7r1rr__submit_leave_backendrf)r6ros r9rJzAsyncSoftReadWriteLock.releases{    +,,&&..II'' d6I6IJ.. '   , sB B BBc&K|jtjk7s |jryd|_ |jj |j rdn |jtj|j|j r|jjn |j|jd{y7#t$r7}t!|t"j$s|jrd|_d}~wwxYww)a End the holds of the tasks that acquired through this instance and release the lock once no task holds it. Idempotent. After calling this method the instance can no longer acquire locks. With ``is_singleton=False`` it also closes the underlying :class:`SoftReadWriteLock`. A singleton wrapper leaves the shared one open, so tasks that acquired through another wrapper and synchronous users of the same path keep their holds. The next acquire notices a synchronous ``close()`` or forced release of that shared lock. One that lands in the few bytecodes between that check and the admission still admits the task into the ended hold. NT)rqrrF)r-r+r,r.r3retirer/r1rr_rsr2closertrf BaseException isinstancerCancelledError)r6errors r9rwzAsyncSoftReadWriteLock.closes    +t||   ,,%%** '' $J\J\djj6F6Fbfbubuv..&    eW%;%;<ATATAV$   s;6DB CC C D C D2D  DDc|jtjk7rd|jd}t ||j rd|jd}t |y)NzAsyncSoftReadWriteLock on z4 was inherited across fork; construct a new instancez has been closed)r-r+r,r7 RuntimeErrorr.)r6msgs r9rVz)AsyncSoftReadWriteLock._raise_if_unusable0s`    +.t~~.>>rsCs# # <<.t~~.>>NOCs# # r;c@|jjtSre)r2_holds_level_ofr r=s r9rfz%AsyncSoftReadWriteLock._backend_holds8szz))*:;;r;cB|jjtyre)r2_release_level_ofr r=s r9rtz%AsyncSoftReadWriteLock._leave_backend<s $$%56r;c.Ktj}|j||j} t |d{t|y7#t j $r}|j t|d{7n-#t$r|dt$r}t||Yd}~nd}~wwxYw t|j|jd{7#t$r}t||Yd}~d}~wwxYwd}~wwxYww)N) cancel_check)rEventrsis_setrrrzsetrrrxrrtr)r6rn abandonedacquire_future cancellationr{s r9r^z#AsyncSoftReadWriteLock._run_acquire@sOO% gI2 2 2 ~&! 3%%  MMO <#N333 -",  <&|U;; < <#DLL1D1D$EFFF ! <&|U;;  < s2DAAA DAD)D :BB  BD B9# B4/D 4B99D ='C+$C'%C+*D + D 4 DD D  D  DDc |jxstj}|j|jt t j|g|i|Sre)r4rget_running_looprun_in_executorr5rrr_)r6funcargskwargsr(s r9rszAsyncSoftReadWriteLock._submitYsLzz7W557##DNNM9CTCTUYCk\`CkdjCkllr;))r7zstr | os.PathLike[str]r8rir"rmr#rmr$rir% float | Noner&rir'z(Callable[[LeaseCompromise], None] | Noner( asyncio.AbstractEventLoop | Noner)futures.Executor | Nonerjrk)rjstr)rjrirl)rjz int | None)rjzLeaseCompromise | None)rjr)rjrre)r8rr" bool | NonerjzAsyncGenerator[None])r8rr"rrjrX)rbzLiteral['read', 'write']r8rr"rrjrk)rormrjrk)rjrk)rnz!Callable[..., AcquireReturnProxy]rjrk)rzCallable[_P, _R]rz_P.argsrz _P.kwargsrjz#asyncio.Future[_BackendOutcome[_R]])__name__ __module__ __qualname____doc__r:propertyr7r8r"rArDr(r)rrLrPrIrOrWrJrwrVrfrtr^rsr;r9r!r!'s :" !$((,#BF15,0")""  "  """&""@"/"*" "B$$""##%%%%!W[!!&!X\!!('+?GK?#?9D? -?4'+?GK?#?9D? -?2 @.3*6$<7'2m$m-4m@Im ,mr;r!c8eZdZdZddZddZ ddZy) rXzTAsync context-aware object that releases an :class:`AsyncSoftReadWriteLock` on exit.c||_yrerS)r6rTs r9r:z-AsyncAcquireSoftReadWriteReturnProxy.__init__cs  r;c"K|jSwrerSr=s r9 __aenter__z/AsyncAcquireSoftReadWriteReturnProxy.__aenter__fsyys cTK|jjd{y7wre)rTrJ)r6exc_type exc_value tracebacks r9 __aexit__z.AsyncAcquireSoftReadWriteReturnProxy.__aexit__is ii!!!s (&(N)rTr!rjrk)rjr!)rztype[BaseException] | NonerzBaseException | NonerzTracebackType | Nonerjrk)rrrrr:rrrr;r9rXrX`s:^","("( "  "r;rX).r __future__r__lazy_modules__rrr+r contextlibrtypingrr r r r filelock._asyncr rrrrrrrfilelock._errorrfilelock._soft_rw._syncrrcollections.abcrr concurrentrtypesr filelock._apirfilelock._leaserrrr!rX__all__rr;r9rsO"^ *DD   $G8"#0/t_ T]vmvmr ""&+ r;