
    |;3h              	      h   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j>                  d
      Z ee!e!ge"f   Z#ee$e!e!f   ge"f   Z% G d d      Z& G d de&      Z' G d de&      Z( G d de&      Z) G d de&      Z* G d de&      Z+ G d de&      Z, G d de&      Z- G d deeef         Z. G d de&      Z/de&iZ0de1d <   d"d#d!Z2e&e'e+e(e*e)e,e-e/f	D ]
  Z3 e2e3        y)$    )annotationsN)FutureThreadPoolExecutor)groupby)
itemgetter)	TYPE_CHECKINGAnyCallableClassVarGeneric
NamedTupleOptionalOrderedDictTypeVar)	ParamSpecPTfsspecc                  H    e Zd ZU dZdZded<   ddZddZddZddZ	dd	Z
y
)	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]namec                f    || _         d| _        || _        || _        d| _        d| _        d| _        y Nr   )	blocksizenblocksfetchersize	hit_count
miss_counttotal_requested_bytes)selfr   r   r   s       N/var/www/html/audio-gradio/venv/lib/python3.12/site-packages/fsspec/caching.py__init__zBaseCache.__init__=   s4    "	%&"    c                t    |d}|| j                   }|| j                   k\  s||k\  ry| j                  ||      S )Nr   r&   )r   r   r#   startstops      r$   _fetchzBaseCache._fetchG   s@    =E<99DDII$||E4((r&   c                .    d| _         d| _        d| _        y)zAReset hit and miss counts for a more ganular report e.g. by file.r   N)r    r!   r"   r#   s    r$   _reset_statszBaseCache._reset_statsP   s    %&"r&   c           	         | j                   dk(  r| j                  dk(  ry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-   s    r$   
_log_statszBaseCache._log_statsV   s^    >>Q4??a#7TYYKr$..!18ISWSmSmRn  oE  F  	Fr&   c                    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-   s    r$   __repr__zBaseCache.__repr__]   s    

..
!
!	" #!^^, -!\\N +!YYK (!^^, -!__- .$$($>$>#? @	 	r&   Nr   intr   Fetcherr   r7   returnNoner)   
int | Noner*   r<   r9   bytesr9   r:   )r9   str)r4   
__module____qualname____doc__r   __annotations__r%   r+   r.   r1   r5    r&   r$   r   r   +   s-     !D- ')'F
r&   r   c                  j     e Zd ZdZdZ	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 d	 fdZd
dZddZddZddZ	 x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.
    mmapc                    t         |   |||       |
t               n|| _        || _        || _        | j                         | _        y N)superr%   setblockslocationmulti_fetcher	_makefilecache)r#   r   r   r   rM   rL   rN   r3   s          r$   r%   zMMapCache.__init__   sB     	GT2%~ce6 *^^%
r&   c                4   dd l }dd l}| j                  dk(  r
t               S | j                  )t
        j                  j                  | j                        s| j                   |j                         }t               | _
        nt        | j                  d      }|j                  | j                  dz
         |j                  d       |j                          nt        | j                  d      } |j                   |j                         | j                        S )Nr   zwb+      1zr+b)rG   tempfiler   	bytearrayrM   ospathexistsTemporaryFilerK   rL   openseekwriteflushfileno)r#   rG   rT   fds       r$   rO   zMMapCache._makefile   s    99>; == t}}(E}}$++-!e$--/GGDIIM"HHTNHHJdmmU+Btyydii00r&   c                     t         j                  d| d|        |d}| j                  }| j                  k\  s||k\  ry| j                  z  }| j                  z  }t	        ||dz         } fd|D        } xj
                  t         fd|D              z  c_        g }t        t        |      d 	      D ]  \  }}	t        t        t        d      |	            }	|	d    j                  z  }
t        |	d
    j                  z   j                  z    j                        } xj                  ||
z
  z  c_        t         j                  d|	d    d|	d
    d|
 d| d	       |j                  |
|f        j                  j!                  |	        xj"                  t%        |	      z  c_         |s j&                  || S  j(                  rmt         j                  d|        t         j)                  |            D ]7  \  }}||   \  }
}t         j                  d|
 d|        | j&                  |
| 9 nD|D ]?  \  }
}t         j                  d|
 d|         j+                  |
|       j&                  |
| A  j&                  || S )NzMMap cache fetching -r   r&   rR   c              3  @   K   | ]  }|j                   vs|  y wrI   rL   .0ir#   s     r$   	<genexpr>z#MMapCache._fetch.<locals>.<genexpr>   s     ?a!4;;*>?   c              3  @   K   | ]  }|j                   v sd   yw)rR   Nrc   rd   s     r$   rg   z#MMapCache._fetch.<locals>.<genexpr>   s     IAT[[8HaIrh   c                    | d   | d   z
  S )Nr   rR   rD   )xs    r$   <lambda>z"MMapCache._fetch.<locals>.<lambda>   s    1! r&   )keyzMMap get blocks z ()zMMap copy block (zMMap get block ()loggerdebugr   r   ranger    sumr   	enumeratetuplemapr   minr"   appendrL   updater!   lenrP   rN   r   )r#   r)   endstart_block	end_blockblock_rangeneedranges__blockssstartsendidxrs   `             r$   r+   zMMapCache._fetch   sy   +E7!C59:=E;))CDII#t~~-4>>)	KQ7?;?#IIII ")D/7LM 	,JAwC
1w78GQZ$..0Fwr{T^^3dnnDdiiPD &&$-7&LL"71:,a}BvhavQO MM64.) KKw'OOs7|+O%	,( ::eC((LL+F845#D$6$6v$>? ,Q!'0$@A*+

6$',
 !' E/xq?@*.,,vt*D

6$'E zz%$$r&   c                @    | j                   j                         }|d= |S )NrP   )__dict__copyr#   states     r$   __getstate__zMMapCache.__getstate__   s     ""$'Nr&   c                d    | j                   j                  |       | j                         | _        y rI   )r   ry   rO   rP   r   s     r$   __setstate__zMMapCache.__setstate__   s"    U#^^%
r&   )NNN)r   r7   r   r8   r   r7   rM   z
str | NonerL   zset[int] | NonerN   zMultiFetcher | Noner9   r:   )r9   zmmap.mmap | bytearrayr)   r<   r{   r<   r9   r=   r9   dict[str, Any]r   r   r9   r:   )r4   r@   rA   rB   r   r%   rO   r+   r   r   __classcell__r3   s   @r$   rF   rF   j   sx    8 D  $"&-1&& & 	&
 &  & +& 
&1,<%|&r&   rF   c                  0     e Zd ZdZdZd fdZddZ x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).
    	readaheadc                R    t         |   |||       d| _        d| _        d| _        y )Nr&   r   )rJ   r%   rP   r)   r{   r#   r   r   r   r3   s       r$   r%   zReadAheadCache.__init__  s)    GT2

r&   c                ^   |d}||| j                   kD  r| j                   }|| j                   k\  s||k\  ry||z
  }|| j                  k\  rM|| j                  k  r>| xj                  dz  c_        | j                  || j                  z
  || j                  z
   S | j                  |cxk  r| j                  k  rOn nL| xj
                  dz  c_        | j                  || j                  z
  d  }|t        |      z  }| j                  }n| xj
                  dz  c_        d}t        | j                   || j                  z         }| xj                  ||z
  z  c_	        | j                  ||      | _        || _        | j                  t        | j                        z   | _        || j                  d | z   S Nr   r&   rR   )r   r)   r{   r    rP   r!   rz   rw   r   r"   r   )r#   r)   r{   lparts        r$   r+   zReadAheadCache._fetch  se   =E;#		/))CDII#%KDJJ3$((?NNaN::edjj033CDDZZ5+488+OOq O::edjj023DTNAHHE OOq OD$))S4>>12""cEk1"\\%-

::DJJ/djj!n$$r&   r6   r   r4   r@   rA   rB   r   r%   r+   r   r   s   @r$   r   r      s     D%r&   r   c                  0     e Zd ZdZdZd fdZddZ xZS )FirstChunkCachezCaches 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.
    firstc                D    ||kD  r|}t         |   |||       d | _        y rI   )rJ   r%   rP   r   s       r$   r%   zFirstChunkCache.__init__/  s(    tIGT2#'
r&   c                n   |xs d}|| j                   kD  rt        j                  d       yt        || j                         }|| j                  k  r&| j
                  | xj                  dz  c_        || j                  kD  r@| xj                  |z  c_        | j                  d|      }|d | j                   | _        ||d  S | j                  d| j                        | _        | xj                  | j                  z  c_        | j
                  || }|| j                  kD  rA| xj                  || j                  z
  z  c_        || j                  | j                  |      z  }| xj                  dz  c_	        |S | xj                  dz  c_        | xj                  ||z
  z  c_        | j                  ||      S )Nr   z,FirstChunkCache: requested start > file sizer&   rR   )
r   rp   rq   rw   r   rP   r!   r"   r   r    )r#   r)   r{   datar   s        r$   r+   zFirstChunkCache._fetch6  sh   
499LLGH#tyy!4>>!zz!1$'..#5.<<3/D!%&6!7DJ<'!\\!T^^<
**dnn<*::eC(DT^^#**cDNN.BB*T^^S99NNaNKOOq O&&#+5&<<s++r&   r6   r   r   r   s   @r$   r   r   &  s     D(,r&   r   c                       e Zd ZdZdZ	 d
	 	 	 	 	 	 	 	 	 d fdZd ZddZddZddZ	d fdZ
	 	 	 	 	 	 	 	 	 	 dd	Z x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``.
    
blockcachec                    t         |   |||       t        j                  ||z        | _        || _         t        j                  |      | j                        | _	        y rI   )
rJ   r%   mathceilr   	maxblocks	functools	lru_cache_fetch_block_fetch_block_cachedr#   r   r   r   r   r3   s        r$   r%   zBlockCache.__init__m  sR     	GT2yy	!12"#A9#6#6y#A$BSBS#T r&   c                6    | j                   j                         S z
        The statistics on the block cache.

        Returns
        -------
        NamedTuple
            Returned directly from the LRU Cache used internally.
        r   
cache_infor-   s    r$   r   zBlockCache.cache_infou       ''2244r&   c                $    | j                   }|d= |S )Nr   r   r   s     r$   r   zBlockCache.__getstate__  s    '(r&   c                    | j                   j                  |        t        j                  |d         | j                        | _        y )Nr   )r   ry   r   r   r   r   r   s     r$   r   zBlockCache.__setstate__  s<    U##J9#6#6u[7I#J$
 r&   c                    |d}|| j                   }|| j                   k\  s||k\  ry|| j                  z  }|| j                  z  }t        ||dz         D ]  }| j                  |        | j	                  ||||      S )Nr   r&   rR   start_block_numberend_block_number)r   r   rr   r   _read_cache)r#   r)   r{   r   r   block_numbers         r$   r+   zBlockCache._fetch  s    =E;))CDII# #dnn4$..0 ""46F6JK 	3L$$\2	3 1-	   
 	
r&   c                @   || j                   kD  rt        d| d| j                    d      || j                  z  }|| j                  z   }| xj                  ||z
  z  c_        | xj                  dz  c_        t
        j                  d|       t        | !  ||      }|S )=
        Fetch the block of data for `block_number`.
        'block_number=(' is greater than the number of blocks (ro   rR   zBlockCache fetching block %d)	r   
ValueErrorr   r"   r!   rp   inforJ   r+   )r#   r   r)   r{   block_contentsr3   s        r$   r   zBlockCache._fetch_block  s     $,,&  /))-a9 
 t~~-dnn$""cEk1"12LAs3r&   c           	        || j                   z  }|| j                   z  }| xj                  dz  c_        ||k(  r| j                  |      }||| S | j                  |      |d g}|j                  t	        | j                  t        |dz   |                   |j                  | j                  |      d|        dj                  |      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.
        rR   Nr&   r   r    r   extendrv   rr   rx   join	r#   r)   r{   r   r   	start_posend_posblockouts	            r$   r   zBlockCache._read_cache  s     DNN*	&!!11334FGE7++ ++,>?	
KLC
 JJ,,,q02BC JJt//0@A(7KL88C= r&       
r   r7   r   r8   r   r7   r   r7   r9   r:   r   r   r   )r   r7   r9   r=   
r)   r7   r{   r7   r   r7   r   r7   r9   r=   )r4   r@   rA   rB   r   r%   r   r   r   r+   r   r   r   r   s   @r$   r   r   T  s    , D MOUU'.U69UFIU	U	5


.$&!&!"&!8;&!OR&!	&!r&   r   c                  Z     e Zd ZU dZdZded<   	 d	 	 	 	 	 	 	 	 	 d	 fdZd
dZddZ x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   c                `    t         |   |||       d| _        d | _        d | _        || _        y )Nr&   )rJ   r%   rP   r)   r{   trim)r#   r   r   r   r   r3   s        r$   r%   zBytesCache.__init__  s2     	GT2
!%
#	r&   c                   |d}|| j                   }|| j                   k\  s||k\  ry| j                  c|| j                  k\  rT| j                  H|| j                  k  r9|| j                  z
  }| xj                  dz  c_        | j                  |||z   |z
   S | j
                  r$t        | j                   || j
                  z         }n|}||k(  s|| j                   kD  ry| j                  || j                  k  rh| j                  || j                  kD  rM| xj                  ||z
  z  c_        | xj                  dz  c_        | j                  ||      | _        || _        n| j                  J | j                  J | xj                  dz  c_        || j                  k  r| j                  | j                  |z
  | j
                  kD  r8| xj                  ||z
  z  c_        | j                  ||      | _        || _        n4| xj                  | j                  |z
  z  c_        | j                  || j                        }|| _        || j                  z   | _        n| j                  || j                  kD  r| j                  | j                   kD  rn|| j                  z
  | j
                  kD  r7| xj                  ||z
  z  c_        | j                  ||      | _        || _        nR| xj                  || j                  z
  z  c_        | j                  | j                  |      }| j                  |z   | _        | j                  t        | j                        z   | _        || j                  z
  }| j                  |||z   |z
   }| j                  rq| j                  | j                  z
  | j
                  dz   z  }|dkD  rC| xj                  | j
                  |z  z  c_        | j                  | j
                  |z  d  | _        |S r   )r   r)   r{   r    rP   r   rw   r"   r!   r   rz   r   )r#   r)   r{   offsetbendnewr   nums           r$   r+   zBytesCache._fetch  sJ    =E;))CDII#JJ"#$dhh TZZ'FNNaN::fv|e';<<>>tyy#"67DD5=EDII-JJ%$**"4HHdhh &&$,6&OOq OeT2DJDJ::)))88'''OOq Otzz!88#txx#~'F..$,>.!%eT!:DJ!&DJ..$**u2DD.,,udjj9C!&DJ!$tzz!1DJ%$/88dii'488^dnn4..$,>.!%eT!:DJ!&DJ..$/A.,,txx6C!%c!1DJ::DJJ/#jj&3,"679988djj(dnnq.@ACQw

dnns22
!ZZ(<(>?

r&   c                ,    t        | j                        S rI   )rz   rP   r-   s    r$   __len__zBytesCache.__len__>  s    4::r&   )T)
r   r7   r   r8   r   r7   r   boolr9   r:   r   )r9   r7   )
r4   r@   rA   rB   r   rC   r%   r+   r   r   r   s   @r$   r   r     sT    
 "D-! IM'.69AE	GRr&   r   c                  X     e Zd ZU dZdZded<   	 	 	 	 d	 	 	 	 	 	 	 	 	 d fdZd	dZ xZS )
AllBytesz!Cache entire contents of the fileallr   r   c                    t         |   |||       |P| xj                  dz  c_        | xj                  | j                  z  c_        | j                  d| j                        }|| _        y )NrR   r   )rJ   r%   r!   r"   r   r   r   )r#   r   r   r   r   r3   s        r$   r%   zAllBytes.__init__G  sY     	GT2<OOq O&&$))3&<<499-D	r&   c                J    | xj                   dz  c_         | j                  || S )NrR   )r    r   r(   s      r$   r+   zAllBytes._fetchU  s!    !yyt$$r&   )NNNN)
r   r<   r   zFetcher | Noner   r<   r   zbytes | Noner9   r:   r;   	r4   r@   rA   rB   r   rC   r%   r+   r   r   s   @r$   r   r   B  sX    +D- !%"&!   	
  
%r&   r   c                  \     e Zd ZU dZdZded<   	 	 d	 	 	 	 	 	 	 	 	 	 	 d fdZd	 fdZ x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   c                   t         |   |||       || _        |rt        |j	                               }|d   g}|j                  |d         g}	|dd  D ]m  \  }
}|d   \  }}|
|k(  r&||f|d<   |	dxx   |j                  |
|f      z  cc<   9|j                  |
|f       |	j                  |j                  |
|f             o t        t        ||	            | _	        y i | _	        y )Nr   rR   rn   )
rJ   r%   strictsortedkeyspoprx   dictzipr   )r#   r   r   r   r   r   r   old_offsetsoffsetsrL   r)   r*   start0stop0r3   s                 r$   r%   zKnownPartsOfAFile.__init__s  s     	GT2  -K"1~&Ghh{1~./F*12 ;t 'E>#)4.GBK2J$((E4="99JNNE4=1MM$((E4="9:; S&12DIDIr&   c                t   |d}|| j                   }d}| j                  j                         D ]t  \  \  }}}||cxk  r|k  sn ||z
  }||||z   |z
   }| j                  r||cxk  r|k  r3n n0|d||z
  t	        |      z
  z  z  }| xj
                  dz  c_        |c S |} n | j                  t        d||f d      t        j                  d||f d       t        j                  d| d	|        | xj                  ||z
  z  c_        | xj                  dz  c_        |t        | =  ||      z   S )
Nr   r&       rR   z&Read is outside the known file parts: z. z%. IO/caching performance may be poor!z!KnownPartsOfAFile cache fetching ra   )r   r   itemsr   rz   r    r   r   warningswarnrp   rq   r"   r!   rJ   r+   )	r#   r)   r*   r   loc0loc1r   offr3   s	           r$   r+   zKnownPartsOfAFile._fetch  s]   =E<99D"&))//"3 	LT4$ u#t#dl3te!34{{dd&:d&:
 7dUlSX&=>>CNNa'NJ
 !E'	0 <<Eudm_TVWXX 	4eT]O D2 3	
 	8qGH""dUl2"1UW^E4000r&   )NT)r   r7   r   r8   r   r7   r   z&Optional[dict[tuple[int, int], bytes]]r   r   r   r	   r;   r   r   s   @r$   r   r   Z  se    , "D-! 8<  	
 5  <+1 +1r&   r   c                  P    e Zd ZdZ G d de      Zd
ddZddZddZddZ	ddZ
y	)UpdatableLRUzg
    Custom implementation of LRU cache that allows updating keys

    Used by BackgroudBlockCache
    c                  6    e Zd ZU ded<   ded<   ded<   ded<   y)UpdatableLRU.CacheInfor7   hitsmissesmaxsizecurrsizeN)r4   r@   rA   rC   rD   r&   r$   	CacheInfor     s    	r&   r  c                    t        j                         | _        || _        || _        d| _        d| _        t        j                         | _	        y r   )
collectionsr   _cache_func	_max_size_hits_misses	threadingLock_lock)r#   funcmax_sizes      r$   r%   zUpdatableLRU.__init__  s<    +6+B+B+D
!
^^%
r&   c                ^   |rt        d|j                                | j                  5  || j                  v rH| j                  j	                  |       | xj
                  dz  c_        | j                  |   cd d d        S 	 d d d         | j                  |i |}| j                  5  || j                  |<   | xj                  dz  c_        t        | j                        | j                  kD  r| j                  j                  d       d d d        |S # 1 sw Y   xY w# 1 sw Y   |S xY w)Nz Got unexpected keyword argument rR   Flast)	TypeErrorr   r  r  move_to_endr
  r  r  rz   r	  popitem)r#   argskwargsresults       r$   __call__zUpdatableLRU.__call__  s    >v{{}oNOOZZ 	)t{{"''-

a
{{4(		) 	)"	) T,V,ZZ 	0 &DKKLLAL4;;$..0###/		0 	) 	)	0 s   AD)A#D"D"D,c                b    | j                   5  || j                  v cd d d        S # 1 sw Y   y xY wrI   )r  r  )r#   r  s     r$   is_key_cachedzUpdatableLRU.is_key_cached  s*    ZZ 	'4;;&	' 	' 	's   %.c                    | j                   5  || j                  |<   t        | j                        | j                  kD  r| j                  j	                  d       d d d        y # 1 sw Y   y xY w)NFr  )r  r  rz   r	  r  )r#   r  r  s      r$   add_keyzUpdatableLRU.add_key  sV    ZZ 	0 &DKK4;;$..0###/	0 	0 	0s   AA$$A-c                    | j                   5  | j                  | j                  t        | j                        | j
                  | j                        cd d d        S # 1 sw Y   y xY w)N)r  r  r   r  )r  r  r	  rz   r  r
  r  r-   s    r$   r   zUpdatableLRU.cache_info  sP    ZZ 	>>T[[)ZZ||	 " 	 	 	s   AAA&N)   )r  zCallable[P, T]r  r7   r9   r:   )r  zP.argsr  zP.kwargsr9   r   )r  r	   r9   r   )r  r   r  r	   r9   r:   r9   r   )r4   r@   rA   rB   r   r  r%   r  r  r  r   rD   r&   r$   r   r     s,    J &&'0r&   r   c                       e Zd ZU dZdZded<   	 d	 	 	 	 	 	 	 	 	 d fdZddZddZddZ	dd	Z
dd fd
Z	 	 	 	 	 	 	 	 	 	 ddZ xZS )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   c                   t         |   |||       t        j                  ||z        | _        || _        t        | j                  |      | _        t        d      | _
        d | _        d | _        t        j                         | _        y )NrR   max_workers)rJ   r%   r   r   r   r   r   r   r   r   _thread_executor_fetch_future_block_number_fetch_futurer  r  _fetch_future_lockr   s        r$   r%   zBackgroundBlockCache.__init__  ss     	GT2yy	!12"#/0A0A9#M  2q A6:'37"+.."2r&   c                6    | j                   j                         S r   r   r-   s    r$   r   zBackgroundBlockCache.cache_info$  r   r&   c                <    | j                   }|d= |d= |d= |d= |d= |S )Nr   r(  r)  r*  r+  r   r   s     r$   r   z!BackgroundBlockCache.__getstate__/  s<    '($%.//"&'r&   c                    | j                   j                  |       t        | j                  |d         | _        t        d      | _        d | _        d | _        t        j                         | _        y )Nr   rR   r&  )r   ry   r   r   r   r   r(  r)  r*  r  r  r+  r   s     r$   r   z!BackgroundBlockCache.__setstate__8  sZ    U##/0A0A5CU#V  2q A*.'!"+.."2r&   c                   |d}|| j                   }|| j                   k\  s||k\  ry|| j                  z  }|| j                  z  }d }d }| j                  5  | j                  | j                  J | j                  j                         rbt        j                  d       | j                  j                  | j                  j                         | j                         d | _        d | _        nKt        || j                  cxk  xr |k  nc       }|r&| j                  }| j                  }d | _        d | _        d d d        |?t        j                  d       | j                  j                  |j                         |       t        ||dz         D ]  }| j                  |        |dz   }	| j                  5  | j                  ]|	| j                  k  rN| j                  j                  |	      s3|	| _        | j                  j!                  | j"                  |	d      | _        d d d        | j%                  ||||      S # 1 sw Y   xY w# 1 sw Y   +xY w)Nr   r&   z3BlockCache joined background fetch without waiting.z(BlockCache waiting for background fetch.rR   asyncr   )r   r   r+  r*  r)  donerp   r   r   r  r  r   rr   r   r  r(  submitr   r   )
r#   r)   r{   r   r   fetch_future_block_numberfetch_future	must_joinr   end_block_plus_1s
             r$   r+   zBackgroundBlockCache._fetch@  s^   =E;))CDII# #dnn4$..0$(!$$ 	2!!-66BBB%%**,KK UV,,44**113T5T5T 7;D3)-D& !%*::,+,!I
 ! 594S4S1'+'9'9 ;?7-1*7	2< #KKBC$$,,##%'@
 ""46F6JK 	3L$$\2	3
 ,a/$$ 		""*$400>>?OP2B/%)%:%:%A%A%%'7&"		 1-	   
 	
o	2 	2X		 		s   C"H>7A*I>IIc                B   || j                   kD  rt        d| d| j                    d      || j                  z  }|| j                  z   }t        j	                  d||       | xj
                  ||z
  z  c_        | xj                  dz  c_        t        | !  ||      }|S )r   r   r   ro   z!BlockCache fetching block (%s) %drR   )	r   r   r   rp   r   r"   r!   rJ   r+   )r#   r   log_infor)   r{   r   r3   s         r$   r   z!BackgroundBlockCache._fetch_block  s     $,,&  /))-a9 
 t~~-dnn$7<P""cEk1"1s3r&   c           	        || j                   z  }|| j                   z  }| xj                  dz  c_        ||k(  r| j                  |      }||| S | j                  |      |d g}|j                  t	        | j                  t        |dz   |                   |j                  | j                  |      d|        dj                  |      S r   r   r   s	            r$   r   z BackgroundBlockCache._read_cache  s     DNN*	& 	!!11,,-?@E7++ ++,>?	
KLC
 JJ,,,q02BC JJt//0@A(7KL88C= r&   r   r   r!  r   r>   r   )sync)r   r7   r8  r?   r9   r=   r   )r4   r@   rA   rB   r   rC   r%   r   r   r   r+   r   r   r   r   s   @r$   r#  r#    s    2 'D-& MO33'.3693FI3	3	53J
X$(!(!"(!8;(!OR(!	(!r&   r#  z!dict[str | None, type[BaseCache]]cachesc                r    | j                   }|s |t        v rt        d|dt        |          | t        |<   y)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   )clsclobberr   s      r$   register_cacher?    s=     88Dtv~+D83Fvd|nUVVF4Lr&   )F)r=  ztype[BaseCache]r>  r   r9   r:   )4
__future__r   r  r   loggingr   rV   r  r   concurrent.futuresr   r   	itertoolsr   operatorr   typingr   r	   r
   r   r   r   r   r   r   rG   typing_extensionsr   r   r   	getLoggerrp   r7   r=   r8   listMultiFetcherr   rF   r   r   r   r   r   r   r   r#  r;  rC   r?  crD   r&   r$   <module>rK     s   "     	   9  
 
 
 +#AACL 
		8	$
C:u$
%c3h(%/0< <~K&	 K&\+%Y +%\+,i +,\F! F!Rb bJ%y %0b1	 b1J971a4= 9xK!9 K!` 	)-) ( 

 A 1r&   