o 'i;@sUddlmZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z ddl m Z mZddlmZddlmZddlmZe rMdd lmZed ZeZd ed <eZdddZeedZ d ddZ!Gddde"Z#Gddde#dZ$dS)!) annotationsN)contextmanagersuppress) TYPE_CHECKINGLiteral)WeakValueDictionary)AcquireReturnProxy)Timeout) Generatorfilelockzset[sqlite3.Connection]_all_connectionsreturnNonec Csjt)ttD]}ttj |Wdn1swYqWddS1s.wYdSN)_all_connections_locklistr rsqlite3ProgrammingErrorclose)conrP/home/jeff/fluffinator/venv/lib/python3.10/site-packages/filelock/_read_write.py_cleanup_connectionss   "ri5wtimeoutfloatblockingboolalready_waitedintcCsx|durdS|dkr tS|dkrd}t||dkr!t||dn|}t|d}|tks1|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_msrrrtimeout_for_sqlite's r)cs@eZdZUdZded<ded< dddddfddZZS)_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]rrrrr/r ReadWriteLockc s|s tj||||dSt|}|jB||jvr,tj||||d}||j|<n|j|}|j|ks;|j|krOd|jd|jd|d|}t ||WdS1s[wYdS)Nr.z$Singleton lock created with timeout=z , blocking=z, cannot be changed to timeout=) super__call__pathlibPathresolver-r,rrr")clsr0rrr/ normalizedinstancer& __class__rrr4Es$   $z_ReadWriteLockMeta.__call__r ) r0r1rrrrr/rrr2)__name__ __module__ __qualname____doc____annotations__r4 __classcell__rrr;rr*:s r*c@seZdZUdZeZded<eZ e d7ddd8ddZ d7dddd9ddZ d:ddZ d;ddZdd$d%Zd7ddd>d&d'Zd(d)d?d+d,Zed@d-ddAd1d2Zed@d-ddAd3d4ZdBd5d6Zd-S)Cr2a 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,r Trr0r1rrrrrcCs||||dS)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 :raises ValueError: if an instance already exists for this path with different *timeout* or *blocking* values :return: the singleton lock instance rDr)r8r0rrrrrget_lockxs zReadWriteLock.get_lockr.r/rcCst||_||_||_t|_t|_d|_ d|_ d|_ t j |jdd|_tt|jWddS1sdnd}|j||dkrR|jd dSdS) N)rrzPRAGMA busy_timeout=;zPRAGMA journal_mode=MEMORY;r^zBEGIN EXCLUSIVE TRANSACTION;zBEGIN TRANSACTION;readz'SELECT name FROM sqlite_schema LIMIT 1;)time perf_counterr)rQexecute) rSrXrrrfwaitedr( recomputedstmtrrr_configure_and_begins    z"ReadWriteLock._configure_and_beginc Cs|dkrdnd}|dkrdnd}|j|jdkr'||||WdSWdn1s1wYt}|j||dzzd|j"|jdkra||||WdWW|jSWdn1skwY|j||||d|j||_ d|_|dkrt |_ Wdn1swYt |d WW|jStjy}z d t|vrt|jdd}~ww|jw) Nrhr^ downgradeupgrader)rr)rrfrr_zdatabase is locked)rLrMrerirjrWrKreleaserorNrIrcrOr rOperationalErrorr[r r0)rSrXrrrZr\rfexcrrr_acquiresF           zReadWriteLock._acquirecC|jd||dS)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 :raises RuntimeError: if a write lock is already held on this instance :raises Timeout: if the lock cannot be acquired within *timeout* seconds :return: a proxy that can be used as a context manager to release the lock rhrDrurSrrrrr acquire_reads zReadWriteLock.acquire_readcCrv)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 :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 :return: a proxy that can be used as a context manager to release the lock r^rDrwrxrrr acquire_writeszReadWriteLock.acquire_writeFforcer|cCsd}|jB|jdkr&|r WddSd|jdt|d}t||r,d|_n|jd8_|jdkr@d|_d|_d}Wdn1sJwY|rX|jdSdS) aj 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 r]z) that is not heldrT) rLrMr0rarbrNrOrQrollback)rSr|should_rollbackr&rrrrrs(   zReadWriteLock.releaseN float | None bool | NoneGenerator[None]ccL|dur|j}|dur|j}|j||dz dVW|dS|w)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 NrD)rrryrrrxrrr read_lock) zReadWriteLock.read_lockccr)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 NrD)rrrzrrrxrrr write_lock=rzReadWriteLock.write_lockcCsL|jdd|jtt|jWddS1swYdS)z Release the lock (if held) and close the underlying SQLite connection. After calling this method, the lock instance is no longer usable. Tr{N)rrrQrrr discard)rSrrrrQs  "zReadWriteLock.closer=)r0r1rrrrrr2) r0r1rrrrr/rrr)rrrrrr)rXrYrZr[r\r[rr ) rXrYrrrrrfrrr)rXrYrrrrrr )rrrrrr )r|rrrr)rrrrrrrr)r>r?r@rArr,rBrIrJr- classmethodrErTrWreroruryrzrrrrrrrrrrr2as4    !r2) metaclassr)rrrrrrrr)% __future__ratexitloggingrGr5rrIri contextlibrrtypingrrweakrefr_apir _errorr collections.abcr getLoggerr$setr rBrJrrregisterr!r)typer*r2rrrrs0        '