
    ij                    <   d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlmZmZmZmZmZ ddlmZ  ej8                  e      5  ddlZddd        ej8                  e      5  ddlZddd        ej8                  e      5  ddl Z ddd       ddl!m"Z"m#Z#m$Z$ ddl%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ e'rdddl%m,Z, dd	l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 dd
l4m5Z5m6Z6m7Z7 e,e8e*e8ge9f   df   Z:e*e8e8ge;f   Z<e*e8e=e8   ge#e8   f   Z>e*e*de(f   e8e.ge;f   Z?e*e*de(f   e8e@ge;f   ZAddlBmCZCmDZDmEZE ddlFmGZGmHZH g dZIg dZJeJg dz   ZK ej                  dj                  eJ      j                               ZO ej                  dj                  eK            ZP ej                  eOj                  dz         ZR ej                  ePj                  dz         ZS e;       ZTd.dZU G d deV      ZW G d d      ZXd/dZY G d de8      ZZ G d de[      Z\d0dZ] G d  d!eZ      Z^ G d" d#eZ      Z_ G d$ d%      Z` G d& d'      Za G d( d)eaeZ      Zb G d* d+eZ      Zc G d, d-      Zdy# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w)1a  
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)BufferedRandomBufferedReaderBufferedWriterFileIOTextIOWrapper)
ModuleType)	GeneratorIterableIterator)IOTYPE_CHECKINGAnyBinaryIOCallableoverload)Union)ExcInfoOpenBinaryModeOpenBinaryModeReadingOpenBinaryModeUpdatingOpenBinaryModeWritingOpenTextMode)LiteralNeverSelf.   )classesmasksmatchers)removeprefixremovesuffix)PathTempDir	Traversal)z

)   u    u    |   $$c                n    t        | t        t        f      r| n| j                         }t        |dz        S )Ni ʚ;)
isinstancefloatint	timestamp)valuetimestamp_ss     :/DATA/.local/lib/python3.12/site-packages/path/__init__.py_make_timestamp_nsr4   k   s-    %eeS\:%@QK{U"##    c                      e Zd Zy)TreeWalkWarningN__name__
__module____qualname__ r5   r3   r7   r7   p       r5   r7   c                  (    e Zd ZdZddZ	 	 	 	 ddZy)r%   ap  
    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
    c                    || _         y N)follow)selfrA   s     r3   __init__zTraversal.__init__   s	    r5   c              #     K   d }	 	 |j                  |      }| t        j                  | j                  |      }7# t        $ r Y y w xY wwr@   )sendStopIteration	functoolspartialrA   )rB   walkertraverseitems       r3   __call__zTraversal.__call__   sX      {{8, J ((d;H  ! s%   A= %A	A	AA		AN)rA   zCallable[[Path], bool])rI   z0Generator[Path, Callable[[], bool] | None, None]returnIterator[Path])r9   r:   r;   __doc__rC   rL   r<   r5   r3   r%   r%   t   s!    (<F<	<r5   r%   c                    d | D        S )zZ
    >>> list(_strip_newlines(['Hello World\r\n', 'foo']))
    ['Hello World', 'foo']
    c              3  H   K   | ]  }t         j                  d |        yw) N)U_NL_ENDsub.0lines     r3   	<genexpr>z"_strip_newlines.<locals>.<genexpr>   s     5utHLLT"us    "r<   liness    r3   _strip_newlinesr[      s    
 6u55r5   c                      e Zd ZU dZej
                  Zded<   	 dd fdZdddZ	ddZ
eej                  dd              Zej                   edd              Zd fd	Zd fd
ZddZddZddZddZddZed        Zedd       ZddZddZddZddZddZddZ ddZ!ddZ"ddZ#e$dd       Z%ddZ&e$dd       Z'ddZ(e$dd       Z)e$dd        Z*e$dd!       Z+dd"Z,dd#Z-dd$Z.dd%Z/dd&Z0ejb                  dd'       Z2dd(Z3dd)Z4dd*Z5dd+Z6ddd,Z7dd-Z8ddd/Z9ddd0Z:ddd1Z;	 d	 	 	 	 	 dd3Z<ddd4Z=ddd5Z>	 d	 	 	 	 	 dd6Z?dd7Z@dd8ZAeB	 	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd;       ZCeB	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd<       ZCeB	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd=       ZCeB	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd>       ZCeB	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd?       ZCeB	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd@       ZCeB	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddA       ZCdB ZCddCZDeB	 	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddD       ZEeB	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddE       ZEeB	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddF       ZEdG ZEdddIZFdddJZGddKZHd.d2ej                  dHf	 	 	 	 	 	 	 	 	 	 	 ddLZJ	 	 	 d	 	 	 	 	 	 	 ddMZK	 	 ddHdN	 	 	 	 	 	 	 ddOZLeMddP       ZNddQZOddRZPddSZQddTZRddUZSddVZTddWZUddXZVddYZWddZZXdd[ZYdd\ZZdd]Z[e$dd^       Z\e\j                  dd_       Z\dd`Z^ddaZ_e$ddb       Z`e`j                  ddc       Z`dddZae$dde       ZbddfZce$ddg       Zde$ddh       Zed.dHd:di	 	 	 	 	 	 	 	 	 ddjZfd:dkddlZgddmZheij                  dnk(  rddoZknddpZke$ddq       Zleij                  dnk7  rd:dkddrZmddsZnddtZoeB	 dd.d:du	 	 	 	 	 	 	 ddv       ZpeB	 dd.d:du	 	 	 	 	 	 	 	 	 ddw       ZpddxZpddyZqeij                  dnk7  rdddzZrdd{Zsdd|Ztd fd}Zuddd~ZvdddZwdddZxdddZyddZzddZ{ddZ|ddZ}ddZ~ddZddZeZeZddZd dZdddZdǐddZddZddZd:dkddZd:dkddZd:dkddZd:dkddZd:dkddZdHd.ej                  dHdHf	 	 	 	 	 	 	 	 	 	 	 	 	 ddZej                  fddZeij"                  dk\  rJeBd9d9d	 	 	 	 	 	 	 	 	 dd       ZeB	 dd9d9d	 	 	 	 	 	 	 	 	 dd       ZeB	 dd9d9d	 	 	 	 	 	 	 d	d       ZnZeij"                  dk\  r,eB	 dd.d	 	 	 	 	 d
d       ZeB	 dd9d	 	 	 	 	 	 	 dd       ZneBddd       ZeB	 d	 	 	 	 	 dd       Zd Zej                  j                  e_        ej                  j                  e_        ej                  j                  e_        ej                  j                  e_        ej                  j                  e_        ej                  j                  e_        ej                   j                  e_        ej$                  j                  e_        ddZddZeZ	 dej                  d d	 	 	 	 	 	 	 ddZeij                  dnk7  rddZeij                  dnk(  rVeij"                  dk\  r/eB	 	 	 d	 	 	 	 	 	 	 dd       ZeB	 	 	 d	 	 	 	 	 	 	 	 	 dd       ZneBdd       ZeBdd       ZddZej4                  	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 	 	 dd       Zej                   edd              Z xZS (  r#   a  
    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.
    r	   modulec                $    t         |   | |      S r@   )super__new__)clsother	__class__s     r3   r`   zPath.__new__   s    wsE**r5   c                >    |t        d      | j                          y )Nz$Invalid initial value for path: None)	TypeError	_validaterB   rb   s     r3   rC   zPath.__init__   s    =BCCr5   c                     y r@   r<   rB   s    r3   rf   zPath._validate       r5   c                b    | j                   dz   |j                   z   }| f}d|i}t        |||      S )N_r]   r9   type)ra   r]   subclass_namebasesnss        r3   using_modulezPath.using_module   s;     s*V__<M5"--r5   c                    | S )zV
        What class should be used to construct new instances from this class
        r<   ra   s    r3   _next_classzPath._next_class   s	     
r5   c                R    t        |       j                   dt        |           dS )N())rn   r9   r_   __repr__)rB   rc   s    r3   ry   zPath.__repr__   s*    t*%%&a(8(:';1==r5   c                @    | j                  t        | 	  |            S r@   )ru   r_   __add__)rB   morerc   s     r3   r{   zPath.__add__   s     566r5   c                B    | j                  |j                  |             S r@   )ru   r{   rg   s     r3   __radd__zPath.__radd__   s    d 344r5   c                X    | j                  | j                  j                  | |            S )zfp.__truediv__(rel) == fp / rel == fp.joinpath(rel)

        Join two path components, adding a separator character if
        needed.

        .. seealso:: :func:`os.path.join`
        ru   r]   joinrB   rels     r3   __truediv__zPath.__truediv__   s&      0 0s ;<<r5   c                X    | j                  | j                  j                  ||             S )zfp.__rtruediv__(rel) == rel / fp

        Join two path components, adding a separator character if
        needed.

        .. seealso:: :func:`os.path.join`
        r   r   s     r3   __rtruediv__zPath.__rtruediv__   s&      0 0d ;<<r5   c                Z    | j                         | _        t        j                  |        | S r@   )cwd_old_diroschdirri   s    r3   	__enter__zPath.__enter__   s    

r5   c                B    t        j                  | j                         y r@   )r   r   r   rB   rl   s     r3   __exit__zPath.__exit__   s    
r5   c                6     | t        j                               S )zgReturn the current working directory as a path object.

        .. seealso:: :func:`os.getcwd`
        )r   getcwdrt   s    r3   r   zPath.cwd   s     299;r5   c                L     | t         j                  j                  d            S )N~)r   path
expanduserrt   s    r3   homez	Path.home  s    277%%c*++r5   c                V    | j                  | j                  j                  |             S )z$.. seealso:: :func:`os.path.abspath`)ru   r]   abspathri   s    r3   absolutezPath.absolute  "     3 3D 9::r5   c                V    | j                  | j                  j                  |             S )z%.. seealso:: :func:`os.path.normcase`)ru   r]   normcaseri   s    r3   r   zPath.normcase  "     4 4T :;;r5   c                V    | j                  | j                  j                  |             S )z%.. seealso:: :func:`os.path.normpath`)ru   r]   normpathri   s    r3   r   zPath.normpath  r   r5   c                V    | j                  | j                  j                  |             S )z%.. seealso:: :func:`os.path.realpath`)ru   r]   realpathri   s    r3   r   zPath.realpath  r   r5   c                V    | j                  | j                  j                  |             S )z'.. seealso:: :func:`os.path.expanduser`)ru   r]   r   ri   s    r3   r   zPath.expanduser  "     6 6t <==r5   c                V    | j                  | j                  j                  |             S )z'.. seealso:: :func:`os.path.expandvars`)ru   r]   
expandvarsri   s    r3   r   zPath.expandvars   r   r5   c                V    | j                  | j                  j                  |             S )z4.. seealso:: :attr:`parent`, :func:`os.path.dirname`)ru   r]   dirnameri   s    r3   r   zPath.dirname$  r   r5   c                V    | j                  | j                  j                  |             S )z3.. seealso:: :attr:`name`, :func:`os.path.basename`)ru   r]   basenameri   s    r3   r   zPath.basename(  r   r5   c                Z    | j                         j                         j                         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   r   ri   s    r3   expandzPath.expand,  s#      ++-6688r5   c                V    | j                   j                  | j                        \  }}|S )zThe same as :meth:`name`, but with one file extension stripped off.

        >>> Path('/home/guido/python.tar.gz').stem
        'python.tar'
        )r]   splitextname)rB   baserl   s      r3   stemz	Path.stem5  s%     ++&&tyy1ar5   c                >    | j                  || j                  z         S )zReturn a new path with the stem changed.

        >>> Path('/home/guido/python.tar.gz').with_stem("foo")
        Path('/home/guido/foo.gz')
        )	with_namesuffix)rB   r   s     r3   	with_stemzPath.with_stem?  s     ~~dT[[011r5   c                B    | j                   j                  |       \  }}|S )z*The file extension, for example ``'.py'``.)r]   r   )rB   rl   r   s      r3   r   zPath.suffixG  s!     KK((.	6r5   c                f    |j                  d      st        d|      | j                         |z   S )a  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'
        .zInvalid suffix )
startswith
ValueErrorstripext)rB   r   s     r3   with_suffixzPath.with_suffixM  s5       %vj9::}}''r5   c                `    | j                   j                  |       \  }}| j                  |      S )z}The drive specifier, for example ``'C:'``.

        This is always empty on systems that don't use drive specifiers.
        r]   
splitdriveru   )rB   driverl   s      r3   r   z
Path.drive_  s-     ;;))$/q&&r5   c                "    | j                         S )zThis 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`
        )r   ri   s    r3   parentzPath.parenth  s     ||~r5   c                "    | j                         S )zThe 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`
        )r   ri   s    r3   r   z	Path.namet  s     }}r5   c                R    | j                  t        | | j                        |z         S )zReturn a new path with the name changed.

        >>> Path('/home/guido/python.tar.gz').with_name("foo.zip")
        Path('/home/guido/foo.zip')
        )ru   r"   r   rB   r   s     r3   r   zPath.with_name  s%     T499 = DEEr5   c                d    | j                   j                  |       \  }}| j                  |      |fS )z~Return two-tuple of ``.parent``, ``.name``.

        .. seealso:: :attr:`parent`, :attr:`name`, :func:`os.path.split`
        )r]   splitru   )rB   r   childs      r3   	splitpathzPath.splitpath  s2    
 ))$/'..r5   c                    | j                   j                  |       \  }}| j                  |      | j                  |      fS )aC  Return 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   )rB   r   r   s      r3   r   zPath.splitdrive  s=     [[++D1
s&(8(8(===r5   c                d    | j                   j                  |       \  }}| j                  |      |fS )a  Return 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`
        )r]   r   ru   )rB   filenameexts      r3   r   zPath.splitext  s2     ,,T2#)3..r5   c                (    | j                         d   S )zRemove one file extension from the path.

        For example, ``Path('/home/guido/python.tar.gz').stripext()``
        returns ``Path('/home/guido/python.tar')``.
        r   )r   ri   s    r3   r   zPath.stripext  s     }}q!!r5   c                Z    | j                   | j                  j                  |g|       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`
        r   )ra   firstotherss      r3   joinpathzPath.joinpath  s'     szzu>v>??r5   c                4    t        | j                               S )a  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.joinpath(*result)`` will yield the original path.

        >>> Path('/foo/bar/baz').splitall()
        [Path('/'), 'foo', 'bar', 'baz']
        )list_partsri   s    r3   splitallzPath.splitall  s     DKKM""r5   c                4    t        | j                               S )z[
        >>> Path('/foo/bar/baz').parts()
        (Path('/'), 'foo', 'bar', 'baz')
        )tupler   ri   s    r3   partsz
Path.parts  s    
 T[[]##r5   c                F    t        t        | j                                     S r@   )reversedr   _parts_iterri   s    r3   r   zPath._parts  s    d..0122r5   c              #     K   | }|t         j                  k7  rY|t         j                  k7  rF|}|j                         \  }}||k(  rn+| |t         j                  k7  r|t         j                  k7  rF| y wr@   )r   curdirpardirr   )rB   locprevr   s       r3   r   zPath._parts_iter  sf     RYY3"))#3D)JCd{K RYY3"))#3 	s   A.A61A6c                F    | j                  |      }|j                  |       S )zzReturn this path as a relative path,
        based from `start`, which defaults to the current working directory.
        )ru   	relpathto)rB   startr   s      r3   relpathzPath.relpath  s#     u%}}T""r5   c                `   | j                         }| j                  |      j                         }|j                         j                         }|j                         }|d   | j                  j                  |d         k7  r|S d}t        ||      D ]*  \  }}|| j                  j                  |      k7  r n|dz  }, t        j                  gt        |      |z
  z  }	|	||d z  }	t        |	      dk(  rt        j                  }
n | j                  j                  |	 }
| j                  |
      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()``.
        r   r   N)r   ru   r   r   r]   zipr   r   lenr   r   )rB   destorigin	dest_path	orig_list	dest_listi	start_segdest_segsegmentsr   s              r3   r   zPath.relpathto  s    $$T*335	OO%..0	&&(	Q<4;;//	!== #&y)#<IxDKK00::FA $= II;#i.1"45IabM!x=AiiG&dkk&&1G((r5   Nc                ~     t        j                  |      }t        | fdt        j                         D              S )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`
        c              3  (   K   | ]	  }|z    y wr@   r<   )rV   r   rB   s     r3   rX   zPath.iterdir.<locals>.<genexpr>  s     I8HudUl8Hs   )r    loadfilterr   listdir)rB   matchs   ` r3   iterdirzPath.iterdir  s/     e$eI

48HIJJr5   c                l    | j                  |      D cg c]  }|j                         s| c}S c c}w )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`.
        )r   is_dirrB   r   ps      r3   dirsz	Path.dirs   s/      <<.=.a!((*.===   11c                l    | j                  |      D cg c]  }|j                         s| c}S c c}w )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`.
        )r   is_filer   s      r3   filesz
Path.files+  s/      <<.>.a!))+.>>>r   strictc              #    K   t         j                  |      }t        j                  |      }	 | j	                         }|D ]F  }d} ||      r|}|xs |j                  }	  |       }|s,|j                  ||      E d{    H y# t
        $ r} |d|  d|        Y d}~yd}~ww xY w# t
        $ r} |d| d|        Y d}~d}~ww xY w7 Ow)a  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.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.
        zUnable to list directory 'z': NzUnable to access ')errorsr   )Handlers_resolver    r   r   	Exceptionr   walk)	rB   r   r  error_fn	childListexcr   rJ   do_traverses	            r3   r  z	Path.walk6  s     & $$V,e$	I
 EHU|!&;/5<<H&j
  ::XU:CCC 	  	1$s3%@A	  -eWCu=>
 Dsi   +CB
 #C"B.)C,CCC
	B+B&!C&B++C.	C7C
C
CCc                4    d | j                  ||      D        S )z#Iterator over subdirs, recursively.c              3  B   K   | ]  }|j                         s|  y wr@   )r   rV   rK   s     r3   rX   z Path.walkdirs.<locals>.<genexpr>b  s     K!9T[[]!9   r  rB   r   r  s      r3   walkdirszPath.walkdirs`  s    K5&!9KKr5   c                4    d | j                  ||      D        S )z!Iterator over files, recursively.c              3  B   K   | ]  }|j                         s|  y wr@   )r   r  s     r3   rX   z!Path.walkfiles.<locals>.<genexpr>f  s     L!9T\\^!9r  r  r  s      r3   	walkfileszPath.walkfilesd  s    L5&!9LLr5   c                    t        |d| j                  j                        }|xs |} || j                        } ||      }t	        j
                  ||      S )a  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 normcase from
            ``self.module``, :func:`os.path.normcase`.

        .. seealso:: :func:`fnmatch.fnmatch`
        r   )getattrr]   r   r   fnmatchfnmatchcase)rB   patternr   default_normcaser   s        r3   r  zPath.fnmatchh  sS     #7J8L8LM//		"7#""411r5   c                |    | j                   }t        j                  | |z        D cg c]
  } ||       c}S c c}w )a  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`.
        )ru   glob)rB   r  ra   ss       r3   r  z	Path.glob}  s:      $		$. 9: 91A 9:::s   9c                ^    | j                   fdt        j                  | |z        D        S )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`.
        c              3  .   K   | ]  } |        y wr@   r<   )rV   r  ra   s     r3   rX   zPath.iglob.<locals>.<genexpr>  s     ; :1A :s   )ru   r  iglob)rB   r  ra   s     @r3   r!  z
Path.iglob  s(     ;

4'> :;;r5   .Tc                     y r@   r<   rB   mode	bufferingencodingr  newlineclosefdopeners           r3   openz	Path.open  s     r5   c                     y r@   r<   r#  s           r3   r*  z	Path.open  s     r5   c                     y r@   r<   r#  s           r3   r*  z	Path.open       r5   c                     y r@   r<   r#  s           r3   r*  z	Path.open  r-  r5   c                     y r@   r<   r#  s           r3   r*  z	Path.open  r-  r5   c                     y r@   r<   r#  s           r3   r*  z	Path.open  s     r5   c                     y r@   r<   r#  s           r3   r*  z	Path.open  s     r5   c                     t        | g|i |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.
        )r*  rB   argskwargss      r3   r*  z	Path.open  s     D*4*6**r5   c                p    | j                  d      5 }|j                         cddd       S # 1 sw Y   yxY w)z8Open this file, read all bytes, return them as a string.rbNr*  readrB   fs     r3   bytesz
Path.bytes  s"    YYt_668 __s   ,5c	                     y r@   r<   	rB   sizer$  r%  r&  r  r'  r(  r)  s	            r3   chunkszPath.chunks  s     r5   c	                     y r@   r<   r>  s	            r3   r@  zPath.chunks	  s     $'r5   c	                     y r@   r<   r>  s	            r3   r@  zPath.chunks  s     *-r5   c              /     K    | j                   |i |5 t        fdd      E d{    ddd       y7 # 1 sw Y   yxY ww)a  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("NEWS.rst").chunks(8192, mode='rb'):
            ...     hash.update(chunk)

         This will read the file by chunks of 8192 bytes.
        c                 .     j                        xs d S r@   )r9  )r;  r?  s   r3   <lambda>zPath.chunks.<locals>.<lambda>0  s    AFF4L$8D$8r5   N)r*  iter)rB   r?  r4  r5  r;  s    `  @r3   r@  zPath.chunks!  sC      TYY''18$??? ('? ('s%   A;9;	A;A AFc                z    | j                  |rdnd      5 }|j                  |       ddd       y# 1 sw Y   yxY w)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.
        abwbN)r*  write)rB   r<  appendr;  s       r3   write_byteszPath.write_bytes2  s-     YYvt40AGGEN 100s   1:c                t    | j                  ||      5 }|j                         cddd       S # 1 sw Y   yxY w)zOpen this file, read it in, return the content as a string.

        Optional parameters are passed to :meth:`open`.

        .. seealso:: :meth:`lines`
        )r&  r  Nr8  )rB   r&  r  r;  s       r3   	read_textzPath.read_text;  s+     YYY8A668 988s   .7c                r    | j                  d      5 }|j                         cddd       S # 1 sw Y   yxY w)z*Return the contents of this file as bytes.r7  r$  Nr8  r:  s     r3   
read_byteszPath.read_bytesE  s'    YYDY!Q668 "!!s   -6c                    |t         j                  ||      }|j                  |xs t        j                         |      }| j                  ||       y)a  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 - 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

        `text` is written using the
        specified `encoding` (or the default encoding if `encoding`
        isn't specified).  The `errors` argument applies only to this
        conversion.
        NrK  )	U_NEWLINErT   encodesysgetdefaultencodingrL  )rB   textr&  r  lineseprK  r<  s          r3   
write_textzPath.write_textJ  sL    v ==$/DH@(>(>(@&Iv.r5   c                p    t         j                  d| j                  ||            }|j                  |      S )a  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 use
                ``locale.getpreferredencoding()``.
            `errors` - How to handle Unicode errors; see
                `open <https://docs.python.org/3/library/functions.html#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.
        r'   )rT  rT   rN  
splitlines)rB   r&  r  retainrX  s        r3   rZ   z
Path.lines  s.    ( }}T4>>(F#CDv&&r5   rS  c                   |rdnd}| j                  |||d      5 }|j                  | j                  |             ddd       y# 1 sw Y   yxY w)aa  Write the given lines of text to this file.

        By default this overwrites any existing file at this path.

        Puts a platform-specific newline sequence on every line.

            `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.

        Use the keyword argument ``append=True`` to append lines to the
        file.  The default is to overwrite the file.
        awrR   )r&  r  r'  N)r*  
writelines_replace_linesep)rB   rZ   r&  r  rK  r$  r;  s          r3   write_lineszPath.write_lines  sG    2 s#YYthvrYJaLL..u56 KJJs   !AAc                &    d t        |       D        S )Nc              3  B   K   | ]  }|t         j                  z     y wr@   )r   rY  rU   s     r3   rX   z(Path._replace_linesep.<locals>.<genexpr>  s     E.Ddrzz!.Ds   )r[   rY   s    r3   rb  zPath._replace_linesep  s    Eoe.DEEr5   c                $    | j                  d      S )zCalculate the md5 hash for this file.

        This reads through the entire file.

        .. seealso:: :meth:`read_hash`
        md5)	read_hashri   s    r3   read_md5zPath.read_md5  s     ~~e$$r5   c                    t        j                  |      }| j                  dd      D ]  }|j                  |        |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    r7  rP  )hashlibnewr@  update)rB   	hash_namemchunks       r3   _hashz
Path._hash  s9     KK	"[[D[1EHHUO 2r5   c                @    | j                  |      j                         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`
        )rq  digestrB   rn  s     r3   rh  zPath.read_hash  s     zz)$++--r5   c                @    | j                  |      j                         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`
        )rq  	hexdigestrt  s     r3   read_hexhashzPath.read_hexhash  s     zz)$..00r5   c                8    | j                   j                  |       S )za
        >>> Path('.').isabs()
        False

        .. seealso:: :func:`os.path.isabs`
        )r]   isabsri   s    r3   ry  z
Path.isabs  s     {{  &&r5   c                8    | j                   j                  |       S )z#.. seealso:: :func:`os.path.exists`)r]   existsri   s    r3   r{  zPath.exists      {{!!$''r5   c                8    | j                   j                  |       S )z".. seealso:: :func:`os.path.isdir`)r]   isdirri   s    r3   r   zPath.is_dir  s    {{  &&r5   c                8    | j                   j                  |       S )z#.. seealso:: :func:`os.path.isfile`)r]   isfileri   s    r3   r   zPath.is_file   r|  r5   c                8    | j                   j                  |       S )z#.. seealso:: :func:`os.path.islink`)r]   islinkri   s    r3   r  zPath.islink  r|  r5   c                8    | j                   j                  |       S )ze
        >>> Path('.').ismount()
        False

        .. seealso:: :func:`os.path.ismount`
        )r]   ismountri   s    r3   r  zPath.ismount  s     {{""4((r5   c                :    | j                   j                  | |      S )z%.. seealso:: :func:`os.path.samefile`)r]   samefilerg   s     r3   r  zPath.samefile  s    {{##D%00r5   c                8    | j                   j                  |       S )z4.. seealso:: :attr:`atime`, :func:`os.path.getatime`)r]   getatimeri   s    r3   r  zPath.getatime      {{##D))r5   c                r    | j                         j                  }| j                  t        |      |f       y N)rq   statst_atime_nsutimer4   )rB   r1   mtime_nss      r3   	set_atimezPath.set_atime  s,    99;**

)%0(;
<r5   c                "    | j                         S )a  
        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`
        )r  ri   s    r3   atimez
Path.atime  s    $ }}r5   c                &    | j                  |       y r@   )r  rB   r1   s     r3   r  z
Path.atime1      ur5   c                8    | j                   j                  |       S )z4.. seealso:: :attr:`mtime`, :func:`os.path.getmtime`)r]   getmtimeri   s    r3   r  zPath.getmtime5  r  r5   c                r    | j                         j                  }| j                  |t        |      f       y r  r  )rB   r1   atime_nss      r3   	set_mtimezPath.set_mtime9  s,    99;**

x!3E!:;
<r5   c                "    | j                         S )a  
        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`
        )r  ri   s    r3   mtimez
Path.mtime=  s     }}r5   c                &    | j                  |       y r@   )r  r  s     r3   r  z
Path.mtimeN  r  r5   c                8    | j                   j                  |       S )z4.. seealso:: :attr:`ctime`, :func:`os.path.getctime`)r]   getctimeri   s    r3   r  zPath.getctimeR  r  r5   c                "    | j                         S )zdCreation time of the file.

        .. seealso:: :meth:`getctime`, :func:`os.path.getctime`
        )r  ri   s    r3   ctimez
Path.ctimeV  s     }}r5   c                8    | j                   j                  |       S )z2.. seealso:: :attr:`size`, :func:`os.path.getsize`)r]   getsizeri   s    r3   r  zPath.getsize^  s    {{""4((r5   c                "    | j                         S )zcSize of the file, in bytes.

        .. seealso:: :meth:`getsize`, :func:`os.path.getsize`
        )r  ri   s    r3   r?  z	Path.sizeb  s     ||~r5   c                \    t        j                  | j                         j                        S )z
        Permissions.

        >>> perms = Path('.').permissions
        >>> isinstance(perms, int)
        True
        >>> set(perms.symbolic) <= set('rwx-')
        True
        >>> perms.symbolic
        'r...'
        )r   Permissionsr  st_moderi   s    r3   permissionszPath.permissionsj  s!       !4!455r5   dir_fdeffective_idsfollow_symlinksc               6    t        j                  | ||||      S )z
        Return does the real user have access to this path.

        >>> Path('.').access(os.F_OK)
        True

        .. seealso:: :func:`os.access`
        r  )r   access)rB   r$  r  r  r  s        r3   r  zPath.accessy  s$      yy'+
 	
r5   r  c               0    t        j                  | |      S )z
        Perform a ``stat()`` system call on this path.

        >>> Path('.').stat()
        os.stat_result(...)

        .. seealso:: :meth:`lstat`, :func:`os.stat`
        r  )r   r  )rB   r  s     r3   r  z	Path.stat  s     wwt_==r5   c                ,    t        j                  |       S )z
        Like :meth:`stat`, but do not follow symbolic links.

        >>> Path('.').lstat() == Path('.').stat()
        True

        .. seealso:: :meth:`stat`, :func:`os.lstat`
        )r   lstatri   s    r3   r  z
Path.lstat  s     xx~r5   win32c                    dt               vrt        d      t        j                  | t        j                        }|j                         }t        j                  d|      \  }}}|dz   |z   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`
            win32securityz)Ownership not available on this platform.N\)globalsNotImplementedErrorr  GetFileSecurityOWNER_SECURITY_INFORMATIONGetSecurityDescriptorOwnerLookupAccountSid)rB   descsidaccountdomaintypecodes         r3   	get_ownerzPath.get_owner  sm     gi/)*UVV 00m>>D 113C(5(F(FtS(Q%GVXD=7**r5   c                t    | j                         }t        j                  |j                        j                  S )z
            Return the name of the owner of this file or directory. Follow
            symbolic links.

            .. seealso:: :attr:`owner`
            )r  pwdgetpwuidst_uidpw_name)rB   sts     r3   r  zPath.get_owner  s(     B<<		*222r5   c                "    | j                         S )zTName of the owner of this file or directory.

        .. seealso:: :meth:`get_owner`)r  ri   s    r3   ownerz
Path.owner  s    
 ~~r5   c               x    | j                  |      j                  }t        j                  |      j                  S )z@
            Return the group name of the file gid.
            r  )r  st_gidgrpgetgrgidgr_name)rB   r  gids      r3   groupz
Path.group  s/     ))O)<CCC<<$,,,r5   c                ,    t        j                  |       S )zkPerform a ``statvfs()`` system call on this path.

            .. seealso:: :func:`os.statvfs`
            )r   statvfsri   s    r3   r  zPath.statvfs  s    
 ::d##r5   c                .    t        j                  | |      S )z .. seealso:: :func:`os.pathconf`)r   pathconfr   s     r3   r  zPath.pathconf  s    ;;tT**r5   )r  r  c                    y r@   r<   )rB   timesr  r  s       r3   r  z
Path.utime  s     r5   c                    y r@   r<   )rB   r  rq   r  r  s        r3   r  z
Path.utime  s     r5   c                8    t        j                  | g|i | | S )z_Set the access and modified times of this file.

        .. seealso:: :func:`os.utime`
        )r   r  r3  s      r3   r  z
Path.utime  s    
 	'''r5   c                    t        |t              r5t        j                  |      } || j	                         j
                        }t        j                  | |       | S )at  
        Set the mode. May be the new mode (os.chmod behavior) or a `symbolic
        mode <http://en.wikipedia.org/wiki/Chmod#Symbolic_modes>`_.

        >>> 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-   strr   compoundr  r  r   chmod)rB   r$  masks      r3   r  z
Path.chmod   sE     dC >>$'D		++,D
tr5   c                \    dd}dd}t        j                  |  ||       ||             | S )zt
            Change the owner and group by names or numbers.

            .. seealso:: :func:`os.chown`
            c                d    t        | t              r| S t        j                  |       j                  S r@   )r-   r/   r  getpwnampw_uid)uids    r3   resolve_uidzPath.chown.<locals>.resolve_uid  %    (c2sPS8I8P8PPr5   c                d    t        | t              r| S t        j                  |       j                  S r@   )r-   r/   r  getgrnamgr_gid)r  s    r3   resolve_gidzPath.chown.<locals>.resolve_gid  r  r5   )r  	str | intrM   r/   )r  r  rM   r/   )r   chown)rB   r  r  r  r  s        r3   r  z
Path.chown  s/    QQ HHT;s+[-=>Kr5   c                P    t        j                  | |       | j                  |      S )z.. seealso:: :func:`os.rename`)r   renameru   rB   rl  s     r3   r  zPath.rename%  s!    
		$$$r5   c                P    t        j                  | |       | j                  |      S )z.. seealso:: :func:`os.renames`)r   renamesru   r  s     r3   r  zPath.renames*  s!    


4$$r5   c                    | j                  |rt        |   |g|       S t        j                  |       j                  |            S )a  
        Replace a path or substitute substrings.

        Implements both pathlib.Path.replace and str.replace.

        If only a target is supplied, rename this path to the target path,
        overwriting if that path exists.

        >>> dest = Path(getfixture('tmp_path'))
        >>> orig = dest.joinpath('foo').touch()
        >>> new = orig.replace(dest.joinpath('fee'))
        >>> orig.exists()
        False
        >>> new.exists()
        True

        ..seealso:: :meth:`pathlib.Path.replace`

        If a second parameter is supplied, perform a textual replacement.

        >>> Path('foo').replace('o', 'e')
        Path('fee')
        >>> Path('foo').replace('o', 'l', 1)
        Path('flo')

        ..seealso:: :meth:`str.replace`
        )ru   r_   replacepathlibr#   )rB   target_or_oldr4  rc   s      r3   r  zPath.replace/  sQ    8  GOM1D1
 	
 d#++M:
 	
r5   c                2    t        j                  | |       | S )z.. seealso:: :func:`os.mkdir`)r   mkdirrB   r$  s     r3   r  z
Path.mkdirT  s    
tr5   c                    t        j                  t              5  | j                  |       ddd       | S # 1 sw Y   | S xY w)z\Like :meth:`mkdir`, but does not raise an exception if the
        directory already exists.N)
contextlibsuppressFileExistsErrorr  r  s     r3   mkdir_pzPath.mkdir_pY  s3       1JJt 2 2	   6A c                2    t        j                  | |       | S )z .. seealso:: :func:`os.makedirs`)r   makedirsr  s     r3   r   zPath.makedirs`  s    
D$r5   c                    t        j                  t              5  | j                  |       ddd       | S # 1 sw Y   | S xY w)z_Like :meth:`makedirs`, but does not raise an exception if the
        directory already exists.N)r  r  r  r   r  s     r3   
makedirs_pzPath.makedirs_pe  s3       1MM$ 2 2r  c                0    t        j                  |        | S )z.. seealso:: :func:`os.rmdir`)r   rmdirri   s    r3   r  z
Path.rmdirl  s    
r5   c                    t         t        t        f}t        j                  | 5  t        j                         5  | j                          ddd       ddd       | S # 1 sw Y   xY w# 1 sw Y   | S xY w)zlLike :meth:`rmdir`, but does not raise an exception if the
        directory is not empty or does not exist.N)FileNotFoundErrorr  DirectoryNotEmptyr  r  	translater  )rB   
suppresseds     r3   rmdir_pzPath.rmdir_pq  s[     '9JJ
  *-",,.

 / .  /. . s"   A(A
A(A%	!A((A2c                0    t        j                  |        | S )z".. seealso:: :func:`os.removedirs`)r   
removedirsri   s    r3   r  zPath.removedirsz  s    
dr5   c                    t        j                  t        t              5  t        j	                         5  | j                          ddd       ddd       | S # 1 sw Y   xY w# 1 sw Y   | S xY w)zqLike :meth:`removedirs`, but does not raise an exception if the
        directory is not empty or does not exist.N)r  r  r  r  r  r  ri   s    r3   removedirs_pzPath.removedirs_p  sT       2CD",,.! / E  /. E s"   A#AA#A 	A##A-c                    t        j                  t        j                  | t         j                  t         j                  z  d             t        j
                  | d       | S )zvSet the access/modified times of this file to the current time.
        Create the file if it does not exist.
        i  N)r   closer*  O_WRONLYO_CREATr  ri   s    r3   touchz
Path.touch  s=     	r{{RZZ7?@
tr5   c                0    t        j                  |        | S )z.. seealso:: :func:`os.remove`)r   removeri   s    r3   r  zPath.remove  s    
		$r5   c                    t        j                  t              5  | j                          ddd       | S # 1 sw Y   | S xY w)zXLike :meth:`remove`, but does not raise an exception if the
        file does not exist.N)r  r  r  unlinkri   s    r3   remove_pzPath.remove_p  1       !23KKM 4 4   5?c                0    t        j                  ||        y)zg
        Create a hard link at self, pointing to target.

        .. seealso:: :func:`os.link`
        N)r   link)rB   targets     r3   hardlink_tozPath.hardlink_to  s     	r5   c                P    t        j                  | |       | j                  |      S )zfCreate a hard link at `newpath`, pointing to this file.

        .. seealso:: :func:`os.link`
        )r   r  ru   )rB   newpaths     r3   r  z	Path.link  s#    
 	g((r5   c                2    t        j                  || |       y)zn
        Create a symbolic link at self, pointing to target.

        .. seealso:: :func:`os.symlink`
        N)r   symlink)rB   r  target_is_directorys      r3   
symlink_tozPath.symlink_to  s     	

64!45r5   c                t    || j                         }t        j                  | |       | j                  |      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`
        )r   r   r"  ru   )rB   newlinks     r3   r"  zPath.symlink  s3     ?mmoG


4!((r5   c                ^    | j                  t        t        j                  |       d            S )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\\?\)ru   r!   r   readlinkri   s    r3   r(  zPath.readlink  s%     R[[->	 JKKr5   c                    | j                         }|j                         r|S | j                  |z  j                         S )zReturn the path to which this symbolic link points.

        The result is always an absolute path.

        .. seealso:: :meth:`readlink`, :func:`os.readlink`
        )r(  ry  r   r   )rB   r   s     r3   readlinkabszPath.readlinkabs  s3     MMOGGIq?DKK!O#=#=#??r5   c               P    | j                  t        j                  | ||            S Nr  )ru   shutilcopyfilerB   dstr  s      r3   r.  zPath.copyfile  s%    OOD#G
 	
r5   c               4    t        j                  | ||       y r,  )r-  copymoder/  s      r3   r2  zPath.copymode      c?Cr5   c               4    t        j                  | ||       y r,  )r-  copystatr/  s      r3   r5  zPath.copystat  r3  r5   c               P    | j                  t        j                  | ||            S r,  )ru   r-  copyr/  s      r3   r7  z	Path.copy  s     D# WXXr5   c               P    | j                  t        j                  | ||            S r,  )ru   r-  copy2r/  s      r3   r9  z
Path.copy2  s%    LLsOD
 	
r5   c                X    | j                  t        j                  | ||||||            S )N)symlinksignorecopy_functionignore_dangling_symlinksdirs_exist_ok)ru   r-  copytree)rB   r0  r;  r<  r=  r>  r?  s          r3   r@  zPath.copytree  s8     OO!+)A+

 
	
r5   c                \    t        j                  | ||      }| j                  |xs |      S )N)r=  )r-  moveru   )rB   r0  r=  retvals       r3   rB  z	Path.move  s)    T3mD#..r5   )      )onexcr  c                    y r@   r<   rB   ignore_errorsonerrorrF  r  s        r3   rmtreezPath.rmtree       r5   c                    y r@   r<   rH  s        r3   rK  zPath.rmtree  rL  r5   c                    y r@   r<   )rB   rI  rF  r  s       r3   rK  zPath.rmtree       r5   )rD     )r  c                    y r@   r<   )rB   rJ  r  s      r3   rK  zPath.rmtree,  s     r5   c                    y r@   r<   )rB   rI  rJ  r  s       r3   rK  zPath.rmtree3  rO  r5   c                     y r@   r<   )rB   rJ  s     r3   rK  zPath.rmtree>  s    JMr5   c                     y r@   r<   )rB   rI  rJ  s      r3   rK  zPath.rmtree@  s     r5   c                6    t        j                  | g|i | y r@   )r-  rK  r3  s      r3   rK  zPath.rmtreeE  s    d,T,V,r5   c                    t        j                  t              5  | j                          ddd       | S # 1 sw Y   | S xY w)z]Like :meth:`rmtree`, but does not raise an exception if the
        directory does not exist.N)r  r  r  rK  ri   s    r3   rmtree_pzPath.rmtree_pS  r  r  c                .    t        j                  |        y)z.. seealso:: :func:`os.chdir`N)r   r   ri   s    r3   r   z
Path.chdirZ  s    
r5   c                    g S r@   r<   )dircontentss     r3   rE  zPath.<lambda>f  s    "r5   )r=  r<  c          	         | j                  |      }|j                          t        | j                               }t	         || |D cg c]  }|j
                   c}            dfd}t        j                  ||      D ]t  }	||	j
                  z  }
|r2|	j                         r"|	j                         }|j                  |
       F|	j                         r|	j                  |
|||       l ||	|
       v | j                  |       yc c}w )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))
        c                     | j                   v S r@   )r   )rK   _ignoreds    r3   ignoredz Path.merge_tree.<locals>.ignored{  s    99((r5   )r;  r=  r<  N)rK   r   rM   bool)ru   r  r   r   setr   	itertoolsfilterfalser  r(  r"  r   
merge_treer5  )rB   r0  r;  r=  r<  dst_pathsourcesrK   r_  sourcer   r  r^  s               @r3   rd  zPath.merge_tree`  s    * ##C(t||~&vd7$C74TYY7$CDE	)  ++GW=Ffkk)DFMMO*t$!!%"/!	 "  fd+ > 	h) %Ds   Dc                .    t        j                  |        y)z.. seealso:: :func:`os.chroot`N)r   chrootri   s    r3   ri  zPath.chroot  s    IIdOr5   )rD  
   c                     y r@   r<   )rB   	argumentsr   show_cmds       r3   	startfilezPath.startfile  s     r5   c                     y r@   r<   )rB   	operationrl  r   rm  s        r3   rn  zPath.startfile  s     r5   c                     y r@   r<   ri   s    r3   rn  zPath.startfile  s    ),r5   c                     y r@   r<   )rB   rp  s     r3   rn  zPath.startfile  s    9<r5   c                8    t        j                  | g|i | | S )z!.. seealso:: :func:`os.startfile`)r   rn  r3  s      r3   rn  zPath.startfile  s    LL///Kr5   c              #  
  K   t        |      j                  d      rt        d      | |xs t        j                  dz   z   }|j                          | j                  |       t        ||||||      }t        j                  |j                               j                  }	t        j                  t        j                  z  t        j                  z  }
|
t        t        dd      z  }
t        j                  | |
|	      }t        |d|j                  dd	      z   ||||      }t!        j"                  t$        t&              5  | j)                  |	       d
d
d
       	 ||f |j+                          |j+                          	 |j                          y
# 1 sw Y   BxY w# t,        $ rC |j+                          |j+                          | j                          |j                  |         w xY w# |j                          w xY ww)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.
        zwa+z%Only read-only file modes can be usedbak)r%  r&  r  r'  O_BINARYr   r`  rrR   N)ra  intersectionr   r   extsepr  r  r*  r  filenor  r  r  O_TRUNCr  r  r  r  OSErrorAttributeErrorr  r  r  )rB   r$  r%  r&  r  r'  backup_extension	backup_fnreadablepermos_modefdwritables                r3   in_placezPath.in_place  s    F t9!!%(DEE ,A		E0AB	I
 wwx()11**r{{*RZZ772z1--WWT7D)$,,sB''
   .9JJt :	!H$$ NNNN ! :9
  	NNNNMMOT"	  sI   D>H FHF ! G. HFHAG++G. .H  Hc                6    t        j                  t        |       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
        <https://pypi.python.org/pypi/appdirs/1.4.0>`_ 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.
        )rG   rH   SpecialResolverrt   s    r3   specialzPath.special  s    .   #66r5   )r   )rb   r   rM   r   )rb   r   rM   NonerM   r  )r]   r	   rM   
type[Self])rM   r  )rM   r  )r|   r  rM   r   )rb   r  rM   r   )r   r  rM   r   rM   r   )rM   r#   )r   r  rM   r   )r   r  rM   r   )r   r  rM   r   )rM   ztuple[Self, str])rM   ztuple[Self, Self])r   r  r   r  rM   r   )rM   zlist[Self | str])rM   ztuple[Self | str, ...])rM   zIterator[Self | str])r   r  rM   r   )r   r  rM   r   r@   )r   _MatchrM   Iterator[Self])r   r  rM   
list[Self])Nr  )r   r  r  r  rM   z0Generator[Self, Callable[[], bool] | None, None])r   r  r  r  rM   r  )r  r  r   zCallable[[str], str] | NonerM   r`  )r  r  rM   r  )r  r  rM   r  ).....T.)r$  r   r%  r/   r&  
str | Noner  r  r'  r  r(  r`  r)   Callable[[str, int], int] | NonerM   r   )...T.)r$  r   r%  z
Literal[0]r&  r  r  r  r'  r  r(  r`  r)  r  rM   r   )....T.)r$  r   r%  Literal[-1, 1]r&  r  r  r  r'  r  r(  r`  r)  r  rM   r   )r$  r   r%  r  r&  r  r  r  r'  r  r(  r`  r)  r  rM   r   )r$  r   r%  r  r&  r  r  r  r'  r  r(  r`  r)  r  rM   r   )r$  r   r%  r/   r&  r  r  r  r'  r  r(  r`  r)  r  rM   r   )r$  r  r%  r/   r&  r  r  r  r'  r  r(  r`  r)  r  rM   zIO[Any])rM   builtins.bytes).......)r?  r/   r$  r   r%  r/   r&  r  r  r  r'  r  r(  r`  r)  r  rM   Iterator[str])......)r?  r/   r$  r   r%  r/   r&  r  r  r  r'  r  r(  r`  r)  r  rM   zIterator[builtins.bytes])r?  r/   r$  r  r%  r/   r&  r  r  r  r'  r  r(  r`  r)  r  rM   zIterator[str | builtins.bytes])F)r<  r  rK  r`  rM   r  )NN)r&  r  r  r  rM   r  )rX  r  r&  r  r  r  rY  r  rK  r`  rM   r  )NNT)r&  r  r  r  r]  r`  rM   	list[str])rZ   r  r&  r  r  r  rK  r`  rZ   zIterable[str]rM   r  )rn  r  rM   zhashlib._Hash)rM   r`  )rb   r  rM   r`  )rM   r.   )r1   float | datetime.datetimerM   r  )rM   r/   )rM   zmasks.Permissions)
r$  r/   r  
int | Noner  r`  r  r`  rM   r`  )r  r`  rM   os.stat_result)rM   r  )r  r`  rM   r  )rM   zos.statvfs_result)r   r  rM   r/   )r  ,tuple[int, int] | tuple[float, float] | Noner  r  r  r`  rM   r   )
r  r  rq   ztuple[int, int]r  r  r  r`  rM   r   )r$  r  rM   r   )r  )r  r  r  r  rM   r   )rl  r  rM   r   )r  r  rM   r   )i  )r$  r/   rM   r   )r  r  rM   r  )r   r  rM   r   )r  r  r#  r`  rM   r  )r&  r  rM   r   )r0  r  r  r`  rM   r   )r0  r  r  r`  rM   r  )r0  r  r;  r`  r<  z_IgnoreFn | Noner=  _CopyFnr>  r`  r?  r`  rM   r   )r0  r  r=  r  rM   r   )
rI  r`  rJ  _OnErrorCallbackrF  r  r  r  rM   r  ).)rI  r`  rF  z_OnExcCallback | Noner  r  rM   r  )rJ  _OnErrorCallback | Noner  r  rM   r  )rI  r`  rJ  r  r  r  rM   r  )rJ  r  rM   r  )rI  r`  rJ  r  rM   r  )r0  r  r;  r`  r=  r  r<  	_IgnoreFn)...)rl  r  r   r  rm  r/   rM   r   )
rp  r  rl  r  r   r  rm  r/   rM   r   )rp  r  rM   r   )rw  r  NNNN)r$  r  r%  r/   r&  r  r  r  r'  r  r~  r  rM   z!Iterator[tuple[IO[Any], IO[Any]]])rM   z'Callable[[str | None], SpecialResolver])r9   r:   r;   rO   r   r   r]   __annotations__r`   rC   rf   classmethodrG   	lru_cacherr   r   ClassPropertyru   ry   r{   r~   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   propertyr   r   r   r   r   r   r   r   r   r   r   r   multimethodr   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r!  r   r*  r<  r@  rL  rN  rQ  rY  rZ  rZ   rc  staticmethodrb  ri  rq  rh  rw  ry  r{  r   r   r  r  r  r  r  r  setterr  r  r  r  r  r  r?  r  r  r  r  rV  platformr  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r  r
  r  r  r  r  r  r  unlink_pr  r  r$  r"  r(  r*  r.  r2  r5  r7  r9  r-  r@  rB  version_inforK  rW  r   cdrd  ri  rn  r  contextmanagerr  r  __classcell__rc   s   @r3   r#   r#      sh    FJ 
+
 .  .   >75==
      , ,;<<<>>;<9  2  
($ ' ' 	 	  F/
>/" 	@ 	@#$3#$)PK 	>	? 3;(D(D,/(D	9(DTLM
 EI22&A2	2*;"<*  !" !36		 	 		
 	 	 	 1	 
	 	 
 36		 	 		
 	 	 	 1	 
	 	  %(36	$	 "	 		
 	 	 	 1	 
	 	  %(36	#	 "	 		
 	 	 	 1	 
	 	  %(36	#	 "	 		
 	 	 	 1	 
	 	  36		 	 		
 	 	 	 1	 
	 	  " !36		 	 		
 	 	 	 1	 
	 	+
  !" !36

 
 	

 
 
 
 
 1
 

 
 
 " !36
'
' 
' 	
'
 
' 
' 
' 
' 1
' 
"
' 
' 
 " !36
-
- 
- 	
-
 
- 
- 
- 
- 1
- 
(
- 
-@"  $ jj>/>/ >/ 	>/
 >/ >/ 
>/D  $!	'' ' 	'
 
'4  $	7 77 7 	7 7: F F%	.1'('(()1*=  & \\ *=    \\ *  )   6 6$ "# $

 	

 
 
 

0 /3 	>	 ||w	+*	3     ||w37 	-	$	+  ?C " $; 	
  
   ?C
 " $; 	
   
 & ||w	 %
%
 
J




 FH)6)L@ =A 

 =A D =A D 9= Y :> 
 #'!').#

 
 !	

 
 #'
 
 

* 7=ll /
 7"	 !$		 &	
 	 	 	 
	 
 #&	
 !$		 &		
 	 	 	 
	 
 #&	 ,/!$		 )		
 	 	 
	 
		W	$ 
 04	 "&		,	 		
 	 
	 
 03	
 "%		 -	
 	 	 
	 
M 
M	JM	!%	0G		 
	-
 ..H..H..H;;&&DLLL((EM..H;;&&DL]]**FN 
B
 - 
 "(4- -  - 
 -  - d ||w	 ||ww& "%"% #	   	
    "%"% #   	
    , ,< <	  #!"'+O!O! O! 	O!
 O! O! %O! 
+O! O!b 7  7r5   r#   c                  <    e Zd Zeej
                  dd              Zy)r  c               #     K   	 d  y # t         $ r6} | j                  t        j                  k(  rt        | j                   |  d } ~ ww xY wwr@   )r|  errno	ENOTEMPTYr  r4  )r
  s    r3   r  zDirectoryNotEmpty.translate&  sA     	 	yyEOO+'2;	s$   A	 A	A1AAAN)rM   zIterator[None])r9   r:   r;   r  r  r  r  r<   r5   r3   r  r  %  s"      r5   r  c                D     t        j                         d fd       }|S )zg
    Wrap a copy function (like shutil.copy2) to return
    the dst if it's newer than the source.
    c                    t        |       }t        |      }|j                         xr! |j                         |j                         k\  }|r|S  | |      S r@   )r#   r{  r  )srcr0  src_pdst_pis_newer_dst	copy_funcs        r3   wrapperzonly_newer.<locals>.wrapper7  sM    S	S	||~N%..*:enn>N*NJc""r5   )r  r  r0  r  )rG   wraps)r  r  s   ` r3   
only_newerr  1  s'     __Y#  # Nr5   c                      e Zd ZdZddZy)
ExtantPathz
    >>> ExtantPath('.')
    ExtantPath('.')
    >>> ExtantPath('does-not-exist')
    Traceback (most recent call last):
    OSError: does-not-exist does not exist.
    c                @    | j                         st        |  d      y )Nz does not exist.)r{  r|  ri   s    r3   rf   zExtantPath._validateL  s#    {{}TF"2344 r5   Nr  r9   r:   r;   rO   rf   r<   r5   r3   r  r  C  s    5r5   r  c                      e Zd ZdZddZy)
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.
    c                @    | j                         st        |  d      y )Nz does not exist as a file.)r   r  ri   s    r3   rf   zExtantFile._validate[  s#    ||~#tf,F$GHH r5   Nr  r  r<   r5   r3   r  r  Q  s    Ir5   r  c                  p    e Zd ZU ded<   ded<    G d d      Z	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 ddZdd	Zdd
Zy)r  rn   
path_classr	   r  c                  2    e Zd ZU ded<   ded<   ddZd	dZy)
SpecialResolver.ResolverScoper  pathsr  scopec                     || _         || _        y r@   )r  r  )rB   r  r  s      r3   rC   z&SpecialResolver.ResolverScope.__init__h  s    DJDJr5   c                N    | j                   j                  | j                  |      S r@   )r  get_dirr  )rB   class_s     r3   __getattr__z)SpecialResolver.ResolverScope.__getattr__l  s    ::%%djj&99r5   N)r  r  r  r  rM   r  )r  r  rM   _MultiPathType)r9   r:   r;   r  rC   r  r<   r5   r3   ResolverScoper  d  s    
		:r5   r  Nc                r    t        j                  d      }|| _        |j                  |||||      | _        y )Nappdirs)appname	appauthorversionroaming	multipath)	importlibimport_moduler  AppDirsr  )rB   r  r  r  r  r  r  r  s           r3   rC   zSpecialResolver.__init__o  s?     )))4$ ' 
r5   c                &    | j                  | |      S r@   )r  )rB   r  s     r3   r  zSpecialResolver.__getattr__  s    !!$..r5   c                    | d| d}t        | j                  |      }t        j                  | j                        }|j                  |      S )zs
        Return the callable function from appdirs, but with the
        result wrapped in self.path_class
        rl   _dir)r  r  Multi	for_classr  detect)rB   r  r  	prop_namer1   	MultiPaths         r3   r  zSpecialResolver.get_dir  sI    
 gQvhd+	i0OODOO4	&&r5   )NNNFF)r  rn   r  r  r  r  r  r  r  r`  r  r`  )r  r  rM   r  )r  r  r  r  rM   r  )r9   r:   r;   r  r  rC   r  r  r<   r5   r3   r  r  `  sr    	: 	: # $"

 
 	

 
 
 
&/'r5   r  c                  l    e Zd ZdZedd       Zedd       Zd	dZej                  ed
d              Z
y)r  zS
    A mix-in for a Path which may contain multiple Path separated by pathsep.
    c                >    d|j                   z   }t        || |fi       S )Nr  rm   )ra   path_clsr   s      r3   r  zMulti.for_class  s%    ***D3/2..r5   c                N    t         j                  |vr| j                  }  | |      S r@   )r   pathsepru   )ra   inputs     r3   r  zMulti.detect  s!    ::U"//C5zr5   c                z    t        t        | j                  | j                  t        j
                                    S r@   )rF  mapru   r   r   r  ri   s    r3   __iter__zMulti.__iter__  s'    C(($**RZZ*@ABBr5   c                :    t        d | j                  D              S )z>
        Multi-subclasses should use the parent class
        c              3  B   K   | ]  }t        |t              r|  y wr@   )
issubclassr  )rV   r  s     r3   rX   z$Multi._next_class.<locals>.<genexpr>  s     VvJvu<UFr  )next__mro__rt   s    r3   ru   zMulti._next_class  s     VVVVr5   N)r  rn   rM   ztype[_MultiPathType])r  r  rM   r  )rM   rN   rM   z
type[Path])r9   r:   r;   rO   r  r  r  r  r   r  ru   r<   r5   r3   r  r    sY     / /  
C W  Wr5   r  c                      e Zd Zy)r  Nr8   r<   r5   r3   r  r    r=   r5   r  c                  l     e Zd ZdZej
                  edd              Zd fdZd	dZ	ddZ
d	dZ xZS )
r$   as  
    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`
    c                    t         S r@   )r#   rt   s    r3   ru   zTempDir._next_class  s	     r5   c                N    t        j                  |i |}t        |   | |      S r@   )tempfilemkdtempr_   r`   )ra   r4  r5  r   rc   s       r3   r`   zTempDir.__new__  s)    ""D3F3wsG,,r5   c                     y r@   r<   r3  s      r3   rC   zTempDir.__init__  rj   r5   c                $    | j                  |       S r@   )ru   ri   s    r3   r   zTempDir.__enter__  s    
 %%r5   c                $    | j                          y r@   )rK  r   s     r3   r   zTempDir.__exit__  s    r5   r  r  r  )r9   r:   r;   rO   r   r  r  ru   r`   rC   r   r   r  r  s   @r3   r$   r$     s>    &   -&r5   r$   c                  T    e Zd Zedd       Zedd       Zedd       Zedd       Zy)	r  c                      r@   r<   msgs    r3   r  zHandlers.strict  s    r5   c                <    t        j                  | t        d       y )N   )
stacklevel)warningswarnr7   r  s    r3   r  zHandlers.warn  s    c?q9r5   c                     y r@   r<   r  s    r3   r<  zHandlers.ignore  s    r5   c                    d}t        |t              r?|t        |       vrt        |      | j                  | j
                  | j                  d|   S t        |      st        |      |S )Nzinvalid errors parameter)r  r  r<  )r-   r  varsr   r  r  r<  callable)ra   paramr  s      r3   r  zHandlers._resolve  s\    (eS!DI% o%!jj#((cjjQRWXXE? o%Lr5   N)r  r  rM   r   )r  r  rM   r  )r  zstr | Callable[[str], None]rM   zCallable[[str], None])	r9   r:   r;   r  r  r  r<  r  r  r<   r5   r3   r  r    sP      : :   	 	r5   r  )r1   r  rM   r/   r  )r  r  rM   r  )erO   
__future__r   builtinsr  datetimer  r  rG   r  rk  r  rb  r   r  rer-  rV  r  r  ior   r   r   r   r   typesr	   r  ImportErrorr  r  r  collections.abcr
   r   r   typingr   r   r   r   r   r   r   	_typeshedr   r   r   r   r   r   typing_extensionsr   r   r   r  r`  r  objectr  r   r  r  BaseException_OnExcCallbackrR   r   r   r    compat.py38r!   r"   __all__LINESEPS
U_LINESEPScompiler   rU  	B_NEWLINErT  r  B_NL_ENDrS   _default_linesepr4   Warningr7   r%   r[   r#   r|  r  r  r  r  r  r  r  r$   r  r<   r5   r3   <module>r      s  0 #           	  	  
    Z% & Z% & Z% & : 9    763#-t34FSz6)*G#tCy)8C=89I#s(!3S' BF JKxS13FNON ' & 3
*66
BJJsxx)0023	BJJsxx
+,	2::i''$./2::i''#-.8 $
	g 	#< #<L6@73 @7F4	 	$5 5I I-' -'`W W8	UD 	(d (V M= &% &% &%s$   3I7J1J7JJJ