Ë
    F^(hô…  ã            	      ó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       úL/var/www/skyplay_api_hub/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Øˆ<Ø—9‘9ˆDØ�D—I‘IÒ ¨$¢ØØ�|‰|˜E 4Ó(Ð(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àØ�T—Y‘Y�K˜r $§.¡.Ð!1°¸¿¹Ð8IÈÐSW×SmÑSmÐRnð  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ð +Ø!ŸY™Y˜Kð (Ø!Ÿ^™^Ð,ð -Ø!Ÿ_™_Ð-ð .$Ø$(×$>Ñ$>Ð#?ð @	ðð 	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   ø€ ô 	‰Ñ˜ G¨TÔ2Ø%˜~”c”e°6ˆŒØ ˆŒØ*ˆÔØ—^‘^Ó%ˆ�
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À   € ÛÛà�9‰9˜Š>Ü“;Ðð �=‰=Ð ¬¯©¯©°t·}±}Ô(EØ�}‰}Ð$Ø×+Ñ+Ó-�Ü!›e�•ä˜$Ÿ-™-¨Ó/�Ø�G‰G�D—I‘I ‘MÔ"Ø�H‰H�TŒNØ�H‰H�Jä�d—m‘m UÓ+ˆBàˆt�y‰y˜Ÿ™› d§i¡iÓ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   øè ø€ ÒI A¸¸T¿[¹[Ò8HœaÑIùrh   c                ó   — | d   | d   z
  S )Nr   rR   rD   )Úxs    r$   ú<lambda>z"MMapCache._fetch.<locals>.<lambda>È   s   € ÀÀ1ÁÈÈ!ÉÁ€ r&   )Úkeyéÿÿÿÿz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  ø€ Ü�‰Ð+¨E¨7°!°C°5Ð9Ô:Øˆ=ØˆEØˆ;Ø—)‘)ˆCØ�D—I‘IÒ ¨#¢ØØ˜tŸ~™~Ñ-ˆØ˜4Ÿ>™>Ñ)ˆ	Ü˜K¨°Q©Ó7ˆã?˜;Ô?ˆà�Šœ#ÓI¨ÔIÓIÑI�àˆô "¤)¨D£/Ñ7LÔMò 	,‰JˆAˆwäœC¤
¨1£¨wÓ7Ó8ˆGà˜Q‘Z $§.¡.Ñ0ˆFä�w˜r‘{ T§^¡^Ñ3°d·n±nÑDÀdÇiÁiÓPˆDð ×&Ò&¨$°©-Ñ7Õ&Ü�L‰LØ" 7¨1¡: ,¨a°¸±¨}¸B¸v¸hÀaÈÀvÈQÐOôð �M‰M˜6 4˜.Ô)ð �K‰K×Ñ˜wÔ'à�OŠOœs 7›|Ñ+ŽOð%	,ñ( Ø—:‘:˜e CÐ(Ð(à×ÒÜ�L‰LÐ+¨F¨8Ð4Ô5Ü# D×$6Ñ$6°vÓ$>Ó?ò ,‘��QØ!'¨¡‘�˜Ü—‘Ð0°°¸¸$¸Ð@ÔAØ*+�—
‘
˜6 $Ñ'ñ,ð
 !'ò E‘�˜Ü—‘Ð/°¨x°q¸¸Ð?Ô@Ø*.¯,©,°v¸tÓ*D�—
‘
˜6 $Ñ'ðEð �z‰z˜% Ð$Ð$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)   ø€ Ü‰Ñ˜ G¨TÔ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Ø�D—I‘IÒ ¨#¢ØØ�%‰KˆØ�D—J‘JÒ 3¨$¯(©(¢?à�NŠN˜aÑ�NØ—:‘:˜e d§j¡jÑ0°3¸¿¹Ñ3CÐDÐDØ�Z‰Z˜5Ô+ 4§8¡8Õ+à�OŠO˜qÑ �OØ—:‘:˜e d§j¡jÑ0Ð2Ð3ˆDØ”�T“‰NˆAØ—H‘H‰Eð �OŠO˜qÑ �OØˆDÜ�$—)‘)˜S 4§>¡>Ñ1Ó2ˆØ×"Ò" c¨E¡kÑ1Õ"Ø—\‘\ %¨Ó-ˆŒ
ØˆŒ
Ø—:‘:¤ D§J¡J£Ñ/ˆŒØ�d—j‘j  !�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 )Ú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.
    Úfirstc                óD   •— ||kD  r|}t         ‰| �  |||«       d | _        y rI   )rJ   r%   rP   r™   s       €r$   r%   zFirstChunkCache.__init__/  s(   ø€ Ø�tÒàˆIÜ‰Ñ˜ G¨TÔ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  € Ø’
˜ˆØ�4—9‘9ÒÜ�L‰LÐGÔHØä�#�t—y‘yÓ!ˆà�4—>‘>Ó!Ø�z‰zÐ!Ø—’ 1Ñ$•Ø˜Ÿ™Ò'Ø×.Ò.°#Ñ5Õ.ØŸ<™<¨¨3Ó/�DØ!%Ð&6¨¯©Ð!7�D”JØ  ˜<Ð'Ø!Ÿ\™\¨!¨T¯^©^Ó<�”
Ø×*Ò*¨d¯n©nÑ<Õ*Ø—:‘:˜e CÐ(ˆDØ�T—^‘^Ò#Ø×*Ò*¨c°D·N±NÑ.BÑBÕ*Ø˜Ÿ™ T§^¡^°SÓ9Ñ9�Ø�NŠN˜aÑ�NØˆKà�OŠO˜qÑ �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   ø€ ô 	‰Ñ˜ G¨TÔ2Ü—y‘y ¨	Ñ!1Ó2ˆŒØ"ˆŒØ#A¤9×#6Ñ#6°yÓ#AÀ$×BSÑBSÓ#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Ô#Ø#J¤9×#6Ñ#6°u¸[Ñ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Ø�D—I‘IÒ ¨#¢Øð # d§n¡nÑ4ÐØ $§.¡.Ñ0Ðô "Ð"4Ð6FÈÑ6JÓKò 	3ˆLØ×$Ñ$ \Õ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Ÿ~™~Ñ-ˆØ�d—n‘nÑ$ˆØ×"Ò" c¨E¡kÑ1Õ"Ø�Š˜1Ñ�Ü�‰Ð2°LÔ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Ñ   € ð ˜DŸN™NÑ*ˆ	Ø˜Ÿ™Ñ&ˆà�Š˜!Ñ�ØÐ!1Ò1Ø×3Ñ3Ð4FÓGˆEØ˜ 7Ð+Ð+ð ×+Ñ+Ð,>Ó?À	À
ÐKÐLˆCð
 �J‰JÜØ×,Ñ,ÜÐ,¨qÑ0Ð2BÓCóôð �J‰J�t×/Ñ/Ð0@ÓAÀ(À7ÐKÔLà—8‘8˜C“=Ð 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   ø€ ô 	‰Ñ˜ G¨TÔ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Ø�D—I‘IÒ ¨#¢Øà�J‰JÐ"Ø˜Ÿ™Ò#Ø—‘Ð$Ø�d—h‘h’ð ˜TŸZ™ZÑ'ˆFØ�NŠN˜aÑ�NØ—:‘:˜f v°¡|°eÑ';Ð<Ð<à�>Š>Ü�t—y‘y #¨¯©Ñ"6Ó7‰DàˆDà�5Š=˜E D§I¡IÒ-Øà�J‰JÐ %¨$¯*©*Ò"4Ø�H‰HÐ  d§h¡h¢ð ×&Ò&¨$°©,Ñ6Õ&Ø�OŠO˜qÑ �OØŸ™ e¨TÓ2ˆDŒJØˆDŽJà—:‘:Ð)Ð)Ð)Ø—8‘8Ð'Ð'Ð'Ø�OŠO˜qÑ �Oà�t—z‘zÒ!Ø—8‘8Ð# t§x¡x°#¡~¸¿¹Ò'FØ×.Ò.°$¸±,Ñ>Õ.Ø!%§¡¨e°TÓ!:�D”JØ!&�D–Jà×.Ò.°$·*±*¸uÑ2DÑDÕ.ØŸ,™, u¨d¯j©jÓ9�CØ!&�D”JØ!$ t§z¡zÑ!1�D•JØ—‘Ð%¨$°·±ª/Ø—8‘8˜dŸi™iÒ'ØØ˜4Ÿ8™8‘^ d§n¡nÒ4Ø×.Ò.°$¸±,Ñ>Õ.Ø!%§¡¨e°TÓ!:�D”JØ!&�D•Jà×.Ò.°$¸¿¹±/ÑAÕ.ØŸ,™, t§x¡x°Ó6�CØ!%§¡¨cÑ!1�D”Jà—:‘:¤ D§J¡J£Ñ/ˆŒØ˜Ÿ™Ñ#ˆØ�j‰j˜ &¨3¡,°Ñ"6Ð7ˆØ�9Š9Ø—8‘8˜dŸj™jÑ(¨d¯n©n¸qÑ.@ÑAˆCØ�QŠwØ—
’
˜dŸn™n¨sÑ2Ñ2•
Ø!ŸZ™Z¨¯©¸Ñ(<Ð(>Ð?�”
Øˆ
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   ø€ ô 	‰Ñ˜ G¨TÔ2Øˆ<Ø�OŠO˜qÑ �OØ×&Ò&¨$¯)©)Ñ3Õ&Ø—<‘<  4§9¡9Ó-ˆDØˆ�	r&   c                óJ   — | xj                   dz  c_         | j                  || S )NrR   )r    r¤   r(   s      r$   r+   zAllBytes._fetchU  s!   € Ø�Š˜!Ñ�Ø�y‰y˜˜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         ‰| �  |||«       || _        |rÄt        |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í   ø€ ô 	‰Ñ˜ G¨TÔ2ØˆŒñ Ü  §¡£Ó-ˆKØ" 1‘~Ð&ˆGØ—h‘h˜{¨1™~Ó.Ð/ˆFØ*¨1¨2˜ò ;‘��tØ '¨¡‘�˜Ø˜E’>Ø#)¨4 .�G˜B‘KØ˜2“J $§(¡(¨E°4¨=Ó"9Ñ9”Jà—N‘N E¨4 =Ô1Ø—M‘M $§(¡(¨E°4¨=Ó"9Õ:ð;ô œS ¨&Ó1Ó2ˆD�IàˆD�Ir&   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Øˆ<Ø—9‘9ˆDàˆØ"&§)¡)§/¡/Ó"3ò 	Ñ‰LˆT�4˜$ð �uÔ#˜tÖ#Ø˜d‘l�Ø˜3  t¡¨eÑ!3Ð4�Ø—{’{ d¨dÔ&:°dÕ&:ð
 ˜7 d¨U¡l´S¸³XÑ&=Ñ>Ñ>�CØ—N’N aÑ'•NØ’Jð
 !�EÙð'	ð0 �<‰<ÐäÐEÀuÈdÀmÀ_ÐTVÐWÓXÐXô 	�‰Ø4°e¸T°]°Oð D2ð 3ô	
ô 	�‰Ð8¸¸¸qÀÀÐGÔHØ×"Ò" d¨U¡lÑ2Õ"Ø�Š˜1Ñ�Ø”U‘W‘^ E¨4Ó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Ø�Z‰Zñ 	)Ø�t—{‘{Ñ"Ø—‘×'Ñ'¨Ô-Ø—
’
˜a‘•
Ø—{‘{ 4Ñ(÷		)ñ 	)Ø"÷	)ð �—‘˜TÐ, VÑ,ˆà�Z‰Zñ 	0Ø &ˆD�K‰K˜ÑØ�LŠL˜AÑ�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*   € Ø�Z‰Zñ 	'Ø˜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   € Ø�Z‰Zñ 	0Ø &ˆD�K‰K˜ÑÜ�4—;‘;Ó $§.¡.Ò0Ø—‘×#Ñ#¨Ð#Ô/÷	0÷ 	0ñ 	0ús   �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   € Ø�Z‰Zñ 	Ø—>‘>ØŸ™Ü˜TŸ[™[Ó)Ø—Z‘ZØ—|‘|ð	 "ó ÷	÷ 	ò 	ú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   ø€ ô 	‰Ñ˜ G¨TÔ2Ü—y‘y ¨	Ñ!1Ó2ˆŒØ"ˆŒÜ#/°×0AÑ0AÀ9Ó#MˆÔ ä 2¸qÔ 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Ô#Ü#/°×0AÑ0AÀ5ÈÑCUÓ#VˆÔ Ü 2¸qÔ 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Ø�D—I‘IÒ ¨#¢Øð # d§n¡nÑ4ÐØ $§.¡.Ñ0Ðà$(Ð!ØˆØ×$Ñ$ñ 	2à×!Ñ!Ð-Ø×6Ñ6ÐBÐBÐBØ×%Ñ%×*Ñ*Ô,Ü—K‘KÐ UÔVØ×,Ñ,×4Ñ4Ø×*Ñ*×1Ñ1Ó3°T×5TÑ5Tôð 7;�DÔ3Ø)-�DÕ&ô !%Ø*Ø×:Ñ:ö,à+ô,ó!�Iñ
 !ð 59×4SÑ4SÐ1Ø'+×'9Ñ'9˜ð ;?˜Ô7Ø-1˜Ô*÷7	2ð< Ð#Ü�K‰KÐBÔCà×$Ñ$×,Ñ,Ø×#Ñ#Ó%Ð'@ôô
 "Ð"4Ð6FÈÑ6JÓKò 	3ˆLØ×$Ñ$ \Õ2ð	3ð
 ,¨aÑ/ÐØ×$Ñ$ñ 		à×"Ñ"Ð*Ø$¨¯©Ò4Ø×0Ñ0×>Ñ>Ð?OÔPà2B�Ô/Ø%)×%:Ñ%:×%AÑ%AØ×%Ñ%Ð'7¸ó&�Ô"÷		ð ×ÑØØØ1Ø-ð	  ó 
ð 	
÷o	2ñ 	2ú÷X		ð 		ú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Ÿ~™~Ñ-ˆØ�d—n‘nÑ$ˆÜ�‰Ð7¸À<ÔPØ×"Ò" c¨E¡kÑ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Ó   € ð ˜DŸN™NÑ*ˆ	Ø˜Ÿ™Ñ&ˆð 	�Š˜!Ñ�àÐ!1Ò1Ø×,Ñ,Ð-?Ó@ˆEØ˜ 7Ð+Ð+ð ×+Ñ+Ð,>Ó?À	À
ÐKÐLˆCð
 �J‰JÜØ×,Ñ,ÜÐ,¨qÑ0Ð2BÓCóôð �J‰J�t×/Ñ/Ð0@ÓAÀ(À7ÐKÔLà—8‘8˜C“=Ð 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Ø'.ð3Ø69ð3ØFIð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=   € ð �8‰8€DÙ�tœv‘~ÜÐ+¨D¨8Ð3FÄvÈdÁ|ÀnÐUÓVÐVØ„Fˆ4‚Lr&   )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áˆCƒL€ð 
ˆ×	Ñ	˜8Ó	$€à
�C˜�:˜uÐ$Ñ
%€Ø˜˜c 3˜h™Ð(¨%Ð/Ñ0€÷<ñ <ô~K&�	ô K&ô\+%�Yô +%ô\+,�iô +,ô\F!�ô F!ôRb�ô bôJ%ˆyô %ô0b1˜	ô b1ôJ9�7˜1˜a˜4‘=ô 9ôxK!˜9ô K!ð` 	ˆ)ð-€Ð)ó ôð( ØØØØØØØØð

ò €Añ �1Õñr&   