o pfc4@sdZddlmZmZddlZddlZddlmZejr%ddlm Z m Z m Z gdZ e dejjZd d Zd d Zd5ddZddZddZddZddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Z d*d+Z!d,d-Z"d.d/Z#d0d1Z$e%d2Z&d3d4Z'dS)6aAUseful functions for working with PyFilesystem paths. This is broadly similar to the standard `os.path` module but works with paths in the canonical format expected by all FS objects (that is, separated by forward slashes and with an optional leading slash). See :ref:`paths` for an explanation of PyFilesystem paths. )print_functionunicode_literalsN)IllegalBackReference)ListTextTuple)abspathbasenamecombinedirnameforcedirfrombaseisabsisbase isdotfileisparent issamedir iswildcard iteratepathjoinnormpathparts recursepath relativefromrelpathsplitsplitextz(^|/)\.\.?($|/)|//cCs|dvr|St|s|dS|drdnd}g}z|dD]}|dvr/|dkr.|q ||q Wn tyAt|w|d|S)aNormalize a path. This function simplifies a path by collapsing back-references and removing duplicated separators. Arguments: path (str): Path to normalize. Returns: str: A valid FS path. Example: >>> normpath("/foo//bar/frob/../baz") '/foo/bar/baz' >>> normpath("foo/../../bar") Traceback (most recent call last): ... fs.errors.IllegalBackReference: path 'foo/../../bar' contains back-references outside of filesystem /..) _requires_normalizationrstrip startswithrpopappend IndexErrorrr)pathprefix components componentr+@/home/ertert/spirit/venv/lib/python3.10/site-packages/fs/path.pyr2s$   rcCstt|}|s gS|dS)zIterate over the individual components of a path. Arguments: path (str): Path to iterate over. Returns: list: A list of path components. Example: >>> iteratepath('/foo/bar/baz') ['foo', 'bar', 'baz'] r)rrrr'r+r+r,r^s  rFcCs|dvrdgStt|d}dg}|j}|j}d}t|}||kr7|d|}||d||d7}||ks"|r@|dddS|S)aNGet intermediate paths from the root to the given path. Arguments: path (str): A PyFilesystem path reverse (bool): Reverses the order of the paths (default `False`). Returns: list: A list of paths. Example: >>> recursepath('a/b/c') ['/', '/a', '/a/b', '/a/b/c'] rrN)r rfindr%len)r'reversepathsr/r%poslen_pathr+r+r,rss  rcC |dS)zCheck if a path is an absolute path. Arguments: path (str): A PyFilesytem path. Returns: bool: `True` if the path is absolute (starts with a ``'/'``). rr#r-r+r+r,rs rcCs|ds d|S|S)a/Convert the given path to an absolute path. Since FS objects have no concept of a *current directory*, this simply adds a leading ``/`` character if the path doesn't already have one. Arguments: path (str): A PyFilesytem path. Returns: str: An absolute path. rr6r-r+r+r,r s r cCr5)a1Convert the given path to a relative path. This is the inverse of `abspath`, stripping a leading ``'/'`` from the path if it is present. Arguments: path (str): A path to adjust. Returns: str: A relative path. Example: >>> relpath('/a/b') 'a/b' r)lstripr-r+r+r,rs rcGsXd}g}|D]}|r|ddkr|dd=d}||qtd|}|r*t|}|S)a]Join any number of paths together. Arguments: *paths (str): Paths to join, given as positional arguments. Returns: str: The joined path. Example: >>> join('foo', 'bar', 'baz') 'foo/bar/baz' >>> join('foo/bar', '../baz') 'foo/baz' >>> join('foo/bar', '/baz') '/baz' FrrNT)r%rrr )r2absoluterelpathspr'r+r+r,rs   rcCs$|s|Sd|d|dS)aJoin two paths together. This is faster than :func:`~fs.path.join`, but only works when the second path is relative, and there are no back references in either path. Arguments: path1 (str): A PyFilesytem path. path2 (str): A PyFilesytem path. Returns: str: The joint path. Example: >>> combine("foo/bar", "baz") 'foo/bar/baz' z{}/{}r)r7formatr"path1path2r+r+r,r sr cCs<t|}|d}|drdndg}|r||d7}|S)zSplit a path in to its component parts. Arguments: path (str): Path to split in to parts. Returns: list: List of components Example: >>> parts('/foo/bar/baz') ['/', 'foo', 'bar', 'baz'] rz./)rstripr#r)r'_pathr)_partsr+r+r,r s  rcCs0d|vrd|fS|dd}|dpd|dfS)aSplit a path into (head, tail) pair. This function splits a path into a pair (head, tail) where 'tail' is the last pathname component and 'head' is all preceding components. Arguments: path (str): Path to split Returns: (str, str): a tuple containing the head and the tail of the path. Example: >>> split("foo/bar") ('foo', 'bar') >>> split("foo/bar/baz") ('foo/bar', 'baz') >>> split("/foo/bar/baz") ('/foo/bar', 'baz') rrrr)rsplit)r'rr+r+r,r$s rcCsbt|\}}|dr|ddkr|dfSd|vr|dfS|dd\}}t||}|d|fS)a~Split the extension from the path. Arguments: path (str): A path to split. Returns: (str, str): A tuple containing the path and the extension. Example: >>> splitext('baz.txt') ('baz', '.txt') >>> splitext('foo/bar/baz.txt') ('foo/bar/baz', '.txt') >>> splitext('foo/bar/.foo') ('foo/bar/.foo', '') .rr)rr#countrBr)r' parent_pathpathnameextr+r+r,r@s   rcCst|dS)aNDetect if a path references a dot file. Arguments: path (str): Path to check. Returns: bool: `True` if the resource name starts with a ``'.'``. Example: >>> isdotfile('.baz') True >>> isdotfile('foo/bar/.baz') True >>> isdotfile('foo/bar.baz') False rC)r r#r-r+r+r,r]srcC t|dS)aReturn the parent directory of a path. This is always equivalent to the 'head' component of the value returned by ``split(path)``. Arguments: path (str): A PyFilesytem path. Returns: str: the parent directory of the given path. Example: >>> dirname('foo/bar/baz') 'foo/bar' >>> dirname('/foo/bar') '/foo' >>> dirname('/foo') '/' rrr-r+r+r,r s r cCrH)aReturn the basename of the resource referenced by a path. This is always equivalent to the 'tail' component of the value returned by split(path). Arguments: path (str): A PyFilesytem path. Returns: str: the name of the resource at the given path. Example: >>> basename('foo/bar/baz') 'baz' >>> basename('foo/bar') 'bar' >>> basename('foo/bar/') '' rrIr-r+r+r,r rJr cCstt|tt|kS)aCheck if two paths reference a resource in the same directory. Arguments: path1 (str): A PyFilesytem path. path2 (str): A PyFilesytem path. Returns: bool: `True` if the two resources are in the same directory. Example: >>> issamedir("foo/bar/baz.txt", "foo/bar/spam.txt") True >>> issamedir("foo/bar/baz/txt", "spam/eggs/spam.txt") False )r rr<r+r+r,rsrcCs"tt|}tt|}||S)a(Check if ``path1`` is a base of ``path2``. Arguments: path1 (str): A PyFilesytem path. path2 (str): A PyFilesytem path. Returns: bool: `True` if ``path2`` starts with ``path1`` Example: >>> isbase('foo/bar', 'foo/bar/baz/egg.txt') True )r r r#)r=r>_path1_path2r+r+r,rs   rcCsv|d}|d}|r|ddkr||r|ddkst|t|kr(dSt||D] \}}||kr8dSq-dS)aCheck if ``path1`` is a parent directory of ``path2``. Arguments: path1 (str): A PyFilesytem path. path2 (str): A PyFilesytem path. Returns: bool: `True` if ``path1`` is a parent directory of ``path2`` Example: >>> isparent("foo/bar", "foo/bar/spam.txt") True >>> isparent("foo/bar/", "foo/bar") True >>> isparent("foo/barry", "foo/baz/bar") False >>> isparent("foo/bar/baz/", "foo/baz/bar") False rr.rFT)rr$r0zip)r=r>bits1bits2bit1bit2r+r+r,rs  rcCs|ds |dS|S)a]Ensure the path ends with a trailing forward slash. Arguments: path (str): A PyFilesytem path. Returns: str: The path, ending with a slash. Example: >>> forcedir("foo/bar") 'foo/bar/' >>> forcedir("foo/bar/") 'foo/bar/' >>> forcedir("foo/spam.txt") 'foo/spam.txt/' r)endswithr-r+r+r,r s r cCs"t||s td|t|dS)a,Get the final path of ``path2`` that isn't in ``path1``. Arguments: path1 (str): A PyFilesytem path. path2 (str): A PyFilesytem path. Returns: str: the final part of ``path2``. Example: >>> frombase('foo/bar/', 'foo/bar/baz/egg') 'baz/egg' zpath1 must be a prefix of path2N)r ValueErrorr0r<r+r+r,r s rcCshtt|}tt|}d}t||D]\}}||krn|d7}qddgt||||dS)ajReturn a path relative from a given base path. Insert backrefs as appropriate to reach the path from the base. Arguments: base (str): Path to a directory. path (str): Path to make relative. Returns: str: the path to ``base`` from ``path``. >>> relativefrom("foo/bar", "baz/index.html") '../../baz/index.html' rrrr N)listrrMrr0)baser' base_parts path_partscommon component_a component_br+r+r,rs   $rz*?[]!{}cCs|dusJt| S)aCheck if a path ends with a wildcard. Arguments: path (str): A PyFilesystem path. Returns: bool: `True` if path ends with a wildcard. Example: >>> iswildcard('foo/bar/baz.*') True >>> iswildcard('foo/bar') False N) _WILD_CHARS isdisjointr-r+r+r,r>s  r)F)(__doc__ __future__rrtypingreerrorsr TYPE_CHECKINGrrr__all__compileUNICODEsearchr!rrrrr rrr rrrrr r rrrr rr frozensetr[rr+r+r+r,s>  , &""