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	 d dl
m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 erdd 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#ee$e!e!f 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&ƒZ.G dd „ d eeef ƒZ/G d!d"„ d"e&ƒZ0de&iZ1d#e2d$< d.d/d,d-„Z3e&e'e,e(e)e+e*e-e.e0f
D ]Z4e3e4ƒ qùdS )0é    )ÚannotationsN)ÚOrderedDict)ÚCallable)ÚFutureÚThreadPoolExecutor)Úgroupby)Ú
itemgetter)ÚTYPE_CHECKINGÚAnyÚClassVarÚGenericÚ
NamedTupleÚTypeVar)Ú	ParamSpecÚPÚTzfsspec.cachingc                   @  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$   ú_/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/fsspec/caching.pyÚ__init__5   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%   Ú_fetch?   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_statsH   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!   r.   r$   r$   r%   Ú
_log_statsN   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!   r.   r$   r$   r%   Ú__repr__U   s   ÿþýüûúùzBaseCache.__repr__N©r   r   r   r   r   r   r   r   ©r'   r(   r)   r(   r   r*   ©r   r   )r   r0   )r4   Ú
__module__Ú__qualname__Ú__doc__r   Ú__annotations__r&   r-   r/   r2   r5   r$   r$   r$   r%   r   #   s   
 



	
r   c                      sV   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 )(Ú	MMapCacheaæ  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

    Parameters
    ----------
    blocksize: int
        How far to read ahead in numbers of bytes
    fetcher: Fetcher
        Function of the form f(start, end) which gets bytes from remote as
        specified
    size: int
        How big this file is
    location: str
        Where to create the temporary file. If None, a temporary file is
        created using tempfile.TemporaryFile().
    blocks: set[int]
        Set of block numbers that have already been fetched. If None, an empty
        set is created.
    multi_fetcher: MultiFetcher
        Function of the form f([(start, end)]) which gets bytes from remote
        as specified. This function is used to fetch multiple blocks at once.
        If not specified, the fetcher function is used instead.
    ÚmmapNr   r   r   r   r   Úlocationú
str | NoneÚblocksúset[int] | NoneÚmulti_fetcherúMultiFetcher | Noner   r   c                   s>   t ƒ  |||¡ |d u rtƒ n|| _|| _|| _|  ¡ | _d S ©N)Úsuperr&   ÚsetrA   r?   rC   Ú	_makefileÚcache)r#   r   r   r   r?   rA   rC   ©r3   r$   r%   r&   �   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   Ú	bytearrayr?   ÚosÚpathÚexistsÚTemporaryFilerG   rA   ÚopenÚseekÚwriteÚflushÚfileno)r#   r>   rN   Úfdr$   r$   r%   rH   �   s   




zMMapCache._makefiler'   r(   Úendr*   c                   s  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  _g }tt|ƒd	d
„ d�D ]W\}}	t	t
tdƒ|	ƒƒ}	|	d ˆ j }
t|	d ˆ j ˆ j ˆ jƒ}ˆ  j||
 7  _t  d|	d › d|	d › d|
› d|› d�	¡ | |
|f¡ ˆ j |	¡ ˆ  jt|	ƒ7  _qY|sºˆ j||… S ˆ jrêt  d|› �¡ tˆ  |¡ƒD ]\}}|| \}
}t  d|
› d|› �¡ |ˆ j|
|…< qÌn|D ]\}
}t  d|
› d|› �¡ ˆ  |
|¡ˆ j|
|…< qìˆ j||… S )NzMMap cache fetching ú-r   r+   rL   c                 3  s   � | ]
}|ˆ j vr|V  qd S rE   ©rA   ©Ú.0Úir.   r$   r%   Ú	<genexpr>²   ó   € z#MMapCache._fetch.<locals>.<genexpr>c                 3  s   � | ]
}|ˆ j v rd V  qdS )rL   Nr\   r]   r.   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 (ú)zMMap copy block (zMMap get block ()ÚloggerÚdebugr   r   Úranger   Úsumr   Ú	enumerateÚtupleÚmapr   Úminr!   ÚappendrA   Úupdater    ÚlenrI   rC   r   )r#   r'   rZ   Zstart_blockZ	end_blockZblock_rangeZneedÚrangesÚ_Z_blocksZsstartÚsendÚidxÚrr$   r.   r%   r-   ¦   sJ   

 
$ÿýzMMapCache._fetchúdict[str, Any]c                 C  ó   | j  ¡ }|d= |S )NrI   ©Ú__dict__Úcopy©r#   Ústater$   r$   r%   Ú__getstate__ä   s   
zMMapCache.__getstate__r}   c                 C  s   | j  |¡ |  ¡ | _d S rE   )rz   rp   rH   rI   r|   r$   r$   r%   Ú__setstate__ê   s   zMMapCache.__setstate__)NNN)r   r   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   )r4   r9   r:   r;   r   r&   rH   r-   r~   r   Ú__classcell__r$   r$   rJ   r%   r=   b   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).
    Z	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    rq   rn   r   r!   r   )r#   r'   rZ   ÚlÚpartr$   r$   r%   r-      s.   zReadAheadCache._fetchr6   r€   ©r4   r9   r:   r;   r   r&   r-   rƒ   r$   r$   rJ   r%   r…   ð   s
    r…   c                      s\   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	dd„ Z
‡  ZS )&ÚAdaptiveReadaheadCacheaß  Cache with adaptive asynchronous prefetching.

    Optimized for sequential and near-sequential reads by dynamically
    adjusting the amount of data prefetched in the background. The cache
    uses the generic prefetch engine when async loop support is available,
    and falls back to ``ReadAheadCache`` when it is not.

    Parameters
    ----------
    blocksize: int
        Nominal read size used by callers.
    fetcher: Fetcher
        Function of the form ``f(start, end)`` that returns bytes.
    size: int
        Total size of the file.
    concurrency: int
        Maximum number of concurrent background fetch tasks.
    max_prefetch_size: int | None
        Optional upper bound for adaptive prefetch size in bytes.
    Úadaptiveé   Nr   r   r   r   r   ÚconcurrencyÚmax_prefetch_sizer(   r   r   c           
   
     sä   t ƒ  |||¡ t|||ƒˆ _d ˆ _	dd‡ fdd	„}zdd
lm} W n ty4 } ztdƒ|‚d }~ww zddlm	}	 |	||||| 
¡ d�ˆ _t d||||¡ W d S  tyq } ztjd|dd� d ˆ _W Y d }~d S d }~ww )NrL   Ústart_offsetr   Ú
total_sizeÚsplit_factorr   r*   c                 “  s   �~t  ˆ j| | | ¡I d H S rE   )ÚasyncioÚ	to_threadr   )r�   r�   r‘   r.   r$   r%   Ú_default_fetcher_asyncB  s
   €
ÿz?AdaptiveReadaheadCache.__init__.<locals>._default_fetcher_async)Úasynz;AdaptiveReadaheadCache requires fsspec.asyn to be available)ÚBackgroundPrefetcher)r   r   r�   rŽ   Úloopz\AdaptiveReadaheadCache enabled (blocksize=%d, size=%d, concurrency=%d, max_prefetch_size=%s)z5AdaptiveReadaheadCache fallback to ReadAheadCache: %sT)Úexc_info)rL   )r�   r   r�   r   r‘   r   r   r*   )rF   r&   r…   Ú	_fallbackÚ_prefetcherr1   r•   ÚImportErrorZ
prefetcherr–   Úget_looprg   ÚinfoÚ	Exception)
r#   r   r   r   r�   rŽ   r”   Zfsspec_asynÚer–   rJ   r.   r%   r&   6  sP   ý
ÿþ€ÿû
ûý€úzAdaptiveReadaheadCache.__init__r'   rZ   r*   c                 C  sl   | j d u r| j ||¡}| jj| _| jj| _| jj| _|S | j  ||¡}|  jd7  _|  jt|ƒ7  _|S ©NrL   )rš   r™   r-   r   r    r!   Úfetchrq   )r#   r'   rZ   Úoutr$   r$   r%   r-   l  s   



zAdaptiveReadaheadCache._fetchc                 C  s"   | j d ur| j  ¡  d | _ d S d S rE   )rš   Úcloser.   r$   r$   r%   r£   y  s   


þzAdaptiveReadaheadCache.closerw   c                 C  s   |   ¡  | j ¡ }d |d< |S )Nrš   )r£   rz   r{   r|   r$   r$   r%   r~   ~  s   
z#AdaptiveReadaheadCache.__getstate__r}   c                 C  s   | j  |¡ d | _d S rE   )rz   rp   rš   r|   r$   r$   r%   r   …  s   
z#AdaptiveReadaheadCache.__setstate__c                 C  s$   z|   ¡  W d S  ty   Y d S w rE   )r£   rž   r.   r$   r$   r%   Ú__del__‰  s
   þzAdaptiveReadaheadCache.__del__)rŒ   N)r   r   r   r   r   r   r�   r   rŽ   r(   r   r   r€   r8   r�   r‚   )r4   r9   r:   r;   r   r&   r-   r£   r~   r   r¤   rƒ   r$   r$   rJ   r%   rŠ     s    ú
6


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  s8  |pd}|| j krt d¡ dS |d u r| j }t|| j ƒ}|| jk r†| jd u r^|  jd7  _|| jkrN|  j|7  _|  d|¡}|d | j… | _||d … S |  d| j¡| _|  j| j7  _| j||… }|| jkr}|  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-   ¡  s4   





zFirstChunkCache._fetchr6   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&   Ú  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_infor.   r$   r$   r%   rµ   â  ó   
	zBlockCache.cache_inforw   c                 C  rx   )Nr°   ry   r|   r$   r$   r%   r~   í  s   
zBlockCache.__getstate__r}   c                 C  s&   | j  |¡ t |d ¡| jƒ| _d S )Nrª   )rz   rp   r­   r®   r¯   r°   r|   r$   r$   r%   r   ò  s   
ÿzBlockCache.__setstate__r'   r(   rZ   r*   c                 C  sZ   |d u rd}|d u s|| j kr| j }|| j ks||krdS |  |||| j |d | j ¡S r†   )r   Ú_read_cacher   )r#   r'   rZ   r$   r$   r%   r-   ø  s   ÿzBlockCache._fetchÚblock_numberc                   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   r�   rF   r-   )r#   r¸   r'   rZ   Úblock_contentsrJ   r$   r%   r¯     s   
ÿÿ

zBlockCache._fetch_blockÚstart_block_numberÚend_block_numberc           	      C  s    || j  }|| j  }|dkr| j }|  jd7  _||kr'|  |¡}|||… S |  |¡|d… g}| t| jt|d |ƒƒ¡ | |  |¡d|… ¡ d |¡S )úú
        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.
        r   rL   Nr+   ©r   r   r°   Úextendrm   ri   ro   Újoin©	r#   r'   rZ   r¾   r¿   Ú	start_posÚend_posÚblockr¢   r$   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*   )r4   r9   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&   P  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   rq   rÌ   )r#   r'   rZ   ÚoffsetZbendÚnewr¢   Únumr$   r$   r%   r-   Y  sn   







zBytesCache._fetchc                 C  ó
   t | jƒS rE   )rq   rI   r.   r$   r$   r%   Ú__len__¢  s   
zBytesCache.__len__)T)
r   r   r   r   r   r   rÌ   rÍ   r   r   r€   )r   r   )
r4   r9   r:   r;   r   r<   r&   r-   rÒ   rƒ   r$   r$   rJ   r%   rË   A  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 r    )r   r§   r,   r$   r$   r%   r-   ¹  s   zAllBytes._fetch)NNNN)
r   r(   r   rÕ   r   r(   r§   rÖ   r   r   r7   )	r4   r9   r:   r;   r   r<   r&   r-   rƒ   r$   r$   rJ   r%   rÓ   ¦  s   
 ûrÓ   c                      st   e Zd ZU dZdZded< 		d!d"‡ fdd„Zedd„ ƒZej	dd„ ƒZedd„ ƒZ
e
j	dd„ ƒZ
d#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   NFr   r   r   r   r   r§   ú#dict[tuple[int, int], bytes] | NoneÚstrictrÍ   rs   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Úpopro   ÚdictÚzipr§   )r#   r   r   r   r§   rÚ   rs   Zold_offsetsÚoffsetsrA   r'   r)   Zstart0Zstop0rJ   r$   r%   r&   ×  s   	

zKnownPartsOfAFile.__init__c                 C  s   t dd„ | jD ƒƒS )Nc                 s  s    � | ]}|d  |d  V  qdS )rL   r   Nr$   )r^   rs   r$   r$   r%   r`   ÷  s   € z)KnownPartsOfAFile.size.<locals>.<genexpr>)rj   r§   r.   r$   r$   r%   r   õ  s   zKnownPartsOfAFile.sizec                 C  ó   d S rE   r$   ©r#   Úvaluer$   r$   r%   r   ù  ó   c                 C  rÑ   rE   )rq   r§   r.   r$   r$   r%   r   ý  s   
zKnownPartsOfAFile.nblocksc                 C  rá   rE   r$   râ   r$   r$   r%   r     rä   r'   r(   r)   r   r*   c           	      C  s
  t  d||¡ |d u rd}|d u r| j}|  j|| 7  _d}d}d}t| jƒD ]Â\}}||  kr6|k r`n n(||  krB|kr`n n|| }|  jd7  _| j||f ||| | …   S ||krf n…|r€||kr€|  jd7  _| jrxt	‚|d||  7 }||  krŠ|k r©n n|  jd7  _|| }| j||f ||| | … }d}n?||k rÂ||krÂ|  jd7  _|| j||f 7 }n&||  krÌ|krèn n|  jd7  _|| j||f d || …  }|  S |}q(|  jd7  _|�r| j�s|d||   }|S t	‚)NzKnown parts request %s %sr   r+   FrL   ó    T)
rg   rh   r   r!   rÛ   r§   r   r    rÚ   r¼   )	r#   r'   r)   r¢   ÚstartedZloc_oldZloc0Zloc1Úoffr$   r$   r%   r-     sN   0"zKnownPartsOfAFile._fetch)NF)r   r   r   r   r   r   r§   rÙ   rÚ   rÍ   rs   r
   r7   )r4   r9   r:   r;   r   r<   r&   Úpropertyr   Úsetterr   r-   rƒ   r$   r$   rJ   r%   r×   ¾  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 )%ÚUpdatableLRUzh
    Custom implementation of LRU cache that allows updating keys

    Used by BackgroundBlockCache
    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)r4   r9   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&   A  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ú   rq   rø   Úpopitem)r#   rþ   r   Úresultr$   r$   r%   Ú__call__I  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ö   rq   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ø   rq   rö   rù   rú   r.   r$   r$   r%   rµ   f  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ë   )r4   r9   r:   r;   r   rð   r&   r  r	  r
  rµ   r$   r$   r$   r%   rê   4  s    


rê   c                      s€   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d„Zd0d1‡ fd$d%„Zd2d(d)„Z‡  ZS )3Ú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                   s`   t ƒ  |||¡ t || ¡| _|| _t| j|ƒ| _t	dd�| _
d | _d | _t ¡ | _d| _d S )NrL   ©Úmax_workersF)rF   r&   r«   r¬   r   rª   rê   r¯   r°   r   Ú_thread_executorÚ_fetch_future_block_numberÚ_fetch_futurerû   rü   Ú_fetch_future_lockÚ_closedr±   rJ   r$   r%   r&   Œ  s   

zBackgroundBlockCache.__init__rë   c                 C  r²   r³   r´   r.   r$   r$   r%   rµ   š  r¶   zBackgroundBlockCache.cache_infoc                 C  s~   | j �  | jr	 W d  ƒ dS d| _| j}d| _d| _W d  ƒ n1 s&w   Y  |dur3| ¡  | jjddd� | `dS )z8Cancel pending work and shut down the background worker.NT)ÚwaitÚcancel_futures)r  r  r  r  Úcancelr  Úshutdownr°   )r#   Úfuturer$   r$   r%   r£   ¥  s   þúzBackgroundBlockCache.closerw   c                 C  s,   | j  ¡ }|d= |d= |d= |d= |d= |S )Nr°   r  r  r  r  ry   r|   r$   r$   r%   r~   ¶  s   
z!BackgroundBlockCache.__getstate__c                 C  sJ   | j  |¡ t| j|d ƒ| _tdd�| _d | _d | _t	 
¡ | _d| _d S )Nrª   rL   r  F)rz   rp   rê   r¯   r°   r   r  r  r  rû   rü   r  r  r|   r$   r$   r%   r   ¿  s   

z!BackgroundBlockCache.__setstate__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 }|| j }d }d }| j�M | jd urt| jd us;J ‚| j ¡ rWt d¡ | j 	| j 
¡ | j¡ d | _d | _nt|| j  kob|kn  ƒ}|rt| j}| j}d | _d | _W d   ƒ n1 s~w   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   Úasync)r¾   r¿   )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_infor0   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¯     s   
ÿÿ

z!BackgroundBlockCache._fetch_blockr¾   r¿   c           	      C  s’   || j  }|| j  }|  jd7  _||kr |  |¡}|||… S |  |¡|d… g}| t| jt|d |ƒƒ¡ | |  |¡d|… ¡ d |¡S )rÀ   rL   Nr+   rÁ   rÄ   r$   r$   r%   r·   &  s   


þÿ
z BackgroundBlockCache._read_cacherÈ   rÉ   r  r8   r�   r€   )r  )r¸   r   r  r0   r   r*   rÊ   )r4   r9   r:   r;   r   r<   r&   rµ   r£   r~   r   r-   r¯   r·   rƒ   r$   r$   rJ   r%   r  p  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_cacheW  s   r#  )F)r   r!  r"  rÍ   r   r   )5Ú
__future__r   r’   rõ   r­   Úloggingr«   rP   rû   r   Úcollections.abcr   Úconcurrent.futuresr   r   Ú	itertoolsr   Úoperatorr   Útypingr	   r
   r   r   r   r   r>   Útyping_extensionsr   r   r   Ú	getLoggerrg   r   r*   r   ÚlistZMultiFetcherr   r=   r…   rŠ   r¥   r¨   rË   rÓ   r×   rê   r  r  r<   r#  Úcr$   r$   r$   r%   Ú<module>   sj     

? .s0 ev< dþö
ô