jgFldZddlmZgdZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZddlmZmZmZmZmZmZdd lmZmZmZmZdd lmZmZmZmZm Z m!Z!m"Z"m#Z#dd l$m%Z%dd l&m'Z'erdd l(m)Z)m*Z*m+Z+ddl,m-Z-ddl.m/Z/ddlm0Z0edZ1edZ2GddZ3GddZ4ddgZ5y)zEAsync wrapper around :class:`ReadWriteLock` for use with ``asyncio``.) annotations)asynciozconcurrent.futureszfilelock._asynczfilelock._error functools threadingN)ThreadPoolExecutor)thread)asynccontextmanager) TYPE_CHECKINGFinalLiteral ParamSpecTypeVarcast)_append_exception_context_ensure_current_process_fork_transition_register_fork_object)_TASKS_THREAD_ID_BackendOutcome _capture_call _drain_future_future_result_raise_cancelled_error_task_owners_for_wait_until_done)Timeout) ReadWriteLock)AsyncGeneratorCallableMutableMapping)futures) TracebackType)AcquireReturnProxy_P_RceZdZdZ dddddd d dZed!dZed"dZed#dZed$d Z ed%d Z e d&dd d'd Z e d&dd d'd Z d(dZ d&dd  d)dZ d&dd  d)dZd*dZddd+dZd,dZd-dZd#dZd,dZ d.dZd,dZed#dZd,dZd,dZd,dZy)/AsyncReadWriteLockaB 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. Each ``asyncio`` task owns its own hold. Tasks share a read lock, and a task asking for the write lock waits until the other holders release, with waiting writers ahead of new readers. As with :class:`ReadWriteLock`, upgrading or downgrading a held lock raises :class:`RuntimeError`. Singleton wrappers over one path share their task holds, and closing one ends only the holds taken through it. :param lock_file: path to the SQLite database file used as the lock :param timeout: maximum wait time in seconds; ``-1`` waits up to SQLite's busy-timeout cap of about 23 days :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_singletonloopexecutorctj}||_d|_d|_| |_t |_t|t5t|||||_ t|j|_ ||_|du|_|xs t!d|_tj|k7r d}t%| dddy#1swYyxYw)NF)r(r)) max_workersz:AsyncReadWriteLock construction cannot continue after fork)osgetpid _creator_pid_fork_invalidated_closed _owns_backendobject_viarrr_lockr_owners_loop_owns_executorr _executor RuntimeError) self lock_filetimeoutr(r)r*r+ creator_pidmsgs g/home/oem/CyberBrain26-unified/dev-env/.venv/lib/python3.12/site-packages/filelock/_async_read_write.py__init__zAsyncReadWriteLock.__init__Hsiik '!& !--!8 d#   (&y'H[ghDJ+DJJ7DLDJ"*d"2D %J);)JDNyy{k)R"3''*  ( ( (s A8CC!c.|jjS)zThe path to the lock file.)r7r>r=s rBr>zAsyncReadWriteLock.lock_filedszz###c.|jjS)zThe default timeout.)r7r?rEs rBr?zAsyncReadWriteLock.timeoutiszz!!!rFc.|jjS)z'Whether blocking is enabled by default.)r7r(rEs rBr(zAsyncReadWriteLock.blockingnszz"""rFc|jS)z2The event loop (or ``None`` for the running loop).)r9rEs rBr*zAsyncReadWriteLock.loopsszzrFc|jS)z_The executor used for ``run_in_executor`` (a dedicated single-thread one if none was supplied).)r;rEs rBr+zAsyncReadWriteLock.executorxs~~rFr(cK|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 rKN) acquire_read BaseException_release_in_contextr=r?r( body_errorerrors rB read_lockzAsyncReadWriteLock.read_lock}s|(;;;+/  7  **:6 6 6 < J   7$**:6 6 6YA8AA8AA8AA8 A AAAA8A5.A1/A55A8cK|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 rKN) acquire_writerNrOrPs rB write_lockzAsyncReadWriteLock.write_locks|  8 <<<+/  7  **:6 6 6 = J   7$**:6 6 6rTcK |jd{y7#t$r}| t||d}~wwxYwwN)releaserNr)r=rQ release_errors rBrOz&AsyncReadWriteLock._release_in_contexts< ,,.  %)-D  s(?? <7<?c~K|j|jd||d{t|S7w)ao Acquire a shared read lock. See :meth:`ReadWriteLock.acquire_read` for full semantics. :param timeout: seconds to wait; ``None`` uses the instance setting; ``-1`` waits up to SQLite's busy-timeout cap of about 23 days :param blocking: if ``False``, raise :class:`~filelock.Timeout` on contention; ``None`` uses the instance setting :returns: a proxy that can be used as an async context manager to release the lock :raises RuntimeError: if the calling task already holds the write lock :raises Timeout: if the lock cannot be acquired within *timeout* seconds :raises TypeError: if *timeout* is a :class:`bool` or not a real number, or *blocking* is not a :class:`bool` :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1`` readrKNlock_raise_if_unusable_acquire AsyncAcquireReadWriteReturnProxyr=r?r(s rBrMzAsyncReadWriteLock.acquire_reads=* !mmFGhm???/T:: @ (=;=c~K|j|jd||d{t|S7w)at Acquire an exclusive write lock. See :meth:`ReadWriteLock.acquire_write` for full semantics. :param timeout: seconds to wait; ``None`` uses the instance setting; ``-1`` waits up to SQLite's busy-timeout cap of about 23 days :param blocking: if ``False``, raise :class:`~filelock.Timeout` on contention; ``None`` uses the instance setting :returns: a proxy that can be used as an async context manager to release the lock :raises RuntimeError: if the calling task already holds the read lock :raises Timeout: if the lock cannot be acquired within *timeout* seconds :raises TypeError: if *timeout* is a :class:`bool` or not a real number, or *blocking* is not a :class:`bool` :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1`` writerKNr^r`rds rBrVz AsyncReadWriteLock.acquire_writes=* !mmGWxm@@@/T:: Arec K| jn|} jndfd }dfd }jj|jj ||d{y7w)Nc Kjjtjjj t |d{y7w)NrK)ra _run_acquirerpartialr7_acquire_level_ofr) remainingr(moder=s rBenterz*AsyncReadWriteLock._acquire..entersR  # # %##!!JJ00$%   sAA AA cDjjSrY)ra_backend_holdsrEsrBjoinablez-AsyncReadWriteLock._acquire..joinables  # # %&&( (rF)r?r(r>viarorr)rmfloatreturnNonerubool)r?r(r8acquirer>r6)r=rnr?r(rorrs`` ` rBrbzAsyncReadWriteLock._acquiresp")/$,,w$,$44==(  )ll"" nn #   sA(A5-A3.A5F)forcec Kt|jry|jj||j|j t j|j|j|jd{y7w)a Release one level of the calling task's hold. The wrapper releases the database lock once no task holds it. :param force: if ``True``, end every level the calling task took through this wrapper. Levels taken through other wrappers on the same path stay. A wrapper that holds no level for the task releases nothing. :raises RuntimeError: if the calling task holds no level through this wrapper and *force* is ``False`` N)rzr>rsleave still_held) r _inheritedr8rZr>r6rrk_submit_leave_backendrq)r=rzs rBrZzAsyncReadWriteLock.releasesm ! ?? ll""nn ##DLL$2E2EF** #   sBB B B cKt|jry|jryd|_ |jj |j rdn |j tj|j|j r|jjn |j|jd{|j&rGt!j(tj|j*j,dd{yy7X#t$rH}t|t j"s|jrd|_|j%d}~wwxYw7\w)a End the holds of the tasks that acquired through this instance and release the lock once no task holds it. After calling this method, the lock instance is no longer usable. With ``is_singleton=False`` it also closes the underlying SQLite connection. A singleton wrapper leaves the shared :class:`ReadWriteLock` open, so tasks that acquired through another wrapper and synchronous users of the same path keep their holds. The next acquire notices a synchronous ``close()`` or forced release of that shared lock. One that lands in the few bytecodes between that check and the admission still admits the task into the ended hold. NT)r|r}Fwait)rr~r3r8retirer4r6rrkrr7closerrqrN isinstancerCancelledError_shutdown_owned_executorr: to_threadr;shutdown)r=rRs rBrzAsyncReadWriteLock.closes) ! ??  <<   ,,%%** '' $J\J\djj6F6Fbfbubuv..&     ##I$5$5dnn6M6MTX$YZ Z Z    eW%;%;<ATATAV$  --/    [sI,E-B D<D=DA E-E+E-D E( AE##E((E-c.Ktj}|j||j} t |d{t|y7#t j $r}|j t|d{7n-#t$r|dt$r}t||Yd}~nd}~wwxYw t|j|jd{7#t$r}t||Yd}~d}~wwxYwd}~wwxYww)N) cancel_check)rEventris_setrrrsetrrrNrrr)r=ry abandonedacquire_future cancellationrRs rBrjzAsyncReadWriteLock._run_acquire;sOO% gI2 2 2 ~&! 3%%  MMO <#N333 -",  <&|U;; < <#DLL1D1D$EFFF ! <&|U;;  < s2DAAA DAD)D :BB  BD B9# B4/D 4B99D ='C+$C'%C+*D + D 4 DD D  D  DDc@|jjtSrY)r7_holds_level_ofrrEs rBrqz!AsyncReadWriteLock._backend_holdsQszz))*:;;rFcB|jjtyrY)r7_release_level_ofrrEs rBrz!AsyncReadWriteLock._leave_backendUs $$%56rFc |jxstjj|jt t j|g|i|SrY)r9rget_running_looprun_in_executorr;rrrk)r=funcargskwargss rBrzAsyncReadWriteLock._submitYsK 8g668II NN    d 4T 4V 4  rFcV|jr|jjdyy)NFr)r:r;rrEs rBrz+AsyncReadWriteLock._shutdown_owned_executorbs%    NN # # # / rFc`|jxs!tj|jk7SrY)r2r/r0r1rEs rBr~zAsyncReadWriteLock._inheritedfs$%%I8I8I)IIrFct|jrd|jd}t||jrd}t j |y)NzAsyncReadWriteLock on z4 was invalidated by fork(); construct a new instancez$Cannot operate on a closed database.)rr~r>r<r3sqlite3ProgrammingError)r=rAs rBraz%AsyncReadWriteLock._raise_if_unusablejsP! ??*4>>*::noCs# # <<8C**3/ / rFcd|_|jrRtdtj}td|j j D]}|j|dyy)NTz(MutableMapping[threading.Thread, object]r)r2r:rexecutor_threads_threads_queuesr;_threadspop)r=registryworkers rB_reset_after_fork_in_childz-AsyncReadWriteLock._reset_after_fork_in_childssa!%    : 00H3T^^DMM + VT* + rFctjt|ddk(r+t|ddr|jj dyyy)Nr1r:Fr)r/r0getattrr;rrEs rB__del__zAsyncReadWriteLock.__del__sG 99;'$= ='$P`bgBh NN # # # /Ci =rF))r>zstr | os.PathLike[str]r?rtr(rxr)rxr* asyncio.AbstractEventLoop | Noner+zfutures.Executor | Nonerurv)rustr)rurtrw)rur)ruzfutures.ExecutorrY)r? float | Noner( bool | NoneruzAsyncGenerator[None])rQBaseException | Nonerurv)r?rr(rrurc)rnzLiteral['read', 'write']r?rr(rrurv)rzrxrurv)rurv)ryz!Callable[..., AcquireReturnProxy]rurv)rzCallable[_P, _R]rz_P.argsrz _P.kwargsruz#asyncio.Future[_BackendOutcome[_R]])__name__ __module__ __qualname____doc__rCpropertyr>r?r(r*r+r rSrWrOrMrVrbrZrrjrqrrrr~rarrrFrBr'r'0s4( !15,0()((  (  (/(*( (8$$""##7W[77(7X\77('+;GK;#;9D; );4'+;GK;#;9D; );2 >.3 ."[H',<7 $ -4 @I , 0JJ0 +0rFr'c8eZdZdZddZddZ ddZy) rczEContext-aware object that releases the async read/write lock on exit.c||_yrYr^)r=r_s rBrCz)AsyncAcquireReadWriteReturnProxy.__init__s  rFc"K|jSwrYr^rEs rB __aenter__z+AsyncAcquireReadWriteReturnProxy.__aenter__syys cTK|jjd{y7wrY)r_rZ)r=exc_type exc_value tracebacks rB __aexit__z*AsyncAcquireReadWriteReturnProxy.__aexit__s ii!!!s (&(N)r_r'rurv)rur')rztype[BaseException] | NonerrrzTracebackType | Nonerurv)rrrrrCrrrrFrBrcrcs:O","("( "  "rFrc)6r __future__r__lazy_modules__rrr/rrconcurrent.futuresrrr contextlibr typingr r r r rr filelock._apirrrrfilelock._asyncrrrrrrrrfilelock._errorrfilelock._read_writercollections.abcrrr concurrentr!typesr"r#r$r%r'rc__all__rrFrBrsK"t 19*JJ   $.HH"#0t_ T]U0U0p ""&' rF