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   úg/var/www/html/academy/tools/voices/clone/cosy-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   ÚctypesZ
PYFUNCTYPEZ	py_objectr   Z	pythonapiZ	Py_IncRefZ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\   r]   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   rf   rc   rd   rZ   )rU   rg   ri   Zall_paths_poisonedZpoisonedr[   rI   rI   rJ   Úraise_if_poisoned~   s   
ÿþÿ
ýúz)_ForkedDatabaseRegistry.raise_if_poisonedri   ú_DatabaseIdentity | Nonec                 C  s(   | j  |¡ |d ur| j |¡ d S d S rO   )rc   Úaddrd   )rU   rg   ri   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   re   rT   rI   rI   rJ   Únote_sqlite_use’   s
   "ÿÿz'_ForkedDatabaseRegistry.note_sqlite_usec                 C  s&   t  ¡ | _| jpto| j| _d| _d S ra   )rP   rQ   rR   rf   r-   re   rT   rI   rI   rJ   r]   —   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)rg   Ústat_resultrI   rI   rJ   ri   œ   s   ÿz _ForkedDatabaseRegistry.identityNr^   )rg   rh   rM   rN   )rg   rh   ri   rk   rM   rN   )rg   rh   rM   rk   )
rE   rF   rG   rV   rj   rm   ro   r]   Ústaticmethodri   rI   rI   rI   rJ   r`   v   s    




r`   Ú_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Úlstatrq   rr   rs   rR   rp   ÚS_ISREGÚst_moder{   ÚgetÚidleÚappendÚ_ProbeÚpopÚnextr}   Úleasesrl   Úlease)rU   r~   r€   rt   ri   Ú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ƒ   Úfstatrr   rs   r   rR   r{   Ú
setdefaultÚ_InodeProbesÚdescriptorsr‰   rŠ   rŒ   r}   r�   rl   rŽ   )rU   r‘   r€   rt   ri   Ú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{   ri   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‡   ri   rŽ   r�   Úremoverˆ   r‰   r‘   Úclearr•   r   r‹   r   rq   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   rz   rR   r{   r   r|   rT   rI   rI   rJ   r]   ø   s   
z,_ProbeDescriptors._reset_after_fork_in_childNr^   )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£   r]   rI   rI   rI   rJ   ry   ®   s    








ry   c                   @  s&   e Zd ZU ded< ded< ded< dS )rŠ   r2   ri   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   rb   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_directoryNrk   Ú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³   ri   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½   ÚErrorrZ   rq   r¨   rT   rI   rI   rJ   Ú__del__F  s   
"ÿz_ForkSafeConnection.__del__)r´   r1   rµ   r1   rM   r)   r^   )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__rZ   ÚpathlibÚPathr   rÍ   rÌ   rÏ   rl   Ú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Î   rb   rÏ   ©r¸   rI   rI   rJ   rØ   Ž  s   
z*_ReadWriteLockMeta._reset_class_after_fork©r¥   )
rÒ   rÓ   rÔ   rÕ   r¡   r™   rÑ   r™   rM   rÖ   r^   )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Î   rb   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_pathrv   rj   rÔ   r¡   rP   rz   Ú_transaction_lockÚ_internal_lockÚ_lock_levelÚ_current_modeÚ_write_thread_idÚ_read_depthsrb   Ú_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Ò   ÚidrZ   Ú_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  rZ   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Ç   rZ   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 rn   )rò   rv   rm   rê   rô   ró   rP   rz   rë   rì   r  rb   rñ   rö   rT   rI   rI   rJ   r]   ©  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Ò   rZ   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Ò   rZ   rl   Ú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÷   rv   ri   rê   rò   ró   rô   r/  )rU   rÔ   r¡   r#  r$  rè   r¹   rI   rI   rJ   r-    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­   r6  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'  r9  r/  Úexecutescriptr¨   Ú_raise_if_database_replaced)rU   r  rÔ   r¡   r*  r#  r$  r¹   ZwaitedÚ
timeout_msZ
recomputedZ
statementsrI   rI   rJ   r.  '  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ê   rp   r¿   rr   rs   rÒ   rq   )rU   r¹   ri   Úcurrentr[   rI   rI   rJ   r=  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,   r_   r\   rZ   Ú_connectrƒ   ré   rê   r­   rÆ   rv   rm   ri   )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 rn   )
r¼   rò   ró   Úin_transactionÚrollbackr½   rÇ   r¨   r   rô   )rU   r¹   Úrollback_errorr3  Ú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  rZ   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Ô   Ú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Ò   rZ   )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Ò   rZ   )rU   r#  r[   rI   rI   rJ   r/  ¶  s   þz'ReadWriteLock._raise_if_process_changedr^   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*  rS  rM   rN   )r#  rC   rM   rN   )/rE   rF   rG   rä   r   rÌ   rH   rP   rQ   rÍ   r,   rÎ   rb   rÏ   rå   Úclassmethodræ   rV   rÿ   r  r   r  r  rŸ   r¨   r  r  r  r  r  rÈ   r]   Úpropertyr
  r  rý   r)  r-  r.  r=  r÷   r  r%  r(  r  r/  rÉ   rI   rI   rº   rJ   rÖ   •  s\   
 ÿÿýú








	

4

"




rÖ   )Ú	metaclassr~   r   rD  ú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_threadrD  Zcached_statementsrÔ   rC  )rv   ro   ÚsysÚplatformÚ_open_lock_databaseÚ_raise_if_walr½   Úconnectrƒ   r¨   Ú_connect_through_descriptor)r~   rD  rÔ   r‘   rI   rI   rJ   rE  ¼  s   


ÿrE  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   rX  )r¬   r�   r—   r[  rž   r\  rÚ   rÛ   r:   rƒ   ÚaccessÚF_OKr�   rp   rr   rs   Ú_link_besiderq   r½   r]  ré   rÄ   r§   rŸ   r   r¿   rÀ   rÁ   )r~   rD  rÔ   r€   rÂ   r˜   ri   r‘   Ú_ÚtargetZ	reachableÚnamedr¹   ZunownedrI   rI   rJ   r^  Í  sR   

ÿÿþÿ
ÿþþ
ÿr^  ri   rh   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Údirr`  Fr?  z%lock database changed while opening: )rÚ   rÛ   ÚparentÚ_sweep_links_of_the_deadÚtempfileÚmkdtempÚ_link_prefixrƒ   Úlinkrp   r0  rÀ   rÁ   rr   rs   rq   )r~   ri   ri  rÂ   rn  Zlinkedr[   rI   rI   rJ   rc  ú  s   
þ

rc  ri  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 )Fr?  )ÚnameÚ
startswithrw   Úis_dirrÚ   rÛ   rg   )Ú.0ÚentryrI   rI   rJ   Ú
<listcomp>  s    
ý
ý
ÿz,_sweep_links_of_the_dead.<locals>.<listcomp>)rƒ   ré   rx   rl   Úscandirrq   Ú_owner_is_gonero  r   rÀ   rÁ   )ri  ÚkeyÚentriesZdirectoriesrÂ   rI   rI   rJ   rj    s(   
þÿ€ÿ

ÿ€ýrj  ro  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)Úremoveprefixrw   ÚsplitÚisdigitr   Ú_host_digestr    rC   )ro  ÚpidÚstartÚdigestÚhostrI   rI   rJ   rv  "  s   0(þrv  c                  C  s<   t t ¡  } ƒ}t› | › d|d u rdn|› dttƒ ƒ› d�S )Nry  r;  )r!   rƒ   Úgetpidrw   r~  r   )r  r€  rI   rI   rJ   rm  ,  s   ,rm  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€  rA  z) is being deleted or held without sharingz&refusing a non-regular lock database: )rY  rZ  r#   ÚPermissionErrorrƒ   Úopenr8   rp   r…   r’   r†   r¨   rq   )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û   rp  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)rv   ro   )r�  r´   rI   rI   rJ   Ú_track_sqlite_use^  s   ÿr‘  r¡   r7  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 -1r8  z7timeout %s is too large for SQLite, using %s ms instead)r3   rÝ   rC   Úmaxr+   Úwarning)rÔ   r¡   r7  r[   r>  rI   rI   rJ   r9  c  s   "r9  )Úafter_in_child)r~   r   rD  rW  rÔ   rÕ   rM   r­   )r~   r   ri   r2   rM   rh   )ri  rh   rM   rN   )ro  r   rM   r™   )rM   r   )r‚  r   rM   r   )r~   r   rM   rC   )r‘   rC   r~   r   rM   rN   )rM   r  r^   )r�  r   r´   r&   rM   rN   )rÔ   rÕ   r¡   r™   r7  rÕ   rM   rC   )€Ú
__future__r   r…  Úloggingrƒ   rÚ   rÀ   r½   rp   rY  rk  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!   rZ  Ú_windowsr#   Úcollections.abcr$   r%   Z	_typeshedr&   Úversion_infor)   Ztyping_extensionsÚ	getLoggerr+   rH   rƒ  r,   Úimplementationro  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   r_   r`   rv   rw   rb   rx   ry   rŠ   r”   r¬   r­   rÊ   rÖ   rE  r^  rc  rj  rv  rm  r~  r[  r\  r¼   r�  r‘  r9  Úaddaudithookr.   Ú__all__rI   rI   rI   rJ   Ú<module>   s´    $8


ÿ0
ÿ,/Q;J    
+

-




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