o Q`e@sdZddlmZmZmZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z ddlmZmZddlZddlZddlmZmZmZmZmZmZmZmZddlmZdd lmZdd l m!Z!m"Z"m#Z#dd l m$Z$dd lm%Z%e j&rdd l'm'Z'ddl m(Z(ddl m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9ddl:m;Z;ddlZ>ddl?m@Z@ddlAmBZBddlmCZCe jDdddZEe jDdddZFe+eFe4ge@eFfZGdgZHddZIeJejKGdddeLZMdS)zPyFilesystem base class. The filesystem base class is common to all filesystems. If you familiarize yourself with this (rather straightforward) API, you can work with any of the supported filesystems. )absolute_importprint_functionunicode_literalsN)closing)partialwraps)copyerrorsfsencodeiotoolsmovetoolswalkwildcard BoundGlobber)validate_open_mode)abspathjoinnormpath)datetime_to_epoch)Walker)datetime)RLock)AnyBinaryIOCallable CollectionDictIOIterableIteratorListMappingOptionalTextTupleTypeUnion) TracebackType) ResourceType)InfoRawInfoSubFS) Permissions) BoundWalker_FFS)Zbound_TcsDtfdd}dj}t|dddur |j|7_|S)z+Return a method with a deprecation warning.cs$tdjt|i|S)Nz6method '{}' has been deprecated, please rename to '{}')warningswarnformat__name__DeprecationWarning)argskwargsmethodold_name)/usr/lib/python3/dist-packages/fs/base.py_methodFsz_new_name.._methodzR Note: .. deprecated:: 2.2.0 Please use `~{}` __doc__N)rr7r8getattrrB)r=r>rAZdeprecated_msgr?r<r@ _new_nameBs rDcseZdZdZiZeZdZfddZddZ ddZ d d Z e d d Z e d dZejdddZejddZej  dddZej  dddZejddZejddZejddZd d!Z "  #dd$d%Zd&d'Zdd(d)Zdd*d+Zdd,d-Zd.d/Zd0d1Z      dd2d3Z d4d5Z!e"e!d6Z#dd7d8Z$e"e$d9Z%   #dd:d;Z&e"e&d<Z'dd>d?Z(d@dAZ)dBdCZ*dDdEZ+dFdGZ,ddIdJZ-dKdLZ.ddMdNZ/dOdPZ0dQdRZ1dSdTZ2dUdVZ3dWdXZ4dYdZZ5dd[d\Z6  dd]d^Z7dd_d`Z8     #ddadbZ9 ddcddZ:dedfZ;  ddgdhZddldmZ?e"e?dnZ@   #ddodpZAe"eAdqZBddrdsZC "  #ddtduZDe"eDdvZEdwdxZFdydzZGd{d|ZHd}d~ZIddZJddZKddZLddZMZNS)r3zBase class for FS objects. Ncs"d|_t|_tt|dS)zJCreate a filesystem. See help(type(self)) for accurate signature. FN)_closed threadingr_locksuperr3__init__self __class__r?r@rIks z FS.__init__cC |dS)z"Auto-close the filesystem on exit.NcloserJr?r?r@__del__ss z FS.__del__cCs|S)z6Allow use of filesystem as a context manager. r?rJr?r?r@ __enter__wsz FS.__enter__cCrN)z"Close filesystem on exit. NrO)rKexc_type exc_value tracebackr?r?r@__exit__}s z FS.__exit__cCst|S)z4`~fs.glob.BoundGlobber`: a globber object.. rrJr?r?r@globszFS.globcCs |j|S)zC`~fs.walk.BoundWalker`: a walker bound to this filesystem. ) walker_classZbindrJr?r?r@rs zFS.walkcCdS)aGet information about a resource on a filesystem. Arguments: path (str): A path to a resource on the filesystem. namespaces (list, optional): Info namespaces to query (defaults to *[basic]*). Returns: ~fs.info.Info: resource information object. For more information regarding resource information, see :ref:`info`. Nr?)rKpath namespacesr?r?r@getinfoz FS.getinfocCrY)a0Get a list of the resource names in a directory. This method will return a list of the resources in a directory. A *resource* is a file, directory, or one of the other types defined in `~fs.enums.ResourceType`. Arguments: path (str): A path to a directory on the filesystem Returns: list: list of names, relative to ``path``. Raises: fs.errors.DirectoryExpected: If ``path`` is not a directory. fs.errors.ResourceNotFound: If ``path`` does not exist. Nr?rKrZr?r?r@listdirr]z FS.listdirFcCrY)ahMake a directory. Arguments: path (str): Path to directory from root. permissions (~fs.permissions.Permissions, optional): a `Permissions` instance, or `None` to use default. recreate (bool): Set to `True` to avoid raising an error if the directory already exists (defaults to `False`). Returns: ~fs.subfs.SubFS: a filesystem whose root is the new directory. Raises: fs.errors.DirectoryExists: If the path already exists. fs.errors.ResourceNotFound: If the path is not found. Nr?)rKrZ permissionsrecreater?r?r@makedirr]z FS.makedirrcKrY)aOpen a binary file-like object. Arguments: path (str): A path on the filesystem. mode (str): Mode to open file (must be a valid non-text mode, defaults to *r*). Since this method only opens binary files, the ``b`` in the mode string is implied. buffering (int): Buffering policy (-1 to use default buffering, 0 to disable buffering, or any positive integer to indicate a buffer size). **options: keyword arguments for any additional information required by the filesystem (if any). Returns: io.IOBase: a *file-like* object. Raises: fs.errors.FileExpected: If the path is not a file. fs.errors.FileExists: If the file exists, and *exclusive mode* is specified (``x`` in the mode). fs.errors.ResourceNotFound: If the path does not exist. Nr?)rKrZmode bufferingoptionsr?r?r@openbinr]z FS.openbincCrY)a Remove a file from the filesystem. Arguments: path (str): Path of the file to remove. Raises: fs.errors.FileExpected: If the path is a directory. fs.errors.ResourceNotFound: If the path does not exist. Nr?r^r?r?r@remover]z FS.removecCrY)aRemove a directory from the filesystem. Arguments: path (str): Path of the directory to remove. Raises: fs.errors.DirectoryNotEmpty: If the directory is not empty ( see `~fs.base.FS.removetree` for a way to remove the directory contents.). fs.errors.DirectoryExpected: If the path does not refer to a directory. fs.errors.ResourceNotFound: If no resource exists at the given path. fs.errors.RemoveRootError: If an attempt is made to remove the root directory (i.e. ``'/'``) Nr?r^r?r?r@ removedir r]z FS.removedircCrY)aSet info on a resource. This method is the complement to `~fs.base.FS.getinfo` and is used to set info values on a resource. Arguments: path (str): Path to a resource on the filesystem. info (dict): Dictionary of resource info. Raises: fs.errors.ResourceNotFound: If ``path`` does not exist on the filesystem The ``info`` dict should be in the same format as the raw info returned by ``getinfo(file).raw``. Example: >>> details_info = {"details": { ... "modified": time.time() ... }} >>> my_fs.setinfo('file.txt', details_info) Nr?)rKrZinfor?r?r@setinfor]z FS.setinfoc Cst|ts td|j,||d }||Wdn1s#wYWddSWddS1s;wYdS)acAppend bytes to the end of a file, creating it if needed. Arguments: path (str): Path to a file. data (bytes): Bytes to append. Raises: TypeError: If ``data`` is not a `bytes` instance. fs.errors.ResourceNotFound: If a parent directory of ``path`` does not exist. z must be bytesabN) isinstancebytes TypeErrorrGopenwrite)rKrZdata append_filer?r?r@ appendbytes>s  "zFS.appendbytesutf-8c Cst|tjs td|j0|j|d|||d }||Wdn1s(wYWddSWddS1s@wYdS)a_Append text to the end of a file, creating it if needed. Arguments: path (str): Path to a file. text (str): Text to append. encoding (str): Encoding for text files (defaults to ``utf-8``). errors (str, optional): What to do with unicode decode errors (see `codecs` module for more information). newline (str): Newline parameter. Raises: TypeError: if ``text`` is not an unicode string. fs.errors.ResourceNotFound: if a parent directory of ``path`` does not exist. zmust be unicode stringZat)encodingr newlineN)rnsix text_typerprGrqrr)rKrZtextrxr ryrtr?r?r@ appendtextSs   "z FS.appendtextcCs d|_dS)aClose the filesystem and release any resources. It is important to call this method when you have finished working with the filesystem. Some filesystems may not finalize changes until they are closed (archives for example). You may call this method explicitly (it is safe to call close multiple times), or you can use the filesystem as a context manager to automatically close. Example: >>> with OSFS('~/Desktop') as desktop_fs: ... desktop_fs.writetext( ... 'note.txt', ... "Don't forget to tape Game of Thrones" ... ) If you attempt to use a filesystem that has been closed, a `~fs.errors.FilesystemClosed` exception will be thrown. TN)rErJr?r?r@rPts zFS.closec Cs|j;|s||rt|t||d}|||Wdn1s)wYWddSWddS1sAwYdS)a$Copy file contents from ``src_path`` to ``dst_path``. Arguments: src_path (str): Path of source file. dst_path (str): Path to destination file. overwrite (bool): If `True`, overwrite the destination file if it exists (defaults to `False`). Raises: fs.errors.DestinationExists: If ``dst_path`` exists, and ``overwrite`` is `False`. fs.errors.ResourceNotFound: If a parent directory of ``dst_path`` does not exist. rbN)rGexistsr DestinationExistsrrqupload)rKsrc_pathdst_path overwrite read_filer?r?r@r s "zFS.copycCsj|j(|s||st|||jst|t||||WddS1s.wYdS)aCopy the contents of ``src_path`` to ``dst_path``. Arguments: src_path (str): Path of source directory. dst_path (str): Path to destination directory. create (bool): If `True`, then ``dst_path`` will be created if it doesn't exist already (defaults to `False`). Raises: fs.errors.ResourceNotFound: If the ``dst_path`` does not exist, and ``create`` is not `True`. N) rGrr ResourceNotFoundr\is_dirDirectoryExpectedr Zcopy_dirrKrrcreater?r?r@copydirs   "z FS.copydirc Cs~|j2|s||r WddSt||dWdn1s'wY WddS1s8wYdS)aCreate an empty file. The default behavior is to create a new file if one doesn't already exist. If ``wipe`` is `True`, any existing file will be truncated. Arguments: path (str): Path to a new file in the filesystem. wipe (bool): If `True`, truncate any existing file to 0 bytes (defaults to `False`). Returns: bool: `True` if a new file had to be created. NFwbT)rGrrrq)rKrZZwiper?r?r@rs$z FS.createc CsL||s t|z||}W|Stjtjfy%d||YSw)zReturn a short descriptive text regarding a path. Arguments: path (str): A path to a resource on the filesystem. Returns: str: a short description of the path. z{} on {})rr r getsyspath NoSysPathr7)rKrZsyspathr?r?r@descs  zFS.desccCs(z||WdStjyYdSw)zCheck if a path maps to a resource. Arguments: path (str): Path to a resource. Returns: bool: `True` if a resource exists at the given path. FT)r\r rr^r?r?r@rs  z FS.existscsj||d}gfdd} fdd} fdd} fdd } |r+t| ||r5t| ||r?t| ||rIt| |rTfd d |D}t|} |d urg|\}}t| ||} | S) aGet an iterator of resource info, filtered by patterns. This method enhances `~fs.base.FS.scandir` with additional filtering functionality. Arguments: path (str): A path to a directory on the filesystem. files (list, optional): A list of UNIX shell-style patterns to filter file names, e.g. ``['*.py']``. dirs (list, optional): A list of UNIX shell-style patterns to filter directory names. exclude_dirs (list, optional): A list of patterns used to exclude directories. exclude_files (list, optional): A list of patterns used to exclude files. namespaces (list, optional): A list of namespaces to include in the resource information, e.g. ``['basic', 'access']``. page (tuple, optional): May be a tuple of ``(, )`` indexes to return an iterator of a subset of the resource info, or `None` to iterate over the entire directory. Paging a directory scan may be necessary for very large directories. Returns: ~collections.abc.Iterator: an iterator of `Info` objects. r[c|jp ||jSz%Pattern match info.name. is_filematchnamepatternsrkrJr?r@ match_dir!zFS.filterdir..match_dircrrrrrrrJr?r@ match_file'rz FS.filterdir..match_filec|jp ||j SrrrrJr?r@ exclude_dir-z!FS.filterdir..exclude_dircrrrrrJr?r@ exclude_file3rz"FS.filterdir..exclude_filec3s*|]tfddDrVqdS)c3s|]}|VqdSNr?).0Z_filterrkr?r@ Dsz)FS.filterdir...N)all)r)filtersrr@rCs  zFS.filterdir..N)scandirappendriter itertoolsislice)rKrZfilesdirsZ exclude_dirsZ exclude_filesr[pageZ resourcesrrrr iter_infostartendr?)rrKr@ filterdirs.&     z FS.filterdircCs@t|j|dd }|}Wd|S1swY|S)aGet the contents of a file as bytes. Arguments: path (str): A path to a readable file on the filesystem. Returns: bytes: the file contents. Raises: fs.errors.ResourceNotFound: if ``path`` does not exist. r~reNrrqread)rKrZrcontentsr?r?r@ readbytesMs   z FS.readbytesgetbytesc Ks~|j2|j|fi|}tj|||dWdn1s wYWddSWddS1s8wYdS)aCopies a file from the filesystem to a file-like object. This may be more efficient that opening and copying files manually if the filesystem supplies an optimized method. Arguments: path (str): Path to a resource. file (file-like): A file-like object open for writing in binary mode. chunk_size (int, optional): Number of bytes to read at a time, if a simple copy is used, or `None` to use sensible default. **options: Implementation specific options required to open the source file. Note that the file object ``file`` will *not* be closed by this method. Take care to close it after this method completes (ideally with a context manager). Example: >>> with open('starwars.mov', 'wb') as write_file: ... my_fs.download('/movies/starwars.mov', write_file)  chunk_sizeNrGrhrcopy_file_data)rKrZfilerrgrr?r?r@downloadas"z FS.downloadgetfilecCsFt|j|d|||d }|}Wd|S1swY|S)aGet the contents of a file as a string. Arguments: path (str): A path to a readable file on the filesystem. encoding (str, optional): Encoding to use when reading contents in text mode (defaults to `None`, reading in binary mode). errors (str, optional): Unicode errors parameter. newline (str): Newlines parameter. Returns: str: file contents. Raises: fs.errors.ResourceNotFound: If ``path`` does not exist. Zrtrerxr ryNr)rKrZrxr ryrrr?r?r@readtexts   z FS.readtextgettextstandardcCs|dkr |j}|Si}|S)ajGet meta information regarding a filesystem. Arguments: namespace (str): The meta namespace (defaults to ``"standard"``). Returns: dict: the meta information. Meta information is associated with a *namespace* which may be specified with the ``namespace`` parameter. The default namespace, ``"standard"``, contains common information regarding the filesystem's capabilities. Some filesystems may provide other namespaces which expose less common or implementation specific information. If a requested namespace is not supported by a filesystem, then an empty dictionary will be returned. The ``"standard"`` namespace supports the following keys: =================== ============================================ key Description ------------------- -------------------------------------------- case_insensitive `True` if this filesystem is case insensitive. invalid_path_chars A string containing the characters that may not be used on this filesystem. max_path_length Maximum number of characters permitted in a path, or `None` for no limit. max_sys_path_length Maximum number of characters permitted in a sys path, or `None` for no limit. network `True` if this filesystem requires a network. read_only `True` if this filesystem is read only. supports_rename `True` if this filesystem supports an `os.rename` operation. =================== ============================================ Most builtin filesystems will provide all these keys, and third- party filesystems should do so whenever possible, but a key may not be present if there is no way to know the value. Note: Meta information is constant for the lifetime of the filesystem, and may be cached. r)_metar )rK namespacemetar?r?r@getmetas 0 z FS.getmetacC||j}|S)aGet the size (in bytes) of a resource. Arguments: path (str): A path to a resource. Returns: int: the *size* of the resource. The *size* of a file is the total number of readable bytes, which may not reflect the exact number of bytes of reserved disk space (or other storage medium). The size of a directory is the number of bytes of overhead use to store the directory entry. ) getdetailssize)rKrZrr?r?r@getsizes z FS.getsizecCs tj|d)aGet the *system path* of a resource. Parameters: path (str): A path on the filesystem. Returns: str: the *system path* of the resource, if any. Raises: fs.errors.NoSysPath: If there is no corresponding system path. A system path is one recognized by the OS, that may be used outside of PyFilesystem (in an application or a shell for example). This method will get the corresponding system path that would be referenced by ``path``. Not all filesystems have associated system paths. Network and memory based filesystems, for example, may not physically store data anywhere the OS knows about. It is also possible for some paths to have a system path, whereas others don't. This method will always return a str on Py3.* and unicode on Py2.7. See `~getospath` if you need to encode the path as bytes. If ``path`` doesn't have a system path, a `~fs.errors.NoSysPath` exception will be thrown. Note: A filesystem may return a system path even if no resource is referenced by that path -- as long as it can be certain what that system path would be. rZ)r rr^r?r?r@rs $z FS.getsyspathcCs||}t|}|S)asGet a *system path* to a resource, encoded in the operating system's prefered encoding. Parameters: path (str): A path on the filesystem. Returns: str: the *system path* of the resource, if any. Raises: fs.errors.NoSysPath: If there is no corresponding system path. This method takes the output of `~getsyspath` and encodes it to the filesystem's prefered encoding. In Python3 this step is not required, as the `os` module will do it automatically. In Python2.7, the encoding step is required to support filenames on the filesystem that don't encode correctly. Note: If you want your code to work in Python2.7 and Python3 then use this method if you want to work will the OS filesystem outside of the OSFS interface. )rr )rKrZrZospathr?r?r@ getospaths z FS.getospathcCr)a\Get the type of a resource. Parameters: path (str): A path on the filesystem. Returns: ~fs.enums.ResourceType: the type of the resource. A type of a resource is an integer that identifies the what the resource references. The standard type integers may be one of the values in the `~fs.enums.ResourceType` enumerations. The most common resource types, supported by virtually all filesystems are ``directory`` (1) and ``file`` (2), but the following types are also possible: =================== ====== ResourceType value ------------------- ------ unknown 0 directory 1 file 2 character 3 block_special_file 4 fifo 5 socket 6 symlink 7 =================== ====== Standard resource types are positive integers, negative values are reserved for implementation specific resource types. )rtype)rKrZZ resource_typer?r?r@gettype2s #z FS.gettypercCs t||)a5Get the URL to a given resource. Parameters: path (str): A path on the filesystem purpose (str): A short string that indicates which URL to retrieve for the given path (if there is more than one). The default is ``'download'``, which should return a URL that serves the file. Other filesystems may support other values for ``purpose``. Returns: str: a URL. Raises: fs.errors.NoURL: If the path does not map to a URL. )r NoURL)rKrZpurposer?r?r@geturlXs z FS.geturlcCs0d}z||W|Stjyd}Y|Sw)zCheck if a path maps to a system path. Parameters: path (str): A path on the filesystem. Returns: bool: `True` if the resource at ``path`` has a *syspath*. TF)rr r)rKrZZ has_sys_pathr?r?r@ hassyspathms  z FS.hassyspathcCs4d}z |j||dW|Stjyd}Y|Sw)a.Check if a path has a corresponding URL. Parameters: path (str): A path on the filesystem. purpose (str): A purpose parameter, as given in `~fs.base.FS.geturl`. Returns: bool: `True` if an URL for the given purpose exists. T)rF)rr r)rKrZrZhas_urlr?r?r@hasurls z FS.hasurlcCs t|ddS)z+Check if the filesystem is closed. rEF)rCrJr?r?r@iscloseds z FS.isclosedcCs&z||jWStjyYdSw)zCheck if a path maps to an existing directory. Parameters: path (str): A path on the filesystem. Returns: bool: `True` if ``path`` maps to a directory. Fr\rr rr^r?r?r@isdirs  zFS.isdircCstt||dduS)aCheck if a directory is empty. A directory is considered empty when it does not contain any file or any directory. Parameters: path (str): A path to a directory on the filesystem. Returns: bool: `True` if the directory is empty. Raises: errors.DirectoryExpected: If ``path`` is not a directory. errors.ResourceNotFound: If ``path`` does not exist. N)nextrrr^r?r?r@isemptysz FS.isemptycCs(z||j WStjyYdSw)zCheck if a path maps to an existing file. Parameters: path (str): A path on the filesystem. Returns: bool: `True` if ``path`` maps to a file. Frr^r?r?r@isfiles  z FS.isfilecCs||dS)zCheck if a path maps to a symlink. Parameters: path (str): A path on the filesystem. Returns: bool: `True` if ``path`` maps to a symlink. Fr\r^r?r?r@islinks z FS.islinkcCs|jS)aNGet a context manager that *locks* the filesystem. Locking a filesystem gives a thread exclusive access to it. Other threads will block until the threads with the lock has left the context manager. Returns: threading.RLock: a lock specific to the filesystem instance. Example: >>> with my_fs.lock(): # May block ... # code here has exclusive access to the filesystem It is a good idea to put a lock around any operations that you would like to be *atomic*. For instance if you are copying files, and you don't want another thread to delete or modify anything while the copy is in progress. Locking with this method is only required for code that calls multiple filesystem methods. Individual methods are thread safe already, and don't need to be locked. Note: This only locks at the Python level. There is nothing to prevent other processes from modifying the filesystem outside of the filesystem instance. )rGrJr?r?r@lockszFS.lockcCsT|j|s||st|t||||WddS1s#wYdS)aMove directory ``src_path`` to ``dst_path``. Parameters: src_path (str): Path of source directory on the filesystem. dst_path (str): Path to destination directory. create (bool): If `True`, then ``dst_path`` will be created if it doesn't exist already (defaults to `False`). Raises: fs.errors.ResourceNotFound: if ``dst_path`` does not exist, and ``create`` is `False`. N)rGrr rr Zmove_dirrr?r?r@movedirs  "z FS.movedirc Cs||jEt||}|D]}z |j||dWqtjy(|s&Yqwz |j||dWn tjy?|s=Ynw||WdS1sOwYdS)aMake a directory, and any missing intermediate directories. Arguments: path (str): Path to directory from root. permissions (~fs.permissions.Permissions, optional): Initial permissions, or `None` to use defaults. recreate (bool): If `False` (the default), attempting to create an existing directory will raise an error. Set to `True` to ignore existing directories. Returns: ~fs.subfs.SubFS: A sub-directory filesystem. Raises: fs.errors.DirectoryExists: if the path is already a directory, and ``recreate`` is `False`. fs.errors.DirectoryExpected: if one of the ancestors in the path is not a directory. )r`N)checkrGrZget_intermediate_dirsrbr ZDirectoryExistsopendir)rKrZr`raZ dir_pathsdir_pathr?r?r@makedirss( $z FS.makedirsc Cs|s ||r t|||jrt||ddrIz ||}||}Wn tj y5Ynwz t ||WdSt yHYnw|j *||d}|||Wdn1sdwY||WddS1sywYdS)aMove a file from ``src_path`` to ``dst_path``. Arguments: src_path (str): A path on the filesystem to move. dst_path (str): A path on the filesystem where the source file will be written to. overwrite (bool): If `True`, destination path will be overwritten if it exists. Raises: fs.errors.FileExpected: If ``src_path`` maps to a directory instead of a file. fs.errors.DestinationExists: If ``dst_path`` exists, and ``overwrite`` is `False`. fs.errors.ResourceNotFound: If a parent directory of ``dst_path`` does not exist. Zsupports_renameFNr~)rr rr\rZ FileExpectedrgetrrosrenameOSErrorrGrqrri)rKrrrZ src_sys_pathZ dst_sys_pathrr?r?r@r :s.      "zFS.movec KsLt||dd}|j|||d} tj|| f|||pd||d|} | S)aOpen a file. Arguments: path (str): A path to a file on the filesystem. mode (str): Mode to open the file object with (defaults to *r*). buffering (int): Buffering policy (-1 to use default buffering, 0 to disable buffering, 1 to select line buffering, of any positive integer to indicate a buffer size). encoding (str): Encoding for text files (defaults to ``utf-8``) errors (str, optional): What to do with unicode decode errors (see `codecs` module for more information). newline (str): Newline parameter. **options: keyword arguments for any additional information required by the filesystem (if any). Returns: io.IOBase: a *file-like* object. Raises: fs.errors.FileExpected: If the path is not a file. fs.errors.FileExists: If the file exists, and *exclusive mode* is specified (``x`` in the mode). fs.errors.ResourceNotFound: If the path does not exist. trw)rerfrv)rerfrxr ry)rreplacerhr Z make_stream) rKrZrerfrxr ryrgZbin_modeZbin_fileZ io_streamr?r?r@rqes '  zFS.opencCs<ddlm}|p |jp |}||jstj|d|||S)aGet a filesystem object for a sub-directory. Arguments: path (str): Path to a directory on the filesystem. factory (callable, optional): A callable that when invoked with an FS instance and ``path`` will return a new FS object representing the sub-directory contents. If no ``factory`` is supplied then `~fs.subfs_class` will be used. Returns: ~fs.subfs.SubFS: A filesystem representing a sub-directory. Raises: fs.errors.DirectoryExpected: If ``dst_path`` does not exist or is not a directory. rr.r)subfsr/ subfs_classgetbasicrr r)rKrZfactoryr/Z_factoryr?r?r@rs    z FS.opendircCstt|}|j;tjdd}|||}|D]\}}|jr%||q||q|dkr<||WddSWddS1sGwYdS)aRecursively remove the contents of a directory. This method is similar to `~fs.base.removedir`, but will remove the contents of the directory if it is not empty. Arguments: dir_path (str): Path to a directory on the filesystem. depth)search/N) rrrGrrrkrrjri)rKrZ _dir_pathZwalkerZgen_info_pathrkr?r?r@ removetrees       "z FS.removetreecsZpdtt|fdd|D}t|}|dur+|\}}t|||}|S)aJGet an iterator of resource info. Arguments: path (str): A path to a directory on the filesystem. namespaces (list, optional): A list of namespaces to include in the resource information, e.g. ``['basic', 'access']``. page (tuple, optional): May be a tuple of ``(, )`` indexes to return an iterator of a subset of the resource info, or `None` to iterate over the entire directory. Paging a directory scan may be necessary for very large directories. Returns: ~collections.abc.Iterator: an iterator of `Info` objects. Raises: fs.errors.DirectoryExpected: If ``path`` is not a directory. fs.errors.ResourceNotFound: If ``path`` does not exist. r?c3s$|] }jt|dVqdS)rN)r\r)rrrr[rKr?r@rs  zFS.scandir..N)rrr_rrr)rKrZr[rrkrrrr?rr@rs z FS.scandircCsTt|ts tdt|j|dd}||WddS1s#wYdS)zCopy binary data to a file. Arguments: path (str): Destination path on the filesystem. contents (bytes): Data to be written. Raises: TypeError: if contents is not bytes. zcontents must be bytesrrN)rnrorprrqrr)rKrZr write_filer?r?r@ writebytess  "z FS.writebytessetbytesc Ks|j4|j|fddi|}tj|||dWdn1s"wYWddSWddS1s:wYdS)aSet a file to the contents of a binary file object. This method copies bytes from an open binary file to a file on the filesystem. If the destination exists, it will first be truncated. Arguments: path (str): A path on the filesystem. file (io.IOBase): a file object open for reading in binary mode. chunk_size (int, optional): Number of bytes to read at a time, if a simple copy is used, or `None` to use sensible default. **options: Implementation specific options required to open the source file. Note that the file object ``file`` will *not* be closed by this method. Take care to close it after this method completes (ideally with a context manager). Example: >>> with open('~/movies/starwars.mov', 'rb') as read_file: ... my_fs.upload('starwars.mov', read_file) rerrNr)rKrZrrrgdst_filer?r?r@rs"z FS.upload setbinfilec Cs|durdnd}|j1|j|||||d}t||Wdn1s'wYWddSWddS1s?wYdS)a*Set a file to the contents of a file object. Arguments: path (str): A path on the filesystem. file (io.IOBase): A file object open for reading. encoding (str, optional): Encoding of destination file, defaults to `None` for binary. errors (str, optional): How encoding errors should be treated (same as `io.open`). newline (str): Newline parameter (same as `io.open`). This method is similar to `~FS.upload`, in that it copies data from a file-like object to a resource on the filesystem, but unlike ``upload``, this method also supports creating files in text-mode (if the ``encoding`` argument is supplied). Note that the file object ``file`` will *not* be closed by this method. Take care to close it after this method completes (ideally with a context manager). Example: >>> with open('myfile.txt') as read_file: ... my_fs.writefile('myfile.txt', read_file) Nrwtr)rGrqrr)rKrZrrxr ryrerr?r?r@ writefile/s" "z FS.writefilesetfilecCsTi}d|i}|durtnt||d<|dur|dnt||d<|||dS)aSet the accessed and modified time on a resource. Arguments: path: A path to a resource on the filesystem. accessed (datetime, optional): The accessed time, or `None` (the default) to use the current time. modified (datetime, optional): The modified time, or `None` (the default) to use the same time as the ``accessed`` parameter. detailsNaccessedmodified)timerrl)rKrZrrrraw_infor?r?r@settimes[s z FS.settimescCs\t|tjs tdt|j|d|||d}||WddS1s'wYdS)aCreate or replace a file with text. Arguments: path (str): Destination path on the filesystem. contents (str): Text to be written. encoding (str, optional): Encoding of destination file (defaults to ``'utf-8'``). errors (str, optional): How encoding errors should be treated (same as `io.open`). newline (str): Newline parameter (same as `io.open`). Raises: TypeError: if ``contents`` is not a unicode string. zcontents must be unicoderrN)rnrzr{rprrqrr)rKrZrrxr ryrr?r?r@ writetextus   "z FS.writetextsettextcCsh|j't}||s"d||di}|||WddSWddS1s-wYdS)a[Touch a file on the filesystem. Touching a file means creating a new file if ``path`` doesn't exist, or update accessed and modified times if the path does exist. This method is similar to the linux command of the same name. Arguments: path (str): A path to a file on the filesystem. r)rrN)rGrrrl)rKrZZnowrr?r?r@touchs  "zFS.touchcCs|t|trttjrdd|}ttj | d}|r/t | |r/t |tt| dd}|dkrdz||}Wn t jyNYnwt||krdd}|j|d}t j||dtt|}|S) aCheck if a path is valid, returning a normalized absolute path. Many filesystems have restrictions on the format of paths they support. This method will check that ``path`` is valid on the underlaying storage mechanism and throw a `~fs.errors.InvalidPath` exception if it is not. Arguments: path (str): A path. Returns: str: A normalized, absolute path. Raises: fs.errors.InvalidCharsInPath: If the path contains invalid characters. fs.errors.InvalidPath: If the path is invalid. fs.errors.FilesystemClosed: if the filesystem is closed. zpaths must be unicode (not str)zpaths must be str (not bytes)Zinvalid_path_charsmax_sys_path_lengthrdz6path too long (max {max_chars} characters in sys path))Z max_chars)msg)rrnrorprzZPY2rtypingcastr{rset intersectionr ZInvalidCharsInPathintrrlenr7Z InvalidPathrr)rKrZrZ invalid_charsrZsys_pathZ_msgrr?r?r@ validatepaths4     zFS.validatepathcC|j|dgdS)a/Get the *basic* resource info. This method is shorthand for the following:: fs.getinfo(path, namespaces=['basic']) Arguments: path (str): A path on the filesystem. Returns: ~fs.info.Info: Resource information object for ``path``. Zbasicrrr^r?r?r@rz FS.getbasiccCr)a3Get the *details* resource info. This method is shorthand for the following:: fs.getinfo(path, namespaces=['details']) Arguments: path (str): A path on the filesystem. Returns: ~fs.info.Info: Resource information object for ``path``. rrrr^r?r?r@rrz FS.getdetailscCs|rtdS)zCheck if a filesystem may be used. Raises: fs.errors.FilesystemClosed: if the filesystem is closed. N)rr ZFilesystemClosedrJr?r?r@rszFS.checkcCsN|durdSt|tjrtdtt|dd }t ||}||S)azCheck if a name matches any of a list of wildcards. Arguments: patterns (list): A list of patterns, e.g. ``['*.py']`` name (str): A file or directory name (not a path) Returns: bool: `True` if ``name`` matches any of the patterns. If a filesystem is case *insensitive* (such as Windows) then this method will perform a case insensitive match (i.e. ``*.py`` will match the same names as ``*.PY``). Otherwise the match will be case sensitive (``*.py`` and ``*.PY`` will match different names). Example: >>> home_fs.match(['*.py'], '__init__.py') True >>> home_fs.match(['*.jpg', '*.png'], 'foo.gif') False Note: If ``patterns`` is `None` (or ``['*']``), then this method will always return `True`. NTz#patterns must be a list or sequenceZcase_insensitiveF) rnrzr{rprrboolrrrZ get_matcher)rKrrZcase_sensitiveZmatcherr?r?r@rs  zFS.matchcKs ddlm}||fi|dS)aRender a tree view of the filesystem to stdout or a file. The parameters are passed to :func:`~fs.tree.render`. Keyword Arguments: path (str): The path of the directory to start rendering from (defaults to root folder, i.e. ``'/'``). file (io.IOBase): An open file-like object to render the tree, or `None` for stdout. encoding (str): Unicode encoding, or `None` to auto-detect. max_levels (int): Maximum number of levels to display, or `None` for no maximum. with_color (bool): Enable terminal color output, or `None` to auto-detect terminal. dirs_first (bool): Show directories first. exclude (list): Option list of directory patterns to exclude from the tree render. filter (list): Optional list of files patterns to match in the tree render. r)renderN)treer)rKr;rr?r?r@r9s zFS.treecCs||zt|}Wntytd|w||} |d}|s+n| |q#Wd| S1s>wY| S)a{Get the hash of a file's contents. Arguments: path(str): A path on the filesystem. name(str): One of the algorithms supported by the hashlib module, e.g. `"md5"` Returns: str: The hex digest of the hash. Raises: fs.errors.UnsupportedHash: If the requested hash is not supported. zhash '{}' is not supportedTiN) r hashlibnew ValueErrorr ZUnsupportedHashr7rhrupdateZ hexdigest)rKrZrZ hash_object binary_filechunkr?r?r@hashUs$      zFS.hashr)NF)rcrd)rvNrw)F)NNNNNN)NNrw)r)r)rcrdNNrw)NN)Or8 __module__ __qualname__rBrrrXrrIrQrRrVpropertyrWrabcabstractmethodr\r_rbrhrirjrlrur}rPr rrrrrrrDrrrrrrrrrrrrrrrrrrrrrr rqrrrrrrrrrrrrrr rrrrrr __classcell__r?r?rLr@r3]s           !    U    6& &   +. 9   (    *  !; &)NrBZ __future__rrrrrrrrFrr contextlibr functoolsrrr5rzrwr r r r r rrrrWrrerrZrrrrrZ TYPE_CHECKINGrrrrrrrr r!r"r#r$r%r&r'r(r)typesr*Zenumsr+rkr,r-rr/r`r0r1TypeVarr2r4Z_OpendirFactory__all__rDZ add_metaclassABCMetaobjectr3r?r?r?r@sH (      D