File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/zipp.tar
Back
glob.py 0000644 00000006012 15030222101 0006022 0 ustar 00 import os import re _default_seps = os.sep + str(os.altsep) * bool(os.altsep) class Translator: """ >>> Translator('xyz') Traceback (most recent call last): ... AssertionError: Invalid separators >>> Translator('') Traceback (most recent call last): ... AssertionError: Invalid separators """ seps: str def __init__(self, seps: str = _default_seps): assert seps and set(seps) <= set(_default_seps), "Invalid separators" self.seps = seps def translate(self, pattern): """ Given a glob pattern, produce a regex that matches it. """ return self.extend(self.translate_core(pattern)) def extend(self, pattern): r""" Extend regex for pattern-wide concerns. Apply '(?s:)' to create a non-matching group that matches newlines (valid on Unix). Append '\Z' to imply fullmatch even when match is used. """ return rf'(?s:{pattern})\Z' def translate_core(self, pattern): r""" Given a glob pattern, produce a regex that matches it. >>> t = Translator() >>> t.translate_core('*.txt').replace('\\\\', '') '[^/]*\\.txt' >>> t.translate_core('a?txt') 'a[^/]txt' >>> t.translate_core('**/*').replace('\\\\', '') '.*/[^/][^/]*' """ self.restrict_rglob(pattern) return ''.join(map(self.replace, separate(self.star_not_empty(pattern)))) def replace(self, match): """ Perform the replacements for a match from :func:`separate`. """ return match.group('set') or ( re.escape(match.group(0)) .replace('\\*\\*', r'.*') .replace('\\*', rf'[^{re.escape(self.seps)}]*') .replace('\\?', r'[^/]') ) def restrict_rglob(self, pattern): """ Raise ValueError if ** appears in anything but a full path segment. >>> Translator().translate('**foo') Traceback (most recent call last): ... ValueError: ** must appear alone in a path segment """ seps_pattern = rf'[{re.escape(self.seps)}]+' segments = re.split(seps_pattern, pattern) if any('**' in segment and segment != '**' for segment in segments): raise ValueError("** must appear alone in a path segment") def star_not_empty(self, pattern): """ Ensure that * will not match an empty segment. """ def handle_segment(match): segment = match.group(0) return '?*' if segment == '*' else segment not_seps_pattern = rf'[^{re.escape(self.seps)}]+' return re.sub(not_seps_pattern, handle_segment, pattern) def separate(pattern): """ Separate out character sets to avoid translating their contents. >>> [m.group(0) for m in separate('*.txt')] ['*.txt'] >>> [m.group(0) for m in separate('a[?]txt')] ['a', '[?]', 'txt'] """ return re.finditer(r'([^\[]+)|(?P<set>[\[].*?[\]])|([\[][^\]]*$)', pattern) __pycache__/__init__.cpython-310.pyc 0000644 00000037502 15030222101 0013205 0 ustar 00 o �hd4 � @ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZddl m Z ddl m Z dgZ dd� Zdd � ZejZ d d � ZG d d � d �ZG dd� d�ZG dd� deeej�ZG dd� de�Zddd�ZG dd� d�ZdS )� N� )� text_encoding)� Translator�Pathc C s t �t| �dd�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 �S/usr/local/CyberCP/lib/python3.10/site-packages/setuptools/_vendor/zipp/__init__.py�_parents s r c c sN � | � tj�} | r!| tjkr%| V t�| �\} }| r#| tjksdS dS dS dS )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 � �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 � _difference? s r c s4 e Zd ZdZ� fdd�Zdd� Z� fdd�Z� ZS )�InitializedStatez? Mix-in to save the initialization state for pickling. c s" || _ || _t� j|i |�� d S �N)�_InitializedState__args�_InitializedState__kwargs�super�__init__)�self�args�kwargs�� __class__r r r L s zInitializedState.__init__c C s | j | jfS r )r r �r r r r � __getstate__Q � z InitializedState.__getstate__c s |\}}t � j|i |�� d S r )r r )r �stater r r! r r � __setstate__T s z InitializedState.__setstate__)�__name__� __module__� __qualname__�__doc__r r$ r' � __classcell__r r r! r r G s r c s, e Zd ZdZ� fdd�Zedd� �Z� ZS )�SanitizedNamesz7 ZipFile mix-in to ensure names are sanitized. c s t t| jt� �� ��S r )�list�map� _sanitizer �namelistr# r! r r r1 ^ s zSanitizedNames.namelistc C s` dd� }t jdd| t jd�}|�dd�}|�d�}d�t||��}|s'td��|d| �d� S ) aa 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 S s | o| dvS )N> �..�.r )�partr r r �allowed� r% z)SanitizedNames._sanitize.<locals>.allowedz ^([A-Z]):z\1)�flags�\�/zEmpty filename) �re�sub� IGNORECASE�replacer �join�filter� ValueError�endswith)�namer5 �bare�clean�parts�joinedr r r r0 a s ( zSanitizedNames._sanitize)r( r) r* r+ r1 � staticmethodr0 r, r r r! r r- Y s r- c sn e Zd ZdZedd� �Z� fdd�Zdd� Zdd � Z� fd d �Z e d d � �Z e de j de j fdd��Z� ZS )� 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�tt| ��}dd� |D �}tt|| ��S )Nc s s � | ]}|t j V qd S r )r r )�.0�pr r r � <genexpr>� s � z-CompleteDirs._implied_dirs.<locals>.<genexpr>)r �chain� from_iterabler/ r �_deduper )�names�parents�as_dirsr r r � _implied_dirs� s zCompleteDirs._implied_dirsc s t � �� }|t| �|�� S r )r r1 r. rQ )r rN r! r r r1 � s zCompleteDirs.namelistc C s t | �� �S r )r r1 r# r r r � _name_set� r% zCompleteDirs._name_setc C s, | � � }|d }||vo||v }|r|S |S )zx If the name represents a directory, return that name as a directory (with the trailing slash). r8 )rR )r rA rN �dirname� dir_matchr r r � resolve_dir� s zCompleteDirs.resolve_dirc sF zt � �|�W S ty" |�d�r|| �� vr� tj|d� Y S w )z6 Supplement getinfo for implied dirs. r8 ��filename)r �getinfo�KeyErrorr@ rR �zipfile�ZipInfo)r rA r! r r rX � s �zCompleteDirs.getinfoc C s: t |t�r|S t |tj�s| |�S d|jvrt} | |_|S )zl Given a source (filename or zipfile), return an appropriate CompleteDirs subclass. �r)� isinstancerG rZ �ZipFile�moder" )�cls�sourcer r r �make� s zCompleteDirs.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. � )rQ r1 �writestr)r` rc rA r r r �inject� s zCompleteDirs.inject)r( r) r* r+ rF rQ r1 rR rU rX � classmethodrb rZ r^ rg r, r r r! r rG � s rG c s, e Zd ZdZ� fdd�Z� fdd�Z� ZS )� FastLookupzV ZipFile subclass to ensure implicit dirs exist and are resolved rapidly. c �B t �t�� | jW d � S 1 sw Y t� �� | _| jS r )� contextlib�suppress�AttributeError�_FastLookup__namesr r1 r# r! r r r1 � � � zFastLookup.namelistc rj r )rk rl rm �_FastLookup__lookupr rR r# r! r r rR � ro zFastLookup._name_set)r( r) r* r+ r1 rR r, r r r! r ri � s ri c O s$ t jjdk}d| }t| |�||fS )N�pypy� )�sys�implementationrA r )�encodingr r �is_pypy� stack_levelr r r �_extract_text_encoding� s rx c @ s e Zd ZdZdZd=dd�Zdd� Zdd � Zd>d d �d d�Zdd� Z e dd� �Z e dd� �Z e dd� �Z e dd� �Ze dd� �Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� 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 �|�| _|| _dS )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)ri rb �root�at)r rz r{ r r r r e s z Path.__init__c C s( | j |j urtS | j| jf|j|jfkS )zU >>> Path(zipfile.ZipFile(io.BytesIO(), 'w')) == 'foo' False )r" �NotImplementedrz r{ )r �otherr r r �__eq__r s z Path.__eq__c C s t | j| jf�S r )�hashrz r{ r# r r r �__hash__{ � z Path.__hash__r\ N��pwdc O s� | � � rt| ��|d }| �� s|dkrt| ��| jj| j||d�}d|v r0|s*|r.td��|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 r\ r� �bz*encoding args invalid for binary operation) �is_dir�IsADirectoryError�exists�FileNotFoundErrorrz �openr{ r? rx �io� TextIOWrapper)r r_ r� r r �zip_mode�streamru r r r r� ~ s z Path.openc C s t �| jp| jj�S r )�pathlib� PurePosixPathr{ rz rW r# r r r �_base� � z Path._basec C � | � � jS r )r� rA r# r r r rA � � z Path.namec C r� r )r� �suffixr# r r r r� � r� z Path.suffixc C r� r )r� �suffixesr# r r r r� � r� z Path.suffixesc C r� r )r� �stemr# r r r r� � r� z Path.stemc C s t �| jj��| j�S r )r� r rz rW �joinpathr{ r# r r r rW � s z Path.filenamec O sZ t |i |��\}}}| jd|g|�R i |��� }|�� W d � S 1 s&w Y d S )Nr\ )rx r� �read)r r r ru �strmr r r � read_text� s $�zPath.read_textc C s6 | � d�� }|�� W d � S 1 sw Y d S )N�rb)r� r� )r r� r r r � read_bytes� s $�zPath.read_bytesc C s t �|j�d��| j�d�kS �Nr8 )r rS r{ r )r r r r r � _is_child� s zPath._is_childc C s | � | j|�S r )r" rz )r r{ r r r �_next� � z Path._nextc C s | j p | j �d�S r� )r{ r@ r# r r r r� � r� z Path.is_dirc C s | � � o| �� S r )r� r� r# r r r �is_file� � z Path.is_filec C s | j | j�� v S r )r{ rz rR r# r r r r� � r� z Path.existsc C s. | � � std��t| j| j�� �}t| j|�S )NzCan't listdir a file)r� r? r/ r� rz r1 r> r� )r �subsr r r �iterdir� s z Path.iterdirc C s t �| j��|�S r )r� r� r{ �match)r � path_patternr r r r� � r� z Path.matchc C s" | j �| j�}|jd? }t�|�S )z8 Return whether this path is a symlink. � )rz rX r{ � external_attr�stat�S_ISLNK)r �infor_ r r r � is_symlink� s zPath.is_symlinkc C sb |s t d|����t�| j�}tdd�}t�||�|� �j}dd� | jj D �}t | j t ||��S )NzUnacceptable pattern: r8 )�sepsc s s � | ]}|j V qd S r rV )rH �datar r r rJ � s � z Path.glob.<locals>.<genexpr>) r? r9 �escaper{ r �compile� translate� fullmatchrz �filelistr/ r� r> )r �pattern�prefix�tr�matchesrN r 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 r} �extrar r r � relative_to� s zPath.relative_toc C s t �| jj| j�S r )r r= rz rW r{ 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| jg|�R � }| �| j�|��S r )r r= r{ r� rz rU )r r} �nextr r r r� � s z Path.joinpathc C s6 | j s| jjS t�| j �d��}|r|d7 }| �|�S r� )r{ rW �parentr rS r r� )r � parent_atr r r r� � s z Path.parent)ry )r\ )"r( r) r* r+ r� r r~ r� r� r� �propertyrA r� r� r� rW r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� � __truediv__r� r r r r r � sJ f r )r� r rZ r rk r� r9 r� rs � compat.py310r r� r �__all__r r �dict�fromkeysrM r r r- r^ rG ri rx r r r r r �<module> s. >K __pycache__/glob.cpython-310.pyc 0000644 00000007564 15030222101 0012376 0 ustar 00 o �h � @ sD d dl Z d dlZe jee j�ee j� ZG dd� d�Zdd� ZdS )� Nc @ s\ e Zd ZU dZeed< efdefdd�Zdd� Zdd� Z d d � Z d d � Z d d� Z dd� Z dS )� Translatorz� >>> Translator('xyz') Traceback (most recent call last): ... AssertionError: Invalid separators >>> Translator('') Traceback (most recent call last): ... AssertionError: Invalid separators �sepsc C s& |r t |�t t�ksJ d��|| _d S )NzInvalid separators)�set� _default_sepsr )�selfr � r �O/usr/local/CyberCP/lib/python3.10/site-packages/setuptools/_vendor/zipp/glob.py�__init__ s zTranslator.__init__c C s | � | �|��S )zH Given a glob pattern, produce a regex that matches it. )�extend�translate_core�r �patternr r r � translate s zTranslator.translatec C s d|� d�S )z� Extend regex for pattern-wide concerns. Apply '(?s:)' to create a non-matching group that matches newlines (valid on Unix). Append '\Z' to imply fullmatch even when match is used. z(?s:z)\Zr r r r r r ! � zTranslator.extendc C s& | � |� d�t| jt| �|����S )a? Given a glob pattern, produce a regex that matches it. >>> t = Translator() >>> t.translate_core('*.txt').replace('\\\\', '') '[^/]*\\.txt' >>> t.translate_core('a?txt') 'a[^/]txt' >>> t.translate_core('**/*').replace('\\\\', '') '.*/[^/][^/]*' � )�restrict_rglob�join�map�replace�separate�star_not_emptyr r r r r , s zTranslator.translate_corec C sB |� d�p t�|� d���dd��ddt�| j�� d���dd �S ) zM Perform the replacements for a match from :func:`separate`. r r z\*\*z.*z\*�[^z]*z\?z[^/])�group�re�escaper r )r �matchr r r r ; s �zTranslator.replacec C s> dt �| j�� d�}t �||�}tdd� |D ��r td��dS )z� Raise ValueError if ** appears in anything but a full path segment. >>> Translator().translate('**foo') Traceback (most recent call last): ... ValueError: ** must appear alone in a path segment �[�]+c s s � | ] }d |v o |d kV qdS )z**Nr )�.0�segmentr r r � <genexpr>Q s � z,Translator.restrict_rglob.<locals>.<genexpr>z&** must appear alone in a path segmentN)r r r �split�any� ValueError)r r � seps_pattern�segmentsr r r r F s �zTranslator.restrict_rglobc C s* dd� }dt �| j�� d�}t �|||�S )z@ Ensure that * will not match an empty segment. c S s | � d�}|dkr dS |S )Nr �*z?*)r )r r r r r �handle_segmentY s z1Translator.star_not_empty.<locals>.handle_segmentr r )r r r �sub)r r r' �not_seps_patternr r r r T s zTranslator.star_not_emptyN)�__name__� __module__� __qualname__�__doc__�str�__annotations__r r r r r r r r r r r r r s r c C s t �d| �S )z� Separate out character sets to avoid translating their contents. >>> [m.group(0) for m in separate('*.txt')] ['*.txt'] >>> [m.group(0) for m in separate('a[?]txt')] ['a', '[?]', 'txt'] z+([^\[]+)|(?P<set>[\[].*?[\]])|([\[][^\]]*$))r �finditer)r r r r r a r r ) �osr �sepr. �altsep�boolr r r r r r r �<module> s Y compat/py310.py 0000644 00000000333 15030222101 0007236 0 ustar 00 import sys import io def _text_encoding(encoding, stacklevel=2, /): # pragma: no cover return encoding text_encoding = ( io.text_encoding if sys.version_info > (3, 10) else _text_encoding # type: ignore ) compat/__pycache__/__init__.cpython-310.pyc 0000644 00000000267 15030222101 0014466 0 ustar 00 o �h � @ s d S )N� r r r �Z/usr/local/CyberCP/lib/python3.10/site-packages/setuptools/_vendor/zipp/compat/__init__.py�<module> s compat/__pycache__/py310.cpython-310.pyc 0000644 00000000650 15030222101 0013577 0 ustar 00 o �h� � @ s6 d dl Z d dlZddd�Ze jdkrejZdS eZdS )� N� c C s | S )N� )�encoding� stacklevelr r �W/usr/local/CyberCP/lib/python3.10/site-packages/setuptools/_vendor/zipp/compat/py310.py�_text_encoding s r )� � )r )�sys�ior � version_info� text_encodingr r r r �<module> s �� compat/__init__.py 0000644 00000000000 15030222101 0010110 0 ustar 00 __init__.py 0000644 00000032144 15030222101 0006643 0 ustar 00 import io import posixpath import zipfile import itertools import contextlib import pathlib import re import stat import sys from .compat.py310 import text_encoding from .glob import Translator __all__ = ['Path'] def _parents(path): """ 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('')) [] """ return itertools.islice(_ancestry(path), 1, None) def _ancestry(path): """ 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('')) [] """ path = path.rstrip(posixpath.sep) while path and path != posixpath.sep: yield path path, tail = posixpath.split(path) _dedupe = dict.fromkeys """Deduplicate an iterable in original order""" def _difference(minuend, subtrahend): """ Return items in minuend not in subtrahend, retaining order with O(1) lookup. """ return itertools.filterfalse(set(subtrahend).__contains__, minuend) class InitializedState: """ Mix-in to save the initialization state for pickling. """ def __init__(self, *args, **kwargs): self.__args = args self.__kwargs = kwargs super().__init__(*args, **kwargs) def __getstate__(self): return self.__args, self.__kwargs def __setstate__(self, state): args, kwargs = state super().__init__(*args, **kwargs) class SanitizedNames: """ ZipFile mix-in to ensure names are sanitized. """ def namelist(self): return list(map(self._sanitize, super().namelist())) @staticmethod def _sanitize(name): r""" 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 """ def allowed(part): return part and part not in {'..', '.'} # Remove the drive letter. # Don't use ntpath.splitdrive, because that also strips UNC paths bare = re.sub('^([A-Z]):', r'\1', name, flags=re.IGNORECASE) clean = bare.replace('\\', '/') parts = clean.split('/') joined = '/'.join(filter(allowed, parts)) if not joined: raise ValueError("Empty filename") return joined + '/' * name.endswith('/') class CompleteDirs(InitializedState, SanitizedNames, zipfile.ZipFile): """ 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/'] """ @staticmethod def _implied_dirs(names): parents = itertools.chain.from_iterable(map(_parents, names)) as_dirs = (p + posixpath.sep for p in parents) return _dedupe(_difference(as_dirs, names)) def namelist(self): names = super().namelist() return names + list(self._implied_dirs(names)) def _name_set(self): return set(self.namelist()) def resolve_dir(self, name): """ If the name represents a directory, return that name as a directory (with the trailing slash). """ names = self._name_set() dirname = name + '/' dir_match = name not in names and dirname in names return dirname if dir_match else name def getinfo(self, name): """ Supplement getinfo for implied dirs. """ try: return super().getinfo(name) except KeyError: if not name.endswith('/') or name not in self._name_set(): raise return zipfile.ZipInfo(filename=name) @classmethod def make(cls, source): """ Given a source (filename or zipfile), return an appropriate CompleteDirs subclass. """ if isinstance(source, CompleteDirs): return source if not isinstance(source, zipfile.ZipFile): return cls(source) # Only allow for FastLookup when supplied zipfile is read-only if 'r' not in source.mode: cls = CompleteDirs source.__class__ = cls return source @classmethod def inject(cls, zf: zipfile.ZipFile) -> zipfile.ZipFile: """ Given a writable zip file zf, inject directory entries for any directories implied by the presence of children. """ for name in cls._implied_dirs(zf.namelist()): zf.writestr(name, b"") return zf class FastLookup(CompleteDirs): """ ZipFile subclass to ensure implicit dirs exist and are resolved rapidly. """ def namelist(self): with contextlib.suppress(AttributeError): return self.__names self.__names = super().namelist() return self.__names def _name_set(self): with contextlib.suppress(AttributeError): return self.__lookup self.__lookup = super()._name_set() return self.__lookup def _extract_text_encoding(encoding=None, *args, **kwargs): # compute stack level so that the caller of the caller sees any warning. is_pypy = sys.implementation.name == 'pypy' stack_level = 3 + is_pypy return text_encoding(encoding, stack_level), args, kwargs class Path: """ 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 """ __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})" def __init__(self, root, at=""): """ 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. """ self.root = FastLookup.make(root) self.at = at def __eq__(self, other): """ >>> Path(zipfile.ZipFile(io.BytesIO(), 'w')) == 'foo' False """ if self.__class__ is not other.__class__: return NotImplemented return (self.root, self.at) == (other.root, other.at) def __hash__(self): return hash((self.root, self.at)) def open(self, mode='r', *args, pwd=None, **kwargs): """ Open this entry as text or binary following the semantics of ``pathlib.Path.open()`` by passing arguments through to io.TextIOWrapper(). """ if self.is_dir(): raise IsADirectoryError(self) zip_mode = mode[0] if not self.exists() and zip_mode == 'r': raise FileNotFoundError(self) stream = self.root.open(self.at, zip_mode, pwd=pwd) if 'b' in mode: if args or kwargs: raise ValueError("encoding args invalid for binary operation") return stream # Text mode: encoding, args, kwargs = _extract_text_encoding(*args, **kwargs) return io.TextIOWrapper(stream, encoding, *args, **kwargs) def _base(self): return pathlib.PurePosixPath(self.at or self.root.filename) @property def name(self): return self._base().name @property def suffix(self): return self._base().suffix @property def suffixes(self): return self._base().suffixes @property def stem(self): return self._base().stem @property def filename(self): return pathlib.Path(self.root.filename).joinpath(self.at) def read_text(self, *args, **kwargs): encoding, args, kwargs = _extract_text_encoding(*args, **kwargs) with self.open('r', encoding, *args, **kwargs) as strm: return strm.read() def read_bytes(self): with self.open('rb') as strm: return strm.read() def _is_child(self, path): return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/") def _next(self, at): return self.__class__(self.root, at) def is_dir(self): return not self.at or self.at.endswith("/") def is_file(self): return self.exists() and not self.is_dir() def exists(self): return self.at in self.root._name_set() def iterdir(self): if not self.is_dir(): raise ValueError("Can't listdir a file") subs = map(self._next, self.root.namelist()) return filter(self._is_child, subs) def match(self, path_pattern): return pathlib.PurePosixPath(self.at).match(path_pattern) def is_symlink(self): """ Return whether this path is a symlink. """ info = self.root.getinfo(self.at) mode = info.external_attr >> 16 return stat.S_ISLNK(mode) def glob(self, pattern): if not pattern: raise ValueError(f"Unacceptable pattern: {pattern!r}") prefix = re.escape(self.at) tr = Translator(seps='/') matches = re.compile(prefix + tr.translate(pattern)).fullmatch names = (data.filename for data in self.root.filelist) return map(self._next, filter(matches, names)) def rglob(self, pattern): return self.glob(f'**/{pattern}') def relative_to(self, other, *extra): return posixpath.relpath(str(self), str(other.joinpath(*extra))) def __str__(self): return posixpath.join(self.root.filename, self.at) def __repr__(self): return self.__repr.format(self=self) def joinpath(self, *other): next = posixpath.join(self.at, *other) return self._next(self.root.resolve_dir(next)) __truediv__ = joinpath @property def parent(self): if not self.at: return self.filename.parent parent_at = posixpath.dirname(self.at.rstrip('/')) if parent_at: parent_at += '/' return self._next(parent_at)
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings