[c@sdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZddlZyddlZWnek rnXyddlZWnek r5nXyddlZWnek rYnXejdfkZe ZefZeZejZ erddl!Z!e!j"fZe!j#Zej Z ej$Z%ej&Z'e(Z)ej*e_+nej,dZ-dddgZ.d d d gZ/e/d d dgZ0ej1dj2e/Z3ej1dj2e0Z4ej1dj5e3j6Z7ej1dj5e4j6Z8yddl9Z9e9j:dZ;Wne<k rdZ;nXde=fdYZ>dZ?dZ@deAfdYZBdeCfdYZDdeCfdYZEdefdYZFdZGd eCfd!YZHd"fd#YZId$eFfd%YZJeJZKd&ZLd'ZMd(eEjNfd)YZOd*eFfd+YZPd,ZQeQdS(-u path.py - An object representing a path to a file or directory. https://github.com/jaraco/path.py 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" i(tunicode_literalsNiccsMy dVWn=tk rH}t|j}t|dd|_|nXdS(Nufilename(tIOErrortOSErrortargstgetattrtNonetfilename(tio_errtos_err((s#lib/python2.7/site-packages/path.pytio_error_compatQs  uPathuTempDiruCaseInsensitivePatternu u u u…u
u
u|u(?:{0})$upath.pyuunknowntTreeWalkWarningcBseZRS((t__name__t __module__(((s#lib/python2.7/site-packages/path.pyR qscGsd}tj||S(NcsfdS(Ncs||S(N((Rtkwargs(tf1tf2(s#lib/python2.7/site-packages/path.pytws((RR((RRs#lib/python2.7/site-packages/path.pyRws(t functoolstreduce(tfuncst compose_two((s#lib/python2.7/site-packages/path.pytcomposevs csifd}|S(u Save results for the :meth:'path.using_module' classmethod. When Python 3.2 is available, use functools.lru_cache instead. cs/|kr|S|||<|S(N((tclstmodule(tfunct saved_results(s#lib/python2.7/site-packages/path.pytwrappers ((RR((RRs#lib/python2.7/site-packages/path.pyt simple_cache{st ClassPropertycBseZdZRS(cCs|jjd|S(N(tfgett__get__R(tselfRtowner((s#lib/python2.7/site-packages/path.pyRs(R R R(((s#lib/python2.7/site-packages/path.pyRst multimethodcBs eZdZdZdZRS(u| Acts like a classmethod when invoked from the class and like an instancemethod when invoked from the instance. cCs ||_dS(N(R(RR((s#lib/python2.7/site-packages/path.pyt__init__scCs5|dkrtj|j|Stj|j||S(N(RRtpartialR(RtinstanceR ((s#lib/python2.7/site-packages/path.pyRs(R R t__doc__R"R(((s#lib/python2.7/site-packages/path.pyR!s tmatcherscBsoeZedZdefdYZdefdYZdefdYZdefdYZRS( cCs6t|trtj|S|dk r,|StjS(u] If the supplied parameter is a string, assum it's a simple pattern. N(t isinstancet string_typesR&tPatternRtNull(tparam((s#lib/python2.7/site-packages/path.pytloadstBasecBseZRS((R R (((s#lib/python2.7/site-packages/path.pyR-sR*cBseZdZRS(cCstS(N(tTrue(Rtpath((s#lib/python2.7/site-packages/path.pyt__call__s(R R R0(((s#lib/python2.7/site-packages/path.pyR*sR)cBs#eZdZdZdZRS(cCs ||_dS(N(tpattern(RR1((s#lib/python2.7/site-packages/path.pyR"scCs8y |jSWntk rnX||j|_|jS(N(t_patterntAttributeErrorR1(Rtnormcase((s#lib/python2.7/site-packages/path.pyt get_patterns   cCs@t|d|jj}|j|}tj||j|S(Nunormcase(RRR4R5tfnmatcht fnmatchcasetname(RR/R4R1((s#lib/python2.7/site-packages/path.pyR0s(R R R"R5R0(((s#lib/python2.7/site-packages/path.pyR)s  tCaseInsensitivecBseZdZeejZRS(u A Pattern with a ``'normcase'`` property, suitable for passing to :meth:`listdir`, :meth:`dirs`, :meth:`files`, :meth:`walk`, :meth:`walkdirs`, or :meth:`walkfiles` to match case-insensitive. For example, to get all files ending in .py, .Py, .pY, or .PY in the current directory:: from path import Path, matchers Path('.').files(matchers.CaseInsensitive('*.py')) (R R R%t staticmethodtntpathR4(((s#lib/python2.7/site-packages/path.pyR9s ( R R R:R,tobjectR-R*R)R9(((s#lib/python2.7/site-packages/path.pyR&s  tPathcBs_eZdZejZddZeedZ e edZ dZ dZ dZdZeZd ZeZd Zd Zd Zed ZdZdZdZdZdZdZdZdZdZe dZ!e dZ"e dZ#dZ$e dZ%e edddZ'e edddZ(dZ)dZ*d Z+d!Z,d"Z-e d#Z.e/d$Z0d%Z1d&d'Z2d(Z3dd)Z4d*Z5d+Z6dd,d-Z7d.Z8d/Z9dd0Z:d1Z;d2Z<d3Z=d4Z>d5Z?e@d6ZAdd,d7ZBdd,ejCe@d8ZDdd,eEd9ZFdd,ejCe@d:ZGd;ZHd<ZId=ZJd>ZKd?ZLd@ZMdAZNdBZOdCZPdDZQdEZRdFZSe eSdddGZTdHZUe eUdddIZVdJZWe eWdddKZXdLZYe eYdddMZZe[edNrdOZ\ndPZ]dQZ^dRZ_dSZ`dTZadUebkre_ZcndVebkre`ZcneaZce ecdddWZde[edXr5dYZene[edZrPd[Zfnd\Zgd]Zhd^d^d_Zid`ZjdaZkdbdcZldbddZmdbdeZndbdfZodgZpdhZqdiZrdjZsdkZtdlZudmZvdnZwdoZxe[edprdqZyne[edrr=ddsZzne[edtraduZ{dvZ|ne}j~Z~e}jZe}jZe}jZe}jZe}jZe[e}dwre}jZne}jZdxZdyZeZe@e@e}jdzd{Ze[ed|r d}Zne[ed~r$dZnejdd^dddddZe edZRS(u 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. ucCs|dkrtdndS(Nu$Invalid initial value for path: None(Rt TypeError(Rtother((s#lib/python2.7/site-packages/path.pyR"s cCsO|jd|j}tr)t|}n|f}i|d6}t|||S(Nu_umodule(R tPY2tstrttype(RRt subclass_nametbasestns((s#lib/python2.7/site-packages/path.pyt using_modules   cCs|S(uV What class should be used to construct new instances from this class ((R((s#lib/python2.7/site-packages/path.pyt _next_classscCs&dt|jtt|jfS(Nu%s(%s)(RBR tsuperR=t__repr__(R((s#lib/python2.7/site-packages/path.pyRIscCs<y#|jtt|j|SWntk r7tSXdS(N(RGRHR=t__add__R>tNotImplemented(Rtmore((s#lib/python2.7/site-packages/path.pyRJs# cCs)t|tstS|j|j|S(N(R'R(RKRGRJ(RR?((s#lib/python2.7/site-packages/path.pyt__radd__ scCs|j|jj||S(u fp.__div__(rel) == fp / rel == fp.joinpath(rel) Join two path components, adding a separator character if needed. .. seealso:: :func:`os.path.join` (RGRtjoin(Rtrel((s#lib/python2.7/site-packages/path.pyt__div__scCs|j|jj||S(u fp.__rdiv__(rel) == rel / fp Join two path components, adding a separator character if needed. .. seealso:: :func:`os.path.join` (RGRRN(RRO((s#lib/python2.7/site-packages/path.pyt__rdiv__ scCs |j|_tj||S(N(tgetcwdt_old_dirtostchdir(R((s#lib/python2.7/site-packages/path.pyt __enter__-s cGstj|jdS(N(RTRURS(Rt_((s#lib/python2.7/site-packages/path.pyt__exit__2scCs|S(N((R((s#lib/python2.7/site-packages/path.pyt __fspath__5scCs |tS(ui Return the current working directory as a path object. .. seealso:: :func:`os.getcwdu` (tgetcwdu(R((s#lib/python2.7/site-packages/path.pyRR8scCs|j|jj|S(u& .. seealso:: :func:`os.path.abspath` (RGRtabspath(R((s#lib/python2.7/site-packages/path.pyR[CscCs|j|jj|S(u' .. seealso:: :func:`os.path.normcase` (RGRR4(R((s#lib/python2.7/site-packages/path.pyR4GscCs|j|jj|S(u' .. seealso:: :func:`os.path.normpath` (RGRtnormpath(R((s#lib/python2.7/site-packages/path.pyR\KscCs|j|jj|S(u' .. seealso:: :func:`os.path.realpath` (RGRtrealpath(R((s#lib/python2.7/site-packages/path.pyR]OscCs|j|jj|S(u) .. seealso:: :func:`os.path.expanduser` (RGRt expanduser(R((s#lib/python2.7/site-packages/path.pyR^SscCs|j|jj|S(u) .. seealso:: :func:`os.path.expandvars` (RGRt expandvars(R((s#lib/python2.7/site-packages/path.pyR_WscCs|j|jj|S(u6 .. seealso:: :attr:`parent`, :func:`os.path.dirname` (RGRtdirname(R((s#lib/python2.7/site-packages/path.pyR`[scCs|j|jj|S(u5 .. seealso:: :attr:`name`, :func:`os.path.basename` (RGRtbasename(R((s#lib/python2.7/site-packages/path.pyRa_scCs|jjjS(u Clean 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^R\(R((s#lib/python2.7/site-packages/path.pytexpandcscCs|jj|j\}}|S(u The same as :meth:`name`, but with one file extension stripped off. >>> Path('/home/guido/python.tar.gz').stem 'python.tar' (RtsplitextR8(Rtbasetext((s#lib/python2.7/site-packages/path.pytstemlscCstjdt|jS(NuUse .stem instead of .namebase(twarningstwarntDeprecationWarningRf(R((s#lib/python2.7/site-packages/path.pytnamebasevscCs|jj|\}}|S(u, The file extension, for example ``'.py'``. (RRc(RtfRe((s#lib/python2.7/site-packages/path.pyRe{scCs8|jds*tdjtn|j|S(u Return 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' u.uInvalid suffix {suffix!r}(t startswitht ValueErrortformattlocalststripext(Rtsuffix((s#lib/python2.7/site-packages/path.pyt with_suffixscCs%|jj|\}}|j|S(u~ The drive specifier, for example ``'C:'``. This is always empty on systems that don't use drive specifiers. (Rt splitdriveRG(Rtdrivetr((s#lib/python2.7/site-packages/path.pyRtsu 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` u 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+|jj|\}}|j||fS(u p.splitpath() -> Return ``(p.parent, p.name)``. .. seealso:: :attr:`parent`, :attr:`name`, :func:`os.path.split` (RtsplitRG(Rtparenttchild((s#lib/python2.7/site-packages/path.pyt splitpathscCs+|jj|\}}|j||fS(uF p.splitdrive() -> Return ``(p.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` (RRsRG(RRtRO((s#lib/python2.7/site-packages/path.pyRss cCs+|jj|\}}|j||fS(u p.splitext() -> Return ``(p.stripext(), p.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` (RRcRG(RRRe((s#lib/python2.7/site-packages/path.pyRcs cCs|jdS(u p.stripext() -> Remove one file extension from the path. For example, ``Path('/home/guido/python.tar.gz').stripext()`` returns ``Path('/home/guido/python.tar')``. i(Rc(R((s#lib/python2.7/site-packages/path.pyRpscCs+|jj|\}}|j||fS(u' .. seealso:: :func:`os.path.splitunc` (RtsplituncRG(Rtunctrest((s#lib/python2.7/site-packages/path.pyRzscCs%|jj|\}}|j|S(ue The UNC mount point for this path. This is empty for paths on local drives. (RRzRG(RR{Ru((s#lib/python2.7/site-packages/path.pytuncsharescGs:t||s||}n|j|jj||S(u 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` (R'RGRRN(Rtfirsttothers((s#lib/python2.7/site-packages/path.pytjoinpaths cCsg}|}xW|tjkre|tjkre|}|j\}}||krUPn|j|qW|j||j|S(u Return 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.Path.joinpath(*result)`` will yield the original path. (RTtcurdirtpardirRytappendtreverse(RtpartstloctprevRx((s#lib/python2.7/site-packages/path.pytsplitalls !   u.cCs|j|}|j|S(u{ Return this path as a relative path, based from `start`, which defaults to the current working directory. (RGt relpathto(Rtstarttcwd((s#lib/python2.7/site-packages/path.pytrelpathsc Cs|j}|j|j}|jj}|j}|d|jj|dkrc|Sd}xCt||D]2\}}||jj|krPn|d7}qyWtjgt||}|||7}t|dkrtj } n|jj |} |j| S(u Return 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.abspath()``. ii( R[RGR4RRtzipRTRtlenRRN( Rtdesttorigint orig_listt dest_listtit start_segtdest_segtsegmentsR((s#lib/python2.7/site-packages/path.pyRs"    cs;tj|}tt|fdtjDS(u D.listdir() -> List of 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|]}|VqdS(N((t.0Rx(R(s#lib/python2.7/site-packages/path.pys Ms(R&R,tlisttfilterRTtlistdir(Rtmatch((Rs#lib/python2.7/site-packages/path.pyR>s  cOs/g|j||D]}|jr|^qS(u D.dirs() -> List 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:`listdir`. (Rtisdir(RRR tp((s#lib/python2.7/site-packages/path.pytdirsPs cOs/g|j||D]}|jr|^qS(u D.files() -> List of the files in this directory. The elements of the list are Path objects. This does not walk into subdirectories (see :meth:`walkfiles`). Accepts parameters to :meth:`listdir`. (Rtisfile(RRR R((s#lib/python2.7/site-packages/path.pytfiles[s ustrictc cskdd dY}t| rA|t|krAtdnt|j||}tj|}y|j}Wn?tk rtj d}d}|t }||dSXx|D]}||r|Vny|j } WnDtk r1tj d}d}|t }||t } nX| rx(|j d|d |D] } | VqQWqqWdS( u D.walk() -> iterator over files and subdirs, recursively. The iterator yields Path objects naming each child item of this directory and its descendants. This requires that ``D.isdir()``. 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. tHandlerscBs#eZdZdZdZRS(cSsdS(N((tmsg((s#lib/python2.7/site-packages/path.pytstrictwscSstj|tdS(N(RgRhR (R((s#lib/python2.7/site-packages/path.pyRhzscSsdS(N((R((s#lib/python2.7/site-packages/path.pytignore}s(R R RRhR(((s#lib/python2.7/site-packages/path.pyRvs  uinvalid errors parameteriu,Unable to list directory '%(self)s': %(exc)sNu%Unable to access '%(child)s': %(exc)sterrorsR((tcallabletvarsRmtgetR&R,Rt Exceptiontsystexc_infoRoRtFalsetwalk( RRRRt childListtexcttmplRRxRtitem((s#lib/python2.7/site-packages/path.pyRfs6          cOsd|j||DS(u= D.walkdirs() -> iterator over subdirs, recursively. css!|]}|jr|VqdS(N(R(RR((s#lib/python2.7/site-packages/path.pys s(R(RRR ((s#lib/python2.7/site-packages/path.pytwalkdirsscOsd|j||DS(uA D.walkfiles() -> iterator over files in D, recursively. css!|]}|jr|VqdS(N(R(RR((s#lib/python2.7/site-packages/path.pys s(R(RRR ((s#lib/python2.7/site-packages/path.pyt walkfilesscCsOt|d|jj}|p!|}||j}||}tj||S(u Return ``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 :meth:`self.module`, which defaults to :meth:`os.path.normcase`. .. seealso:: :func:`fnmatch.fnmatch` unormcase(RRR4R8R6R7(RR1R4tdefault_normcaseR8((s#lib/python2.7/site-packages/path.pyR6s   cCs3|j}gtj||D]}||^qS(u Return 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`. (RGtglob(RR1Rts((s#lib/python2.7/site-packages/path.pyRs cs*|jfdtj||DS(u  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|]}|VqdS(N((RR(R(s#lib/python2.7/site-packages/path.pys s(RGRtiglob(RR1((Rs#lib/python2.7/site-packages/path.pyRs cOs'ttj|||SWdQXdS(u Open this file and return a corresponding :class:`file` object. Keyword arguments work as in :func:`io.open`. If the file cannot be opened, an :class:`~exceptions.OSError` is raised. N(R tiotopen(RRR ((s#lib/python2.7/site-packages/path.pyRs cCs&|jd}|jSWdQXdS(u: Open this file, read all bytes, return them as a string. urbN(Rtread(RRk((s#lib/python2.7/site-packages/path.pytbytessc/sJ|j||2x(tfddD] }|Vq1WWdQXdS(u Returns 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("path.py").chunks(8192, mode='rb'): ... hash.update(chunk) This will read the file by chunks of 8192 bytes. csjpdS(N(RR((Rktsize(s#lib/python2.7/site-packages/path.pyRsN(RtiterR(RRRR tchunk((RkRs#lib/python2.7/site-packages/path.pytchunkss"cCs>|rd}nd}|j|}|j|WdQXdS(u Open 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. uabuwbN(Rtwrite(RRRtmodeRk((s#lib/python2.7/site-packages/path.pyt write_bytes s  cCsA|jddd|d|}tjd|jSWdQXdS(u Open this file, read it in, return the content as a string. All newline sequences are converted to ``'\n'``. Keyword arguments will be passed to :meth:`open`. .. seealso:: :meth:`lines` RurtencodingRu N(Rt U_NEWLINEtsubR(RRRRk((s#lib/python2.7/site-packages/path.pyttexts!cCst|trQ|dk r0tj||}n|j|pEtj|}n$|dksctt j||}|j |d|dS(u. Write 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/unicode - The text to be written. `encoding` - str - The Unicode encoding that will be used. This is ignored if `text` isn't a Unicode string. `errors` - str - How to handle Unicode encoding errors. Default is ``'strict'``. See ``help(unicode.encode)`` for the options. This is 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`. You can also specify ``None`` to leave all newlines as they are in `text`. `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'``). If you don't like your platform's default, you can override it using the `linesep=` keyword argument. If you specifically want ``write_text()`` to preserve the newlines as-is, use ``linesep=None``. This applies to Unicode text the same as to 8-bit text, except there are three additional standard Unicode end-of-line sequences: ``u'\x85'``, ``u'\r\x85'``, and ``u'
'``. (This is slightly different from when you open a file for writing with ``fopen(filename, "w")`` in C or ``open(filename, 'w')`` in Python.) --- 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. RN( R't text_typeRRRtencodeRtgetdefaultencodingtAssertionErrortNEWLINER(RRRRtlinesepR((s#lib/python2.7/site-packages/path.pyt write_text"sA !cCs|j||j|S(u+ Open 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 the content of the file is read as 8-bit characters and returned as a list of (non-Unicode) str objects. `errors` - How to handle Unicode errors; see help(str.decode) for the options. Default is ``'strict'``. `retain` - If ``True``, retain newline characters; but all newline character combinations (``'\r'``, ``'\n'``, ``'\r\n'``) are translated to ``'\n'``. If ``False``, newline characters are stripped off. Default is ``True``. .. seealso:: :meth:`text` (Rt splitlines(RRRtretain((s#lib/python2.7/site-packages/path.pytlineslsc Cs|j|rdnd}x|D]}t|t}|dk rq|rRtnt} | jd||}n|r|j|ptj |}n|j |q%WWdQXdS(u Write 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 - 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'
'``), 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 :meth:`file.writelines`. Use the keyword argument ``append=True`` to append lines to the file. The default is to overwrite the file. .. warning :: When you use this with Unicode data, if the encoding of the existing data in the file is different from the encoding you specify with the `encoding=` parameter, the result is mixed-encoding data, which can really confuse someone trying to read the file later. uabuwbuN( RR'RRtU_NL_ENDtNL_ENDRRRRR( RRRRRRRktlinet isUnicodeR1((s#lib/python2.7/site-packages/path.pyt write_liness&  cCs |jdS(u Calculate the md5 hash for this file. This reads through the entire file. .. seealso:: :meth:`read_hash` umd5(t read_hash(R((s#lib/python2.7/site-packages/path.pytread_md5scCs@tj|}x*|jdddD]}|j|q%W|S(u Returns 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 Rurb(thashlibtnewRtupdate(Rt hash_nametmR((s#lib/python2.7/site-packages/path.pyt_hashscCs|j|jS(u Calculate 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` (Rtdigest(RR((s#lib/python2.7/site-packages/path.pyRscCs|j|jS(u Calculate 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` (Rt hexdigest(RR((s#lib/python2.7/site-packages/path.pyt read_hexhashscCs|jj|S(u$ .. seealso:: :func:`os.path.isabs` (Rtisabs(R((s#lib/python2.7/site-packages/path.pyRscCs|jj|S(u% .. seealso:: :func:`os.path.exists` (Rtexists(R((s#lib/python2.7/site-packages/path.pyRscCs|jj|S(u$ .. seealso:: :func:`os.path.isdir` (RR(R((s#lib/python2.7/site-packages/path.pyRscCs|jj|S(u% .. seealso:: :func:`os.path.isfile` (RR(R((s#lib/python2.7/site-packages/path.pyRscCs|jj|S(u% .. seealso:: :func:`os.path.islink` (Rtislink(R((s#lib/python2.7/site-packages/path.pyRscCs|jj|S(u& .. seealso:: :func:`os.path.ismount` (Rtismount(R((s#lib/python2.7/site-packages/path.pyRscCs_t|jdsLt|jjj}|jjj|kS|jj||S(u' .. seealso:: :func:`os.path.samefile` usamefile(thasattrRR=R]R\R4tsamefile(RR?((s#lib/python2.7/site-packages/path.pyRscCs|jj|S(u6 .. seealso:: :attr:`atime`, :func:`os.path.getatime` (Rtgetatime(R((s#lib/python2.7/site-packages/path.pyRsuh Last access time of the file. .. seealso:: :meth:`getatime`, :func:`os.path.getatime` cCs|jj|S(u6 .. seealso:: :attr:`mtime`, :func:`os.path.getmtime` (Rtgetmtime(R((s#lib/python2.7/site-packages/path.pyRsuj Last-modified time of the file. .. seealso:: :meth:`getmtime`, :func:`os.path.getmtime` cCs|jj|S(u6 .. seealso:: :attr:`ctime`, :func:`os.path.getctime` (Rtgetctime(R((s#lib/python2.7/site-packages/path.pyRsue Creation time of the file. .. seealso:: :meth:`getctime`, :func:`os.path.getctime` cCs|jj|S(u4 .. seealso:: :attr:`size`, :func:`os.path.getsize` (Rtgetsize(R((s#lib/python2.7/site-packages/path.pyRsud Size of the file, in bytes. .. seealso:: :meth:`getsize`, :func:`os.path.getsize` uaccesscCstj||S(u Return ``True`` if current user has access to this path. mode - One of the constants :data:`os.F_OK`, :data:`os.R_OK`, :data:`os.W_OK`, :data:`os.X_OK` .. seealso:: :func:`os.access` (RTtaccess(RR((s#lib/python2.7/site-packages/path.pyR)scCs tj|S(um Perform a ``stat()`` system call on this path. .. seealso:: :meth:`lstat`, :func:`os.stat` (RTtstat(R((s#lib/python2.7/site-packages/path.pyR3scCs tj|S(us Like :meth:`stat`, but do not follow symbolic links. .. seealso:: :meth:`stat`, :func:`os.lstat` (RTtlstat(R((s#lib/python2.7/site-packages/path.pyR:scCsHtj|tj}|j}tjd|\}}}|d|S(u Return the name of the owner of this file or directory. Follow symbolic links. Return a name of the form ``r'DOMAIN\User Name'``; may be a group. .. seealso:: :attr:`owner` u\N(t win32securitytGetFileSecuritytOWNER_SECURITY_INFORMATIONtGetSecurityDescriptorOwnertLookupAccountSidR(Rtdesctsidtaccounttdomainttypecode((s#lib/python2.7/site-packages/path.pyt__get_owner_windowsAs  cCs|j}tj|jjS(u Return the name of the owner of this file or directory. Follow symbolic links. .. seealso:: :attr:`owner` (Rtpwdtgetpwuidtst_uidtpw_name(Rtst((s#lib/python2.7/site-packages/path.pyt__get_owner_unixPs cCstddS(Nu)Ownership not available on this platform.(tNotImplementedError(R((s#lib/python2.7/site-packages/path.pyt__get_owner_not_implementedZsu win32securityupwduU Name of the owner of this file or directory. .. seealso:: :meth:`get_owner`ustatvfscCs tj|S(ul Perform a ``statvfs()`` system call on this path. .. seealso:: :func:`os.statvfs` (RTtstatvfs(R((s#lib/python2.7/site-packages/path.pyRksupathconfcCstj||S(u" .. seealso:: :func:`os.pathconf` (RTtpathconf(RR8((s#lib/python2.7/site-packages/path.pyRsscCstj|||S(u` Set the access and modified times of this file. .. seealso:: :func:`os.utime` (RTtutime(Rttimes((s#lib/python2.7/site-packages/path.pyRzscCsGt|tr3t|}||jj}ntj|||S(u Set the mode. May be the new mode (os.chmod behavior) or a `symbolic mode `_. .. seealso:: :func:`os.chmod` (R'R(t_multi_permission_maskRtst_modeRTtchmod(RRtmask((s#lib/python2.7/site-packages/path.pyRs  icCsttdrdtkrBt|trBtj|j}ndtkrut|trutj |j }ntj |||nd}t ||S(u Change the owner and group by names rather than the uid or gid numbers. .. seealso:: :func:`os.chown` uchownupwdugrpu)Ownership not available on this platform.( RRTtglobalsR'R(Rtgetpwnamtpw_uidtgrptgetgrnamtgr_gidtchownR(RtuidtgidR((s#lib/python2.7/site-packages/path.pyRs cCstj|||j|S(u .. seealso:: :func:`os.rename` (RTtrenameRG(RR((s#lib/python2.7/site-packages/path.pyRscCstj|||j|S(u! .. seealso:: :func:`os.renames` (RTtrenamesRG(RR((s#lib/python2.7/site-packages/path.pyRsicCstj|||S(u .. seealso:: :func:`os.mkdir` (RTtmkdir(RR((s#lib/python2.7/site-packages/path.pyRscCsVy|j|Wn>tk rQtj\}}}|jtjkrRqRnX|S(u^ Like :meth:`mkdir`, but does not raise an exception if the directory already exists. (RRRRterrnotEEXIST(RRRWte((s#lib/python2.7/site-packages/path.pytmkdir_ps  cCstj|||S(u" .. seealso:: :func:`os.makedirs` (RTtmakedirs(RR((s#lib/python2.7/site-packages/path.pyRscCsVy|j|Wn>tk rQtj\}}}|jtjkrRqRnX|S(ua Like :meth:`makedirs`, but does not raise an exception if the directory already exists. (RRRRRR(RRRWR((s#lib/python2.7/site-packages/path.pyt makedirs_ps  cCstj||S(u .. seealso:: :func:`os.rmdir` (RTtrmdir(R((s#lib/python2.7/site-packages/path.pyRs cCshy|jWnStk rctj\}}}tjtjtjf}|j|krdqdnX|S(un Like :meth:`rmdir`, but does not raise an exception if the directory is not empty or does not exist. (RRRRRt ENOTEMPTYRtENOENT(RRWRt bypass_codes((s#lib/python2.7/site-packages/path.pytrmdir_ps  cCstj||S(u$ .. seealso:: :func:`os.removedirs` (RTt removedirs(R((s#lib/python2.7/site-packages/path.pyR s cCsey|jWnPtk r`tj\}}}|jtjkra|jtjkraqanX|S(us Like :meth:`removedirs`, but does not raise an exception if the directory is not empty or does not exist. (R RRRRRR(RRWR((s#lib/python2.7/site-packages/path.pyt removedirs_ps $ cCs@tj|tjtjBd}tj|tj|d|S(uw Set the access/modified times of this file to the current time. Create the file if it does not exist. iN(RTRtO_WRONLYtO_CREATtcloseRR(Rtfd((s#lib/python2.7/site-packages/path.pyttouchs cCstj||S(u .. seealso:: :func:`os.remove` (RTtremove(R((s#lib/python2.7/site-packages/path.pyR's cCsFy|jWn1tk rA}trB|jtjkrBqBnX|S(uZ Like :meth:`remove`, but does not raise an exception if the file does not exist. (tunlinktFileNotFoundErrorR@RR(RR((s#lib/python2.7/site-packages/path.pytremove_ps  cCstj||S(u .. seealso:: :func:`os.unlink` (RTR((R((s#lib/python2.7/site-packages/path.pyR(s cCs|j|S(uZ Like :meth:`unlink`, but does not raise an exception if the file does not exist. (R*(R((s#lib/python2.7/site-packages/path.pytunlink_p s ulinkcCstj|||j|S(uo Create a hard link at `newpath`, pointing to this file. .. seealso:: :func:`os.link` (RTtlinkRG(Rtnewpath((s#lib/python2.7/site-packages/path.pyR,susymlinkcCs8|dkr|j}ntj|||j|S(u Create 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(RRaRTtsymlinkRG(Rtnewlink((s#lib/python2.7/site-packages/path.pyR.s ureadlinkcCs|jtj|S(u Return the path to which this symbolic link points. The result may be an absolute or a relative path. .. seealso:: :meth:`readlinkabs`, :func:`os.readlink` (RGRTtreadlink(R((s#lib/python2.7/site-packages/path.pyR0-scCs1|j}|jr|S|j|jSdS(u Return the path to which this symbolic link points. The result is always an absolute path. .. seealso:: :meth:`readlink`, :func:`os.readlink` N(R0RRwR[(RR((s#lib/python2.7/site-packages/path.pyt readlinkabs6s  umovecCsSy|jWn>tk rNtj\}}}|jtjkrOqOnX|S(u_ Like :meth:`rmtree`, but does not raise an exception if the directory does not exist. (trmtreeRRRRR(RRWR((s#lib/python2.7/site-packages/path.pytrmtree_pQs  cCstj|dS(u .. seealso:: :func:`os.chdir` N(RTRU(R((s#lib/python2.7/site-packages/path.pyRU\scCsgS(N((tdirtcontents((s#lib/python2.7/site-packages/path.pyRgsc s.|j|}|j|rDtjdtddt|}n|j}||g|D]}|j^q]fd}xtj ||D]} || j} |r| j r| j } | j | q| j r | j| d|d|d|d|q|| | qW|j|d S( u 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)) u@Update is deprecated; use copy_function=only_newer(shutil.copy2)t stacklevelics |jkS(N(R8(R(t_ignored(s#lib/python2.7/site-packages/path.pytignoredstsymlinksRt copy_functionRN(RGRRgRhRit only_newerRR8t itertoolst filterfalseRR0R.Rt merge_treetcopystat( RtdstR9RR:RtsourcesRR8tsourceRttarget((R7s#lib/python2.7/site-packages/path.pyR>bs2  %    uchrootcCstj|dS(u .. seealso:: :func:`os.chroot` N(RTtchroot(R((s#lib/python2.7/site-packages/path.pyRDsu startfilecCstj||S(u# .. seealso:: :func:`os.startfile` (RTt startfile(R((s#lib/python2.7/site-packages/path.pyREs urc csddl}t|jdr0tdn||pCtjd}ytj|Wntjk rnnXtj|||j ||d|d|d|d |} ytj | j j } WnHt k rt |d |jd d d|d|d|d |} nXtjtjBtjB} ttd rF| tjO} ntj || | } |j | d |jd d d|d|d|d |} y&ttdrtj|| nWnt k rnXzy| | fVWn`tk rC| j| jytj|Wntjk r,nXtj||nX| j| jWdytj|Wntjk rnXXdS(ua 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.isfile() 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. iNuwa+u%Only read-only file modes can be usedubakt bufferingRRtnewlineuwuruuO_BINARYuchmod(Rtsett intersectionRmRTtextsepR(terrorRRtfstattfilenoRRtreplaceR#R"tO_TRUNCRtO_BINARYRRR$(RRRFRRRGtbackup_extensionRt backup_fntreadabletpermtwritabletos_modeR%((s#lib/python2.7/site-packages/path.pytin_placesd         cCstjt|S(u 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. (RR#tSpecialResolver(R((s#lib/python2.7/site-packages/path.pytspecialsN(R R R%RTR/RR"t classmethodRRFRRGRIRJRMRPt __truediv__RQt __rtruediv__RVRXRYRRR[R4R\R]R^R_R`RaRbtpropertyRfRjReRrRtRRwR8RyRsRcRpRzR}R!RRRRRRRRRRR6RRRRRRRRRRR.RRRRRRRRRRRRRRtatimeRtmtimeRtctimeRRRRRRt_Path__get_owner_windowst_Path__get_owner_unixt _Path__get_owner_not_implementedR t get_ownerR RRRRRRRRRRRRRR R!R&R'R*R(R+R,R.R0R1tshutiltcopyfiletcopymodeR?tcopytcopy2tcopytreetmoveR2R3RUtcdR>RDREt contextlibtcontextmanagerRWRY(((s#lib/python2.7/site-packages/path.pyR=sF                                   (  9       I0                                                     5   Xcs"tjfd}|S(ug Wrap a copy function (like shutil.copy2) to return the dst if it's newer than the source. csA|jo!|j|jk}|r.|S||||S(N(RR(tsrcR@RR t is_newer_dst(t copy_func(s#lib/python2.7/site-packages/path.pyR#s  (Rtwraps(RqR((Rqs#lib/python2.7/site-packages/path.pyR;s RXcBs6eZdddYZdZdZdZRS(t ResolverScopecBseZdZdZRS(cCs||_||_dS(N(tpathstscope(RRtRu((s#lib/python2.7/site-packages/path.pyR"1s cCs|jj|j|S(N(Rttget_dirRu(Rtclass_((s#lib/python2.7/site-packages/path.pyt __getattr__5s(R R R"Rx(((s#lib/python2.7/site-packages/path.pyRs0s cOsRtjd}| o%|jddt|jd|d|j||dS(Nuappdirsuappnamet path_classR(t importlibt import_modulet setdefaultRRRtAppDirs(RRyRR tappdirs((s#lib/python2.7/site-packages/path.pyR"8s cCs|j||S(N(Rs(RRu((s#lib/python2.7/site-packages/path.pyRxDscCsCdjt}t|j|}tj|j}|j|S(us Return the callable function from appdirs, but with the result wrapped in self.path_class u{scope}_{class_}_dir(RnRoRRtMultit for_classRytdetect(RRuRwt prop_nametvaluet MultiPath((s#lib/python2.7/site-packages/path.pyRvGs((R R RsR"RxRv(((s#lib/python2.7/site-packages/path.pyRX/s RcBsJeZdZedZedZdZeedZRS(uS A mix-in for a Path which may contain multiple Path separated by pathsep. cCs8d|j}tr"t|}nt|||fiS(NuMulti(R R@RARB(Rtpath_clsR8((s#lib/python2.7/site-packages/path.pyRVs cCs%tj|kr|j}n||S(N(RTtpathsepRG(Rtinput((s#lib/python2.7/site-packages/path.pyR]s cCs"tt|j|jtjS(N(RtmapRGRvRTR(R((s#lib/python2.7/site-packages/path.pyt__iter__cscCstd|jDS(u> Multi-subclasses should use the parent class css$|]}t|ts|VqdS(N(t issubclassR(RRw((s#lib/python2.7/site-packages/path.pys ms(tnextt__mro__(R((s#lib/python2.7/site-packages/path.pyRGfs( R R R%RZRRRRRG(((s#lib/python2.7/site-packages/path.pyRRs  tTempDircBsGeZdZeedZdZdZdZdZ RS(uT A temporary directory via :func:`tempfile.mkdtemp`, and constructed with the same parameters that you can use as a context manager. Example:: with TempDir() as d: # do stuff with the Path object "d" # here the directory is deleted automatically .. seealso:: :func:`tempfile.mkdtemp` cCstS(N(R=(R((s#lib/python2.7/site-packages/path.pyRGscOs+tj||}tt|j||S(N(ttempfiletmkdtempRHRt__new__(RRR R`((s#lib/python2.7/site-packages/path.pyRscOsdS(N((RRR ((s#lib/python2.7/site-packages/path.pyR"scCs |j|S(N(RG(R((s#lib/python2.7/site-packages/path.pyRVscCs|s|jndS(N(R2(Rtexc_typet exc_valuet traceback((s#lib/python2.7/site-packages/path.pyRXs( R R R%RRZRGRR"RVRX(((s#lib/python2.7/site-packages/path.pyRss   cCs+d}tj|tt|jdS(u Support multiple, comma-separated Unix chmod symbolic modes. >>> _multi_permission_mask('a=r,u+w')(0) == 0o644 True csfdS(Ncs||S(N((RR (Rktg(s#lib/python2.7/site-packages/path.pyRs((RkR((RkRs#lib/python2.7/site-packages/path.pyRsu,(RRRt_permission_maskRv(RR((s#lib/python2.7/site-packages/path.pyRs cstjd|}|s*td|ntddddddfd |jd D}tjtj|d td d dddd |jdj dd}fd|D}tjtj|}|jd}|dkr|dN}n|dkrFfd|D}tjtj|dAnitjd6tj d6fdd6}tj |||S(u3 Convert a Unix chmod symbolic mode like ``'ugo+rwx'`` to a function suitable for applying to a mask to affect that change. >>> mask = _permission_mask('ugo+rwx') >>> mask(0o554) == 0o777 True >>> _permission_mask('go-x')(0o777) == 0o766 True >>> _permission_mask('o-x')(0o445) == 0o444 True >>> _permission_mask('a+x')(0) == 0o111 True >>> _permission_mask('a=rw')(0o057) == 0o666 True >>> _permission_mask('u=x')(0o666) == 0o166 True >>> _permission_mask('g=')(0o157) == 0o107 True u.(?P[ugoa]+)(?P[-+=])(?P[rwx]*)$uUnrecognized symbolic modeRuitwitxic3s|]}|VqdS(N((RRT(tspec_map(s#lib/python2.7/site-packages/path.pys suwhatituiRitouwhouauugoc3s|]}|>VqdS(N((Rtsubj(t shift_maptspec(s#lib/python2.7/site-packages/path.pys suopu-iu=c3s|]}d|>VqdS(iN((RR(R(s#lib/python2.7/site-packages/path.pys su+cs |@|AS(N((RRC(R(s#lib/python2.7/site-packages/path.pyRs( treRRmtdicttgroupRRtoperatortor_RNtand_R#(RtparsedtspecstwhotmasksRtoptop_map((RRRRs#lib/python2.7/site-packages/path.pyRs*     tCaseInsensitivePatterncBseZdZRS(cCs0tjdtddtt|j|dS(Nu$Use matchers.CaseInsensitive insteadR6i(RgRhRiRHRR"(RR((s#lib/python2.7/site-packages/path.pyR"s (R R R"(((s#lib/python2.7/site-packages/path.pyRstFastPathcBseZdZRS(cOs3tjdtddtt|j||dS(Nu3Use Path, as FastPath no longer holds any advantageR6i(RgRhRiRHRR"(RRR ((s#lib/python2.7/site-packages/path.pyR"s (R R R"(((s#lib/python2.7/site-packages/path.pyRscsxt stjdkrdSyddlWntk rAdSXddfdY}tjd|tdS(u As reported in #130, when Linux users create filenames not in the file system encoding, it creates problems on Python 2. This function attempts to patch the os module to make it behave more like that on Python 3. uLinuxNitOScs/eZdZdZdZfdZRS(u, The proxy to the os module cSs ||_dS(N(t_orig(Rtwrapped((s#lib/python2.7/site-packages/path.pyR"scSst|j|S(N(RR(RR8((s#lib/python2.7/site-packages/path.pyRxscs.|jj||}ttjj|S(N(RRRRRTtfsdecode(RRR titems(t backports(s#lib/python2.7/site-packages/path.pyRs(R R R%R"RxR((R(s#lib/python2.7/site-packages/path.pyR s  RT((R@tplatformtsystemt backports.ost ImportErrorR RRT(R((Rs#lib/python2.7/site-packages/path.pytpatch_for_linux_python2s (RR%t __future__RRRgRTR6RReRRRRRRRmRRzR<RR;RRRR t version_infotPY3R@RAR(RRRRZt __builtin__t basestringtunicodetimapRtifilterRRR)t ifilterfalseR=RnR t__all__tLINESEPSt U_LINESEPStcompileRNRRRnR1RRtimportlib_metadatatversiont __version__RtWarningR RRR]RR<R!R&R=R;RXRRttempdirRRR9RRR(((s#lib/python2.7/site-packages/path.pyts                                  6O #!) >