i"dZddlmZddlZddlZddlmZddlmZddl m Z erddl Z ddl m Z mZdd lmZdd lmZGd d ZGd dZd dgZdS)zIAsync wrapper around :class:`SoftReadWriteLock` for use with ``asyncio``.) annotationsN)asynccontextmanager) TYPE_CHECKING)SoftReadWriteLock)AsyncGeneratorCallable)futures) TracebackTypec*eZdZdZddZddZddZdS)$AsyncAcquireSoftReadWriteReturnProxyzTAsync context-aware object that releases an :class:`AsyncSoftReadWriteLock` on exit.lockAsyncSoftReadWriteLockreturnNonec||_dSNr)selfrs Y/usr/local/lib/hermes-agent/venv/lib/python3.11/site-packages/filelock/_soft_rw/_async.py__init__z-AsyncAcquireSoftReadWriteReturnProxy.__init__s  cK|jSrrrs r __aenter__z/AsyncAcquireSoftReadWriteReturnProxy.__aenter__syrexc_typetype[BaseException] | None exc_valueBaseException | None tracebackTracebackType | NonecHK|jd{VdSr)rrelease)rrrr s r __aexit__z.AsyncAcquireSoftReadWriteReturnProxy.__aexit__s4 i!!!!!!!!!!!rN)rrrr)rr)rrrrr r!rr)__name__ __module__ __qualname____doc__rrr$rrr r sV^^""""""rr c *eZdZdZ d3ddddddddd4dZed5dZed6dZed7dZed8dZ ed9dZ d:dd d;d#Z d:dd d;d$Z d%d&dd,Zd?d2ZdS)@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_intervalloopexecutor lock_filestr | os.PathLike[str]timeoutfloatr,boolr-r.r/ float | Noner0r1 asyncio.AbstractEventLoop | Noner2futures.Executor | Nonerrc Xt||||||||_||_| |_dS)N)r,r-r.r/r0)r_lock_loop _executor) rr3r5r,r-r.r/r0r1r2s rrzAsyncSoftReadWriteLock.__init__;sC'  %1+'     !rstrc|jjS)z>:returns: the path to the lock file passed to the constructor.)r<r3rs rr3z AsyncSoftReadWriteLock.lock_fileTsz##rc|jjS)zf:returns: the default timeout applied when ``acquire_read`` / ``acquire_write`` is called without one.)r<r5rs rr5zAsyncSoftReadWriteLock.timeoutYsz!!rc|jjS)zc:returns: whether ``acquire_*`` defaults to blocking; ``False`` makes contention raise immediately.)r<r,rs rr,zAsyncSoftReadWriteLock.blocking^sz""rc|jS)zX:returns: the event loop used for ``run_in_executor``, or ``None`` for the running loop.)r=rs rr1zAsyncSoftReadWriteLock.loopcs zrc|jS)zZ:returns: the executor used for ``run_in_executor``, or ``None`` for the default executor.)r>rs rr2zAsyncSoftReadWriteLock.executorhs ~rr, bool | Noner cvK||jj||d{Vt|S)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 rENr)_runr< acquire_readr rr5r,s rrIz#AsyncSoftReadWriteLock.acquire_readmsH(ii /8iLLLLLLLLL3>>>>rcvK||jj||d{Vt|S)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 rENr)rHr< acquire_writer rJs rrLz$AsyncSoftReadWriteLock.acquire_writesH&ii 0'HiMMMMMMMMM3>>>>rFforcerNcXK||jj|d{VdS)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`` rMN)rHr<r#)rrNs rr#zAsyncSoftReadWriteLock.releases;ii *%i88888888888rAsyncGenerator[None]cK|||d{V dWV|d{VdS#|d{VwxYw)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 rEN)rIr#rJs r read_lockz AsyncSoftReadWriteLock.read_locks(;;;;;;;;; ! EEEE,,.. $,,.. AAcK|||d{V dWV|d{VdS#|d{VwxYw)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 rEN)rLr#rJs r write_lockz!AsyncSoftReadWriteLock.write_locks  8 <<<<<<<<< ! EEEE,,.. $,,.. rScTK||jjd{VdS)zRRelease any held lock and release the underlying filesystem resources. Idempotent.N)rHr<closers rrWzAsyncSoftReadWriteLock.closes5ii ()))))))))))rfuncCallable[..., object]argsobjectkwargscK|jptj}||jt j|g|Ri|d{VSr)r=asyncioget_running_looprun_in_executorr> functoolspartial)rrXrZr\r1s rrHzAsyncSoftReadWriteLock._runsbz7W577))$.):KD:bSW:b:b:b[a:b:bcccccccccr)r+)r3r4r5r6r,r7r-r7r.r6r/r8r0r6r1r9r2r:rr)rr?)rr6)rr7)rr9)rr:r)r5r8r,rFrr )rNr7rr)r5r8r,rFrrP)rr)rXrYrZr[r\r[rr[)r%r&r'r(rpropertyr3r5r,r1r2rIrLr#rrRrUrWrHr)rrrr%s 0" !$((,#15,0""""""2$$$X$"""X"###X#XX '+?GK??????0'+?GK??????,.3 9 9 9 9 9 9!W[!!!!!!"!X\!!!!!!"****ddddddrr)r( __future__rr^ra contextlibrtypingr_syncroscollections.abcrr concurrentr typesr r r__all__r)rrrms)OO""""""****** $$$$$$$ III88888888""""""######""""""""$jdjdjdjdjdjdjdjd\+ r