o
    ôj(Í  ã                   @  s„  U d dl m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	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 d dlmZmZ d dlmZ d dlmZmZmZmZmZmZmZ d dl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- d	dl.m/Z/ d	dl0m1Z1m2Z2m3Z3 e	j4dkržd	dl5m6Z6 erÀd dl7m8Z8m9Z9 d dl:m;Z; e	j<dkrºd dlm=Z= nd dl>m=Z= e ?d¡Z@deAd< ejBZCdeAd< e	jDjEdkZFdeAd< eGedƒoée	jDjEdkoée	j<dk ZHdeAd< eIeJB ejKeI B ejKeJ B eLB eMB eNejO B dB ZPdeAd < eQeMeMf ZRdeAd!< d"ZSd#eAd$< d%ZTd#eAd&< ejUejVB eWed'd ƒB eWed(d ƒB ZXd#eAd)< e	j4d*k�r?d+nd,ZYd-eAd.< d/ZZd0eAd1< e[d2d3ƒZ\d4eAd5< d3Z]d#eAd6< d7Z^d#eAd8< G d9d:„ d:ej_ƒZ`e`ƒ Zad;eAd<< G d=d>„ d>ƒZbebƒ Zcd;eAd?< G d@dA„ dAƒZdedƒ Zed;eAdB< dCZfd-eAdD< egƒ ZhdEeAdF< G dGdH„ dHƒZiG dIdJ„ dJeƒZjedKdL�G dMdN„ dNƒƒZkeiƒ Zld;eAdO< G dPdQ„ dQejOƒZmG dRdS„ dSeNƒZnG dTdU„ dUendV�Zodˆd^d_„Zpdˆd`da„Zqd‰ddde„ZrdŠdhdi„Zsd‹dldm„ZtdŒdndo„Zud�dqdr„ZvdŽdtdu„Zwd�dwdx„Zxed�dzd{„ƒZyd‘d|d}„Zzd’d�d‚„Z{d“d…d†„Z|e(ecƒ e(eeƒ e(elƒ e'eoƒ eF�r0e	 }e{¡ eGedƒ�r<ej~ezd‡� dUd†gZdS )”é    )ÚannotationsN)Údeque)ÚcontextmanagerÚsuppress)Ú	dataclassÚfield)Úcount)ÚTYPE_CHECKINGÚClassVarÚFinalÚLiteralÚ
NamedTupleÚ	TypeAliasÚcast)ÚWeakValueDictionaryé   )ÚAcquireReturnProxyÚ
_canonicalÚ_ensure_current_processÚ_fork_transitionÚ_raise_chained_errorsÚ_register_fork_classÚ_register_fork_objectÚ_register_owned_descriptorÚ_resolve_read_write_timeoutÚ_secondsÚ_timeout_behaviorÚ_unregister_owned_descriptor)ÚTimeout)Ú	host_nameÚowner_is_staleÚprocess_start_tokenÚwin32)Ú_open_non_reparse_fd)ÚCallableÚ	Generator)ÚUnused)é   é   )ÚSelfÚfilelockzFinal[logging.Logger]Ú_LOGGERzFinal[Callable[[], int]]Ú_GETPIDZpypyzFinal[bool]Ú_IS_PYPYÚregister_at_forkZcpython)r'   é   Ú_NEEDS_CONNECTION_ESCROWr   Ú_ConnectionParameterÚ_DatabaseIdentityiÿ“5wz
Final[int]Ú_MAX_SQLITE_TIMEOUT_MSéF   Ú_UNSAFE_FORK_EXIT_STATUSÚ
O_NOFOLLOWÚ
O_NONBLOCKÚ_DB_OPEN_FLAGSÚlinuxz/proc/self/fdz/dev/fdz
Final[str]Ú_FD_DIRs   SQLite format 3 zFinal[bytes]Ú_SQLITE_MAGICé   é   zFinal[slice]Ú_FORMAT_VERSIONSÚ_HEADER_SIZEé   Ú_WAL_FORMAT_VERSIONc                   @  s   e Zd ZU dZded< dS )Ú_SQLiteTransitionContextr   ÚintÚdepthN)Ú__name__Ú
__module__Ú__qualname__rD   Ú__annotations__© rI   rI   úe/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/filelock/_read_write.pyrB   N   s   
 rB   r   Ú_SQLITE_TRANSITION_CONTEXTc                   @  s*   e Zd Zddd„Zddd„Zddd	„Zd
S )Ú_ConnectionEscrowÚreturnÚNonec                 C  s   t  ¡ | _d | _d S ©N)Ú	threadingÚRLockÚ_lockÚ
_functions©ÚselfrI   rI   rJ   Ú__init__V   s   

z_ConnectionEscrow.__init__úXtuple[Callable[[sqlite3.Connection], None], Callable[[sqlite3.Connection], None]] | Nonec                 C  sº   t sd S | j�L | jd u rIdd l}| d |j¡}| |jj|j	¡j
}| |jj|j	¡j
}|d u s4|d u r:d}t|ƒ‚td||ƒƒtd||ƒƒf| _| jW  d   ƒ S 1 sVw   Y  d S )Nr   z+CPython reference functions have no addressz$Callable[[sqlite3.Connection], None])r0   rR   rS   ÚctypesÚ
PYFUNCTYPEÚ	py_objectr   Ú	pythonapiZ	Py_IncRefÚc_void_pÚvalueZ	Py_DecRefÚRuntimeError)rU   rX   Zfunction_typeZincrement_addressZdecrement_addressÚmsgrI   rI   rJ   Ú	functionsZ   s    
þ$òz_ConnectionEscrow.functionsc                 C  s   t  ¡ | _d S rO   )rP   rQ   rR   rT   rI   rI   rJ   Ú_reset_after_fork_in_childo   s   z,_ConnectionEscrow._reset_after_fork_in_childN©rM   rN   )rM   rW   )rE   rF   rG   rV   r`   ra   rI   rI   rI   rJ   rL   U   s    

rL   Ú_CONNECTION_ESCROWc                   @  sL   e Zd Zddd„Zddd„Zddd„Zddd„Zddd„Zeddd„ƒZ	dS )Ú_ForkedDatabaseRegistryrM   rN   c                 C  s*   t  ¡ | _tƒ | _tƒ | _d| _d| _d S ©NF)rP   rQ   rR   ÚsetÚ_pathsÚ_identitiesÚ_sqlite_usedÚ_all_paths_poisonedrT   rI   rI   rJ   rV   w   s
   

z _ForkedDatabaseRegistry.__init__Úpathúpathlib.Pathc                 C  sz   |   |¡}| j� | j}|p|| jv p|d uo|| jv }W d   ƒ n1 s&w   Y  |r;|r1dnd|›d�}t|ƒ‚d S )NzOReadWriteLock is unavailable in a PyPy fork child; exec or exit before using itzSQLite database zD was active across fork(); exec or exit before using it in the child)ÚidentityrR   rj   rg   rh   r^   )rU   rk   rm   Zall_paths_poisonedZpoisonedr_   rI   rI   rJ   Úraise_if_poisoned~   s   
ÿþÿ
ýúz)_ForkedDatabaseRegistry.raise_if_poisonedrm   ú_DatabaseIdentity | Nonec                 C  s(   | j  |¡ |d ur| j |¡ d S d S rO   )rg   Úaddrh   )rU   rk   rm   rI   rI   rJ   Úpoison_after_fork�   s   ÿz)_ForkedDatabaseRegistry.poison_after_forkc                 C  s:   t r| j� d| _W d   ƒ d S 1 sw   Y  d S d S ©NT)r-   rR   ri   rT   rI   rI   rJ   Únote_sqlite_use’   s
   "ÿÿz'_ForkedDatabaseRegistry.note_sqlite_usec                 C  s&   t  ¡ | _| jpto| j| _d| _d S re   )rP   rQ   rR   rj   r-   ri   rT   rI   rI   rJ   ra   —   s   

z2_ForkedDatabaseRegistry._reset_after_fork_in_childc                 C  s.   z|   ¡ }W n
 ty   Y d S w |j|jfS rO   )ÚstatÚOSErrorÚst_devÚst_ino)rk   Ústat_resultrI   rI   rJ   rm   œ   s   ÿz _ForkedDatabaseRegistry.identityNrb   )rk   rl   rM   rN   )rk   rl   rm   ro   rM   rN   )rk   rl   rM   ro   )
rE   rF   rG   rV   rn   rq   rs   ra   Ústaticmethodrm   rI   rI   rI   rJ   rd   v   s    




rd   Ú_FORKED_DATABASESz
.filelock-Ú_LINK_PREFIXzFinal[set[str]]Ú_SWEPT_DIRECTORIESc                   @  s\   e Zd Zddd„Zdd
d„Zd dd„Zd!dd„Zd"dd„Zddd„Zd"dd„Z	ddd„Z
dS )#Ú_ProbeDescriptorsrM   rN   c                 C  s$   t  ¡ | _i | _tƒ | _tƒ | _d S rO   )rP   ÚLockrR   Ú_inodesr   Ú	_releasesr   Ú_leasesrT   rI   rI   rJ   rV   ¯   s   
z_ProbeDescriptors.__init__ÚdatabaseÚstrÚclaimedúlist[_Probe]ú_Probe | Nonec                 C  sÀ   zt  |¡}W n
 ty   Y d S w |j|jf}| j�; t |j¡r-| j	 
|¡ }r-|js6	 W d   ƒ d S | t||j ¡ t| jƒƒ }¡ |j |j¡ W d   ƒ |S 1 sYw   Y  |S rO   )ÚosÚlstatru   rv   rw   rR   rt   ÚS_ISREGÚst_moder   ÚgetÚidleÚappendÚ_ProbeÚpopÚnextr�   Úleasesrp   Úlease)rU   r‚   r„   rx   rm   ÚprobesZadoptedrI   rI   rJ   Úadoptµ   s    ÿ"þ"
üûz_ProbeDescriptors.adoptÚfdrC   rŽ   c                 C  s–   t  |¡}|j|jf}t||ƒ}| j�. | j |tƒ ¡ }j	 
||f¡ | 
t||t| jƒƒ }¡ |j |j¡ W d   ƒ |S 1 sDw   Y  |S rO   )r‡   Úfstatrv   rw   r   rR   r   Ú
setdefaultÚ_InodeProbesÚdescriptorsr�   rŽ   r�   r�   r‘   rp   r’   )rU   r•   r„   rx   rm   Útokenr“   ZretainedrI   rI   rJ   ÚretainÄ   s   

 
ýüz_ProbeDescriptors.retainÚprobeÚboolc                 C  s@   | j � t| j|j jƒdkW  d   ƒ S 1 sw   Y  d S ©Nr   )rR   Úlenr   rm   r‘   ©rU   rœ   rI   rI   rJ   ÚsharedÎ   s   $ÿz_ProbeDescriptors.sharedc                 C  s   | j  |¡ |  ¡  d S rO   )r€   r�   Údrainr    rI   rI   rJ   ÚreleaseÒ   s   z_ProbeDescriptors.releasec                 C  sz   | j r7| jjdd�r9z| j r|  | j d ¡ | j  ¡  | j sW | j ¡  n| j ¡  w | j r;| jjdd�s
d S d S d S d S )NF©Úblockingr   )r€   rR   ÚacquireÚ_release_lockedÚpopleftr£   rT   rI   rI   rJ   r¢   ×   s   
þ€$ùz_ProbeDescriptors.drainc                 C  sÐ   | j  |j¡ }d u rd S |j|jv r$|j |j¡ |jr$|j |j¡ |jr)d S |j 	¡  |j
ra|j
d \}}|d ur@t|ƒ |j
 ¡  ttƒ� t |¡ W d   ƒ n1 sYw   Y  |j
s1| j |j= d S )Néÿÿÿÿ)r   r‹   rm   r’   r‘   ÚremoverŒ   r�   r•   Úclearr™   r   r�   r   ru   r‡   Úclose)rU   rœ   r“   r•   rš   rI   rI   rJ   r§   á   s&   


ÿù	z!_ProbeDescriptors._release_lockedc                 C  s   t  ¡ | _i | _tƒ | _d S rO   )rP   r~   rR   r   r   r€   rT   rI   rI   rJ   ra   ø   s   
z,_ProbeDescriptors._reset_after_fork_in_childNrb   )r‚   rƒ   r„   r…   rM   r†   )r•   rC   r„   r…   rM   rŽ   )rœ   rŽ   rM   r�   )rœ   rŽ   rM   rN   )rE   rF   rG   rV   r”   r›   r¡   r£   r¢   r§   ra   rI   rI   rI   rJ   r}   ®   s    








r}   c                   @  s&   e Zd ZU ded< ded< ded< dS )rŽ   r2   rm   rC   r•   r’   N)rE   rF   rG   rH   rI   rI   rI   rJ   rŽ   ÿ   s   
 rŽ   T)Úslotsc                   @  sD   e Zd ZU eed�Zded< eed�Zded< eed�Z	ded< dS )	r˜   )Údefault_factoryzset[int]r‘   zlist[tuple[int, int | None]]r™   z	list[int]rŒ   N)
rE   rF   rG   r   rf   r‘   rH   Úlistr™   rŒ   rI   rI   rI   rJ   r˜     s   
 r˜   Ú_PROBE_DESCRIPTORSc                      sx   e Zd ZU ded< ded< ded< dZded	< dZd
ed< d!‡ fdd„Zd"dd„Zd#dd„Zd$dd„Z	d"dd „Z
‡  ZS )%Ú_ForkSafeConnectionrC   Ú_creator_pidz+Callable[[sqlite3.Connection], None] | NoneÚ_decrement_escrowúpathlib.Path | NoneÚ_database_directoryNro   Údatabase_identityr†   Ú_probeÚ_argsr1   Ú_kwargsrM   r)   c                   s$   t ƒ  | ¡}tƒ |_d |_d |_|S rO   )ÚsuperÚ__new__r,   r²   r³   rµ   )Úclsr¸   r¹   Ú
connection©Ú	__class__rI   rJ   r»     s
   z_ForkSafeConnection.__new__rN   c                 C  s@  t ƒ �“ tƒ | jkr	 W d   ƒ d S tƒ �h tj | ¡ z7| j }d urAd | _tt	ƒ� t
 |¡ W d   ƒ n1 s<w   Y  W | j }d urTd  | _| _t |¡ n| j }d urhd  | _| _t |¡ w w | j }d urwd | _|| ƒ W d   ƒ n1 s�w   Y  W d   ƒ d S W d   ƒ d S 1 s™w   Y  d S rO   )Ú_sqlite_transitionr,   r²   r   Úsqlite3Ú
Connectionr¬   rµ   r   ÚFileNotFoundErrorÚshutilÚrmtreer·   r¶   r°   r£   r³   )rU   Ú	directoryrœ   Ú	decrementrI   rI   rJ   r¬   "  s:   þ
ÿ€
€þþ€òý"ýz_ForkSafeConnection.closerÆ   rœ   rŽ   c                 C  s   || _ || _|j| _dS )z^Keep the private link and this connection's probe descriptor until SQLite no longer uses them.N)rµ   r·   rm   r¶   )rU   rÆ   rœ   rI   rI   rJ   Úretain_until_close6  s   z&_ForkSafeConnection.retain_until_closer`   rW   c                 C  s&   |d ur|\}}|| ƒ || _ d S d S rO   )r³   )rU   r`   Ú	incrementrÇ   rI   rI   rJ   Úacquire_escrow<  s
   
ýz"_ForkSafeConnection.acquire_escrowc                 C  s<   t tjttƒ� |  ¡  W d   ƒ d S 1 sw   Y  d S rO   )r   rÁ   ÚErrorr^   ru   r¬   rT   rI   rI   rJ   Ú__del__F  s   
"ÿz_ForkSafeConnection.__del__)r¸   r1   r¹   r1   rM   r)   rb   )rÆ   r´   rœ   rŽ   rM   rN   )r`   rW   rM   rN   )rE   rF   rG   rH   r¶   r·   r»   r¬   rÈ   rÊ   rÌ   Ú__classcell__rI   rI   r¾   rJ   r±     s   
 



r±   c                      sZ   e Zd ZU dZded< ded< ded< ded	< 	
ddddœd‡ fdd„Zddd„Z‡  ZS )Ú_ReadWriteLockMetaa
  
    Resolve singleton instances for ``is_singleton=True`` construction.

    This logic lives here rather than in ReadWriteLock.get_lock so ``ReadWriteLock(path)`` returns cached instances
    without a 2-arg ``super()`` call that type checkers cannot verify.

    ú0WeakValueDictionary[pathlib.Path, ReadWriteLock]Ú
_instanceszthreading.RLockÚ_instances_lockrC   Ú_instances_pidzset[pathlib.Path]Ú_instances_under_constructionr©   T©r¥   Úis_singletonÚ	lock_fileústr | os.PathLike[str]ÚtimeoutÚfloatr¥   r�   rÕ   rM   ÚReadWriteLockc          
   
     sŒ  t ƒ  td|ƒ}| jtƒ kr|  ¡  tƒ }|s.tƒ j||||d�}tƒ |kr,d}t|ƒ‚|S t 	t
|ƒ¡}| j�„ || jvrˆ|| jv rLd|›�}t|ƒ‚| j}	|	 |¡ ztƒ j||||d�}W tƒ |krj|	 |¡ ntƒ |krv|	 |¡ w w tƒ |kr‚d}t|ƒ‚|| j|< n| j| }t|jdd�t|dd�ksŸ|j|kr³d|j› d|j› d	|› d|› �}t|ƒ‚|W  d   ƒ S 1 s¿w   Y  d S )
NrØ   rÔ   z5ReadWriteLock construction cannot continue after forkz2Singleton lock construction is already active for F)Úany_negativez$Singleton lock created with timeout=z, blocking=z, cannot be changed to timeout=)r   r   rÒ   r,   Ú_reset_class_after_forkrº   Ú__call__r^   ÚpathlibÚPathr   rÑ   rÐ   rÓ   rp   Údiscardr   rØ   r¥   Ú
ValueError)
r¼   rÖ   rØ   r¥   rÕ   Úconstruction_pidÚinstancer_   Ú
normalizedÚconstruction_registryr¾   rI   rJ   rÝ   Y  sZ   







€
ÿÿ


ÿ
ÿÿÿ$ãz_ReadWriteLockMeta.__call__rN   c                 C  s&   t ƒ | _t ¡ | _tƒ | _tƒ | _d S rO   )	r   rÐ   rP   rQ   rÑ   r,   rÒ   rf   rÓ   ©r¼   rI   rI   rJ   rÜ   Ž  s   
z*_ReadWriteLockMeta._reset_class_after_fork©r©   )
rÖ   r×   rØ   rÙ   r¥   r�   rÕ   r�   rM   rÚ   rb   )rE   rF   rG   Ú__doc__rH   rÝ   rÜ   rÍ   rI   rI   r¾   rJ   rÎ   K  s   
 ýú5rÎ   c                      s¸  e Zd ZU dZeƒ Zded< e ¡ Z	e
ƒ Zeƒ Zded< dd‡ fdd	„Ze	
deddœdfdd„ƒZ	
dedddœdgdd„Zdhddœdidd„Zdhddœdidd „Zedhddœdjd"d#„ƒZedhddœdjd$d%„ƒZd&d'œdkd)d*„Zddd+d,„Zdld/d0„Zdd1œdmd4d5„Zdld6d7„Zdld8d9„Zddd:d;„Zddd<d=„Zddd>d?„Ze dnd@dA„ƒZ!dddBdC„Z"dodFdG„Z#dpdJdK„Z$dqdLdM„Z%drdPdQ„Z&dsdTdU„Z'dtdWdX„Z(dddYdZ„Z)dud[d\„Z*dvd]d^„Z+dwd`da„Z,dxdbdc„Z-‡  Z.S )yrÚ   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, and each thread sharing a read lock can release only the levels it acquired.

    An instance coordinates processes, not threads: a thread asking for the opposite mode of another thread's hold
    raises :class:`RuntimeError` instead of waiting. Threads that must wait for each other each need their own
    instance (``is_singleton=False``).

    By default, ``is_singleton=True``: calling ``ReadWriteLock(path)`` with the same resolved path returns the same
    instance. The path is handed to :func:`sqlite3.connect` as given, so a ``.db`` extension is a convention rather
    than a requirement; the filesystem must be one the active SQLite VFS supports. Give the lock a file of its own: a
    WAL-mode database raises :class:`ValueError`.

    :param lock_file: path to the SQLite database file used as the lock
    :param timeout: maximum wait time in seconds; ``-1`` waits up to SQLite's busy-timeout cap of about 23 days
    :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Ð   zClassVar[set[pathlib.Path]]rÓ   rM   rN   c                   s8   t ƒ  ¡  tƒ | _t ¡ | _tƒ | _t	ƒ | _
t| ƒ d S rO   )rº   Ú__init_subclass__r   rÐ   rP   rQ   rÑ   r,   rÒ   rf   rÓ   r   ræ   r¾   rI   rJ   ré   µ  s   

zReadWriteLock.__init_subclass__r©   Tr¤   rÖ   r×   rØ   rÙ   r¥   r�   c                C  s   | |||d�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`` waits up to SQLite's busy-timeout cap of about 23 days
        :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

        r¤   rI   )r¼   rÖ   rØ   r¥   rI   rI   rJ   Úget_lock½  s   zReadWriteLock.get_lockrÔ   rÕ   c             	   C  s  t  |¡| _t t|ƒ¡| _t | j¡ || _	|| _
t ¡ | _t ¡ | _d| _d | _d | _i | _tƒ | _d | _d| _d | _d| _tƒ | _d| _t| ƒ tƒ �. tƒ � | jdd�}|  ¡  W d   ƒ n1 sgw   Y  W d   ƒ d S W d   ƒ d S 1 sw   Y  d S )Nr   TFg      @©Úsqlite_timeout)!r‡   ÚfspathrÖ   rÞ   rß   r   Ú_canonical_pathrz   rn   rØ   r¥   rP   r~   Ú_transaction_lockÚ_internal_lockÚ_lock_levelÚ_current_modeÚ_write_thread_idÚ_read_depthsrf   Ú_acquisition_thread_idsÚ_conÚ _connection_transaction_releasedÚ_connection_identityÚ_closedr,   r²   Ú_fork_invalidatedr   r   rÀ   Ú_open_connectionr¬   )rU   rÖ   rØ   r¥   rÕ   Zvalidation_connectionrI   rI   rJ   rV   Ï  s.   


PþzReadWriteLock.__init__Núfloat | Noneúbool | Noner   c                C  ó0   | j d|du r
| jn||du r| jd�S |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: seconds to wait; ``None`` uses the instance setting; ``-1`` waits up to SQLite's
            busy-timeout cap of about 23 days
        :param blocking: if ``False``, raise :class:`~filelock.Timeout` on contention;
            ``None`` uses the instance setting

        :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
        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``

        ÚreadNr¤   ©Ú_acquirerØ   r¥   ©rU   rØ   r¥   rI   rI   rJ   Úacquire_readî  s   ýýzReadWriteLock.acquire_readc                C  rþ   )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: seconds to wait; ``None`` uses the instance setting; ``-1`` waits up to SQLite's
            busy-timeout cap of about 23 days
        :param blocking: if ``False``, raise :class:`~filelock.Timeout` on contention;
            ``None`` uses the instance setting

        :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
        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``

        ÚwriteNr¤   r   r  rI   rI   rJ   Úacquire_write  s   ýýzReadWriteLock.acquire_writeúGenerator[None]c                c  ó0   � | j ||d� z
dV  W |  ¡  dS |  ¡  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

        r¤   N)r  r£   r  rI   rI   rJ   Ú	read_lock$  ó
   €zReadWriteLock.read_lockc                c  r  )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

        r¤   N)r  r£   r  rI   rI   rJ   Ú
write_lock5  r	  zReadWriteLock.write_lockF)Úforcer  c                C  sb   t ƒ �$ tƒ  | jr	 W d  ƒ dS |  d¡ | j|dd� W d  ƒ dS 1 s*w   Y  dS )aÎ  
        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``, or if the calling thread holds
            no level of the current lock and *force* is ``False``

        Nr£   F©r  r¬   ©r   r   Ú
_inheritedÚ_raise_if_acquiringÚ_release)rU   r  rI   rI   rJ   r£   F  s   ý
"ûzReadWriteLock.releasec                 C  sb   t ƒ �$ tƒ  | jr	 W d  ƒ dS |  d¡ | jddd� W d  ƒ dS 1 s*w   Y  dS )a  
        Release the lock (if held) and close the underlying SQLite connection.

        After calling this method, the lock instance is no longer usable. Unlike :meth:`release`, it ends every
        thread's hold on this instance, whichever thread calls it.

        Nr¬   Tr  r  rT   rI   rI   rJ   r¬   Y  s   ý
"ûzReadWriteLock.closeÚ	thread_idrC   c                 C  sL   t ƒ � tƒ  |  d¡ | jdd|d� W d   ƒ d S 1 sw   Y  d S )Nr£   F)r  r¬   r  )r   r   r  r  )rU   r  rI   rI   rJ   Ú_release_level_ofh  s
   
"ýzReadWriteLock._release_level_of)r  r¬   ú
int | Nonec             
   C  s^  |d u rt  ¡ n|}| j�˜ | j�| |s|  |¡ | jdkrK|r9| jd u r9|r*d| _	 W d   ƒ W d   ƒ d S |sKd| j› dt	| ƒ› d�}t
|ƒ‚|sf| jdkrf|  |¡ 	 W d   ƒ W d   ƒ d S z|  ¡  W n tjy|   | jr{|  ¡  ‚ w |  ¡  |r†d| _W d   ƒ n1 s�w   Y  W d   ƒ d S W d   ƒ d S 1 s¨w   Y  d S )Nr   TzCannot release a lock on ú (lock id: z) that is not heldr   )rP   Ú	get_identrï   rð   Ú_raise_if_not_holderrñ   rö   rù   rÖ   Úidr^   Ú_leave_one_levelÚ_finish_connectionrÁ   rË   r÷   Ú_clear_lock_state)rU   r  r¬   r  r_   rI   rI   rJ   r  n  s:   

ù
óý€PêzReadWriteLock._releasec                 C  s‚   | j dkr || jkr d| j› dt| ƒ› d|› d| j› �}t|ƒ‚| j dkr=|| jvr?d| j› dt| ƒ› d|› d�}t|ƒ‚d S d S )	Nr  zCannot release write lock on r  ú) from thread ú while it is held by thread rÿ   zCannot release read lock on z, which does not hold it)rò   ró   rÖ   r  r^   rô   )rU   r  r_   rI   rI   rJ   r  ˆ  s   ÿÿÿÿÿûz"ReadWriteLock._raise_if_not_holderc                 C  sB   |  j d8  _ | jdkr| j |¡d  }r|| j|< d S d S d S )Nr   rÿ   )rñ   rò   rô   r�   )rU   r  rD   rI   rI   rJ   r  ™  s   ÿzReadWriteLock._leave_one_levelc                 C  s   d| _ d | _d | _i | _d S )Nr   )rñ   rò   ró   rô   rT   rI   rI   rJ   r  ž  s   
zReadWriteLock._clear_lock_statec                 C  sh   t ƒ t| dd ƒkr0t| dd ƒ }d ur2ttjtƒ� | ¡  W d   ƒ d S 1 s)w   Y  d S d S d S )Nr²   rö   )r,   Úgetattrr   rÁ   rË   r^   r¬   )rU   r½   rI   rI   rJ   rÌ   ¤  s
   &
"ÿÿzReadWriteLock.__del__c                 C  sZ   | j d urt | j| j¡ d | _ d| _d | _t ¡ | _t ¡ | _	|  
¡  tƒ | _d| _d S rr   )rö   rz   rq   rî   rø   r÷   rP   r~   rï   rð   r  rf   rõ   rú   rT   rI   rI   rJ   ra   ©  s   



z(ReadWriteLock._reset_after_fork_in_childc                 C  s   | j ptƒ | jkS rO   )rú   r,   r²   rT   rI   rI   rJ   r  µ  s   zReadWriteLock._inheritedc                 C  s:   t ƒ  | jrd| j› d�}t|ƒ‚| jrd}t |¡‚d S )NúReadWriteLock on ú4 was invalidated by fork(); construct a new instancez$Cannot operate on a closed database.)r   r  rÖ   r^   rù   rÁ   ÚProgrammingError)rU   r_   rI   rI   rJ   Ú_raise_if_unusable¹  s   
þz ReadWriteLock._raise_if_unusableÚmodeúLiteral['read', 'write']c                C  s„  t ƒ �µ |  ¡  t||d�}tƒ }t ¡ }| j�6 | jdkr1|  |¡W  d   ƒ W  d   ƒ S || j	v rAd| j
› d�}t|ƒ‚| j	 |¡ W d   ƒ n1 sQw   Y  zGt ¡ }| j||d� z5|  ¡  | j|||||d�W | j ¡  W | j� | j	 |¡ W d   ƒ n1 s‹w   Y  W  d   ƒ S | j ¡  w | j� | j	 |¡ W d   ƒ w 1 s²w   Y  w 1 s»w   Y  d S )Nr¤   r   z Cannot acquire ReadWriteLock on ú+ while acquisition is active in this thread©r¥   rØ   ©r¥   Úoperation_pidÚ
start_time)r   r!  r   r,   rP   r  rð   rñ   Ú_validate_reentrantrõ   rÖ   r^   rp   ÚtimeÚperf_counterÚ_acquire_transaction_lockÚ_do_acquire_innerrï   r£   rà   )rU   r"  rØ   r¥   r'  r  r_   r(  rI   rI   rJ   r  Â  sJ   
þû
úûÿåÿåzReadWriteLock._acquirer'  r(  c          	      C  sˆ  | j � | jdkr|  |¡W  d   ƒ S W d   ƒ n1 sw   Y  | jd ur-|  ¡  z| j||||d� | j|||||fd� |  |¡ W nG ty� } z;t	|t
jƒrbdt|ƒv rbt| jƒ}n|}z|  ¡  W n t
jy‚ } zt||ƒ W Y d }~nd }~ww ||urŠ|d ‚‚ d }~ww | j �$ |  |¡ || _d| _|dkr©t ¡ | _nt ¡ di| _W d   ƒ n1 sºw   Y  t| d�S )Nr   r&  )r¥   Ú	operationzdatabase is lockedr   r  ©Úlock)rð   rñ   r)  rö   r  Ú_open_for_acquisitionÚ_configure_and_beginÚ_raise_if_process_changedÚBaseExceptionÚ
isinstancerÁ   ÚOperationalErrorrƒ   r   rÖ   rË   r   rò   rP   r  ró   rô   r   )	rU   r"  rØ   r¥   r'  r(  ÚerrorÚacquisition_errorÚcleanup_errorrI   rI   rJ   r-  á  s^   

þÿ
üü€ÿ€ô
€ù
zReadWriteLock._do_acquire_innerc                C  sz   t ƒ �0 t||t ¡ | d�d }| j|d�}|dt | j¡| _| _	| _
|  |¡ W d   ƒ d S 1 s6w   Y  d S )N©r¥   Úalready_waitedéè  rë   F)rÀ   Útimeout_for_sqliter*  r+  rû   rz   rm   rî   rö   r÷   rø   r3  )rU   rØ   r¥   r'  r(  rì   r½   rI   rI   rJ   r1    s    
ýûÿ
ý"ñz#ReadWriteLock._open_for_acquisitionr.  útuple[int, float]c                C  sò   t ƒ �l |\}}td| jƒ}t ¡ | }t|||d�}	|  |¡ | d|	› d�¡ ¡  t ¡ | }t|||d�}
|  |¡ |
|	krGd|
› d�nd}||dkrPdnd	7 }|d
kr[|d7 }| |¡ ¡  |  	|¡ W d   ƒ d S 1 srw   Y  d S )Nr±   r:  zPRAGMA busy_timeout=z; PRAGMA journal_mode=MEMORY;z; Ú r  zBEGIN EXCLUSIVE TRANSACTION;zBEGIN TRANSACTION;rÿ   z( SELECT name FROM sqlite_master LIMIT 1;)
rÀ   r   rö   r*  r+  r=  r3  Úexecutescriptr¬   Ú_raise_if_database_replaced)rU   r"  rØ   r¥   r.  r'  r(  r½   ZwaitedÚ
timeout_msZ
recomputedZ
statementsrI   rI   rJ   r2  '  s"   

"èz"ReadWriteLock._configure_and_beginr½   r±   c                 C  sn   |j  }d u r	d S z	| jjdd�}W n ty   d }Y nw |d u s*|j|jf|kr5d| j›d�}t|ƒ‚d S )NF©Úfollow_symlinksúlock database z< was unlinked or replaced while acquiring; leave it in place)r¶   rî   rt   rÃ   rv   rw   rÖ   ru   )rU   r½   rm   Úcurrentr_   rI   rI   rJ   rA  I  s   ÿþz)ReadWriteLock._raise_if_database_replacedrì   c                C  s¦   t ƒ �F tƒ }t ¡ }tƒ |krd}t|ƒ‚tt | j¡t	|d�}|d ur*| 
|¡ tƒ |kr@t | jt | j¡¡ d}t|ƒ‚|W  d   ƒ S 1 sLw   Y  d S )Nz9SQLite connection construction cannot continue after fork©ÚfactoryrØ   )rÀ   r,   rc   r`   r^   Ú_connectr‡   rí   rî   r±   rÊ   rz   rq   rm   )rU   rì   Úcreator_pidr`   r_   r½   rI   rI   rJ   rû   V  s,   

ý


þ$ìzReadWriteLock._open_connectionc                 C  s
  t ƒ �x | j }d u r	 W d   ƒ d S d }| jsF|jrCz| ¡  W n tjy> } z|jr/‚ d| _|}W Y d }~nd }~ww d| _nd| _z| ¡  W n tjyc } z
|d ur^t||ƒ ‚ d }~ww d | _d| _d | _	|d urs|‚W d   ƒ d S 1 s~w   Y  d S rr   )
rÀ   rö   r÷   Úin_transactionÚrollbackrÁ   rË   r¬   r   rø   )rU   r½   Úrollback_errorr7  Úclose_errorrI   rI   rJ   r  m  sB   þ€ü
€ýÿ"æz ReadWriteLock._finish_connectionc                 C  s  t  ¡ }| j|krH|dkrdnd}|| jks|| jv r-|dkr!dnd}d|› d|› d�}nd|› d	�}d
|› d| j› dt| ƒ› d|› �}t|ƒ‚|dkrg|| jkrgd| j› dt| ƒ› d|› d| j› �}t|ƒ‚|dkrw| j |d¡d | j|< |  j	d7  _	t
| d�S )Nrÿ   r  Ú	downgradeÚupgradezalready holding a z lock (z not allowed)zanother thread holds a z‚ lock on this instance, which coordinates processes rather than threads; give each thread its own instance with is_singleton=FalsezCannot acquire z	 lock on r  z): zCannot acquire write lock on r  r  r   r   r/  )rP   r  rò   ró   rô   rÖ   r  r^   r‹   rñ   r   )rU   r"  ÚcurZoppositeÚ	directionÚreasonr_   rI   rI   rJ   r)  ‹  s,   

ÿ"ÿÿÿ
z!ReadWriteLock._validate_reentrantc                C  sX   |s
| j jdd�}n|dkr| j jdd�}n| j jdt|tjƒd�}|s*t| jƒd ‚d S )NFr¤   r©   Tr%  )rï   r¦   ÚminrP   ÚTIMEOUT_MAXr   rÖ   )rU   r¥   rØ   ZacquiredrI   rI   rJ   r,  ¤  s   ÿz'ReadWriteLock._acquire_transaction_lockú&Literal['acquire', 'close', 'release']c                 C  sX   | j � t ¡ | jv }W d   ƒ n1 sw   Y  |r*d|› d| j› d�}t|ƒ‚d S )NzCannot z ReadWriteLock on r$  )rð   rP   r  rõ   rÖ   r^   )rU   r.  Zactive_in_current_threadr_   rI   rI   rJ   r  ¯  s   ÿþz!ReadWriteLock._raise_if_acquiringc                 C  s*   t ƒ |ks| jrd| j› d�}t|ƒ‚d S )Nr  r  )r,   r  rÖ   r^   )rU   r'  r_   rI   rI   rJ   r3  ¶  s   þz'ReadWriteLock._raise_if_process_changedrb   rç   )rÖ   r×   rØ   rÙ   r¥   r�   rM   rÚ   )
rÖ   r×   rØ   rÙ   r¥   r�   rÕ   r�   rM   rN   rO   )rØ   rü   r¥   rý   rM   r   )rØ   rü   r¥   rý   rM   r  )r  r�   rM   rN   )r  rC   rM   rN   )r  r�   r¬   r�   r  r  rM   rN   )rM   r�   )r"  r#  rØ   rÙ   r¥   r�   rM   r   )r"  r#  rØ   rÙ   r¥   r�   r'  rC   r(  rÙ   rM   r   )
rØ   rÙ   r¥   r�   r'  rC   r(  rÙ   rM   rN   )
r"  r#  rØ   rÙ   r¥   r�   r.  r>  rM   rN   )r½   r±   rM   rN   )rì   rÙ   rM   r±   )r"  r#  rM   r   )r¥   r�   rØ   rÙ   rM   rN   )r.  rV  rM   rN   )r'  rC   rM   rN   )/rE   rF   rG   rè   r   rÐ   rH   rP   rQ   rÑ   r,   rÒ   rf   rÓ   ré   Úclassmethodrê   rV   r  r  r   r  r
  r£   r¬   r  r  r  r  r  rÌ   ra   Úpropertyr  r!  r  r-  r1  r2  rA  rû   r  r)  r,  r  r3  rÍ   rI   rI   r¾   rJ   rÚ   •  s\   
 ÿÿýú








	

4

"




rÚ   )Ú	metaclassr‚   rƒ   rH  útype[_ForkSafeConnection]rØ   rÙ   rM   c             	   C  s`   t  ¡  tjdkr)t| ƒ}zt|| ƒ tj| d|d|d�W t 	|¡ S t 	|¡ w t
| ||d�S )Nr"   Fr   ©Zcheck_same_threadrH  Zcached_statementsrØ   rG  )rz   rs   ÚsysÚplatformÚ_open_lock_databaseÚ_raise_if_walrÁ   Úconnectr‡   r¬   Ú_connect_through_descriptor)r‚   rH  rØ   r•   rI   rI   rJ   rI  ¼  s   


ÿrI  c                C  s   g }d }z¡t  | |¡ }d u rt  t| ƒ|¡}|\}}}t  ¡  t|| ƒ t t› d|› �¡}	t	 
|	t	j¡}
|
rIt  |¡ra|	 ¡  }j|jf|krazt| |ƒ}W n ty\   |
sZ‚ Y nw |d }	tjt	 |	¡d|d|d�}| ||¡ | ¡  |W |D ]}t  |¡ q||r¤|d ur¥ttƒ� t |¡ W d   ƒ S 1 sžw   Y  S S S |D ]}t  |¡ q¨|rÏ|d urÏttƒ� t |¡ W d   ƒ w 1 sÊw   Y  w )Nú/úlock.dbFr   r[  )r°   r”   r›   r^  r¢   r_  rÞ   rß   r:   r‡   ÚaccessÚF_OKr¡   rt   rv   rw   Ú_link_besideru   rÁ   r`  rí   rÈ   r«   r£   r   rÃ   rÄ   rÅ   )r‚   rH  rØ   r„   rÆ   rœ   rm   r•   Ú_ÚtargetZ	reachableÚnamedr½   ZunownedrI   rI   rJ   ra  Í  sR   

ÿÿþÿ
ÿþþ
ÿra  rm   rl   c                 C  sž   t  | ¡j}t|ƒ t  tjtƒ |d�¡}ztj| |d  }dd� |j	dd�}W n t
y6   t |¡ ‚ w |j|jf|krMt |¡ d| ›�}t|ƒ‚|S )N)ÚprefixÚdirrc  FrC  z%lock database changed while opening: )rÞ   rß   ÚparentÚ_sweep_links_of_the_deadÚtempfileÚmkdtempÚ_link_prefixr‡   Úlinkrt   r4  rÄ   rÅ   rv   rw   ru   )r‚   rm   rl  rÆ   rq  Zlinkedr_   rI   rI   rJ   rf  ú  s   
þ

rf  rl  rN   c              	   C  s¼   t  | ¡ }tv rd S t |¡ zt  | ¡�}dd„ |D ƒ}W d   ƒ n1 s(w   Y  W n
 ty8   Y d S w |D ] }t|jƒr[ttƒ� t	 
|¡ W d   ƒ n1 sVw   Y  q;d S )Nc                 S  s0   g | ]}|j  t¡r|jd d�rt |j¡‘qS )FrC  )ÚnameÚ
startswithr{   Úis_dirrÞ   rß   rk   )Ú.0ÚentryrI   rI   rJ   Ú
<listcomp>  s    
ý
ý
ÿz,_sweep_links_of_the_dead.<locals>.<listcomp>)r‡   rí   r|   rp   Úscandirru   Ú_owner_is_gonerr  r   rÄ   rÅ   )rl  ÚkeyÚentriesÚdirectoriesrÆ   rI   rI   rJ   rm    s(   
þÿ€ÿ

ÿ€ýrm  rr  r�   c                 C  st   |   t¡ d¡  r6 dkr6\ }}}| ¡ r7| ¡ s|s7tƒ }|t|ƒko5tt|ƒ||r3t|ƒnd ƒS  	 dS )Nú-é   F)Úremoveprefixr{   ÚsplitÚisdigitr   Ú_host_digestr    rC   )rr  ÚpidÚstartÚdigestÚhostrI   rI   rJ   ry  "  s   0(þry  c                  C  s<   t t ¡  } ƒ}t› | › d|d u rdn|› dttƒ ƒ› d�S )Nr}  r?  )r!   r‡   Úgetpidr{   r‚  r   )rƒ  r„  rI   rI   rJ   rp  ,  s   ,rp  r†  c                 C  s   t  |  ¡ ¡ ¡ d d… S )Né   )ÚhashlibÚsha256ÚencodeÚ	hexdigest)r†  rI   rI   rJ   r‚  2  s   r‚  rC   c                 C  st   t jdkrt| dƒ }d u rd| ›d�}t|ƒ‚|S t | td¡}t t 	|¡j
¡s8t |¡ d| ›�}t|ƒ‚|S )Nr"   i€  rE  z) is being deleted or held without sharingz&refusing a non-regular lock database: )r\  r]  r#   ÚPermissionErrorr‡   Úopenr8   rt   r‰   r–   rŠ   r¬   ru   )r‚   r•   r_   rI   rI   rJ   r^  7  s   


r^  r•   c                 C  sV   t tdƒrt | td¡nt | t¡}| t¡r't|t v r)d|›d�}t	|ƒ‚d S d S )NÚpreadr   z#refusing a WAL-mode lock database: z&; give ReadWriteLock a file of its own)
Úhasattrr‡   r�  r?   rÿ   rs  r;   rA   r>   rá   )r•   r‚   Úheaderr_   rI   rI   rJ   r_  F  s
   $þr_  r  c                	   c  s<   � t  jd7  _zd V  W t  jd8  _d S t  jd8  _w rž   )rK   rD   rI   rI   rI   rJ   rÀ   P  s
   €"rÀ   c                   C  s   t jr
t t¡ d S d S rO   )rK   rD   r‡   Ú_exitr5   rI   rI   rI   rJ   Ú_abort_forked_sqlite_transitionY  s   ÿr“  Úeventr¸   r&   c                 C  s   | dkr
t  ¡  d S d S )Nzsqlite3.connect)rz   rs   )r”  r¸   rI   rI   rJ   Ú_track_sqlite_use^  s   ÿr•  r¥   r;  c                C  st   |du rdS | dkrt S | dk rd}t|ƒ‚t| dkr"t| | dƒn| d ƒ}|t ks/|dk r8t d| t ¡ t S |S )NFr   r©   z+timeout must be a non-negative number or -1r<  z7timeout %s is too large for SQLite, using %s ms instead)r3   rá   rC   Úmaxr+   Úwarning)rØ   r¥   r;  r_   rB  rI   rI   rJ   r=  c  s   "r=  )Úafter_in_child)r‚   rƒ   rH  rZ  rØ   rÙ   rM   r±   )r‚   rƒ   rm   r2   rM   rl   )rl  rl   rM   rN   )rr  rƒ   rM   r�   )rM   rƒ   )r†  rƒ   rM   rƒ   )r‚   rƒ   rM   rC   )r•   rC   r‚   rƒ   rM   rN   )rM   r  rb   )r”  rƒ   r¸   r&   rM   rN   )rØ   rÙ   r¥   r�   r;  rÙ   rM   rC   )€Ú
__future__r   r‰  Úloggingr‡   rÞ   rÄ   rÁ   rt   r\  rn  rP   r*  Úcollectionsr   Ú
contextlibr   r   Údataclassesr   r   Ú	itertoolsr   Útypingr	   r
   r   r   r   r   r   Úweakrefr   Ú_apir   r   r   r   r   r   r   r   r   r   r   r   Ú_errorr   Ú	_identityr   r    r!   r]  Ú_windowsr#   Úcollections.abcr$   r%   Z	_typeshedr&   Úversion_infor)   Útyping_extensionsÚ	getLoggerr+   rH   r‡  r,   Úimplementationrr  r-   r�  r0   rƒ   ÚbytesÚPathLikerÙ   rC   ÚtyperÂ   r1   Útupler2   r3   r5   ÚO_RDWRÚO_CREATr  r8   r:   r;   Úslicer>   r?   rA   ÚlocalrB   rK   rL   rc   rd   rz   r{   rf   r|   r}   rŽ   r˜   r°   r±   rÎ   rÚ   rI  ra  rf  rm  ry  rp  r‚  r^  r_  rÀ   r“  r•  r=  Úaddaudithookr.   Ú__all__rI   rI   rI   rJ   Ú<module>   s´    $8


ÿ0
ÿ,/Q;J    
+

-











þ