"ja7NdZddlmZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z mZmZddlmZmZmZmZdd lmZmZmZmZmZmZmZdd lmZe rdd lm Z m!Z!dd l"m#Z#dd l$m%Z%ddlm&Z&edZ'edZ(GddZ)GddZ*ddgZ+dS)zEAsync wrapper around :class:`ReadWriteLock` for use with ``asyncio``.) annotationsN)ThreadPoolExecutor)asynccontextmanager) TYPE_CHECKINGLiteral ParamSpecTypeVar)_append_exception_context_ensure_current_process_fork_transition_register_fork_object)_BackendOutcome _capture_call _drain_future_future_result_raise_cancelled_error_task_owners_for_wait_until_done) ReadWriteLock)AsyncGeneratorCallable)futures) TracebackType)AcquireReturnProxy_P_Rc|eZdZdZ dAddddddBdZedCdZedDdZedEdZedFdZ edGdZ e dHdddIdZ e dHdddId Z dJd#Z dHdddKd%Z dHdddKd&ZdLd)Zd*d+dMd-ZdNd.ZdOd1ZdPd9ZdQd;ZdNd<ZedEd=ZdNd>ZdNd?ZdNd@ZdS)RAsyncReadWriteLocka 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. :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]timeoutfloatr!boolr"r# asyncio.AbstractEventLoop | Noner$futures.Executor | NonereturnNonectj}||_d|_d|_t |t 5t|||||_t|j|_ ||_ |du|_ |ptd|_tj|krd}t| ddddS#1swxYwYdS)NF)r!r"r ) max_workersz:AsyncReadWriteLock construction cannot continue after fork)osgetpid _creator_pid_fork_invalidated_closedrr r_lockr_owners_loop_owns_executorr _executor RuntimeError) selfr%r'r!r"r#r$ creator_pidmsgs Z/home/spazio/kingdom_calls/venv/lib/python3.11/site-packages/filelock/_async_read_write.py__init__zAsyncReadWriteLock.__init__As#ikk '!& d###    ( (&y'H[ghhhDJ+DJ77DLDJ"*d"2D %J);)J)J)JDNy{{k))R"3'''*  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (sBCCCstrc|jjS)zThe path to the lock file.)r5r%r;s r>r%zAsyncReadWriteLock.lock_fileZsz##c|jjS)zThe default timeout.)r5r'rBs r>r'zAsyncReadWriteLock.timeout_sz!!rCc|jjS)z'Whether blocking is enabled by default.)r5r!rBs r>r!zAsyncReadWriteLock.blockingdsz""rCc|jS)z2The event loop (or ``None`` for the running loop).)r7rBs r>r#zAsyncReadWriteLock.loopis zrCfutures.Executorc|jS)z_The executor used for ``run_in_executor`` (a dedicated single-thread one if none was supplied).)r9rBs r>r$zAsyncReadWriteLock.executorns ~rCr! float | None bool | NoneAsyncGenerator[None]cK|||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 rIN) acquire_read BaseException_release_in_contextr;r'r! body_errorerrors r> read_lockzAsyncReadWriteLock.read_lockss(;;;;;;;;;+/  7 EEEEE   J    **:66 6 6 6 6 6 6 6 6 6$**:66 6 6 6 6 6 6 6 6 )A ;6;AA9cK|||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 rIN) acquire_writerOrPrQs r> write_lockzAsyncReadWriteLock.write_locks  8 <<<<<<<<<+/  7 EEEEE   J    **:66 6 6 6 6 6 6 6 6 6$**:66 6 6 6 6 6 6 6 6rUrRBaseException | NonecK |d{VdS#t$r}|t||d}~wwxYwN)releaserOr )r;rR release_errors r>rPz&AsyncReadWriteLock._release_in_contextsi ,,..    %)-DDD  s A=A AsyncAcquireReadWriteReturnProxycK||d||d{Vt|S)a` 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 without a limit :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 readrINlock_raise_if_unusable_acquirer^r;r'r!s r>rNzAsyncReadWriteLock.acquire_readsU$ !!!mmFGhm?????????/T::::rCcK||d||d{Vt|S)ae 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 without a limit :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 writerINrarcrfs r>rWz AsyncReadWriteLock.acquire_writesU$ !!!mmGWxm@@@@@@@@@/T::::rCmodeLiteral['read', 'write']cK|jn|}jn|dkr jjn jjdfd }j||j|d{VdS) Nr` remainingr(r,r-clKtj|d{VdS)NrI) _run_acquire functoolspartial)rlr!r; sync_acquires r>enterz*AsyncReadWriteLock._acquire..entersF##I$5lIX`$a$a$abb b b b b b b b b brC)r'r!r%rr)rlr(r,r-)r'r!r5rNrWr6acquirer%)r;rir'r!rrrqs` ` @r>rezAsyncReadWriteLock._acquires")/$,,w$,$44==(26&..tz..djF^  c c c c c c c cl""48W[Wemr"sssssssssssrCF)forcertcKt|jrdS|j||jt j|j|jjd{VdS)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``, drop the calling task's whole hold at any nesting level :raises RuntimeError: if the calling task holds no lock and *force* is ``False`` N)rtr%leave) r _inheritedr6r\r%rorp_runr5)r;rts r>r\zAsyncReadWriteLock.releases !!! ?  Fl""4>9J49VZV`Vh9i9i#           rCcKt|jrdS|jrdS||jj} t |d{Vn#tj$rx} t|d{Vn'#t$r}t||Yd}~nd}~wwxYwd|_|j |d}~wwxYwt|d|_|j |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 rwr4_submitr5closerasyncioCancelledErrorrrOrr6reset_shutdown_owned_executorrr8 to_threadrorpr9shutdown)r; close_future cancellationrSs r>r}zAsyncReadWriteLock.closes !!! ?  F <  F||DJ$455  "<00 0 0 0 0 0 0 0 0%    <#L1111111111  < < <&|U;;;;;;;; <DL L    ) ) + + +   |$$$     [#I$5dn6MTX$Y$Y$YZZ Z Z Z Z Z Z Z Z Z [ [s<AC )A?>C? B# BCB##8CC rs 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|dSr[) r|rr~rrrOrr5r\r)r;rsacquire_futurerrSs r>rnzAsyncReadWriteLock._run_acquire sWg.. ">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|Sr[)r|rr~rrrOrr)r;rrrfuturerrSs r>rxzAsyncReadWriteLock._runsd4T444V44 "6** * * * * * * * *%    <#F++++++++++  < < <&|U;;;;;;;; <    f%%%s8+A>AA9 A5A0+A90A55A99A>#asyncio.Future[_BackendOutcome[_R]]c |jptj|jt t j|g|Ri|Sr[)r7r~get_running_looprun_in_executorr9rrorp)r;rrrs r>r|zAsyncReadWriteLock._submit)sR 8g688II N   d 4T 4 4 4V 4 4   rCcN|jr|jddSdS)NFrz)r8r9rrBs r>rz+AsyncReadWriteLock._shutdown_owned_executor2s6   0 N # # # / / / / / 0 0rCcH|jptj|jkSr[)r3r0r1r2rBs r>rwzAsyncReadWriteLock._inherited6s%I8I)IIrCct|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 rwr%r:r4sqlite3ProgrammingError)r;r=s r>rdz%AsyncReadWriteLock._raise_if_unusable:sb!!! ? $o4>oooCs## # < 08C*3// / 0 0rCcd|_dS)NT)r3rBs r>_reset_after_fork_in_childz-AsyncReadWriteLock._reset_after_fork_in_childCs!%rCctjt|ddkr.t|ddr|jddSdSdS)Nr2r8Frz)r0r1getattrr9rrBs r>__del__zAsyncReadWriteLock.__del__Fsa 9;;'$== = ='$P`bgBhBh = N # # # / / / / / > = = =rC)r )r%r&r'r(r!r)r"r)r#r*r$r+r,r-)r,r@)r,r()r,r))r,r*)r,rGr[)r'rJr!rKr,rL)rRrYr,r-)r'rJr!rKr,r^)rirjr'rJr!rKr,r-)rtr)r,r-)r,r-)rsrr,r-)rrrrrrr,r)rrrrrrr,r)__name__ __module__ __qualname____doc__r?propertyr%r'r!r#r$rrTrXrPrNrWrer\r}rnrxr|rrwrdrrrCr>rr)s4( !15,0((((((2$$$X$"""X"###X#XX7W[777777(7X\777777('+;GK;;;;;;.'+;GK;;;;;;,tttt.3      $[[[[@'''' & & & &    0000JJJXJ0000&&&&000000rCrc*eZdZdZddZddZddZdS)r^zEContext-aware object that releases the async read/write lock on exit.rbrr,r-c||_dSr[ra)r;rbs r>r?z)AsyncAcquireReadWriteReturnProxy.__init__Ps  rCcK|jSr[rarBs r> __aenter__z+AsyncAcquireReadWriteReturnProxy.__aenter__SsyrCexc_typetype[BaseException] | None exc_valuerY tracebackTracebackType | NonecHK|jd{VdSr[)rbr\)r;rrrs r> __aexit__z*AsyncAcquireReadWriteReturnProxy.__aexit__Vs4 i!!!!!!!!!!!rCN)rbrr,r-)r,r)rrrrYrrr,r-)rrrrr?rrrrCr>r^r^MsVOO""""""rCr^),r __future__rr~ror0rconcurrent.futuresr contextlibrtypingrrrr _apir r r r_asyncrrrrrrr _read_writercollections.abcrr concurrentrtypesrrrrrr^__all__rrCr>rsKK"""""" 111111******============ '&&&&&)88888888""""""######((((((Yt__ WT]]a0a0a0a0a0a0a0a0H """"""""&' rC