o
    Uh!.                     @   s   d 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 ddlmZ ddlmZ dgZdd	 Zd
d ZejZ	 dd ZG dd dZG dd dee	jZG dd deZdddZG dd dZdS )z
A Path-like interface for zipfiles.

This codebase is shared between zipfile.Path in the stdlib
and zipp in PyPI. See
https://github.com/python/importlib_metadata/wiki/Development-Methodology
for more detail.
    N   )text_encoding)
Translator)save_method_argsPathc                 C   s   t 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(''))
    []
    r   N)	itertoolsislice	_ancestry)path r   a/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/zipp/__init__.py_parents   s   r   c                 c   sB    |  tj} |  tjr| V  t| \} }|  tjsdS dS )a  
    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(''))
    []

    Multiple separators are treated like a single.

    >>> list(_ancestry('//b//d///f//'))
    ['//b//d///f', '//b//d', '//b']
    N)rstrip	posixpathsepsplit)r
   tailr   r   r   r	   0   s   r	   c                 C   s   t t|j| S )zZ
    Return items in minuend not in subtrahend, retaining order
    with O(1) lookup.
    )r   filterfalseset__contains__)minuend
subtrahendr   r   r   _differenceO   s   r   c                       s8   e Zd ZdZe fddZdd Z fddZ  ZS )InitializedStatez?
    Mix-in to save the initialization state for pickling.
    c                    s   t  j|i | d S Nsuper__init__)selfargskwargs	__class__r   r   r   \      zInitializedState.__init__c                 C   s   | j j| j jfS r   )_saved___init__r   r    r   r   r   r   __getstate__`      zInitializedState.__getstate__c                    s   |\}}t  j|i | d S r   r   )r   stater   r    r!   r   r   __setstate__c   s   zInitializedState.__setstate__)	__name__
__module____qualname____doc__r   r   r&   r)   __classcell__r   r   r!   r   r   W   s    r   c                       sn   e Zd ZdZedd Z fddZdd Zdd	 Z fd
dZ	e
dd Ze
dejdejfddZ  ZS )CompleteDirsa8  
    A ZipFile subclass that ensures that implied directories
    are always included in the namelist.

    >>> list(CompleteDirs._implied_dirs(['foo/bar.txt', 'foo/bar/baz.txt']))
    ['foo/', 'foo/bar/']
    >>> list(CompleteDirs._implied_dirs(['foo/bar.txt', 'foo/bar/baz.txt', 'foo/bar/']))
    ['foo/']
    c                 C   s.   t jtt| }dd |D }tt|| S )Nc                 s   s    | ]}|t j V  qd S r   )r   r   ).0pr   r   r   	<genexpr>v   s    z-CompleteDirs._implied_dirs.<locals>.<genexpr>)r   chainfrom_iterablemapr   _deduper   )namesparentsas_dirsr   r   r   _implied_dirss   s   zCompleteDirs._implied_dirsc                    s   t   }|t| | S r   )r   namelistlistr:   )r   r7   r!   r   r   r;   y   s   
zCompleteDirs.namelistc                 C   s   t |  S r   )r   r;   r%   r   r   r   	_name_set}   s   zCompleteDirs._name_setc                 C   s,   |   }|d }||vo||v }|r|S |S )zx
        If the name represents a directory, return that name
        as a directory (with the trailing slash).
        /)r=   )r   namer7   dirname	dir_matchr   r   r   resolve_dir   s   zCompleteDirs.resolve_dirc                    sF   zt  |W S  ty"   |dr||  vr tj|d Y S w )z6
        Supplement getinfo for implied dirs.
        r>   )filename)r   getinfoKeyErrorendswithr=   zipfileZipInfo)r   r?   r!   r   r   rD      s   zCompleteDirs.getinfoc                 C   s:   t |tr|S t |tjs| |S d|jvrt} | |_|S )zl
        Given a source (filename or zipfile), return an
        appropriate CompleteDirs subclass.
        r)
isinstancer/   rG   ZipFilemoder"   )clssourcer   r   r   make   s   

zCompleteDirs.makezfreturnc                 C   s$   |  | D ]}||d q|S )z
        Given a writable zip file zf, inject directory entries for
        any directories implied by the presence of children.
            )r:   r;   writestr)rM   rP   r?   r   r   r   inject   s   zCompleteDirs.inject)r*   r+   r,   r-   staticmethodr:   r;   r=   rB   rD   classmethodrO   rG   rK   rT   r.   r   r   r!   r   r/   h   s    



 r/   c                       sH   e Zd ZdZdd Zej fddZdd Zej fdd	Z	  Z
S )

FastLookupzV
    ZipFile subclass to ensure implicit
    dirs exist and are resolved rapidly.
    c                 C      | j S r   )	_namelistr%   r   r   r   r;         zFastLookup.namelistc                    
   t   S r   )r   r;   r%   r!   r   r   rY         
zFastLookup._namelistc                 C   rX   r   )_name_set_propr%   r   r   r   r=      rZ   zFastLookup._name_setc                    r[   r   )r   r=   r%   r!   r   r   r]      r\   zFastLookup._name_set_prop)r*   r+   r,   r-   r;   	functoolscached_propertyrY   r=   r]   r.   r   r   r!   r   rW      s    rW   c                 O   s$   t jjdk}d| }t| |||fS )Npypy   )sysimplementationr?   r   )encodingr   r    is_pypystack_levelr   r   r   _extract_text_encoding   s   rg   c                   @   s  e Zd ZdZdZd=ddZdd Zdd	 Zd>ddddZdd Z	e
dd Ze
dd Ze
dd Ze
dd Ze
dd Zdd Zdd Zdd  Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 Zd1d2 Zd3d4 Zd5d6 Zd7d8 Zd9d: ZeZ e
d;d< Z!dS )?r   u$  
    A :class:`importlib.resources.abc.Traversable` interface for zip files.

    Implements many of the features users enjoy from
    :class:`pathlib.Path`.

    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 = 'mem/abcde.zip'

    Path accepts the zipfile object itself or a filename

    >>> path = Path(zf)

    From there, several path operations are available.

    Directory iteration (including the zip file itself):

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

    name property:

    >>> b.name
    'b'

    join with divide operator:

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

    Read text:

    >>> c.read_text(encoding='utf-8')
    'content of c'

    existence:

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

    Coercion to string:

    >>> import os
    >>> str(c).replace(os.sep, posixpath.sep)
    'mem/abcde.zip/b/c.txt'

    At the root, ``name``, ``filename``, and ``parent``
    resolve to the zipfile.

    >>> str(path)
    'mem/abcde.zip/'
    >>> path.name
    'abcde.zip'
    >>> path.filename == pathlib.Path('mem/abcde.zip')
    True
    >>> str(path.parent)
    'mem'

    If the zipfile has no filename, such attributes are not
    valid and accessing them will raise an Exception.

    >>> zf.filename = None
    >>> path.name
    Traceback (most recent call last):
    ...
    TypeError: ...

    >>> path.filename
    Traceback (most recent call last):
    ...
    TypeError: ...

    >>> path.parent
    Traceback (most recent call last):
    ...
    TypeError: ...

    # workaround python/cpython#106763
    >>> pass
    z>{self.__class__.__name__}({self.root.filename!r}, {self.at!r}) c                 C   s   t || _|| _dS )aX  
        Construct a Path from a ZipFile or filename.

        Note: When the source is an existing ZipFile object,
        its type (__class__) will be mutated to a
        specialized type. If the caller wishes to retain the
        original type, the caller should either create a
        separate ZipFile object or pass a filename.
        N)rW   rO   rootat)r   ri   rj   r   r   r   r   8  s   

zPath.__init__c                 C   s(   | j |j urtS | j| jf|j|jfkS )zU
        >>> Path(zipfile.ZipFile(io.BytesIO(), 'w')) == 'foo'
        False
        )r"   NotImplementedri   rj   )r   otherr   r   r   __eq__E  s   zPath.__eq__c                 C   s   t | j| jfS r   )hashri   rj   r%   r   r   r   __hash__N  r'   zPath.__hash__rI   Npwdc                O   s   |   rt| |d }|dkr|  st| | jj| j||d}d|v r0|s*|r.td|S t|i |\}}}t	j
||g|R i |S )z
        Open this entry as text or binary following the semantics
        of ``pathlib.Path.open()`` by passing arguments through
        to io.TextIOWrapper().
        r   rI   rp   bz*encoding args invalid for binary operation)is_dirIsADirectoryErrorexistsFileNotFoundErrorri   openrj   
ValueErrorrg   ioTextIOWrapper)r   rL   rq   r   r    zip_modestreamrd   r   r   r   rw   Q  s   z	Path.openc                 C   s   t | jp| jjS r   )pathlibPurePosixPathrj   ri   rC   r%   r   r   r   _basee     z
Path._basec                 C   
   |   jS r   )r   r?   r%   r   r   r   r?   h  r\   z	Path.namec                 C   r   r   )r   suffixr%   r   r   r   r   l  r\   zPath.suffixc                 C   r   r   )r   suffixesr%   r   r   r   r   p  r\   zPath.suffixesc                 C   r   r   )r   stemr%   r   r   r   r   t  r\   z	Path.stemc                 C   s   t | jj| jS r   )r}   r   ri   rC   joinpathrj   r%   r   r   r   rC   x  r#   zPath.filenamec                 O   sZ   t |i |\}}}| jd|g|R i |}| W  d    S 1 s&w   Y  d S )NrI   )rg   rw   read)r   r   r    rd   strmr   r   r   	read_text|  s   $zPath.read_textc                 C   s6   |  d}| W  d    S 1 sw   Y  d S )Nrb)rw   r   )r   r   r   r   r   
read_bytes  s   $zPath.read_bytesc                 C   s   t |jd| jdkS Nr>   )r   r@   rj   r   )r   r
   r   r   r   	_is_child  s   zPath._is_childc                 C   s   |  | j|S r   )r"   ri   )r   rj   r   r   r   _next     z
Path._nextc                 C   s   | j  p	| j dS r   )rj   rF   r%   r   r   r   rs     r   zPath.is_dirc                 C   s   |   o|   S r   )ru   rs   r%   r   r   r   is_file     zPath.is_filec                 C   s   | j | j v S r   )rj   ri   r=   r%   r   r   r   ru     r'   zPath.existsc                 C   s.   |   stdt| j| j }t| j|S )NzCan't listdir a file)rs   rx   r5   r   ri   r;   filterr   )r   subsr   r   r   iterdir  s   zPath.iterdirc                 C   s   t | j|S r   )r}   r~   rj   match)r   path_patternr   r   r   r     r   z
Path.matchc                 C   s"   | j | j}|jd? }t|S )z8
        Return whether this path is a symlink.
           )ri   rD   rj   external_attrstatS_ISLNK)r   inforL   r   r   r   
is_symlink  s   

zPath.is_symlinkc                 C   sV   |s	t d|t| j}tdd}t||| j}t| j	t
|| j S )NzUnacceptable pattern: r>   )seps)rx   reescaperj   r   compile	translate	fullmatchr5   r   r   ri   r;   )r   patternprefixtrmatchesr   r   r   glob  s   
z	Path.globc                 C   s   |  d| S )Nz**/)r   )r   r   r   r   r   rglob  r'   z
Path.rglobc                 G   s   t t| t|j| S r   )r   relpathstrr   )r   rl   extrar   r   r   relative_to  s   zPath.relative_toc                 C   s   t | jj| jS r   )r   joinri   rC   rj   r%   r   r   r   __str__  r   zPath.__str__c                 C   s   | j j| dS )Nr%   )_Path__reprformatr%   r   r   r   __repr__  r   zPath.__repr__c                 G   s&   t j| jg|R  }| | j|S r   )r   r   rj   r   ri   rB   )r   rl   nextr   r   r   r     s   zPath.joinpathc                 C   s6   | j s| jjS t| j d}|r|d7 }| |S r   )rj   rC   parentr   r@   r   r   )r   	parent_atr   r   r   r     s   
zPath.parent)rh   )rI   )"r*   r+   r,   r-   r   r   rm   ro   rw   r   propertyr?   r   r   r   rC   r   r   r   r   rs   r   ru   r   r   r   r   r   r   r   r   r   __truediv__r   r   r   r   r   r      sJ    f
	




	r   )r-   r^   ry   r   r}   r   r   r   rb   rG   compat.py310r   r   r   
_functoolsr   __all__r   r	   dictfromkeysr6   r   r   rK   r/   rW   rg   r   r   r   r   r   <module>   s0    	K
