o pfUk@sdZddlmZddlZddlmZmZmZddlm Z ddl m Z ddl m Z mZmZejr[dd lmZmZmZmZmZmZmZmZmZmZdd lmZdd lmZeeege fZ!ej"d d dZ#eddZ$ Gddde%Z&Gdddej'e#Z(e&Z)e)j*Z*e)j+Z,e)jZ-e)j.Z/dS)zMachinery for walking a filesystem. *Walking* a filesystem means recursively visiting a directory and any sub-directories. It is a fairly common requirement for copying, searching etc. See :ref:`walking` for details. )unicode_literalsN) defaultdictdeque namedtuple) make_repr)FSError)abspathcombinenormpath) AnyCallable CollectionIteratorListMutableMappingOptionalTextTupleType)FS)Info_Fr)boundStepzpath, dirs, filescseZdZdZ        d,fdd ZeddZed d Zed d Zed dZ ddZ d-ddZ ddZ ddZ ddZddZddZ d-ddZ  d.d d!Zd/d"d#Zd/d$d%Z  d.d&d'Z d-d(d)Z d-d*d+ZZS)0Walkerz>A walker object recursively lists directories in a filesystem.FNbreadthc s|dvrtd||_|r|rtdn|r|jn|j}t|s$td||_||_||_||_ ||_ ||_ ||_ t t|dS)a-Create a new `Walker` instance. Arguments: ignore_errors (bool): If `True`, any errors reading a directory will be ignored, otherwise exceptions will be raised. on_error (callable, optional): If ``ignore_errors`` is `False`, then this callable will be invoked for a path and the exception object. It should return `True` to ignore the error, or `False` to re-raise it. search (str): If ``"breadth"`` then the directory will be walked *top down*. Set to ``"depth"`` to walk *bottom up*. filter (list, optional): If supplied, this parameter should be a list of filename patterns, e.g. ``["*.py"]``. Files will only be returned if the final component matches one of the patterns. exclude (list, optional): If supplied, this parameter should be a list of filename patterns, e.g. ``["~*"]``. Files matching any of these patterns will be removed from the walk. filter_dirs (list, optional): A list of patterns that will be used to match directories paths. The walk will only open directories that match at least one of these patterns. exclude_dirs (list, optional): A list of patterns that will be used to filter out directories from the walk. e.g. ``['*.svn', '*.git']``. max_depth (int, optional): Maximum directory depth to walk. )rdepthz#search must be 'breadth' or 'depth'z,on_error is invalid when ignore_errors==Truezon_error must be callableN) ValueError ignore_errors_ignore_errors _raise_errorscallable TypeErroron_errorsearchfilterexclude filter_dirs exclude_dirs max_depthsuperr__init__) selfrr$r%r&r'r(r)r* __class__@/home/ertert/spirit/venv/lib/python3.10/site-packages/fs/walk.pyr,5s$(zWalker.__init__cCdS)z#Ignore dir scan errors when called.Tr0clspatherrorr0r0r1r qzWalker._ignore_errorscCr2)z%Re-raise dir scan errors when called.Fr0r3r0r0r1r!wr7zWalker._raise_errorscCs |d}|r|ddSdS)zBCalculate the 'depth' of a directory path (i.e. count components)./rr)stripcount)r4r5_pathr0r0r1_calculate_depth}s zWalker._calculate_depthcCst|S)aBind a `Walker` instance to a given filesystem. This *binds* in instance of the Walker to a given filesystem, so that you won't need to explicitly provide the filesystem as a parameter. Arguments: fs (FS): A filesystem object. Returns: ~fs.walk.BoundWalker: a bound walker. Examples: Use this method to explicitly bind a filesystem instance:: >>> walker = Walker.bind(my_fs) >>> for path in walker.files(filter=['*.py']): ... print(path) /foo.py /bar.py Unless you have written a customized walker class, you will be unlikely to need to call this explicitly, as filesystem objects already have a ``walk`` attribute which is a bound walker object:: >>> for path in my_fs.walk.files(filter=['*.py']): ... print(path) /foo.py /bar.py ) BoundWalker)r4fsr0r0r1binds#z Walker.bindc CsNt|jj|jdf|jdf|jdf|jdf|jdf|jdf|j df|j dfd S)NFr)rr$r%r&r'r(r)r*) rr/__name__rr$r%r&r'r(r)r*r-r0r0r1__repr__szWalker.__repr__cCs*|jdkr |j|||dS|j|||dS)zGet the walk generator.r namespaces)r% _walk_breadth _walk_depth)r-r>r5rDr0r0r1 _iter_walks zWalker._iter_walkcCsJ|jdur||j|jrdS|jdur||j|jsdS||||S)z6Check if a directory should be considered in the walk.NF)r)matchnamer(check_open_dirr-r>r5infor0r0r1_check_open_dirs zWalker._check_open_dircCr2)adCheck if a directory should be opened. Override to exclude directories from the walk. Arguments: fs (FS): A filesystem instance. path (str): Path to directory. info (Info): A resource info object for the directory. Returns: bool: `True` if the directory should be opened. Tr0rKr0r0r1rJszWalker.check_open_dircCs&|jdur ||jkr dS||||S)z0Check if a directory contents should be scanned.NF)r*check_scan_dir)r-r>r5rLrr0r0r1_check_scan_dirszWalker._check_scan_dircCr2)aCheck if a directory should be scanned. Override to omit scanning of certain directories. If a directory is omitted, it will appear in the walk but its files and sub-directories will not. Arguments: fs (FS): A filesystem instance. path (str): Path to directory. info (Info): A resource info object for the directory. Returns: bool: `True` if the directory should be scanned. Tr0rKr0r0r1rNszWalker.check_scan_dircCs.|jdur||j|jrdS||j|jS)aCheck if a filename should be included. Override to exclude files from the walk. Arguments: fs (FS): A filesystem instance. info (Info): A resource info object. Returns: bool: `True` if the file should be included. NF)r'rHrIr&)r-r>rLr0r0r1 check_fileszWalker.check_filec csXz|j||dD]}|Vq WdSty+}z|||s WYd}~dSd}~ww)aGet an iterator of `Info` objects for a directory path. Arguments: fs (FS): A filesystem instance. dir_path (str): A path to a directory on the filesystem. namespaces (list): A list of additional namespaces to include in the `Info` objects. Returns: ~collections.Iterator: iterator of `Info` objects for resources within the given path. rCN)scandirrr$)r-r>dir_pathrDrLr6r0r0r1_scan s z Walker._scanr8c cstt|}tt}|j|||d}|D]/\}}|dur=g} g} ||D] } | jr,| n| | q%t|| | V||=q|||qdS)abWalk the directory structure of a filesystem. Arguments: fs (FS): A filesystem instance. path (str): A path to a directory on the filesystem. namespaces (list, optional): A list of additional namespaces to add to the `Info` objects. Returns: collections.Iterator: an iterator of `~fs.walk.Step` instances. The return value is an iterator of ``(, , )`` named tuples, where ```` is an absolute path to a directory, and ```` and ```` are a list of `~fs.info.Info` objects for directories and files in ````. Example: >>> walker = Walker(filter=['*.py']) >>> for path, dirs, files in walker.walk(my_fs, namespaces=["details"]): ... print("[{}]".format(path)) ... print("{} directories".format(len(dirs))) ... total = sum(info.size for info in files) ... print("{} bytes".format(total)) [/] 2 directories 55 bytes ... rCN)r r rlistrGis_dirappendr) r-r>r5rDr;dir_info_walkrRrLdirsfiles_infor0r0r1walk%s $  z Walker.walkccs>t}|j||dD]\}}|dur|js|||jVq dS)aDWalk a filesystem, yielding absolute paths to files. Arguments: fs (FS): A filesystem instance. path (str): A path to a directory on the filesystem. Yields: str: absolute path to files on the filesystem found recursively within the given directory. r5Nr rGrUrIr-r>r5_combiner;rLr0r0r1rZW z Walker.filesccs>t}|j||dD]\}}|dur|jr|||jVq dS)aPWalk a filesystem, yielding absolute paths to directories. Arguments: fs (FS): A filesystem instance. path (str): A path to a directory on the filesystem. Yields: str: absolute path to directories on the filesystem found recursively within the given directory. r]Nr^r_r0r0r1rYiraz Walker.dirsccsBt}|j|||d}|D]\}}|dur|||j|fVq dS)aWalk a filesystem, yielding tuples of ``(, )``. Arguments: fs (FS): A filesystem instance. path (str): A path to a directory on the filesystem. namespaces (list, optional): A list of additional namespaces to add to the `Info` objects. Yields: (str, Info): a tuple of ``(, )``. r5rDN)r rGrI)r-r>r5rDr`rXr;rLr0r0r1rL{s z Walker.infoccst|g}|j}|j}t}|j}|j} |j} |j} |j} | |} |ri|}||||dD]2}|j rU| || d}| |||rT||fV| ||||rT||||j q-| ||r_||fVq-|dfV|s#dSdS)z*Walk files using a *breadth first* search.rCrN) r appendleftpopr rSr<rMrOrPrUrI)r-r>r5rDqueuepushrdr`rSr<rMrO _check_filerrRrL_depthr0r0r1rEs4       zWalker._walk_breadthccst}|j}|j}|j}|j}|j} ||} |||||ddfg} | j} | r| d\} }}t|d}|durF|dur=|V| dfV| d=n=|jry|| | d}||| |rx||| ||rs|| |j }| |||||d| |ffn| |fVn | ||r| |fV| s&dSdS)z(Walk files using a *depth first* search.rCNr) r rSr<rMrOrPrVnextrUrI)r-r>r5rDr`rSr<rMrOrgrstackrfrR iter_filesparentrLrhr;r0r0r1rFsF          zWalker._walk_depth)FNrNNNNN)Nr8Nr8)r@ __module__ __qualname____doc__r, classmethodr r!r<r?rBrGrMrJrOrNrPrSr\rZrYrLrErF __classcell__r0r0r.r1r2sR<    $     2   'rc@s`eZdZdZefddZddZddZ  dd d ZeZ dd d Z dddZ  dddZ d S)r=aA class that binds a `Walker` instance to a `FS` instance. You will typically not need to create instances of this class explicitly. Filesystems have a `~FS.walk` property which returns a `BoundWalker` object. Example: >>> tmp_fs = fs.tempfs.TempFS() >>> tmp_fs.walk BoundWalker(TempFS()) A `BoundWalker` is callable. Calling it is an alias for the `~fs.walk.BoundWalker.walk` method. cCs||_||_dS)zCreate a new walker bound to the given filesystem. Arguments: fs (FS): A filesystem instance. walker_class (type): A `~fs.walk.WalkerBase` sub-class. The default uses `~fs.walk.Walker`. N)r> walker_class)r-r>rur0r0r1r,s zBoundWalker.__init__cCs d|jS)NzBoundWalker({!r}))formatr>rAr0r0r1rBs zBoundWalker.__repr__cOs|j|i|}|S)zCreate a walker instance.)ru)r-argskwargswalkerr0r0r1 _make_walker szBoundWalker._make_walkerr8NcK"|jdi|}|j|j||dS)aY Walk the directory structure of a filesystem. Arguments: path (str): namespaces (list, optional): A list of namespaces to include in the resource information, e.g. ``['basic', 'access']`` (defaults to ``['basic']``). Keyword Arguments: ignore_errors (bool): If `True`, any errors reading a directory will be ignored, otherwise exceptions will be raised. on_error (callable): If ``ignore_errors`` is `False`, then this callable will be invoked with a path and the exception object. It should return `True` to ignore the error, or `False` to re-raise it. search (str): If ``'breadth'`` then the directory will be walked *top down*. Set to ``'depth'`` to walk *bottom up*. filter (list): If supplied, this parameter should be a list of file name patterns, e.g. ``['*.py']``. Files will only be returned if the final component matches one of the patterns. exclude (list, optional): If supplied, this parameter should be a list of filename patterns, e.g. ``['~*', '.*']``. Files matching any of these patterns will be removed from the walk. filter_dirs (list, optional): A list of patterns that will be used to match directories paths. The walk will only open directories that match at least one of these patterns. exclude_dirs (list): A list of patterns that will be used to filter out directories from the walk, e.g. ``['*.svn', '*.git']``. max_depth (int, optional): Maximum directory depth to walk. Returns: ~collections.Iterator: an iterator of ``(, , )`` named tuples, where ```` is an absolute path to a directory, and ```` and ```` are a list of `~fs.info.Info` objects for directories and files in ````. Example: >>> walker = Walker(filter=['*.py']) >>> for path, dirs, files in walker.walk(my_fs, namespaces=['details']): ... print("[{}]".format(path)) ... print("{} directories".format(len(dirs))) ... total = sum(info.size for info in files) ... print("{} bytes".format(total)) [/] 2 directories 55 bytes ... This method invokes `Walker.walk` with bound `FS` object. rbNr0)rzr\r>r-r5rDrxryr0r0r1r\s=zBoundWalker.walkcK |jdi|}|j|j|dS)aAWalk a filesystem, yielding absolute paths to files. Arguments: path (str): A path to a directory. Keyword Arguments: ignore_errors (bool): If `True`, any errors reading a directory will be ignored, otherwise exceptions will be raised. on_error (callable): If ``ignore_errors`` is `False`, then this callable will be invoked with a path and the exception object. It should return `True` to ignore the error, or `False` to re-raise it. search (str): If ``'breadth'`` then the directory will be walked *top down*. Set to ``'depth'`` to walk *bottom up*. filter (list): If supplied, this parameter should be a list of file name patterns, e.g. ``['*.py']``. Files will only be returned if the final component matches one of the patterns. exclude (list, optional): If supplied, this parameter should be a list of filename patterns, e.g. ``['~*', '.*']``. Files matching any of these patterns will be removed from the walk. filter_dirs (list, optional): A list of patterns that will be used to match directories paths. The walk will only open directories that match at least one of these patterns. exclude_dirs (list): A list of patterns that will be used to filter out directories from the walk, e.g. ``['*.svn', '*.git']``. max_depth (int, optional): Maximum directory depth to walk. Returns: ~collections.Iterator: An iterator over file paths (absolute from the filesystem root). This method invokes `Walker.files` with the bound `FS` object. r]Nr0)rzrZr>r-r5rxryr0r0r1rZTs'zBoundWalker.filescKr})auWalk a filesystem, yielding absolute paths to directories. Arguments: path (str): A path to a directory. Keyword Arguments: ignore_errors (bool): If `True`, any errors reading a directory will be ignored, otherwise exceptions will be raised. on_error (callable): If ``ignore_errors`` is `False`, then this callable will be invoked with a path and the exception object. It should return `True` to ignore the error, or `False` to re-raise it. search (str): If ``'breadth'`` then the directory will be walked *top down*. Set to ``'depth'`` to walk *bottom up*. filter_dirs (list, optional): A list of patterns that will be used to match directories paths. The walk will only open directories that match at least one of these patterns. exclude_dirs (list): A list of patterns that will be used to filter out directories from the walk, e.g. ``['*.svn', '*.git']``. max_depth (int, optional): Maximum directory depth to walk. Returns: ~collections.Iterator: an iterator over directory paths (absolute from the filesystem root). This method invokes `Walker.dirs` with the bound `FS` object. r]Nr0)rzrYr>r~r0r0r1rY~s zBoundWalker.dirscKr{)a Walk a filesystem, yielding path and `Info` of resources. Arguments: path (str): A path to a directory. namespaces (list, optional): A list of namespaces to include in the resource information, e.g. ``['basic', 'access']`` (defaults to ``['basic']``). Keyword Arguments: ignore_errors (bool): If `True`, any errors reading a directory will be ignored, otherwise exceptions will be raised. on_error (callable): If ``ignore_errors`` is `False`, then this callable will be invoked with a path and the exception object. It should return `True` to ignore the error, or `False` to re-raise it. search (str): If ``'breadth'`` then the directory will be walked *top down*. Set to ``'depth'`` to walk *bottom up*. filter (list): If supplied, this parameter should be a list of file name patterns, e.g. ``['*.py']``. Files will only be returned if the final component matches one of the patterns. exclude (list, optional): If supplied, this parameter should be a list of filename patterns, e.g. ``['~*', '.*']``. Files matching any of these patterns will be removed from the walk. filter_dirs (list, optional): A list of patterns that will be used to match directories paths. The walk will only open directories that match at least one of these patterns. exclude_dirs (list): A list of patterns that will be used to filter out directories from the walk, e.g. ``['*.svn', '*.git']``. max_depth (int, optional): Maximum directory depth to walk. Returns: ~collections.Iterable: an iterable yielding tuples of ``(, )``. This method invokes `Walker.info` with the bound `FS` object. rbNr0)rzrLr>r|r0r0r1rLs/zBoundWalker.infornro) r@rprqrrrr,rBrzr\__call__rZrYrLr0r0r0r1r=s   @  *%r=)0rr __future__rtyping collectionsrrr_reprrerrorsrr5r r r TYPE_CHECKINGr r rrrrrrrrbaserrLr ExceptionboolOnErrorTypeVarrrobjectrGenericr=default_walkerr\rZ walk_files walk_inforY walk_dirsr0r0r0r1s4   0  ;o