1j 4,dZddlmZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z mZddlmZmZmZmZdd lmZmZmZmZmZmZdd lmZe rdd lmZmZdd l m!Z!dd l"m#Z#ddlm$Z$e dZ%edZ&GddZ'GddZ(ddgZ)y)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_RcheZdZdZ dddddd ddZeddZed dZed!dZed"d Z ed#d Z e d$dd d%d Z e d$dd d%d Z d&dZddd d'dZddd d'dZddd(dZd)dZd*dZd+dZ d,dZd)dZed!dZd)dZd)dZd)dZy)-AsyncReadWriteLocka 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_singletonloopexecutorcftj}||_d|_d|_t |t 5t|||||_||_ |du|_ |xs td|_ tj|k7r d}t| dddy#1swYyxYw)NF)rrr ) max_workersz:AsyncReadWriteLock construction cannot continue after fork)osgetpid _creator_pid_fork_invalidated_closedr r r_lock_loop_owns_executorr _executor RuntimeError) self lock_filetimeoutrrr r! creator_pidmsgs /home/vela/workspace/domain/tn-silver/web/tn-site/.runtime/depth-eval/venv/lib/python3.12/site-packages/filelock/_async_read_write.py__init__zAsyncReadWriteLock.__init__>siik '!& d#  &y'H[ghDJDJ"*d"2D %J);)JDNyy{k)R"3''*   s AB''B0c.|jjS)zThe path to the lock file.)r)r/r.s r3r/zAsyncReadWriteLock.lock_fileVszz###c.|jjS)zThe default timeout.)r)r0r6s r3r0zAsyncReadWriteLock.timeout[szz!!!r7c.|jjS)z'Whether blocking is enabled by default.)r)rr6s r3rzAsyncReadWriteLock.blocking`szz"""r7c|jS)z2The event loop (or ``None`` for the running loop).)r*r6s r3r zAsyncReadWriteLock.loopeszzr7c|jS)z_The executor used for ``run_in_executor`` (a dedicated single-thread one if none was supplied).)r,r6s r3r!zAsyncReadWriteLock.executorjs~~r7rcTK||jj}||jj}|j||d{d} d |j |d{y7'#t$r}|}d}~wwxYw7#|j |d{7wxYww)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 Nr<)r)r0r acquire_read BaseException_release_in_contextr.r0r body_errorerrors r3 read_lockzAsyncReadWriteLock.read_lockos ?jj((G  zz**H(;;;+/  7  **:6 6 6 < J   7$**:6 6 6`AB( A1 B(A3B(+B,B(3 B<A??BB B( B%B!B%%B(cTK||jj}||jj}|j||d{d} d |j |d{y7'#t$r}|}d}~wwxYw7#|j |d{7wxYww)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 Nr<)r)r0r acquire_writer?r@rAs r3 write_lockzAsyncReadWriteLock.write_locks ?jj((G  zz**H  8 <<<+/  7  **:6 6 6 = J   7$**:6 6 6rEcK |jd{y7#t$r}| t||d}~wwxYwwN)releaser?r )r.rB release_errors r3r@z&AsyncReadWriteLock._release_in_contexts< ,,.  %)-D  s(?? <7<?cK|j|jtj|jj ||d{t |S7w)a7 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 r<Nlock)_raise_if_unusable _run_acquire functoolspartialr)r> AsyncAcquireReadWriteReturnProxyr.r0rs r3r>zAsyncReadWriteLock.acquire_readsS ! 1 1$**2I2I7]e fggg/T:: hAA$A"A$cK|j|jtj|jj ||d{t |S7w)aZ 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 r<NrN)rPrQrRrSr)rGrTrUs r3rGz AsyncReadWriteLock.acquire_writesS ! 1 1$**2J2JG^f ghhh/T:: irVFforcecKt|jry|j|jj|d{y7w)a2 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`` NrX)r _inherited_runr)rK)r.rYs r3rKzAsyncReadWriteLock.releases8 ! ?? ii **%i888sAA A A cnKt|jry|jry|j|jj } t |d{t|d|_|jrGtjt!j"|j$j&dd{yy7j#tj$rU} t|d{7n"#t$r}t||Yd}~nd}~wwxYwd|_|jd}~wwxYw7sw)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 r[r(_submitr)closerasyncioCancelledErrorrr?r_shutdown_owned_executorrr+ to_threadrRrSr,shutdown)r. close_future cancellationrCs r3razAsyncReadWriteLock.closes ! ??  << ||DJJ$4$45  "<0 0 0 |$    ##I$5$5dnn6M6MTX$YZ Z Z  1%%  <#L111  <&|U;; <DL  ) ) +   [syA D5 CCC AD5?D3D5CD0C1*C-+C10D+1 D: D D+ DD++D00D5cK|j|} t|d{t|y7#tj$r} t |d{7n"#t $r}t ||Yd}~nd}~wwxYw t |j|jjd{7#t $r}t ||Yd}~d}~wwxYwd}~wwxYwwrJ) r`rrbrcrr?rr)rKr)r.acquireacquire_futurerhrCs r3rQzAsyncReadWriteLock._run_acquiresg. ">2 2 2 ~& 3%%  <#N333  <&|U;; < <#DLL1C1C$DEEE ! <&|U;;  < sC$646 C$6C! AAAC A>( A94C9A>>C1B:3B64B:9C: C CCCCC!!C$cK|j|g|i|} t|d{t|S7#tj$r=} t |d{7#t $r}t ||Yd}~d}~wwxYwd}~wwxYwwrJ)r`rrbrcrr?rr)r.funcargskwargsfuturerhrCs r3r\zAsyncReadWriteLock._run sd4T4V4 "6* * *f%% +%%  <#F+++ ! <&|U;;  < saB :8: B :B A#AA#"B# B, A=8B=BBB  B c |jxstjj|jt t j|g|i|SrJ)r*rbget_running_looprun_in_executorr,rrRrS)r.rmrnros r3r`zAsyncReadWriteLock._submitsK 8g668II NN    d 4T 4V 4  r7cV|jr|jjdyy)NFr^)r+r,rfr6s r3rdz+AsyncReadWriteLock._shutdown_owned_executor"s%    NN # # # / r7c`|jxs!tj|jk7SrJ)r'r$r%r&r6s r3r[zAsyncReadWriteLock._inherited&s$%%I8I8I)IIr7ct|jrd|jd}t||jrd}t j |y)NzAsyncReadWriteLock on z4 was invalidated by fork(); construct a new instancez$Cannot operate on a closed database.)r r[r/r-r(sqlite3ProgrammingError)r.r2s r3rPz%AsyncReadWriteLock._raise_if_unusable*sP! ??*4>>*::noCs# # <<8C**3/ / r7cd|_y)NT)r'r6s r3_reset_after_fork_in_childz-AsyncReadWriteLock._reset_after_fork_in_child3s !%r7ctjt|ddk(r+t|ddr|jj dyyy)Nr&r+Fr^)r$r%getattrr,rfr6s r3__del__zAsyncReadWriteLock.__del__6sG 99;'$= ='$P`bgBh NN # # # /Ci =r7))r/zstr | os.PathLike[str]r0floatrboolrrr asyncio.AbstractEventLoop | Noner!zfutures.Executor | NonereturnNone)rstr)rr)rr)rr)rzfutures.ExecutorrJ)r0z float | Nonerz bool | NonerzAsyncGenerator[None])rBBaseException | Nonerr)r0rrrrrT)rYrrr)rr)rjz Callable[[], AcquireReturnProxy]rr)rmCallable[_P, _R]rn_P.argsro _P.kwargsrr)rmrrnrrorrz#asyncio.Future[_BackendOutcome[_R]])__name__ __module__ __qualname____doc__r4propertyr/r0rr r!rrDrHr@r>rGrKrarQr\r`rdr[rPrzr}r7r3rr(s0( !15,0()((  (  (/(*( (0$$""##7W[7707X\770;$;&;4;&.39 [<' & $ -4 @I , 0JJ0&0r7rc8eZdZdZddZddZ ddZy) rTzEContext-aware object that releases the async read/write lock on exit.c||_yrJrN)r.rOs r3r4z)AsyncAcquireReadWriteReturnProxy.__init__@s  r7c"K|jSwrJrNr6s r3 __aenter__z+AsyncAcquireReadWriteReturnProxy.__aenter__Csyys cTK|jjd{y7wrJ)rOrK)r.exc_type exc_value tracebacks r3 __aexit__z*AsyncAcquireReadWriteReturnProxy.__aexit__Fs ii!!!s (&(N)rOrrr)rr)rztype[BaseException] | NonerrrzTracebackType | Nonerr)rrrrr4rrrr7r3rTrT=s:O","("( "  "r7rT)*r __future__rrbrRr$rwconcurrent.futuresr contextlibrtypingrrr_apir r r r _asyncrrrrrr _read_writercollections.abcrr concurrentrtypesrrrrrrT__all__rr7r3rsK" 1*44 '8"#(t_ T]R0R0j""&' r7