o #j"@sdZddlmZddlZddlZddlmZddlmZddl m Z erd?ZdS)Mr 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_intervalloopexecutor lock_filestr | os.PathLike[str]timeoutfloatr%boolr&r'r( float | Noner)r* asyncio.AbstractEventLoop | Noner+futures.Executor | Nonerrc Cs(t|||||||d|_||_| |_dS)N)r%r&r'r(r))r_lock_loop _executor) rr,r.r%r&r'r(r)r*r+rrrr;s  zAsyncSoftReadWriteLock.__init__strcC|jjS)z>:returns: the path to the lock file passed to the constructor.)r4r,rrrrr,Tz AsyncSoftReadWriteLock.lock_filecCr8)zf:returns: the default timeout applied when ``acquire_read`` / ``acquire_write`` is called without one.)r4r.rrrrr.Yr9zAsyncSoftReadWriteLock.timeoutcCr8)zc:returns: whether ``acquire_*`` defaults to blocking; ``False`` makes contention raise immediately.)r4r%rrrrr%^r9zAsyncSoftReadWriteLock.blockingcC|jS)zX:returns: the event loop used for ``run_in_executor``, or ``None`` for the running loop.)r5rrrrr*czAsyncSoftReadWriteLock.loopcCr:)zZ:returns: the executor used for ``run_in_executor``, or ``None`` for the default executor.)r6rrrrr+hr;zAsyncSoftReadWriteLock.executorr% bool | Noner c&|j|jj||dIdHt|dS)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)_runr4 acquire_readr rr.r%rrrr@ms z#AsyncSoftReadWriteLock.acquire_readcr>)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?r4 acquire_writer rArrrrBs z$AsyncSoftReadWriteLock.acquire_writeFforcerDcs|j|jj|dIdHdS)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`` rCN)r?r4r)rrDrrrrs zAsyncSoftReadWriteLock.releaseAsyncGenerator[None]cCB|j||dIdHz dVW|IdHdS|IdHw)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@rrArrr read_lock  "z AsyncSoftReadWriteLock.read_lockcCrF)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)rBrrArrr write_lockrHz!AsyncSoftReadWriteLock.write_lockcs||jjIdHdS)zRRelease any held lock and release the underlying filesystem resources. Idempotent.N)r?r4closerrrrrJszAsyncSoftReadWriteLock.closefuncCallable[..., object]argsobjectkwargscs8|jpt}||jtj|g|Ri|IdHSr)r5asyncioZget_running_loopZrun_in_executorr6 functoolspartial)rrKrMrOr*rrrr?s(zAsyncSoftReadWriteLock._run)r$)r,r-r.r/r%r0r&r0r'r/r(r1r)r/r*r2r+r3rr)rr7)rr/)rr0)rr2)rr3r)r.r1r%r=rr )rDr0rr)r.r1r%r=rrE)rr)rKrLrMrNrOrNrrN)r r!r"r#rpropertyr,r.r%r*r+r@rBrrrGrIrJr?rrrrr %sJ       r )r# __future__rrPrQ contextlibrtypingrZ_syncroscollections.abcrrZ concurrentr typesr r r __all__rrrrs$      /