j,dZddlmZddlZddlZddlZddlmZddlm Z m Z m Z ddl m Z mZmZmZmZmZddlmZe rdd lmZmZdd lmZdd lmZdd lmZe d Ze dZGddZ GddZ!ddgZ"y)zIAsync wrapper around :class:`SoftReadWriteLock` for use with ``asyncio``.) annotationsN)asynccontextmanager) TYPE_CHECKING ParamSpecTypeVar)_BackendOutcome _capture_call _drain_future_future_result_raise_cancelled_error_wait_until_done)SoftReadWriteLock)AsyncGeneratorCallable)futures) TracebackType)AcquireReturnProxy_P_Rc `eZdZdZ ddddddddd ddZeddZedd Zedd Zedd Z ed d Z e d!dd d"dZ e d!dd d"dZ d!dd  d#dZ d!dd  d#dZddd$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()``. The underlying :class:`SoftReadWriteLock` handles reentrancy, upgrade/downgrade rules, fork handling, heartbeat and TTL stale detection, and singleton behavior. :param lock_file: path to the lock file; sidecar state/write/readers live next to it :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 of mtime inactivity before a marker is stale; defaults to ``3 * heartbeat_interval`` :param poll_interval: seconds between acquire retries under contention; default 0.25 s :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_intervalloopexecutorc tj|_t||||||||_||_| |_y)N)rrrrr)osgetpid _creator_pidr_lock_loop _executor) self lock_filetimeoutrrrrrrrs d/home/min/hermes_workspace/demo_review/venv/lib/python3.12/site-packages/filelock/_soft_rw/_async.py__init__zAsyncSoftReadWriteLock.__init__7sCIIK&  %1+'   !c.|jjS)z4The path to the lock file passed to the constructor.)r$r(r's r*r(z AsyncSoftReadWriteLock.lock_fileQszz###r,c.|jjS)z\The default timeout applied when ``acquire_read`` / ``acquire_write`` is called without one.)r$r)r.s r*r)zAsyncSoftReadWriteLock.timeoutVszz!!!r,c.|jjS)zYWhether ``acquire_*`` defaults to blocking; ``False`` makes contention raise immediately.)r$rr.s r*rzAsyncSoftReadWriteLock.blocking[szz"""r,c|jS)zNThe event loop used for ``run_in_executor``, or ``None`` for the running loop.)r%r.s r*rzAsyncSoftReadWriteLock.loop`szzr,c|jS)zPThe executor used for ``run_in_executor``, or ``None`` for the default executor.)r&r.s r*rzAsyncSoftReadWriteLock.executores~~r,rcK|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 a write lock is already held on this instance :raises Timeout: if the lock cannot be acquired within *timeout* seconds r3N) acquire_readreleaser'r)rs r* read_lockz AsyncSoftReadWriteLock.read_lockjsR(;;; ! ,,. < !$,,. >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 a read lock is already held, or a write lock is held by a different thread :raises Timeout: if the lock cannot be acquired within *timeout* seconds r3N) acquire_writer6r7s r* write_lockz!AsyncSoftReadWriteLock.write_lock|sR  8 <<< ! ,,. = !$,,. r9cK|j|jtj|jj ||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 a write lock is already held, 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 r3Nlock)_raise_if_inherited _run_acquire functoolspartialr$r5$AsyncAcquireSoftReadWriteReturnProxyr7s r*r5z#AsyncSoftReadWriteLock.acquire_readsS&   " 1 1$**2I2I7]e fggg3>> hAA$A"A$cK|j|jtj|jj ||d{t |S7w)a Acquire an exclusive write lock. See :meth:`SoftReadWriteLock.acquire_write` for the two-phase 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 a read lock is already held, if a write lock is held by a different thread, 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 r3Nr>)r@rArBrCr$r;rDr7s r*r;z$AsyncSoftReadWriteLock.acquire_writesS&   " 1 1$**2J2JG^f ghhh3>> irEFforcecK|jtjk(r0|j|jj |d{yy7w)z Release one level of the current lock. :param force: if ``True``, release the lock completely regardless of the current lock level :raises RuntimeError: if no lock is currently held and *force* is ``False`` rGN)r#r!r"_runr$r6)r'rHs r*r6zAsyncSoftReadWriteLock.releasesD    +))DJJ..e)< < < ,    +))DJJ,,- - - , -sA A A Ac||jtjk7rd|jd}t |y)NzAsyncSoftReadWriteLock on z4 was inherited across fork; construct a new instance)r#r!r"r( RuntimeError)r'msgs r*r@z*AsyncSoftReadWriteLock._raise_if_inheriteds:    +.t~~.>>rsCs# # ,r,cK|j|} t|d{t|y7#tj$r} t |d{7n"#t $r}t ||Yd}~nd}~wwxYw t |j|jjd{7#t $r}t ||Yd}~d}~wwxYwd}~wwxYwwN) _submitr asyncioCancelledErrorr BaseExceptionr r$r6r )r'acquireacquire_future cancellationerrors r*rAz#AsyncSoftReadWriteLock._run_acquires g. ">2 2 2 ~& 3%%  <#N333  <&|U;; < <#DLL1C1C$DEEE ! <&|U;;  < sC$646 C$6C! AAAC A>( A94C9A>>C1B:3B64B:9C: C CCCCC!!C$cK|j|g|i|} t|d{t|S7#tj$r=} t |d{7#t $r}t ||Yd}~d}~wwxYwd}~wwxYwwrQ)rRr rSrTr rUr r )r'funcargskwargsfuturerXrYs r*rJzAsyncSoftReadWriteLock._runsd4T4V4 "6* * *f%% +%%  <#F+++ ! <&|U;;  < saB :8: B :B A#AA#"B# B, A=8B=BBB  B c |jxstj}|j|jt t j|g|i|SrQ)r%rSget_running_looprun_in_executorr&r rBrC)r'r[r\r]rs r*rRzAsyncSoftReadWriteLock._submitsLzz7W557##DNNM9CTCTUYCk\`CkdjCkllr,))r(zstr | os.PathLike[str]r)floatrboolrrdrrcr float | Nonerrcr asyncio.AbstractEventLoop | Nonerfutures.Executor | NonereturnNone)rhstr)rhrc)rhrd)rhrf)rhrgrQ)r)rer bool | NonerhzAsyncGenerator[None])r)rerrkrhrD)rHrdrhri)rhri)rVz Callable[[], AcquireReturnProxy]rhri)r[Callable[_P, _R]r\_P.argsr] _P.kwargsrhr)r[rlr\rmr]rnrhz#asyncio.Future[_BackendOutcome[_R]])__name__ __module__ __qualname____doc__r+propertyr(r)rrrrr8r<r5r;r6rLr@rArJrRr,r*rr!s0" !$((,#15,0")""  "  """&""/"*" "4$$""##!W[!!"!X\!!$'+?GK?#?9D? -?0'+?GK?#?9D? -?..3 =. $ '( &m$m-4m@Im ,mr,rc8eZdZdZddZddZ ddZy) rDzTAsync context-aware object that releases an :class:`AsyncSoftReadWriteLock` on exit.c||_yrQr>)r'r?s r*r+z-AsyncAcquireSoftReadWriteReturnProxy.__init__s  r,c"K|jSwrQr>r.s r* __aenter__z/AsyncAcquireSoftReadWriteReturnProxy.__aenter__syys cTK|jjd{y7wrQ)r?r6)r'exc_type exc_value tracebacks r* __aexit__z.AsyncAcquireSoftReadWriteReturnProxy.__aexit__s ii!!!s (&(N)r?rrhri)rhr)rzztype[BaseException] | Noner{zBaseException | Noner|zTracebackType | Nonerhri)rorprqrrr+rxr}rtr,r*rDrDs:^","("( "  "r,rD)#rr __future__rrSrBr! contextlibrtypingrrrfilelock._asyncrr r r r r _syncrcollections.abcrr concurrentrtypesr filelock._apirrrrrD__all__rtr,r*rsuO" *44%8"#0t_ T]WmWmt""&+ r,