NXc@sdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlmZddlZyddlZWnek r nXyddlZWnek r-nXyddlZWnek rQnXejdfkZe ZefZeZejZ dZ!erddl"Z"e"j#fZe"j$Zej Z e j%de!nej&dZ'd d gZ(d d d gZ)e)dddgZ*ej+dj,e)Z-ej+dj,e*Z.ej+dj/e-j0Z1ej+dj/e.j0Z2y&ddl3Z3e3j4ddj5Z6Wn0ek rdZ6ne3j7k rdZ6nXde8fdYZ9dZ:dZ;de<fdYZ=de>fdYZ?defdYZ@d e>fd!YZAd"fd#YZBd$e@fd%YZCd&ZDd'ZEd(efd)YZFd*e@fd+YZGe(d,g7Z(dS(-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') for f in d.files('*.py'): f.chmod(0o755) i(tunicode_literalsN(tdir_utilicCsZ|j|j|j!}t|dks.tt|}|d7}tj||jfS(uS Simulate the Python 3 ``surrogateescape`` handler, but for Python 2 only. ii(tobjecttstarttendtlentAssertionErrortordt __builtin__tunichr(terrortcharstval((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytsurrogate_escapePs   usurrogateescapeccsMy dVWn=tk rH}t|j}t|dd|_|nXdS(Nufilename(tIOErrortOSErrortargstgetattrtNonetfilename(tio_errtos_err((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytio_error_compatas  uPathuCaseInsensitivePatternu u u u…u
u
u|u(?:{0})$upath.pyiuunknowntTreeWalkWarningcBseZRS((t__name__t __module__(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRscGsd}tj||S(NcsfdS(Ncs||S(N((Rtkwargs(tf1tf2(s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyts((RR((RRs</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs(t functoolstreduce(tfuncst compose_two((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytcomposes 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(t saved_resultstfunc(s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytwrappers ((R&R'((R%R&s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt simple_cachest ClassPropertycBseZdZRS(cCs|jjd|S(N(tfgett__get__R(tselfR#towner((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR+s(RRR+(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR)st 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&(R,R&((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt__init__scCs5|dkrtj|j|Stj|j||S(N(RRtpartialR&(R,tinstanceR-((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR+s(RRt__doc__R/R+(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR.s tPathcBsDeZdZejZddZeedZ e edZ edZ dZ dZdZd ZeZd ZeZd Zd Zed ZdZdZdZdZdZdZdZdZdZe dZ!e dZ"e dZ#e edddZ%e edddZ&dZ'dZ(dZ)dZ*d Z+e d!Z,e-d"Z.d#Z/d$d%Z0d&Z1dd'Z2dd(Z3dd)Z4dd*d+Z5dd*d,Z6dd*d-Z7dd.Z8d/Z9d0Z:d1Z;d2Z<e=d3Z>dd*d4Z?dd*ej@e=d5ZAdd*eBd6ZCdd*ej@e=d7ZDd8ZEd9ZFd:ZGd;ZHd<ZId=ZJd>ZKd?ZLd@ZMdAZNdBZOdCZPe ePdddDZQdEZRe eRdddFZSdGZTe eTdddHZUdIZVe eVdddJZWeXedKrdLZYndMZZdNZ[dOZ\dPZ]dQZ^dRe_kre\Z`ndSe_kre]Z`ne^Z`e e`dddTZaeXedUr,dVZbneXedWrGdXZcndYZddZZed[d[d\Zfd]Zgd^Zhd_d`Zid_daZjd_dbZkd_dcZlddZmdeZndfZodgZpdhZqdiZrdjZsdkZtdlZueXedmrdnZvneXedor1dpZwneXedqrUdrZxdsZynezj{Z{ezj|Z|ezj}Z}ezj~Z~ezjZezjZeXezdtrezjZnezjZduZdvZeZe=dwZeXedxrdyZneXedzr d{Znejd|d[ddddd}Ze ed~ZRS(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(R,tother((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR/s cCsO|jd|j}tr)t|}n|f}i|d6}t|||S(Nu_umodule(RtPY2tstrttype(R#R$t subclass_nametbasestns((s</data/av2000/mvv/env_mvv/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</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt _next_classscCs/tst|tr|S|jtjdS(u Ensure the path as retrieved from a Python API, such as :func:`os.listdir`, is a proper Unicode string. usurrogateescape(tPY3t isinstancet text_typetdecodetsystgetfilesystemencoding(R#tpath((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt_always_unicodescCs&dt|jtt|jfS(Nu%s(%s)(R8RtsuperR3t__repr__(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRGscCs<y#|jtt|j|SWntk r7tSXdS(N(R=RFR3t__add__R4tNotImplemented(R,tmore((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRHs# cCs)t|tstS|j|j|S(N(R?t string_typesRIR=RH(R,R5((s</data/av2000/mvv/env_mvv/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` (R=R$tjoin(R,trel((s</data/av2000/mvv/env_mvv/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` (R=R$RM(R,RN((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt__rdiv__scCs |j|_tj||S(N(tgetcwdt_old_dirtostchdir(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt __enter__s cGstj|jdS(N(RSRTRR(R,t_((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt__exit__scCs |tS(ui Return the current working directory as a path object. .. seealso:: :func:`os.getcwdu` (tgetcwdu(R#((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRQscCs|j|jj|S(u& .. seealso:: :func:`os.path.abspath` (R=R$tabspath(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRY%scCs|j|jj|S(u' .. seealso:: :func:`os.path.normcase` (R=R$tnormcase(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRZ)scCs|j|jj|S(u' .. seealso:: :func:`os.path.normpath` (R=R$tnormpath(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR[-scCs|j|jj|S(u' .. seealso:: :func:`os.path.realpath` (R=R$trealpath(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR\1scCs|j|jj|S(u) .. seealso:: :func:`os.path.expanduser` (R=R$t expanduser(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR]5scCs|j|jj|S(u) .. seealso:: :func:`os.path.expandvars` (R=R$t expandvars(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR^9scCs|j|jj|S(u6 .. seealso:: :attr:`parent`, :func:`os.path.dirname` (R=R$tdirname(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR_=scCs|j|jj|S(u5 .. seealso:: :attr:`name`, :func:`os.path.basename` (R=R$tbasename(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR`AscCs|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</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytexpandEscCs|jj|j\}}|S(u The same as :meth:`name`, but with one file extension stripped off. For example, ``Path('/home/guido/python.tar.gz').name == 'python.tar.gz'``, but ``Path('/home/guido/python.tar.gz').namebase == 'python.tar'``. (R$tsplitexttname(R,tbasetext((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytnamebaseNs cCs|jj|\}}|S(u, The file extension, for example ``'.py'``. (R$Rb(R,tfRe((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyReZscCs%|jj|\}}|j|S(u~ The drive specifier, for example ``'C:'``. This is always empty on systems that don't use drive specifiers. (R$t splitdriveR=(R,tdrivetr((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRi`su 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` (R$tsplitR=(R,tparenttchild((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt splitpath~scCs+|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` (R$RhR=(R,RiRN((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRhs 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` (R$RbR=(R,RRe((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRbs 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(Rb(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytstripextscCs+|jj|\}}|j||fS(u' .. seealso:: :func:`os.path.splitunc` (R$tsplituncR=(R,tunctrest((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRpscCs%|jj|\}}|j|S(ue The UNC mount point for this path. This is empty for paths on local drives. (R$RpR=(R,RqRj((s</data/av2000/mvv/env_mvv/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?R=R$RM(R#tfirsttothers((s</data/av2000/mvv/env_mvv/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. (RStcurdirtpardirRntappendtreverse(R,tpartstloctprevRm((s</data/av2000/mvv/env_mvv/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. (R=t relpathto(R,Rtcwd((s</data/av2000/mvv/env_mvv/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( RYR=RZR~R$tzipRSRxRRwRM( R,tdesttorigint orig_listt dest_listtit start_segtdest_segtsegmentsR((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs"    cCs]|dkrd}ngt|jtj|D](}|j|j|r1||^q1S(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 `pattern` argument, this only lists items whose names match the given pattern. .. seealso:: :meth:`files`, :meth:`dirs` u*N(RtmapRERStlistdirR=tfnmatch(R,tpatternRm((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR s  cCs,g|j|D]}|jr|^qS(uv 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`). With the optional `pattern` argument, this only lists directories whose names match the given pattern. For example, ``d.dirs('build-*')``. (Rtisdir(R,Rtp((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytdirss cCs,g|j|D]}|jr|^qS(uU 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`). With the optional `pattern` argument, this only lists files whose names match the given pattern. For example, ``d.files('*.pyc')``. (Rtisfile(R,RR((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytfiles+s ustrictc csedddY}t| rA|t|krAtdnt|j||}y|j}Wn?tk rtjd}d}|t}||dSXx|D]}|dks|j |r|Vny|j } WnDtk r1tjd}d}|t}||t } nX| rx"|j ||D] } | VqKWqqWdS( 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</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytstrictIscSstj|tdS(N(twarningstwarnR(R((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRLscSsdS(N((R((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytignoreOs(RRRRR(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRHs  uinvalid errors parameteriu,Unable to list directory '%(self)s': %(exc)sNu%Unable to access '%(child)s': %(exc)s((tcallabletvarst ValueErrortgetRt ExceptionRBtexc_infotlocalsRRRtFalsetwalk( R,RterrorsRt childListtexcttmplRRmRtitem((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR8s4         ccs|dkrtdny|j}WnXtk r|dkrKdS|dkrtjd|tjdftdSnXxS|D]K}|dks|j |r|Vnx|j ||D] }|VqWqWdS( u< D.walkdirs() -> iterator over subdirs, recursively. With the optional `pattern` argument, this yields only directories whose names match the given pattern. For example, ``mydir.walkdirs('*test')`` yields only directories with names ending in ``'test'``. The `errors=` keyword argument controls behavior when an error occurs. The default is ``'strict'``, which causes an exception. The other allowed values are ``'warn'`` (which reports the error via :func:`warnings.warn()`), and ``'ignore'``. ustrictuwarnuignoreuinvalid errors parameterNu!Unable to list directory '%s': %si(ustrictuwarnuignore( RRRRRRBRRRRtwalkdirs(R,RRRRmt subsubdir((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRos&     ccsj|d krtdny|j}WnXtk r|dkrKdS|dkrtjd|tjdftdSnXx|D]}y#|j}| o|j }WnR|dkrqq |dkrtjd|tjdftqq nX|r7|dks,|j |rb|Vqbq|rx"|j ||D] }|VqPWqqWdS( u D.walkfiles() -> iterator over files in D, recursively. The optional argument `pattern` limits the results to files with names that match the pattern. For example, ``mydir.walkfiles('*.tmp')`` yields only files with the ``.tmp`` extension. ustrictuwarnuignoreuinvalid errors parameterNu!Unable to list directory '%s': %siuUnable to access '%s': %s(ustrictuwarnuignore( RRRRRRBRRRRRRt walkfiles(R,RRRRmRRRg((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRsD         cCsOt|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(RR$RZRcRt fnmatchcase(R,RRZtdefault_normcaseRc((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs   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` (R=tglob(R,RR#ts((s</data/av2000/mvv/env_mvv/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(Rtiotopen(R,RR((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs cCs&|jd}|jSWdQXdS(u: Open this file, read all bytes, return them as a string. urbN(Rtread(R,Rg((s</data/av2000/mvv/env_mvv/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((tsizeRg(s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRsN(RtiterR(R,RRRtchunk((RgRs</data/av2000/mvv/env_mvv/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(R,RRytmodeRg((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt write_bytess  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(R,RRRg((s</data/av2000/mvv/env_mvv/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. RyN( R?R@RRRtencodeRBtgetdefaultencodingRtNEWLINER(R,RRRtlinesepRy((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt write_textsA !cCsT|dkr7|r7|jd}|jSWdQXn|j||j|SdS(uL 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``. This uses ``'U'`` mode. .. seealso:: :meth:`text` uUN(RRt readlinesRt splitlines(R,RRtretainRg((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytlineshsc 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?R@RtU_NL_ENDtNL_ENDRRRBRR( R,RRRRRyRgtlt isUnicodeR((s</data/av2000/mvv/env_mvv/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</data/av2000/mvv/env_mvv/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(R,t hash_nametmR((s</data/av2000/mvv/env_mvv/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(R,R((s</data/av2000/mvv/env_mvv/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(R,R((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt read_hexhashscCs|jj|S(u$ .. seealso:: :func:`os.path.isabs` (R$tisabs(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRscCs|jj|S(u% .. seealso:: :func:`os.path.exists` (R$texists(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRscCs|jj|S(u$ .. seealso:: :func:`os.path.isdir` (R$R(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRscCs|jj|S(u% .. seealso:: :func:`os.path.isfile` (R$R(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRscCs|jj|S(u% .. seealso:: :func:`os.path.islink` (R$tislink(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRscCs|jj|S(u& .. seealso:: :func:`os.path.ismount` (R$tismount(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRscCs_t|jdsLt|jjj}|jjj|kS|jj||S(u' .. seealso:: :func:`os.path.samefile` usamefile(thasattrR$R3R\R[RZtsamefile(R,R5((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRscCs|jj|S(u6 .. seealso:: :attr:`atime`, :func:`os.path.getatime` (R$tgetatime(R,((s</data/av2000/mvv/env_mvv/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` (R$tgetmtime(R,((s</data/av2000/mvv/env_mvv/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` (R$tgetctime(R,((s</data/av2000/mvv/env_mvv/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` (R$tgetsize(R,((s</data/av2000/mvv/env_mvv/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` (RStaccess(R,R((s</data/av2000/mvv/env_mvv/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` (RStstat(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR4scCs tj|S(us Like :meth:`stat`, but do not follow symbolic links. .. seealso:: :meth:`stat`, :func:`os.lstat` (RStlstat(R,((s</data/av2000/mvv/env_mvv/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(R,tdesctsidtaccounttdomainttypecode((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt__get_owner_windowsBs  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(R,tst((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt__get_owner_unixQs cCstddS(Nu)Ownership not available on this platform.(tNotImplementedError(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt__get_owner_not_implemented[su 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` (RStstatvfs(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRlsupathconfcCstj||S(u" .. seealso:: :func:`os.pathconf` (RStpathconf(R,Rc((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRtscCstj|||S(u` Set the access and modified times of this file. .. seealso:: :func:`os.utime` (RStutime(R,ttimes((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR{scCsGt|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?RKt_multi_permission_maskRtst_modeRStchmod(R,Rtmask((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs  icCsttdrdtkrBt|trBtj|j}ndtkrut|trutj |j }ntj |||n t d|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.( RRStglobalsR?RKRtgetpwnamtpw_uidtgrptgetgrnamtgr_gidtchownR(R,tuidtgid((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs cCstj|||j|S(u .. seealso:: :func:`os.rename` (RStrenameR=(R,R((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRscCstj|||j|S(u! .. seealso:: :func:`os.renames` (RStrenamesR=(R,R((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR sicCstj|||S(u .. seealso:: :func:`os.mkdir` (RStmkdir(R,R((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR scCsVy|j|Wn>tk rQtj\}}}|jtjkrRqRnX|S(u^ Like :meth:`mkdir`, but does not raise an exception if the directory already exists. (R RRBRterrnotEEXIST(R,RRVte((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytmkdir_ps  cCstj|||S(u" .. seealso:: :func:`os.makedirs` (RStmakedirs(R,R((s</data/av2000/mvv/env_mvv/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. (RRRBRR R (R,RRVR ((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt makedirs_ps  cCstj||S(u .. seealso:: :func:`os.rmdir` (RStrmdir(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs cCsey|jWnPtk r`tj\}}}|jtjkra|jtjkraqanX|S(un Like :meth:`rmdir`, but does not raise an exception if the directory is not empty or does not exist. (RRRBRR t ENOTEMPTYR (R,RVR ((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytrmdir_ps $ cCstj||S(u$ .. seealso:: :func:`os.removedirs` (RSt removedirs(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs 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. (RRRBRR RR (R,RVR ((s</data/av2000/mvv/env_mvv/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(RSRtO_WRONLYtO_CREATtcloseRR(R,tfd((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyttouchs cCstj||S(u .. seealso:: :func:`os.remove` (RStremove(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs cCsSy|jWn>tk rNtj\}}}|jtjkrOqOnX|S(uZ Like :meth:`remove`, but does not raise an exception if the file does not exist. (tunlinkRRBRR tENOENT(R,RVR ((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytremove_ps  cCstj||S(u .. seealso:: :func:`os.unlink` (RSR(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs cCs|j|S(uZ Like :meth:`unlink`, but does not raise an exception if the file does not exist. (R(R,((s</data/av2000/mvv/env_mvv/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` (RStlinkR=(R,tnewpath((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR susymlinkcCstj|||j|S(un Create a symbolic link at `newlink`, pointing here. .. seealso:: :func:`os.symlink` (RStsymlinkR=(R,tnewlink((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR"sureadlinkcCs|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` (R=RStreadlink(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR$(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(R$RRlRY(R,R((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt readlinkabs1s  umovecCsSy|jWn>tk rNtj\}}}|jtjkrOqOnX|S(u_ Like :meth:`rmtree`, but does not raise an exception if the directory does not exist. (trmtreeRRBRR R(R,RVR ((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytrmtree_pLs  cCstj|dS(u .. seealso:: :func:`os.chdir` N(RSRT(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRTWsc Osp|jdt}tO}|tt|}|j||||tj||d|d|WdQXdS(u, Copy entire contents of self to dst, overwriting existing contents in dst with those in self. If the additional keyword `update` is True, each `src` will only be copied if `dst` does not exist, or `src` is newer than `dst`. Note that the technique employed stages the files in a temporary directory first, so this function is not suitable for merging trees with large files, especially if the temporary directory is not capable of storing a copy of the entire source tree. uupdatetpreserve_symlinksRN(tpopRttempdirR7thashtcopytreeRt copy_tree(R,tdsttsymlinksRRRt _temp_dirtstage((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt merge_tree]s  uchrootcCstj|dS(u .. seealso:: :func:`os.chroot` N(RStchroot(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR3zsu startfilecCstj||S(u# .. seealso:: :func:`os.startfile` (RSt startfile(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR4s 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(uQ 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 intersectionRRStextsepRR RRtfstattfilenoRRtreplaceRRtO_TRUNCRtO_BINARYRRR(R,RR5RRR6tbackup_extensionRt backup_fntreadabletpermtwritabletos_modeR((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytin_places^         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. (RR0tSpecialResolver(R#((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pytspecialsN(RRR2RSRDR$R/t classmethodR(R<R)R=RERGRHRLROt __truediv__RPt __rtruediv__RURWRQRYRZR[R\R]R^R_R`RatpropertyRfReRiRRlRcRnRhRbRoRpRsR.RvR~RRRRRRRRRRRRRRRRRRtTrueRRRRRRRRRRRRRRtatimeRtmtimeRtctimeRRRRRRt_Path__get_owner_windowst_Path__get_owner_unixt _Path__get_owner_not_implementedRt get_ownerR-RRRRRRR R RRRRRRRRRRRRR R"R$R%tshutiltcopyfiletcopymodetcopystattcopytcopy2R,tmoveR&R'RTtcdR2R3R4t contextlibtcontextmanagerRERG(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR3s:                                 (  7$0      I/                                                         ORFcBs6eZdddYZdZdZdZRS(t ResolverScopecBseZdZdZRS(cCs||_||_dS(N(tpathstscope(R,R_R`((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR/s cCs|jj|j|S(N(R_tget_dirR`(R,tclass_((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt __getattr__s(RRR/Rc(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR^s cOsRtjd}| o%|jddt|jd|d|j||dS(Nuappdirsuappnamet path_classR'(t importlibt import_modulet setdefaultRRRtAppDirs(R,RdRRtappdirs((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR/s cCs|j||S(N(R^(R,R`((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRcscCsCdjt}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(tformatRRR'tMultit for_classRdtdetect(R,R`Rbt prop_nametvaluet MultiPath((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRa s((RRR^R/RcRa(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRFs RkcBsJeZdZedZedZdZeedZRS(uS A mix-in for a Path which may contain multiple Path separated by pathsep. cCs8d|j}tr"t|}nt|||fiS(NuMulti(RR6R7R8(R#tpath_clsRc((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRls cCs%tj|kr|j}n||S(N(RStpathsepR=(R#tinput((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRms cCs"tt|j|jtjS(N(RRR=RkRSRr(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt__iter__%scCstd|jDS(u> Multi-subclasses should use the parent class css$|]}t|ts|VqdS(N(t issubclassRk(t.0Rb((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pys /s(tnextt__mro__(R#((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR=(s( RRR2RHRlRmRtR)R=(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRks  R*cBsGeZdZeedZdZdZdZdZ RS(uO 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(R3(R#((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR=DscOs+tj||}tt|j||S(N(ttempfiletmkdtempRFR*t__new__(R#RRR_((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR{IscOsdS(N((R,RR((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR/MscCs|S(N((R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRUPscCs|s|jndS(N(R&(R,texc_typet exc_valuet traceback((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRWSs( RRR2R)RHR=R{R/RURW(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR*5s    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(Rgtg(s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR_s((RgR((RRgs</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR_su,(RRRt_permission_maskRk(RR"((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRXs 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 modeRjitwitxic3s|]}|VqdS(N((RvRB(tspec_map(s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pys suwhatituiRitouwhouauugoc3s|]}|>VqdS(N((Rvtsubj(tspect shift_map(s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pys suopu-iu=c3s|]}d|>VqdS(iN((RvR(R(s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pys su+cs |@|AS(N((Rttarget(R(s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs( tretmatchRtdicttgroupRRtoperatortor_R<tand_R0(RtparsedtspecstwhotmasksRtoptop_map((RRRRs</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRcs*     tCaseInsensitivePatterncBseZdZedZRS(u A string 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, CaseInsensitivePattern as ci Path('.').files(ci('*.py')) cCs tdjS(Nuntpath(t __import__RZ(R,((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRZs(RRR2RKRZ(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRs RDcBseZdZRS(cOs)d}tj|ttj|||S(Nu%path is deprecated. Use Path instead.(RRtDeprecationWarningR3R{(R#RRR((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyR{s(RRR{(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyRDsupath(HR2t __future__RRBRRSRRRTtcodecsRR RyRRRR\Rt distutilsRReRt ImportErrorRRt version_infoR>R6R7RKR@RQRXR Rt basestringtunicodetregister_errorR]Rt__all__tLINESEPSt U_LINESEPStcompileRMRRRjRRRt pkg_resourcestrequiretversiont __version__tDistributionNotFoundtWarningRR"R(RKR)RR.R3RFRkR*RRRRD(((s</data/av2000/mvv/env_mvv/lib/python2.7/site-packages/path.pyt"s                                 G#!# >