ώi;jUddlmZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z ddl m Z mZddlmZddlmZddlmZe rdd lmZejd ZeZd ed <ejZddZejedZ ddZ!Gdde"Z#Gdde#Z$dS)) annotationsN)contextmanagersuppress) TYPE_CHECKINGLiteral)WeakValueDictionary)AcquireReturnProxy)Timeout) Generatorfilelockzset[sqlite3.Connection]_all_connectionsreturnNonec&t5ttD]B}tt5|dddn #1swxYwYCtddddS#1swxYwYdSN)_all_connections_locklistrr Exceptioncloseclear)cons G/var/www/icac/venv/lib/python3.11/site-packages/filelock/_read_write.py_cleanup_connectionsrs !!())  C)$$                     !!!!!!!!!!!!!!!!!!s4+BA BA BA BB  B i5wtimeoutfloatblockingboolalready_waitedintc&|durdS|dkrtS|dkrd}t||dkrt||z dn|}t|dz}|tks|dkr(td|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 ValueErrormaxr _LOGGERwarning)rrrmsg remaining timeout_mss rtimeout_for_sqliter+(s5q"}}%%{{;oo4;aKKGn,a000WIY%&&J***j1nnQSZ\rsss%% cFeZdZUdZded<ded< dddddfdZxZS)_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_lockr"Tr is_singleton lock_filestr | os.PathLike[str]rrrrr3r ReadWriteLockc |s%t||||Stj|}|j5||jvr0t||||}||j|<n |j|}|j|ks |j|kr'd|jd|jd|d|}t||cdddS#1swxYwYdS)Nr2z$Singleton lock created with timeout=z , blocking=z, cannot be changed to timeout=) super__call__pathlibPathresolver1r0rrr$) clsr4rrr3 normalizedinstancer( __class__s rr9z_ReadWriteLockMeta.__call__Gsy f77##IwXd#ee e\),,4466   // 77++Iw`l+mm-5z**>*57**h.?8.K.KT8;KTTX`XiTT5<TTIQTT!oo%                  sBC((C,/C,r") r4r5rrrrr3rrr6)__name__ __module__ __qualname____doc____annotations__r9 __classcell__)r@s@rr.r.;sA@@@####  ! r,r.ceZdZUdZeZded<ejZ e d+ddd,dZ d+dddd-dZ d.dZ d/dZd0dZd1dZd+ddd2dZd+ddd2dZd d!d3d#Zed4d$dd5d(Zed4d$dd5d)Zd6d*Zd$S)7r6a 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/r0r"Trr4r5rrrrrc||||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 rI)r=r4rrs rget_lockzReadWriteLock.get_lock{s s9g9999r,r2r3rctj||_||_||_t j|_t j|_d|_ d|_ d|_ tj |jd|_t5t |jddddS#1swxYwYdS)NrF)check_same_thread)osfspathr4rr threadingLock_transaction_lock_internal_lock _lock_level _current_mode_write_thread_idsqlite3connect_conrradd)selfr4rrr3s r__init__zReadWriteLock.__init__s9--   !*!1!1'n..>B,0ODNeLLL " , ,   + + + , , , , , , , , , , , , , , , , , ,s CCCc|s|jd}n>|dkr|jd}n|jd|}|st|jddS)NFrIr"Trr)rSacquirer r4)r\rracquireds r_acquire_transaction_lockz'ReadWriteLock._acquire_transaction_locks V-55u5EEHH ]]-55t5DDHH-55tW5UUH 4$.))t 3 4 4r,modeLiteral['read', 'write']oppositestr directionr c n|j|kr3d|d|jdt|d|d|d }t||dkrRt jx}|jkr4d|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) rVr4id RuntimeErrorrQ get_identrWrUr )r\rcrergr(curs r_validate_reentrantz!ReadWriteLock._validate_reentrants*   % %O$OOOOBtHHOO%-OO6?OOO s## # 7??y':'<'< <AVVVXXX2d88XX"XX@D@UXX s## # A!t,,,,r, start_timectj|z }t|||}|jd|d|jdtj|z }t|||x}|kr0|jd|d|dkrdnd}|j||dkr.|jd dSdS) N)rrzPRAGMA busy_timeout=;zPRAGMA journal_mode=MEMORY;rjzBEGIN EXCLUSIVE TRANSACTION;zBEGIN TRANSACTION;readz'SELECT name FROM sqlite_schema LIMIT 1;)time perf_counterr+rZexecuter) r\rcrrrrwaitedr* recomputedstmts r_configure_and_beginz"ReadWriteLock._configure_and_beginsR"$$z1'(SYZZZ  >>>>??EEGGG 788>>@@@"$$z1,WxX^___ _Jdn n n I  BZBBB C C I I K K K15--FZ $%%''' 6>> I  G H H N N P P P P P >r,c|dkrdnd}|dkrdnd}|j5|jdkr#||||cdddS dddn #1swxYwYtj}||| |j5|jdkr<||||cddd|jS dddn #1swxYwY||||||j5||_ d|_|dkrtj |_ dddn #1swxYwYt| |jS#tj$r,}d t!|vrt#|jdd}~wwxYw#|jwxYw) Nrurj downgradeupgraderr_)rrrr rkzdatabase is locked)rTrUrqrvrwrbrSreleaser|rVrQrorWr rXOperationalErrorrfr r4)r\rcrrrergrrexcs r_acquirezReadWriteLock._acquires="fnn77&#'6>>KKy   K K!##//h JJ K K K K K K K K# K K K K K K K K K K K K K K K&((  &&'&JJJ -$ O O#a''33D(INN O O O O O O O&  " * * , , , ,%( O O O O O O O O O O O O O O O  % %dGhS] % ^ ^ ^$ B B%)"#$ 7??,5,?,A,AD)  B B B B B B B B B B B B B B B &4000  " * * , , , , ' 4 4 4#3s8833$.))t 3 4  " * * , , , ,s"AAAF"C*7 F F*C..F1C.2#F-E FEFEFF='F88F==GGc2|d||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 rurIrr\rrs r acquire_readzReadWriteLock.acquire_reads }}VWx}@@@r,c2|d||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 rjrIrrs r acquire_writezReadWriteLock.acquire_writes$}}Wg}AAAr,Fforcercvd}|j5|jdkr:|r ddddSd|jdt|d}t ||rd|_n|xjdzc_|jdkrd|_d|_d}dddn #1swxYwY|r|jdSdS) 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 riz) that is not heldr T) rTrUr4rmrnrVrWrZrollback)r\rshould_rollbackr(s rrzReadWriteLock.releasesR   ' '1$$ ' ' ' ' ' ' ' 'j$.iiRPTXXiii"3''' &#$    A%  1$$%)"(,%"& ' ' ' ' ' ' ' ' ' ' ' ' ' ' '  ! I    ! !sBABBBN float | None bool | NoneGenerator[None]c#K||j}||j}||| dV|dS#|wxYw)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 NrI)rrrrrs r read_lockzReadWriteLock.read_lock8sk ?lG  }H 'H555  EEE LLNNNNNDLLNNNN AAc#K||j}||j}||| dV|dS#|wxYw)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 NrI)rrrrrs r write_lockzReadWriteLock.write_lockMsk ?lG  }H 7X666  EEE LLNNNNNDLLNNNNrc|d|jt5t|jddddS#1swxYwYdS)z Release the lock (if held) and close the underlying SQLite connection. After calling this method, the lock instance is no longer usable. TrN)rrZrrrdiscard)r\s rrzReadWriteLock.closebs 4      " 0 0  $ $TY / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0s A$$A(+A(rA)r4r5rrrrrr6) r4r5rrrrr3rrr)rrrrrr)rcrdrerfrgrfrr ) rcrdrrrrrrrrr)rcrdrrrrrr )rrrrrr )rrrrr)rrrrrrrr)rBrCrDrErr0rFrQrRr1 classmethodrLr]rbrqr|rrrrrrrrrKr,rr6r6cs(DWCVCXCXJXXXX$in&&OAC:Y]:::::[:(, ! ,,,,,,(4444---- QQQQ2----BADAAAAAA$BTBBBBBB((-!!!!!!:QU^(RV^( 0 0 0 0 0 0r,r6) metaclassr)rrrrrrrr )% __future__ratexitloggingrOr:rXrQrv contextlibrrtypingrrweakrefr_apir _errorr collections.abcr getLoggerr&setrrFrRrrregisterr#r+typer.r6rKr,rrs"""""""   ////////))))))))''''''$$$$$$*)))))) ' J ' ',/CEE1111& ((!!!!$%%%+&%%%%%%%%PI0I0I0I0I00I0I0I0I0I0I0r,