Ë

����†£éfÄ�ã������������������ó^��—�d�dl�mZ�d�dlZd�dlZd�dlZd�dlZd�dlZd�dlZd�dlZd�dl	m
Z
�d�dlmZ�d�dl
mZ�d�dlmZmZmZmZ�ddlmZ�dd	lmZmZ�dd
lmZ�ddlmZ�ddlmZmZm Z m!Z!m"Z"m#Z#m$Z$��ejJ������������������d
«������Z&d„�Z'�G�d„�de(«������Z)�G�d„�de)¬«������Z*�G�d„�dejV������������������«������Z,y)é����)ÚannotationsN)ÚESPIPE)Ú	has_magic)Úsha256)ÚAnyÚClassVarÚDictÚTupleé���)ÚDEFAULT_CALLBACK)Úapply_configÚconf)ÚDirCache)ÚTransaction)Ú_unstrip_protocolÚglob_translateÚ
isfilelikeÚother_pathsÚ
read_blockÚstringify_pathÚtokenizeÚfsspecc����������������ó���—��|�|i�|¤ŽS�©N©�)ÚclsÚargsÚkwargss���   úT/var/lib/jenkins/workspace/mettalog/venv/lib/python3.12/site-packages/fsspec/spec.pyÚ
make_instancer ��� ���s���€�ِИÑÐó����c������������������ó,���‡�—�e�Zd�ZdZˆ�fd„Zˆ�fd„Zˆ�xZS�)Ú_Cacheda��
    Metaclass for caching file system instances.

    Notes
    -----
    Instances are cached according to

    * The values of the class attributes listed in `_extra_tokenize_attributes`
    * The arguments passed to ``__init__``.

    This creates an additional reference to the filesystem, which prevents the
    filesystem from being garbage collected when all *user* references go away.
    A call to the :meth:`AbstractFileSystem.clear_instance_cache` must *also*
    be made for a filesystem instance to be garbage collected.
    c����������������óÂ���•—�t��������‰|���|i�|¤Ž�t��������j������������������d«������rt	��������j
������������������«�������|�_��������ni�|�_��������t��������j������������������«�������|�_	��������y�)NÚweakref_instance_cache)
ÚsuperÚ__init__r���ÚgetÚweakrefÚWeakValueDictionaryÚ_cacheÚosÚgetpidÚ_pid)r���r���r���Ú	__class__s���   €r���r'���z_Cached.__init__5���sH���ø€�Ü
‰Ñ˜$Ð) &Ò)ô�8‰8Ð,Ô-ä ×4Ñ4Ó6ˆCJàˆCŒJÜ—9‘9“;ˆr!���c����������������óÈ��•‡�—�t��������‰�|«������}t��������ˆ�fd„‰�j������������������D�«�������«������}t��������‰�‰�j������������������t��������j������������������«�������g|¢|¢­i�|¤Ž}|j������������������dd«������}t��������j������������������«�������‰�j������������������k7��r3‰�j������������������j������������������«��������t��������j������������������«�������‰�_��������|s0‰�j������������������r$|‰�j������������������v�r|‰�_
��������‰�j������������������|���S�t��������‰‰�<��|i�|¤Ž}||_��������||_��������||_��������|j&������������������r|j(������������������rddlm}��||«�������‰�j������������������r|s|‰�_
��������|‰�j������������������|<���|S�)Nc��������������3��ó8���•K��—�|�]��}t��������‰|d�«������–—�Œ�y�­wr���©Úgetattr)Ú.0Úattrr���s���  €r���ú	<genexpr>z#_Cached.__call__.<locals>.<genexpr>C���s���øè�ø€�ò�
Ø)-ŒGC˜˜t×$ñ
ùs���ƒÚskip_instance_cacheFr���)Úmirror_sync_methods)r
���ÚtupleÚ_extra_tokenize_attributesr���r.���Ú	threadingÚ	get_identÚpopr,���r-���r+���ÚclearÚcachableÚ_latestr&���Ú__call__Ú
_fs_token_Ústorage_argsÚstorage_optionsÚ
async_implr8���Úasyn)	r���r���r���Úextra_tokensÚtokenÚskipÚobjr8���r/���s	���`       €r���rA���z_Cached.__call__A���s8��ù€�ܘc 6Ó*ˆÜó�
Ø14×1OÑ1Oô
ó�
ˆô�Ø—‘œ9×.Ñ.Ó0ð
Ø37ð
Ø:Fò
ØJPñ
ˆð�z‰zÐ/°Ó7ˆÜ
9‰9‹;˜#Ÿ(™(Ò"ØJ‰J×ÑÔÜ—y‘y“{ˆCŒHÙ˜Ÿš¨°#·*±*Ñ)<؈CŒKØ—:‘:˜eÑ$Ð$ä‘'Ñ" DÐ3¨FÑ3ˆCà"ˆCŒNØ#ˆCÔØ"(ˆCÔ؏~Š~ #×"9Ò"9Ý5á# CÔ(à|Š|¡DØ#”Ø$'—
‘
˜5Ñ!؈Jr!���)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r'���rA���Ú
__classcell__)r/���s���@r���r#���r#���$���s���ø„�ñô 
÷ð�r!���r#���c������������������ó6��—�e�Zd�ZU�dZdZdZdZdZdZde	d<���d	Z
dZdZd
Z
eZdZde	d
<���de	d<���d„�Zed„�«�������Zed„�«�������Zd„�Zd„�Zd„�Zd„�Zed„�«�������Zdcd„Zed„�«�������Zed„�«�������Zed„�«�������Zd„�Z d„�Z!ddd„Z"ded„Z#dfd „Z$d!„�Z%ded"„Z&d#„�Z'dgd$„Z(dhd%„Z)did&„Z*ddd'„Z+d(„�Z,d)„�Z-d*„�Z.d+„�Z/d,„�Z0d-„�Z1d.„�Z2d/„�Z3djd0„Z4	�djd1„Z5dkd2„Z6d3„�Z7ddd4„Z8	�dld5„Z9dmd6„Z:e;d	fd7„Z<de;d	fd8„Z=e;fd9„Z>de;d	fd:„Z?dnd;„Z@dnd<„ZAd=„�ZB	�dod>„ZCdpd?„ZDdpd@„ZEdA„�ZFdB„�ZGdpdC„ZHedD„�«�������ZI	�	�	�	�dqdE„ZJ	�	�	�	�drdF„ZKdedG„ZLdH„�ZMdddI„ZNddJœdsdK„ZOedtdL„«�������ZPddJœdudM„ZQedvdN„«�������ZRdO„�ZSdwdP„ZTedQ„�«�������ZUdR„�ZVdS„�ZWdkdT„ZXdU„�ZYdedV„ZZdfdW„Z[dedX„Z\dY„�Z]dZ„�Z^d[„�Z_dxd\„Z`d]„�Zadpd^„Zbdfd_„Zcdfd`„Zddyda„Zedb„�Zfy	)zÚAbstractFileSystemz—
    An abstract super-class for pythonic file-systems

    Implementations are expected to be compatible with or, better, subclass
    from here.
    TFi��@�ú/ÚabstractzClassVar[str | tuple[str, ...]]ÚprotocolNÚ�r���zTuple[Any, ...]rC���úDict[str, Any]rD���c����������������ó4��—�|�j�������������������ryd|�_���������d|�_��������d|�_��������g�|�_��������t	��������di�|¤Ž|�_��������|j
������������������dd«������rt��������j������������������dt��������«�������|j
������������������dd«������rt��������j������������������dt��������«�������d|�_
��������y)	a»��Create and configure file-system instance

        Instances may be cachable, so if similar enough arguments are seen
        a new instance is not required. The token attribute exists to allow
        implementations to cache instances if they wish.

        A reasonable default should be provided if there are no arguments.

        Subclasses should call this method.

        Parameters
        ----------
        use_listings_cache, listings_expiry_time, max_paths:
            passed to ``DirCache``, if the implementation supports
            directory listing caching. Pass use_listings_cache=False
            to disable such caching.
        skip_instance_cache: bool
            If this is a cachable implementation, pass True here to force
            creating a new instance even if a matching instance exists, and prevent
            storing this instance.
        asynchronous: bool
        loop: asyncio-compatible IOLoop or None
        NTFÚadd_docsz add_docs is no longer supported.Úadd_aliaseszadd_aliases has been removed.r���)Ú_cachedÚ_intransÚ_transactionÚ"_invalidated_caches_in_transactionr���Údircacher=���ÚwarningsÚwarnÚ
FutureWarningrB���)Úselfr���rD���s���   r���r'���zAbstractFileSystem.__init__{���s€���€�ð0�<Š<à؈Œ؈Œ
Ø ˆÔØ24ˆÔ/Ü Ñ3 ?Ñ3ˆŒ
à×јz¨4Ô0ÜM‰MÐ<¼mÔLà×ј}¨dÔ3ÜM‰MÐ9¼=ÔIàˆr!���c����������������ó���—�t���������‚)zbPersistent filesystem id that can be used to compare filesystems
        across sessions.
        ©ÚNotImplementedError©rb���s��� r���ÚfsidzAbstractFileSystem.fsid¤���s
���€�ô
�"Ð!r!���c����������������ó���—�|�j�������������������S�r���)rB���rf���s��� r���Ú	_fs_tokenzAbstractFileSystem._fs_token«���s���€�à‰Ðr!���c����������������ó���—�|�j�������������������S�r���)ri���rf���s��� r���Ú__dask_tokenize__z$AbstractFileSystem.__dask_tokenize__¯���s���€�؏~‰~Ðr!���c����������������ó.���—�t��������|�j������������������d«������S�)Né���)Úintri���rf���s��� r���Ú__hash__zAbstractFileSystem.__hash__²���s���€�ܐ4—>‘> 2Ó&Ð&r!���c����������������ób���—�t��������|t��������|�«������«������xr�|�j������������������|j������������������k(��S�r���)Ú
isinstanceÚtyperi���©rb���Úothers���  r���Ú__eq__zAbstractFileSystem.__eq__µ���s%���€�ܘ%¤ d£Ó,ÒR°·±À5Ç?Á?Ñ1RÐRr!���c����������������óR���—�t���������t��������|�«������|�j������������������|�j������������������ffS�r���)r ���rr���rC���rD���rf���s��� r���Ú
__reduce__zAbstractFileSystem.__reduce__¸���s$���€�Üœt D›z¨4×+<Ñ+<¸d×>RÑ>RÐSÐSÐSr!���c����������������óÎ��—�t��������|t��������«������r|D�cg�c]��}|�j������������������|«������‘Œ�c}S�t��������|«������}t��������|�j������������������t
��������«������r
|�j������������������fn|�j������������������}|D�]N��}|j
������������������|dz���«������r|t��������|«������dz���d�}Œ)|j
������������������|dz���«������sŒ>|t��������|«������dz���d�}ŒP�|j������������������d«������}|xs�|�j������������������S�c�c}w�)zTurn path from fully-qualified to file-system-specific

        May require FS-specific handling, e.g., for relative paths or links.
        ú://é���Nz::é���rR���)
rq���ÚlistÚ_strip_protocolr���rT���ÚstrÚ
startswithÚlenÚrstripÚroot_marker)r���ÚpathÚpÚprotosrT���s���     r���r}���z"AbstractFileSystem._strip_protocol»���sÍ���€�ô�dœDÔ!Ø48Ö9¨qC×'Ñ'¨Õ*Ò9Ð9ܘdÓ#ˆÜ$.¨s¯|©|¼SÔ$A#—,‘,‘ÀsÇ|Á|ˆÛˆH؏‰˜x¨%Ñ/Ô0ØœC ›M¨AÑ-Ð/Ð0‘Ø—‘ ¨D¡Õ1ØœC ›M¨AÑ-Ð/Ð0‘ð	�ð
�{‰{˜3ÓˆàÒ&s—‘Ð&ùò�:s���•C"c����������������óº���—�t��������|�j������������������t��������«������r
|�j������������������fn|�j������������������}|D�]��}|j������������������|›�d«������sŒ|c�S��|d���›�d|›�S�)z6Format FS-specific path to generic, including protocolry���r���)rq���rT���r~���r���)rb���Únamer…���rT���s���    r���Úunstrip_protocolz#AbstractFileSystem.unstrip_protocolÎ���sZ���€�ä%/°·
±
¼sÔ%C$—-‘-Ñ!ÈÏɈۈH؏‰ ( ¨3Ð/Õ0Ø’ð�ð�˜‘)˜C ˜vÐ&Ð&r!���c����������������ó���—�i�S�)af��If kwargs can be encoded in the paths, extract them here

        This should happen before instantiation of the class; incoming paths
        then should be amended to strip the options in methods.

        Examples may look like an sftp path "sftp://user@host:/my/path", where
        the user and host should become kwargs and later get stripped.
        r���)rƒ���s��� r���Ú_get_kwargs_from_urlsz(AbstractFileSystem._get_kwargs_from_urlsÖ���s	���€�ð�ˆ	r!���c����������������ór���—�|�j�������������������|�j������������������v�r|�j������������������|�j����������������������S��|�«�������S�)zReturn the most recently instantiated FileSystem

        If no instance has been created, then create one with defaults
        )r@���r+���©r���s��� r���ÚcurrentzAbstractFileSystem.currentã���s.���€�ð�;‰;˜#Ÿ*™*Ñ$Ø—:‘:˜cŸk™kÑ*Ð*Ù‹uˆr!���c����������������ó^���—�|�j�������������������€|�j������������������|�«������|�_���������|�j�������������������S�)z½A context within which files are committed together upon exit

        Requires the file class to implement `.commit()` and `.discard()`
        for the normal and exception cases.
        )r\���Útransaction_typerf���s��� r���ÚtransactionzAbstractFileSystem.transactioní���s/���€�ð�×ÑÐ$Ø $× 5Ñ 5°dÓ ;ˆDÔØ× Ñ Ð r!���c����������������óT���—�d|�_���������|�j������������������|�«������|�_��������|�j������������������S�)z@Begin write transaction for deferring files, non-context versionT)r[���r���r\���r���rf���s��� r���Ústart_transactionz$AbstractFileSystem.start_transactionø���s(���€�àˆŒ
Ø ×1Ñ1°$Ó7ˆÔØ×ÑÐr!���c����������������ó¾���—�|�j�������������������j������������������«��������d|�_��������|�j������������������D�]��}|�j	������������������|«�������Œ�|�j������������������j������������������«��������y)z-Finish write transaction, non-context versionN)r���Úcompleter\���r]���Úinvalidate_cacher>���©rb���rƒ���s���  r���Úend_transactionz"AbstractFileSystem.end_transactionþ���sL���€�à×Ñ×!Ñ!Ô#Ø ˆÔà×;Ô;ˆDØ×!Ñ! $Õ'ð�<à×/Ñ/×5Ñ5Õ7r!���c����������������óT���—�|�j�������������������r|�j������������������j������������������|«�������yy)zß
        Discard any cached directory information

        Parameters
        ----------
        path: string or None
            If None, clear all listings cached else listings at or under given
            path.
        N)r[���r]���Úappendr–���s���  r���r•���z#AbstractFileSystem.invalidate_cache��s$���€�ð�=Š=Ø×3Ñ3×:Ñ:¸4Õ@ð�r!���c�����������������ó���—�y)aŽ��
        Create directory entry at path

        For systems that don't have true directories, may create an for
        this instance only and not touch the real filesystem

        Parameters
        ----------
        path: str
            location
        create_parents: bool
            if True, this is equivalent to ``makedirs``
        kwargs:
            may be permissions, etc.
        Nr���©rb���rƒ���Úcreate_parentsr���s���    r���ÚmkdirzAbstractFileSystem.mkdir��s���€�ð �	
r!���c�����������������ó���—�y)a‚��Recursively make directories

        Creates directory at path and any intervening required directories.
        Raises exception if, for instance, the path already exists but is a
        file.

        Parameters
        ----------
        path: str
            leaf directory name
        exist_ok: bool (False)
            If False, will error if the target already exists
        Nr���©rb���rƒ���Úexist_oks���   r���ÚmakedirszAbstractFileSystem.makedirs*��s���€�ð�	
r!���c�����������������ó���—�y)zRemove a directory, if emptyNr���r–���s���  r���ÚrmdirzAbstractFileSystem.rmdir:��ó���€�àr!���c����������������ó���—�t���������‚)ap��List objects at path.

        This should include subdirectories and files at that location. The
        difference between a file and a directory must be clear when details
        are requested.

        The specific keys, or perhaps a FileInfo class, or similar, is TBD,
        but must be consistent across implementations.
        Must include:

        - full path to the entry (without protocol)
        - size of the entry, in bytes. If the value cannot be determined, will
          be ``None``.
        - type of entry, "file", "directory" or other

        Additional information
        may be present, appropriate to the file-system, e.g., generation,
        checksum, etc.

        May use refresh=True|False to allow use of self._ls_from_cache to
        check for a saved listing and avoid calling the backend. This would be
        common where listing may be expensive.

        Parameters
        ----------
        path: str
        detail: bool
            if True, gives a list of dictionaries, where each is the same as
            the result of ``info(path)``. If False, gives a list of paths
            (str).
        kwargs: may have additional backend-specific options, such as version
            information

        Returns
        -------
        List of strings if detail is False, or list of directory information
        dicts if detail is True.
        rd���©rb���rƒ���Údetailr���s���    r���ÚlszAbstractFileSystem.ls>��s���€�ôN�"Ð!r!���c����������������óh��—�|�j������������������|«������}	�|�j������������������|j������������������d«���������S�#�t��������$�r�Y�nw�xY�w	�|�j������������������|���D�cg�c]+��}|d���|k(��s|d���|j������������������d«������k(��r
|d���dk(��r|‘Œ-�nc�c}w�}}t	��������|«������dk(��rt��������|«������‚|S�#�t��������$�r�Y�yw�xY�w)z¦Check cache for listing

        Returns listing, if found (may be empty list for a directly that exists
        but contains nothing), None if not in cache.
        rR���r‡���rr���Ú	directoryr���N)Ú_parentr^���r���ÚKeyErrorr€���ÚFileNotFoundError)rb���rƒ���ÚparentÚfÚfiless���     r���Ú_ls_from_cachez!AbstractFileSystem._ls_from_cacheg��sÎ���€�ð�—‘˜dÓ#ˆð	Ø—=‘= §¡¨SÓ!1Ñ2Ð2øÜò�	Ùð	úð	ð�Ÿ™ vÑ.öàؐV‘9 Ò$ؐf‘I §¡¨SÓ!1Ò1°a¸±iÀ;Ò6Nò�ñùò�ˆEð�ô�5‹z˜QŠä'¨Ó-Ð-؈LøÜò�	Ùð	ús*���“1�±	=¼=ÁB%�Á0BÂ"B%�Â%	B1Â0B1c��������������+��óÂ��K��—�||dk��rt��������d«������‚|�j������������������|«������}i�}i�}i�}|j������������������dd«������}		��|�j������������������|fddi|¤Ž}
|
D�]S��}|d���j������������������d	«������}
|
j������������������d	d«������d
���}|d���dk(��r|
|k7��r|
||<���|||<���ŒD|
|k(��r||d
<���ŒO|||<���ŒU�|	st��������|«������}t��������|«������}|r|||f–—�||dz��}|dk��r
|s|||f–—�y|D�]$��}�|�j������������������||���f||	|dœ|¤ŽE�d{��–—†��Œ&�|s|||f–—�yy#�t��������t
��������f$�r4}|dk(��r‚�t
��������|«������r�||«�������|	r
|i�i�fcY�d}~S�|g�g�fcY�d}~S�d}~ww�xY�w7�ŒW­w)aÍ��Return all files belows path

        List all files, recursing into subdirectories; output is iterator-style,
        like ``os.walk()``. For a simple list of files, ``find()`` is available.

        When topdown is True, the caller can modify the dirnames list in-place (perhaps
        using del or slice assignment), and walk() will
        only recurse into the subdirectories whose names remain in dirnames;
        this can be used to prune the search, impose a specific order of visiting,
        or even to inform walk() about directories the caller creates or renames before
        it resumes walk() again.
        Modifying dirnames when topdown is False has no effect. (see os.walk)

        Note that the "files" outputted will include anything that is not
        a directory, such as links.

        Parameters
        ----------
        path: str
            Root to recurse into
        maxdepth: int
            Maximum recursion depth. None means limitless, but not recommended
            on link-based file-systems.
        topdown: bool (True)
            Whether to walk the directory tree from the top downwards or from
            the bottom upwards.
        on_error: "omit", "raise", a collable
            if omit (default), path with exception will simply be empty;
            If raise, an underlying exception will be raised;
            if callable, it will be called with a single OSError instance as argument
        kwargs: passed to ``ls``
        Nr���úmaxdepth must be at least 1r§���FTÚraiser‡���rR���éÿÿÿÿrr���rª���rU���)Úmaxdepthr§���Útopdown)Ú
ValueErrorr}���r=���r¨���r­���ÚOSErrorÚcallabler���Úrsplitr|���Úwalk)rb���rƒ���r¶���r·���Úon_errorr���Ú	full_dirsÚdirsr°���r§���ÚlistingÚeÚinfoÚpathnamer‡���Úds���                r���r¼���zAbstractFileSystem.walk€��sà��è�ø€�ðB�РH¨q¢LÜÐ:Ó;Ð;à×#Ñ# DÓ)ˆØˆ	ØˆØˆà—‘˜H eÓ,ˆð		 ؐd—g‘g˜dÑ:¨4Ð:°6Ñ:ˆGó�ˆDð�˜F‘|×*Ñ*¨3Ó/ˆHØ—?‘? 3¨Ó*¨2Ñ.ˆDؐF‰|˜{Ò*¨x¸4Ò/?à"*	˜$‘Ø!T’
ؘTÒ!à b’	à"d’ð�ñ�ܘ“:ˆDܘ“KˆEáà˜˜eÐ#Ò#àÐØ˜‰MˆHؘ!Š|ÙØ  eÐ+Ò+ØãˆAØ t—y‘yؘ!‘ðà!ØØñ	ð
�ñ÷�
ñ�
ð�ñ�à˜˜eÐ#Ó#ð�øôa�"¤7Ð+ò�	 ؘ7Ò"Øܘ(Ô#Ù˜”ÙؘR |Õ#ؘ˜R<Õûð	 úðP
úsS���‚<E¿D�ÁB1EÄEÄEÄEÄ&EÅEÅEÅEÅEÅEÅEÅEc�����������	�����óÜ��—�|�j������������������|«������}i�}|r*|dk7��r%|�j������������������|«������r|�j������������������|«������||<����|�j������������������||fddi|¤ŽD�]O��\��}}}	|r|	j	������������������|«�������|j	������������������|	j������������������«�������D�
ci�c]��\��}
}|d���|“Œ
�c}}
«�������ŒQ�|s|�j
������������������|«������ri�||<���t��������|«������}|s|S�|D�
ci�c]��}
|
||
���“Œ
�c}
S�c�c}}
w�c�c}
w�)a½��List all files below path.

        Like posix ``find`` command without conditions

        Parameters
        ----------
        path : str
        maxdepth: int or None
            If not None, the maximum number of levels to descend
        withdirs: bool
            Whether to include directory paths in the output. This is True
            when used by glob, but users usually only want files.
        kwargs are passed to ``ls``.
        rU���r§���Tr‡���)r}���ÚisdirrÂ���r¼���ÚupdateÚitemsÚisfileÚsorted)
rb���rƒ���r¶���Úwithdirsr§���r���ÚoutÚ_r¿���r°���r‡���rÂ���Únamess
���             r���ÚfindzAbstractFileSystem.findà��sñ���€�ð �×#Ñ# DÓ)ˆØˆñ�˜ š
 t§z¡z°$Ô'7ØŸ	™	 $›ˆC‰Ià'˜dŸi™i¨¨hÑN¸tÐNÀvÔN‰NˆAˆtUÙØ—‘˜TÔ"ØJ‰J¸U¿[¹[»]×K©z¨t°T˜˜V™ dÑ*ÓKÕLð�Oñ�t—{‘{ 4Ô(ð�ˆC‰Iܐs“ˆÙ؈Là05Ö6¨D˜#˜d™)‘OÒ6Ð6ùó�Lùò�7s���ÂC#Ã
C)c����������������ó��—�i�}|r-|�j������������������|«������r|�j������������������|«������}|d���||d���<����|�j������������������|f||dœ|¤ŽD�]��}|�j������������������|«������}|d���||d���<���Œ �|rt��������|j	������������������«�������«������S�|S�)as��Space used by files and optionally directories within a path

        Directory size does not include the size of its contents.

        Parameters
        ----------
        path: str
        total: bool
            Whether to sum all the file sizes
        maxdepth: int or None
            Maximum number of directory levels to descend, None for unlimited.
        withdirs: bool
            Whether to include directory paths in the output.
        kwargs: passed to ``find``

        Returns
        -------
        Dict of {path: size} if total=False, or int otherwise, where numbers
        refer to bytes used.
        Úsizer‡���)r¶���rË���)rÆ���rÂ���rÏ���ÚsumÚvalues)	rb���rƒ���Útotalr¶���rË���r���ÚsizesrÂ���r¯���s	���         r���ÚduzAbstractFileSystem.du��s’���€�ð*�ˆÙ˜Ÿ
™
 4Ô(à—9‘9˜T“?ˆDØ"& v¡,ˆE$v‘,Ñؐ—‘˜4ÐP¨(¸XÑPÈÔPˆAØ—9‘9˜Q“<ˆDØ"& v¡,ˆE$v‘,Òð�Qñ�ܐu—|‘|“~Ó&Ð&àˆLr!���c����������������óÄ��—�||dk��rt��������d«������‚ddl}t��������j������������������j������������������r4t��������j������������������j
������������������t��������j������������������j������������������fnt��������j������������������j
������������������f}|j
������������������|«������}|�j������������������|«������}|xs!�|j
������������������t��������d„�|D�«�������«������«������}|j������������������d«������dk\��r|j������������������d«������n
t��������|«������}|j������������������d«������dk\��r|j������������������d«������n
t��������|«������}	|j������������������d«������dk\��r|j������������������d«������n
t��������|«������}
t��������||	|
«������}|j������������������d	d
«������}t��������|«������s3�|�j������������������|fi�|¤Žr|s|gS�|�|�j������������������|fi�|¤ŽiS�|sg�S�i�S�d|d|�v�r7|d|�j!������������������d«������}|d|dz����}
||dz���d�j#������������������d«������dz���}nd}
||dz���d�j#������������������d«������dz���}d
|v�r5|1|j������������������d
«������}||d�j#������������������d«������dz���}||z
��|z���}nd}�|�j������������������|
f|dddœ|¤Ž}t%��������||rdndz���«������}|j'������������������|«������}t)��������|j+������������������«�������«������D�ci�c](��\��}}|j-������������������|r
|d���dk(��r|dz���n|«������r||“Œ*�}}}|r|S�t/��������|«������S�c�c}}w�)aJ��
        Find files by glob-matching.

        If the path ends with '/', only folders are returned.

        We support ``"**"``,
        ``"?"`` and ``"[..]"``. We do not support ^ for pattern negation.

        The `maxdepth` option is applied on the first `**` found in the path.

        kwargs are passed to ``ls``.
        Nr���r³���r���c��������������3��ó&���K��—�|�]	��}|d�z���–—�Œ�y­w)ú**Nr���)r4���Úseps���  r���r6���z*AbstractFileSystem.glob.<locals>.<genexpr>>��s���è�ø€�Ò- #˜•*Ñ-ùs���‚Ú*ú?ú[r§���FrR���rU���rÙ���T©r¶���rË���r§���rr���rª���)r¸���Úrer,���rƒ���ÚaltseprÚ���Úendswithr}���r9���rÏ���r€���Úminr=���r���ÚexistsrÂ���ÚrindexÚcountr���ÚcompilerÊ���rÈ���Úmatchr|���)rb���rƒ���r¶���r���rß���ÚsepsÚ
ends_with_sepÚappend_slash_to_dirnameÚidx_starÚ	idx_qmarkÚ	idx_braceÚmin_idxr§���ÚrootÚdepthÚidx_double_starsÚdepth_double_starsÚallpathsÚpatternr„���rÂ���rÌ���s���                      r���ÚglobzAbstractFileSystem.glob(��sß��€�ð�РH¨q¢LÜÐ:Ó;Ð;ãä02·±·²”—‘—‘œRŸW™WŸ^™^Ñ,ÄRÇWÁWÇ[Á[ÀNˆØŸ
™
 dÓ+ˆ
Ø×#Ñ# DÓ)ˆØ"/ò�#
°4·=±=ÜÑ-¨Ô-Ó-ó4
Ðð�&*§Y¡Y¨s£^°qÒ%84—9‘9˜S”>¼cÀ$»iˆØ&*§i¡i°£n¸Ò&9D—I‘I˜c”N¼sÀ4»yˆ	Ø&*§i¡i°£n¸Ò&9D—I‘I˜c”N¼sÀ4»yˆ	äh 	¨9Ó5ˆà—‘˜H eÓ,ˆä˜ŒØˆt{‰{˜4Ñ* 6Ò*ÙØ ˜6Mà  ) $§)¡)¨DÑ";°FÑ";Ð<Ð<áؐIàIØ
D˜˜'NÑ
"ؘ8˜Gn×+Ñ+¨CÓ0ˆGؘ
˜' A™+Ð&ˆDؘ 1™˜Ð'×-Ñ-¨cÓ2°QÑ6‰EàˆDؘ 1™˜Ð'×-Ñ-¨cÓ2°QÑ6ˆEà4‰<ØÐ#Ø#'§9¡9¨T£?Ð Ø%)Ð*:Ð*;Ð%<×%BÑ%BÀ3Ó%GÈ!Ñ%KÐ"ØÐ 2Ñ2°XÑ=‘àà4—9‘9˜TÐX¨E¸DÈÑXÐQWÑXˆä  ±
©À2Ñ!FÓGˆØ—*‘*˜WÓ%ˆô�" (§.¡.Ó"2Ó3÷

ᐐ4؏}‰}ñ�/°4¸±<À;Ò3Nð�˜’Gàô	ð�
ˆt‰Gð

ˆñ�

ñ�؈J䘓9Ðùó

s���Ê-Kc����������������ó:���—�	��|�j�������������������|fi�|¤Ž�y#��Y�yxY�w)z!Is there a file at the given pathTF©rÂ���©rb���rƒ���r���s���   r���rã���zAbstractFileSystem.existsy��s'���€�ð	ØˆDI‰IdÑ%˜fÒ%Øøð	áús���‚�–c����������������ó$���—�|�j������������������|«������S�)zEIf there is a file at the given path (including
        broken links))rã���rø���s���   r���ÚlexistszAbstractFileSystem.lexists‚��s���€�ð�{‰{˜4Ó Ð r!���c����������������óü��—�|�j������������������|«������}�|�j������������������|�j������������������|«������fddi|¤Ž}|D�cg�c]��}|d���j������������������d«������|k(��sŒ|‘Œ�}}|r|d���S��|�j������������������|fddi|¤Ž}|j������������������d«������}|D�cg�c]��}|d���j������������������d«������|k(��sŒ|‘Œ�}}t	��������|«������dk(��rd|d���vrd|d���d<���|d���S�t	��������|«������dkD��s|r|dd	d
œS�t��������|«������‚c�c}w�c�c}w�)ag��Give details of entry at path

        Returns a single dictionary, with exactly the same information as ``ls``
        would with ``detail=True``.

        The default implementation should calls ls and could be overridden by a
        shortcut. kwargs are passed on to ```ls()``.

        Some file systems might not be able to measure the file's size, in
        which case, the returned dict will include ``'size': None``.

        Returns
        -------
        dict with keys: name (full path in the FS), size (in bytes), type (file,
        directory, or something else) and other FS-specific keys.
        r§���Tr‡���rR���r���r���rÑ���Nrª���)r‡���rÑ���rr���)r}���r¨���r«���r���r€���r­���)rb���rƒ���r���rÌ���ÚoÚout1s���      r���rÂ���zAbstractFileSystem.info‡��s��€�ð"�×#Ñ# DÓ)ˆØˆdg‰gd—l‘l 4Ó(Ñ@°Ð@¸Ñ@ˆØÖ?Q  6¡×!1Ñ!1°#Ó!6¸$Ó!>ŠqÐ?ˆÐ?Ùؐq‘6ˆM؈dg‰gdÑ2 4Ð2¨6Ñ2ˆØ{‰{˜3ÓˆØÖ@a ! F¡)×"2Ñ"2°3Ó"7¸4Ó"?’Ð@ˆÐ@܈t‹9˜Š>ؘT !™WÑ$Ø"&Q‘˜‘ؘ‘7ˆNÜ
‹Y˜Š]™cØ ¨!°[ÑAÐAä# DÓ)Ð)ùò�@ùò
�As���ºC4ÁC4ÂC9Â+C9c����������������óJ���—�t��������t��������|�j������������������|«������«������d«������S�)aª��Unique value for current version of file

        If the checksum is the same from one moment to another, the contents
        are guaranteed to be the same. If the checksum changes, the contents
        *might* have changed.

        This should normally be overridden; default will probably capture
        creation/modification timestamp (which would be good) or maybe
        access timestamp (which would be bad)
        rm���)rn���r���rÂ���r–���s���  r���ÚchecksumzAbstractFileSystem.checksum©��s���€�ô�”8˜DŸI™I d›OÓ,¨bÓ1Ð1r!���c����������������óD���—�|�j������������������|«������j������������������dd«������S�)zSize in bytes of filerÑ���N)rÂ���r(���r–���s���  r���rÑ���zAbstractFileSystem.size¶��s���€�ày‰y˜‹×"Ñ" 6¨4Ó0Ð0r!���c����������������óJ���—�|D�cg�c]��}|�j������������������|«������‘Œ�c}S�c�c}w�)z-Size in bytes of each file in a list of paths)rÑ���)rb���Úpathsr„���s���   r���rÕ���zAbstractFileSystem.sizesº��s���€�à&+Ö, —	‘	˜!•Ò,Ð,ùÒ,s���… c����������������óP���—�	�|�j������������������|«������d���dk(��S�#�t��������$�r�Y�yw�xY�w)zIs this entry directory-like?rr���rª���F)rÂ���r¹���r–���s���  r���rÆ���zAbstractFileSystem.isdir¾��s1���€�ð	Ø—9‘9˜T“? 6Ñ*¨kÑ9Ð9øÜò�	Ùð	ús���‚�™	%¤%c����������������ó@���—�	�|�j������������������|«������d���dk(��S�#��Y�yxY�w)zIs this entry file-like?rr���ÚfileFr÷���r–���s���  r���rÉ���zAbstractFileSystem.isfileÅ��s)���€�ð	Ø—9‘9˜T“? 6Ñ*¨fÑ4Ð4øð	Ùús���‚�™c����������������ó~���—��|�j�������������������|fd|||dœ|¤Ž5�}|j������������������«�������cddd«�������S�#�1�sw�Y���yxY�w)zÊGet the contents of the file as a string.

        Parameters
        ----------
        path: str
            URL of file on this filesystems
        encoding, errors, newline: same as `open`.
        Úr©ÚmodeÚencodingÚerrorsÚnewlineN©ÚopenÚread)rb���rƒ���r
��r��r��r���r¯���s���       r���Ú	read_textzAbstractFileSystem.read_textÌ��sS���€�ð�ˆTY‰YØð
àØØØñ
ð�ñ

ð�	ð�Ø—6‘6“8÷	÷�	ò�	ús���™3³<c����������������ó€���—��|�j�������������������|fd|||dœ|¤Ž5�}|j������������������|«������cddd«�������S�#�1�sw�Y���yxY�w)a��Write the text to the given file.

        An existing file will be overwritten.

        Parameters
        ----------
        path: str
            URL of file on this filesystems
        value: str
            Text to write.
        encoding, errors, newline: same as `open`.
        Úwr��N©r��Úwrite)rb���rƒ���Úvaluer
��r��r��r���r¯���s���        r���Ú
write_textzAbstractFileSystem.write_textß��sU���€�ð�ˆTY‰YØð
àØØØñ
ð�ñ

ð�	"ð�Ø—7‘7˜5“>÷	"÷�	"ò�	"ús���™4´=c����������������óz��—��|�j�������������������|dfi�|¤Ž5�}|?|dk\��r|j������������������|«�������n(|j������������������t��������d|j������������������|z���«������«�������|?|dk��r|j������������������|z���}|j	������������������||j������������������«�������z
��«������cddd«�������S�|j	������������������«�������cddd«�������S�#�1�sw�Y���yxY�w)ah��Get the content of a file

        Parameters
        ----------
        path: URL of file on this filesystems
        start, end: int
            Bytes limits of the read. If negative, backwards from end,
            like usual python slices. Either can be None for start or
            end of file, respectively
        kwargs: passed to ``open()``.
        ÚrbNr���)r��ÚseekÚmaxrÑ���r��Útell)rb���rƒ���ÚstartÚendr���r¯���s���      r���Úcat_filezAbstractFileSystem.cat_fileø��s§���€�ð�ˆTY‰Yt˜TÑ
, VÑ
,ð�
	°ØРؘA’:Ø—F‘F˜5•Mà—F‘Fœ3˜q !§&¡&¨5¡.Ó1Ô2؈ؘ’7ØŸ&™& 3™,CØ—v‘v˜c A§F¡F£H™nÓ-÷
	ñ�
	ð�—6‘6“8÷
	÷�
	ò�
	ús���•A9B1ÂB1Â1B:c����������������óx���—��|�j�������������������|dfi�|¤Ž5�}|j������������������|«�������ddd«�������y#�1�sw�Y���yxY�w)zSet the bytes of given fileÚwbNr��)rb���rƒ���r��r���r¯���s���     r���Ú	pipe_filezAbstractFileSystem.pipe_file��s9���€�à
ˆTY‰Yt˜TÑ
, VÑ
,ð�	°Ø
G‰GEŒN÷	÷�	ñ�	ús���•0°9c����������������ó��—�t��������|t��������«������r$�|�j������������������|�j������������������|«������|fi�|¤Ž�yt��������|t��������«������r<|j������������������«�������D�](��\��}}�|�j������������������|�j������������������|«������|fi�|¤Ž�Œ*�yt
��������d«������‚)aŸ��Put value into path

        (counterpart to ``cat``)

        Parameters
        ----------
        path: string or dict(str, bytes)
            If a string, a single remote location to put ``value`` bytes; if a dict,
            a mapping of {path: bytesvalue}.
        value: bytes, optional
            If using a single path, these are the bytes to put there. Ignored if
            ``path`` is a dict
        zpath must be str or dictN)rq���r~���r!��r}���ÚdictrÈ���r¸���)rb���rƒ���r��r���ÚkÚvs���      r���ÚpipezAbstractFileSystem.pipe��sz���€�ô�dœCÔ ØˆDN‰N˜4×/Ñ/°Ó5°uÑGÀÓGÜ
˜œdÔ
#ØŸ
™
ž‘1ؐ—‘˜t×3Ñ3°AÓ6¸ÑD¸VÓDñ�%ô�Ð7Ó8Ð8r!���c����������������óø��—�|t���������‚t��������|t��������«������st��������‚t��������|t��������«������s|gt	��������|«������z��}t��������|t��������«������s|gt	��������|«������z��}t	��������|«������t	��������|«������k7��st	��������|«������t	��������|«������k7��rt
��������‚g�}t
��������|||«������D�])��\��}}	}
	�|j������������������|�j������������������||	|
«������«�������Œ+�|S�#�t��������$�r"}
|dk(��r|j������������������|
«�������n‚�Y�d}
~
ŒTd}
~
ww�xY�w)aY��Get the contents of byte ranges from one or more files

        Parameters
        ----------
        paths: list
            A list of of filepaths on this filesystems
        starts, ends: int or list
            Bytes limits of the read. If using a single int, the same value will be
            used to read all the specified files.
        NÚreturn)
re���rq���r|���Ú	TypeErrorr€���r¸���Úzipr™���r��Ú	Exception)rb���r��ÚstartsÚendsÚmax_gapr½���r���rÌ���r„���ÚsrÁ���s���           r���Ú
cat_rangeszAbstractFileSystem.cat_ranges,��sè���€�ð�ÐÜ%Ð%ܘ%¤Ô&܈Oܘ&¤$Ô'ؐX¤ E£
Ñ*ˆFܘ$¤Ô%ؐ6œC ›JÑ&ˆD܈v‹;œ#˜e›*Ò$¬¨D«	´S¸³ZÒ(?ÜÐ؈ܘ5 &¨$Ö/‰GˆAˆq!ð
Ø—
‘
˜4Ÿ=™=¨¨A¨qÓ1Õ2ð�0ð�ˆ
øô�ò�
ؘxÒ'Ø—J‘J˜q•Màô�"ûð
ús���Â("CÃ	C9ÃC4Ã4C9c����������������óN��—�|�j������������������||¬«������}t��������|«������dkD��s't��������|t��������«������s|d���|�j	������������������|«������k7��r"i�}|D�]��}	��|�j
������������������|fi�|¤Ž||<���Œ�|S��|�j
������������������|d���fi�|¤ŽS�#�t��������$�r}|dk(��r‚�|dk(��r|||<���Y�d}~ŒRd}~ww�xY�w)a��Fetch (potentially multiple) paths' contents

        Parameters
        ----------
        recursive: bool
            If True, assume the path(s) are directories, and get all the
            contained files
        on_error : "raise", "omit", "return"
            If raise, an underlying exception will be raised (converted to KeyError
            if the type is in self.missing_exceptions); if omit, keys with exception
            will simply not be included in the output; if "return", all keys are
            included in the output, but the value will be bytes or an exception
            instance.
        kwargs: passed to cat_file

        Returns
        -------
        dict of {path: contents} if there are multiple paths
        or the path has been otherwise expanded
        ©Ú	recursiver���r���r´���r(��N)Úexpand_pathr€���rq���r|���r}���r��r+��)rb���rƒ���r3��r½���r���r��rÌ���rÁ���s���        r���ÚcatzAbstractFileSystem.catN��sÂ���€�ð*�× Ñ  °Ð Ó;ˆä‹J˜ŠNܘ$¤Ô%ؐQ‰x˜4×/Ñ/°Ó5Ò5àˆCېð&Ø - §
¡
¨dÑ =°fÑ =C˜’Ið�ð�ˆJà 4—=‘=  q¡Ñ4¨VÑ4Ð4øô�!ò�&Ø 7Ò*ØØ 8Ò+Ø$%˜˜D™	ÿøð	&ús���ÁBÂ	B$Â
BÂB$c����������������ó˜��—�ddl�m}�t��������|«������r|}n)|�j������������������|«������rt	��������j
������������������|d¬«�������y�|d¬«������}|j������������������|j
������������������|«������d¬«��������|�j������������������|dfi�|¤Ž5�}|€t��������|d«������}	�|j������������������t��������|d	d«������«�������d}	|	rM|j������������������|�j������������������«������}	|j������������������|	«������}
|
€t��������|	«������}
|j������������������|
«�������|	rŒMt��������|«������s|j������������������«��������	�ddd«�������y#�t��������|«������s|j������������������«��������w�w�xY�w#�1�sw�Y���yxY�w)
z Copy single remote file to localr���)ÚLocalFileSystemT©r ���N)Ú
auto_mkdirr��r ��rÑ���)Úimplementations.localr7��r���rÆ���r,���r¡���r«���r��Úset_sizer3���r��Ú	blocksizer��r€���Úrelative_updateÚclose)rb���ÚrpathÚlpathÚcallbackÚoutfiler���r7��ÚfsÚf1ÚdataÚsegment_lens���           r���Úget_filezAbstractFileSystem.get_filev��s'��€�å:äeÔ؉GØ
Z‰Z˜Ô
ÜK‰K˜¨Õ-Øá
¨Ô
-ˆØ
‰B—J‘J˜uÓ%°ˆÔ5à
ˆTY‰Yu˜dÑ
- fÑ
-ð�	$°ØˆÜ˜u dÓ+ð
$Ø×!Ñ!¤'¨"¨f°dÓ";Ô<ؐÙØŸ7™7 4§>¡>Ó2DØ")§-¡-°Ó"5KØ"Ð*Ü&)¨$£i˜Ø×,Ñ,¨[Ô9ò�ô�" %Ô(Ø—M‘M•O÷	$ð�	$øô�" %Ô(Ø—M‘M•Oð�)ú÷	$ð�	$ús%���Á=E�Â
A,DÃ:E�ÄD=Ä=E�Å�E	c����������������ó>��—�t��������|t��������«������rt��������|t��������«������r|}|}nùddlm}	m}
m}�t��������|t��������«������}|�j������������������|||¬«������}|r1|r|-|D�
cg�c]��}
�||
«������rŒ|�j������������������|
«������rŒ|
‘Œ!�}}
|syt��������|t��������«������r�|
|«������}t��������|«������dk(��}t��������|t��������«������xr ��||«������xs��|	«�������j������������������|«������}|xr,�t��������|«������xr�|xs�t��������|«�������xr
�|xr	��||«�������}t��������||||�¬«������}|j������������������t��������|«������«�������|j������������������t��������||«������«������D�]6��\��}}|j������������������||«������5�}�|�j ������������������||fd|i|¤Ž�ddd«�������Œ8�yc�c}
w�#�1�sw�Y���ŒHxY�w)aT��Copy file(s) to local.

        Copies a specific file or tree of files (if recursive=True). If lpath
        ends with a "/", it will be assumed to be a directory, and target files
        will go within. Can submit a list of paths, which may be glob-patterns
        and will be expanded.

        Calls get_file for each source.
        r���©r7��Úmake_path_posixÚtrailing_sep©r3��r¶���N©rã���ÚflattenrA��)rq���r|���r:��r7��rJ��rK��r~���r4��rÆ���r€���r���r���r;��Úwrapr*��ÚbranchedrG��)rb���r?��r@��r3��rA��r¶���r���ÚrpathsÚlpathsr7��rJ��rK��Ú
source_is_strr„���Úsource_is_fileÚdest_is_dirrã���Úchilds���                  r���r(���zAbstractFileSystem.get”��s´��€�ô$�eœTÔ"¤z°%¼Ô'>ð�ˆF؉F÷
ñ�
ô�' u¬cÓ2ˆMØ×%Ñ% e°yÈ8Ð%ÓTˆFÙ¡i°8Ð3Gà%+ÖV ±LÀµOÀtÇzÁzÐRSÅ}š!ÐVÐVÙØä˜%¤Ô%Ù'¨Ó.ä  ›[¨AÑ-ˆNÜ$ U¬CÓ0ò�Ù˜UÓ#ÒE¡Ó'8×'>Ñ'>¸uÓ'Eð�
ð�#ò�ܘ5Ó!Ò4 nò�VÜ! %Ó(Ð(ÒT¨[ÒTÁÈeÓATÐ=Tð�
ô�!ØØØØ)Ð)ô	ˆFð�	×Ñœ#˜f›+Ô&Ø$ŸM™M¬#¨f°fÓ*=Ö>‰LˆE5Ø×"Ñ" 5¨%Ó0ð�
F°Eؐ—
‘
˜e UÑE°UÐE¸fÒE÷
Fð�
Fñ�?ùò1�W÷2
Fð�
Fús���Á
FÁ,FÁ>FÅ,FÆF	c����������������ó²��—�t���������j������������������j������������������|«������r|�j������������������|d¬«�������yt	��������|d«������5�}|j������������������dd«������}|j
������������������|«�������|j������������������d«�������|�j������������������|�j������������������t��������j������������������|«������«������d¬«��������|�j������������������|dfi�|¤Ž5�}|j������������������«�������|k��r^|j������������������|�j������������������«������}|j������������������|«������}	|	€t��������|«������}	|j������������������|	«�������|j������������������«�������|k��rŒ^ddd«�������ddd«�������y#�1�sw�Y���ŒxY�w#�1�sw�Y���yxY�w)zCopy single file to remoteTr8��Nr��r���r{���r ��)r,���rƒ���rÆ���r¡���r��r��r;��Úmkdirsr«���Úfspathr��r��r<��r��r€���r=��)
rb���r@��r?��rA��r���rD��rÑ���Úf2rE��rF��s
���          r���Úput_filezAbstractFileSystem.put_fileÒ��s��€�ä
7‰7=‰=˜ÔØM‰M˜%¨$ˆMÔ/Øä
%˜Ó
ð�	: "Ø—7‘7˜1˜a“=ˆDØ×Ñ˜dÔ#ØG‰GAŒJàK‰K˜Ÿ™¤R§Y¡Y¨uÓ%5Ó6ÀˆKÔFؐ—‘˜5 $Ñ1¨&Ñ1ð�
:°RØ—g‘g“i $Ò&ØŸ7™7 4§>¡>Ó2DØ"$§(¡(¨4£.KØ"Ð*Ü&)¨$£i˜Ø×,Ñ,¨[Ô9ð�—g‘g“i $Ó&÷
:÷
	:ð�	:÷
:ð�
:ú÷
	:ð�	:ús&���Á�A>E
Â>A1EÄ0E
ÅE
	ÅE
Å
Ec����������������ó²��—�t��������|t��������«������rt��������|t��������«������r|}|}n-ddlm}	m}
m}�t��������|t��������«������}|r�|
|«������}�|	«�������}
|
j������������������|||¬«������}|r1|r|-|D�cg�c]��}�||«������rŒ|
j������������������|«������rŒ|‘Œ!�}}|syt��������|«������dk(��}t��������|t��������«������xr��||«������xs�|�j������������������|«������}t��������|t��������«������r|�j������������������|«������n|D�cg�c]��}|�j������������������|«������‘Œ�c}}|xr,�t��������|«������xr�|xs�t��������|«�������xr
�|xr	��||«�������}t��������||||�¬«������}|j������������������t��������|«������«�������|j������������������t��������||«������«������D�]6��\��}}|j!������������������||«������5�}�|�j"������������������||fd|i|¤Ž�ddd«�������Œ8�yc�c}w�c�c}w�#�1�sw�Y���ŒMxY�w)a��Copy file(s) from local.

        Copies a specific file or tree of files (if recursive=True). If rpath
        ends with a "/", it will be assumed to be a directory, and target files
        will go within.

        Calls put_file for each source.
        r���rI��rL��NrM��rA��)rq���r|���r:��r7��rJ��rK��r~���r4��rÆ���r€���r}���r���r���r;��rO��r*��rP��r[��)rb���r@��r?��r3��rA��r¶���r���rQ��rR��r7��rJ��rK��rS��rC��r„���rT��rU��rã���rV��s���                   r���ÚputzAbstractFileSystem.putæ��sì��€�ô"�eœTÔ"¤z°%¼Ô'>ð�ˆFØŠF÷
ñ�
ô�' u¬cÓ2ˆMÙÙ'¨Ó.Ù Ó"ˆBØ—^‘^ E°YȐ^ÓRˆFÙ¡i°8Ð3Gà%+ÖT ±LÀµOÀrÇxÁxÐPQÅ{š!ÐTÐTÙØä  ›[¨AÑ-ˆNÜ$ U¬CÓ0ò�Ù˜UÓ#Ò8 t§z¡z°%Ó'8ð�
ô�˜e¤SÔ)ð�×$Ñ$ UÔ+à7<Ö=°!d×*Ñ*¨1Õ-Ò=ð�
ð
�#ò�ܘ5Ó!Ò4 nò�VÜ! %Ó(Ð(ÒT¨[ÒTÁÈeÓATÐ=Tð�
ô�!ØØØØ)Ð)ô	ˆFð�	×Ñœ#˜f›+Ô&Ø$ŸM™M¬#¨f°fÓ*=Ö>‰LˆE5Ø×"Ñ" 5¨%Ó0ð�
F°Eؐ—
‘
˜e UÑE°UÐE¸fÒE÷
Fð�
Fñ�?ùò5�Uùò�>÷
Fð�
Fús$���Á0
GÁ>GÂGÃ9GÆ!G
Ç
G	c����������������ót���—�|�j������������������|d«������5�}|j������������������|«������cddd«�������S�#�1�sw�Y���yxY�w)z&Get the first ``size`` bytes from filer��Nr
��©rb���rƒ���rÑ���r¯���s���    r���ÚheadzAbstractFileSystem.head(��s2���€�à
Y‰Yt˜TÓ
"ð�	  aØ—6‘6˜$“<÷	 ÷�	 ò�	 ús���“.®7c����������������óÂ���—�|�j������������������|d«������5�}|j������������������t��������|�|j�������������������«������d«�������|j	������������������«�������cddd«�������S�#�1�sw�Y���yxY�w)z%Get the last ``size`` bytes from filer��r{���N)r��r��r��rÑ���r��r_��s���    r���ÚtailzAbstractFileSystem.tail-��sM���€�à
Y‰Yt˜TÓ
"ð�	 aØ
F‰F”3˜u˜qŸv™v˜gÓ&¨Ô*Ø—6‘6“8÷	÷�	ò�	ús���“8AÁAc����������������ó���—�t���������‚r���rd���©rb���Úpath1Úpath2r���s���    r���Úcp_filezAbstractFileSystem.cp_file3��s���€�Ü!Ð!r!���c����������������óš��—�|€|rd}n|€d}t��������|t��������«������rt��������|t��������«������r|}|}nØddlm}	�t��������|t��������«������}
|�j������������������|||¬«������}|
r1|r|-|D�cg�c]��}�|	|«������rŒ|�j
������������������|«������rŒ|‘Œ!�}}|syt��������|«������dk(��}t��������|t��������«������xr��|	|«������xs�|�j
������������������|«������}
|
xr,�t��������|«������xr�|xs�t��������|«�������xr
�|
xr	��|	|«�������}t��������||||
�¬«������}t��������||«������D�]��\��}}	��|�j������������������||fi�|¤Ž�Œ�yc�c}w�#�t��������$�r	�|dk(��r‚�Y�Œ4w�xY�w)a?��Copy within two locations in the filesystem

        on_error : "raise", "ignore"
            If raise, any not-found exceptions will be raised; if ignore any
            not-found exceptions will cause the path to be skipped; defaults to
            raise unless recursive is true, where the default is ignore
        NÚignorer´���r���)rK��rL��rM��)
rq���r|���r:��rK��r~���r4��rÆ���r€���r���r���r*��rg��r­���)rb���re��rf��r3��r¶���r½���r���Úpaths1Úpaths2rK��rS��r„���rT��rU��rã���Úp1Úp2s���                 r���ÚcopyzAbstractFileSystem.copy6��s��€�ð�С	؉HØ
Ð
؈HäeœTÔ"¤z°%¼Ô'>ð�ˆF؉Få;ä& u¬cÓ2ˆMØ×%Ñ% e°yÈ8Ð%ÓTˆFÙ¡i°8Ð3Gà%+ÖV ±LÀµOÀtÇzÁzÐRSÅ}š!ÐVÐVÙØä  ›[¨AÑ-ˆNÜ$ U¬CÓ0ò�Ù˜UÓ#Ò8 t§z¡z°%Ó'8ð�
ð�#ò�ܘ5Ó!Ò4 nò�VÜ! %Ó(Ð(ÒT¨[ÒTÁÈeÓATÐ=Tð�
ô�!ØØØØ)Ð)ô	ˆFô�˜& &Ö)‰FˆBð
ؐ—‘˜R Ñ. vÓ.ñ�*ùò)�Wøô.�%ò�
ؘwÒ&Øñ�'ð
ús$���Á%
D3Á3D3ÂD3ÄD8Ä8E
Å	E
c�����������
�����ó¤��—�||dk��rt��������d«������‚t��������|t��������t��������j������������������f«������r|�j������������������|g||«������}nít
��������«�������}|D�cg�c]��}|�j������������������|«������‘Œ�}}|D�]À��}t��������|«������r`t
���������|�j������������������|fd|i|¤Ž«������}||z��}|r:||dk��rŒ;|t
���������|�j
������������������t��������|«������f|||dz
��nddœ|¤Ž«������z��}Œn|r%t
���������|�j������������������|f|dddœ|¤Ž«������}||z��}||vsŒš|du�s|�j������������������|«������sŒ°|j������������������|«�������ŒÂ�|st��������|«������‚t��������|«������S�c�c}w�)	zÃTurn one or more globs or directories into a list of all matching paths
        to files or directories.

        kwargs are passed to ``glob`` or ``find``, which may in turn call ``ls``
        Nr���r³���r¶���rL��TFrÞ���)r¸���rq���r~���r,���ÚPathLiker4��Úsetr}���r���rõ���r|���rÏ���rã���Úaddr­���rÊ���)	rb���rƒ���r3��r¶���r���rÌ���r„���ÚbitÚrecs	���         r���r4��zAbstractFileSystem.expand_pathl��s…��€�ð�РH¨q¢LÜÐ:Ó;Ð;ädœS¤"§+¡+Ð.Ô/Ø×"Ñ" D 6¨9°hÓ?‰Cä“%ˆCØ59Ö:°D×(Ñ(¨Õ+Ð:ˆDÐ:ېܘQ”<ܘi˜dŸi™i¨ÑG°HÐGÀÑGÓHCؘ3‘JCÙ ð�$Ð/°HÀ²MØ$ØœsØ,˜D×,Ñ,Ü $ S£	ðà*3Ø9AÐ9M¨°AªÐSWñð�#)ñ	ó ñ�˜ð�ÙÜØ!˜Ÿ	™	ØðØ(0¸4ÈñØQWñóCð
�˜3‘JCؘC’< Y°%Ñ%7¸4¿;¹;Àq½>à—G‘G˜A•Jð9�ñ:�Ü# DÓ)Ð)ܐc‹{ÐùòA�;s���ÁE
c����������������óŽ���—�||k(��rt���������j������������������d|�«�������y|�j������������������||||d¬«�������|�j������������������||¬«�������y)z)Move file(s) from one location to anotherz6%s mv: The paths are the same, so no files were moved.r´���)r3��r¶���Úonerrorr2��N)ÚloggerÚdebugrn��Úrm)rb���re��rf��r3��r¶���r���s���      r���ÚmvzAbstractFileSystem.mvœ��sI���€�àEŠ>ÜL‰LÐQÐSWÕXð�
I‰Iؐu¨	¸HÈgð�
ô�
ð�
G‰GE YˆGÕ/r!���c����������������ó&���—�|�j������������������|«�������y)z
Delete a fileN)Ú_rmr–���s���  r���Úrm_filezAbstractFileSystem.rm_file§��s
���€�à‰r!���c����������������ó���—�t���������‚)zDelete one filerd���r–���s���  r���r|��zAbstractFileSystem._rm«��s
���€�ô�"Ð!r!���c����������������ón���—�|�j������������������|||¬«������}t��������|«������D�]��}|�j������������������|«�������Œ�y)aÓ��Delete files.

        Parameters
        ----------
        path: str or list of str
            File(s) to delete.
        recursive: bool
            If file(s) are directories, recursively delete contents and then
            also remove the directory
        maxdepth: int or None
            Depth to pass to walk for finding files to delete, if recursive.
            If None, there will be no limit and infinite recursion may be
            possible.
        rL��N)r4��Úreversedr}��)rb���rƒ���r3��r¶���r„���s���     r���ry��zAbstractFileSystem.rm°��s4���€�ð�×Ñ °	ÀHÐÓMˆÜ˜$–ˆAØL‰L˜Oñ� r!���c����������������ó¾���—�|�j������������������|«������}d|v�r=|j������������������dd«������d���j������������������|�j������������������«������}|�j������������������|z���S�|�j������������������S�)NrR���r���r���)r}���r»���Úlstripr‚���)r���rƒ���r®���s���   r���r«���zAbstractFileSystem._parentÃ��sV���€�à×"Ñ" 4Ó(ˆØ$‰;Ø—[‘[  aÓ(¨Ñ+×2Ñ2°3·?±?ÓCˆFØ—?‘? VÑ+Ð+à—?‘?Ð"r!���c����������������ó&���—�t��������|�||||fd|i|¤ŽS�)z4Return raw bytes-mode file-like from the file-systemÚ
cache_options)ÚAbstractBufferedFile)rb���rƒ���r	��Ú
block_sizeÚ
autocommitr„��r���s���       r���Ú_openzAbstractFileSystem._openÌ��s4���€�ô�$ØØØØØñ
ð�(ð

ð�ñ
ð�	
r!���c�����������	�����ó��—�ddl�}|�j������������������|«������}d|vra|j������������������dd«������dz���}dD�ci�c]��}||v�r||j������������������|«������“Œ�}	}�|j�������������������|�j
������������������||f|||dœ|¤Žfi�|	¤ŽS�|j������������������d|�j�������������������«������}
�|�j������������������|f|||
|d	œ|¤Ž}|'dd
lm	}�ddl
m}
��|
||«������}||���}�|||d���¬«������}|
s)d
|vr%|�j������������������j������������������j������������������|«�������|S�c�c}w�)a6��
        Return a file-like object from the filesystem

        The resultant instance must function correctly in a context ``with``
        block.

        Parameters
        ----------
        path: str
            Target file
        mode: str like 'rb', 'w'
            See builtin ``open()``
        block_size: int
            Some indication of buffering - this is a value in bytes
        cache_options : dict, optional
            Extra arguments to pass through to the cache.
        compression: string or None
            If given, open file using compression codec. Can either be a compression
            name (a key in ``fsspec.compression.compr``) or "infer" to guess the
            compression from the filename suffix.
        encoding, errors, newline: passed on to TextIOWrapper for text mode
        r���NÚbÚtrU���)r
��r��r��)r†��r„��Úcompressionr‡��)r	��r†��r‡��r„��)Úcompr)Úget_compression)r	��r��)Úior}���Úreplacer=���Ú
TextIOWrapperr��r[���rˆ��Úfsspec.compressionr��Úfsspec.corerŽ��r���r°���r™���)rb���rƒ���r	��r†��r„��rŒ��r���r��r$��Útext_kwargsÚacr¯���r��rŽ��Úcompresss���               r���r��zAbstractFileSystem.openà��s^��€�ó>�	à×#Ñ# DÓ)ˆØd‰?Ø—<‘<  RÓ(¨3Ñ.ˆDð�;öàؘ‘;ð�6—:‘:˜a“=Ñ ðˆKð�ð
�$2×#Ñ#ؐ—	‘	ØØðð� *Ø"/Ø +ñð�ñ
ñ
ð�ñ
ð�

ð�—‘˜L¨d¯m©mÐ*;Ó<ˆBؐ—
‘
ØðàØ%ØØ+ñð�ñ
ˆAð�Ð&Ý4Ý7á-¨d°KÓ@Ø  Ñ-Ù˜Q T¨!¡WÔ-á˜# T™/Ø× Ñ ×&Ñ&×-Ñ-¨aÔ0؈HùòIs���³Dc����������������óŠ���—�|s|�j������������������|«������s�|�j������������������|dfi�|¤Ž5��	�ddd«�������yt��������‚#�1�sw�Y���yxY�w)a!��Create empty file, or update timestamp

        Parameters
        ----------
        path: str
            file location
        truncate: bool
            If True, always set file size to 0; if False, update timestamp and
            leave file unchanged, if backend allows this
        r ��N)rã���r��re���)rb���rƒ���Útruncater���s���    r���ÚtouchzAbstractFileSystem.touch+��sL���€�ñ�˜4Ÿ;™; tÔ,ؐ—‘˜4 Ñ0¨Ñ0ñ�
Ø÷
ð�
ô�&Ð%÷
ð�
ús	���¨9¹Ac����������������ó€���—�t��������t��������|�j������������������|«������«������j������������������«�������«������j	������������������«�������S�)z2Hash of file properties, to tell if it has changed)r���r~���rÂ���ÚencodeÚ	hexdigestr–���s���  r���ÚukeyzAbstractFileSystem.ukey<��s,���€�ä”c˜$Ÿ)™) D›/Ó*×1Ñ1Ó3Ó4×>Ñ>Ó@Ð@r!���c����������������ó¬���—�|�j������������������|d«������5�}|j������������������}|€|}|
||z���|kD��r||z
��}t��������||||«������cddd«�������S�#�1�sw�Y���yxY�w)a��Read a block of bytes from

        Starting at ``offset`` of the file, read ``length`` bytes.  If
        ``delimiter`` is set then 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.  The
        bytestring returned WILL include the end delimiter string.

        If offset+length is beyond the eof, reads to eof.

        Parameters
        ----------
        fn: string
            Path to filename
        offset: int
            Byte offset to start read
        length: int
            Number of bytes to read. If None, read to end.
        delimiter: bytes (optional)
            Ensure reading starts and stops at delimiter bytestring

        Examples
        --------
        >>> fs.read_block('data/file.csv', 0, 13)  # doctest: +SKIP
        b'Alice, 100\nBo'
        >>> fs.read_block('data/file.csv', 0, 13, delimiter=b'\n')  # doctest: +SKIP
        b'Alice, 100\nBob, 200\n'

        Use ``length=None`` to read to the end of the file.
        >>> fs.read_block('data/file.csv', 0, None, delimiter=b'\n')  # doctest: +SKIP
        b'Alice, 100\nBob, 200\nCharlie, 300'

        See Also
        --------
        :func:`fsspec.utils.read_block`
        r��N)r��rÑ���r���)rb���ÚfnÚoffsetÚlengthÚ	delimiterr¯���rÑ���s���       r���r���zAbstractFileSystem.read_block@��se���€�ðJ�Y‰Yr˜4Ó
 ð�	< AØ—6‘6ˆD؈~ؐØРF¨V¡O°dÒ$:Ø ™Ü˜a ¨°Ó;÷
	<÷�	<ò�	<ús���“-A
Á
A)Úinclude_passwordc����������	�����óX���—�ddl�m}�t��������j������������������|�t��������d|fd|i«������¬«������S�)a��
        JSON representation of this filesystem instance.

        Parameters
        ----------
        include_password: bool, default True
            Whether to include the password (if any) in the output.

        Returns
        -------
        JSON string with keys ``cls`` (the python location of this class),
        protocol (text name of this class's protocol, first one in case of
        multiple), ``args`` (positional args, usually empty), and all other
        keyword arguments as their own keys.

        Warnings
        --------
        Serialized filesystems may contain sensitive information which have been
        passed to the constructor, such as passwords and tokens. Make sure you
        store and send them in a secure environment!
        r���©ÚFilesystemJSONEncoderÚ_FilesystemJSONEncoderr£��rŒ���)Újsonr¦��Údumpsrr���)rb���r£��r¦��s���   r���Úto_jsonzAbstractFileSystem.to_jsonm��s5���€�õ,�	0äz‰zØÜØ(Ø&Ð(Ø#Ð%5Ð6óô
ð�	
r!���c����������������ó<���—�ddl�m}�t��������j������������������|�|¬«������S�)a��
        Recreate a filesystem instance from JSON representation.

        See ``.to_json()`` for the expected structure of the input.

        Parameters
        ----------
        blob: str

        Returns
        -------
        file system instance, not necessarily of this particular class.

        Warnings
        --------
        This can import arbitrary modules (as determined by the ``cls`` key).
        Make sure you haven't installed any modules that may execute malicious code
        at import time.
        r���©ÚFilesystemJSONDecoderrŒ���)r¨��r­��Úloads)Úblobr­��s���  r���Ú	from_jsonzAbstractFileSystem.from_jsonŽ��s���€�õ*�	0äz‰z˜$Ð$9Ô:Ð:r!���c����������	�����ór��—�ddl�m}��|«�������}t��������|�«������}|�j������������������}t	��������|�j
������������������«������}|s|j
������������������dd«�������t	��������d|j������������������›�d|j������������������›�t��������|t��������t��������f«������r|d���n||j������������������|�j������������������«������dœ|j������������������|«������¤ŽS�)	a��
        JSON-serializable dictionary representation of this filesystem instance.

        Parameters
        ----------
        include_password: bool, default True
            Whether to include the password (if any) in the output.

        Returns
        -------
        Dictionary with keys ``cls`` (the python location of this class),
        protocol (text name of this class's protocol, first one in case of
        multiple), ``args`` (positional args, usually empty), and all other
        keyword arguments as their own keys.

        Warnings
        --------
        Serialized filesystems may contain sensitive information which have been
        passed to the constructor, such as passwords and tokens. Make sure you
        store and send them in a secure environment!
        r���r¥��ÚpasswordNú:r���)r���rT���r���r���)r¨��r¦��rr���rT���r#��rD���r=���rL���rK���rq���r9���r|���Úmake_serializablerC���)rb���r£��r¦��Újson_encoderr���ÚprotorD���s���       r���Úto_dictzAbstractFileSystem.to_dict§��s¬���€�õ,�	0á,Ó.ˆä4‹jˆØ—
‘
ˆä˜t×3Ñ3Ó4ˆÙØ×Ñ 
¨DÔ1äð�
Ø—>‘>Ð" ! C§L¡L >Ð2Ü!+¨E´E¼4°=Ô!AU˜1’XÀuØ×/Ñ/°×0AÑ0AÓBñ
ð�×,Ñ,¨_Ó=ñ	
ð�	
r!���c����������������ó"��—�ddl�m}��|«�������}t��������|�«������}�|j������������������|�«������}|€t	��������d«������‚|�j������������������dd«�������|�j������������������dd«��������||j
������������������|�j������������������dd«������«������i�|j
������������������|�«������¤ŽS�)	a��
        Recreate a filesystem instance from dictionary representation.

        See ``.to_dict()`` for the expected structure of the input.

        Parameters
        ----------
        dct: Dict[str, Any]

        Returns
        -------
        file system instance, not necessarily of this particular class.

        Warnings
        --------
        This can import arbitrary modules (as determined by the ``cls`` key).
        Make sure you haven't installed any modules that may execute malicious code
        at import time.
        r���r¬��Nz#Not a serialized AbstractFileSystemr���rT���r���r���)r¨��r­��r#��Útry_resolve_fs_clsr¸���r=���Úunmake_serializable)Údctr­��Újson_decoderr���s���    r���Ú	from_dictzAbstractFileSystem.from_dictÏ��sŽ���€�õ*�	0á,Ó.ˆä3‹iˆà#×6Ñ6°sÓ;ˆØˆ;ÜÐBÓCÐCà‰tÔ؏‰
˜DÔ!áØ
×
-Ñ
-¨c¯g©g°f¸bÓ.AÓ
Bð
à×.Ñ.¨sÓ3ñ
ð�	
r!���c����������������ó���—�|�S�)zW
        Make a version of the FS instance which will be acceptable to pyarrow
        r���rf���s��� r���Ú_get_pyarrow_filesystemz*AbstractFileSystem._get_pyarrow_filesystemö��s	���€�ð
�ˆr!���c����������������ó(���—�ddl�m}��|||�|||¬«������S�)z¿Create key/value store based on this file-system

        Makes a MutableMapping interface to the FS at the given root path.
        See ``fsspec.mapping.FSMap`` for further details.
        r���)ÚFSMap)ÚcheckÚcreateÚmissing_exceptions)ÚmappingrÁ��)rb���rï���rÂ��rÃ��rÄ��rÁ��s���      r���Ú
get_mapperzAbstractFileSystem.get_mapperý��s#���€�õ�	#áØØØØØ1ô
ð�	
r!���c����������������ó8���—�|�j�������������������j������������������«��������y)a´��
        Clear the cache of filesystem instances.

        Notes
        -----
        Unless overridden by setting the ``cachable`` class attribute to False,
        the filesystem class stores a reference to newly created instances. This
        prevents Python's normal rules around garbage collection from working,
        since the instances refcount will not drop to zero until
        ``clear_instance_cache`` is called.
        N)r+���r>���rŒ���s��� r���Úclear_instance_cachez'AbstractFileSystem.clear_instance_cache
��s���€�ð�	
‰
×ÑÕr!���c����������������ó���—�t���������‚)z=Return the created timestamp of a file as a datetime.datetimerd���r–���s���  r���ÚcreatedzAbstractFileSystem.created��ó���€�ä!Ð!r!���c����������������ó���—�t���������‚)z>Return the modified timestamp of a file as a datetime.datetimerd���r–���s���  r���ÚmodifiedzAbstractFileSystem.modified ��rË��r!���c����������������ó.���—��|�j�������������������|f||dœ|¤ŽS�)z'Alias of `AbstractFileSystem.cat_file`.)r��r��)r��)rb���rƒ���r��r��r���s���     r���Ú
read_byteszAbstractFileSystem.read_bytes'��s���€�àˆt}‰}˜TÐB¨°CÑB¸6ÑBÐBr!���c����������������ó,���—��|�j�������������������||fi�|¤Ž�y)z(Alias of `AbstractFileSystem.pipe_file`.N)r!��)rb���rƒ���r��r���s���    r���Úwrite_byteszAbstractFileSystem.write_bytes+��s���€�àˆ‰t˜UÑ- fÓ-r!���c����������������ó,���—��|�j�������������������|fd|i|¤ŽS�)z$Alias of `AbstractFileSystem.mkdir`.rœ���)r���r›���s���    r���ÚmakedirzAbstractFileSystem.makedir/��s���€�àˆtz‰z˜$ÑH¨~ÐHÀÑHÐHr!���c����������������ó(���—�|�j������������������||¬«������S�)z'Alias of `AbstractFileSystem.makedirs`.r8��)r¡���rŸ���s���   r���rX��zAbstractFileSystem.mkdirs3��s���€�à}‰}˜T¨Hˆ}Ó5Ð5r!���c����������������ó,���—��|�j�������������������|fd|i|¤ŽS�)z!Alias of `AbstractFileSystem.ls`.r§���)r¨���r¦���s���    r���ÚlistdirzAbstractFileSystem.listdir7��s���€�àˆtw‰wtÑ5 FÐ5¨fÑ5Ð5r!���c����������������ó*���—��|�j�������������������||fi�|¤ŽS�)z#Alias of `AbstractFileSystem.copy`.)rn��rd��s���    r���ÚcpzAbstractFileSystem.cp;��s���€�àˆty‰y˜ Ñ0¨Ñ0Ð0r!���c����������������ó*���—��|�j�������������������||fi�|¤ŽS�©z!Alias of `AbstractFileSystem.mv`.©rz��rd��s���    r���ÚmovezAbstractFileSystem.move?��ó���€�àˆtw‰wu˜eÑ. vÑ.Ð.r!���c����������������ó(���—��|�j�������������������|fi�|¤ŽS�)z#Alias of `AbstractFileSystem.info`.r÷���rø���s���   r���ÚstatzAbstractFileSystem.statC��s���€�àˆty‰y˜Ñ( Ñ(Ð(r!���c����������������ó.���—��|�j�������������������|f||dœ|¤ŽS�)z!Alias of `AbstractFileSystem.du`.)rÔ���r¶���)rÖ���)rb���rƒ���rÔ���r¶���r���s���     r���Ú
disk_usagezAbstractFileSystem.disk_usageG��s���€�àˆtw‰wtÐF 5°8ÑF¸vÑFÐFr!���c����������������ó*���—��|�j�������������������||fi�|¤ŽS�rÚ��rÛ��rd��s���    r���ÚrenamezAbstractFileSystem.renameK��rÝ��r!���c����������������ó*���—�|�j������������������|||¬«������S�)z!Alias of `AbstractFileSystem.rm`.rL��)ry��)rb���rƒ���r3��r¶���s���    r���ÚdeletezAbstractFileSystem.deleteO��s���€�àw‰wt y¸8ˆwÓDÐDr!���c����������������ó.���—��|�j�������������������||fd|i|¤ŽS�)z"Alias of `AbstractFileSystem.put`.r3��)r]��)rb���r@��r?��r3��r���s���     r���ÚuploadzAbstractFileSystem.uploadS��ó���€�àˆtx‰x˜˜uÑD°	ÐD¸VÑDÐDr!���c����������������ó.���—��|�j�������������������||fd|i|¤ŽS�)z"Alias of `AbstractFileSystem.get`.r3��)r(���)rb���r?��r@��r3��r���s���     r���ÚdownloadzAbstractFileSystem.downloadW��rè��r!���c����������������ó���—�t��������d«������‚)a��Create a signed URL representing the given path

        Some implementations allow temporary URLs to be generated, as a
        way of delegating credentials.

        Parameters
        ----------
        path : str
             The path on the filesystem
        expiration : int
            Number of seconds to enable the URL for (if supported)

        Returns
        -------
        URL : str
            The signed URL

        Raises
        ------
        NotImplementedError : if method is not implemented for a filesystem
        z+Sign is not implemented for this filesystemrd���)rb���rƒ���Ú
expirationr���s���    r���ÚsignzAbstractFileSystem.sign[��s���€�ô,�"Ð"OÓPÐPr!���c�����������������ó���—�y)NFr���rf���s��� r���Ú_isfilestorezAbstractFileSystem._isfilestores��s���€�ð
�r!���)r‡���r~���r(��r~���r���)T©F)NTÚomit)NFF)TNF)NNN)NN)Nr(��)Fr´���)i���)FNN)FN)r��NTN)r��NNN)r£��Úboolr(��r~���)r¯��r~���r(��rQ���)r£��rò��r(��rV���)r»��rV���r(��rQ���)rU���FFN)TN)éd���)grK���rL���rM���rN���r?���rZ���r<��rÚ���rT���Ú__annotations__r@���rE���r8���r‚���r���r���r:���r'���Úpropertyrg���ri���rk���ro���ru���rw���Úclassmethodr}���rˆ���ÚstaticmethodrŠ���r���r���r’���r—���r•���r���r¡���r£���r¨���r±���r¼���rÏ���rÖ���rõ���rã���rú���rÂ���rÿ���rÑ���rÕ���rÆ���rÉ���r��r��r��r!��r&��r0��r5��r���rG��r(���r[��r]��r`��rb��rg��rn��r4��rz��r}��r|��ry��r«���rˆ��r��r™��r��r���rª��r°��r·��r½��r¿��rÆ��rÈ��rÊ��rÍ��rÏ��rÑ��rÓ��rX��rÖ��rØ��rÜ��rß��rá��rã��rå��rç��rê��rí��rï��r���r!���r���rQ���rQ���a���s	��…�ñð�€HØ€GØ€IØ

€CØ0:€HÐ-Ó:Ø€GØ€JØÐØ€KØ"Ðð�"$Ðð�"Ó!Ø#Ó#ò'ðR�ñ"ó�ð"ð�ñó�ðòò'òSòTð�ñ'ó�ð'ó$'ð�ñ
ó�ð
ð�ñó�ðð�ñ!ó�ð!ò ò8óAó"
ó$
ò 
ó'"òRó2^$ó@$7óL óDOòbò!ò
 *òD2ò1ò-òòóð(�@Dó"ó2ò2ó
9ð.�;Có óD&5ðP�/?Èó�$ðD�Ø!Øó
<Fð|�/?ó�:ð0�Ø!Øó
@FóD ó
ò"ð�FJó4ól.ó`	0òò"ó
ð&�ñ#ó�ð#ð�ØØØó

ð.�ØØØó
IóV&ò"Aó+<ðZ�37õ�
ðB�ò;ó�ð;ð0�37õ�&
ðP�ò$
ó�ð$
òLó
ð �ñó�ðò"ò"óCò.óIó6ó6ò1ò/ò)óGò/óEóEóEóQó0r!���rQ���)Ú	metaclassc������������������óZ��—�e�Zd�ZdZdZdZ	�	�	�	�	�	�d&d„Zed„�«�������Zej������������������d„�«�������Zed„�«�������Z
ed„�«�������Zej������������������d	„�«�������Zd
„�Zd„�Z
d„�Zd
„�Zd„�Zd„�Zd'd„Zd„�Zd(d„Zd(d„Zd„�Zd„�Zd)d„Zd„�Zd*d„Zd„�Zd„�Zd„�Zd„�Zd„�Zd„�Z d„�Z!d „�Z"d!„�Z#d"„�Z$d#„�Z%e%Z&d$„�Z'd%„�Z(y)+r…��a?��Convenient class to derive from to provide buffering

    In the case that the backend does not provide a pythonic file-like object
    already, this class contains much of the logic to build one. The only
    methods that need to be overridden are ``_upload_chunk``,
    ``_initiate_upload`` and ``_fetch_range``.
    i��P�Nc	����������������óL��—�ddl�m}
�||�_��������||�_��������||�_��������|dv�r|�j
������������������n||�_��������d|�_��������||�_��������d|�_	��������d|�_
��������d|�_��������|€i�}d|	v�r.t��������j������������������dt��������«�������|	j������������������d«������|d<���|	|�_��������|d	vrt#��������d
«������‚|dk(��rP|||�_��������n|�j&������������������d���|�_���������|
|���|�j������������������|�j(������������������|�j$������������������fi�|¤Ž|�_��������yt-��������j.������������������«�������|�_��������d|�_��������d|�_��������d|�_��������y)
a��
        Template for files with buffered reading and writing

        Parameters
        ----------
        fs: instance of FileSystem
        path: str
            location in file-system
        mode: str
            Normal file modes. Currently only 'wb', 'ab' or 'rb'. Some file
            systems may be read-only, and some may not support append.
        block_size: int
            Buffer size for reading or writing, 'default' for class default
        autocommit: bool
            Whether to write to final destination; may only impact what
            happens when file is being closed.
        cache_type: {"readahead", "none", "mmap", "bytes"}, default "readahead"
            Caching policy in read mode. See the definitions in ``core``.
        cache_options : dict
            Additional options passed to the constructor for the cache specified
            by `cache_type`.
        size: int
            If given and in read mode, suppressed having to look up the file size
        kwargs:
            Gets stored as self.kwargs
        r���)Úcaches)ÚdefaultNr���NFÚtrimzyPassing 'trim' to control the cache behavior has been deprecated. Specify it within the 'cache_options' argument instead.>���Úabr��r ��zFile mode not supportedr��rÑ���)Úcorerû��rƒ���rC��r	��ÚDEFAULT_BLOCK_SIZEr<��Úlocr‡��r��r��Úclosedr_���r`���ra���r=���r���re���rÑ���ÚdetailsÚ_fetch_rangeÚcacher��ÚBytesIOÚbufferr ��ÚforcedÚlocation)rb���rC��rƒ���r	��r†��r‡��Ú
cache_typer„��rÑ���r���rû��s���           r���r'���zAbstractBufferedFile.__init__‡��s-��€�õL�	!àˆŒ	؈ŒØˆŒ	à'1Ð5FÑ'FˆD×#Ò#ÈJð�	
Œð�ˆŒØ$ˆŒØˆŒØˆŒ
؈ŒàР؈MàVÑÜM‰MðJäô
ð
�%+§J¡J¨vÓ$6ˆM˜&Ñ!àˆŒàÐ)Ñ)Ü%Ð&?Ó@Ð@ؐ4Š<ØÐØ •	à ŸL™L¨Ñ0”	Ø+˜ 
Ñ+Ø—‘ × 1Ñ 1°4·9±9ñØ@MñˆDJô�Ÿ*™*›,ˆDŒK؈DŒK؈DŒKØ ˆDMr!���c����������������ó†���—�|�j�������������������€*|�j������������������j������������������|�j������������������«������|�_���������|�j�������������������S�r���)Ú_detailsrC��rÂ���rƒ���rf���s��� r���r��zAbstractBufferedFile.detailsØ��s.���€�à=‰=Ð Ø ŸG™GŸL™L¨¯©Ó3ˆDŒM؏}‰}Ðr!���c����������������ó&���—�||�_���������|d���|�_��������y�)NrÑ���)r��rÑ���)rb���r��s���  r���r��zAbstractBufferedFile.detailsÞ��s���€�àˆŒ
ؘ&‘Mˆ	r!���c����������������óB���—�t��������|�j������������������|�j������������������«������S�r���)r���rƒ���rC��rf���s��� r���Ú	full_namezAbstractBufferedFile.full_nameã��s���€�ä  §¡¨D¯G©GÓ4Ð4r!���c����������������ó���—�t��������|�dd«������S�)NÚ_closedTr2���rf���s��� r���r��zAbstractBufferedFile.closedç��s���€�ô�t˜Y¨Ó-Ð-r!���c����������������ó���—�||�_���������y�r���)r��)rb���Úcs���  r���r��zAbstractBufferedFile.closedí��s	���€�àˆr!���c����������������ór���—�d|�j�������������������v�rt��������|�«������S�t��������t��������|�j������������������«������d«������S�)Nr��rm���)r	��Úidrn���r���r��rf���s��� r���ro���zAbstractBufferedFile.__hash__ñ��s-���€�ؐ$—)‘)Ñܐd“8ˆOä”x §¡Ó-¨rÓ2Ð2r!���c����������������ó¬���—�|�|u�ryt��������|t��������|�«������«������xr9�|�j������������������dk(��xr(�|j������������������dk(��xr�t��������|�«������t��������|«������k(��S�)zAFiles are equal if they have the same checksum, only in read modeTr��)rq���rr���r	��Úhashrs���s���  r���ru���zAbstractBufferedFile.__eq__÷��sX���€�à5‰=Øäuœd 4›jÓ)ò�
*Ø—	‘	˜TÑ!ò
*à—
‘
˜dÑ"ò
*ô�T“
œd 5›kÑ)ð		
r!���c�����������������ó���—�y)z#Move from temp to final destinationNr���rf���s��� r���ÚcommitzAbstractBufferedFile.commit��ó����r!���c�����������������ó���—�y)zThrow away temporary fileNr���rf���s��� r���ÚdiscardzAbstractBufferedFile.discard��r��r!���c����������������óL���—�d|�j�������������������v�r|�j������������������S�t��������d«������‚)z File information about this pathr��z Info not available while writing)r	��r��r¸���rf���s��� r���rÂ���zAbstractBufferedFile.info��s$���€�à$—)‘)ÑØ—<‘<ÐäÐ?Ó@Ð@r!���c����������������ó���—�|�j�������������������S�)zCurrent file location)r��rf���s��� r���r��zAbstractBufferedFile.tell��s���€�àx‰xˆr!���c����������������ó��—�t��������|«������}|�j������������������dk(��st��������t��������d«������‚|dk(��r|}n9|dk(��r|�j������������������|z���}n$|dk(��r|�j
������������������|z���}nt
��������d|›�d«������‚|dk��rt
��������d«������‚||�_��������|�j������������������S�)	zÕSet current file location

        Parameters
        ----------
        loc: int
            byte location
        whence: {0, 1, 2}
            from start of file, current location or end of file, resp.
        r��z Seek only available in read moder���r���r{���zinvalid whence (z, should be 0, 1 or 2)zSeek before start of file)rn���r	��r¹���r���r��rÑ���r¸���)rb���r��ÚwhenceÚnlocs���    r���r��zAbstractBufferedFile.seek��s”���€�ô�#‹hˆØy‰y˜DÒ Üœ&Ð"DÓEÐEؐQŠ;؉DØ
qŠ[Ø—8‘8˜c‘>‰DØ
qŠ[Ø—9‘9˜s‘?‰DäÐ/°¨xÐ7MÐNÓOÐOؐ!Š8ÜÐ8Ó9Ð9؈ŒØx‰xˆr!���c����������������ób��—�|�j�������������������dvrt��������d«������‚|�j������������������rt��������d«������‚|�j������������������rt��������d«������‚|�j������������������j������������������|«������}|�xj������������������|z
��c_��������|�j������������������j������������������«�������|�j������������������k\��r|�j������������������«��������|S�)zë
        Write data to buffer.

        Buffer only sent on flush() or if buffer is greater than
        or equal to blocksize.

        Parameters
        ----------
        data: bytes
            Set of bytes to be written.
        >���rþ��r ��zFile not in write modeúI/O operation on closed file.z0This file has been force-flushed, can only close)
r	��r¸���r��r��r��r��r��r��r<��Úflush)rb���rE��rÌ���s���   r���r��zAbstractBufferedFile.write-��sŠ���€�ð�9‰9˜LÑ(ÜÐ5Ó6Ð6؏;Š;ÜÐ<Ó=Ð=؏;Š;ÜÐOÓPÐP؏k‰k×Ñ Ó%ˆØŠC‰Ø;‰;×ÑÓ §¡Ò/ØJ‰JŒL؈
r!���c����������������ó��—�|�j�������������������rt��������d«������‚|r|�j������������������rt��������d«������‚|rd|�_��������|�j������������������dvry|s(|�j������������������j������������������«�������|�j������������������k��ry|�j������������������€d|�_��������	�|�j������������������«��������|�j������������������|¬«������durI|�xj������������������|�j������������������j������������������dd	«������z
��c_��������t��������j������������������«�������|�_��������yy#��d|�_���������‚�xY�w)
a{��
        Write buffered data to backend store.

        Writes the current buffer, if it is larger than the block-size, or if
        the file is being closed.

        Parameters
        ----------
        force: bool
            When closing, write the last block even if it is smaller than
            blocks are allowed to be. Disallows further writing to this file.
        zFlush on closed filez+Force flush cannot be called more than onceT>���rþ��r ��Nr���)ÚfinalFr{���)
r��r¸���r��r	��r��r��r<��r ��Ú_initiate_uploadÚ
_upload_chunkr��r��r��)rb���Úforces���  r���r$��zAbstractBufferedFile.flushE��sß���€�ð�;Š;ÜÐ3Ó4Ð4ِT—[’[ÜÐJÓKÐKÙ؈DŒKà9‰9˜LÑ(àᘟ™×)Ñ)Ó+¨d¯n©nÒ<àà;‰;ÐàˆDŒKð
Ø×%Ñ%Ô'ð
�×Ñ EÐÓ*°%Ñ7ØKŠK˜4Ÿ;™;×+Ñ+¨A¨qÓ1Ñ1KÜŸ*™*›,ˆDKð�8øð	
Ø"”Øús���ÂC5�Ã5
C?c�����������������ó���—�y)zÔWrite one part of a multi-block file upload

        Parameters
        ==========
        final: bool
            This is the last block, so should complete file, if
            self.autocommit is True.
        Nr���)rb���r&��s���  r���r(��z"AbstractBufferedFile._upload_chunko��r��r!���c�����������������ó���—�y)zCreate remote file/uploadNr���rf���s��� r���r'��z%AbstractBufferedFile._initiate_uploadz��r¤���r!���c����������������ó���—�t���������‚)z*Get the specified set of bytes from remoterd���)rb���r��r��s���   r���r��z!AbstractBufferedFile._fetch_range~��rË��r!���c����������������ó���—�|€dn
t��������|«������}|�j������������������dk7��rt��������d«������‚|dk��r|�j������������������|�j������������������z
��}|�j
������������������rt��������d«������‚|dk(��ry|�j������������������j������������������|�j������������������|�j������������������|z���«������}t��������j������������������d|�|�j������������������|�j������������������|z���|�j������������������j������������������«�������«�������|�xj������������������t��������|«������z
��c_��������|S�)zÇ
        Return data from cache, or fetch pieces as necessary

        Parameters
        ----------
        length: int (-1)
            Number of bytes to read; if <0, all remaining bytes.
        rµ���r��zFile not in read moder���r#��r!���z%s read: %i - %i %s)rn���r	��r¸���rÑ���r��r��r��Ú_fetchrw��rx��Ú
_log_statsr€���)rb���r¡��rÌ���s���   r���r��zAbstractBufferedFile.read‚��sÒ���€�ð�~‘¬3¨v«;ˆØ9‰9˜ÒÜÐ4Ó5Ð5ؐAŠ:Ø—Y‘Y §¡Ñ)ˆF؏;Š;ÜÐ<Ó=Ð=ؐQŠ;à؏j‰j×Ñ §¡¨$¯(©(°VÑ*;Ó<ˆä‰Ø!ØØH‰HØH‰HvÑØJ‰J×!Ñ!Ó#ô	
ð�	
Š”C˜“Hэ؈
r!���c����������������óž���—�t��������|«������j������������������d«������}|�j������������������|j������������������«������}||dt	��������|«�������t	��������|«������S�)zxmirrors builtin file's readinto method

        https://docs.python.org/3/library/io.html#io.RawIOBase.readinto
        ÚBN)Ú
memoryviewÚcastr��Únbytesr€���)rb���rŠ��rÌ���rE��s���    r���ÚreadintozAbstractBufferedFile.readinto¡��sD���€�ô
�˜‹m× Ñ  Ó%ˆØy‰y˜Ÿ™Ó$ˆØˆˆKŒc$‹iÐܐ4‹yÐr!���c����������������óx��—�g�}	�|�j������������������«�������}|�j������������������|xs�|�j������������������«������}t��������|«������dk(��rni|j	������������������|«������}|dkD��rA|j������������������|d|t��������|«������z����«�������|�j
������������������||z���t��������|«������z���«�������n|j������������������|«�������Œ§dj������������������|«������S�)a›��Return data between current position and first occurrence of char

        char is included in the output, except if the end of the tile is
        encountered first.

        Parameters
        ----------
        char: bytes
            Thing to find
        blocks: None or int
            How much to read in each go. Defaults to file blocksize - which may
            mean a new read on every call.
        r���rµ���Nr!���)r��r��r<��r€���rÏ���r™���r��Újoin)rb���ÚcharÚblocksrÌ���r��ÚpartÚfounds���       r���Ú	readuntilzAbstractBufferedFile.readuntil«��sª���€�ð�ˆØØ—I‘I“KˆEØ—9‘9˜VÒ5 t§~¡~Ó6ˆDܐ4‹y˜AŠ~ØØ—I‘I˜d“OˆEؐrŠzØ—
‘
˜4Ð 3 %¬#¨d«)Ñ"3Ð4Ô5Ø—	‘	˜% %™-¬#¨d«)Ñ3Ô4ØØJ‰JtÔð�ð�x‰x˜‹}Ðr!���c����������������ó$���—�|�j������������������d«������S�)z Read until first occurrence of newline character

        Note that, because of character encoding, this is not necessarily a
        true line ending.
        �
)r<��rf���s��� r���ÚreadlinezAbstractBufferedFile.readlineÇ��s���€�ð�~‰~˜eÓ$Ð$r!���c����������������ó6���—�|�j������������������«�������}|r|S�t��������‚r���)r?��Ú
StopIteration)rb���rÌ���s���  r���Ú__next__zAbstractBufferedFile.__next__Ï��s���€�؏m‰m‹oˆÙ؈JÜÐr!���c����������������ó���—�|�S�r���r���rf���s��� r���Ú__iter__zAbstractBufferedFile.__iter__Õ��ó���€�؈r!���c����������������ó°���—�|�j������������������«�������}|j������������������d«������}|dd�D�cg�c]��}|dz���‘Œ	�}}|j������������������d«������r|S�||d���gz���S�c�c}w�)z/Return all data, split by the newline characterr>��Nrµ���)r��Úsplitrá���)rb���rE��ÚlinesÚlrÌ���s���     r���Ú	readlineszAbstractBufferedFile.readlinesØ��s_���€�ày‰y‹{ˆØ—
‘
˜5Ó!ˆØ"'¨¨ *Ö-˜Qˆq5‹yÐ-ˆÐ-؏=‰=˜Ô؈Jà˜% ™)˜Ñ$Ð$ùò	�.s���©Ac����������������ó$���—�|�j������������������|«������S�r���)r5��)rb���rŠ��s���  r���Ú	readinto1zAbstractBufferedFile.readinto1ã��s���€�؏}‰}˜QÓÐr!���c����������������óž��—�t��������|�dd«������ry|�j������������������ry|�j������������������dk(��rd|�_��������d|�_��������y|�j������������������s|�j������������������d¬«�������|�j������������������c|�j������������������j������������������|�j������������������«�������|�j������������������j������������������|�j������������������j������������������|�j������������������«������«�������d|�_��������y)z=Close file

        Finalizes writes, discards cache
        Ú_unclosableFNr��T)r)��)
r3���r��r	��r��r��r$��rC��r•���rƒ���r«���rf���s��� r���r>��zAbstractBufferedFile.closeæ��sš���€�ô
�4˜¨Ô.Ø؏;Š;Ø؏9‰9˜Ò؈DŒJð�ˆð�—;’;Ø—
‘
 
Ô&àw‰wÐ"Ø—‘×(Ñ(¨¯©Ô3Ø—‘×(Ñ(¨¯©¯©¸¿¹Ó)CÔDàˆr!���c����������������ó>���—�|�j�������������������dk(��xr
�|�j�������������������S�)zWhether opened for readingr��©r	��r��rf���s��� r���ÚreadablezAbstractBufferedFile.readableû��s���€�ày‰y˜DÑ Ò4¨¯© _Ð4r!���c����������������ó"���—�|�j������������������«�������S�)z'Whether is seekable (only in read mode))rQ��rf���s��� r���ÚseekablezAbstractBufferedFile.seekableÿ��s���€�à}‰}‹Ðr!���c����������������ó<���—�|�j�������������������dv�xr
�|�j�������������������S�)zWhether opened for writing>���rþ��r ��rP��rf���s��� r���ÚwritablezAbstractBufferedFile.writable��s���€�ày‰y˜LÐ(Ò<°·±¨_Ð<r!���c����������������ó>���—�|�j�������������������s|�j������������������«��������y�y�r���)r��r>��rf���s��� r���Ú__del__zAbstractBufferedFile.__del__��s���€�؏{Š{ØJ‰JLð�r!���c����������������ób���—�dt��������|�j������������������«������j������������������›�d|�j������������������›�dS�)Nz<File-like object z, ú>)rr���rC��rK���rƒ���rf���s��� r���Ú__str__zAbstractBufferedFile.__str__��s*���€�Ø#¤D¨¯©£M×$:Ñ$:Ð#;¸2¸d¿i¹i¸[ÈÐJÐJr!���c����������������ó���—�|�S�r���r���rf���s��� r���Ú	__enter__zAbstractBufferedFile.__enter__��rE��r!���c����������������ó$���—�|�j������������������«��������y�r���)r>��)rb���r���s���  r���Ú__exit__zAbstractBufferedFile.__exit__��s���€�Ø
‰
r!���)r��rü��TÚ	readaheadNN)r���rð��)rµ���)r>��N))rK���rL���rM���rN���r���r��r'���rõ��r��Úsetterr��r��ro���ru���r��r��rÂ���r��r��r��r$��r(��r'��r��r��r5��r<��r?��rB��rD��rJ��rL��r>��rQ��rS��rU��rW��rZ��Ú__repr__r\��r^��r���r!���r���r…��r…��{��s1��„�ñð�#ÐØ€Hð�ØØØØØ
óO!ðb�ñó�ðð
�
‡^^ñ"ó�ð"ð�ñ5ó�ð5ð�ñ.ó�ð.ð
�‡]]ñó�ðò3ò	
ò2ò(òAòóò4ó0('óTò
ò"óò>óò8%òòò%ò òò*5òò=òòKð�€Hòór!���r…��)-Ú
__future__r���r��r¨��Úloggingr,���r;���r_���r)���Úerrnor���rõ���r���Úhashlibr���Útypingr���r���r	���r
���Ú	callbacksr���Úconfigr
���r���r^���r���r���r���Úutilsr���r���r���r���r���r���r���Ú	getLoggerrw��r ���rr���r#���rQ���ÚIOBaser…��r���r!���r���ú<module>rl�����sŽ���ðÝ�"ã�	Û�Û�Û�	Û�Û�Û�Ý�Ý�Ý�ß�-Ó�-å�'ß�&Ý�Ý�$÷÷�ñ�ð�
ˆ×	Ñ	˜8Ó	$€ò ô:ˆdô�:ôzW 7õ�Wôt0Y˜2Ÿ9™9õ�Yr!���