*pj 46SrSSKJr SSKrSSKrSSKrSSKrSSKJr SSK J r SSK J r J r Jr SSKJrJrJrJr SS KJrJrJrJrJrJr SS KJr \ (aSS KJrJr SS K J!r! SS K"J#r# SSKJ$r$ \ "S5r%\"S5r&"SS5r'"SS5r(SS/r)g)zEAsync wrapper around :class:`ReadWriteLock` for use with ``asyncio``.) annotationsN)ThreadPoolExecutor)asynccontextmanager) TYPE_CHECKING ParamSpecTypeVar)_append_exception_context_ensure_current_process_fork_transition_register_fork_object)_BackendOutcome _capture_call _drain_future_future_result_raise_cancelled_error_wait_until_done) ReadWriteLock)AsyncGeneratorCallable)futures) TracebackType)AcquireReturnProxy_P_Rc\rSrSrSrSSSSSS.S Sjjjr\S!Sj5r\S"Sj5r\S#S j5r \S$S j5r \S%S j5r \ S&SS .S'S jjj5r \ S&SS .S'Sjjj5rS(SjrSSS .S)SjjjrSSS .S)SjjjrSS.S*SjjrS+SjrS,SjrS-SjrS.SjrS+Sjr\S#Sj5rS+SjrS+SjrS+SjrSrg)/AsyncReadWriteLock(a Async wrapper around :class:`ReadWriteLock` for use in ``asyncio`` applications. This wrapper dispatches every blocking SQLite operation to a thread pool via ``loop.run_in_executor()`` because Python's :mod:`sqlite3` module has no async API. It delegates reentrancy, upgrade/downgrade rules, and singleton behavior to the underlying :class:`ReadWriteLock`. :param lock_file: path to the SQLite database file used as the lock :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable :param is_singleton: if ``True``, reuse existing :class:`ReadWriteLock` instances for the same resolved path :param loop: event loop for ``run_in_executor``; ``None`` uses the running loop :param executor: executor for ``run_in_executor``. When ``None`` this lock creates and owns a dedicated single-thread executor so every operation runs on the same thread (SQLite affinity requires this) and shuts it down in :meth:`close`. This lock uses a caller-supplied executor as-is and never shuts it down, so after passing no executor call :meth:`close` to release the owned one. .. versionadded:: 3.21.0 TN)blocking is_singletonloopexecutorcl[R"5nXplSUlSUl[ U5 [ 5 [XX4S9UlXPl USLUl U=(d [SS9Ul [R"5U:wa Sn[U5eSSS5 g!,(df  g=f)NF)rr r ) max_workersz:AsyncReadWriteLock construction cannot continue after fork)osgetpid _creator_pid_fork_invalidated_closedr r r_lock_loop_owns_executorr _executor RuntimeError) self lock_filetimeoutrr r!r" creator_pidmsgs V/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/filelock/_async_read_write.py__init__AsyncReadWriteLock.__init__>siik '!& d#  &yHhDJJ"*d"2D %J);)JDNyy{k)R"3''*   s AB%% B3c.URR$)zThe path to the lock file.)r*r0r/s r4r0AsyncReadWriteLock.lock_fileVszz###c.URR$)zThe default timeout.)r*r1r8s r4r1AsyncReadWriteLock.timeout[szz!!!r:c.URR$)z'Whether blocking is enabled by default.)r*rr8s r4rAsyncReadWriteLock.blocking`szz"""r:cUR$)z2The event loop (or ``None`` for the running loop).)r+r8s r4r!AsyncReadWriteLock.loopeszzr:cUR$)z_The executor used for ``run_in_executor`` (a dedicated single-thread one if none was supplied).)r-r8s r4r"AsyncReadWriteLock.executorjs~~r:rcR# UcURRnUcURRnURXS9IShvN SnS7v UR U5IShvN gN'![anUneSnAff=fN!UR U5IShvN f=f7f)a[ Async context manager that acquires and releases a shared read lock. Falls back to instance defaults for *timeout* and *blocking* when ``None``. :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 NrC)r*r1r acquire_read BaseException_release_in_contextr/r1r body_errorerrors r4 read_lockAsyncReadWriteLock.read_lockos ?jj((G  zz**H;;;+/  7  **:6 6 6 < J   7$**:6 6 6`AB'A/B'A1B')B*B'1 B;A>>BBB'B$B B$$B'cR# UcURRnUcURRnURXS9IShvN SnS7v UR U5IShvN gN'![anUneSnAff=fN!UR U5IShvN f=f7f)a` Async context manager that acquires and releases an exclusive write lock. Falls back to instance defaults for *timeout* and *blocking* when ``None``. :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 NrC)r*r1r acquire_writerFrGrHs r4 write_lockAsyncReadWriteLock.write_locks ?jj((G  zz**H   <<<+/  7  **:6 6 6 = J   7$**:6 6 6rMc# UR5IShvN gN![anUb [X!5 eSnAff=f7fN)releaserFr )r/rI release_errors r4rG&AsyncReadWriteLock._release_in_contexts9 ,,.  %)-D  s+AA =8=Ac# UR5 UR[R"URR XS95IShvN [ US9$N 7f)a Acquire a shared read lock. See :meth:`ReadWriteLock.acquire_read` for full semantics. :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable :returns: a proxy that can be used as an async context manager to release the lock :raises RuntimeError: if a write lock is already held on this instance :raises Timeout: if the lock cannot be acquired within *timeout* seconds rCNlock)_raise_if_unusable _run_acquire functoolspartialr*rE AsyncAcquireReadWriteReturnProxyr/r1rs r4rEAsyncReadWriteLock.acquire_readsO ! 1 1$**2I2I7 fggg/T:: hA AAAc# UR5 UR[R"URR XS95IShvN [ US9$N 7f)a Acquire an exclusive write lock. See :meth:`ReadWriteLock.acquire_write` for full semantics. :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable :returns: a proxy that can be used as an async context manager to release the lock :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 rCNrX)rZr[r\r]r*rOr^r_s r4rO AsyncReadWriteLock.acquire_writesO ! 1 1$**2J2JG ghhh/T:: iraFforcec# [5 UR(agURURRUS9IShvN gN7f)a  Release one level of the current lock. See :meth:`ReadWriteLock.release` for full semantics. :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`` Nrd)r _inherited_runr*rT)r/res r4rTAsyncReadWriteLock.releases7 ! ?? ii **%i888sAAA Ac# [5 UR(agUR(agURURR 5n[ U5IShvN [U5 SUlUR(aF[R"[ R""UR$R&SS95IShvN ggNn![RaUn[U5IShvN O"![an[X#5 SnAOSnAff=fSUlUR5 eSnAff=fNt7f)z Release the lock (if held) and close the underlying SQLite connection. After calling this method, the lock instance is no longer usable. NTwait)r rgr)_submitr*closerasyncioCancelledErrorrrFr_shutdown_owned_executorrr, to_threadr\r]r-shutdown)r/ close_future cancellationrJs r4rnAsyncReadWriteLock.closes ! ??  << ||DJJ$4$45  "<0 0 0 |$    ##I$5$5dnn6M6MTX$YZ Z Z  1%%  <#L111  <&|;; <DL  ) ) +   [syAEC%C&C*A#E EECD?+D9C<:D?D: D DD:DD::D??Ec# URU5n[U5IShvN [U5 gN![Ran[ U5IShvN O"![ an[ X45 SnAOSnAff=f[ URURR55IShvN e![ an[ X45 SnAeSnAff=fSnAff=f7frS) rmrrorprrFrr*rTr)r/acquireacquire_futurerurJs r4r[AsyncReadWriteLock._run_acquiresg. ">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=f7frS)rmrrorprrFrr)r/funcargskwargsfuturerurJs r4rhAsyncReadWriteLock._run sd4T4V4 "6* * *f%% +%%  <#F+++ ! <&|;;  < saB:8: B:B A$A A$#B$ B. A>9B>BBB  Bc UR=(d [R"5RUR[ [ R"U/UQ70UD65$rS)r+roget_running_looprun_in_executorr-rr\r])r/r|r}r~s r4rmAsyncReadWriteLock._submitsK 8g668II NN    d 4T 4V 4  r:cZUR(aURRSS9 gg)NFrk)r,r-rsr8s r4rq+AsyncReadWriteLock._shutdown_owned_executor"s%    NN # # # / r:clUR=(d" [R"5UR:g$rS)r(r%r&r'r8s r4rgAsyncReadWriteLock._inherited&s$%%I8I8I)IIr:c[5 UR(aSURS3n[U5eUR(aSn[ R "U5eg)NzAsyncReadWriteLock on z4 was invalidated by fork(); construct a new instancez$Cannot operate on a closed database.)r rgr0r.r)sqlite3ProgrammingError)r/r3s r4rZ%AsyncReadWriteLock._raise_if_unusable*sP! ??*4>>*::noCs# # <<8C**3/ / r:cSUlg)NT)r(r8s r4_reset_after_fork_in_child-AsyncReadWriteLock._reset_after_fork_in_child3s !%r:c[R"5[USS5:Xa-[USS5(aURR SS9 ggg)Nr'r,Frk)r%r&getattrr-rsr8s r4__del__AsyncReadWriteLock.__del__6sJ 99;'$= ='$P`bgBhBh NN # # # /Ci =r:)r)r'r-r(r*r+r,))r0zstr | os.PathLike[str]r1floatrboolr rr! asyncio.AbstractEventLoop | Noner"zfutures.Executor | NonereturnNone)rstr)rr)rr)rr)rzfutures.ExecutorrS)r1z float | Nonerz bool | NonerzAsyncGenerator[None])rIBaseException | Nonerr)r1rrrrr^)rerrr)rr)rxz Callable[[], AcquireReturnProxy]rr)r|Callable[_P, _R]r}_P.argsr~ _P.kwargsrr)r|rr}rr~rrz#asyncio.Future[_BackendOutcome[_R]])__name__ __module__ __qualname____firstlineno____doc__r5propertyr0r1rr!r"rrKrPrGrErOrTrnr[rhrmrqrgrZrr__static_attributes__r:r4rr(s0( !15,0()((  (  (/(*( (0$$""##7W[7707X\770;$;;&;4;;&.39 [<' & $ -4 @I , 0JJ0&0r:rcF\rSrSrSrSSjrS SjrS SjrSrg) r^i=zEContext-aware object that releases the async read/write lock on exit.cXlgrSrX)r/rYs r4r5)AsyncAcquireReadWriteReturnProxy.__init__@s r:c"# UR$7frSrXr8s r4 __aenter__+AsyncAcquireReadWriteReturnProxy.__aenter__Csyys cT# URR5IShvN gN7frS)rYrT)r/exc_type exc_value tracebacks r4 __aexit__*AsyncAcquireReadWriteReturnProxy.__aexit__Fs ii!!!s (&(rXN)rYrrr)rr)rztype[BaseException] | NonerrrzTracebackType | Nonerr) rrrrrr5rrrrr:r4r^r^=s:O","("( "  "r:r^)*r __future__rror\r%rconcurrent.futuresr contextlibrtypingrrr_apir r r r _asyncrrrrrr _read_writercollections.abcrr concurrentrtypesrrrrrr^__all__rr:r4rsK" 1*44 '8"#(t_ T]R0R0j""&' r: