qi;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 F/opt/pipecat/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*c:eZdZUdZeZded<ejZ e ddd ddZ dddd ddZ dd Z dd Z dd Zdd Zddddd ZdddddZddddZedddd dZedddd 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 ~|j|k7r0d|d|jdt|d|d|d }t||dk(rYt j x}|j k7r6d|jdt|d |d |j }t||xjd z c_t| S) NzCannot acquire z lock on (lock id: z): already holding a z lock (z not allowed)writezCannot 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    %!$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;readz'SELECT name FROM sqlite_schema LIMIT 1;)time perf_counterr'rYexecuter) r[rjr!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|dk(rdnd}|dk(rdnd}|j5|jdkDr|j|||cdddS dddtj}|j || |j5|jdkDr6|j|||cddd|j jS ddd|j|||||j5||_ d|_|dk(rtj|_ dddt| |j jS#1swY xYw#1swYxYw#1swYHxYw#tj$r)}d t!|vrt#|j$dd}~wwxYw#|j jwxYw) Nrqrd downgradeupgraderr^)r"rur rezdatabase is locked)rSrTrnrrrsrarRreleaseryrUrPrirVr rWOperationalErrorstrr r7)r[rjr!r"rkrlruexcs r_acquirezReadWriteLock._acquires"fn7&#'6>Ky   K!#//h J K K# K&&(  &&'&J -$$ O##a'33D(IN O O&  " " * * ,%( O  % %dGhS] % ^$$ B%)"#$ 7?,5,?,?,AD)  B &40  " " * * ,7 K K O O  B B'' 4#3s83$..)t 3 4  " " * * ,se"E< E8"E * E8)E88-E,%E8E E)%E8,E51E88F4 $F//F44F77Gc*|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 rqrHrr[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_writes$}}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 rcz) that is not heldr T) rSrTr7rgrhrUrVrYrollback)r[rshould_rollbackr$s rr}zReadWriteLock.releases   '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"rr}rs r read_lockzReadWriteLock.read_lock8sR ?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"rr}rs r write_lockzReadWriteLock.write_lockMsR ?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)r}rYrrrdiscard)r[s rrzReadWriteLock.closebsJ 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)rjLiteral['read', 'write']rkrrlrr?r ) rjrr!r=r"r>rur=r?r)rjrr!r=r"r>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\rarnryrrrr}rrrrrJr(rr@r@csQ(DWCXJ@X$inn&OAC:Y]:.:9>:RV: ::(, ! ,),,  ,  , ,(4- Q,Q7<QKOQ]bQ Q2-BADA$BTB((-!:QU(RV( 0r(r@) metaclassr)r!r=r"r>r#r=r?r)% __future__ratexitloggingrNr3rWrPrr contextlibrrtypingrrweakrefr_apir _errorr collections.abcr getLoggerrsetrrErQrrregisterrr'typer*r@rJr(rrs"   /)'$) '  J ',/E)1& (!$%+&%%PI00I0r(