§ ÏŽ°iyãóº—dZddlmZddlZddlZddlmZddlmZddl m Z erddl Z ddl m Z mZdd lmZdd lmZGd „d ¦«ZGd „d¦«Zd dgZdS)zEAsync wrapper around :class:`ReadWriteLock` for use with ``asyncio``.é)Ú annotationsN)Úasynccontextmanager)Ú TYPE_CHECKINGé)Ú ReadWriteLock)ÚAsyncGeneratorÚCallable)Úfutures)Ú TracebackTypecó*—eZdZdZdd„Zdd„Zdd„ZdS)Ú AsyncAcquireReadWriteReturnProxyzEContext-aware object that releases the async read/write lock on exit.ÚlockÚAsyncReadWriteLockÚreturnÚNonecó—||_dS©N©r)Úselfrs úM/var/www/icac/venv/lib/python3.11/site-packages/filelock/_async_read_write.pyÚ__init__z)AsyncAcquireReadWriteReturnProxy.__init__s €ØˆŒ ˆ ˆ ócƒóK—|jSrr©rs rÚ __aenter__z+AsyncAcquireReadWriteReturnProxy.__aenter__sèè€ØŒyÐrÚexc_typeútype[BaseException] | NoneÚ exc_valueúBaseException | NoneÚ tracebackúTracebackType | NonecƒóHK—|j ¦«ƒd{V—†dSr)rÚrelease)rrrr s rÚ __aexit__z*AsyncAcquireReadWriteReturnProxy.__aexit__s4èè€ð Œi×ÒÑ!Ô!Ð!Ð!Ð!Ð!Ð!Ð!Ð!Ð!Ð!rN)rrrr)rr)rrrrr r!rr)Ú__name__Ú __module__Ú __qualname__Ú__doc__rrr$©rrr r sV€€€€€ØOÐOððððððððð"ð"ð"ð"ð"ð"rr có —eZdZdZ d.dddddœd/d„Zed0d„¦«Zed1d„¦«Zed2d„¦«Zed3d„¦«Z ed4d„¦«Z d5d„Z d.dd œd6d"„Z d.dd œd6d#„Z d$d%œd7d'„Zed8dd œd9d+„¦«Zed8dd œd9d,„¦«Zd:d-„ZdS);ra¹ Async wrapper around :class:`ReadWriteLock` for use in ``asyncio`` applications. Because Python's :mod:`sqlite3` module has no async API, all blocking SQLite operations are dispatched to a thread pool via ``loop.run_in_executor()``. Reentrancy, upgrade/downgrade rules, and singleton behavior are delegated to the underlying :class:`ReadWriteLock`. :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``; ``None`` uses the default executor .. versionadded:: 3.21.0 éÿÿÿÿTN)ÚblockingÚ is_singletonÚloopÚexecutorÚ lock_fileústr | os.PathLike[str]ÚtimeoutÚfloatr,Úboolr-r.ú asyncio.AbstractEventLoop | Noner/úfutures.Executor | NonerrcóR—t||||¬¦«|_||_||_dS)N)r,r-)rÚ_lockÚ_loopÚ _executor)rr0r2r,r-r.r/s rrzAsyncReadWriteLock.__init__8s/€õ# 9¨gÀÐWcÐdÑdÔdˆŒ ؈Œ Ø!ˆŒˆˆrÚstrcó—|jjS)z$:returns: the path to the lock file.)r8r0rs rr0zAsyncReadWriteLock.lock_fileFs€ðŒzÔ#Ð#rcó—|jjS)z:returns: the default timeout.)r8r2rs rr2zAsyncReadWriteLock.timeoutKs€ðŒzÔ!Ð!rcó—|jjS)z1:returns: whether blocking is enabled by default.)r8r,rs rr,zAsyncReadWriteLock.blockingPs€ðŒzÔ"Ð"rcó—|jS)z<:returns: the event loop (or ``None`` for the running loop).)r9rs rr.zAsyncReadWriteLock.loopUs €ðŒzÐrcó—|jS)z5:returns: the executor (or ``None`` for the default).)r:rs rr/zAsyncReadWriteLock.executorZs €ðŒ~ÐrÚfuncúCallable[..., object]ÚargsÚobjectÚkwargscó¢K—|jptj¦«}| |jt j|g|¢Ri|¤Ž¦«ƒd{V—†Sr)r9ÚasyncioÚget_running_loopÚrun_in_executorr:Ú functoolsÚpartial)rrArCrEr.s rÚ_runzAsyncReadWriteLock._run_sbèè€ØŒzÐ7WÔ5Ñ7Ô7ˆØ×)Ò)¨$¬.½)Ô:KÈDÐ:bÐSWÐ:bÐ:bÐ:bÐ[aÐ:bÐ:bÑcÔcÐcÐcÐcÐcÐcÐcÐcr©r,r cƒóvK—| |jj||¬¦«ƒd{V—†t|¬¦«S)a7 Acquire a shared read lock. See :meth:`ReadWriteLock.acquire_read` for full semantics. :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 an async 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 rMNr)rLr8Ú acquire_readr ©rr2r,s rrOzAsyncReadWriteLock.acquire_readcsHèè€ðiŠi˜œ Ô/°À8ˆiÑLÔLÐLÐLÐLÐLÐLÐLÐLÝ/°TÐ:Ñ:Ô:Ð:rcƒóvK—| |jj||¬¦«ƒd{V—†t|¬¦«S)aZ Acquire an exclusive write lock. See :meth:`ReadWriteLock.acquire_write` for full semantics. :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 an async 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 rMNr)rLr8Ú acquire_writer rPs rrRz AsyncReadWriteLock.acquire_writeusHèè€ðiŠi˜œ Ô0°'ÀHˆiÑMÔMÐMÐMÐMÐMÐMÐMÐMÝ/°TÐ:Ñ:Ô:Ð:rF©ÚforcerTcƒóXK—| |jj|¬¦«ƒd{V—†dS)a2 Release one level of the current lock. See :meth:`ReadWriteLock.release` for full semantics. :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`` rSN)rLr8r#)rrTs rr#zAsyncReadWriteLock.release‡s;èè€ðiŠi˜œ Ô*°%ˆiÑ8Ô8Ð8Ð8Ð8Ð8Ð8Ð8Ð8Ð8Ð8rú float | Noneú bool | NoneúAsyncGenerator[None]cóúK—|€ |jj}|€ |jj}| ||¬¦«ƒd{V—† dWV—| ¦«ƒd{V—†dS#| ¦«ƒd{V—†wxYw)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 NrM)r8r2r,rOr#rPs rÚ read_lockzAsyncReadWriteLock.read_lock”s®èè€ð ˆ?Ø”jÔ(ˆGØ Ð Ø”zÔ*ˆHØ×Ò °(ÐÑ;Ô;Ð;Ð;Ð;Ð;Ð;Ð;Ð;ð !Ø ˆEˆEˆEˆEà—,’,‘.”.Ð Ð Ð Ð Ð Ð Ð Ð Ð ø$—,’,‘.”.Ð Ð Ð Ð Ð Ð Ð Ð øøøó ½AÁA:cóúK—|€ |jj}|€ |jj}| ||¬¦«ƒd{V—† dWV—| ¦«ƒd{V—†dS#| ¦«ƒd{V—†wxYw)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 NrM)r8r2r,rRr#rPs rÚ write_lockzAsyncReadWriteLock.write_lock©s®èè€ð ˆ?Ø”jÔ(ˆGØ Ð Ø”zÔ*ˆHØ× Ò  °8Ð Ñ<Ô<Ð<Ð<Ð<Ð<Ð<Ð<Ð<ð !Ø ˆEˆEˆEˆEà—,’,‘.”.Ð Ð Ð Ð Ð Ð Ð Ð Ð ø$—,’,‘.”.Ð Ð Ð Ð Ð Ð Ð Ð øøør[cƒóTK—| |jj¦«ƒd{V—†dS)z¤ Release the lock (if held) and close the underlying SQLite connection. After calling this method, the lock instance is no longer usable. N)rLr8Úclosers rr_zAsyncReadWriteLock.close¾s7èè€ðiŠi˜œ Ô(Ñ)Ô)Ð)Ð)Ð)Ð)Ð)Ð)Ð)Ð)Ð)r)r+)r0r1r2r3r,r4r-r4r.r5r/r6rr)rr;)rr3)rr4)rr5)rr6)rArBrCrDrErDrrD)r2r3r,r4rr )rTr4rrr)r2rVr,rWrrX)rr)r%r&r'r(rÚpropertyr0r2r,r.r/rLrOrRr#rrZr]r_r)rrrr%só€€€€€ððð*ð "ð Ø!Ø15Ø,0ð "ð "ð "ð "ð "ð "ðð$ð$ð$ñ„Xð$ðð"ð"ð"ñ„Xð"ðð#ð#ð#ñ„Xð#ððððñ„Xðððððñ„Xððdðdðdðdð;È$ð;ð;ð;ð;ð;ð;ð$;È4ð;ð;ð;ð;ð;ð;ð$.3ð 9ð 9ð 9ð 9ð 9ð 9ðð!ÐW[ð!ð!ð!ð!ð!ñÔð!ð(ð!ÐX\ð!ð!ð!ð!ð!ñÔð!ð(*ð*ð*ð*ð*ð*rr)r(Ú __future__rrGrJÚ contextlibrÚtypingrÚ _read_writerÚosÚcollections.abcrr Ú concurrentr Útypesr r rÚ__all__r)rrúrjs!ðØKÐKà"Ð"Ð"Ð"Ð"Ð"à€€€ØÐÐÐØ*Ð*Ð*Ð*Ð*Ð*Ø Ð Ð Ð Ð Ð à&Ð&Ð&Ð&Ð&Ð&àð$Ø €I€I€IØ8Ð8Ð8Ð8Ð8Ð8Ð8Ð8Ø"Ð"Ð"Ð"Ð"Ð"Ø#Ð#Ð#Ð#Ð#Ð#ð"ð"ð"ð"ð"ñ"ô"ð"ð$`*ð`*ð`*ð`*ð`*ñ`*ô`*ð`*ðH'Øð €€€r