Ë
    F^(hÄY  ã                  ó”  — 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 d dlmZmZmZmZmZmZmZmZ d dlmZ erd dlZd dlmZ d d	lmZ d
Z ed«      Z 	 d'	 	 	 	 	 d(d„Z!	 d'	 	 	 	 	 d)d„Z"i Z#de$d<   d*d„Z%d+d„Z&d,d„Z'	 	 d-	 	 	 	 	 	 	 	 	 	 	 d.d„Z(d/d„Z)d0d„Z*	 	 	 	 	 	 	 	 d1d„Z+d2d„Z,	 	 d3	 	 	 	 	 	 	 	 	 d4d„Z-d5d„Z.d6d„Z/d7d„Z0d8d„Z1d9d„Z2	 	 	 	 d:	 	 	 	 	 	 	 	 	 d;d„Z3d<d„Z4	 	 	 	 	 	 d=d „Z5ejl                  d>d!„«       Z7	 	 	 d?	 	 	 	 	 	 	 	 	 	 	 	 	 d@d"„Z8dAd#„Z9ejl                  dBdCd$„«       Z:d%„ Z;d&„ Z<y)Dé    )ÚannotationsN)Úpartial)Úmd5)Úversion)ÚIOÚTYPE_CHECKINGÚAnyÚCallableÚIterableÚIteratorÚSequenceÚTypeVar)Úurlsplit)Ú	TypeGuard)ÚAbstractFileSystemi  P ÚTc                óŠ  — t        j                  d| «      st        j                  d| «      €d| dœS t        | «      }|j                  xs d}|j                  r(dj                  |j                  |j                  g«      }n|j                  }|dk(  r2t        j                  d|«      }|r|j                  «       \  }}|› d|› �}|dv r|| dœS ||dœ}|j                  r¡|j                  j                  d	d
«      d   j                  dd
«      d   |d<   |dv r|d   |d   z   |d<   n|d   |d<   |j                  r|j                  |d<   |j                  r|j                  |d<   |j                  r|j                  |d<   |j                  r|j                  |d<   |j                  r|j                  |d<   |rt        ||«       |S )a«  Infer storage options from URL path and merge it with existing storage
    options.

    Parameters
    ----------
    urlpath: str or unicode
        Either local absolute file path or URL (hdfs://namenode:8020/file.csv)
    inherit_storage_options: dict (optional)
        Its contents will get merged with the inferred information from the
        given path

    Returns
    -------
    Storage options dict.

    Examples
    --------
    >>> infer_storage_options('/mnt/datasets/test.csv')  # doctest: +SKIP
    {"protocol": "file", "path", "/mnt/datasets/test.csv"}
    >>> infer_storage_options(
    ...     'hdfs://username:pwd@node:123/mnt/datasets/test.csv?q=1',
    ...     inherit_storage_options={'extra': 'value'},
    ... )  # doctest: +SKIP
    {"protocol": "hdfs", "username": "username", "password": "pwd",
    "host": "node", "port": 123, "path": "/mnt/datasets/test.csv",
    "url_query": "q=1", "extra": "value"}
    z^[a-zA-Z]:[\\/]z^[a-zA-Z0-9]+://Úfile)ÚprotocolÚpathú#z^/([a-zA-Z])[:|]([\\/].*)$ú:)ÚhttpÚhttpsú@é   éÿÿÿÿr   Úhost)Ús3Ús3aÚgcsÚgsr   ÚportÚusernameÚpasswordÚ	url_queryÚurl_fragment)ÚreÚmatchr   ÚschemeÚfragmentÚjoinr   ÚgroupsÚnetlocÚrsplitr#   r$   r%   ÚqueryÚupdate_storage_options)ÚurlpathÚinherit_storage_optionsÚparsed_pathr   r   Úwindows_pathÚdriveÚoptionss           úJ/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/fsspec/utils.pyÚinfer_storage_optionsr9   &   sÕ  € ô@ 	�‰Ð# WÔ-Ü�8‰8Ð'¨Ó1Ð9à"¨GÑ4Ð4ä˜7Ó#€KØ×!Ñ!Ò+ V€HØ×ÒØ�x‰x˜×)Ñ)¨;×+?Ñ+?Ð@ÓA‰à×ÑˆØ�6Òô —x‘xÐ =¸tÓDˆÙØ&×-Ñ-Ó/‰KˆE�4Ø�W˜A˜d˜VÐ$ˆDàÐ$Ñ$à$¨gÑ6Ð6à+3¸TÑB€Gà×Òð &×,Ñ,×3Ñ3°C¸Ó;¸BÑ?×FÑFÀsÈAÓNÈqÑQˆ�‰àÐ1Ñ1Ø% f™o°¸±Ñ?ˆG�FŠOà% f™oˆG�F‰OØ×ÒØ)×.Ñ.ˆG�F‰OØ×ÒØ"-×"6Ñ"6ˆG�JÑØ×ÒØ"-×"6Ñ"6ˆG�JÑà×ÒØ*×0Ñ0ˆ�ÑØ×ÒØ"-×"6Ñ"6ˆ�ÑáÜ˜wÐ(?Ô@à€Nó    c                óÐ   — |si }t        | «      t        |«      z  }|r8|D ]3  }| j                  |«      |j                  |«      k7  sŒ't        d|› �«      ‚ | j                  |«       y )Nz9Collision between inferred and specified storage option:
)ÚsetÚgetÚKeyErrorÚupdate)r7   Ú	inheritedÚ
collisionsÚ	collisions       r8   r1   r1   {   st   € ñ Øˆ	Ü�W“¤ I£Ñ.€JÙØ#ò 	ˆIØ�{‰{˜9Ó%¨¯©°yÓ)AÓAÜð Ø )˜{ð,óð ð	ð ‡N�N�9Õr:   zdict[str, str]Úcompressionsc                ó¤   — t         j                  j                  | «      d   j                  d«      j	                  «       }|t
        v r	t
        |   S y)a  Infer compression, if available, from filename.

    Infer a named compression type, if registered and available, from filename
    extension. This includes builtin (gz, bz2, zip) compressions, as well as
    optional compressions. See fsspec.compression.register_compression.
    r   ú.N)Úosr   ÚsplitextÚstripÚlowerrC   )ÚfilenameÚ	extensions     r8   Úinfer_compressionrL   �   sG   € ô —‘× Ñ  Ó*¨2Ñ.×4Ñ4°SÓ9×?Ñ?ÓA€IØ”LÑ Ü˜IÑ&Ð&Ør:   c                ó€   ‡— | dz  } t        t        j                  t        j                  | «      «      «      Šdˆfd„}|S )a�  Returns a function that receives a single integer
    and returns it as a string padded by enough zero characters
    to align with maximum possible integer

    >>> name_f = build_name_function(57)

    >>> name_f(7)
    '07'
    >>> name_f(31)
    '31'
    >>> build_name_function(1000)(42)
    '0042'
    >>> build_name_function(999)(42)
    '042'
    >>> build_name_function(0)(0)
    '0'
    g:Œ0âŽyE>c                ó8   •— t        | «      j                  ‰«      S ©N)ÚstrÚzfill)ÚiÚ
pad_lengths    €r8   Úname_functionz*build_name_function.<locals>.name_function³   s   ø€ Ü�1‹v�|‰|˜JÓ'Ð'r:   )rR   ÚintÚreturnrP   )rU   ÚmathÚceilÚlog10)Úmax_intrT   rS   s     @r8   Úbuild_name_functionr[   œ   s7   ø€ ð& ˆt�O€Gä”T—Y‘YœtŸz™z¨'Ó2Ó3Ó4€Jõ(ð Ðr:   c                óv  — | j                  «       dk(  ryd}	 | j                  |«      }|sy|r||z   n|}	 ||v rL|j                  |«      }| j                  | j                  «       t	        |«      |z
  z
  t	        |«      z   «       yt	        |«      |k  ry	 |t	        |«       d }ŒŽ# t
        t        f$ r Y Œ!w xY w)a˜  Seek current file to file start, file end, or byte after delimiter seq.

    Seeks file to next chunk delimiter, where chunks are defined on file start,
    a delimiting sequence, and file end. Use file.tell() to see location afterwards.
    Note that file start is a valid split, so must be at offset > 0 to seek for
    delimiter.

    Parameters
    ----------
    file: a file
    delimiter: bytes
        a delimiter like ``b'\n'`` or message sentinel, matching file .read() type
    blocksize: int
        Number of bytes to read from the file at once.


    Returns
    -------
    Returns True if a delimiter was found, False if at file start or end.

    r   FNT)ÚtellÚreadÚindexÚseekÚlenÚOSErrorÚ
ValueError)r   Ú	delimiterÚ	blocksizeÚlastÚcurrentÚfullrR   s          r8   Úseek_delimiterri   ¹   sÍ   € ð. ‡y�yƒ{�aÒàð €DØ
Ø—)‘)˜IÓ&ˆÙàÙ!%ˆt�gŠ~¨7ˆð		Ø˜DÑ Ø—J‘J˜yÓ)�Ø—	‘	˜$Ÿ)™)›+¬¨T«°Q©Ñ7¼#¸i».ÑHÔIØÜ�W“ 	Ò)àð *ð
 ”S˜“^�OÐ%Ð&ˆð! øô œÐ$ò 	Ùð	ús   ¶AB& ÂB& Â&B8Â7B8c                óž  — |r¤| j                  |«       t        | |d«      }|€| j                  «       S | j                  «       }|||z
  z  }| j                  ||z   «       t        | |d«      }| j                  «       }|r|r|t	        |«      z  }|r|r|t	        |«      z  }|}||z
  }| j                  |«       |€J ‚| j                  |«      }	|	S )a�  Read a block of bytes from a file

    Parameters
    ----------
    f: File
        Open file
    offset: int
        Byte offset to start read
    length: int
        Number of bytes to read, read through end of file if None
    delimiter: bytes (optional)
        Ensure reading starts and stops at delimiter bytestring
    split_before: bool (optional)
        Start/stop read *before* delimiter bytestring.


    If using the ``delimiter=`` keyword argument we ensure that the read
    starts and stops at delimiter boundaries that follow the locations
    ``offset`` and ``offset + length``.  If ``offset`` is zero then we
    start at zero, regardless of delimiter.  The bytestring returned WILL
    include the terminating delimiter string.

    Examples
    --------

    >>> from io import BytesIO  # doctest: +SKIP
    >>> f = BytesIO(b'Alice, 100\nBob, 200\nCharlie, 300')  # doctest: +SKIP
    >>> read_block(f, 0, 13)  # doctest: +SKIP
    b'Alice, 100\nBo'

    >>> read_block(f, 0, 13, delimiter=b'\n')  # doctest: +SKIP
    b'Alice, 100\nBob, 200\n'

    >>> read_block(f, 10, 10, delimiter=b'\n')  # doctest: +SKIP
    b'Bob, 200\nCharlie, 300'
    i   )r`   ri   r^   r]   ra   )
ÚfÚoffsetÚlengthrd   Úsplit_beforeÚfound_start_delimÚstartÚfound_end_delimÚendÚbs
             r8   Ú
read_blockrt   ê   sÕ   € ñV Ø	�‰ˆvŒÜ*¨1¨i¸Ó?ÐØˆ>Ø—6‘6“8ˆOØ—‘“ˆØ�%˜&‘.Ñ ˆà	�‰ˆu�v‰~ÔÜ(¨¨I°uÓ=ˆØ�f‰f‹hˆñ ¡Ø”S˜“^Ñ#ˆEá™|Ø”3�y“>Ñ!ˆCàˆØ�u‘ˆà‡F�Fˆ6„Nð ÐÐÐØ	�‰ˆv‹€AØ€Hr:   c                 óü   — |r| |fz  } 	 t        t        | «      j                  «       «      }|j	                  «       S # t        $ r6 t        t        | «      j                  «       d¬«      }Y |j	                  «       S w xY w)z¶Deterministic token

    (modified from dask.base)

    >>> tokenize([1, 2, '3'])
    '9d71491b50023b06fc76928e6eddb952'

    >>> tokenize('Hello') == tokenize('Hello')
    True
    F)Úusedforsecurity)r   rP   Úencoderc   Ú	hexdigest)ÚargsÚkwargsÚhs      r8   Útokenizer|   4  ss   € ñ Ø��	Ñˆð;Ü”�D“	× Ñ Ó"Ó#ˆð �;‰;‹=Ðøô ò ;ä”�D“	× Ñ Ó"°EÔ:‰Ø�;‰;‹=Ðð;ús   Š"< ¼-A;Á:A;c                ó’   — t        | t        «      r| S t        | d«      r| j                  «       S t        | d«      r| j                  S | S )a6  Attempt to convert a path-like object to a string.

    Parameters
    ----------
    filepath: object to be converted

    Returns
    -------
    filepath_str: maybe a string version of the object

    Notes
    -----
    Objects supporting the fspath protocol are coerced according to its
    __fspath__ method.

    For backwards compatibility with older Python version, pathlib.Path
    objects are specially coerced.

    Any other object is passed through unchanged, which includes bytes,
    strings, buffers, or anything else that's not even path-like.
    Ú
__fspath__r   )Ú
isinstancerP   Úhasattrr~   r   )Úfilepaths    r8   Ústringify_pathr‚   I  sE   € ô, �(œCÔ ØˆÜ	�˜<Ô	(Ø×"Ñ"Ó$Ð$Ü	�˜6Ô	"Ø�}‰}Ðàˆr:   c                ó6   —  | |i |¤Ž}|j                  «        |S rO   )Ú_determine_worker)Úclsry   rz   Úinsts       r8   Úmake_instancer‡   i  s$   € ñ �Ð˜Ñ€DØ×ÑÔØ€Kr:   c                ó   ‡‡— | D �cg c]  }|j                  d«      ‘Œ c}Št        d„ ‰D «       «      }d}t        |«      D ]  Št        ˆˆfd„‰D «       «      }|rŒ n ‰|z  Šdj	                  ‰d   d‰ «      S c c}w )z;For a list of paths, find the shortest prefix common to allú/c              3  ó2   K  — | ]  }t        |«      –— Œ y ­wrO   )ra   )Ú.0Úps     r8   ú	<genexpr>z common_prefix.<locals>.<genexpr>t  s   è ø€ Ò%˜!Œs�1�vÑ%ùó   ‚r   c              3  ó:   •K  — | ]  }|‰   ‰d    ‰   k(  –— Œ y­w)r   N© )r‹   rŒ   rR   Úpartss     €€r8   r�   z common_prefix.<locals>.<genexpr>w  s"   øè ø€ Ò5¨!�!�A‘$˜% ™( 1™+Õ%Ñ5ùs   ƒN)ÚsplitÚminÚrangeÚallr,   )ÚpathsrŒ   Úlmaxrr   rR   r‘   s       @@r8   Úcommon_prefixr˜   q  s‚   ù€ à#(Ö)˜aˆQ�W‰W�S�\Ò)€EÜÑ%˜uÔ%Ó%€DØ
€CÜ�4‹[ò ˆÜÔ5¨uÔ5Ó5ˆÚÙðð ˆ�H€AØ�8‰8�E˜!‘H˜R˜a�LÓ!Ð!ùò *s   ‡A;c           	     óø  — t        |t        «      rÁ|j                  d«      }|r4| D �cg c]'  }dj                  ||j	                  d«      d   f«      ‘Œ) }}|S t        | «      }|r|j                  dd«      d   }|s4t        d„ | D «       «      r"| D �cg c]  }dj                  ||g«      ‘Œ }}|S | D �cg c]  }|j                  ||d«      ‘Œ }}|S t        | «      t        |«      k(  sJ ‚|S c c}w c c}w c c}w )a‰  In bulk file operations, construct a new file tree from a list of files

    Parameters
    ----------
    paths: list of str
        The input file tree
    path2: str or list of str
        Root to construct the new list in. If this is already a list of str, we just
        assert it has the right number of elements.
    exists: bool (optional)
        For a str destination, it is already exists (and is a dir), files should
        end up inside.
    flatten: bool (optional)
        Whether to flatten the input directory tree structure so that the output files
        are in the same directory.

    Returns
    -------
    list of str
    r‰   r   r   r   c              3  ó@   K  — | ]  }|j                  d «       –— Œ y­w)r‰   N)Ú
startswith©r‹   Úss     r8   r�   zother_paths.<locals>.<genexpr>¢  s   è ø€ ÒC¸ !§,¡,¨sÓ"3Ô3ÑCùs   ‚)
r   rP   Úrstripr,   r’   r˜   r/   r•   Úreplacera   )r–   Úpath2ÚexistsÚflattenrŒ   Úcps         r8   Úother_pathsr¤   ~  s  € ô6 �%œÔØ—‘˜SÓ!ˆáØBGÖH¸Q�S—X‘X˜u a§g¡g¨c£l°2Ñ&6Ð7Õ8ÐHˆEÐHð €Lô ˜uÓ%ˆBÙØ—Y‘Y˜s AÓ& qÑ)�Ùœ#ÑC¸UÔCÔCØ7<Ö=°!˜Ÿ™ 5¨! *Õ-Ð=�Ð=ð
 €Lð ;@Ö@°Q˜Ÿ™ 2 u¨aÕ0Ð@�Ð@ð €Lô �5‹zœS ›ZÒ'Ð'Ð'Ø€Lùò Iùò >ùâ@s   ¨,C-ÂC2Â4C7c                ó"   — t        | t        «      S rO   )r   ÚBaseException©Úobjs    r8   Úis_exceptionr©   «  s   € Ü�cœ=Ó)Ð)r:   c                ó,   ‡ — t        ˆ fd„dD «       «      S )Nc              3  ó6   •K  — | ]  }t        ‰|«      –— Œ y ­wrO   )r€   )r‹   Úattrrk   s     €r8   r�   zisfilelike.<locals>.<genexpr>°  s   øè ø€ ÒF DŒw�q˜$×ÑFùs   ƒ)r^   Úcloser]   )r•   )rk   s   `r8   Ú
isfileliker®   ¯  s   ø€ ÜÓFÐ,EÔFÓFÐFr:   c                óp   — t        | «      } t        j                  d| d¬«      }t        |«      dkD  r|d   S y)Nz(\:\:|\://)r   )Úmaxsplitr   r   )r‚   r(   r’   ra   )Úurlr‘   s     r8   Úget_protocolr²   ³  s5   € Ü
˜Ó
€CÜ�H‰H�^ S°1Ô5€EÜ
ˆ5ƒz�A‚~Ø�Q‰xˆØr:   c                ór   — ddl m} 	 t         |t        | «      «      dd«      S # t        t
        f$ r Y yw xY w)z*Can the given URL be used with open_local?r   )Úget_filesystem_classÚ
local_fileF)Úfsspecr´   Úgetattrr²   rc   ÚImportError)r   r´   s     r8   Úcan_be_localr¹   »  s;   € å+ðÜÑ+¬L¸Ó,>Ó?ÀÈuÓUÐUøÜœÐ$ò áðús   ˆ$ ¤6µ6c                ó  — | t         j                  v r+t         j                  |    }t        |d«      r|j                  S 	 t	        | «      S #  Y nxY w	 ddl}|j                  | «      }|j                  S # t        t        f$ r Y yw xY w)a  For given package name, try to find the version without importing it

    Import and package.__version__ is still the backup here, so an import
    *might* happen.

    Returns either the version string, or None if the package
    or the version was not readily  found.
    Ú__version__r   N)	ÚsysÚmodulesr€   r»   r   Ú	importlibÚimport_moduler¸   ÚAttributeError)ÚnameÚmodr¾   s      r8   Ú"get_package_version_without_importrÃ   Æ  s„   € ð Œs�{‰{ÑÜ�k‰k˜$ÑˆÜ�3˜Ô&Ø—?‘?Ð"ðÜ�t‹}ÐøðÙúðÛà×%Ñ% dÓ+ˆØ�‰ÐøÜœÐ(ò Ùðús   ¿
A
 Á
AÁ A3 Á3BÂBc                óF  — | €|€t        d«      ‚| xs t        j                  |«      } t        j                  «       }t        j                  d«      }|j                  |«       |r| j                  j                  «        | j                  |«       | j                  |«       | S )Nz+Provide either logger object or logger namezD%(asctime)s - %(name)s - %(levelname)s - %(funcName)s -- %(message)s)
rc   ÚloggingÚ	getLoggerÚStreamHandlerÚ	FormatterÚsetFormatterÚhandlersÚclearÚ
addHandlerÚsetLevel)ÚloggerÚlogger_nameÚlevelrË   ÚhandleÚ	formatters         r8   Úsetup_loggingrÓ   à  s’   € ð €~˜+Ð-ÜÐFÓGÐGØÒ5”w×(Ñ(¨Ó5€FÜ×"Ñ"Ó$€FÜ×!Ñ!ØNó€Ið ×Ñ˜	Ô"ÙØ�‰×ÑÔØ
×Ñ�fÔØ
‡O�O�EÔØ€Mr:   c                ó$   — |j                  | «      S rO   )Úunstrip_protocol)rÁ   Úfss     r8   Ú_unstrip_protocolr×   õ  s   € Ø×Ñ˜tÓ$Ð$r:   c                ó&   ‡ ‡‡— dˆ fd„Šdˆˆfd„}|S )zqMirror attributes and methods from the given
    origin_name attribute of the instance to the
    decorated classc                ó4   •— t        |‰«      }t        || «      S rO   )r·   )ÚmethodÚselfÚoriginÚorigin_names      €r8   Úorigin_getterz"mirror_from.<locals>.origin_getter   s   ø€ Ü˜˜{Ó+ˆÜ�v˜vÓ&Ð&r:   c                óZ   •— ‰D ]$  }t        ‰|«      }t        | |t        |«      «       Œ& | S rO   )r   ÚsetattrÚproperty)r…   rÚ   Úwrapped_methodÚmethodsrÞ   s      €€r8   Úwrapperzmirror_from.<locals>.wrapper  s6   ø€ Øò 	;ˆFÜ$ ]°FÓ;ˆNÜ�C˜¤¨.Ó!9Õ:ð	;ð ˆ
r:   )rÚ   rP   rÛ   r	   rV   r	   )r…   útype[T]rV   rå   r�   )rÝ   rã   rä   rÞ   s   `` @r8   Úmirror_fromræ   ù  s   ú€ õ'öð €Nr:   c              #  ó   K  — | –— y ­wrO   r�   r§   s    r8   Únullcontextrè     s   è ø€ à
ƒIùs   ‚c           
     ó.  — t        | t        «      st        ‚t        |t        «      s|gt        | «      z  }t        |t        «      s|gt        | «      z  }t        |«      t        | «      k7  st        |«      t        | «      k7  rt        ‚t        |«      dk  r| ||fS |D �cg c]  }|xs d‘Œ
 }}|r'd„ t        t        t        | ||«      «      Ž D «       \  } }}| r³| dd }|dd }|dd }	t        dt        | «      «      D ]‡  }
| |
   | |
dz
     k(  r|	d   €Œ| |
   | |
dz
     k7  s||
   |	d   z
  |kD  s|�K||
   |d   z
  |kD  r=|j                  | |
   «       |j                  ||
   «       |	j                  ||
   «       Œ€||
   |	d<   Œ‰ |||	fS | ||fS c c}w )a}  Merge adjacent byte-offset ranges when the inter-range
    gap is <= `max_gap`, and when the merged byte range does not
    exceed `max_block` (if specified). By default, this function
    will re-order the input paths and byte ranges to ensure sorted
    order. If the user can guarantee that the inputs are already
    sorted, passing `sort=False` will skip the re-ordering.
    r   r   c              3  ó2   K  — | ]  }t        |«      –— Œ y ­wrO   )Úlist)r‹   Úvs     r8   r�   z&merge_offset_ranges.<locals>.<genexpr>2  s   è ø€ ò 
àô ��Gñ
ùrŽ   Nr   )	r   rë   Ú	TypeErrorra   rc   ÚzipÚsortedr”   Úappend)r–   ÚstartsÚendsÚmax_gapÚ	max_blockÚsortr�   Ú	new_pathsÚ
new_startsÚnew_endsrR   s              r8   Úmerge_offset_rangesrù     sà  € ô  �eœTÔ"ÜˆÜ�fœdÔ#Ø�œC ›JÑ&ˆÜ�dœDÔ!Øˆvœ˜E›
Ñ"ˆÜ
ˆ6ƒ{”c˜%“jÒ ¤C¨£I´°U³Ò$;ÜÐô ˆ6ƒ{�aÒØ�f˜dÐ"Ð"à$Ö%˜ˆaŠf�1‰fÐ%€FÐ%áñ
äÜÜ˜˜v tÓ,óðô
Ñˆˆv�tñ ð ˜"˜1�Iˆ	Ø˜B˜Q�Zˆ
Ø˜˜�8ˆÜ�qœ#˜e›*Ó%ò 	'ˆAØ�Q‰x˜5  Q¡™<Ò'¨H°R©LÐ,@Øà�a‘˜E ! a¡%™LÒ(Ø˜A‘Y ¨"¡Ñ-°Ò8ØÐ)¨t°A©w¸ÀB¹Ñ/GÈ9Ò.Tð × Ñ   q¡Ô*Ø×!Ñ! &¨¡)Ô,Ø—‘  Q¡Õ(ð  $ A™w�˜’ð!	'ð" ˜* hÐ.Ð.ð �&˜$ÐÐùòM &s   Â Fc                ó–   — | j                  «       }	 | j                  dd«      | j                  |«       S # | j                  |«       w xY w)z+Find length of any open read-mode file-liker   é   )r]   r`   )ÚfilelikeÚposs     r8   Ú	file_sizerþ   X  s9   € à
�-‰-‹/€CðØ�}‰}˜Q Ó"à�‰�cÕøˆ�‰�cÕús	   ’5 µAc              #  óÔ  K  — t        j                  t        j                  j	                  | «      t        j                  j                  | «      dz   ¬«      \  }}	 t        ||«      5 }|–— ddd«       t        j                  || «       y# 1 sw Y   Œ xY w# t        $ rE t        j                  t        «      5  t        j                  |«       ddd«       ‚ # 1 sw Y   ‚ xY ww xY w­w)z©
    A context manager that opens a temporary file next to `path` and, on exit,
    replaces `path` with the temporary file, thereby updating `path`
    atomically.
    ú-)ÚdirÚprefixN)ÚtempfileÚmkstemprF   r   ÚdirnameÚbasenameÚopenrŸ   r¦   Ú
contextlibÚsuppressÚFileNotFoundErrorÚunlink)r   ÚmodeÚfdÚfnÚfps        r8   Úatomic_writer  a  s¹   è ø€ ô ×ÑÜ�G‰G�O‰O˜DÓ!¬"¯'©'×*:Ñ*:¸4Ó*@À3Ñ*Fô�F€BˆðÜ�"�d‹^ð 	˜rØŠH÷	ô 	�
‰
�2�tÕ÷	ð 	ûäò Ü× Ñ Ô!2Ó3ñ 	Ü�I‰I�bŒM÷	à÷	àúðüsN   ‚AC(ÁB Á'BÁ,B Á4C(ÂBÂB Â"C%Â9CÃ	C%ÃC!	ÃC%Ã%C(c                ó`  — g }|j                   }dt        | «      }}||k  �r| |   }|dz   }|dk(  r|r|d   |u�rå ||«       �nÛ|dk(  r
 ||«       �nÌ|dk(  �r«|}||k  r| |   dk(  r|dz   }||k  r| |   dk(  r|dz   }||k  r| |   dk7  r|dz   }||k  r	| |   dk7  rŒ||k\  r
 |d	«       �nq| || }	d
|	vr|	j                  dd«      }	nÛg }
| |   dk(  r|dz   n|dz   }	 | j                  d
||«      }|dk  rn|
j                  | || «       |dz   }|dz   }Œ8| || }|r|
j                  |«       n|
dxx   d
z  cc<   t	        t        |
«      dz
  dd«      D ]4  }|
|dz
     d   |
|   d   kD  sŒ|
|dz
     d d |
|   dd  z   |
|dz
  <   |
|= Œ6 d
j                  d„ |
D «       «      }	t        j                  dd|	«      }	|dz   }|	s	 |d«       nS|	dk(  r	 |d«       nE|	d   dk(  r	d|	dd  z   }	n|	d   dv rd|	z   }	 |d|	› d�«       n |t        j                  |«      «       ||k  r�Œ||k(  sJ ‚|S )Nr   r   Ú*r   ú?ú[ú!ú]z\[r   ú\ú\\rû   é   c              3  ó`   K  — | ]&  }|j                  d d«      j                  dd«      –— Œ( y­w)r  r  r   z\-N)rŸ   rœ   s     r8   r�   z_translate.<locals>.<genexpr>¨  s-   è ø€ ò %ØGH˜Ÿ	™	 $¨Ó.×6Ñ6°s¸E×Bñ%ùs   ‚,.z([&~|])z\\\1z(?!)rE   ú^)r  r  )	rð   ra   rŸ   Úfindr”   r,   r(   ÚsubÚescape)ÚpatÚSTARÚQUESTION_MARKÚresÚaddrR   ÚnÚcÚjÚstuffÚchunksÚkÚchunks                r8   Ú
_translater+  v  s¼  € à€CØ
�*‰*€CØŒc�#‹h€q€AØ
ˆa‹%Ø�‰FˆØ�‰EˆØ�Š8á˜C ™G¨4Ò/Ù�D–	Ø�#ŠXÙ�ÖØ�#‹XØˆAØ�1Šu˜˜Q™ 3šØ˜‘E�Ø�1Šu˜˜Q™ 3šØ˜‘E�Ø�a’%˜C ™F cšMØ˜‘E�ð �a’%˜C ™F c›Mà�AŠvÙ�E–
à˜A˜a˜�Ø˜eÑ#Ø!ŸM™M¨$°Ó6‘Eà�FØ!$ Q¡¨3¢˜˜Aš°A¸±E�AØØŸH™H S¨!¨QÓ/˜Ø˜qš5Ø!ØŸ™ c¨!¨A hÔ/Ø ™E˜Ø ™E˜ð ð    !˜H�EÙØŸ™ eÕ,à˜r›
 cÑ)›
ä"¤3 v£;°¡?°A°rÓ:ò *˜Ø! ! a¡%™=¨Ñ,¨v°a©y¸©|Ó;Ø,2°1°q±5©M¸#¸2Ð,>ÀÈÁÈ1È2ÀÑ,N˜F 1 q¡5™MØ & q¡	ð*ð  ŸH™Hñ %ØLRô%ó �Eô Ÿ™˜z¨7°EÓ:�Ø˜‘E�Ùá˜•KØ˜c’\á˜•Hà˜Q‘x 3’Ø # e¨A¨B i¡™Ø˜q™ ZÑ/Ø $ u¡˜Ù˜!˜E˜7 !˜Õ%á”—	‘	˜!“ÔðA ˆaŒ%ðB �Š6€Mˆ6Ø€Jr:   c                ó,  — t         j                  j                  r6t         j                  j                  t         j                  j                  z   }nt         j                  j                  }dj	                  t        t        j                  |«      «      }t        |«      dkD  rd|› d�n|}d|› d�}|› d�}|› |› �}d|› d�}d	}g }	t        j                  || «      }
t        |
«      dz
  }t        |
«      D ]ˆ  \  }}|d
k(  r|	j                  ||k  r|n|«       Œ$|dk(  r|	j                  ||k  r|n|«       ŒBd|v rt        d«      ‚|r|	j                  t        ||› d
�|«      «       ||k  sŒx|	j                  |«       ŒŠ dj	                  |	«      }d|› d�S )zBTranslate a pathname with shell wildcards to a regular expression.Ú r   r  r  z[^ú+z(?:.+z)?z.*r  z**z:Invalid pattern: '**' can only be an entire path componentz(?s:z)\Z)rF   r   ÚaltsepÚsepr,   Úmapr(   r  ra   r’   Ú	enumeraterð   rc   Úextendr+  )r  ÚsepsÚescaped_sepsÚany_sepÚnot_sepÚone_last_segmentÚone_segmentÚany_segmentsÚany_last_segmentsÚresultsr‘   Úlast_part_idxÚidxÚpartr"  s                  r8   Úglob_translater@  À  sŠ  € ô
 
‡w�w‡~‚~Ü�w‰w�{‰{œRŸW™WŸ^™^Ñ+‰ä�w‰w�{‰{ˆØ—7‘7œ3œrŸy™y¨$Ó/Ó0€LÜ%(¨£Y°¢]��,�˜qÑ!¸€GØ�<�. Ð"€GØ!˜ !�}ÐØ%Ð& w iÐ0€KØ˜7˜) 2Ð&€LØÐØ€GÜ�H‰H�W˜cÓ"€EÜ˜“J ‘N€MÜ˜uÓ%ò $‰	ˆˆTØ�3Š;Ø�N‰N¨#°Ò*=™;ÐCSÔTØØ�4Š<Ø�N‰N¨3°Ò+>™<ÐDUÔVØØ�T‰\ÜØLóð ñ Ø�N‰Nœ: d¨w¨i°q¨M¸7ÓCÔDØ�ÓØ�N‰N˜7Õ#ð$ð �'‰'�'Ó
€CØ�3�%�sÐÐr:   rO   )r2   rP   r3   údict[str, Any] | NonerV   údict[str, Any])r7   rB  r@   rA  rV   ÚNone)rJ   rP   rV   ú
str | None)rZ   ÚfloatrV   zCallable[[int], str])r   ú	IO[bytes]rd   Úbytesre   rU   rV   Úbool)NF)rk   rF  rl   rU   rm   ú
int | Nonerd   zbytes | Nonern   rH  rV   rG  )ry   r	   rz   r	   rV   rP   )r�   z%str | os.PathLike[str] | pathlib.PathrV   rP   )r…   zCallable[..., T]ry   zSequence[Any]rz   rB  rV   r   )r–   úIterable[str]rV   rP   )FF)
r–   ú	list[str]r    zstr | list[str]r¡   rH  r¢   rH  rV   rK  )r¨   r	   rV   rH  )rk   r	   rV   zTypeGuard[IO[bytes]])r±   rP   rV   rP   )r   rP   rV   rH  )rÁ   rP   rV   rD  )NNÚDEBUGT)
rÎ   zlogging.Logger | NonerÏ   rD  rÐ   rP   rË   rH  rV   zlogging.Logger)rÁ   rP   rÖ   r   rV   rP   )rÝ   rP   rã   rJ  rV   zCallable[[type[T]], type[T]])r¨   r   rV   zIterator[T])r   NT)r–   rK  rñ   úlist[int] | intrò   rM  ró   rU   rô   rI  rõ   rH  rV   z&tuple[list[str], list[int], list[int]])rü   rF  rV   rU   )Úwb)r   rP   r  rP   )=Ú
__future__r   r  rÅ   rW   rF   r(   r¼   r  Ú	functoolsr   Úhashlibr   Úimportlib.metadatar   Útypingr   r   r	   r
   r   r   r   r   Úurllib.parser   ÚpathlibÚtyping_extensionsr   Úfsspec.specr   ÚDEFAULT_BLOCK_SIZEr   r9   r1   rC   Ú__annotations__rL   r[   ri   rt   r|   r‚   r‡   r˜   r¤   r©   r®   r²   r¹   rÃ   rÓ   r×   ræ   Úcontextmanagerrè   rù   rþ   r  r+  r@  r�   r:   r8   ú<module>r[     s›  ðÞ "ã Û Û Û 	Û 	Û 
Û Ý Ý Ý &÷	÷ 	ó 	õ "áÛå+å.ð Ð áˆCƒL€ð DHðRØðRØ+@ðRàóRðl AEðØðØ(=ðà	óð"  "€ˆnÓ !ó
óó:.'ðj #ØðGØðGàðGð ðGð ð	Gð
 ðGð óGóTó*ð@Ø	ðØ!.ðØ8Fðàóó
"ð  Øð	*Øð*àð*ð ð*ð ð	*ð
 ó*óZ*óGóóóð6 %)Ø"ØØð	Ø!ðàðð ðð ð	ð
 óó*%ðØðØ,ðà!óð( ×Ñòó ðð Ø ØðCØðCàðCð ðCð ð	Cð
 ðCð ðCð ,óCóLð ×Ñóó ðò(GóT#r:   