dtj 4FdZddlmZddlZddlZddlZddlZddlmZddl 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)dS)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_RcpeZdZdZ d>dddddd?dZed@dZedAdZedBdZedCdZ edDdZ e dEdddFdZ e dEdddFd Z dGd#Zd>dddHd%Zd>dddHd&Zd'd(dId*ZdJd+ZdKd.ZdLd6ZdMd8ZdJd9ZedBd:ZdJd;ZdJd<ZdJd=ZdS)NAsyncReadWriteLocka 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_singletonloopexecutor lock_filestr | os.PathLike[str]timeoutfloatrboolr r! asyncio.AbstractEventLoop | Noner"futures.Executor | NonereturnNonectj}||_d|_d|_t |t 5t|||||_||_ |du|_ |ptd|_ tj|krd}t| ddddS#1swxYwYdS)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) selfr#r%rr r!r" creator_pidmsgs X/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/filelock/_async_read_write.py__init__zAsyncReadWriteLock.__init__>sikk '!& d###    ( (&y'H[ghhhDJDJ"*d"2D %J);)J)J)JDNy{{k))R"3'''*  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (sA(B<<CCstrc|jjS)zThe path to the lock file.)r3r#r8s r;r#zAsyncReadWriteLock.lock_fileVsz##c|jjS)zThe default timeout.)r3r%r?s r;r%zAsyncReadWriteLock.timeout[sz!!r@c|jjS)z'Whether blocking is enabled by default.)r3rr?s r;rzAsyncReadWriteLock.blocking`sz""r@c|jS)z2The event loop (or ``None`` for the running loop).)r4r?s r;r!zAsyncReadWriteLock.loopes zr@futures.Executorc|jS)z_The executor used for ``run_in_executor`` (a dedicated single-thread one if none was supplied).)r6r?s r;r"zAsyncReadWriteLock.executorjs ~r@r float | None bool | NoneAsyncGenerator[None]c0K| |jj}| |jj}|||d{Vd} dWVn#t$r}|}d}~wwxYw ||d{VdS#||d{VwxYw)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 NrF)r3r%r acquire_read BaseException_release_in_contextr8r%r body_errorerrors r; read_lockzAsyncReadWriteLock.read_lockos ?j(G  z*H(;;;;;;;;;+/  7 EEEEE   J    **:66 6 6 6 6 6 6 6 6 6$**:66 6 6 6 6 6 6 6 6)AA8 AAAA88Bc0K| |jj}| |jj}|||d{Vd} dWVn#t$r}|}d}~wwxYw ||d{VdS#||d{VwxYw)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 NrF)r3r%r acquire_writerLrMrNs r; write_lockzAsyncReadWriteLock.write_locks ?j(G  z*H  8 <<<<<<<<<+/  7 EEEEE   J    **:66 6 6 6 6 6 6 6 6 6$**:66 6 6 6 6 6 6 6 6rRrOBaseException | NonecK |d{VdS#t$r}|t||d}~wwxYwN)releaserLr )r8rO release_errors r;rMz&AsyncReadWriteLock._release_in_contextsi ,,..    %)-DDD  s A=A AsyncAcquireReadWriteReturnProxycK||tj|jj||d{Vt |S)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 rFNlock)_raise_if_unusable _run_acquire functoolspartialr3rKr[r8r%rs r;rKzAsyncReadWriteLock.acquire_readsi !!! 1$*2I7]e f f fggggggggg/T::::r@cK||tj|jj||d{Vt |S)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 rFNr])r_r`rarbr3rTr[rcs r;rTz AsyncReadWriteLock.acquire_writesi !!! 1$*2JG^f g g ghhhhhhhhh/T::::r@FforcerfcKt|jrdS||jj|d{VdS)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`` Nre)r _inherited_runr3rY)r8rfs r;rYzAsyncReadWriteLock.releasesV !!! ?  Fii *%i88888888888r@cFKt|jrdS|jrdS||jj} t |d{Vnq#tj$r_} t|d{Vn'#t$r}t||Yd}~nd}~wwxYwd|_| d}~wwxYwt|d|_|jr:tjt!j|jjdd{VdSdS)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 rhr2_submitr3closerasyncioCancelledErrorrrLr_shutdown_owned_executorrr5 to_threadrarbr6shutdown)r8 close_future cancellationrPs r;rnzAsyncReadWriteLock.closes !!! ?  F <  F||DJ$455  "<00 0 0 0 0 0 0 0 0%    <#L1111111111  < < <&|U;;;;;;;; <DL  ) ) + + +   |$$$    [#I$5dn6MTX$Y$Y$YZZ Z Z Z Z Z Z Z Z Z [ [s<AC)A?>C? B# BCB##CCacquire Callable[[], AcquireReturnProxy]cK||} t|d{Vn#tj$r} t |d{Vn'#t $r}t ||Yd}~nd}~wwxYw t ||jjd{Vn'#t $r}t ||Yd}~nd}~wwxYwd}~wwxYwt|dSrX) rmrrorprrLrr3rYr)r8rvacquire_futurerurPs r;r`zAsyncReadWriteLock._run_acquiresWg.. ">22 2 2 2 2 2 2 2 2%    <#N3333333333  < < <&|U;;;;;;;; < <#DLL1C$D$DEEEEEEEEEE  < < <&|U;;;;;;;; <   ~&&&&&sb/CAC A9A4/C4A99C=2B0/C0 C:C CCCCfuncCallable[_P, _R]args_P.argskwargs _P.kwargsrc K|j|g|Ri|} t|d{VnV#tj$rD} t |d{Vn'#t $r}t ||Yd}~nd}~wwxYwd}~wwxYwt|SrX)rmrrorprrLrr)r8rzr|r~futurerurPs r;rizAsyncReadWriteLock._run sd4T444V44 "6** * * * * * * * *%    <#F++++++++++  < < <&|U;;;;;;;; <    f%%%s8+A>AA9 A5A0+A90A55A99A>#asyncio.Future[_BackendOutcome[_R]]c |jptj|jt t j|g|Ri|SrX)r4roget_running_looprun_in_executorr6rrarb)r8rzr|r~s r;rmzAsyncReadWriteLock._submitsR 8g688II N   d 4T 4 4 4V 4 4   r@cN|jr|jddSdS)NFrk)r5r6rsr?s r;rqz+AsyncReadWriteLock._shutdown_owned_executor"s6   0 N # # # / / / / / 0 0r@cH|jptj|jkSrX)r1r.r/r0r?s r;rhzAsyncReadWriteLock._inherited&s%I8I)IIr@ct|jrd|jd}t||jrd}t j|dS)NzAsyncReadWriteLock on z4 was invalidated by fork(); construct a new instancez$Cannot operate on a closed database.)r rhr#r7r2sqlite3ProgrammingError)r8r:s r;r_z%AsyncReadWriteLock._raise_if_unusable*sb!!! ? $o4>oooCs## # < 08C*3// / 0 0r@cd|_dS)NT)r1r?s r;_reset_after_fork_in_childz-AsyncReadWriteLock._reset_after_fork_in_child3s!%r@ctjt|ddkr.t|ddr|jddSdSdS)Nr0r5Frk)r.r/getattrr6rsr?s r;__del__zAsyncReadWriteLock.__del__6sa 9;;'$== = ='$P`bgBhBh = N # # # / / / / / > = = =r@)r)r#r$r%r&rr'r r'r!r(r"r)r*r+)r*r=)r*r&)r*r')r*r()r*rDrX)r%rGrrHr*rI)rOrVr*r+)r%r&rr'r*r[)rfr'r*r+)r*r+)rvrwr*r+)rzr{r|r}r~rr*r)rzr{r|r}r~rr*r)__name__ __module__ __qualname____doc__r<propertyr#r%rr!r"rrQrUrMrKrTrYrnr`rirmrqrhr_rrr@r;rr(s0( !15,0((((((0$$$X$"""X"###X#XX7W[77777707X\7777770;$;;;;;;&;4;;;;;;&.3999999 [[[[<'''' & & & &    0000JJJXJ0000&&&&000000r@rc*eZdZdZddZddZddZdS)r[zEContext-aware object that releases the async read/write lock on exit.r^rr*r+c||_dSrXr])r8r^s r;r<z)AsyncAcquireReadWriteReturnProxy.__init__@s  r@cK|jSrXr]r?s r; __aenter__z+AsyncAcquireReadWriteReturnProxy.__aenter__Csyr@exc_typetype[BaseException] | None exc_valuerV tracebackTracebackType | NonecHK|jd{VdSrX)r^rY)r8rrrs r; __aexit__z*AsyncAcquireReadWriteReturnProxy.__aexit__Fs4 i!!!!!!!!!!!r@N)r^rr*r+)r*r)rrrrVrrr*r+)rrrrr<rrrr@r;r[r[=sVOO""""""r@r[)*r __future__rrorar.rconcurrent.futuresr contextlibrtypingrrr_apir r r r _asyncrrrrrr _read_writercollections.abcrr concurrentrtypesrrrrrr[__all__rr@r;rsKK"""""" 111111******4444444444 '&&&&&)88888888""""""######((((((Yt__ WT]]R0R0R0R0R0R0R0R0j""""""""&' r@