\j"dZddlmZddlZddlZddlmZddlmZddl m Z erddl Z ddl m Z mZdd lmZdd lmZGd d ZGd dZd dgZy)zIAsync wrapper around :class:`SoftReadWriteLock` for use with ``asyncio``.) annotationsN)asynccontextmanager) TYPE_CHECKING)SoftReadWriteLock)AsyncGeneratorCallable)futures) TracebackTypec8eZdZdZddZddZ ddZy) $AsyncAcquireSoftReadWriteReturnProxyzTAsync context-aware object that releases an :class:`AsyncSoftReadWriteLock` on exit.c||_yNlock)selfrs B/root/env/lib/python3.12/site-packages/filelock/_soft_rw/_async.py__init__z-AsyncAcquireSoftReadWriteReturnProxy.__init__s  c"K|jSwrrrs r __aenter__z/AsyncAcquireSoftReadWriteReturnProxy.__aenter__syys cTK|jjd{y7wr)rrelease)rexc_type exc_value tracebacks r __aexit__z.AsyncAcquireSoftReadWriteReturnProxy.__aexit__s ii!!!s (&(N)rAsyncSoftReadWriteLockreturnNone)r r)rztype[BaseException] | NonerzBaseException | NonerzTracebackType | Noner r!)__name__ __module__ __qualname____doc__rrrrrr r s:^","("( "  "rr c 8eZdZdZ ddddddddd ddZeddZedd Zedd Zedd Z edd Z ddd  ddZ ddd  ddZ ddd dZ eddd d!dZeddd d!dZd"dZd#dZy)$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 Tg>@Ng?)blocking is_singletonheartbeat_intervalstale_threshold poll_intervalloopexecutorc Nt||||||||_||_| |_y)N)r(r)r*r+r,)r_lock_loop _executor) r lock_filetimeoutr(r)r*r+r,r-r.s rrzAsyncSoftReadWriteLock.__init__;s5'  %1+'   !rc.|jjS)z>:returns: the path to the lock file passed to the constructor.)r0r3rs rr3z AsyncSoftReadWriteLock.lock_fileTszz###rc.|jjS)zf:returns: the default timeout applied when ``acquire_read`` / ``acquire_write`` is called without one.)r0r4rs rr4zAsyncSoftReadWriteLock.timeoutYszz!!!rc.|jjS)zc:returns: whether ``acquire_*`` defaults to blocking; ``False`` makes contention raise immediately.)r0r(rs rr(zAsyncSoftReadWriteLock.blocking^szz"""rc|jS)zX:returns: the event loop used for ``run_in_executor``, or ``None`` for the running loop.)r1rs rr-zAsyncSoftReadWriteLock.loopcszzrc|jS)zZ:returns: the executor used for ``run_in_executor``, or ``None`` for the default executor.)r2rs rr.zAsyncSoftReadWriteLock.executorhs~~rr(cK|j|jj||d{t|S7w)aC 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 r:Nr)_runr0 acquire_readr rr4r(s rr=z#AsyncSoftReadWriteLock.acquire_readms;(ii //8iLLL3>> M,A?AcK|j|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 r:Nr)r<r0 acquire_writer r>s rrAz$AsyncSoftReadWriteLock.acquire_writes;&ii 00'HiMMM3>> Nr?FforcecnK|j|jj|d{y7w)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`` rBN)r<r0r)rrCs rrzAsyncSoftReadWriteLock.releases(ii **%i888s +535cK|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 r:N)r=rr>s r 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 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)rArr>s r write_lockz!AsyncSoftReadWriteLock.write_locksR  8 <<< ! ,,. = !$,,. rGcjK|j|jjd{y7w)zRRelease any held lock and release the underlying filesystem resources. Idempotent.N)r<r0closers rrKzAsyncSoftReadWriteLock.closes"ii (()))s )313cK|jxstj}|j|jt j |g|i|d{S7wr)r1asyncioget_running_looprun_in_executorr2 functoolspartial)rfuncargskwargsr-s rr<zAsyncSoftReadWriteLock._runsQzz7W557))$..):K:KD:bSW:b[a:bccccsAA"A A"))r3zstr | os.PathLike[str]r4floatr(boolr)rWr*rVr+ float | Noner,rVr- asyncio.AbstractEventLoop | Noner.futures.Executor | Noner r!)r str)r rV)r rW)r rY)r rZr)r4rXr( bool | Noner r )rCrWr r!)r4rXr(r\r zAsyncGenerator[None])r r!)rRzCallable[..., object]rSobjectrTr]r r])r"r#r$r%rpropertyr3r4r(r-r.r=rArrrFrIrKr<r&rrrr%s0" !$((,#15,0")""  "  """&""/"*" "2$$""## '+?GK?#?9D? -?0'+?GK?#?9D? -?,.3 9!W[!!"!X\!!"*drr)r% __future__rrMrP contextlibrtypingr_syncroscollections.abcrr concurrentr typesr r r__all__r&rrrhsQO"* $ 8"#""$jdjd\+ r