403Webshell
Server IP : 127.0.0.1  /  Your IP : 216.73.216.109
Web Server : Apache/2.4.54 (Win64) OpenSSL/1.1.1q PHP/8.1.10
System : Windows NT DESKTOP-E5T4RUN 10.0 build 19045 (Windows 10) AMD64
User : SERVERWEB ( 0)
PHP Version : 8.1.10
Disable Function : NONE
MySQL : OFF |  cURL : ON |  WGET : OFF |  Perl : OFF |  Python : OFF |  Sudo : OFF |  Pkexec : OFF
Directory :  C:/cygwin64/lib/python3.9/site-packages/packaging/__pycache__/

Upload File :
current_dir [ Writeable] document_root [ Writeable]

 

Command :

[ Back ]     

Current File : C:/cygwin64/lib/python3.9/site-packages/packaging/__pycache__/specifiers.cpython-39.opt-2.pyc
a

4p�a�u�@s�ddlZddlZddlZddlZddlZddlmZmZmZm	Z	m
Z
mZmZm
Z
mZmZmZddlmZddlmZmZmZeeefZeeeefZeded�ZeeegefZGdd	�d	e�ZGd
d�dejd�Z Gd
d�de �Z!Gdd�de!�Z"edeegefedeegefd�dd�Z#Gdd�de!�Z$e�%d�Z&ee
ed�dd�Z'eed�dd�Z(e
ee
eee
ee
efd�dd�Z)Gd d!�d!e �Z*dS)"�N)�Callable�Dict�Iterable�Iterator�List�Optional�Pattern�Set�Tuple�TypeVar�Union�)�canonicalize_version)�
LegacyVersion�Version�parse�VersionTypeVar)�boundc@seZdZdS)�InvalidSpecifierN)�__name__�
__module__�__qualname__�rr�8/usr/lib/python3.9/site-packages/packaging/specifiers.pyr!src@s�eZdZejed�dd��Zejed�dd��Zeje	e
d�dd��Zeje
e
d�d	d
��Zeje
dd�d
d
��Zejdee
e
e
d�dd��Zejdeee
e
eed�dd��ZdS)�
BaseSpecifier��returncCsdS�Nr��selfrrr�__str__(szBaseSpecifier.__str__cCsdSrrrrrr�__hash__/szBaseSpecifier.__hash__��otherrcCsdSrr�rr#rrr�__eq__5szBaseSpecifier.__eq__cCsdSrrrrrr�prereleases<szBaseSpecifier.prereleasesN��valuercCsdSrr�rr(rrrr&Cs��itemr&rcCsdSrr�rr+r&rrr�containsJszBaseSpecifier.contains��iterabler&rcCsdSrr)rr/r&rrr�filterPszBaseSpecifier.filter)N)N)rrr�abc�abstractmethod�strr �intr!�object�boolr%�abstractpropertyrr&�setterr-rrr0rrrrr's$��r)�	metaclassc@sReZdZUiZeeefed<eeed<d+eee	dd�dd�Z
ed�d	d
�Zed�dd�Ze
eeefd�d
d��Zed�dd�Zee	d�dd�Zeed�dd�Zeed�dd�Ze
ed�dd��Ze
ed�dd��Ze
ee	d�dd��Zeje	dd �d!d��Zee	d"�d#d$�Zd,eee	e	d%�d&d'�Zd-ee ee	ee d(�d)d*�Z!dS).�_IndividualSpecifier�
_operators�_regex�N��specr&rcCsH|j�|�}|s td|�d���|�d���|�d���f|_||_dS)NzInvalid specifier: '�'�operator�version)r<�searchr�group�strip�_spec�_prereleases)rr?r&�matchrrr�__init___s�z_IndividualSpecifier.__init__rcCs8|jdurd|j��nd}d|jj�dt|��|�d�S)N�, prereleases=r=�<�(�)>)rGr&�	__class__rr3�rZprerrr�__repr__ls
��z_IndividualSpecifier.__repr__cCsdj|j�S)Nz{}{})�formatrFrrrrr usz_IndividualSpecifier.__str__cCs|jdt|jd�fS)Nrr
)rFrrrrr�_canonical_specxsz$_IndividualSpecifier._canonical_speccCs
t|j�Sr)�hashrRrrrrr!|sz_IndividualSpecifier.__hash__r"cCsRt|t�r6z|�t|��}WqFty2tYS0nt||j�sFtS|j|jkSr)�
isinstancer3rNr�NotImplementedrRr$rrrr%s
z_IndividualSpecifier.__eq__)�oprcCst|d|j|���}|S)NZ	_compare_)�getattrr;)rrV�operator_callablerrr�
_get_operator�s�z"_IndividualSpecifier._get_operator�rBrcCst|ttf�st|�}|Sr)rTrrr�rrBrrr�_coerce_version�sz$_IndividualSpecifier._coerce_versioncCs
|jdS)Nr�rFrrrrrA�sz_IndividualSpecifier.operatorcCs
|jdS)Nr
r]rrrrrB�sz_IndividualSpecifier.versioncCs|jSr�rGrrrrr&�sz _IndividualSpecifier.prereleasesr'cCs
||_dSrr^r)rrrr&�s�r+rcCs
|�|�Sr�r-�rr+rrr�__contains__�sz!_IndividualSpecifier.__contains__r*cCs>|dur|j}|�|�}|jr&|s&dS|�|j�}|||j�S�NF)r&r\�
is_prereleaserYrArB)rr+r&Znormalized_itemrXrrrr-�s

z_IndividualSpecifier.containsr.ccs�d}g}d|dur|ndi}|D]F}|�|�}|j|fi|��r |jr\|s\|js\|�|�q d}|Vq |s�|r�|D]
}|VqtdS)NFr&T)r\r-rdr&�append)rr/r&�yielded�found_prereleases�kwrB�parsed_versionrrrr0�s"
��z_IndividualSpecifier.filter)r=N)N)N)"rrrr;rr3�__annotations__rrr6rIrPr �propertyr
rRr4r!r5r%�CallableOperatorrY�UnparsedVersion�
ParsedVersionr\rArBr&r8rbr-rrr0rrrrr:Zs<

	����r:cs�eZdZdZe�dedejejB�Zdddddd	d
�Z	d e
eedd
��fdd�
Z
eed�dd�Zee
ed�dd�Zee
ed�dd�Zee
ed�dd�Zee
ed�dd�Zee
ed�dd�Zee
ed�dd�Z�ZS)!�LegacySpecifiera�
        (?P<operator>(==|!=|<=|>=|<|>))
        \s*
        (?P<version>
            [^,;\s)]* # Since this is a "legacy" specifier, and the version
                      # string can be just about anything, we match everything
                      # except for whitespace, a semi-colon for marker support,
                      # a closing paren since versions can be enclosed in
                      # them, and a comma since it's a version separator.
        )
        �^\s*�\s*$�equal�	not_equal�less_than_equal�greater_than_equal�	less_than�greater_than)�==�!=�<=�>=rK�>r=Nr>cst��||�t�dt�dS)NzZCreating a LegacyVersion has been deprecated and will be removed in the next major release)�superrI�warnings�warn�DeprecationWarning)rr?r&�rNrrrI�s
�zLegacySpecifier.__init__rZcCst|t�stt|��}|Sr)rTrr3r[rrrr\s
zLegacySpecifier._coerce_version��prospectiver?rcCs||�|�kSr�r\�rr�r?rrr�_compare_equal
szLegacySpecifier._compare_equalcCs||�|�kSrr�r�rrr�_compare_not_equal
sz"LegacySpecifier._compare_not_equalcCs||�|�kSrr�r�rrr�_compare_less_than_equalsz(LegacySpecifier._compare_less_than_equalcCs||�|�kSrr�r�rrr�_compare_greater_than_equalsz+LegacySpecifier._compare_greater_than_equalcCs||�|�kSrr�r�rrr�_compare_less_thansz"LegacySpecifier._compare_less_thancCs||�|�kSrr�r�rrr�_compare_greater_thansz%LegacySpecifier._compare_greater_than)r=N)rrr�
_regex_str�re�compile�VERBOSE�
IGNORECASEr<r;r3rr6rIrmrr\r�r�r�r�r�r��
__classcell__rrr�rro�s&�		�ro�	Specifier)�fnrcs&t���dtttd��fdd��}|S)Nr�)rr�r?rcst|t�sdS�|||�Src)rTrr��r�rr�wrapped"s
z)_require_version_compare.<locals>.wrapped)�	functools�wrapsrnr3r6)r�r�rr�r�_require_version_comparesr�c	@seZdZdZe�dedejejB�Zdddddd	d
dd�Z	e
eee
d
�dd��Ze
eee
d
�dd��Ze
eee
d
�dd��Ze
eee
d
�dd��Ze
eee
d
�dd��Ze
eee
d�dd��Ze
eee
d�dd��Zeee
d
�dd�Zee
d�d d!��Zeje
d"d#�d$d!��Zd"S)%r�a
        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
        (?P<version>
            (?:
                # The identity operators allow for an escape hatch that will
                # do an exact string match of the version you wish to install.
                # This will not be parsed by PEP 440 and we cannot determine
                # any semantic meaning from it. This operator is discouraged
                # but included entirely as an escape hatch.
                (?<====)  # Only match for the identity operator
                \s*
                [^\s]*    # We just match everything, except for whitespace
                          # since we are only testing for strict identity.
            )
            |
            (?:
                # The (non)equality operators allow for wild card and local
                # versions to be specified so we have to define these two
                # operators separately to enable that.
                (?<===|!=)            # Only match for equals and not equals

                \s*
                v?
                (?:[0-9]+!)?          # epoch
                [0-9]+(?:\.[0-9]+)*   # release
                (?:                   # pre release
                    [-_\.]?
                    (a|b|c|rc|alpha|beta|pre|preview)
                    [-_\.]?
                    [0-9]*
                )?
                (?:                   # post release
                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                )?

                # You cannot use a wild card and a dev or local version
                # together so group them with a | and make them optional.
                (?:
                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
                    |
                    \.\*  # Wild card syntax of .*
                )?
            )
            |
            (?:
                # The compatible operator requires at least two digits in the
                # release segment.
                (?<=~=)               # Only match for the compatible operator

                \s*
                v?
                (?:[0-9]+!)?          # epoch
                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
                (?:                   # pre release
                    [-_\.]?
                    (a|b|c|rc|alpha|beta|pre|preview)
                    [-_\.]?
                    [0-9]*
                )?
                (?:                                   # post release
                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                )?
                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
            )
            |
            (?:
                # All other operators only allow a sub set of what the
                # (non)equality operators do. Specifically they do not allow
                # local versions to be specified nor do they allow the prefix
                # matching wild cards.
                (?<!==|!=|~=)         # We have special cases for these
                                      # operators so we want to make sure they
                                      # don't match here.

                \s*
                v?
                (?:[0-9]+!)?          # epoch
                [0-9]+(?:\.[0-9]+)*   # release
                (?:                   # pre release
                    [-_\.]?
                    (a|b|c|rc|alpha|beta|pre|preview)
                    [-_\.]?
                    [0-9]*
                )?
                (?:                                   # post release
                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                )?
                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
            )
        )
        rprqZ
compatiblerrrsrtrurvrwZ	arbitrary)�~=rxryrzr{rKr|�===r�cCsJd�tt�tt|���dd��}|d7}|�d�||�oH|�d�||�S)N�.����.*r{rx)�join�list�	itertools�	takewhile�_is_not_suffix�_version_splitrY)rr�r?�prefixrrr�_compare_compatible�s��zSpecifier._compare_compatiblec	Csz|�d�rVt|j�}t|dd��}tt|��}|dt|��}t||�\}}||kSt|�}|jsnt|j�}||kSdS)Nr����)�endswithr�publicr�r3�len�_pad_version�local)	rr�r?Z
split_specZsplit_prospectiveZshortened_prospectiveZpadded_specZpadded_prospectiveZspec_versionrrrr��s

�
zSpecifier._compare_equalcCs|�||�Sr)r�r�rrrr��szSpecifier._compare_not_equalcCst|j�t|�kSr�rr�r�rrrr��sz"Specifier._compare_less_than_equalcCst|j�t|�kSrr�r�rrrr��sz%Specifier._compare_greater_than_equal)r��spec_strrcCs<t|�}||ksdS|js8|jr8t|j�t|j�kr8dSdS�NFT)rrd�base_version�rr�r�r?rrrr��szSpecifier._compare_less_thancCs^t|�}||ksdS|js8|jr8t|j�t|j�kr8dS|jdurZt|j�t|j�krZdSdSr�)rZis_postreleaser�r�r�rrrr�s
zSpecifier._compare_greater_thancCst|���t|���kSr)r3�lowerr�rrr�_compare_arbitrary%szSpecifier._compare_arbitraryrcCsR|jdur|jS|j\}}|dvrN|dkr@|�d�r@|dd�}t|�jrNdSdS)N)rxr{rzr�r�rxr�r�TF)rGrFr�rrd)rrArBrrrr&(s


zSpecifier.prereleasesNr'cCs
||_dSrr^r)rrrr&As)rrrr�r�r�r�r�r<r;r�rnr3r6r�r�r�r�r�r�r�rr�rkr&r8rrrrr�+s@]�'�	z^([0-9]+)((?:a|b|c|rc)[0-9]+)$rZcCs@g}|�d�D],}t�|�}|r0|�|���q|�|�q|S)Nr�)�split�
_prefix_regexrC�extend�groupsre)rB�resultr+rHrrrr�Is
r�)�segmentrcst�fdd�dD��S)Nc3s|]}��|�VqdSr)�
startswith)�.0r��r�rr�	<genexpr>Usz!_is_not_suffix.<locals>.<genexpr>)�dev�a�b�rcZpost)�anyr�rr�rr�Ts�r�)�left�rightrc
Cs�gg}}|�tt�dd�|���|�tt�dd�|���|�|t|d�d��|�|t|d�d��|�ddgtdt|d�t|d���|�ddgtdt|d�t|d���ttj|��ttj|��fS)NcSs|��Sr��isdigit��xrrr�<lambda>^�z_pad_version.<locals>.<lambda>cSs|��Srr�r�rrrr�_r�rr
�0)rer�r�r�r��insert�max�chain)r�r�Z
left_splitZright_splitrrrr�Zs
,,r�c@s
eZdZd#eeedd�dd�Zed�dd�Zed�d	d
�Ze	d�dd�Z
edefdd
�dd�Ze
ed
�dd�Ze	d�dd�Zeed�dd�Zeeed�dd��Zejedd�dd��Zeed�dd�Zd$eeeed�dd�Zd%eeeeeed �d!d"�ZdS)&�SpecifierSetr=N)�
specifiersr&rc	Csldd�|�d�D�}t�}|D]8}z|�t|��WqtyT|�t|��Yq0qt|�|_||_dS)NcSsg|]}|��r|���qSr)rE�r��srrr�
<listcomp>sr�z)SpecifierSet.__init__.<locals>.<listcomp>�,)	r��set�addr�rro�	frozenset�_specsrG)rr�r&Zsplit_specifiers�parsed�	specifierrrrrIms
zSpecifierSet.__init__rcCs.|jdurd|j��nd}dt|��|�d�S)NrJr=z<SpecifierSet(rM)rGr&r3rOrrrrP�s
��zSpecifierSet.__repr__cCsd�tdd�|jD���S)Nr�css|]}t|�VqdSr)r3r�rrrr��r�z'SpecifierSet.__str__.<locals>.<genexpr>)r��sortedr�rrrrr �szSpecifierSet.__str__cCs
t|j�Sr)rSr�rrrrr!�szSpecifierSet.__hash__r"cCs�t|t�rt|�}nt|t�s"tSt�}t|j|jB�|_|jdurX|jdurX|j|_n<|jdurv|jdurv|j|_n|j|jkr�|j|_ntd��|S)NzFCannot combine SpecifierSets with True and False prerelease overrides.)rTr3r�rUr�r�rG�
ValueError)rr#r�rrr�__and__�s 





�zSpecifierSet.__and__cCs6t|ttf�rtt|��}nt|t�s*tS|j|jkSr)rTr3r:r�rUr�r$rrrr%�s

zSpecifierSet.__eq__cCs
t|j�Sr)r�r�rrrr�__len__�szSpecifierSet.__len__cCs
t|j�Sr)�iterr�rrrr�__iter__�szSpecifierSet.__iter__cCs.|jdur|jS|jsdStdd�|jD��S)Ncss|]}|jVqdSr�r&r�rrrr��r�z+SpecifierSet.prereleases.<locals>.<genexpr>)rGr�r�rrrrr&�s

zSpecifierSet.prereleasesr'cCs
||_dSrr^r)rrrr&�sr_cCs
|�|�Srr`rarrrrb�szSpecifierSet.__contains__r*csLt�ttf�st����dur$|j��s2�jr2dSt��fdd�|jD��S)NFc3s|]}|j��d�VqdS)r�Nr`r��r+r&rrr��r�z(SpecifierSet.contains.<locals>.<genexpr>)rTrrrr&rd�allr�r,rr�rr-�s
zSpecifierSet.containsr.cCs�|dur|j}|jr6|jD]}|j|t|�d�}q|Sg}g}|D]P}t|ttf�s^t|�}n|}t|t�rnqB|jr�|s�|s�|�	|�qB|�	|�qB|s�|r�|dur�|S|SdS)Nr�)
r&r�r0r6rTrrrrdre)rr/r&r?Zfilteredrgr+rirrrr0�s*



zSpecifierSet.filter)r=N)N)N)rrrr3rr6rIrPr r4r!rr�r5r%r�rr:r�rkr&r8rmrbr-rrr0rrrrr�ls6��	����r�)+r1r�r�r�r~�typingrrrrrrrr	r
rrZutilsrrBrrrrnr3rmrr6rlr�r�ABCMetarr:ror�r�r�r�r�r�r�r�rrrr�<module>s643
=�
*

Youez - 2016 - github.com/yon3zu
LinuXploit