+ ~j"Rt^RIHt^RIt^RIt^RIHt^RIHt^RI H t ]'d^RI t ^RI H t Ht^RIHt^RIHt!R R 4t!R R 4tR R .tR#) zIAsync wrapper around :class:`SoftReadWriteLock` for use with ``asyncio``.) annotationsN)asynccontextmanager) TYPE_CHECKING)SoftReadWriteLock)AsyncGeneratorCallable)futures) TracebackTypec>]tRt^tRtRRltRRltRRltRtR #) $AsyncAcquireSoftReadWriteReturnProxyzTAsync context-aware object that releases an :class:`AsyncSoftReadWriteLock` on exit.c V^8dQhRRRR/#)lockAsyncSoftReadWriteLockreturnNone)formats"m/Users/mitch_tango/dev/rabbit-r1-livekit/agent/.venv/lib/python3.14/site-packages/filelock/_soft_rw/_async.py __annotate__1AsyncAcquireSoftReadWriteReturnProxy.__annotate__s3c WnR#Nr)selfrs&&r__init__-AsyncAcquireSoftReadWriteReturnProxy.__init__s rcV^8dQhRR/#)r rrr)rs"rrrs"8rc ""VP#5irrrs&r __aenter__/AsyncAcquireSoftReadWriteReturnProxy.__aenter__syys c(V^8dQhRRRRRRRR/#) r exc_typeztype[BaseException] | None exc_valuezBaseException | None tracebackzTracebackType | Nonerrr)rs"rrrs2"","("( "  "rc V"VPP4GRjxL R#L5ir)rrelease)rr$r%r&s&&&&r __aexit__.AsyncAcquireSoftReadWriteReturnProxy.__aexit__s ii!!!s )')rN) __name__ __module__ __qualname____firstlineno____doc__rr!r)__static_attributes__rrrr r s^""rr cX]tRt^%tRtR*RRRRRRRRR R R RR R/R Rlllt]RRl4t]RRl4t]RRl4t ]RRl4t ]RRl4t R+RR/RRlllt R+RR/RRlllt RR/RR llt]R+RR/R!R"lll4t]R+RR/R#R$lll4tR%R&ltR'R(ltR)tR#),ra 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()``. Reentrancy, upgrade/downgrade rules, fork handling, heartbeat and TTL stale detection, and singleton behavior are delegated to the underlying :class:`SoftReadWriteLock`. :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 blockingT is_singletonheartbeat_intervalg>@stale_thresholdN poll_intervalg?loopexecutorc@V^8dQhRRRRRRRRRRR R R RR R RRRR/ #)r lock_filezstr | os.PathLike[str]timeoutfloatr2boolr3r4r5 float | Noner6r7 asyncio.AbstractEventLoop | Noner8futures.Executor | Nonerrr)rs"rr#AsyncSoftReadWriteLock.__annotate__;sn"")""  "  """&""/"*" "rc  L\VVVVVVVR7VnWnWnR#))r2r3r4r5r6N)r_lock_loop _executor) rr:r;r2r3r4r5r6r7r8s &&&$$$$$$$rrAsyncSoftReadWriteLock.__init__;s1'  %1+'   !rcV^8dQhRR/#)r rstrr)rs"rrrAUs$$3$rc .VPP#)z>:returns: the path to the lock file passed to the constructor.)rCr:r s&rr: AsyncSoftReadWriteLock.lock_fileTszz###rcV^8dQhRR/#)r rr<r)rs"rrrAZs"""rc .VPP#)zf:returns: the default timeout applied when ``acquire_read`` / ``acquire_write`` is called without one.)rCr;r s&rr;AsyncSoftReadWriteLock.timeoutYszz!!!rcV^8dQhRR/#)r rr=r)rs"rrrA_s##$#rc .VPP#)zc:returns: whether ``acquire_*`` defaults to blocking; ``False`` makes contention raise immediately.)rCr2r s&rr2AsyncSoftReadWriteLock.blocking^szz"""rcV^8dQhRR/#)r rr?r)rs"rrrAds6rc VP#)zX:returns: the event loop used for ``run_in_executor``, or ``None`` for the running loop.)rDr s&rr7AsyncSoftReadWriteLock.loopcszzrcV^8dQhRR/#)r rr@r)rs"rrrAis1rc VP#)zZ:returns: the executor used for ``run_in_executor``, or ``None`` for the default executor.)rEr s&rr8AsyncSoftReadWriteLock.executorhs~~rc$V^8dQhRRRRRR/#r r;r>r2 bool | Nonerr r)rs"rrrAms$??#?9D? -?rc "VPVPPWR7GRjxL \VR7#L5i)a Acquire a shared read lock. See :meth:`SoftReadWriteLock.acquire_read` for the full reentrancy / upgrade / fork semantics. The blocking work runs inside ``run_in_executor`` so other coroutines on the same loop continue to progress 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 r2Nr)_runrC acquire_readr rr;r2s&&$rr]#AsyncSoftReadWriteLock.acquire_readms8(ii //iLLL3>> M+A>Ac$V^8dQhRRRRRR/#rXr)rs"rrrAs$??#?9D? -?rc "VPVPPWR7GRjxL \VR7#L5i)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 r[Nr)r\rC acquire_writer r^s&&$rrc$AsyncSoftReadWriteLock.acquire_writes8&ii 00'iMMM3>> Nr`forceFc V^8dQhRRRR/#)r rer=rrr)rs"rrrAs 9 9d 9t 9rc p"VPVPPVR7GRjxL R#L5i)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`` )reN)r\rCr()rres&$rr(AsyncSoftReadWriteLock.releases'ii **%i888s +646c$V^8dQhRRRRRR/#r r;r>r2rYrzAsyncGenerator[None]r)rs"rrrAs"!!|!!`t!rc "VPWR7GRjxL R5xVP4GRjxL R#L$L TP4GRjxL i;i5i)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 r[N)r]r(r^s&&$r read_lock AsyncSoftReadWriteLock.read_locksN;;; ! ,,. < !$,,. >A=AAA?AAAAAAc$V^8dQhRRRRRR/#rjr)rs"rrrAs"!! !+!au!rc "VPWR7GRjxL R5xVP4GRjxL R#L$L TP4GRjxL i;i5i)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 r[N)rcr(r^s&&$r write_lock!AsyncSoftReadWriteLock.write_locksN   <<< ! ,,. = !$,,. rncV^8dQhRR/#)r rrr)rs"rrrAs**T*rc l"VPVPP4GRjxL R#L5i)zRRelease any held lock and release the underlying filesystem resources. Idempotent.N)r\rCcloser s&rruAsyncSoftReadWriteLock.closes!ii (()))s )424c(V^8dQhRRRRRRRR/#)r funczCallable[..., object]argsobjectkwargsrr)rs"rrrAs0dd4dVdvdZ`drc "VP;'g\P!4pVPVP\ P !V.VO5/VB4GRjxL #L5ir)rDasyncioget_running_looprun_in_executorrE functoolspartial)rrxryr{r7s&&*, rr\AsyncSoftReadWriteLock._runsSzz77W557))$..):K:KD:bSW:b[a:bccccsA!A*#A($A*)rErCrD)r)r+r,r-r.r/rpropertyr:r;r2r7r8r]rcr(rrlrqrur\r0rrrrr%s4*"  " " "%)")-" $"26"-1""2$$""##?GK??.?GK??, 9U 9!W[!!"!X\!!"*ddrr)r/ __future__rr}r contextlibrtypingr_syncroscollections.abcrr concurrentrtypesr r r__all__rrrrsQO"* $ 8"#""$jdjd\+ r