:j<bUddlmZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z ddl m Z mZddlmZddlmZddlmZe rdd lmZej.d ZeZd ed <ej8Zdd Zej>edZ ddZ!Gdde"Z#Gdde#Z$y)) annotationsN)contextmanagersuppress) TYPE_CHECKINGLiteral)WeakValueDictionary)AcquireReturnProxy)Timeout) Generatorfilelockzset[sqlite3.Connection]_all_connectionsct5ttD]*}tt5|j ddd,tj dddy#1swYSxYw#1swYyxYwN)_all_connections_locklistrr Exceptioncloseclear)cons i/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/filelock/_read_write.py_cleanup_connectionsrsm !() C)$       !!  !!s!"A-A!A-!A* &A--A6i5wc|dury|dk(rtS|dkr d}t||dkDrt||z dn|}t|dz}|tkDs|dkr!tj d|ttS|S)NFrz+timeout must be a non-negative number or -1iz7timeout %s is too large for SQLite, using %s ms instead)_MAX_SQLITE_TIMEOUT_MS ValueErrormaxint_LOGGERwarning)timeoutblockingalready_waitedmsg remaining timeout_mss rtimeout_for_sqliter'(s5"}%%{;o4;aKGn,a0WIY%&J**j1nQSZ\rs%% cXeZdZUdZded<ded< d ddd d fdZxZS) _ReadWriteLockMetaa" Metaclass that handles singleton resolution when is_singleton=True. Singleton logic lives here rather than in ReadWriteLock.get_lock so that ``ReadWriteLock(path)`` transparently returns cached instances without a 2-arg ``super()`` call that type checkers cannot verify. 0WeakValueDictionary[pathlib.Path, ReadWriteLock] _instanceszthreading.Lock_instances_lockTr" is_singletonc |st|||||Stj|j }|j 5||j vr#t|||||}||j |<n|j |}|j|k7s|j|k7r-d|jd|jd|d|}t||cdddS#1swYyxYw)Nr.z$Singleton lock created with timeout=z , blocking=z, cannot be changed to timeout=) super__call__pathlibPathresolver-r,r!r"r) cls lock_filer!r"r/ normalizedinstancer$ __class__s rr2z_ReadWriteLockMeta.__call__Gs7#IwXd#e e\\),446  / 7+Iw`l+m-5z*>>*57*h.?.?8.K:8;K;K:LKX`XiXiWjk55return ReadWriteLock)__name__ __module__ __qualname____doc____annotations__r2 __classcell__)r:s@rr*r*;scA@##  ! )     r(r*cVeZdZUdZeZded<ejZ e ddd ddZ dddd ddZ dd Z dd Z dd Zdd Z dd ZdddddZdddddZddd dZed!ddd"dZed!ddd"dZd#dZy)$r@a Cross-process read-write lock backed by SQLite. Allows concurrent shared readers or a single exclusive writer. The lock is reentrant within the same mode (multiple ``acquire_read`` calls nest, as do multiple ``acquire_write`` calls from the same thread), but upgrading from read to write or downgrading from write to read raises :class:`RuntimeError`. Write locks are pinned to the thread that acquired them. By default, ``is_singleton=True``: calling ``ReadWriteLock(path)`` with the same resolved path returns the same instance. The lock file must use a ``.db`` extension (SQLite database). :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 instances for the same resolved path .. versionadded:: 3.21.0 r+r,Tr"c||||S)a  Return the singleton :class:`ReadWriteLock` for *lock_file*. :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 :returns: the singleton lock instance :raises ValueError: if an instance already exists for this path with different *timeout* or *blocking* values rH)r6r7r!r"s rget_lockzReadWriteLock.get_lock{s 9g99r(r.ctj||_||_||_t j |_t j |_d|_ d|_ d|_ tj|jd|_t5t j#|jdddy#1swYyxYw)NrF)check_same_thread)osfspathr7r!r" threadingLock_transaction_lock_internal_lock _lock_level _current_mode_write_thread_idsqlite3connect_conrradd)selfr7r!r"r/s r__init__zReadWriteLock.__init__s9-   !*!1'nn.>B,0OODNNeL " ,   + , , ,s  CCc|s|jjd}n?|dk(r|jjd}n|jjd|}|st|jdy)NFrHrTr"r!)rRacquirer r7)r[r"r!acquireds r_acquire_transaction_lockz'ReadWriteLock._acquire_transaction_locksr--55u5EH ]--55t5DH--55tW5UH$..)t 3r(c |dk(rdnd}|dk(rdnd}|j|k7r0d|d|jdt|d|d |d }t||dk(rYt j x}|j k7r6d |jdt|d |d |j }t||xjdz c_t|S)Nreadwrite downgradeupgradezCannot acquire z lock on (lock id: z): already holding a z lock (z not allowed)zCannot acquire write lock on z) from thread z while it is held by thread r lock) rUr7id RuntimeErrorrP get_identrVrTr )r[modeopposite directionr$curs r_validate_reentrantz!ReadWriteLock._validate_reentrants"fn7&#'6>Ky    %!$y0@ BtH:V%%-Jgi[ O s# # 7?y':':'< <AVAVV//?{2d8*U"e#?@U@U?VX s# # A!t,,r(cjtj|z }t|||}|jj d|dj |jj dj tj|z }t|||x}|k7r-|jj d|dj |dk(rdnd}|jj |j |dk(r*|jj d j yy) N)r"r#zPRAGMA busy_timeout=;zPRAGMA journal_mode=MEMORY;rdzBEGIN EXCLUSIVE TRANSACTION;zBEGIN TRANSACTION;rcz'SELECT name FROM sqlite_schema LIMIT 1;)time perf_counterr'rYexecuter) r[rmr!r" start_timewaitedr& recomputedstmts r_configure_and_beginz"ReadWriteLock._configure_and_begins ""$z1'(SYZ  0 A>?EEG 78>>@""$z1,WxX^_ _Jdn n II   4ZLB C I I K15-FZ $%%' 6> II  G H N N P r(c|j5|jdkDr|j|cdddS dddtj}|j || |j |||||jjS#1swY`xYw#tj$r)}dt|vrt|jdd}~wwxYw#|jjwxYw)Nrr^r"rwzdatabase is locked)rSrTrqrtrura_do_acquire_innerrRreleaserWOperationalErrorstrr r7)r[rmr!r"rwexcs r_acquirezReadWriteLock._acquires   6!#//5 6 6# 6&&(  &&'&J -))$(Wa)b  " " * * , 6 6'' 4#3s83$..)t 3 4  " " * * ,s/ B(B#B #C6$CCC""C>ct|j5|jdkDr|j|cdddS ddd|j|||||j5||_d|_|dk(rt j |_dddt|S#1swYkxYw#1swY!xYw)Nrr}r rdrh) rSrTrqr{rUrPrlrVr )r[rmr!r"rws rr~zReadWriteLock._do_acquire_inners  6!#//5 6 6# 6 !!$(z!Z   >!%D  D w(1(;(;(=%  > "t,, 6 6 > >s B"!-B."B+.B7c*|jd||S)a Acquire a shared read lock. If this instance already holds a read lock, the lock level is incremented (reentrant). Attempting to acquire a read lock while holding a write lock raises :class:`RuntimeError` (downgrade not allowed). :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 a 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 rcrHrr[r!r"s r acquire_readzReadWriteLock.acquire_reads }}VWx}@@r(c*|jd||S)a Acquire an exclusive write lock. If this instance already holds a write lock from the same thread, the lock level is incremented (reentrant). Attempting to acquire a write lock while holding a read lock raises :class:`RuntimeError` (upgrade not allowed). Write locks are pinned to the acquiring thread: a different thread trying to re-enter also raises :class:`RuntimeError`. :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 a 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 rdrHrrs r acquire_writezReadWriteLock.acquire_write s$}}Wg}AAr(Fforcecd}|j5|jdk(r3|r dddyd|jdt|d}t ||rd|_n|xjdzc_|jdk(rd|_d|_d}ddd|r|jjyy#1swY'xYw) al Release one level of the current lock. When the lock level reaches zero the underlying SQLite transaction is rolled back, releasing the database lock. :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`` FrNzCannot release a lock on rgz) that is not heldr T) rSrTr7rjrkrUrVrYrollback)r[rshould_rollbackr$s rrzReadWriteLock.release s   '1$ ' '2$..1ARPTXJVhi"3''#$   A% 1$%)"(,%"& '  II     ' 'sB6A%B66B?Nc#K| |j}| |j}|j|| d|jy#|jwxYww)a} 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 NrH)r!r"rrrs r read_lockzReadWriteLock.read_lock=sR ?llG  }}H 'H5   LLNDLLN0AAAAAc#K| |j}| |j}|j|| d|jy#|jwxYww)a 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 NrH)r!r"rrrs r write_lockzReadWriteLock.write_lockRsR ?llG  }}H 7X6   LLNDLLNrc|jd|jjt5tj |jdddy#1swYyxYw)z Release the lock (if held) and close the underlying SQLite connection. After calling this method, the lock instance is no longer usable. TrN)rrYrrrdiscard)r[s rrzReadWriteLock.closegsJ 4    " 0  $ $TYY / 0 0 0s AA%r;)r7r<r!r=r"r>r?r@) r7r<r!r=r"r>r/r>r?None)r"r>r!r=r?r)rmLiteral['read', 'write']r?r ) rmrr!r=r"r>rwr=r?r)rmrr!r=r"r>r?r ) rmrr!r=r"r>rwr=r?r )r!r=r"r>r?r )rr>r?rr)r!z float | Noner"z bool | Noner?zGenerator[None]r?r)rArBrCrDrr,rErPrQr- classmethodrKr\rarqr{rr~rrrrrrrrJr(rr@r@cs(DWCXJ@X$inn&OAC:Y]:.:9>:RV: ::(, ! ,),,  ,  , ,(4-$Q,Q7<QKOQ]bQ Q2- -&--  -  - -(ADA$BTB((-!:QU(RV( 0r(r@) metaclassr)r!r=r"r>r#r=r?r)% __future__ratexitloggingrNr3rWrPrt contextlibrrtypingrrweakrefr_apir _errorr collections.abcr getLoggerrsetrrErQrrregisterrr'typer*r@rJr(rrs"   /)'$) '  J ',/E)1& (!$%+&%%PN00N0r(