o

��f�@s�dd
lm
Z

ddlZddlZddlZddlZddlZddlZddlZddl	Z	e
Zdd�Zdd�Z
Gdd�d�ZGd	d
�d
�ZdS)�)
�divisionNc

Cst�
t|�
d
d�S)a2

    Given a path with elements separated by
    posixpath.sep, generate all parents of that path.

    >>> list(_parents('b/d'))
    ['b']
    >>> list(_parents('/b/d/'))
    ['/b']
    >>> list(_parents('b/d/f/'))
    ['b/d', 'b']
    >>> list(_parents('b'))
    []
    >>> list(_parents(''))
    []
    �
N)�	itertools�islice�	_ancestry�
�path�r	�&/usr/lib/python3/dist-packages/zipp.py�_parentssrc
csN�|�t
j�
}|r!|t
jkr%|V
t
�|�
\}}
|r#|t
jksd
Sd
Sd
Sd
S)aR

    Given a path with elements separated by
    posixpath.sep, generate all elements of that path

    >>> list(_ancestry('b/d'))
    ['b/d', 'b']
    >>> list(_ancestry('/b/d/'))
    ['/b/d', '/b']
    >>> list(_ancestry('b/d/f/'))
    ['b/d/f', 'b/d', 'b']
    >>> list(_ancestry('b'))
    ['b']
    >>> list(_ancestry(''))
    []
    N)�rstrip�	posixpath�sep�split)r�tailr	r	r
r%s�


�rcs,eZ
dZd
Z�f
dd�Zedd��
Z�ZS)�SanitizedNamesz7
    ZipFile mix-in to ensure names are sanitized.
    c

stt
|jt�����
S�
N)�list�map�	_sanitize�super�namelist�
�self�
�	__class__r	r
r?s
zSanitizedNames.namelistc
Cs`d
d�}
tj
dd|tjd�}|�dd�}|�d�
}d�t|
|��
}|s'td�
�
|d|�d�
S)	a]
        Ensure a relative path with posix separators and no dot names.
        Modeled after
        https://github.com/python/cpython/blob/bcc1be39cb1d04ad9fc0bd1b9193d3972835a57c/Lib/zipfile/__init__.py#L1799-L1813
        but provides consistent cross-platform behavior.
        >>> san = SanitizedNames._sanitize
        >>> san('/foo/bar')
        'foo/bar'
        >>> san('//foo.txt')
        'foo.txt'
        >>> san('foo/.././bar.txt')
        'foo/bar.txt'
        >>> san('foo../.bar.txt')
        'foo../.bar.txt'
        >>> san('\\foo\\bar.txt')
        'foo/bar.txt'
        >>> san('D:\\foo.txt')
        'D/foo.txt'
        >>> san('\\\\server\\share\\file.txt')
        'server/share/file.txt'
        >>> san('\\\\?\\GLOBALROOT\\Volume3')
        '?/GLOBALROOT/Volume3'
        >>> san('\\\\.\\PhysicalDrive1\\root')
        'PhysicalDrive1/root'
        Retain any trailing slash.
        >>> san('abc/')
        'abc/'
        Raises a ValueError if the result is empty.
        >>> san('../..')
        Traceback (most recent call last):
        ...
        ValueError: Empty filename
        c

Ss|o|d
v
S)N>�..�
.r	)
�partr	r	r
�allowedf�
z)SanitizedNames._sanitize.<locals>.allowedz	^([A-Z]):z\1)
�flags�
\�
/zEmpty filename)	�re�sub�
IGNORECASE�replacer�join�filter�
ValueError�endswith)�namer�bare�clean�parts�joinedr	r	r
rBs$






zSanitizedNames._sanitize)�__name__�
__module__�__qualname__�__doc__r�staticmethodr�
__classcell__r	r	rr
r:s


rc@s�eZ
dZd
ZdZd,dd�
Zedd��
Zedd	��
Z	ed
d��
Z
dd
�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd d!�ZeZed"d#��
Zed$d%��
Zed&d'��
Zd(d)�Zejd*krleZd+Sd+S)-�Pathu�
    A pathlib-compatible interface for zip files.

    Consider a zip file with this structure::

        .
        ├── a.txt
        └── b
            ├── c.txt
            └── d
                └── e.txt

    >>> data = io.BytesIO()
    >>> zf = zipfile.ZipFile(data, 'w')
    >>> zf.writestr('a.txt', 'content of a')
    >>> zf.writestr('b/c.txt', 'content of c')
    >>> zf.writestr('b/d/e.txt', 'content of e')
    >>> zf.filename = 'abcde.zip'

    Path accepts the zipfile object itself or a filename

    >>> root = Path(zf)

    From there, several path operations are available.

    Directory iteration (including the zip file itself):

    >>> a, b = root.iterdir()
    >>> a
    Path('abcde.zip', 'a.txt')
    >>> b
    Path('abcde.zip', 'b/')

    name property:

    >>> b.name
    'b'

    join with divide operator:

    >>> c = b / 'c.txt'
    >>> c
    Path('abcde.zip', 'b/c.txt')
    >>> c.name
    'c.txt'

    Read text:

    >>> c.read_text()
    'content of c'

    existence:

    >>> c.exists()
    True
    >>> (b / 'missing.txt').exists()
    False

    Coercion to string:

    >>> str(c)
    'abcde.zip/b/c.txt'
    z>{self.__class__.__name__}({self.root.filename!r}, {self.at!r})�cCs,t|
t
j�r|
nt
�|�|
�
�
|_||_dSr)�
isinstance�zipfile�ZipFile�_pathlib_compat�root�at)rr=r>r	r	r
�__init__�s

��
z
Path.__init__c

Cs&z|��WSt
y


t|�
YSw)
zu
        For path-like objects, convert to a filename for compatibility
        on Python 3.6.1 and earlier.
        )�
__fspath__�AttributeError�strrr	r	r
r<�s




�zPath._pathlib_compatc

C�t�
|jj|j�Sr)�	functools�partialr=�openr>rr	r	r
rF��z	Path.openc

Cst�
|j�d
�
�
S�Nr#)r
�basenamer>rrr	r	r
r,�rGz	Path.namec
OsH|���}t
j|g
|
�
Ri|�
�
��Wd�
S1sw



Y
dSr)rF�io�
TextIOWrapper�read)r�args�kwargs�strmr	r	r
�	read_text�s


$�zPath.read_textc
Cs4|���}
|
�
�Wd�
S1sw



Y
dSr)rFrL)rrOr	r	r
�
read_bytes�s


$�zPath.read_bytescCst�
|
j�d
�
�
|j�d
�
kSrH)r
�dirnamer>r)rrr	r	r
�	_is_child�s
zPath._is_childcCst|j
|
�Sr)r7r=)rr>r	r	r
�_next�r z
Path._nextc

Cs|jp	|j�
d
�
SrH)r>r+rr	r	r
�is_dir�s
zPath.is_dirc

Cs
|��Sr)
rUrr	r	r
�is_file�s

zPath.is_filec

Cs|j|�
�vSr)r>�_namesrr	r	r
�exists��
zPath.existsc
Cs,|��st
d
�
�
t|j|���}
t|j|
�S)NzCan't listdir a file)rUr*rrTrWr)rS)r�subsr	r	r
�iterdir�s



zPath.iterdirc

CrCr)r
r(r=�filenamer>rr	r	r
�__str__�s
zPath.__str__c

Cs|jj
|d
�
S)Nr)�_Path__repr�formatrr	r	r
�__repr__�rYz
Path.__repr__cCsP|�|
�
}
t
�|j|
�}t
�|j|
d
�}|��}|�||v
r%||vr%|�
S|�
S)Nr8)r<r
r(r>rWrT)r�add�next�next_dir�namesr	r	r
�joinpath�s





 
z
Path.joinpathc

st�
�f
d
d��D�
�
S)Nc
3s2�|]}
t|
�
D]
}|d�v
r|dV
qqd
S)r#N)
r)�.0r,�parent�
rdr	r
�	<genexpr>�s�
�
��z%Path._implied_dirs.<locals>.<genexpr>)�more_itertools�unique_everseenrhr	rhr
�
_implied_dirs�s�zPath._implied_dirscCs|
t|�
|
�
�
Sr)rrl)�clsrdr	r	r
�_add_implied_dirs
rGzPath._add_implied_dirsc
Cs(t�
|j�d
�
�
}
|
r|
d
7}
|�|
�
SrH)r
rRr>rrT)r�	parent_atr	r	r
rg

s



zPath.parentc

Cs|�t
ttj|j����
�
Sr)rnrrrrr=rrr	r	r
rW
s
zPath._names)
�N)
r8)r1r2r3r4r^r?r5r<�propertyrFr,rPrQrSrTrUrVrXr[r]r`re�__truediv__rl�classmethodrnrgrW�sys�version_info�__div__r	r	r	r
r7ss@
@















�r7)�
__future__rrJrtr
r:rDrr$rj�type�
__metaclass__rrrr7r	r	r	r
�<module>
s





9