U f @sdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlmZeeddlZW5QRXeeddlZW5QRXeeddlZW5QRXddlmZmZmZmZmZddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'e"rdddl(m)Z)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/d d l0m1Z1m2Z2m3Z3d d l4m5Z5m6Z6d d gZ7dddgZ8e8dddgZ9e:d;e8<Z=e:d;e9Z>e:e=j?dZ@e:e>j?dZAeBZCdddddZDGdddeEZFGdddZGd d!ZHGd"d d eIZJGd#d$d$eKZLd%d&ZMGd'd(d(eJZNGd)d*d*eJZOGd+d,d,ZPGd-d.d.ZQGd/d d eJZRGd0d1d1ZSdS)2a Path Pie Implements ``path.Path`` - An object representing a path to a file or directory. Example:: from path import Path d = Path('/home/guido/bin') # Globbing for f in d.files('*.py'): f.chmod(0o755) # Changing the working directory: with Path("somewhere"): # cwd in now `somewhere` ... # Concatenate paths with / foo_txt = Path("bar") / "foo.txt" ) annotationsN)Number)BufferedRandomBufferedReaderBufferedWriterFileIO TextIOWrapper)IO TYPE_CHECKINGAnyBinaryIOCallableIteratoroverload)OpenBinaryModeOpenBinaryModeReadingOpenBinaryModeUpdatingOpenBinaryModeWriting OpenTextMode)Literal)classesmasksmatchers) removeprefix removesuffixPathTempDirz   …u
u
|$$zNumber | datetime.datetimer)valuereturncCs"t|tr|n|}t|dS)Niʚ;) isinstancer timestampint)r$Z timestamp_sr)1/tmp/pip-unpacked-wheel-qyyspjli/path/__init__.py_make_timestamp_nsasr+c@s eZdZdS)TreeWalkWarningN)__name__ __module__ __qualname__r)r)r)r*r,fsr,c@s eZdZdZddZddZdS) Traversalap Wrap a walk result to customize the traversal. `follow` is a function that takes an item and returns True if that item should be followed and False otherwise. For example, to avoid traversing into directories that begin with `.`: >>> traverse = Traversal(lambda dir: not dir.startswith('.')) >>> items = list(traverse(Path('.').walk())) Directories beginning with `.` will appear in the results, but their children will not. >>> dot_dir = next(item for item in items if item.is_dir() and item.startswith('.')) >>> any(item.parent == dot_dir for item in items) False cCs ||_dSN)follow)selfr2r)r)r*__init__szTraversal.__init__ccsDd}z||}Wntk r(YdSX|Vt|j|}qdSr1)send StopIteration functoolspartialr2)r3walkertraverseitemr)r)r*__call__szTraversal.__call__N)r-r.r/__doc__r4r<r)r)r)r*r0jsr0cCsdd|DS)zZ >>> list(_strip_newlines(['Hello World\r\n', 'foo'])) ['Hello World', 'foo'] css|]}td|VqdS)N)U_NL_ENDsub.0liner)r)r* sz"_strip_newlines..r))linesr)r)r*_strip_newlinessrFc seZdZdZejZd;fdd ZdZ,e%e#d=d=d?Z-d@dAZ.dBdCZ/dDdEZ0dFdGZ1dHdIZ2e j3dJdKZ4dLdMZ5dNdOZ6dPdQZ7dRdSZ8d=dTdUZ9dVdWZ:d>dXdYZ;d?dZd[Zd@dadbZ?dcddZ@dedfZAdAdgdhZBdidjZCdkdlZDeEdBdndodpdpdpdqdrdsdtdudvZFeEdCdwdxdpdpdpdqdydzdtd{dvZFeEdDd|d}dpdpdpdqdyd~dtddvZFeEdEdd}dpdpdpdqdyddtddvZFeEdFdd}dpdpdpdqdyddtddvZFeEdGdwdodpdpdpdqdyddtddvZFeEdHddodpdpdpdqdyddtddvZFddvZFddZGeEdIdodndodpdpdpdqdrdd ddZHeEdJdodwdodpdpdpdqdrdd ddZHeEdKdoddodpdpdpdqdrdd ddZHddZHdLddZIdMddZJddZKdNddZLeEdOddpddpdqddddZMeEdPddddpdqddddZMd=d`ejNdfddZMdQddZOd=d`ePdfddZQeRddZSddZTddZUddZVddZWddZXddZYddZZddZ[ddZ\ddZ]ddÄZ^ddńZ_ddDŽZ`ddɄZadd˄Zbe%eaebd=d̃Zcdd΄ZdddЄZee%edeed=dуZfddӄZge%egd=d=dԃZhddքZie%eid=d=d׃Zje%ddٜddۄZkdd݄ZlddޜddZmddZnddZoddZpddZqderkreonderkrepneqZse%esd=d=dZtderkrddޜddZuevedrddZwevedrddZxddZyddZzevedr dRddZ{ddZ|ddZ}dSddZ~dTddZdUddZdVdd Zd d Zd d ZddZddZddZddZddZeZeZdddddZddZdWddqddddZdXd d!Zd"d#Zd$d%ZejZejZejZejZejZejZeved&rXejZejZd'd(Zd)d*ZeZdYejd+d,d-d.d/Zeved0rd1d2Zeved3rҐd4d5ZejdZd7d8Ze je d9d:ZZS([ra Represents a filesystem path. For documentation on individual methods, consult their counterparts in :mod:`os.path`. Some methods are additionally included from :mod:`shutil`. The functions are linked directly into the class namespace such that they will be bound to the Path instance. For example, ``Path(src).copy(target)`` is equivalent to ``shutil.copy(src, target)``. Therefore, when referencing the docs for these methods, assume `src` references `self`, the Path instance. .cst||Sr1)super__new__)clsother __class__r)r*rIsz Path.__new__c Cs2|dkrtdtt|W5QRXdS)Nz$Invalid initial value for path: None) TypeError contextlibsuppressAttributeError _validater3rKr)r)r*r4s z Path.__init__cCs*|jd|j}|f}d|i}t|||S)N_moduler-type)rJrUZ subclass_namebasesnsr)r)r* using_moduleszPath.using_modulecCs|S)zV What class should be used to construct new instances from this class r)rJr)r)r* _next_classszPath._next_classcst|jdtdS)N())rWr-rH__repr__r3rLr)r*r_sz Path.__repr__cs|t|Sr1)r\rH__add__)r3ZmorerLr)r*rasz Path.__add__cCs|||Sr1)r\rarSr)r)r*__radd__sz Path.__radd__cCs||j||S)zfp.__div__(rel) == fp / rel == fp.joinpath(rel) Join two path components, adding a separator character if needed. .. seealso:: :func:`os.path.join` r\rUjoinr3relr)r)r*__div__sz Path.__div__cCs||j||S)zfp.__rdiv__(rel) == rel / fp Join two path components, adding a separator character if needed. .. seealso:: :func:`os.path.join` rcrer)r)r*__rdiv__sz Path.__rdiv__cCs||_t||Sr1)cwd_old_diroschdirr`r)r)r* __enter__s  zPath.__enter__cGst|jdSr1)rkrlrj)r3rTr)r)r*__exit__sz Path.__exit__cCs |tS)zgReturn the current working directory as a path object. .. seealso:: :func:`os.getcwd` )rkgetcwdr[r)r)r*riszPath.cwdcCstjdtdd|S)Nz.getcwd is deprecated; use cwd stacklevel)warningswarnDeprecationWarningrir[r)r)r*ros z Path.getcwdcCs||j|S)z$.. seealso:: :func:`os.path.abspath`)r\rUabspathr`r)r)r*absolute sz Path.absolutecCstjdtdd|S)Nz$.abspath is deprecated; use absoluterprq)rsrtrurwr`r)r)r*rv s z Path.abspathcCs||j|S)z%.. seealso:: :func:`os.path.normcase`)r\rUnormcaser`r)r)r*rxsz Path.normcasecCs||j|S)z%.. seealso:: :func:`os.path.normpath`)r\rUnormpathr`r)r)r*rysz Path.normpathcCs||j|S)z%.. seealso:: :func:`os.path.realpath`)r\rUrealpathr`r)r)r*rzsz Path.realpathcCs||j|S)z'.. seealso:: :func:`os.path.expanduser`)r\rU expanduserr`r)r)r*r{!szPath.expandusercCs||j|S)z'.. seealso:: :func:`os.path.expandvars`)r\rU expandvarsr`r)r)r*r|%szPath.expandvarscCs||j|S)z4.. seealso:: :attr:`parent`, :func:`os.path.dirname`)r\rUdirnamer`r)r)r*r})sz Path.dirnamecCs||j|S)z3.. seealso:: :attr:`name`, :func:`os.path.basename`)r\rUbasenamer`r)r)r*r~-sz Path.basenamecCs|S)zClean up a filename by calling :meth:`expandvars()`, :meth:`expanduser()`, and :meth:`normpath()` on it. This is commonly everything needed to clean up a filename read from a configuration file, for example. )r|r{ryr`r)r)r*expand1sz Path.expandcCs|j|j\}}|S)zThe same as :meth:`name`, but with one file extension stripped off. >>> Path('/home/guido/python.tar.gz').stem 'python.tar' )rUsplitextname)r3baseextr)r)r*stem:sz Path.stemcCs|||jS)zReturn a new path with the stem changed. >>> Path('/home/guido/python.tar.gz').with_stem("foo") Path('/home/guido/foo.gz') ) with_namesuffix)r3rr)r)r* with_stemDszPath.with_stemcCs|j|\}}|S)z*The file extension, for example ``'.py'``.)rUr)r3frr)r)r*rLsz Path.suffixcCstjdtdd|jS)Nz.ext is deprecated; use suffixrprq)rsrtrurr`r)r)r*rRs zPath.extcCs$|dstd|||S)aReturn a new path with the file suffix changed (or added, if none) >>> Path('/home/guido/python.tar.gz').with_suffix(".foo") Path('/home/guido/python.tar.foo') >>> Path('python').with_suffix('.zip') Path('python.zip') >>> Path('filename.ext').with_suffix('zip') Traceback (most recent call last): ... ValueError: Invalid suffix 'zip' rGzInvalid suffix ) startswith ValueErrorstripext)r3rr)r)r* with_suffix[s zPath.with_suffixcCs|j|\}}||S)z}The drive specifier, for example ``'C:'``. This is always empty on systems that don't use drive specifiers. rU splitdriver\)r3driverr)r)r*rnsz Path.driveNz This path's parent directory, as a new Path object. For example, ``Path('/usr/local/lib/libpython.so').parent == Path('/usr/local/lib')`` .. seealso:: :meth:`dirname`, :func:`os.path.dirname` z The name of this file or directory without the full path. For example, ``Path('/usr/local/lib/libpython.so').name == 'libpython.so'`` .. seealso:: :meth:`basename`, :func:`os.path.basename` cCs|t||j|S)zReturn a new path with the name changed. >>> Path('/home/guido/python.tar.gz').with_name("foo.zip") Path('/home/guido/foo.zip') )r\rrr3rr)r)r*rszPath.with_namecCs|j|\}}|||fS)z~Return two-tuple of ``.parent``, ``.name``. .. seealso:: :attr:`parent`, :attr:`name`, :func:`os.path.split` )rUsplitr\)r3parentchildr)r)r* splitpathszPath.splitpathcCs$|j|\}}||||fS)aCReturn two-tuple of ``.drive`` and rest without drive. Split the drive specifier from this path. If there is no drive specifier, :samp:`{p.drive}` is empty, so the return value is simply ``(Path(''), p)``. This is always the case on Unix. .. seealso:: :func:`os.path.splitdrive` r)r3rrfr)r)r*rs zPath.splitdrivecCs|j|\}}|||fS)aReturn two-tuple of ``.stripext()`` and ``.ext``. Split the filename extension from this path and return the two parts. Either part may be empty. The extension is everything from ``'.'`` to the end of the last path segment. This has the property that if ``(a, b) == p.splitext()``, then ``a + b == p``. .. seealso:: :func:`os.path.splitext` )rUrr\)r3filenamerr)r)r*rs z Path.splitextcCs |dS)zRemove one file extension from the path. For example, ``Path('/home/guido/python.tar.gz').stripext()`` returns ``Path('/home/guido/python.tar')``. r)rr`r)r)r*rsz Path.stripextcGs||jj|f|S)a Join first to zero or more :class:`Path` components, adding a separator character (:samp:`{first}.module.sep`) if needed. Returns a new instance of :samp:`{first}._next_class`. .. seealso:: :func:`os.path.join` rc)rJfirstZothersr)r)r*joinpaths z Path.joinpathcCs t|S)aReturn a list of the path components in this path. The first item in the list will be a Path. Its value will be either :data:`os.curdir`, :data:`os.pardir`, empty, or the root directory of this path (for example, ``'/'`` or ``'C:\\'``). The other items in the list will be strings. ``Path.joinpath(*result)`` will yield the original path. >>> Path('/foo/bar/baz').splitall() [Path('/'), 'foo', 'bar', 'baz'] )list_partsr`r)r)r*splitalls z Path.splitallcCs t|S)z[ >>> Path('/foo/bar/baz').parts() (Path('/'), 'foo', 'bar', 'baz') )tuplerr`r)r)r*partssz Path.partscCstt|Sr1)reversedr _parts_iterr`r)r)r*rsz Path._partsccsD|}|tjkr:|tjkr:|}|\}}||kr2q:|Vq|VdSr1)rkcurdirpardirr)r3locprevrr)r)r*rs zPath._parts_itercCs||}||S)zzReturn this path as a relative path, based from `start`, which defaults to the current working directory. )r\ relpathto)r3startrir)r)r*relpaths z Path.relpathc Cs|}||}|}|}|d|j|dkrF|Sd}t||D]$\}}||j|krpqz|d7}qTtjgt||}|||d7}t|dkrtj } n |jj |} || S)zReturn a relative path from `self` to `dest`. If there is no relative path from `self` to `dest`, for example if they reside on different drives in Windows, then this returns ``dest.absolute()``. rrN) rwr\rxrrUziprkrlenrrd) r3destoriginZ orig_listZ dest_listiZ start_segZdest_segsegmentsrr)r)r*rs"    zPath.relpathtocs(t|}t|fddtDS)a}Yields items in this directory. Use :meth:`files` or :meth:`dirs` instead if you want a listing of just files or just subdirectories. The elements of the list are Path objects. With the optional `match` argument, a callable, only return items whose names match the given pattern. .. seealso:: :meth:`files`, :meth:`dirs` c3s|]}|VqdSr1r))rBrr`r)r*rD1szPath.iterdir..)rloadfilterrklistdirr3matchr)r`r*iterdir#s z Path.iterdircCs tjdtddt|j|dS)Nz#.listdir is deprecated; use iterdirrprq)r)rsrtrurrrr)r)r*r3s z Path.listdircOsdd|j||DS)zList of this directory's subdirectories. The elements of the list are Path objects. This does not walk recursively into subdirectories (but see :meth:`walkdirs`). Accepts parameters to :meth:`iterdir`. cSsg|]}|r|qSr)is_dirrBpr)r)r* DszPath.dirs..rr3argskwargsr)r)r*dirs;s z Path.dirscOsdd|j||DS)zList of the files in self. The elements of the list are Path objects. This does not walk into subdirectories (see :meth:`walkfiles`). Accepts parameters to :meth:`iterdir`. cSsg|]}|r|qSr)is_filerr)r)r*rOszPath.files..rrr)r)r*filesFs z Path.filesstrictc cst|}t|}z |}Wn<tk r\}z|d|d|WYdSd}~XYnX|D]}d}||rx|V}|p|j}z |}Wn>tk r}z |d|d|WYqbW5d}~XYnX|rb|j||dEdHqbdS)aIterator over files and subdirs, recursively. The iterator yields Path objects naming each child item of this directory and its descendants. This requires that ``D.is_dir()``. This performs a depth-first traversal of the directory tree. Each directory is returned just before all its children. The `errors=` keyword argument controls behavior when an error occurs. The default is ``'strict'``, which causes an exception. Other allowed values are ``'warn'`` (which reports the error via :func:`warnings.warn()`), and ``'ignore'``. `errors` may also be an arbitrary callable taking a msg parameter. zUnable to list directory 'z': NzUnable to access ')errorsr)Handlers_resolverrr Exceptionrwalk)r3rrZ childListexcrr:Z do_traverser)r)r*rQs&     z Path.walkcOsdd|j||DS)z#Iterator over subdirs, recursively.css|]}|r|VqdSr1rrBr;r)r)r*rD{sz Path.walkdirs..rrr)r)r*walkdirsysz Path.walkdirscOsdd|j||DS)z!Iterator over files, recursively.css|]}|r|VqdSr1rrr)r)r*rDsz!Path.walkfiles..rrr)r)r* walkfiles}szPath.walkfilescCs6t|d|jj}|p|}||j}||}t||S)aReturn ``True`` if `self.name` matches the given `pattern`. `pattern` - A filename pattern with wildcards, for example ``'*.py'``. If the pattern contains a `normcase` attribute, it is applied to the name and path prior to comparison. `normcase` - (optional) A function used to normalize the pattern and filename before matching. Defaults to normcase from ``self.module``, :func:`os.path.normcase`. .. seealso:: :func:`fnmatch.fnmatch` rx)getattrrUrxrfnmatch fnmatchcase)r3patternrxZdefault_normcaserr)r)r*rs  z Path.fnmatchcs"|jfddt||DS)aReturn a list of Path objects that match the pattern. `pattern` - a path relative to this directory, with wildcards. For example, ``Path('/users').glob('*/bin/*')`` returns a list of all the files users have in their :file:`bin` directories. .. seealso:: :func:`glob.glob` .. note:: Glob is **not** recursive, even when using ``**``. To do recursive globbing see :func:`walk`, :func:`walkdirs` or :func:`walkfiles`. csg|] }|qSr)r)rBsr[r)r*rszPath.glob..)r\globr3rr)r[r*rsz Path.globcs"|jfddt||DS)a Return an iterator of Path objects that match the pattern. `pattern` - a path relative to this directory, with wildcards. For example, ``Path('/users').iglob('*/bin/*')`` returns an iterator of all the files users have in their :file:`bin` directories. .. seealso:: :func:`glob.iglob` .. note:: Glob is **not** recursive, even when using ``**``. To do recursive globbing see :func:`walk`, :func:`walkdirs` or :func:`walkfiles`. c3s|]}|VqdSr1r)rr[r)r*rDszPath.iglob..)r\riglobrr)r[r*rsz Path.iglob.rr(z str | Noneboolz Callable[[str, int], int] | Noner)mode bufferingencodingrnewlineclosefdopenerr%cCsdSr1r)r3rrrrrrrr)r)r*opens z Path.openrz Literal[0]zCallable[[str, int], int]rcCsdSr1r)rr)r)r*rs rzLiteral[(-1, 1)]rcCsdSr1r)rr)r)r*rs rrcCsdSr1r)rr)r)r*rs rrcCsdSr1r)rr)r)r*rs r cCsdSr1r)rr)r)r*rs strzIO[Any]cCsdSr1r)rr)r)r*rs cOst|f||S)zOpen this file and return a corresponding file object. Keyword arguments work as in :func:`io.open`. If the file cannot be opened, an :class:`OSError` is raised. )rrr)r)r*rsc Cs*|d}|W5QRSQRXdS)z8Open this file, read all bytes, return them as a string.rbNrreadr3rr)r)r*bytess z Path.bytesz Iterator[str]) sizerrrrrrrr%c CsdSr1r) r3rrrrrrrrr)r)r*chunkss z Path.chunkszIterator[builtins.bytes]c CsdSr1r)rr)r)r*r(s zIterator[str | builtins.bytes]c CsdSr1r)rr)r)r*r5s c /s6|j|| tfdddEdHW5QRXdS)aReturns a generator yielding chunks of the file, so it can be read piece by piece with a simple for loop. Any argument you pass after `size` will be passed to :meth:`open`. :example: >>> hash = hashlib.md5() >>> for chunk in Path("NEWS.rst").chunks(8192, mode='rb'): ... hash.update(chunk) This will read the file by chunks of 8192 bytes. csp dSr1)rr)rrr)r*QzPath.chunks..N)riter)r3rrrr)rr*rBsFc Cs,||r dnd}||W5QRXdS)zOpen this file and write the given bytes to it. Default behavior is to overwrite any existing file. Call ``p.write_bytes(bytes, append=True)`` to append instead. abwbN)rwrite)r3rappendrr)r)r* write_bytesSszPath.write_bytesc Cs.|j||d}|W5QRSQRXdS)zOpen this file, read it in, return the content as a string. Optional parameters are passed to :meth:`open`. .. seealso:: :meth:`lines` )rrNr)r3rrrr)r)r* read_text\szPath.read_textc Cs,|jdd}|W5QRSQRXdS)z*Return the contents of this file as bytes.rrNrrr)r)r* read_bytesfszPath.read_bytescCs$tjdtddtd|||S)zYLegacy function to read text. Converts all newline sequences to ``\n``. z".text is deprecated; use read_textrprqr)rsrtru U_NEWLINEr@r)r3rrr)r)r*textks z Path.textNone)rrrlineseprr%cCsdSr1r)r3rrrrrr)r)r* write_textwszPath.write_textzbuiltins.bytescCsdSr1r)rr)r)r*rscCs~t|tr4|dk rt||}||p,t|}n8tjdt dd|dksPt |dk rht ||}|}|j ||ddS)aWrite the given text to this file. The default behavior is to overwrite any existing file; to append instead, use the `append=True` keyword argument. There are two differences between :meth:`write_text` and :meth:`write_bytes`: newline handling and Unicode handling. See below. Parameters: `text` - str/bytes - The text to be written. `encoding` - str - The text encoding used. `errors` - str - How to handle Unicode encoding errors. Default is ``'strict'``. See ``help(unicode.encode)`` for the options. Ignored if `text` isn't a Unicode string. `linesep` - keyword argument - str/unicode - The sequence of characters to be used to mark end-of-line. The default is :data:`os.linesep`. Specify ``None`` to use newlines unmodified. `append` - keyword argument - bool - Specifies what to do if the file already exists (``True``: append to the end of it; ``False``: overwrite it). The default is ``False``. --- Newline handling. ``write_text()`` converts all standard end-of-line sequences (``'\n'``, ``'\r'``, and ``'\r\n'``) to your platform's default end-of-line sequence (see :data:`os.linesep`; on Windows, for example, the end-of-line marker is ``'\r\n'``). To override the platform's default, pass the `linesep=` keyword argument. To preserve the newlines as-is, pass ``linesep=None``. This handling applies to Unicode text and bytes, except with Unicode, additional non-ASCII newlines are recognized: ``\x85``, ``\r\x85``, and ``\u2028``. --- Unicode If `text` isn't Unicode, then apart from newline handling, the bytes are written verbatim to the file. The `encoding` and `errors` arguments are not used and must be omitted. If `text` is Unicode, it is first converted to :func:`bytes` using the specified `encoding` (or the default encoding if `encoding` isn't specified). The `errors` argument applies only to this conversion. Nz)Writing bytes in write_text is deprecatedrrq)r) r&rrr@encodesysgetdefaultencodingrsrtruAssertionError B_NEWLINEr)r3rrrrrrr)r)r*rs:   TcCstd|||}||S)aOpen this file, read all lines, return them in a list. Optional arguments: `encoding` - The Unicode encoding (or character set) of the file. The default is ``None``, meaning use ``locale.getpreferredencoding()``. `errors` - How to handle Unicode errors; see `open `_ for the options. Default is ``None`` meaning "strict". `retain` - If ``True`` (default), retain newline characters, but translate all newline characters to ``\n``. If ``False``, newline characters are omitted. .. seealso:: :meth:`text` r)rr@r splitlines)r3rrZretainrr)r)r*rEsz Path.linesc Cs@|rdnd}|j|||dd}||||W5QRXdS)aWrite the given lines of text to this file. By default this overwrites any existing file at this path. This puts a platform-specific newline sequence on every line. See `linesep` below. `lines` - A list of strings. `encoding` - A Unicode encoding to use. This applies only if `lines` contains any Unicode strings. `errors` - How to handle errors in Unicode encoding. This also applies only to Unicode strings. linesep - (deprecated) The desired line-ending. This line-ending is applied to every line. If a line already has any standard line ending (``'\r'``, ``'\n'``, ``'\r\n'``, ``u'\x85'``, ``u'\r\x85'``, ``u'\u2028'``), that will be stripped off and this will be used instead. The default is os.linesep, which is platform-dependent (``'\r\n'`` on Windows, ``'\n'`` on Unix, etc.). Specify ``None`` to write the lines as-is, like ``.writelines`` on a file object. Use the keyword argument ``append=True`` to append lines to the file. The default is to overwrite the file. awr>)rrrN)r writelines_replace_linesep)r3rErrrrrrr)r)r* write_liness$ zPath.write_linescsBtkrtjdtddntjdkr,|Sfddt|DS)Nzlinesep is deprecatedrqc3s|]}|VqdSr1r)rArr)r*rDsz(Path._replace_linesep..)_default_lineseprsrtrurkrrF)rErr)rr*rs zPath._replace_linesepcCs |dS)zCalculate the md5 hash for this file. This reads through the entire file. .. seealso:: :meth:`read_hash` md5) read_hashr`r)r)r*read_md5sz Path.read_md5cCs,t|}|jdddD]}||q|S)zReturns a hash object for the file at the current path. `hash_name` should be a hash algo name (such as ``'md5'`` or ``'sha1'``) that's available in the :mod:`hashlib` module. i rr)hashlibnewrupdate)r3 hash_namemchunkr)r)r*_hash%s  z Path._hashcCs||S)zCalculate given hash for this file. List of supported hashes can be obtained from :mod:`hashlib` package. This reads the entire file. .. seealso:: :meth:`hashlib.hash.digest` )rdigestr3r r)r)r*r0szPath.read_hashcCs||S)zCalculate given hash for this file, returning hexdigest. List of supported hashes can be obtained from :mod:`hashlib` package. This reads the entire file. .. seealso:: :meth:`hashlib.hash.hexdigest` )r hexdigestrr)r)r* read_hexhash:szPath.read_hexhashcCs |j|S)za >>> Path('.').isabs() False .. seealso:: :func:`os.path.isabs` )rUisabsr`r)r)r*rIsz Path.isabscCs |j|S)z#.. seealso:: :func:`os.path.exists`)rUexistsr`r)r)r*rRsz Path.existscCstjdtdd|S)Nzisdir is deprecated; use is_dirrprq)rsrtrurr`r)r)r*isdirVs z Path.isdircCs |j|S)z".. seealso:: :func:`os.path.isdir`)rUrr`r)r)r*r^sz Path.is_dircCstjdtdd|S)Nz!isfile is deprecated; use is_filerprq)rsrtrurr`r)r)r*isfilebs z Path.isfilecCs |j|S)z#.. seealso:: :func:`os.path.isfile`)rUrr`r)r)r*rjsz Path.is_filecCs |j|S)z#.. seealso:: :func:`os.path.islink`)rUislinkr`r)r)r*rnsz Path.islinkcCs |j|S)ze >>> Path('.').ismount() False .. seealso:: :func:`os.path.ismount` )rUismountr`r)r)r*rrsz Path.ismountcCs|j||S)z%.. seealso:: :func:`os.path.samefile`)rUsamefilerSr)r)r*r{sz Path.samefilecCs |j|S)z4.. seealso:: :attr:`atime`, :func:`os.path.getatime`)rUgetatimer`r)r)r*rsz Path.getatimecCs"|j}|jt||fddSN)rYstat st_atime_nsutimer+)r3r$Zmtime_nsr)r)r* set_atimes zPath.set_atimea Last access time of the file. >>> Path('.').atime > 0 True Allows setting: >>> some_file = Path(getfixture('tmp_path')).joinpath('file.txt').touch() >>> MST = datetime.timezone(datetime.timedelta(hours=-7)) >>> some_file.atime = datetime.datetime(1976, 5, 7, 10, tzinfo=MST) >>> some_file.atime 200336400.0 .. seealso:: :meth:`getatime`, :func:`os.path.getatime` cCs |j|S)z4.. seealso:: :attr:`mtime`, :func:`os.path.getmtime`)rUgetmtimer`r)r)r*r"sz Path.getmtimecCs"|j}|j|t|fddSrr)r3r$Zatime_nsr)r)r* set_mtimes zPath.set_mtimea Last modified time of the file. Allows setting: >>> some_file = Path(getfixture('tmp_path')).joinpath('file.txt').touch() >>> MST = datetime.timezone(datetime.timedelta(hours=-7)) >>> some_file.mtime = datetime.datetime(1976, 5, 7, 10, tzinfo=MST) >>> some_file.mtime 200336400.0 .. seealso:: :meth:`getmtime`, :func:`os.path.getmtime` cCs |j|S)z4.. seealso:: :attr:`ctime`, :func:`os.path.getctime`)rUgetctimer`r)r)r*r$sz Path.getctimeze Creation time of the file. .. seealso:: :meth:`getctime`, :func:`os.path.getctime` cCs |j|S)z2.. seealso:: :attr:`size`, :func:`os.path.getsize`)rUgetsizer`r)r)r*r%sz Path.getsizezd Size of the file, in bytes. .. seealso:: :meth:`getsize`, :func:`os.path.getsize` zmasks.Permissions)r%cCst|jS)z Permissions. >>> perms = Path('.').permissions >>> isinstance(perms, int) True >>> set(perms.symbolic) <= set('rwx-') True >>> perms.symbolic 'r...' )rZ Permissionsrst_moder`r)r)r* permissionss zPath.permissionscOstj|f||S)z Return does the real user have access to this path. >>> Path('.').access(os.F_OK) True .. seealso:: :func:`os.access` )rkaccessrr)r)r*r(s z Path.accessfollow_symlinkscCstj||dS)z Perform a ``stat()`` system call on this path. >>> Path('.').stat() os.stat_result(...) .. seealso:: :meth:`lstat`, :func:`os.stat` r))rkr)r3r*r)r)r*rs z Path.statcCs t|S)z Like :meth:`stat`, but do not follow symbolic links. >>> Path('.').lstat() == Path('.').stat() True .. seealso:: :meth:`stat`, :func:`os.lstat` )rklstatr`r)r)r*r+s z Path.lstatcCs4t|tj}|}td|\}}}|d|S)z Return the name of the owner of this file or directory. Follow symbolic links. Return a name of the form ``DOMAIN\User Name``; may be a group. .. seealso:: :attr:`owner` N\) win32securityZGetFileSecurityZOWNER_SECURITY_INFORMATIONZGetSecurityDescriptorOwnerZLookupAccountSid)r3descZsidaccountdomaintypecoder)r)r*Z__get_owner_windowss zPath.__get_owner_windowscCs|}t|jjS)z Return the name of the owner of this file or directory. Follow symbolic links. .. seealso:: :attr:`owner` )rpwdgetpwuidst_uidpw_name)r3str)r)r*Z__get_owner_unixszPath.__get_owner_unixcCs tddS)Nz)Ownership not available on this platform.)NotImplementedErrorr`r)r)r*Z__get_owner_not_implementedsz Path.__get_owner_not_implementedr-r2zU Name of the owner of this file or directory. .. seealso:: :meth:`get_owner`grpcCs|j|dj}t|jS)z@ Return the group name of the file gid. r))rst_gidr8getgrgidgr_name)r3r*gidr)r)r*group4sz Path.groupstatvfscCs t|S)zkPerform a ``statvfs()`` system call on this path. .. seealso:: :func:`os.statvfs` )rkr>r`r)r)r*r>=sz Path.statvfspathconfcCs t||S)z .. seealso:: :func:`os.pathconf`)rkr?rr)r)r*r?Fsz Path.pathconfcOstj|f|||S)z_Set the access and modified times of this file. .. seealso:: :func:`os.utime` )rkr rr)r)r*r Msz Path.utimecCs2t|tr"t|}||j}t|||S)at Set the mode. May be the new mode (os.chmod behavior) or a `symbolic mode `_. >>> a_file = Path(getfixture('tmp_path')).joinpath('afile.txt').touch() >>> a_file.chmod(0o700) Path(... >>> a_file.chmod('u+x') Path(... .. seealso:: :func:`os.chmod` )r&rrZcompoundrr&rkchmod)r3rmaskr)r)r*r@Us   z Path.chmodchowncCs*dd}dd}t||||||S)zt Change the owner and group by names or numbers. .. seealso:: :func:`os.chown` cSst|tr|St|jSr1)r&r(r2getpwnampw_uid)uidr)r)r* resolve_uidqszPath.chown..resolve_uidcSst|tr|St|jSr1)r&r(r8getgrnamgr_gid)r<r)r)r* resolve_gidtszPath.chown..resolve_gid)rkrB)r3rFr<rGrJr)r)r*rBjsz Path.chowncCst||||S)z.. seealso:: :func:`os.rename`)rkrenamer\r3r r)r)r*rKzs z Path.renamecCst||||S)z.. seealso:: :func:`os.renames`)rkrenamesr\rLr)r)r*rMs z Path.renamescCst|||S)z.. seealso:: :func:`os.mkdir`)rkmkdirr3rr)r)r*rOs z Path.mkdirc Cs$tt||W5QRX|S)z\Like :meth:`mkdir`, but does not raise an exception if the directory already exists.)rOrPFileExistsErrorrOrPr)r)r*mkdir_ps z Path.mkdir_pcCst|||S)z .. seealso:: :func:`os.makedirs`)rkmakedirsrPr)r)r*rSs z Path.makedirsc Cs$tt||W5QRX|S)z_Like :meth:`makedirs`, but does not raise an exception if the directory already exists.)rOrPrQrSrPr)r)r* makedirs_ps zPath.makedirs_pcCst||S)z.. seealso:: :func:`os.rmdir`)rkrmdirr`r)r)r*rUs z Path.rmdirc Cs@tttf}t|"t|W5QRXW5QRX|S)zlLike :meth:`rmdir`, but does not raise an exception if the directory is not empty or does not exist.)FileNotFoundErrorrQDirectoryNotEmptyrOrP translaterU)r3Z suppressedr)r)r*rmdir_ps    z Path.rmdir_pcCst||S)z".. seealso:: :func:`os.removedirs`)rk removedirsr`r)r)r*rZs zPath.removedirsc Cs8ttt"t|W5QRXW5QRX|S)zqLike :meth:`removedirs`, but does not raise an exception if the directory is not empty or does not exist.)rOrPrQrWrXrZr`r)r)r* removedirs_ps zPath.removedirs_pcCs,tt|tjtjBdt|d|S)zvSet the access/modified times of this file to the current time. Create the file if it does not exist. iN)rkcloserO_WRONLYO_CREATr r`r)r)r*touchs z Path.touchcCst||S)z.. seealso:: :func:`os.remove`)rkremover`r)r)r*r`s z Path.removec Cs"tt|W5QRX|S)zXLike :meth:`remove`, but does not raise an exception if the file does not exist.)rOrPrVunlinkr`r)r)r*remove_ps z Path.remove_p)targetr%cCst||dS)zg Create a hard link at self, pointing to target. .. seealso:: :func:`os.link` N)rklink)r3rcr)r)r* hardlink_toszPath.hardlink_tocCst||||S)zfCreate a hard link at `newpath`, pointing to this file. .. seealso:: :func:`os.link` )rkrdr\)r3newpathr)r)r*rds z Path.link)rctarget_is_directoryr%cCst|||dS)zn Create a symbolic link at self, pointing to target. .. seealso:: :func:`os.symlink` N)rksymlink)r3rcrgr)r)r* symlink_toszPath.symlink_tocCs&|dkr|}t||||S)zCreate a symbolic link at `newlink`, pointing here. If newlink is not supplied, the symbolic link will assume the name self.basename(), creating the link in the cwd. .. seealso:: :func:`os.symlink` N)r~rkrhr\)r3Znewlinkr)r)r*rhs z Path.symlinkcCs|tt|dS)zReturn the path to which this symbolic link points. The result may be an absolute or a relative path. .. seealso:: :meth:`readlinkabs`, :func:`os.readlink` z\\?\)r\rrkreadlinkr`r)r)r*rjsz Path.readlinkcCs"|}|r|S|j|S)zReturn the path to which this symbolic link points. The result is always an absolute path. .. seealso:: :meth:`readlink`, :func:`os.readlink` )rjrrrw)r3rr)r)r* readlinkabsszPath.readlinkabsmovec Cs"tt|W5QRX|S)z]Like :meth:`rmtree`, but does not raise an exception if the directory does not exist.)rOrPrVrmtreer`r)r)r*rmtree_ps z Path.rmtree_pcCst|dS)z.. seealso:: :func:`os.chdir`N)rkrlr`r)r)r*rl"sz Path.chdircCsgSr1r))dircontentsr)r)r*r.rz Path.) copy_functionignorec s||}|t|}||dd|Dfdd}t||D]T}||j}|rx|rx|} | |qJ| r|j ||||dqJ|||qJ| |dS)a Copy entire contents of self to dst, overwriting existing contents in dst with those in self. Pass ``symlinks=True`` to copy symbolic links as links. Accepts a ``copy_function``, similar to copytree. To avoid overwriting newer files, supply a copy function wrapped in ``only_newer``. For example:: src.merge_tree(dst, copy_function=only_newer(shutil.copy2)) cSsg|] }|jqSr)rrr)r)r*rAsz#Path.merge_tree..cs |jkSr1rs)r;Z_ignoredr)r*ignoredCsz Path.merge_tree..ignored)symlinksrqrrN) r\rTrr itertools filterfalserrrjrhr merge_treecopystat) r3dstrvrqrrsourcesrusourcerrcr)rtr*ry(s&       zPath.merge_treechrootcCst|dS)z.. seealso:: :func:`os.chroot`N)rkr~r`r)r)r*r~\sz Path.chroot startfilecOstj|f|||S)z!.. seealso:: :func:`os.startfile`)rkrrr)r)r*rbszPath.startfilerc cs>t|drtd||p$tjd}|||t||||||d}t| j } tj tj Btj B} | ttddO} t|| | } t| d|dd ||||d} ttt|| W5QRXz^z|| fVWn:tk r|| |||YnX|| W5|Xd S) ab A context in which a file may be re-written in-place with new content. Yields a tuple of :samp:`({readable}, {writable})` file objects, where `writable` replaces `readable`. If an exception occurs, the old file is restored, removing the written data. Mode *must not* use ``'w'``, ``'a'``, or ``'+'``; only read-only-modes are allowed. A :exc:`ValueError` is raised on invalid modes. For example, to add line numbers to a file:: p = Path(filename) assert p.is_file() with p.in_place() as (reader, writer): for number, line in enumerate(reader, 1): writer.write('{0:3}: '.format(number))) writer.write(line) Thereafter, the file at `filename` will have line numbers in it. zwa+z%Only read-only file modes can be usedZbak)rrrrO_BINARYrrrr>N)set intersectionrrkextseprbrKrrfilenor&r^r]O_TRUNCrreplacerOrPOSErrorrQr@rr\) r3rrrrrZbackup_extensionZ backup_fnreadablepermZos_modefdwritabler)r)r*in_placeisL#    z Path.in_placecCs tt|S)a Return a SpecialResolver object suitable referencing a suitable directory for the relevant platform for the given type of content. For example, to get a user config directory, invoke: dir = Path.special().user.config Uses the `appdirs `_ to resolve the paths in a platform-friendly way. To create a config directory for 'My App', consider: dir = Path.special("My App").user.config.makedirs_p() If the ``appdirs`` module is not installed, invocation of special will raise an ImportError. )r7r8SpecialResolverr[r)r)r*specialsz Path.special)rG)rG)rG)N)N)Nr)N).......).....)......)......)......).....)......).......)......)......)F)NN)Nr)....)....)NNT)rCrC)rN)rN)rN)rN)F)N)F)rrCNNNN)r-r.r/r=rkpathrUrIr4 classmethodr7 lru_cacherZr ClassPropertyr\r_rarbrg __truediv__rh __rtruediv__rmrnrirorwrvrxryrzr{r|r}r~rpropertyrrrrrrrrrrrrrZ multimethodrrrrrrrrrrrrrrrrrrrrrrrrrrrrErr staticmethodrrrrrrrrrrrrrrrr!atimer"r#mtimer$ctimer%rr'r(rr+Z_Path__get_owner_windowsZ_Path__get_owner_unixZ _Path__get_owner_not_implementedglobalsZ get_ownerownerr=hasattrr>r?r r@rBrKrMrOrRrSrTrUrYrZr[r_r`rbraZunlink_prerdrirhrjrkshutilcopyfilecopymoderzcopycopy2copytreerlrmrnrlZcdryr~rrOcontextmanagerrr __classcell__r)r)rLr*rsx                  (    (        " " "      J  (                            2  Qc@seZdZeejddZdS)rWc csLz dVWn<tk rF}z|jtjkr4t|j|W5d}~XYnXdSr1)rerrno ENOTEMPTYrWr)rr)r)r*rXs    zDirectoryNotEmpty.translateN)r-r.r/rrOrrXr)r)r)r*rWsrWcstfdd}|S)zg Wrap a copy function (like shutil.copy2) to return the dst if it's newer than the source. cs2|o||k}|r |S||f||Sr1)rr")srcr{rrZ is_newer_dst copy_funcr)r*wrapperszonly_newer..wrapper)r7wraps)rrr)rr* only_newersrc@seZdZdZddZdS) ExtantPathz >>> ExtantPath('.') ExtantPath('.') >>> ExtantPath('does-not-exist') Traceback (most recent call last): OSError: does-not-exist does not exist. cCs|st|ddS)Nz does not exist.)rrr`r)r)r*rRszExtantPath._validateNr-r.r/r=rRr)r)r)r*rsrc@seZdZdZddZdS) ExtantFilea >>> ExtantFile('.') Traceback (most recent call last): FileNotFoundError: . does not exist as a file. >>> ExtantFile('does-not-exist') Traceback (most recent call last): FileNotFoundError: does-not-exist does not exist as a file. cCs|st|ddS)Nz does not exist as a file.)rrVr`r)r)r*rR szExtantFile._validateNrr)r)r)r*rs rc@s2eZdZGdddZddZddZddZd S) rc@seZdZddZddZdS)zSpecialResolver.ResolverScopecCs||_||_dSr1)pathsscope)r3rrr)r)r*r4sz&SpecialResolver.ResolverScope.__init__cCs|j|j|Sr1)rget_dirr)r3class_r)r)r* __getattr__sz)SpecialResolver.ResolverScope.__getattr__N)r-r.r/r4rr)r)r)r* ResolverScopesrcOs(td}t|j||j||ddS)Nappdirs) path_classr) importlib import_modulevarsr AppDirs)r3rrrrr)r)r*r4s   zSpecialResolver.__init__cCs |||Sr1)r)r3rr)r)r*rszSpecialResolver.__getattr__cCs2|d|d}t|j|}t|j}||S)zs Return the callable function from appdirs, but with the result wrapped in self.path_class rTZ_dir)rrMulti for_classrdetect)r3rrZ prop_namer$Z MultiPathr)r)r*r!s  zSpecialResolver.get_dirN)r-r.r/rr4rrr)r)r)r*rsrc@sBeZdZdZeddZeddZddZej edd Z d S) rzS A mix-in for a Path which may contain multiple Path separated by pathsep. cCsd|j}t|||fiS)NrrV)rJpath_clsrr)r)r*r1s zMulti.for_classcCstj|kr|j}||Sr1)rkpathsepr\)rJinputr)r)r*r6s z Multi.detectcCstt|j|tjSr1)rmapr\rrkrr`r)r)r*__iter__<szMulti.__iter__cCstdd|jDS)z> Multi-subclasses should use the parent class css|]}t|ts|VqdSr1) issubclassr)rBrr)r)r*rDEs z$Multi._next_class..)next__mro__r[r)r)r*r\?szMulti._next_classN) r-r.r/r=rrrrrrr\r)r)r)r*r,s  rcsJeZdZdZejeddZfddZddZ dd Z d d Z Z S) ras A temporary directory via :func:`tempfile.mkdtemp`, and constructed with the same parameters that you can use as a context manager. For example: >>> with TempDir() as d: ... d.is_dir() and isinstance(d, Path) True The directory is deleted automatically. >>> d.is_dir() False .. seealso:: :func:`tempfile.mkdtemp` cCstSr1)rr[r)r)r*r\\szTempDir._next_classcstj||}t||Sr1)tempfilemkdtemprHrI)rJrrr}rLr)r*rIas zTempDir.__new__cOsdSr1r)rr)r)r*r4eszTempDir.__init__cCs ||Sr1)r\r`r)r)r*rmhszTempDir.__enter__cCs |dSr1)rm)r3exc_type exc_value tracebackr)r)r*rnoszTempDir.__exit__) r-r.r/r=rrrr\rIr4rmrnrr)r)rLr*rHs  c@s0eZdZddZddZddZeddZd S) rcCsdSr1r)msgr)r)r*rtszHandlers.strictcCstj|tdddS)Nrprq)rsrtr,rr)r)r*rtwsz Handlers.warncCsdSr1r)rr)r)r*rrzszHandlers.ignorecCs,t|s|ttkrtdt|||S)Nzinvalid errors parameter)callablerrrget)rJparamr)r)r*r}szHandlers._resolveN)r-r.r/rrtrrrrr)r)r)r*rss r)Tr= __future__rbuiltinsrOdatetimerrr7rr rrwrkrerrrrsnumbersrrP ImportErrorr-r2r8iorrrrrtypingr r r r r rrZ _typeshedrrrrrZtyping_extensionsrr>rrrZ compat.py38rr__all__ZLINESEPSZ U_LINESEPScompilerdrrrrZB_NL_ENDr?objectrr+Warningr,r0rFrrrrWrrrrrrrr)r)r)r*s     $   $K +