obc4FdZddlmZmZddlZddlZddlmZejr ddlm Z m Z m Z gdZ ejdejjZd Zd Zdd Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$e%dZ&dZ'y) aAUseful 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(^|/)\.\.?($|/)|//cT|dvr|St|s|jdS|jdrdnd}g} |jdD].}|dvr|dk(s |j |j |0 |dj|zS#t $r t|wxYw)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 components )/usr/lib/python3/dist-packages/fs/path.pyrr2s, s{  #4 ({{3OOC(SbFJ )C -ID $NN$!!),  - CHHZ( (( )"4(()sB$BB'cTtt|}|sgS|jdS)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)s r-rr^s( 8D> "D  ::c?c|dvrdgStt|dz}dg}|j}|j}d}t |}||kr|d|}||d||dz }||kr|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'] r rN)r rfindr'len)r)reversepathsr3r'poslen_paths r-rrss" s{u 8D> "S (D EE 99D \\F C4yH .3ntDSz q . TrT{ Lr0c$|jdS)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 ``'/'``). r r%r/s r-rrs ??3 r0c2|jdsd|zS|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. r r:r/s r-r r s ??3 Tz Kr0c$|jdS)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/s r-rrs$ ;;s r0cd}g}|D]%}|s|ddk(r|dd=d}|j|'tdj|}|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' Frr NT)r'rrr )r6absoluterelpathspr)s r-rrsi&HH  ts{QK OOA   CHHX& 'Dt} Kr0c|s|jSdj|jd|jdS)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 )r=formatr$path1path2s r-r r s6( ||~ >>%,,s+U\\#-> ??r0ct|}|jd}|jdrdndg}|r||jdz }|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'] r z./)rstripr%r)r)_pathr+_partss r-rr sO TNES!J%%c*c 5F*""3'' Mr0cRd|vrd|fS|jdd}|dxsd|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') r r!rr)rsplit)r)rs r-rr$s<, $Dz KKQ E !HOU1X &&r0ct|\}}|jdr|jddk(r|dfSd|vr|dfS|jdd\}}t ||}|d|zfS)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%countrLr)r) parent_pathpathnameexts r-rr@sx&"$KK3HNN3$71$<Rx (RxOOC+MHc  X &D s?r0c6t|jdS)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 rN)r r%r/s r-rr]s& D> $ $S ))r0ct|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/s r-r r s, ;q>r0ct|dS)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/') '' rrUr/s r-r r rVr0cTtt|tt|k(S)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 rrDs r-rrs!$ 8E? #wx'? ??r0cttt|}tt|}|j|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 )rr r%)rErF_path1_path2s r-rrs1 gen %F gen %F   V $$r0c|jd}|jd}|r#|ddk(r|j|r |ddk(rt|t|kDryt||D] \}}||k7s yy)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 r r2r!FT)rr&r4zip)rErFbits1bits2bit1bit2s r-rrs, KK E KK E E"IO  E"IO 5zCJE5) t 4< r0c2|jds|dzS|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/s r-rrs& == cz Kr0cLt||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 ValueErrorr4rDs r-rr s+ E5 !:;; U r0ctt|}tt|}d}t||D]\}}||k7rn|dz }djdgt ||z z||dzS)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' rrr r"N)listrr]rr4)baser) base_parts path_partscommon component_a component_bs r-rrs"k$'(Jk$'(J F$' J$? [ + % !  88TFc*o67*VW:MM NNr0z*?[]!{}c6|Jtj| 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 ) _WILD_CHARS isdisjointr/s r-rr>s$"   %%d+ ++r0)F)(__doc__ __future__rrtypingreerrorsr TYPE_CHECKINGrrr __all__compileUNICODEsearchr#rrrrr rrr rrrrr r rrrrrr frozensetrorr0r-r}s8 ( (( 0%"**%:BJJGNN))X*#L  (*D@20'8:*,22@*%*D0*O: " ,r0