*pj, SrSSKJr SSKrSSKrSSKrSSKJr SSKJ r J r J r SSK J r JrJrJrJrJr SSKJr \ (aSS KJrJr SS KJr SS KJr SS KJr \ "S 5r\ "S5r"SS5r "SS5r!SS/r"g)zIAsync wrapper around :class:`SoftReadWriteLock` for use with ``asyncio``.) annotationsN)asynccontextmanager) TYPE_CHECKING ParamSpecTypeVar)_BackendOutcome _capture_call _drain_future_future_result_raise_cancelled_error_wait_until_done)SoftReadWriteLock)AsyncGeneratorCallable)futures) TracebackType)AcquireReturnProxy_P_Rc \rSrSrSrSSSSSSSSS.SSjjjr\SS j5r\SS j5r\S S j5r \S!S j5r \S"S j5r \ S#SS.S$Sjjj5r \ S#SS.S$Sjjj5rS#SS.S%SjjjrS#SS.S%SjjjrSS.S&SjjrS'SjrS'SjrS(SjrS)SjrS*SjrSrg)+AsyncSoftReadWriteLock!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()``. The underlying :class:`SoftReadWriteLock` handles reentrancy, upgrade/downgrade rules, fork handling, heartbeat and TTL stale detection, and singleton behavior. :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 x[R"5Ul[UUUUUUUS9UlXlXlg)N)rrrrr)osgetpid _creator_pidr_lock_loop _executor) self lock_filetimeoutrrrrrrr s T/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/filelock/_soft_rw/_async.py__init__AsyncSoftReadWriteLock.__init__7s?IIK&  %1+'   !c.URR$)z4The path to the lock file passed to the constructor.)r%r)r(s r+r) AsyncSoftReadWriteLock.lock_fileQszz###r.c.URR$)z\The default timeout applied when ``acquire_read`` / ``acquire_write`` is called without one.)r%r*r0s r+r*AsyncSoftReadWriteLock.timeoutVszz!!!r.c.URR$)zYWhether ``acquire_*`` defaults to blocking; ``False`` makes contention raise immediately.)r%rr0s r+rAsyncSoftReadWriteLock.blocking[szz"""r.cUR$)zNThe event loop used for ``run_in_executor``, or ``None`` for the running loop.)r&r0s r+rAsyncSoftReadWriteLock.loop`szzr.cUR$)zPThe executor used for ``run_in_executor``, or ``None`` for the default executor.)r'r0s r+r AsyncSoftReadWriteLock.executores~~r.rc# 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 r:N) acquire_readreleaser(r*rs r+ read_lock AsyncSoftReadWriteLock.read_lockjsN;;; ! ,,. < !$,,. <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 r:N) acquire_writer=r>s r+ write_lock!AsyncSoftReadWriteLock.write_lock|sN   <<< ! ,,. = !$,,. rAc# UR5 UR[R"URR XS95IShvN [ US9$N 7f)a Acquire a shared read lock. See :meth:`SoftReadWriteLock.acquire_read` for reentrancy / upgrade / fork semantics. The blocking work runs inside ``run_in_executor`` so other coroutines on the same loop keep progressing 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:Nlock)_raise_if_inherited _run_acquire functoolspartialr%r<$AsyncAcquireSoftReadWriteReturnProxyr>s r+r<#AsyncSoftReadWriteLock.acquire_readsO&   " 1 1$**2I2I7 fggg3>> hA AAAc# UR5 UR[R"URR XS95IShvN [ 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 r:NrG)rIrJrKrLr%rCrMr>s r+rC$AsyncSoftReadWriteLock.acquire_writesO&   " 1 1$**2J2JG ghhh3>> irOFforcec# UR[R"5:Xa-URURR US9IShvN ggN7f)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`` rRN)r$r"r#_runr%r=)r(rSs r+r=AsyncSoftReadWriteLock.releasesC    +))DJJ..e)< < < , >rsCs# # ,r.c# URU5n[U5IShvN [U5 gN![Ran[ U5IShvN O"![ an[ X45 SnAOSnAff=f[ URURR55IShvN e![ an[ X45 SnAeSnAff=fSnAff=f7fN) _submitr asyncioCancelledErrorr BaseExceptionr r%r=r )r(acquireacquire_future cancellationerrors r+rJ#AsyncSoftReadWriteLock._run_acquires g. ">2 2 2 ~& 3%%  <#N333  <&|;; < <#DLL1C1C$DEEE ! <&|;;  < sC%646 C%6C" A AA C A?* A:5C:A??C1B;4B75B;:C; C CCCCC""C%c # UR"U/UQ70UD6n[U5IShvN [U5$N![Ra=n[ U5IShvN e![ an[ XV5 SnAeSnAff=fSnAff=f7fr_)r`r rarbr rcr r )r(funcargskwargsfuturerfrgs r+rUAsyncSoftReadWriteLock._runsd4T4V4 "6* * *f%% +%%  <#F+++ ! <&|;;  < saB:8: B:B A$A A$#B$ B. A>9B>BBB  Bc UR=(d [R"5nURUR[ [ R"U/UQ70UD65$r_)r&raget_running_looprun_in_executorr'r rKrL)r(rjrkrlrs r+r`AsyncSoftReadWriteLock._submitsLzz7W557##DNNM9CTCTUYCk\`CkdjCkllr.)r$r'r%r&))r)zstr | os.PathLike[str]r*floatrboolrrurrtr float | Nonerrtr asyncio.AbstractEventLoop | Noner futures.Executor | NonereturnNone)rystr)ryrt)ryru)ryrw)ryrxr_)r*rvr bool | NoneryzAsyncGenerator[None])r*rvrr|ryrM)rSruryrz)ryrz)rdz Callable[[], AcquireReturnProxy]ryrz)rjCallable[_P, _R]rk_P.argsrl _P.kwargsryr)rjr}rkr~rlrryz#asyncio.Future[_BackendOutcome[_R]])__name__ __module__ __qualname____firstlineno____doc__r,propertyr)r*rrr rr?rDr<rCr=rXrIrJrUr`__static_attributes__r.r+rr!s0" !$((,#15,0")""  "  """&""/"*" "4$$""##!W[!!"!X\!!$'+?GK?#?9D? -?0'+?GK?#?9D? -?..3 =. $ '( &m$m-4m@Im ,mr.rcF\rSrSrSrSSjrS SjrS SjrSrg) rMzTAsync context-aware object that releases an :class:`AsyncSoftReadWriteLock` on exit.cXlgr_rG)r(rHs r+r,-AsyncAcquireSoftReadWriteReturnProxy.__init__s r.c"# UR$7fr_rGr0s r+ __aenter__/AsyncAcquireSoftReadWriteReturnProxy.__aenter__syys cT# URR5IShvN gN7fr_)rHr=)r(exc_type exc_value tracebacks r+ __aexit__.AsyncAcquireSoftReadWriteReturnProxy.__aexit__s ii!!!s (&(rGN)rHrryrz)ryr)rztype[BaseException] | NonerzBaseException | NonerzTracebackType | Noneryrz) rrrrrr,rrrrr.r+rMrMs:^","("( "  "r.rM)#r __future__rrarKr" contextlibrtypingrrrfilelock._asyncrr r r r r _syncrcollections.abcrr concurrentrtypesr filelock._apirrrrrM__all__rr.r+rsuO" *44%8"#0t_ T]WmWmt""&+ r.