Ë
    @ôjÔª  ã                  ó¼  — U d Z ddlmZ g d¢ZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlmZ ddlmZmZmZ ddlmZ ddlmZmZmZmZmZ dd	lmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0 dd
l1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z: ddl;m<Z< ddl=m>Z> ddl?m@Z@ ddlAmBZB ddlCmDZD ddlEmFZF ddlGmHZH erddlImJZJmKZKmLZLmMZMmNZN ddlOmPZP ddlmQZQ  ej¤                  d«      ZSdeTd<   dZUdeTd<   dZVdeTd<   g ZWdeTd<    eX«       ZYdeTd <    ed!d"¬#«      ZZ ed$«      Z[ G d%„ d&e«      Z\ G d'„ d"ee\¬(«      Z]d<d)„Z^e G d*„ d+e«      «       Z_ G d,„ d-e_e «      Z` ee_«      D ]&  Za ebe`eajÆ                   e$eajÆ                  «      «       Œ(  G d.„ d/«      Zd G d0„ d1e@e]«      Ze G d2„ d3eBe]«      Zf G d4„ d5e>e]«      Zg G d6„ d7eDe]«      Zh G d8„ d9eHe]«      Zid=d:„Zjg d;¢Zky)>z1An asyncio-based implementation of the file lock.é    )Úannotations)ÚasyncioÚ
concurrentÚ
contextlibzfilelock._asynczfilelock._errorzfilelock._utilÚ	functoolsÚinspectN)Úfutures)Ú	dataclassÚfieldÚfields)Úiscoroutinefunction)ÚTYPE_CHECKINGÚFinalÚNoReturnÚTypeVarÚcast)Ú_UNSET_FILE_MODEÚBaseFileLockÚCloseErrorPolicyÚContextErrorPolicyÚFileLockContextÚFileLockMetaÚThreadLocalFileContextÚ_append_exception_contextÚ
_canonicalÚ_check_blockingÚ_delegate_to_currentÚ_ExtraValueÚ_fork_transitionÚ_grouped_errorsÚ_is_system_call_failureÚ_LockSettingsÚ_raise_body_and_releaseÚ_raise_chained_errorsÚ_raise_cleanup_errorsÚ_raise_grouped_errorsÚ_register_fork_objectÚ_resolve_poll_intervalÚ_resolve_timeout)	Ú_AsyncTransitionGateÚ _AsyncTransitionUnavailableErrorÚ_BackendOutcomeÚ_capture_awaitableÚ_capture_callÚ_drain_futureÚ_future_resultÚ_run_in_executorÚ_wait_until_done)ÚTimeout)ÚSoftFileLease)ÚSoftFileLock)ÚStrictSoftFileLock)ÚUnixFileLock)Úensure_directory_exists)ÚWindowsFileLock)Ú	AwaitableÚCallableÚ	CoroutineÚHashableÚMapping)ÚTracebackType)ÚSelfÚfilelockzFinal[logging.Logger]Ú_LOGGERz9lock release cancellation and backend release both failedz
Final[str]Ú"_ASYNC_RELEASE_CANCELLATION_ERRORSÚ$_filelock_async_release_cancellationÚ'_ASYNC_RELEASE_CANCELLATION_MARKER_ATTRzFinal[list[None]]Ú"_ASYNC_RELEASE_CANCELLATION_MARKERz5Final[set[asyncio.Task[None] | futures.Future[None]]]Ú_FINALIZER_RELEASESÚ_ATÚBaseAsyncFileLock)ÚboundÚ_Tc                  ó’   ‡ — e Zd ZdZdedfddddddddddddd	œ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dˆ fd
„Zˆ xZS )ÚAsyncFileLockMetazjGives the async locks their constructor, which rejects ``run_in_executor`` together with ``thread_local``.éÿÿÿÿFTçš™™™™™©?NÚchainÚdefault©ÚblockingÚis_singletonÚpoll_intervalÚlifetimeÚcontext_error_policyÚclose_error_policyÚfallback_to_softÚpreserve_lock_fileÚon_acquiredÚloopÚrun_in_executorÚexecutorc               ó¨   •— |r|rd}t        |«      ‚t        ‰| �  di |¤i d|“d|“d|“d|“d|“d|“d|“d	|“d
|	“d|
“d|“d|“d|“d|“d|“d|“¤ŽS )Nz:run_in_executor is not supported when thread_local is TrueÚ	lock_fileÚtimeoutÚmodeÚthread_localrS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   r^   © )Ú
ValueErrorÚsuperÚ__call__)Úclsr`   ra   rb   rc   rS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   r^   ÚkwargsÚmsgÚ	__class__s                      €úa/var/www/html/academy/tools/voices/clone/fw-venv/lib/python3.12/site-packages/filelock/asyncio.pyrg   zAsyncFileLockMeta.__call__[   sÑ   ø€ ñ* ™OØNˆCÜ˜S“/Ð!Ü‰wÑñ 
Øò
áð
ñ ð
ñ ð	
ñ
 &ð
ñ ð
ñ &ð
ñ (ð
ñ ð
ñ "6ð
ñ  2ð
ñ .ð
ñ  2ð
ñ $ð
ñ ð
ñ  ,ð!
ñ" ñ#
ð 	
ó    )&rh   z	type[_AT]r`   ústr | os.PathLike[str]ra   Úfloatrb   Úintrc   ÚboolrS   rq   rT   rq   rU   ro   rV   úfloat | NonerW   r   rX   r   rY   rq   rZ   rq   r[   úCallable[[int], None] | Noner\   ú asyncio.AbstractEventLoop | Noner]   rq   r^   úfutures.Executor | Noneri   r   ÚreturnrH   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   rg   Ú__classcell__©rk   s   @rl   rM   rM   X   s   ø„ Ùtð
 Ø$Ø"ð*
ð Ø"Ø#Ø!%Ø3:Ø/8Ø!%Ø#(Ø48Ø15Ø $Ø,0ñ%*
Øð*
à)ð*
ð ð*
ð ð	*
ð
 ð*
ð ð*
ð ð*
ð ð*
ð ð*
ð 1ð*
ð -ð*
ð ð*
ð !ð*
ð 2ð*
ð  /ð!*
ð" ð#*
ð$ *ð%*
ð& ð'*
ð( 
÷)*
ñ *
rm   rM   c                  óž  ‡ — e Zd ZU dZdZded<   dZded<   ded	fd
d	ddddd
d	ddd
ddœ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d5d„Zd6d„Z		 	 	 	 	 	 	 	 d7d„Z
d8d„Z	 	 d9dddœ	 	 	 	 	 	 	 	 	 d:d„Z	 	 	 	 	 	 	 	 	 	 	 	 d;d„Zd<d„Zed=d„«       Zed>d„«       Zej$                  d?d„«       Z	 	 	 	 	 	 	 	 	 	 	 	 d@d„ZdAd„Z	 	 	 	 dBd„ZdAd„ZdCd„ZdDd „ZdEd!„ZdAd"„ZdAd#„ZdFd$„ZdAd%„Z	 dG	 	 	 	 	 	 	 	 	 dHd&„ZdId'„Z	 	 	 	 	 	 	 	 d7d(„Z 	 	 	 	 dJd)„Z!dKdLd*„Z"dLd+„Z#dAd,„Z$dMd-„Z%dAd.„Z&e'dNd/„«       Z(dOˆ fd0„Z)edPd1„«       Z*dAd2„Z+dAd3„Z,dQd4„Z-ˆ xZ.S )RrI   zP
    Base class for asynchronous file locks.

    .. versionadded:: 3.15.0

    z'BaseAsyncFileLock instance in this taskÚstrÚ_deadlock_holder_descé   rp   Ú(_constructor_lifetime_warning_stacklevelrN   FTrO   NrP   rQ   rR   c               ó  — | j                  t        |||	|
|||¬«      «       i | _        i | _         |rt        nt
        t        j                  |«      ||||||||¬«	      | _        | j                  | _	        t        | «       y)a´  
        Create a new lock object.

        :param lock_file: path to the file
        :param timeout: default timeout when acquiring the lock, in seconds. It will be used as fallback value in the
            acquire method, if no timeout value (``None``) is given. If you want to disable the timeout, set it to a
            negative value. A timeout of 0 means that there is exactly one attempt to acquire the file lock.

        :param mode: file permissions for the lockfile. When not specified, the OS controls permissions via umask and
            default ACLs, preserving POSIX default ACL inheritance in shared directories.
        :param thread_local: Whether this object's internal context should be thread local or not. If this is set to
            ``False`` (the default) then the lock will be reentrant across threads. When ``True``, **all fields of the
            lock's internal context are per-thread**, including the configuration values ``poll_interval``, ``timeout``,
            ``blocking``, ``mode``, and ``lifetime``.

            Setting one of these properties from one thread does not change the value seen by another thread; threads
            that did not perform the write continue to see the value supplied at construction time. ``mode`` has no
            setter, so construction is the only place it is ever set. If you need configuration values to be visible
            across threads, construct the lock with ``thread_local=False``.

        :param blocking: whether the lock should be blocking or not
        :param is_singleton: If this is set to ``True`` then only one instance of this class will be created per lock
            file. This is useful if you want to use the lock object for reentrant locking without needing to pass the
            same object around.
        :param poll_interval: default interval for polling the lock file, in seconds. It will be used as fallback value
            in the acquire method, if no poll_interval value (``None``) is given.

        :param lifetime: for :class:`AsyncSoftFileLock`, the age in seconds after which a waiting process may delete the
            marker, even while its holder remains alive. This legacy expiry mode does not provide strict mutual
            exclusion. ``None`` (the default) disables age-based expiry. Native OS locks (:class:`AsyncFileLock`) cannot
            be revoked by file age and ignore a non-``None`` ``lifetime`` with a warning.

        :param context_error_policy: how a context manager reconciles a failure in its body with a failure while
            releasing on exit. ``"chain"`` (the default) keeps Python's behavior: the release error propagates with the
            body error in its ``__context__``. ``"group"`` raises a :class:`BaseExceptionGroup` holding the body error
            first and the release error second, so neither hides the other.
        :param close_error_policy: for native locks (:class:`AsyncFileLock`), what to do with an ``os.close`` failure
            after the OS unlock has already committed. ``"default"`` keeps each platform's historical behavior,
            ``"raise"`` always propagates the ``OSError``, and ``"suppress"`` always ignores it.

        :param fallback_to_soft: for :class:`AsyncFileLock`, whether to fall back to soft existence locking when
            ``flock`` returns ``ENOSYS``. ``True`` (default) keeps the fallback; ``False`` propagates the error.
        :param preserve_lock_file: for native locks (:class:`AsyncFileLock`), whether filelock promises not to unlink
            the lock pathname on release. ``False`` (default) keeps each backend's cleanup; ``True`` keeps a stable file
            identity (Windows skips its unlink, Unix refuses the ``ENOSYS`` soft fallback). :class:`AsyncSoftFileLock`
            rejects ``True``.

        :param on_acquired: for native locks (:class:`AsyncFileLock`), a callable invoked with the borrowed lock
            descriptor once per physical acquisition, after the lock is held but before
            :meth:`~BaseAsyncFileLock.acquire` returns. With ``run_in_executor=True`` (the default) it runs in the
            backend executor. It must not close or unlock the descriptor; a raise rolls the acquisition back.
            :class:`AsyncSoftFileLock` rejects it.

        :param loop: the event loop a garbage-collected lock schedules its release on when no loop runs in the
            collecting thread. :meth:`~BaseAsyncFileLock.acquire` and :meth:`~BaseAsyncFileLock.release` always run on
            the loop that awaits them.
        :param run_in_executor: If this is set to ``True`` then the lock will be acquired in an executor.
        :param executor: The executor to use. If not specified, the default executor will be used.

        )rc   rT   rW   rX   rY   rZ   r[   )	r`   ra   rb   rS   rU   rV   r\   r]   r^   N)Ú_adopt_settingsr"   Ú_thread_holdsÚ_thread_pendingÚAsyncThreadLocalFileContextÚAsyncFileLockContextÚosÚfspathÚ_async_contextÚ_contextr'   )Úselfr`   ra   rb   rc   rS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   r^   s                    rl   Ú__init__zBaseAsyncFileLock.__init__“   s•   € ð` 	×ÑÜØ)Ø)Ø%9Ø#5Ø!1Ø#5Ø'ôô
	
ð  ˆÔØ!ˆÔð R©<Õ'Ô=Qä—i‘i 	Ó*ØØØØ'ØØØ+Øô<
ˆÔð ×+Ñ+ˆŒÜ˜dÕ#rm   c                ó   — d}t        |«      ‚)zTSync context manager entry is not supported because lock acquisition is a coroutine.úaUse `async with`: acquire/release are coroutines and cannot be awaited in a sync context manager.©ÚNotImplementedError)rŒ   rj   s     rl   Ú	__enter__zBaseAsyncFileLock.__enter__  s   € àqˆÜ! #Ó&Ð&rm   c                ó   — d}t        |«      ‚)zOSync context manager exit is not supported because lock release is a coroutine.r�   r�   )rŒ   Úexc_typeÚ	exc_valueÚ	tracebackrj   s        rl   Ú__exit__zBaseAsyncFileLock.__exit__  s   € ð rˆÜ! #Ó&Ð&rm   c              ƒ  óB   K  — | j                  «       ƒ d{  –—†  | S 7 Œ­w)zG
        Acquire the lock.

        :returns: the lock object

        N)Úacquire©rŒ   s    rl   Ú
__aenter__zBaseAsyncFileLock.__aenter__  s!   è ø€ ð �l‰l‹n×ÐØˆð 	ús   ‚–—)rS   Úcancel_checkc             ƒ  ó°  K  — | j                  «        |€| j                  j                  }|€| j                  j                  }t	        |«       |€| j                  j
                  }t        |«      }t        ||¬«      }t        j                  «       }	 | j                  |||||¬«      ƒ d{  –—† S 7 Œ# t        $ r t        | j                  «      d‚w xY w­w)ar  
        Try to acquire the file lock.

        :param timeout: maximum wait time for acquiring the lock, ``None`` means use the default
            :attr:`~BaseFileLock.timeout` is and if ``timeout < 0``, there is no timeout and this method will block
            until the lock could be acquired
        :param poll_interval: interval of trying to acquire the lock file, ``None`` means use the default
            :attr:`~BaseFileLock.poll_interval`
        :param blocking: whether to retry until this call holds the lock or the timeout expires, ``None`` means use the
            default :attr:`~BaseFileLock.blocking`. ``False`` makes one attempt and raises :class:`~Timeout` on failure.

        :param cancel_check: a callable returning ``True`` when the acquisition should be canceled. Checked on each poll
            iteration. When triggered, raises :class:`~Timeout` just like an expired timeout.

        :returns: a context object that will unlock the file when the context is exited

        :raises Timeout: if fails to acquire lock within the timeout period
        :raises TypeError: if *blocking* is not a :class:`bool`
        :raises ValueError: if a blocking call gets a ``nan`` timeout, or *poll_interval* exceeds
            :data:`threading.TIMEOUT_MAX`

        .. code-block:: python

            # You can use this method in the context manager (recommended)
            async with await lock.acquire():
                pass

            # Or use an equivalent try-finally construct:
            await lock.acquire()
            try:
                pass
            finally:
                await lock.release()

        N)rS   ©rS   rœ   ra   rU   Ú
start_time)Ú_raise_if_inheritedr‹   ra   rS   r   rU   r(   r)   ÚtimeÚperf_counterÚ_acquire_with_admissionr+   r3   r`   )rŒ   ra   rU   rS   rœ   rŸ   s         rl   r™   zBaseAsyncFileLock.acquire  sÖ   è ø€ ðV 	× Ñ Ô"Øˆ?Ø—m‘m×+Ñ+ˆGàÐØ—}‘}×-Ñ-ˆHä˜Ô!àÐ Ø ŸM™M×7Ñ7ˆMÜ.¨}Ó=ˆÜ" 7°XÔ>ˆä×&Ñ&Ó(ˆ
ð		4Ø×5Ñ5Ø!Ø)ØØ+Ø%ð 6ó ÷ ð ð ùô 0ò 	4Ü˜$Ÿ.™.Ó)¨tÐ3ð	4üs0   ‚BCÂB3 Â,B1Â-B3 Â0CÂ1B3 Â3 CÃCc             ƒ  ó(  K  — | j                   j                  j                  |||dk  rd n||z   |¬«      4 ƒd {  –—†  | j                  r<| j                  xj
                  dz  c_        t        | ¬«      cd d d «      ƒd {  –—†  S | j                  t        j                  t        | j                  «      «      ƒ d {  –—† }| j                  xj
                  dz  c_        | j                  |||¬«       | j                  |«       	 | j                  |||||¬«      ƒ d {  –—†  | j#                  |«       t        | ¬«      cd d d «      ƒd {  –—†  S 7 �Œ7 ŒÔ7 Œš7 Œ9# t        $ r | j!                  |«       ‚ w xY w7 Œ-# 1 ƒd {  –—†7  sw Y   y xY w­w)Nr   )rS   rœ   ÚdeadlinerU   é   ©Úlock)ra   rS   rž   )rŠ   Útransition_gateÚhold_for_acquireÚ	is_lockedr‹   Úlock_counterÚAsyncAcquireReturnProxyÚ	_off_loopr   Úpartialr   r`   Ú_raise_if_would_deadlockÚ_pin_lock_pathÚ_async_poll_until_acquiredÚBaseExceptionÚ_reconcile_failed_acquireÚ_commit_acquire)rŒ   rS   rœ   ra   rU   rŸ   Ú	canonicals          rl   r£   z)BaseAsyncFileLock._acquire_with_admissiona  s~  è ø€ ð ×&Ñ&×6Ñ6×GÑGØØ%Ø$ qš[‘T¨j¸7Ñ.BØ'ð	 Hó 
÷ 	6ñ 	6ð �~Š~Ø—‘×*Ò*¨aÑ/Õ*Ü.°DÔ9÷	6÷ 	6ñ 	6ð #Ÿn™n¬Y×->Ñ->¼zÈ4Ï>É>Ó-ZÓ[×[ˆIØ�M‰M×&Ò&¨!Ñ+Õ&Ø×)Ñ)¨)¸WÈxÐ)ÔXØ×Ñ 	Ô*ð
Ø×5Ñ5Ø%Ø!-Ø#Ø"/Ø)ð 6ó ÷ ð ð × Ñ  Ô+Ü*°Ô5÷7	6÷ 	6ò 	6ùð 	6øð \øð
ùô !ò Ø×.Ñ.¨yÔ9Øðúð/	6ø÷ 	6÷ 	6ñ 	6üsŸ   ‚8FºE»F¾7E=Á5FÂEÂFÂ6E=Â=EÂ>AE=ÄEÄ EÄ!EÄ%E=ÅFÅE;ÅFÅFÅE=ÅEÅE8Å8E=Å;FÅ=FÆFÆFÆFc              ƒ  óì   K  — | j                   rt        | j                  «      r |«       S t        t	        j
                  «       | j                  |«      }t        |«      ƒ d {  –—†  t        |«      S 7 Œ­w©N)	r]   r   Ú_acquirer1   r   Úget_running_loopr^   r2   r0   )rŒ   ÚcallÚfutures      rl   r®   zBaseAsyncFileLock._off_loop‡  s[   è ø€ à×#Ò#Ô':¸4¿=¹=Ô'IÙ“6ˆMÜ!¤'×":Ñ":Ó"<¸d¿m¹mÈTÓRˆÜ˜vÓ&×&Ð&Ü˜fÓ%Ð%ð 	'ús   ‚A A4Á"A2Á#A4c                ó.   — | j                   j                  S )zWhether run in executor.)rŠ   r]   rš   s    rl   r]   z!BaseAsyncFileLock.run_in_executor�  s   € ð ×"Ñ"×2Ñ2Ð2rm   c                ó.   — | j                   j                  S )zThe executor.©rŠ   r^   rš   s    rl   r^   zBaseAsyncFileLock.executor”  s   € ð ×"Ñ"×+Ñ+Ð+rm   c                ó&   — || j                   _        y)z[
        Change the executor.

        :param value: the new executor or ``None``

        Nr¿   )rŒ   Úvalues     rl   r^   zBaseAsyncFileLock.executor™  s   € ð (-ˆ×ÑÕ$rm   c             ƒ  ó  K  — t        | «      }| j                  }| j                  t        j                  t
        | j                  «      «      ƒ d {  –—†  	 | j                  «        t        j                  d||«       | j                  «       ƒ d {  –—†  | j                  «        | j                  rt        j                  d||«       y | j                  ||||¬«      r-t        || j                  | j                  «      ƒ d {  –—† «      ‚|}|dk\  r.t        |t!        ||z   t#        j$                  «       z
  d«      «      }t        j                  d|||«       t'        j(                  |«      ƒ d {  –—†  �Œ!7 �Œ'7 Œé7 Œy7 Œ­w)Nz#Attempting to acquire lock %s on %szLock %s acquired on %s)rS   rœ   ra   rŸ   r   g        z2Lock %s not acquired on %s, waiting %s seconds ...)Úidr`   r®   r   r¯   r8   Ú
_lock_pathr    rB   ÚdebugÚ_run_acquire_attemptr«   Ú_check_give_upr3   Ú_unprobeable_holderÚminÚmaxr¡   r¢   r   Úsleep)	rŒ   rS   rœ   ra   rU   rŸ   Úlock_idÚlock_filenameÚdelays	            rl   r²   z,BaseAsyncFileLock._async_poll_until_acquired£  sP  è ø€ ô �T“(ˆØŸ™ˆØ�n‰nœY×.Ñ.Ô/FÈÏÉÓXÓY×YÐYØØ×$Ñ$Ô&Ü�M‰MÐ?ÀÈ-ÔXØ×+Ñ+Ó-×-Ð-Ø×$Ñ$Ô&Ø�~Š~Ü—‘Ð6¸ÀÔOØØ×"Ñ"Ø!Ø)ØØ%ð	 #ô ô ˜m°4·>±>À$×BZÑBZÓ3[×-[Ó\Ð\Ø!ˆEØ˜!Š|Ü˜E¤3 z°GÑ';¼d×>OÑ>OÓ>QÑ'QÐSVÓ#WÓX�Ü�M‰MÐNÐPWÐYfÐhmÔnÜ—-‘- Ó&×&Ð&ñ' ð 	Zùð .øð .\øð
 'úsJ   ‚AF ÁE7Á?F ÂE:ÂA1F ÄE<
ÄA-F Å0E>Å1F Å:F Å<F Å>F c              ƒ  óè  K  — | j                  t        | j                  «      r| j                  n| j                  «      }	 t        |«      ƒ d {  –—†  	 t        |«       y 7 Œ# t        j                  $ rÀ}d }	 t        |«      ƒ d {  –—†7   n# t        $ r}|}Y d }~nd }~ww xY wd }| j                  r<	 t        | j                  «       «      ƒ d {  –—†7   n# t        $ r}|}Y d }~nd }~ww xY w|�)|�| j                  d|||«       | j                  d||«       |�| j                  d||«       ‚ d }~ww xY w# t        j                  $ r$}| j                  |«      ƒ d {  –—†7   Y d }~y d }~ww xY w­w)NzClock acquisition cancellation, backend attempt, and rollback failedz=lock acquisition cancellation and backend attempt both failedz6lock acquisition cancellation and rollback both failed)Ú_start_internal_methodr   r¹   Ú!_acquire_with_fork_tracking_asyncÚ_break_expired_and_acquirer2   r   ÚCancelledErrorr/   r³   r«   Ú_start_tracked_releaseÚ_raise_cancelled_errorsr0   Ú#_rollback_backend_cancelled_acquire)rŒ   Úacquire_futureÚcancellationÚacquire_errorÚerrorÚrollback_errors         rl   rÆ   z&BaseAsyncFileLock._run_acquire_attemptÄ  sp  è ø€ Ø×4Ñ4ä" 4§=¡=Ô1ð ×2Ò2à×0Ñ0ó
ˆð
	Ü" >Ó2×2Ð2ð>	JÜ˜>Õ*ðA 3ùÜ×%Ñ%ò 	Ø26ˆMð&Ü# NÓ3×3Ò3øÜ ò &Ø %•ûð&úð 48ˆNØ�~Š~ð+Ü'¨×(CÑ(CÓ(EÓF×FÒFøÜ$ò +Ø%*•Nûð+úð Ð(Ø!Ð-Ø×0Ñ0Ø]Ø$Ø%Ø&ô	ð ×,Ñ,ØSÐUaÐcpôð Ð)Ø×,Ñ,ØLÈlÐ\jôð ûð;	ûô@ ×%Ñ%ò 	JØ×:Ñ:¸=ÓI×IÖIûð	JüsØ   ‚=E2Á A" ÁA ÁA" ÁD8 ÁE2Á A" Á"D5Á5D0Á8BÂB	ÂBÂD0Â	B"ÂBÂD0ÂB"Â"D0Â4CÃCÃCÃD0Ã	C,Ã C'Ã"D0Ã'C,Ã,AD0Ä0D5Ä5E2Ä8E/ÅE*ÅE"Å E*Å%E2Å*E/Å/E2c           	     óP  — t        |«      r-t        j                  t         t	        d|«      «       «      «      S t        j
                  «       }t	        d|«      }| j                  rt        || j                  |«      S |j                  «       }|j                  t        |«      «       |S )Nz)Callable[[], Coroutine[None, None, None]]zCallable[[], None])r   r   Úcreate_taskr-   r   rº   r]   r1   r^   Úcreate_futureÚ
set_resultr.   )rŒ   Úmethodr\   Úsync_methodr¼   s        rl   rÐ   z(BaseAsyncFileLock._start_internal_methodï  s�   € ô ˜vÔ&Ü×&Ñ&Ô'9Ð:s¼$Ð?jÐlrÓ:sÓ:uÓ'vÓwÐwÜ×'Ñ'Ó)ˆÜÐ/°Ó8ˆØ×ÒÜ# D¨$¯-©-¸ÓEÐEØ8<×8JÑ8JÓ8LˆØ×Ñœ-¨Ó4Ô5Øˆrm   c              ƒ  óÚ  K  — | j                  «        t        | «      5  	  t        d| j                  «      «       ƒ d {  –—†  	 | j                  «        	 d d d «       | j                  r| j                  «       ƒ d {  –—†  y y 7 ŒD# t        $ r }| j                  |«      ƒ d {  –—†7   ‚ d }~ww xY w# t        $ r }| j                  |«      ƒ d {  –—†7   ‚ d }~ww xY w# 1 sw Y   Œ‰xY w7 Œl­w©NzCallable[[], Awaitable[None]])
Ú_try_break_expired_lockr   r   r¹   r³   Ú_rollback_failed_acquire_asyncÚ_register_context_descriptorÚ#_rollback_failed_registration_asyncr«   Ú_invoke_on_acquired_async)rŒ   Úacquisition_errorÚregistration_errors      rl   rÑ   z3BaseAsyncFileLock._acquire_with_fork_tracking_asyncü  sÛ   è ø€ Ø×$Ñ$Ô&Ü˜dÓ#ñ 
	ðØJ”dÐ:¸D¿M¹MÓJÓL×LÐLðØ×1Ñ1Õ3÷
	ð �>Š>Ø×0Ñ0Ó2×2Ñ2ð ð MùÜ ò Ø×9Ñ9Ð:KÓL×LÑLØûðûô
 !ò Ø×>Ñ>Ð?QÓR×RÑRØûðú÷
	ð 
	úð 3ús‹   ‚C+žC B¾B¿BÁB1Á'C+Á<C)Á=C+ÂBÂ	B.ÂB)Â"B%Â#B)Â)B.Â.CÂ1	CÂ:CÃCÃCÃCÃCÃC&Ã"C+c              ƒ  ó´  K  — | j                   sy d }d }	 | j                  «        	 t	        | j                  «       «      ƒ d {  –—†  |�t        d|||«       y y # t        $ r6}|}	 | j                  «        n# t        $ r}|}Y d }~nd }~ww xY wY d }~Œnd }~ww xY w7 ŒX# t        $ r/}|€|€| j                  ||«       t        d||||«       Y d }~Œ‰d }~ww xY w­w)Nzlock acquisition cleanup failed)r«   ræ   r³   Ú'_register_unverified_context_descriptorr/   rÔ   Ú_raise_acquire_rollback_errorsr%   )rŒ   ré   rê   Útracking_errorrÚ   rÛ   s         rl   rå   z0BaseAsyncFileLock._rollback_failed_acquire_async  só   è ø€ Ø�~Š~ØØ37ÐØ/3ˆð	'Ø×-Ñ-Ô/ð	Ü × ;Ñ ;Ó =Ó>×>Ð>ð Ð)Ü!Ø1Ð3DÐFXÐZhõð *øô' ò 	'Ø!&Ðð'à×<Ñ<Õ>øÜ ò 'Ø!&•ûð'ÿûð	'úð ?ùÜò 		Ø!Ð)¨nÐ.DØ×3Ñ3Ð4EÀ~ÔVÜ!Ø1Ø!Ø"ØØ÷ñ ûð		üs�   ‚C•A ¦B ÁBÁB ÁCÁ	BÁ"BÁ%A6Á5BÁ6	BÁ?BÂBÂBÂBÂCÂBÂCÂB Â	CÂ&%CÃCÃCÃCc                óT   — | j                   dk(  rt        d||«       t        ||«       y )NÚgroupz1lock acquisition backend and rollback both failed)Ú_context_error_policyr&   r$   ©rŒ   rÙ   rÛ   s      rl   rí   z0BaseAsyncFileLock._raise_acquire_rollback_errors+  s)   € Ø×%Ñ%¨Ò0Ü!Ð"UÐWdÐftÔuÜ˜m¨^Õ<rm   c              ƒ  ó  K  — d }	 | j                  «        	 t        | j                  «       «      ƒ d {  –—†  |�t	        d||«       y y # t        $ r}|}Y d }~ŒCd }~ww xY w7 Œ-# t        $ r}t	        d|||«       Y d }~ŒGd }~ww xY w­w)Nz&descriptor registration cleanup failed)rì   r³   r/   rÔ   r%   )rŒ   rê   rî   rÚ   rÛ   s        rl   rç   z5BaseAsyncFileLock._rollback_failed_registration_async0  s—   è ø€ Ø/3ˆð	#à×8Ñ8Ô:ð	Ü × ;Ñ ;Ó =Ó>×>Ð>ð
 Ð%Ü!Ð"JÐL^Ð`nÕoð &øô ò 	#Ø"�Nûð	#úð ?ùÜò 	Ü!Ø8Ð:LÈnÐ^l÷ñ ûð	üs`   ‚B†A	 —A# ³A!´A# ¸BÁ		AÁAÁBÁAÁBÁ!A# Á#	BÁ,A?Á:BÁ?BÂBc              ƒ  óš  K  — | j                   �| j                  j                  dk7  ry 	 | j                  t        d| j                  j                  «      «       y # t
        $ re}|j                  }	 t        | j                  «       «      ƒ d {  –—†7   ||_        ‚ # t
        $ r}t        ||«       Y d }~||_        ‚ d }~ww xY wd }~ww xY w­w)Nr¦   rp   )
Ú_on_acquiredr‹   r¬   r   Úlock_file_fdr³   Ú__context__r/   rÔ   r#   )rŒ   Úcallback_errorÚcallback_contextÚrelease_errors       rl   rè   z+BaseAsyncFileLock._invoke_on_acquired_async@  sº   è ø€ Ø×ÑÐ$¨¯©×(BÑ(BÀaÒ(GØð		Ø×Ñœd 5¨$¯-©-×*DÑ*DÓEÕFøÜò 	Ø-×9Ñ9ÐðGÜ# D×$?Ñ$?Ó$AÓB×BÑBð *:ˆNÔ&Øøô !ò GÜ'¨¸×FÐFØ)9ˆNÔ&ØûðGþð		üs^   ‚'Cª/A ÁCÁ	CÁ#CÁ0BÂBÂBÂCÂ	C Â#B;Â/CÂ;C Ã CÃCÃCc                óD   — | j                  «        | j                  «        y r¸   )rä   Ú_acquire_with_fork_trackingrš   s    rl   rÒ   z,BaseAsyncFileLock._break_expired_and_acquireN  s   € à×$Ñ$Ô&Ø×(Ñ(Õ*rm   c                ó‚   — | j                  t        | j                  «      r| j                  «      S | j                  «      S r¸   )rÐ   r   Ú_releaseÚ!_release_with_fork_tracking_asyncÚ_release_with_fork_trackingrš   s    rl   rÔ   z(BaseAsyncFileLock._start_tracked_releaseS  sA   € Ø×*Ñ*ä" 4§=¡=Ô1ð ×2Ñ2ó
ð 	
ð ×1Ñ1ó
ð 	
rm   c              ƒ  óä   K  — t        | «      5  	  t        d| j                  «      «       ƒ d {  –—†  | j                  «        	 d d d «       y 7 Œ# | j                  «        w xY w# 1 sw Y   y xY w­wrã   )r   r   rþ   Ú_unregister_released_descriptorrš   s    rl   rÿ   z3BaseAsyncFileLock._release_with_fork_tracking_asyncZ  sc   è ø€ Ü˜dÓ#ñ 	7ð7ØJ”dÐ:¸D¿M¹MÓJÓL×LÐLà×4Ñ4Õ6÷		7ð 	7àLùà×4Ñ4Õ6ú÷		7ð 	7üsB   ‚A0ŽA$�A®A¯A³A$Á	A0ÁAÁA!Á!A$Á$A-Á)A0c                ó  — | j                   dk(  r8|t        k(  rt        t        fnd }|€t	        ||||¬«       t	        |||||¬«       |j
                  x}�%||ur!|j
                  x}�t        ||«       ||_        ||_        t        ||«       y )Nrð   )Úmarker)rñ   rC   rE   rF   r&   r÷   r   r$   )rŒ   ÚmessagerØ   Úfirst_errorÚsecond_errorr  ÚcontextÚcancellation_contexts           rl   rÕ   z)BaseAsyncFileLock._raise_cancelled_errorsa  s§   € ð ×%Ñ%¨Ò0ð Ô@Ò@ô 9Ô:\Ñ]àð ð
 Ð#Ü% g¨|¸[ÐQWÕXÜ! '¨<¸ÀlÐ[aÕbØ"×.Ñ.Ð.ˆGÐ;ÀÈ|Ñ@[Ø(4×(@Ñ(@Ð@Ð$ÐMÜ)¨'Ð3GÔHØ'.ˆLÔ$Ø".ˆÔÜ˜k¨<Õ8rm   c              ƒ  óÄ   K  — | j                   r$	 t        | j                  «       «      ƒ d {  –—†  |‚|‚7 Œ# t        $ r}| j	                  ||«       Y d }~|‚d }~ww xY w­wr¸   )r«   r/   rÔ   r³   rí   rò   s      rl   rÖ   z5BaseAsyncFileLock._rollback_backend_cancelled_acquirex  sg   è ø€ Ø�>Š>ðSÜ# D×$?Ñ$?Ó$AÓB×BÐBð ÐˆmÐð CùÜ ò SØ×3Ñ3°MÀ>×RÐRØÐûðSüs7   ‚A �7 ¬5­7 ±A µ7 ·	AÁ AÁA ÁAÁA c              ƒ  óB   K  — | j                  |«      ƒ d{  –—†  y7 Œ­w)a%  
        Release the lock, reconciling a release failure with any body failure per :attr:`context_error_policy`.

        :param exc_type: the exception type if raised
        :param exc_value: the exception value if raised
        :param traceback: the exception traceback if raised

        N)Ú_release_in_context©rŒ   r”   r•   r–   s       rl   Ú	__aexit__zBaseAsyncFileLock.__aexit__€  s   è ø€ ð ×&Ñ& yÓ1×1Ò1ús   ‚—˜c              ƒ  óh  K  — 	 | j                  «       ƒ d {  –—†  y 7 Œ# t        $ r‡}|€‚ | j                  dk(  rt        ||«       ‚ t	        |t
        t        t        f«      x}	 �4|  r0 dk(  r+\  xt        j                  d˜ x�\   }}t        d|||«       n   t        ||«       Y d }~y d }~ww xY w­w)NrP   é   rd   z>context body, release cancellation, and backend release failed)Úreleaser³   rñ   r   r    rC   rE   rF   r   rÓ   r&   r#   )rŒ   Ú
body_errorrú   ÚerrorsrØ   Úbackend_errors         rl   r  z%BaseAsyncFileLock._release_in_context�  sº   è ø€ ð	?Ø—,‘,“.× Ò ùÜò 	?ØÐ!ØØ×)Ñ)¨WÒ4Ü)¨-¸ÔDØä)Ø!Ü6Ü<Ô>`Ðaóð �ð
 ðð çRÐRÐBœ'×0Ñ0Õ2ÑRÜ-Ø\Ø&Ø(Ø)õ	ò Sô $ J°×>Ñ>ûð-	?üs7   ‚B2„ —˜ œB2� Ÿ	B/¨A=B*Â%B2Â*B/Â/B2c              ƒ  óL  K  — | j                   t        j                  «       k7  s| j                  sy| j                  j
                  j                  «       4 ƒd{  –—†  | j                  |¬«      ƒ d{  –—†  ddd«      ƒd{  –—†  y7 Œ/7 Œ7 Œ	# 1 ƒd{  –—†7  sw Y   yxY w­w)a1  
        Release the file lock. The lock is only completely released when the lock counter reaches 0. The lock file
        itself may be deleted automatically, the behavior is platform-specific.

        :param force: If true, the lock counter is ignored and the lock is released in every case.

        N©Úforce)Ú_creator_pidrˆ   Úgetpidr«   rŠ   r©   ÚholdÚ_release_serialized)rŒ   r  s     rl   r  zBaseAsyncFileLock.release®  s‡   è ø€ ð ×Ñ¤§	¡	£Ò+°4·>²>ØØ×&Ñ&×6Ñ6×;Ñ;Ó=÷ 	8ñ 	8Ø×*Ñ*°Ð*Ó7×7Ð7÷	8÷ 	8ñ 	8øØ7øð	8ø÷ 	8÷ 	8ñ 	8üsZ   ‚AB$ÁB	ÁB$ÁBÁ3BÁ4BÁ8B$ÂBÂB$ÂBÂB$ÂB!ÂBÂB!ÂB$c             ƒ  óä  K  — | j                   j                  }| j                  sy |s9| j                   j                  dkD  r | j                   xj                  dz  c_        y 	 | j                  «       ƒ d {  –—†  y 7 Œ# t        $ rg}| j                  ||«      rOt        j                  t        «      5  | j                  «        d d d «       n# 1 sw Y   nxY w| j                  «        ‚ d }~ww xY w­w)Nr¦   )r‹   r¬   r«   Ú_release_through_backendr³   Ú"_release_interrupted_before_commitr   ÚsuppressÚ	Exceptionr   Ú_commit_release_if_released)rŒ   r  Úcounter_beforerú   s       rl   r  z%BaseAsyncFileLock._release_serialized»  s¿   è ø€ Ø $§¡× :Ñ :ˆØ�~Š~ØÙ˜Ÿ™×3Ñ3°aÒ7Ø�M‰M×&Ò&¨!Ñ+Õ&Øð	Ø×/Ñ/Ó1×1Ò1ùÜò 	Ø×6Ñ6°~À}ÔUÜ×(Ñ(¬Ó3ñ 7Ø×4Ñ4Ô6÷7÷ 7ñ 7úà×0Ñ0Ô2Øûð	üsT   ‚AC0Á"A= Á5A;Á6A= Á:C0Á;A= Á=	C-Â+C(Â1CÃ	C(ÃC	ÃC(Ã(C-Ã-C0c              ƒ  óT  K  — t        | «      | j                  }}t        j                  d||«       | j	                  «       }	 t        |«      ƒ d {  –—†  	 t        |«       | j                  «        t        j                  d||«       y 7 Œ8# t        j                  $ ri}	 t        |«      ƒ d {  –—†7   n=# t        $ r1}| j                  «        | j                  t        ||«       Y d }~nd }~ww xY w| j                  «        ‚ d }~ww xY w# t        $ r | j                  «        ‚ w xY w­w)Nz#Attempting to release lock %s on %szLock %s released on %s)rÃ   r`   rB   rÅ   rÔ   r2   r   rÓ   r/   r³   r!  rÕ   rC   Ú_commit_releaser0   )rŒ   rÌ   rÍ   Úrelease_futurerØ   rú   s         rl   r  z*BaseAsyncFileLock._release_through_backendÌ  s	  è ø€ Ü!# D£¨4¯>©>�ˆÜ�‰Ð;¸WÀmÔTØ×4Ñ4Ó6ˆð		Ü" >Ó2×2Ð2ð	Ü˜>Ô*ð 	×ÑÔÜ�‰Ð.°¸ÕGð 3ùÜ×%Ñ%ò 	ðnÜ# NÓ3×3Ò3øÜ ò nØ×0Ñ0Ô2Ø×,Ñ,Ô-OÐQ]Ð_l×mÑmûðnúð × Ñ Ô"Øûð	ûô ò 	Ø×,Ñ,Ô.Øð	üs}   ‚?D(ÁB ÁB	ÁB ÁD
 Á!(D(Â	B ÂDÂB4Â-B0Â.B4Â3DÂ4	C.Â='C)Ã$DÃ)C.Ã.DÄDÄD(Ä
D%Ä%D(c                óô   — || j                   j                  k(  xr^ | j                  xrP | j                   xrA t	        | j
                  «       xr) t        |t        j                  «       xr t        |«       S r¸   )
r‹   r¬   r«   r]   r   rþ   Ú
isinstancer   rÓ   r!   )rŒ   r"  rú   s      rl   r  z4BaseAsyncFileLock._release_interrupted_before_commitâ  sz   € ð
 ˜dŸm™m×8Ñ8Ñ8ò ;Ø—‘ò;à×(Ñ(Ð(ò;ô (¨¯©Ó6Ð6ò;ô ˜}¬g×.DÑ.DÓEÐEò	;ô
 ,¨MÓ:Ð:ð	
rm   c                ó>   — | j                   s| j                  «        y y r¸   )r«   r$  rš   s    rl   r!  z-BaseAsyncFileLock._commit_release_if_releasedï  s   € ð �~Š~Ø× Ñ Õ"ð rm   c                 ó*   — t        j                  «       S r¸   )r   Úcurrent_taskrd   rm   rl   Ú_deadlock_scopez!BaseAsyncFileLock._deadlock_scopeõ  s   € ô ×#Ñ#Ó%Ð%rm   c               ó   •‡— t         ‰| �  ‰«      }|j                  ˆfd„d| j                  fd| j                  ffD «       «       ‰d   | j
                  k7  r&t        ‰d   «      t        | j
                  «      f|d<   |S )Nc              3  óh   •K  — | ])  \  }}‰|   |ur|t        ‰|   «      t        |«      ff–— Œ+ y ­wr¸   )r~   )Ú.0ÚnamerÁ   ri   s      €rl   ú	<genexpr>z@BaseAsyncFileLock._singleton_extra_mismatches.<locals>.<genexpr>   s@   øè ø€ ò 
á��eØ�d‰| 5Ñ(ð ”C˜˜t™Ó%¤s¨5£zÐ2Ô3ñ
ùs   ƒ/2r\   r^   r]   )rf   Ú_singleton_extra_mismatchesÚupdater\   r^   r]   r~   )rŒ   ri   Ú
mismatchesrk   s    ` €rl   r1  z-BaseAsyncFileLock._singleton_extra_mismatchesý  s‡   ù€ Ü‘WÑ8¸Ó@ˆ
à×Ñó 
à!'¨¯©Ð 3°jÀ$Ç-Á-Ð5PÐQô
ô 	
ð
 Ð#Ñ$¨×(<Ñ(<Ò<Ü-0°Ð8IÑ1JÓ-KÌSÐQU×QeÑQeÓMfÐ,gˆJÐ(Ñ)ØÐrm   c                ó.   — | j                   j                  S )zThe event loop.)rŠ   r\   rš   s    rl   r\   zBaseAsyncFileLock.loop	  s   € ð ×"Ñ"×'Ñ'Ð'rm   c                óp  — t        j                  t        «      5  | j                  r/t	        | j
                  «      s| j                  «        	 d d d «       y 	 t        j                  «       }| j                  «        |j                  | j                  d¬«      «      }t*        j-                  |«       |j/                  | j0                  «       d d d «       y # t        $ rË | j                  j                  x}�$|j                  «       st!        j"                  «       r| j                  «        Y d d d «       y |j%                  «       s+|j'                  | j                  d¬«      «       Y d d d «       y | j                  «        t        j(                  | j                  d¬«      |«      }Y �Œw xY w# 1 sw Y   y xY w)NTr  )r   r  r   Ú_is_thread_localr   rþ   Ú_release_without_loopr   rº   Ú_drop_registry_entryrÝ   r  ÚRuntimeErrorrŠ   r\   Ú	is_closedÚsysÚis_finalizingÚ
is_runningÚrun_until_completeÚrun_coroutine_threadsaferG   ÚaddÚadd_done_callbackÚ_settle_finalizer_release)rŒ   r\   Úpendings      rl   Ú_release_abandoned_holdsz*BaseAsyncFileLock._release_abandoned_holds  sz  € ä× Ñ ¤Ó+ñ 	Fð ×$Ò$Ô-@ÀÇÁÔ-OØ×*Ñ*Ô,Ø÷	Fð 	FðEÜ×/Ñ/Ó1�ð ×)Ñ)Ô+Ø×*Ñ*¨4¯<©<¸d¨<Ó+CÓD�ä×#Ñ# GÔ,Ø×%Ñ% d×&DÑ&DÔE÷3	Fð 	Føô  ò [à ×/Ñ/×4Ñ4Ð4�DÐ=ÀÇÁÔAQÔUX×UfÑUfÔUhØ×.Ñ.Ô0Ø÷	Fð 	Fð —‘Ô(Ø×+Ñ+¨D¯L©L¸t¨LÓ,DÔEØ÷	Fð 	Fð" ×)Ñ)Ô+ä!×:Ñ:¸4¿<¹<Èd¸<Ó;SÐUYÓZ“ð[ú÷	Fð 	FúsI   š3F,ÁCÁ+A!F,ÃAF)Ä*F,Ä41F)Å%F,Å/6F)Æ%F,Æ(F)Æ)F,Æ,F5c                óØ   — t        | j                  «      ry | j                  r!	 | j                  «        | j	                  «        | j                  d¬«       y # | j	                  «        w xY w)NF)Úexited_only)r   rþ   r«   r   r!  Ú_release_thread_holdsrš   s    rl   r7  z'BaseAsyncFileLock._release_without_loop+  sX   € ô ˜tŸ}™}Ô-ØØ�>Š>ð3Ø×0Ñ0Ô2à×0Ñ0Ô2à×"Ñ"¨uÐ"Õ5øð ×0Ñ0Õ2ús   ¤A ÁA)c                ón  — t         j                  |«       t        j                  t        j
                  t        j
                  «      5  |j                  «       €
	 d d d «       y 	 d d d «       t        j                  t        «      5  | j                  «        d d d «       y # 1 sw Y   Œ<xY w# 1 sw Y   y xY wr¸   )
rG   Údiscardr   r  r   rÓ   r	   Ú	exceptionr   r7  )rŒ   rC  s     rl   rB  z+BaseAsyncFileLock._settle_finalizer_release8  s–   € Ü×#Ñ# GÔ,ä× Ñ ¤×!7Ñ!7¼×9OÑ9OÓPñ 	Ø× Ñ Ó"Ð*Ø÷	ð 	Ø*÷	ô × Ñ ¤Ó+ñ 	)Ø×&Ñ&Ô(÷	)ð 	)÷	ð 	ú÷	)ð 	)ús   ÁBÂB+ÂB(Â+B4)"r`   rn   ra   ro   rb   rp   rc   rq   rS   rq   rT   rq   rU   ro   rV   rr   rW   r   rX   r   rY   rq   rZ   rq   r[   rs   r\   rt   r]   rq   r^   ru   rv   ÚNone)rv   r   ©r”   ztype[BaseException] | Noner•   úBaseException | Noner–   zTracebackType | Nonerv   rK  )rv   r@   )NN)
ra   rr   rU   rr   rS   zbool | Nonerœ   úCallable[[], bool] | Nonerv   r­   )rS   rq   rœ   rN  ra   ro   rU   ro   rŸ   ro   rv   r­   )r»   zCallable[[], _T]rv   rK   )rv   rq   )rv   ru   )rÁ   ru   rv   rK  )rS   rq   rœ   rN  ra   ro   rU   ro   rŸ   ro   rv   rK  )rv   rK  )rà   z>Callable[[], None] | Callable[[], Coroutine[None, None, None]]rv   ú%asyncio.Future[_BackendOutcome[None]])ré   r³   rv   rK  )rÙ   r³   rÛ   r³   rv   r   )rê   r³   rv   rK  )rv   rO  r¸   )
r  r~   rØ   úasyncio.CancelledErrorr  r³   r  rM  rv   r   )rÙ   rP  rv   r   )r  rM  rv   rK  )F)r  rq   rv   rK  )r"  rp   rú   r³   rv   rq   )rv   zHashable | None)ri   zMapping[str, _ExtraValue]rv   zdict[str, tuple[str, str]])rv   rt   )rC  z)asyncio.Task[None] | futures.Future[None]rv   rK  )/rw   rx   ry   rz   r   Ú__annotations__r�   r   r�   r’   r—   r›   r™   r£   r®   Úpropertyr]   r^   Úsetterr²   rÆ   rÐ   rÑ   rå   rí   rç   rè   rÒ   rÔ   rÿ   rÕ   rÖ   r  r  r  r  r  r  r!  Ústaticmethodr+  r1  r\   rD  r7  rB  r{   r|   s   @rl   rI   rI   ˆ   sƒ  ø… ñð "KÐ˜3ÓJØ45Ð,¨cÓ5ð
 Ø$Ø"ðn$ð Ø"Ø#Ø!%Ø3:Ø/8Ø!%Ø#(Ø48Ø15Ø $Ø,0ñ%n$à)ðn$ð ðn$ð ð	n$ð
 ðn$ð ðn$ð ðn$ð ðn$ð ðn$ð 1ðn$ð -ðn$ð ðn$ð !ðn$ð 2ðn$ð  /ð!n$ð" ð#n$ð$ *ð%n$ð& 
ó'n$ó`'ð
'à,ð'ð (ð'ð (ð	'ð
 
ó'óð !%Ø&*ðC4ð
 !%Ø26ñC4àðC4ð $ðC4ð
 ðC4ð 0ðC4ð 
!óC4ðJ$6ð ð$6ð 0ð	$6ð
 ð$6ð ð$6ð ð$6ð 
!ó$6óL&ð ò3ó ð3ð ò,ó ð,ð ‡_�_ò-ó ð-ð'ð ð'ð 0ð	'ð
 ð'ð ð'ð ð'ð 
ó'óB)JðVØTðà	.óó3ó ó>=ó
pó ó+ó

ó7ð .2ð9àð9ð -ð9ð #ð	9ð
 +ð9ð 
ó9ó.ð2à,ð2ð (ð2ð (ð	2ð
 
ó2ð ?Ø.ð?à	ó?ô<8óó"Hó,
ó#ð ò&ó ð&õ
ð ò(ó ð(óFó:6÷)rm   )Ú	metaclassc                 ó   — t        «       S r¸   )r*   rd   rm   rl   Ú_new_transition_gaterW  B  s   € äÓ!Ð!rm   c                  óX   — e Zd ZU dZdZded<   dZded<   dZded	<    ee	¬
«      Z
ded<   y)r‡   zGA dataclass which holds the context for a ``BaseAsyncFileLock`` object.Trq   r]   Nru   r^   rt   r\   )Údefault_factoryr*   r©   )rw   rx   ry   rz   r]   rQ  r^   r\   r   rW  r©   rd   rm   rl   r‡   r‡   G  s>   … áQð !€O�TÓ ð )-€HÐ%Ó,ð .2€DÐ
*Ó1ñ -2ÐBVÔ,W€OÐ)ÔWrm   r‡   c                  óJ   — e Zd ZdZdddddœ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd„Zy)r†   aÆ  
    A thread local version of the ``FileLockContext`` class.

    :param lock_file: The path of the lock file.
    :param timeout: The timeout for acquiring the lock, ``-1`` for unlimited.
    :param mode: The file mode of the lock file.
    :param blocking: Whether acquiring the lock blocks.
    :param poll_interval: The interval between attempts to acquire the lock.
    :param lifetime: The lifetime of the lock, or ``None`` for no expiry.
    :param run_in_executor: Whether the lock is acquired in an executor.
    :param executor: The executor to use, or ``None`` for the loop's default.
    :param loop: The event loop the lock is bound to.
    :ivar current: The context of the calling thread.

    NT)rV   r]   r^   r\   c       	        ó6   — t        |||||||||	¬«	      | _        y )N)	r`   ra   rb   rS   rU   rV   r]   r^   r\   )r‡   Úcurrent)
rŒ   r`   ra   rb   rS   rU   rV   r]   r^   r\   s
             rl   r�   z$AsyncThreadLocalFileContext.__init__k  s+   € ô ,ØØØØØ'ØØ+ØØô

ˆ�rm   )r`   r~   ra   ro   rb   rp   rS   rq   rU   ro   rV   rr   r]   rq   r^   ru   r\   rt   rv   rK  )rw   rx   ry   rz   r�   rd   rm   rl   r†   r†   Y  s~   „ ñð2 "&Ø $Ø,0Ø15ñ
ð ð
ð ð	
ð
 ð
ð ð
ð ð
ð ð
ð ð
ð *ð
ð /ð
ð 
ô
rm   r†   c                  ó8   — e Zd ZdZdd„Zdd„Z	 	 	 	 	 	 	 	 dd„Zy)	r­   z|
    A context-aware object that will release the lock file when exiting.

    :param lock: the lock to release on exit
    c                ó   — || _         y r¸   r§   )rŒ   r¨   s     rl   r�   z AsyncAcquireReturnProxy.__init__�  s	   € Øˆ�	rm   c              ƒ  ó"   K  — | j                   S ­wr¸   r§   rš   s    rl   r›   z"AsyncAcquireReturnProxy.__aenter__“  s   è ø€ Ø�y‰yÐùs   ‚c              ƒ  óV   K  — | j                   j                  |«      ƒ d {  –—†  y 7 Œ­wr¸   )r¨   r  r  s       rl   r  z!AsyncAcquireReturnProxy.__aexit__–  s    è ø€ ð �i‰i×+Ñ+¨IÓ6×6Ò6ús   ‚)¡'¢)N)r¨   rI   rv   rK  )rv   rI   rL  )rw   rx   ry   rz   r�   r›   r  rd   rm   rl   r­   r­   ‰  s<   „ ñóóð7à,ð7ð (ð7ð (ð	7ð
 
ô7rm   r­   c                  ó    — e Zd ZU dZdZded<   y)ÚAsyncSoftFileLockz.Simply watches the existence of the lock file.)ÚAsyncStrictSoftFileLockÚAsyncSoftFileLeaseztuple[str, str] | NoneÚ_lifetime_replacementsN)rw   rx   ry   rz   re  rQ  rd   rm   rl   rb  rb  Ÿ  s   … Ù8à5fÐÐ2Ôfrm   rb  c                  ó   — e Zd ZdZy)rc  z?Run strict owner-claim locking without blocking the event loop.N©rw   rx   ry   rz   rd   rm   rl   rc  rc  ¥  s   „ ÚIrm   rc  c                  ó   — e Zd ZdZy)rd  z_Existence lock whose claim expires, so a peer may take it while the previous holder still runs.Nrg  rd   rm   rl   rd  rd  ©  s   „ Úirm   rd  c                  ó   — e Zd ZdZy)ÚAsyncUnixFileLockzHUses the :func:`fcntl.flock` to hard lock the lock file on unix systems.Nrg  rd   rm   rl   rj  rj  ­  s   „ ÚRrm   rj  c                  ó   — e Zd ZdZy)ÚAsyncWindowsFileLockzRUses ``LockFileEx`` to hard lock a byte range of the lock file on Windows systems.Nrg  rd   rm   rl   rl  rl  ±  s   „ Ú\rm   rl  c                 ó    — t        t        «      S r¸   )ÚlistÚ__all__rd   rm   rl   Ú__dir__rp  µ  s   € ä”‹=Ðrm   )
r­   r‡   rM   rd  rb  rc  r†   rj  rl  rI   )rv   r*   )rv   z	list[str])lrz   Ú
__future__r   Ú__lazy_modules__r   r   r   Úloggingrˆ   r;  r¡   r   r	   Údataclassesr
   r   r   r   r   Útypingr   r   r   r   r   Úfilelock._apir   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   Úfilelock._asyncr*   r+   r,   r-   r.   r/   r0   r1   r2   Úfilelock._errorr3   Úfilelock._leaser4   Úfilelock._softr5   Úfilelock._strictr6   Úfilelock._unixr7   Úfilelock._utilr8   Úfilelock._windowsr9   Úcollections.abcr:   r;   r<   r=   r>   Útypesr?   r@   Ú	getLoggerrB   rQ  rC   rE   rF   ÚsetrG   rH   rK   rM   rI   rW  r‡   r†   Ú_fieldÚsetattrr/  r­   rb  rc  rd  rj  rl  rp  ro  rd   rm   rl   ú<module>r…     sç  ðÚ 7å "ò	Ð ó Û Û Û Û 	Û 
Û Ý ß 0Ñ 0Ý 'ß @Õ @÷÷ ÷ ÷ ÷ ÷ ñ ÷2
÷ 
õ 
õ $Ý )Ý 'Ý /Ý 'Ý 2Ý -áßQÕQÝ#Ýð "3 ×!2Ñ!2°:Ó!>€Ð	Ó >Ø1lÐ " JÓ lØ6\Ð '¨Ó \Ø8:Ð "Ð$5Ó :ÙMPËUÐ ÐJÓ RáˆeÐ.Ô/€ÙˆTƒ]€ô-
˜ô -
ô`w
)˜Ð0Aõ w
)ót"ð
 ôX˜?ó Xó ðXô")
Ð"6Ð8Nô )
ñX Ð)Ó*ò Y€FÙÐ'¨¯©Ñ6JÈ6Ï;É;Ó6WÕXðY÷7ñ 7ô,g˜Ð&7ô gôJÐ0Ð2Cô Jôj˜Ð(9ô jôS˜Ð&7ô Sô]˜?Ð,=ô ]óò
�rm   