;j"SrSSKJr SSKrSSKrSSKJr SSKJr SSK J r \(aSSK r SSK J r Jr SS KJr SS KJr "S S 5r"S S5rS S/rg)zIAsync wrapper around :class:`SoftReadWriteLock` for use with ``asyncio``.) annotationsN)asynccontextmanager) TYPE_CHECKING)SoftReadWriteLock)AsyncGeneratorCallable)futures) TracebackTypecF\rSrSrSrSSjrS SjrS SjrSrg) $AsyncAcquireSoftReadWriteReturnProxyzTAsync context-aware object that releases an :class:`AsyncSoftReadWriteLock` on exit.cXlgNlock)selfrs i/root/GenerationalWealth/GenerationalWealth/venv/lib/python3.13/site-packages/filelock/_soft_rw/_async.py__init__-AsyncAcquireSoftReadWriteReturnProxy.__init__s c"# UR$7frrrs r __aenter__/AsyncAcquireSoftReadWriteReturnProxy.__aenter__syys cT# URR5IShvN gN7fr)rrelease)rexc_type exc_value tracebacks r __aexit__.AsyncAcquireSoftReadWriteReturnProxy.__aexit__s ii!!!s (&(rN)rAsyncSoftReadWriteLockreturnNone)r$r#)rztype[BaseException] | NonerzBaseException | Noner zTracebackType | Noner$r%) __name__ __module__ __qualname____firstlineno____doc__rrr!__static_attributes__rrr r s:^","("( "  "rr c p\rSrSrSrSSSSSSSSS.SSjjjr\SS j5r\SS j5r\SS j5r \SS j5r \SS j5r S SS.S!Sjjjr S SS.S!Sjjjr SS.S"Sjjr\S SS.S#Sjjj5r\S SS.S#Sjjj5rS$SjrS%SjrSrg)&r#%a 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 Tg>@Ng?)blocking is_singletonheartbeat_intervalstale_threshold poll_intervalloopexecutorc D[UUUUUUUS9UlXlXlg)N)r/r0r1r2r3)r_lock_loop _executor) r lock_filetimeoutr/r0r1r2r3r4r5s rrAsyncSoftReadWriteLock.__init__;s1'  %1+'   !rc.URR$)z>:returns: the path to the lock file passed to the constructor.)r7r:rs rr: AsyncSoftReadWriteLock.lock_fileTszz###rc.URR$)zf:returns: the default timeout applied when ``acquire_read`` / ``acquire_write`` is called without one.)r7r;rs rr;AsyncSoftReadWriteLock.timeoutYszz!!!rc.URR$)zc:returns: whether ``acquire_*`` defaults to blocking; ``False`` makes contention raise immediately.)r7r/rs rr/AsyncSoftReadWriteLock.blocking^szz"""rcUR$)zX:returns: the event loop used for ``run_in_executor``, or ``None`` for the running loop.)r8rs rr4AsyncSoftReadWriteLock.loopcszzrcUR$)zZ:returns: the executor used for ``run_in_executor``, or ``None`` for the default executor.)r9rs rr5AsyncSoftReadWriteLock.executorhs~~rr/cx# URURRXS9IShvN [US9$N 7f)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 rGNr)_runr7 acquire_readr rr;r/s rrJ#AsyncSoftReadWriteLock.acquire_readms8(ii //iLLL3>> M (:8:cx# URURRXS9IShvN [US9$N 7f)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 rGNr)rIr7 acquire_writer rKs rrO$AsyncSoftReadWriteLock.acquire_writes8&ii 00'iMMM3>> NrMFforcech# URURRUS9IShvN gN7f)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`` rQN)rIr7r)rrRs rrAsyncSoftReadWriteLock.releases'ii **%i888s (202c# URXS9IShvN S7v UR5IShvN gN#N!UR5IShvN f=f7f)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 rGN)rJrrKs r read_lock AsyncSoftReadWriteLock.read_locksN;;; ! ,,. < !$,,. <A9A=A;AAAAAAc# URXS9IShvN S7v UR5IShvN gN#N!UR5IShvN f=f7f)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 rGN)rOrrKs r write_lock!AsyncSoftReadWriteLock.write_locksN   <<< ! ,,. = !$,,. rXcj# URURR5IShvN gN7f)zRRelease any held lock and release the underlying filesystem resources. Idempotent.N)rIr7closers rr]AsyncSoftReadWriteLock.closes!ii (()))s )313c# UR=(d [R"5nURUR[ R "U/UQ70UD65IShvN $N7fr)r8asyncioget_running_looprun_in_executorr9 functoolspartial)rfuncargskwargsr4s rrIAsyncSoftReadWriteLock._runsPzz7W557))$..):K:KD:bSW:b[a:bccccsA A)"A'#A))r9r7r8))r:zstr | os.PathLike[str]r;floatr/boolr0rkr1rjr2 float | Noner3rjr4 asyncio.AbstractEventLoop | Noner5futures.Executor | Noner$r%)r$str)r$rj)r$rk)r$rm)r$rnr)r;rlr/ bool | Noner$r )rRrkr$r%)r;rlr/rpr$zAsyncGenerator[None])r$r%)rezCallable[..., object]rfobjectrgrqr$rq)r&r'r(r)r*rpropertyr:r;r/r4r5rJrOrrrVrZr]rIr+r,rrr#r#%s0" !$((,#15,0")""  "  """&""/"*" "2$$""## '+?GK?#?9D? -?0'+?GK?#?9D? -?,.3 9!W[!!"!X\!!"*drr#)r* __future__rr`rc contextlibrtypingr_syncroscollections.abcrr concurrentr typesr r r#__all__r,rrr|sQO"* $ 8"#""$jdjd\+ r