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	m
Z
mZ d dl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 er^d dlZd dlmZ edƒZnedƒZed	ƒZe d
¡Z ee!e!ge"f Z#G dd„ dƒZ$G dd„ de$ƒZ%G dd„ de$ƒZ&G dd„ de$ƒZ'G dd„ de$ƒZ(G dd„ de$ƒZ)G dd„ de$ƒZ*G dd„ de$ƒZ+G dd„ deeef ƒZ,G dd„ de$ƒZ-de$iZ.de/d < d*d+d(d)„Z0e$e%e)e&e(e'e*e+e-f	D ]Z1e0e1ƒ qßdS ),é    )ÚannotationsN)ÚFutureÚThreadPoolExecutor)Úgroupby)Ú
itemgetter)	ÚTYPE_CHECKINGÚAnyÚCallableÚClassVarÚGenericÚ
NamedTupleÚOptionalÚOrderedDictÚTypeVar)Ú	ParamSpecÚPÚTÚfsspecc                   @  sP   e Zd ZU dZdZded< ddd„Zddd„Zddd„Zddd„Z	ddd„Z
dS ) Ú	BaseCacheag  Pass-though cache: doesn't keep anything, calls every time

    Acts as base class for other cachers

    Parameters
    ----------
    blocksize: int
        How far to read ahead in numbers of bytes
    fetcher: func
        Function of the form f(start, end) which gets bytes from remote as
        specified
    size: int
        How big this file is
    ÚnoneúClassVar[str]ÚnameÚ	blocksizeÚintÚfetcherÚFetcherÚsizeÚreturnÚNonec                 C  s.   || _ d| _|| _|| _d| _d| _d| _d S ©Nr   )r   Únblocksr   r   Ú	hit_countÚ
miss_countÚtotal_requested_bytes©Úselfr   r   r   © r&   úa/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/fsspec/caching.pyÚ__init__<   s   
zBaseCache.__init__Ústartú
int | NoneÚstopÚbytesc                 C  s<   |d u rd}|d u r| j }|| j ks||krdS |  ||¡S )Nr   ó    )r   r   ©r%   r)   r+   r&   r&   r'   Ú_fetchF   s   zBaseCache._fetchc                 C  s   d| _ d| _d| _dS )zAReset hit and miss counts for a more ganular report e.g. by file.r   N)r!   r"   r#   ©r%   r&   r&   r'   Ú_reset_statsO   s   
zBaseCache._reset_statsÚstrc              	   C  s>   | j dkr| jdkrdS d| j› d| j › d| j› d| j› d�	S )z2Return a formatted string of the cache statistics.r   Ú z , z: z hits, z	 misses, z total requested bytes)r!   r"   r   r#   r0   r&   r&   r'   Ú
_log_statsU   s   &zBaseCache._log_statsc                 C  s@   d| j j› d| j› d| j› d| j› d| j› d| j› d| j› d�S )	Nz

        <z:
            block size  :   z
            block count :   z
            file size   :   z
            cache hits  :   z
            cache misses:   z$
            total requested bytes: z
>
        )Ú	__class__Ú__name__r   r    r   r!   r"   r#   r0   r&   r&   r'   Ú__repr__\   s   ÿþýüûúùzBaseCache.__repr__N©r   r   r   r   r   r   r   r   ©r)   r*   r+   r*   r   r,   ©r   r   )r   r2   )r6   Ú
__module__Ú__qualname__Ú__doc__r   Ú__annotations__r(   r/   r1   r4   r7   r&   r&   r&   r'   r   *   s   
 



	
r   c                      sT   e Zd ZdZdZ		d d!‡ fdd„Zd"dd„Zd#dd„Zd$dd„Zd%dd„Z	‡  Z
S )&Ú	MMapCachezämemory-mapped sparse file cache

    Opens temporary file, which is filled blocks-wise when data is requested.
    Ensure there is enough disc space in the temporary location.

    This cache method might only work on posix
    ÚmmapNr   r   r   r   r   Úlocationú
str | NoneÚblocksúset[int] | Noner   r   c                   s8   t ƒ  |||¡ |d u rtƒ n|| _|| _|  ¡ | _d S ©N)Úsuperr(   ÚsetrC   rA   Ú	_makefileÚcache)r%   r   r   r   rA   rC   ©r5   r&   r'   r(   t   s   zMMapCache.__init__úmmap.mmap | bytearrayc                 C  s¢   dd l }dd l}| jdkrtƒ S | jd u stj | j¡sB| jd u r*| ¡ }t	ƒ | _
nt| jdƒ}| | jd ¡ | d¡ | ¡  nt| jdƒ}|  | ¡ | j¡S )Nr   zwb+é   ó   1zr+b)r@   Útempfiler   Ú	bytearrayrA   ÚosÚpathÚexistsÚTemporaryFilerG   rC   ÚopenÚseekÚwriteÚflushÚfileno)r%   r@   rN   Úfdr&   r&   r'   rH   �   s   




zMMapCache._makefiler)   r*   Úendr,   c                   st  t  d|› d|› �¡ |d u rd}|d u rˆ j}|ˆ jks!||kr#dS |ˆ j }|ˆ j }t||d ƒ}‡ fdd„|D ƒ}ˆ  jt‡ fdd„|D ƒƒ7  _tt|ƒd	d
„ d�D ][\}}t	t
tdƒ|ƒƒ}|d ˆ j }	t|d ˆ j ˆ j ˆ jƒ}
ˆ  j|
|	 7  _t  d|d › d|d › d|	› d|
› d�	¡ ˆ  |	|
¡ˆ j|	|
…< ˆ j |¡ ˆ  jt|ƒ7  _qWˆ j||… S )NzMMap cache fetching ú-r   r-   rL   c                 3  s   � | ]
}|ˆ j vr|V  qd S rE   ©rC   ©Ú.0Úir0   r&   r'   Ú	<genexpr>£   ó   € z#MMapCache._fetch.<locals>.<genexpr>c                 3  s   � | ]
}|ˆ j v rd V  qdS )rL   Nr\   r]   r0   r&   r'   r`   ¥   ra   c                 S  s   | d | d  S )Nr   rL   r&   )Úxr&   r&   r'   Ú<lambda>¯   s    z"MMapCache._fetch.<locals>.<lambda>)ÚkeyéÿÿÿÿzMMap get blocks z (ú))ÚloggerÚdebugr   r   Úranger!   Úsumr   Ú	enumerateÚtupleÚmapr   Úminr#   r   rI   rC   Úupdater"   Úlen)r%   r)   rZ   Ústart_blockÚ	end_blockZblock_rangeÚneedÚ_Ú_blocksZsstartÚsendr&   r0   r'   r/   —   s0   

 
$ÿzMMapCache._fetchúdict[str, Any]c                 C  s   | j  ¡ }|d= |S )NrI   )Ú__dict__Úcopy©r%   Ústater&   r&   r'   Ú__getstate__Å   s   
zMMapCache.__getstate__r{   c                 C  s   | j  |¡ |  ¡ | _d S rE   )rx   ro   rH   rI   rz   r&   r&   r'   Ú__setstate__Ë   s   zMMapCache.__setstate__)NN)r   r   r   r   r   r   rA   rB   rC   rD   r   r   )r   rK   ©r)   r*   rZ   r*   r   r,   ©r   rw   ©r{   rw   r   r   )r6   r;   r<   r=   r   r(   rH   r/   r|   r}   Ú__classcell__r&   r&   rJ   r'   r?   i   s    ú


.r?   c                      ó0   e Zd ZdZdZd‡ fd
d„Zddd„Z‡  ZS )ÚReadAheadCachea!  Cache which reads only when we get beyond a block of data

    This is a much simpler version of BytesCache, and does not attempt to
    fill holes in the cache or keep fragments alive. It is best suited to
    many small reads in a sequential order (e.g., reading lines from a file).
    Ú	readaheadr   r   r   r   r   r   r   c                   s&   t ƒ  |||¡ d| _d| _d| _d S )Nr-   r   )rF   r(   rI   r)   rZ   r$   rJ   r&   r'   r(   Û   s   
zReadAheadCache.__init__r)   r*   rZ   r,   c                 C  s>  |d u rd}|d u s|| j kr| j }|| j ks||krdS || }|| jkr?|| jkr?|  jd7  _| j|| j || j … S | j|  krK| jk rhn n|  jd7  _| j|| j d … }|t|ƒ8 }| j}n	|  jd7  _d}t| j || j ƒ}|  j	|| 7  _	|  
||¡| _|| _| jt| jƒ | _|| jd |…  S ©Nr   r-   rL   )r   r)   rZ   r!   rI   r"   rp   rn   r   r#   r   )r%   r)   rZ   ÚlÚpartr&   r&   r'   r/   á   s.   zReadAheadCache._fetchr8   r~   ©r6   r;   r<   r=   r   r(   r/   r�   r&   r&   rJ   r'   rƒ   Ñ   s
    rƒ   c                      r‚   )ÚFirstChunkCachez›Caches the first block of a file only

    This may be useful for file types where the metadata is stored in the header,
    but is randomly accessed.
    Úfirstr   r   r   r   r   r   r   c                   s&   ||kr|}t ƒ  |||¡ d | _d S rE   )rF   r(   rI   r$   rJ   r&   r'   r(     s   
zFirstChunkCache.__init__r)   r*   rZ   r,   c                 C  s*  |pd}|| j krt d¡ dS t|| j ƒ}|| jk r| jd u rW|  jd7  _|| jkrG|  j|7  _|  d|¡}|d | j… | _||d … S |  d| j¡| _|  j| j7  _| j||… }|| jkrv|  j|| j 7  _||  | j|¡7 }|  j	d7  _	|S |  jd7  _|  j|| 7  _|  ||¡S )Nr   z,FirstChunkCache: requested start > file sizer-   rL   )
r   rg   rh   rn   r   rI   r"   r#   r   r!   )r%   r)   rZ   Údatar‡   r&   r&   r'   r/     s0   





zFirstChunkCache._fetchr8   r~   rˆ   r&   r&   rJ   r'   r‰   ÿ   s
    r‰   c                      sh   e Zd ZdZdZ	d#d$‡ fdd„Zdd„ Zd%dd„Zd&dd„Zd'dd„Z	d(‡ fdd„Z
d)d!d"„Z‡  ZS )*Ú
BlockCacheaè  
    Cache holding memory as a set of blocks.

    Requests are only ever made ``blocksize`` at a time, and are
    stored in an LRU cache. The least recently accessed block is
    discarded when more than ``maxblocks`` are stored.

    Parameters
    ----------
    blocksize : int
        The number of bytes to store in each block.
        Requests are only ever made for ``blocksize``, so this
        should balance the overhead of making a request against
        the granularity of the blocks.
    fetcher : Callable
    size : int
        The total size of the file being cached.
    maxblocks : int
        The maximum number of blocks to cache for. The maximum memory
        use for this cache is then ``blocksize * maxblocks``.
    Z
blockcacheé    r   r   r   r   r   Ú	maxblocksr   r   c                   s<   t ƒ  |||¡ t || ¡| _|| _t |¡| jƒ| _	d S rE   )
rF   r(   ÚmathÚceilr    rŽ   Ú	functoolsÚ	lru_cacheÚ_fetch_blockÚ_fetch_block_cached©r%   r   r   r   rŽ   rJ   r&   r'   r(   F  s   zBlockCache.__init__c                 C  ó
   | j  ¡ S ©zª
        The statistics on the block cache.

        Returns
        -------
        NamedTuple
            Returned directly from the LRU Cache used internally.
        ©r”   Ú
cache_infor0   r&   r&   r'   r™   N  ó   
	zBlockCache.cache_inforw   c                 C  s   | j }|d= |S )Nr”   ©rx   rz   r&   r&   r'   r|   Y  s   zBlockCache.__getstate__r{   c                 C  s&   | j  |¡ t |d ¡| jƒ| _d S )NrŽ   )rx   ro   r‘   r’   r“   r”   rz   r&   r&   r'   r}   ^  s   
ÿzBlockCache.__setstate__r)   r*   rZ   r,   c                 C  st   |d u rd}|d u r| j }|| j ks||krdS || j }|| j }t||d ƒD ]}|  |¡ q)| j||||d�S )Nr   r-   rL   ©Ústart_block_numberÚend_block_number)r   r   ri   r”   Ú_read_cache)r%   r)   rZ   r�   rž   Úblock_numberr&   r&   r'   r/   d  s    

üzBlockCache._fetchr    c                   st   || j krtd|› d| j › d�ƒ‚|| j }|| j }|  j|| 7  _|  jd7  _t d|¡ tƒ  ||¡}|S )ú=
        Fetch the block of data for `block_number`.
        ú'block_number=ú(' is greater than the number of blocks (rf   rL   zBlockCache fetching block %d)	r    Ú
ValueErrorr   r#   r"   rg   ÚinforF   r/   )r%   r    r)   rZ   Úblock_contentsrJ   r&   r'   r“   {  s   
ÿÿ

zBlockCache._fetch_blockr�   rž   c           	      C  ó’   || j  }|| j  }|  jd7  _||kr |  |¡}|||… S |  |¡|d… g}| t| jt|d |ƒƒ¡ | |  |¡d|… ¡ d |¡S ©zú
        Read from our block cache.

        Parameters
        ----------
        start, end : int
            The start and end byte positions.
        start_block_number, end_block_number : int
            The start and end block numbers.
        rL   Nr-   ©r   r!   r”   Úextendrm   ri   ÚappendÚjoin©	r%   r)   rZ   r�   rž   Ú	start_posÚend_posÚblockÚoutr&   r&   r'   rŸ   �  s   


þÿ
zBlockCache._read_cache©r�   ©
r   r   r   r   r   r   rŽ   r   r   r   r   r€   r~   )r    r   r   r,   ©
r)   r   rZ   r   r�   r   rž   r   r   r,   )r6   r;   r<   r=   r   r(   r™   r|   r}   r/   r“   rŸ   r�   r&   r&   rJ   r'   rŒ   -  s    ÿ


rŒ   c                      sH   e Zd ZU dZdZded< 	dd‡ fdd„Zddd„Zddd„Z‡  Z	S )Ú
BytesCacheaK  Cache which holds data in a in-memory bytes object

    Implements read-ahead by the block size, for semi-random reads progressing
    through the file.

    Parameters
    ----------
    trim: bool
        As we read more data, whether to discard the start of the buffer when
        we are more than a blocksize ahead of it.
    r,   r   r   Tr   r   r   r   r   ÚtrimÚboolr   r   c                   s,   t ƒ  |||¡ d| _d | _d | _|| _d S )Nr-   )rF   r(   rI   r)   rZ   r¶   )r%   r   r   r   r¶   rJ   r&   r'   r(   Å  s
   
zBytesCache.__init__r)   r*   rZ   c                 C  sÚ  |d u rd}|d u r| j }|| j ks||krdS | jd urC|| jkrC| jd urC|| jk rC|| j }|  jd7  _| j||| | … S | jrPt| j || j ƒ}n|}||ks[|| j kr]dS | jd u sg|| jk rŒ| jd u sq|| jkrŒ|  j|| 7  _|  jd7  _|  	||¡| _|| _n�| jd us“J ‚| jd usšJ ‚|  jd7  _|| jk râ| jd u s³| j| | jkrÇ|  j|| 7  _|  	||¡| _|| _nb|  j| j| 7  _|  	|| j¡}|| _|| j | _nG| jd u�r)|| jk�r)| j| j krõn4|| j | jk�r|  j|| 7  _|  	||¡| _|| _n|  j|| j 7  _|  	| j|¡}| j| | _| jt
| jƒ | _|| j }| j||| | … }| j�rk| j| j | jd  }|dk�rk|  j| j| 7  _| j| j| d … | _|S r…   )r   r)   rZ   r!   rI   r   rn   r#   r"   r   rp   r¶   )r%   r)   rZ   ÚoffsetZbendÚnewr±   Únumr&   r&   r'   r/   Î  sn   







zBytesCache._fetchc                 C  s
   t | jƒS rE   )rp   rI   r0   r&   r&   r'   Ú__len__  s   
zBytesCache.__len__)T)
r   r   r   r   r   r   r¶   r·   r   r   r~   )r   r   )
r6   r;   r<   r=   r   r>   r(   r/   r»   r�   r&   r&   rJ   r'   rµ   ¶  s   
 ÿ
	Irµ   c                      sD   e Zd ZU dZdZded< 				dd‡ fdd„Zddd„Z‡  ZS )ÚAllBytesz!Cache entire contents of the fileÚallr   r   Nr   r*   r   úFetcher | Noner   r‹   úbytes | Noner   r   c                   sN   t ƒ  |||¡ |d u r"|  jd7  _|  j| j7  _|  d| j¡}|| _d S )NrL   r   )rF   r(   r"   r#   r   r   r‹   )r%   r   r   r   r‹   rJ   r&   r'   r(      s   
zAllBytes.__init__r)   r+   r,   c                 C  s   |  j d7  _ | j||… S )NrL   )r!   r‹   r.   r&   r&   r'   r/   .  s   zAllBytes._fetch)NNNN)
r   r*   r   r¾   r   r*   r‹   r¿   r   r   r9   ©	r6   r;   r<   r=   r   r>   r(   r/   r�   r&   r&   rJ   r'   r¼     s   
 ûr¼   c                      sD   e Zd ZU dZdZded< 		dd‡ fdd„Zd‡ fdd„Z‡  ZS )ÚKnownPartsOfAFilea½  
    Cache holding known file parts.

    Parameters
    ----------
    blocksize: int
        How far to read ahead in numbers of bytes
    fetcher: func
        Function of the form f(start, end) which gets bytes from remote as
        specified
    size: int
        How big this file is
    data: dict
        A dictionary mapping explicit `(start, stop)` file-offset tuples
        with known bytes.
    strict: bool, default True
        Whether to fetch reads that go beyond a known byte-range boundary.
        If `False`, any read that ends outside a known part will be zero
        padded. Note that zero padding will not be used for reads that
        begin outside a known byte-range.
    Úpartsr   r   NTr   r   r   r   r   r‹   ú&Optional[dict[tuple[int, int], bytes]]Ústrictr·   rt   r   c                   sÒ   t ƒ  |||¡ || _|rdt| ¡ ƒ}|d g}| |d ¡g}	|dd … D ]3\}
}|d \}}|
|krH||f|d< |	d  | |
|f¡7  < q&| |
|f¡ |	 | |
|f¡¡ q&tt||	ƒƒ| _	d S i | _	d S )Nr   rL   re   )
rF   r(   rÄ   ÚsortedÚkeysÚpopr«   ÚdictÚzipr‹   )r%   r   r   r   r‹   rÄ   rt   Zold_offsetsÚoffsetsrC   r)   r+   Ústart0Ústop0rJ   r&   r'   r(   L  s   	

zKnownPartsOfAFile.__init__r)   r*   r+   r   r,   c                   s:  |d u rd}|d u r| j }d}| j ¡ D ]J\\}}}||  kr$|k r^n q|| }|||| | … }| jrC||  krA|krZn n|d|| t|ƒ  7 }|  jd7  _|  S |} nq| jd u rntd||f› d�ƒ‚t 	d||f› d�¡ t
 d|› d	|› �¡ |  j|| 7  _|  jd7  _|tƒ  ||¡ S )
Nr   r-   ó    rL   z&Read is outside the known file parts: z. z%. IO/caching performance may be poor!z!KnownPartsOfAFile cache fetching r[   )r   r‹   ÚitemsrÄ   rp   r!   r   r¤   ÚwarningsÚwarnrg   rh   r#   r"   rF   r/   )r%   r)   r+   r±   Úloc0Zloc1r‹   ÚoffrJ   r&   r'   r/   j  s2   ð
ÿzKnownPartsOfAFile._fetch)NT)r   r   r   r   r   r   r‹   rÃ   rÄ   r·   rt   r   r9   rÀ   r&   r&   rJ   r'   rÁ   3  s   
 úrÁ   c                   @  sT   e Zd ZdZG dd„ deƒZdd dd„Zd!dd„Zd"dd„Zd#dd„Z	d$dd„Z
dS )%ÚUpdatableLRUzg
    Custom implementation of LRU cache that allows updating keys

    Used by BackgroudBlockCache
    c                   @  s.   e Zd ZU ded< ded< ded< ded< dS )úUpdatableLRU.CacheInfor   ÚhitsÚmissesÚmaxsizeÚcurrsizeN)r6   r;   r<   r>   r&   r&   r&   r'   Ú	CacheInfoŸ  s
   
 rÙ   é€   ÚfuncúCallable[P, T]Úmax_sizer   r   r   c                 C  s0   t  ¡ | _|| _|| _d| _d| _t ¡ | _	d S r   )
Úcollectionsr   Ú_cacheÚ_funcÚ	_max_sizeÚ_hitsÚ_missesÚ	threadingÚLockÚ_lock)r%   rÛ   rÝ   r&   r&   r'   r(   ¥  s   
zUpdatableLRU.__init__ÚargsúP.argsÚkwargsúP.kwargsr   c                 O  sú   |rt d| ¡ › �ƒ‚| j�& || jv r-| j |¡ |  jd7  _| j| W  d   ƒ S W d   ƒ n1 s7w   Y  | j|i |¤Ž}| j�, || j|< |  jd7  _t| jƒ| j	krk| jj
dd� W d   ƒ |S W d   ƒ |S 1 svw   Y  |S )Nz Got unexpected keyword argument rL   F©Úlast)Ú	TypeErrorrÆ   ræ   rß   Úmove_to_endrâ   rà   rã   rp   rá   Úpopitem)r%   rç   ré   Úresultr&   r&   r'   Ú__call__­  s.   
üÿ

üý
ýúzUpdatableLRU.__call__r   r·   c                 G  s4   | j � || jv W  d   ƒ S 1 sw   Y  d S rE   )ræ   rß   )r%   rç   r&   r&   r'   Úis_key_cachedÀ  s   $ÿzUpdatableLRU.is_key_cachedrð   c                 G  sd   | j �% || j|< t| jƒ| jkr | jjdd� W d   ƒ d S W d   ƒ d S 1 s+w   Y  d S )NFrë   )ræ   rß   rp   rá   rï   )r%   rð   rç   r&   r&   r'   Úadd_keyÄ  s   
ý"þzUpdatableLRU.add_keyrÔ   c                 C  sH   | j � | j| jt| jƒ| j| jd�W  d   ƒ S 1 sw   Y  d S )N)r×   rØ   rÕ   rÖ   )ræ   rÙ   rá   rp   rß   râ   rã   r0   r&   r&   r'   r™   Ê  s   ü$ÿzUpdatableLRU.cache_infoN)rÚ   )rÛ   rÜ   rÝ   r   r   r   )rç   rè   ré   rê   r   r   )rç   r   r   r·   )rð   r   rç   r   r   r   ©r   rÔ   )r6   r;   r<   r=   r   rÙ   r(   rñ   rò   ró   r™   r&   r&   r&   r'   rÓ   ˜  s    


rÓ   c                      sv   e Zd ZU dZdZded< 	d(d)‡ fdd„Zd*dd„Zd+dd„Zd,dd„Z	d-dd„Z
d.d/‡ fd"d#„Zd0d&d'„Z‡  ZS )1ÚBackgroundBlockCacheaƒ  
    Cache holding memory as a set of blocks with pre-loading of
    the next block in the background.

    Requests are only ever made ``blocksize`` at a time, and are
    stored in an LRU cache. The least recently accessed block is
    discarded when more than ``maxblocks`` are stored. If the
    next block is not in cache, it is loaded in a separate thread
    in non-blocking way.

    Parameters
    ----------
    blocksize : int
        The number of bytes to store in each block.
        Requests are only ever made for ``blocksize``, so this
        should balance the overhead of making a request against
        the granularity of the blocks.
    fetcher : Callable
    size : int
        The total size of the file being cached.
    maxblocks : int
        The maximum number of blocks to cache for. The maximum memory
        use for this cache is then ``blocksize * maxblocks``.
    Ú
backgroundr   r   r�   r   r   r   r   r   rŽ   r   r   c                   sZ   t ƒ  |||¡ t || ¡| _|| _t| j|ƒ| _t	dd�| _
d | _d | _t ¡ | _d S )NrL   ©Úmax_workers)rF   r(   r�   r�   r    rŽ   rÓ   r“   r”   r   Ú_thread_executorÚ_fetch_future_block_numberÚ_fetch_futurerä   rå   Ú_fetch_future_lockr•   rJ   r&   r'   r(   ð  s   zBackgroundBlockCache.__init__rÔ   c                 C  r–   r—   r˜   r0   r&   r&   r'   r™   ý  rš   zBackgroundBlockCache.cache_inforw   c                 C  s(   | j }|d= |d= |d= |d= |d= |S )Nr”   rù   rú   rû   rü   r›   rz   r&   r&   r'   r|     s   z!BackgroundBlockCache.__getstate__c                 C  sD   | j  |¡ t| j|d ƒ| _tdd�| _d | _d | _t	 
¡ | _d S )NrŽ   rL   r÷   )rx   ro   rÓ   r“   r”   r   rù   rú   rû   rä   rå   rü   rz   r&   r&   r'   r}     s   z!BackgroundBlockCache.__setstate__r)   r*   rZ   r,   c           
      C  s¸  |d u rd}|d u r| j }|| j ks||krdS || j }|| j }d }d }| j�M | jd uro| jd us6J ‚| j ¡ rRt d¡ | j 	| j 
¡ | j¡ d | _d | _nt|| j  ko]|kn  ƒ}|ro| j}| j}d | _d | _W d   ƒ n1 syw   Y  |d ur�t d¡ | j 	| 
¡ |¡ t||d ƒD ]}|  |¡ q—|d }	| j�% | jd u rÄ|	| jkrÄ| j |	¡sÄ|	| _| j | j|	d¡| _W d   ƒ n1 sÎw   Y  | j||||d�S )Nr   r-   z3BlockCache joined background fetch without waiting.z(BlockCache waiting for background fetch.rL   Úasyncrœ   )r   r   rü   rû   rú   Údonerg   r¥   r”   ró   rð   r·   ri   r    rò   rù   Úsubmitr“   rŸ   )
r%   r)   rZ   r�   rž   Zfetch_future_block_numberZfetch_futureZ	must_joinr    Zend_block_plus_1r&   r&   r'   r/     sv   




ÿÿþÿ€å
ÿ


ÿÿ€ùüzBackgroundBlockCache._fetchÚsyncr    Úlog_infor2   c                   sv   || j krtd|› d| j › d�ƒ‚|| j }|| j }t d||¡ |  j|| 7  _|  jd7  _tƒ  ||¡}|S )r¡   r¢   r£   rf   z!BlockCache fetching block (%s) %drL   )	r    r¤   r   rg   r¥   r#   r"   rF   r/   )r%   r    r  r)   rZ   r¦   rJ   r&   r'   r“   e  s   
ÿÿ

z!BackgroundBlockCache._fetch_blockr�   rž   c           	      C  r§   r¨   r©   r­   r&   r&   r'   rŸ   w  s   


þÿ
z BackgroundBlockCache._read_cacher²   r³   rô   r   r:   r~   )r   )r    r   r  r2   r   r,   r´   )r6   r;   r<   r=   r   r>   r(   r™   r|   r}   r/   r“   rŸ   r�   r&   r&   rJ   r'   rõ   Ô  s   
 ÿ


	
Lrõ   z!dict[str | None, type[BaseCache]]ÚcachesFÚclsútype[BaseCache]Úclobberr·   r   r   c                 C  s6   | j }|s|tv rtd|›dt| › �ƒ‚| t|< dS )zÝ'Register' cache implementation.

    Parameters
    ----------
    clobber: bool, optional
        If set to True (default is False) - allow to overwrite existing
        entry.

    Raises
    ------
    ValueError
    zCache with name z is already known: N)r   r  r¤   )r  r  r   r&   r&   r'   Úregister_cache¨  s   r  )F)r  r  r  r·   r   r   )2Ú
__future__r   rÞ   r‘   Úloggingr�   rP   rä   rÏ   Úconcurrent.futuresr   r   Ú	itertoolsr   Úoperatorr   Útypingr   r   r	   r
   r   r   r   r   r   r@   Útyping_extensionsr   r   r   Ú	getLoggerrg   r   r,   r   r   r?   rƒ   r‰   rŒ   rµ   r¼   rÁ   rÓ   rõ   r  r>   r  Úcr&   r&   r&   r'   Ú<module>   s^    ,

?h.. 
ee< Qþ÷
õ