o

���g���@
s
dZd
dl
mZ
d
dlZd
dlZd
dlZd
dlmZmZm	Z	m
Z
mZ
ddlm
Z

ddlmZ
eeefZe
ded	�ZeeegefZd*dd�ZGdd�de�ZGdd�dejd�ZGdd�de�Ze�d�
Zd+dd�Zd,dd�Zd-d!d"�Zd.d&d'�Z Gd(d)�d)e�Z!dS)/z�
.. testsetup::

    from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier
    from packaging.version import Version
�)
�annotationsN)�Callable�Iterable�Iterator�TypeVar�Union�
)
�canonicalize_version)
�Version�UnparsedVersionVar)
�bound�version�UnparsedVersion�returnr
c

C
st|t
�s	t
|�
}|S�
N)�
isinstancer
)
r
�r�?/usr/local/lib/python3.10/dist-packages/packaging/specifiers.py�_coerce_versions



rc
@
seZ
dZd
ZdS)�InvalidSpecifiera

    Raised when attempting to create a :class:`Specifier` with a specifier
    string that is invalid.

    >>> Specifier("lolwat")
    Traceback (most recent call last):
        ...
    packaging.specifiers.InvalidSpecifier: Invalid specifier: 'lolwat'
    N)�__name__�
__module__�__qualname__�__doc__rrrrr s
rc@
s�eZ
dZejddd��
Zejddd��
Zejddd��
Zeejd dd��
�
Z	e	j
d!dd��
Z	ejd"d#dd��
Zej	d"d$dd��
ZdS)%�
BaseSpecifierr�strc


C
�d
S)z�
        Returns the str representation of this Specifier-like object. This
        should be representative of the Specifier itself.
        Nr�
�selfrrr�__str__-�zBaseSpecifier.__str__�intc


C
r)zF
        Returns a hash value for this Specifier-like object.
        Nrrrrr�__hash__4r zBaseSpecifier.__hash__�other�object�boolc
C
r)z�
        Returns a boolean representing whether or not the two Specifier-like
        objects are equal.

        :param other: The other object to check against.
        Nr�rr#rrr�__eq__:r zBaseSpecifier.__eq__�bool | Nonec


C
r)z�Whether or not pre-releases as a whole are allowed.

        This can be set to either ``True`` or ``False`` to explicitly enable or disable
        prereleases or it can be set to ``None`` (the default) to use default semantics.
        Nrrrrr�prereleasesCr zBaseSpecifier.prereleases�value�Nonec
C
r)zQSetter for :attr:`prereleases`.

        :param value: The value to set.
        Nr�rr*rrrr)Lr N�itemr)c
C
r)zR
        Determines if the given item is contained within this specifier.
        Nr)rr-r)rrr�containsSr zBaseSpecifier.contains�iterable�Iterable[UnparsedVersionVar]�Iterator[UnparsedVersionVar]c
C
r)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�filterYr zBaseSpecifier.filter�rr�rr!�r#r$rr%�rr(�r*r%rr+r)r-rr)r(rr%�r/r0r)r(rr1)
rrr�abc�abstractmethodrr"r'�propertyr)�setterr.r2rrrrr,s"







�r)
�	metaclassc	@
sH
eZ
dZd
ZdZdZe�deedejej	B�Z
dddd	d
ddd
d�ZdSdTdd�Ze
dUdd��
ZejdVdd��
Ze
dWdd��
Ze
dWd d!��
ZdWd"d#�ZdWd$d%�Ze
dXd'd(��
ZdYd*d+�ZdZd.d/�Zd[d2d3�Zd\d6d7�Zd\d8d9�Zd\d:d;�Zd\d<d=�Zd\d>d?�Zd]dAdB�Zd]dCdD�Zd\dEdF�Zd^dIdJ�Z d_d`dLdM�Z!	d_dadQdR�Z"dS)b�	Specifiera?
This class abstracts handling of version specifiers.

    .. tip::

        It is generally not required to instantiate this manually. You should instead
        prefer to work with :class:`SpecifierSet` instead, which can parse
        comma-separated version specifiers (which is what package metadata contains).
    z8
        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
        a�
        (?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;)]*  # The arbitrary version can be just about anything,
                          # we match everything except for whitespace, a
                          # semi-colon for marker support, and a closing paren
                          # since versions can be enclosed in them.
            )
            |
            (?:
                # 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

                # You cannot use a wild card and a pre-release, post-release, a dev or
                # local version together so group them with a | and make them optional.
                (?:
                    \.\*  # Wild card syntax of .*
                    |
                    (?:                                  # pre release
                        [-_\.]?
                        (alpha|beta|preview|pre|a|b|c|rc)
                        [-_\.]?
                        [0-9]*
                    )?
                    (?:                                  # post release
                        (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                    )?
                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
                )?
            )
            |
            (?:
                # 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
                    [-_\.]?
                    (alpha|beta|preview|pre|a|b|c|rc)
                    [-_\.]?
                    [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
                    [-_\.]?
                    (alpha|beta|preview|pre|a|b|c|rc)
                    [-_\.]?
                    [0-9]*
                )?
                (?:                                   # post release
                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                )?
                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
            )
        )
        z^\s*z\s*$�
compatible�equal�	not_equal�less_than_equal�greater_than_equal�	less_than�greater_than�	arbitrary)�~=�==z!=�<=�>=�
<�
>�===�N�specrr)r(rr+cC
sF|j�
|
�
}|std
|
���
�
|�d�
��|�d�
��f|_||_dS)a�
Initialize a Specifier instance.

        :param spec:
            The string representation of a specifier which will be parsed and
            normalized before use.
        :param prereleases:
            This tells the specifier if it should accept prerelease versions if
            applicable or not. The default of ``None`` will autodetect it from the
            given specifiers.
        :raises InvalidSpecifier:
            If the given specifier is invalid (i.e. bad syntax).
        zInvalid specifier: �operatorr
N)�_regex�searchr�group�strip�_spec�_prereleases)rrOr)�matchrrr�__init__�s



�
zSpecifier.__init__r%c
C
sR|jdu
r|jS|j
\}
}|
d
vr'|
dkr |�d�
r |dd�}t|�
jr'dSdS)N)rHrJrIrGrMrLrKrH�.*���TF)rVrU�endswithr
�
is_prerelease)rrPr
rrrr)�s






zSpecifier.prereleasesr*cC
�
|
|_dSr�
rVr,rrrr)
�
c

C
�
|jd
S)z`The operator of this specifier.

        >>> Specifier("==1.2.3").operator
        '=='
        r
�
rUrrrrrP
�
zSpecifier.operatorc

C
r`)zaThe version of this specifier.

        >>> Specifier("==1.2.3").version
        '1.2.3'
        rrarrrrr

rbzSpecifier.versionc
C
s8|jd
u
rd|j
��n
d}
d|jj�dt|�
�|
�d�S)aT
A representation of the Specifier that shows all internal state.

        >>> Specifier('>=1.0.0')
        <Specifier('>=1.0.0')>
        >>> Specifier('>=1.0.0', prereleases=False)
        <Specifier('>=1.0.0', prereleases=False)>
        >>> Specifier('>=1.0.0', prereleases=True)
        <Specifier('>=1.0.0', prereleases=True)>
        N�, prereleases=rNrK�
(�)>)rVr)�	__class__rr�r�prerrr�__repr__&
s

��zSpecifier.__repr__c

C
sd
j|j
�S)z�A string representation of the Specifier that can be round-tripped.

        >>> str(Specifier('>=1.0.0'))
        '>=1.0.0'
        >>> str(Specifier('>=1.0.0', prereleases=False))
        '>=1.0.0'
        z{}{})�formatrUrrrrr8
szSpecifier.__str__�tuple[str, str]c
C
s*t|j
d
|j
ddkd�}
|j
d|
fS)Nrr
rG�
�strip_trailing_zero)r	rU)r�canonical_versionrrr�_canonical_specB
s


�zSpecifier._canonical_specr!c

C
�
t|j
�
Sr)�hashrorrrrr"J
�

zSpecifier.__hash__r#r$cC
sPt|
t
�rz	|�t
|
�
�
}
Wnty


tYSwt|
|j�s"tS|j|
jkS)
a>Whether or not the two Specifier-like objects are equal.

        :param other: The other object to check against.

        The value of :attr:`prereleases` is ignored.

        >>> Specifier("==1.2.3") == Specifier("== 1.2.3.0")
        True
        >>> (Specifier("==1.2.3", prereleases=False) ==
        ...  Specifier("==1.2.3", prereleases=True))
        True
        >>> Specifier("==1.2.3") == "==1.2.3"
        True
        >>> Specifier("==1.2.3") == Specifier("==1.2.4")
        False
        >>> Specifier("==1.2.3") == Specifier("~=1.2.3")
        False
        )rrrfr�NotImplementedror&rrrr'M
s




�
zSpecifier.__eq__�op�CallableOperatorcC
st|d
|j
|
���}|S)N�	_compare_)�getattr�
_operators)rrt�operator_callablerrr�
_get_operatorj
s

�zSpecifier._get_operator�prospectiver
cC
sHtt
t�tt|�
��
dd
��
}|d7}|�d�
|
|�o#|�d�
|
|�S)N���rYrJrH)�
_version_join�list�	itertools�	takewhile�_is_not_suffix�_version_splitrz)rr{rO�prefixrrr�_compare_compatiblep
s	
�
�zSpecifier._compare_compatiblecC
s�|�d
�
r1t
|
jdd�}t
|dd�dd�}t|�
}t|�
}t||�\}}|dt|�
�}	|	|kSt|�
}
|
js=t|
j�
}
|
|
kS)NrYFrlrZ)r[r	�publicr��_pad_version�lenr
�local)rr{rO�normalized_prospective�normalized_spec�
split_spec�split_prospective�padded_prospective�
_�shortened_prospective�spec_versionrrr�_compare_equal�
s

�

zSpecifier._compare_equalcC
s|�|
|�Sr)
r��rr{rOrrr�_compare_not_equal�
s
zSpecifier._compare_not_equalcC
st|
j
�
t|�
k
Sr�r
r�r�rrr�_compare_less_than_equal�
�z"Specifier._compare_less_than_equalcC
st|
j
�
t|�
kSrr�r�rrr�_compare_greater_than_equal�
r�z%Specifier._compare_greater_than_equal�spec_strcC
s<t|�
}|
|ks
d
S|j
s|
j
rt|
j�
t|j�
krd
SdS�NFT)r
r\�base_version�rr{r�rOrrr�_compare_less_than�
s


zSpecifier._compare_less_thancC
s^t|�
}|
|ks
d
S|j
s|
j
rt|
j�
t|j�
krd
S|
jdu
r-t|
j�
t|j�
kr-d
SdSr�)r
�is_postreleaser�r�r�rrr�_compare_greater_than�
s





zSpecifier._compare_greater_thancC
st|
�
�
�t|�
�
�kSr)r�lowerr�rrr�_compare_arbitrary�
s
zSpecifier._compare_arbitraryr-�
str | VersioncC
�
|�|
�
S)
a;Return whether or not the item is contained in this specifier.

        :param item: The item to check for.

        This is used for the ``in`` operator and behaves the same as
        :meth:`contains` with no ``prereleases`` argument passed.

        >>> "1.2.3" in Specifier(">=1.2.3")
        True
        >>> Version("1.2.3") in Specifier(">=1.2.3")
        True
        >>> "1.0.0" in Specifier(">=1.2.3")
        False
        >>> "1.3.0a1" in Specifier(">=1.2.3")
        False
        >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True)
        True
        �
r.�rr-rrr�__contains__�
�
zSpecifier.__contains__rcC
s<|d
ur|j}t
|
�
}|jr|sdS|�|j�
}|||j�S)alReturn whether or not the item is contained in this specifier.

        :param item:
            The item to check for, which can be a version string or a
            :class:`Version` instance.
        :param prereleases:
            Whether or not to match prereleases with this Specifier. If set to
            ``None`` (the default), it uses :attr:`prereleases` to determine
            whether or not prereleases are allowed.

        >>> Specifier(">=1.2.3").contains("1.2.3")
        True
        >>> Specifier(">=1.2.3").contains(Version("1.2.3"))
        True
        >>> Specifier(">=1.2.3").contains("1.0.0")
        False
        >>> Specifier(">=1.2.3").contains("1.3.0a1")
        False
        >>> Specifier(">=1.2.3", prereleases=True).contains("1.3.0a1")
        True
        >>> Specifier(">=1.2.3").contains("1.3.0a1", prereleases=True)
        True
        NF)r)rr\rzrPr
)rr-r)�normalized_itemryrrrr.	s



zSpecifier.containsr/r0r1cc
s��d
}g}d|du
r|n
di
}|
D]"}t|�
}|j
|f
i|�
�
r3|jr.|s.|js.|�|�

qd}|V
q|s@|rB|D]	}|V
q:dSdSdS)aOFilter items in the given iterable, that match the specifier.

        :param iterable:
            An iterable that can contain version strings and :class:`Version` instances.
            The items in the iterable will be filtered according to the specifier.
        :param prereleases:
            Whether or not to allow prereleases in the returned iterator. If set to
            ``None`` (the default), it will be intelligently decide whether to allow
            prereleases or not (based on the :attr:`prereleases` attribute, and
            whether the only versions matching are prereleases).

        This method is smarter than just ``filter(Specifier().contains, [...])``
        because it implements the rule from :pep:`440` that a prerelease item
        SHOULD be accepted if no other versions match the given specifier.

        >>> list(Specifier(">=1.2.3").filter(["1.2", "1.3", "1.5a1"]))
        ['1.3']
        >>> list(Specifier(">=1.2.3").filter(["1.2", "1.2.3", "1.3", Version("1.4")]))
        ['1.2.3', '1.3', <Version('1.4')>]
        >>> list(Specifier(">=1.2.3").filter(["1.2", "1.5a1"]))
        ['1.5a1']
        >>> list(Specifier(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True))
        ['1.3', '1.5a1']
        >>> list(Specifier(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"]))
        ['1.3', '1.5a1']
        Fr)NT)rr.r\r)�append)rr/r)�yielded�found_prereleases�kwr
�parsed_versionrrrr25s*�


�
�
�

�
zSpecifier.filter�rNN)rOrr)r(rr+)rr%r7r3)rrkr4r5)rtrrru)r{r
rOrrr%)r{r
r�rrr%)r-r�rr%r)r-rr)r(rr%r8)#rrrr�_operator_regex_str�_version_regex_str�re�compile�VERBOSE�
IGNORECASErQrxrXr;r)r<rPr
rirror"r'rzr�r�r�r�r�r�r�r�r�r.r2rrrrr>csZ
	^


�






�













(





-�r>z^([0-9]+)((?:a|b|c|rc)[0-9]+)$r�	list[str]c
C
s^g}
|�d
�
\}}}|
�
|pd�

|�d�
D]}t�|�
}|r'|
�|���

q|
�
|�

q|
S)a
Split version into components.

    The split components are intended for version comparison. The logic does
    not attempt to retain the original version string, so joining the
    components back with :func:`_version_join` may not produce the original
    version string.
    �
!�
0�
.)�
rpartitionr��split�
_prefix_regexrR�extend�groups)r
�result�epochr��restr-rWrrrr�vs





r��
componentsc
C
s|^
}
}|
�d
d�|�
��S)z�Join split version components into a version string.

    This function assumes the input came from :func:`_version_split`, where the
    first component must be the epoch (either empty or numeric), and all other
    components numeric.
    r�r�)
�join)r�r�r�rrrr}�s
r}�segmentr%c


st�f
d
d�dD�
�
S)Nc
3
s�|]}
��|
�
V
qdSr)
�
startswith)�.0r��
r�rr�	<genexpr>�s�


�z!_is_not_suffix.<locals>.<genexpr>)�dev�
a�
b�rc�post)
�anyr�rr�rr��s


�r��left�right�tuple[list[str], list[str]]c
C
s�gg}}|�t
t�d
d�|��
�

|�t
t�dd�|
��
�

|�|t|d�
d��

|�|
t|d�
d��

|�ddg
tdt|d�
t|d�
��
|�ddg
tdt|d�
t|d�
��
t
tj�|�
�
t
tj�|�
�
fS)Nc

S
�|��Sr�
�isdigit�
�
xrrr�<lambda>��z_pad_version.<locals>.<lambda>c

S
r�rr�r�rrrr��r�r
rr�)	r�r~rr�r��insert�max�chain�
from_iterable)r�r��
left_split�right_splitrrrr��s



,,

�r�c@
s�eZ
dZd
Z		d1d2d
d�Zed3dd
��
Zejd4dd
��
Zd5dd�Zd5dd�Z	d6dd�Z
d7dd�Zd8dd�Zd6d d!�Z
d9d#d$�Zd:d'd(�Z		d;d<d*d+�Z	d=d>d/d0�ZdS)?�SpecifierSetz�This class abstracts handling of a set of version specifiers.

    It can be passed a single specifier (``>=3.0``), a comma-separated list of
    specifiers (``>=3.0,!=3.1``), or no specifier at all.
    rNN�
specifiers�str | Iterable[Specifier]r)r(rr+cC
sDt|
t
�rd
d�|
�d�
D�
}ttt|��
|_nt|
�
|_||_dS)a�Initialize a SpecifierSet instance.

        :param specifiers:
            The string representation of a specifier or a comma-separated list of
            specifiers which will be parsed and normalized before use.
            May also be an iterable of ``Specifier`` instances, which will be used
            as is.
        :param prereleases:
            This tells the SpecifierSet if it should accept prerelease versions if
            applicable or not. The default of ``None`` will autodetect it from the
            given specifiers.

        :raises InvalidSpecifier:
            If the given ``specifiers`` are not parseable than this exception will be
            raised.
        c
S
sg|]
}
|
��r|
���qSr)
rT�r��
srrr�
<listcomp>�sz)SpecifierSet.__init__.<locals>.<listcomp>�
,N)rrr��	frozenset�mapr>�_specsrV)rr�r)�split_specifiersrrrrX�s



zSpecifierSet.__init__c

C
s.|jdu
r|jS|j
s
dStd
d�|j
D�
�
S)Nc
s
s�|]}
|
jV
qdSr�
r)r�rrrr��s�z+SpecifierSet.prereleases.<locals>.<genexpr>)rVr�r�rrrrr)�s



zSpecifierSet.prereleasesr*r%cC
r]rr^r,rrrr)�r_rc
C
s.|jd
u
rd|j
��n
d}
dt|�
�|
�d�S)aA representation of the specifier set that shows all internal state.

        Note that the ordering of the individual specifiers within the set may not
        match the input string.

        >>> SpecifierSet('>=1.0.0,!=2.0.0')
        <SpecifierSet('!=2.0.0,>=1.0.0')>
        >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=False)
        <SpecifierSet('!=2.0.0,>=1.0.0', prereleases=False)>
        >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=True)
        <SpecifierSet('!=2.0.0,>=1.0.0', prereleases=True)>
        NrcrNz<SpecifierSet(re)rVr)rrgrrrri�s

��zSpecifierSet.__repr__c

C
sd
�t
dd�|jD�
�
�
S)an
A string representation of the specifier set that can be round-tripped.

        Note that the ordering of the individual specifiers within the set may not
        match the input string.

        >>> str(SpecifierSet(">=1.0.0,!=1.0.1"))
        '!=1.0.1,>=1.0.0'
        >>> str(SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False))
        '!=1.0.1,>=1.0.0'
        r�c
s
s�|]}
t|
�
V
qdSr)
rr�rrrr�s�z'SpecifierSet.__str__.<locals>.<genexpr>)r��sortedr�rrrrr	szSpecifierSet.__str__r!c

C
rpr)rqr�rrrrr"rrzSpecifierSet.__hash__r#�SpecifierSet | strcC
s�t|
t
�r
t|
�
}
nt|
t�stSt�}t|j|
jB�
|_|jd
ur-|
jd
u
r-|
j|_|S|jd
u
r=|
jd
ur=|j|_|S|j|
jkrI|j|_|Std�
�
)a�
Return a SpecifierSet which is a combination of the two sets.

        :param other: The other object to combine with.

        >>> SpecifierSet(">=1.0.0,!=1.0.1") & '<=2.0.0,!=2.0.1'
        <SpecifierSet('!=1.0.1,!=2.0.1,<=2.0.0,>=1.0.0')>
        >>> SpecifierSet(">=1.0.0,!=1.0.1") & SpecifierSet('<=2.0.0,!=2.0.1')
        <SpecifierSet('!=1.0.1,!=2.0.1,<=2.0.0,>=1.0.0')>
        NzFCannot combine SpecifierSets with True and False prerelease overrides.)rrr�rsr�r�rV�
ValueError)rr#�	specifierrrr�__and__s$








�
	�
�
�zSpecifierSet.__and__r$cC
s6t|
t
tf�rtt
|
�
�
}
nt|
t�stS|j|
jkS)
a�Whether or not the two SpecifierSet-like objects are equal.

        :param other: The other object to check against.

        The value of :attr:`prereleases` is ignored.

        >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.1")
        True
        >>> (SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False) ==
        ...  SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True))
        True
        >>> SpecifierSet(">=1.0.0,!=1.0.1") == ">=1.0.0,!=1.0.1"
        True
        >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0")
        False
        >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.2")
        False
        )rrr>r�rsr�r&rrrr'9s




zSpecifierSet.__eq__c

C
rp)
z7Returns the number of specifiers in this specifier set.)r�r�rrrr�__len__Sr_zSpecifierSet.__len__�Iterator[Specifier]c

C
rp)
z�
        Returns an iterator over all the underlying :class:`Specifier` instances
        in this specifier set.

        >>> sorted(SpecifierSet(">=1.0.0,!=1.0.1"), key=str)
        [<Specifier('!=1.0.1')>, <Specifier('>=1.0.0')>]
        )�iterr�rrrr�__iter__Ws
zSpecifierSet.__iter__r-rcC
r�)
arReturn whether or not the item is contained in this specifier.

        :param item: The item to check for.

        This is used for the ``in`` operator and behaves the same as
        :meth:`contains` with no ``prereleases`` argument passed.

        >>> "1.2.3" in SpecifierSet(">=1.0.0,!=1.0.1")
        True
        >>> Version("1.2.3") in SpecifierSet(">=1.0.0,!=1.0.1")
        True
        >>> "1.0.1" in SpecifierSet(">=1.0.0,!=1.0.1")
        False
        >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1")
        False
        >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True)
        True
        r�r�rrrr�ar�zSpecifierSet.__contains__�	installedc
s\t�t
�s	t
��
��
d
ur|j�
�
s�jrdS|r!�jr!t
�j�
�t��
fdd�|jD�
�
S)a�Return whether or not the item is contained in this SpecifierSet.

        :param item:
            The item to check for, which can be a version string or a
            :class:`Version` instance.
        :param prereleases:
            Whether or not to match prereleases with this SpecifierSet. If set to
            ``None`` (the default), it uses :attr:`prereleases` to determine
            whether or not prereleases are allowed.

        >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.2.3")
        True
        >>> SpecifierSet(">=1.0.0,!=1.0.1").contains(Version("1.2.3"))
        True
        >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.0.1")
        False
        >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1")
        False
        >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True).contains("1.3.0a1")
        True
        >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True)
        True
        NFc
3
s�|]
}
|
j��
d�V
qd
S)r�Nr�r��r-r)rrr��s�z(SpecifierSet.contains.<locals>.<genexpr>)rr
r)r\r��allr�)rr-r)r�rr�rr.vs







zSpecifierSet.containsr/r0r1cC
s�|d
ur|j}|j
r|j
D]}|j|
t|�
d�}
q
t|
�
Sg}g}|
D]}t|�
}|jr6|s6|s5|�|�

q#|�|�

q#|sH|rH|d
urHt|�
St|�
S)a.Filter items in the given iterable, that match the specifiers in this set.

        :param iterable:
            An iterable that can contain version strings and :class:`Version` instances.
            The items in the iterable will be filtered according to the specifier.
        :param prereleases:
            Whether or not to allow prereleases in the returned iterator. If set to
            ``None`` (the default), it will be intelligently decide whether to allow
            prereleases or not (based on the :attr:`prereleases` attribute, and
            whether the only versions matching are prereleases).

        This method is smarter than just ``filter(SpecifierSet(...).contains, [...])``
        because it implements the rule from :pep:`440` that a prerelease item
        SHOULD be accepted if no other versions match the given specifier.

        >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", "1.5a1"]))
        ['1.3']
        >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", Version("1.4")]))
        ['1.3', <Version('1.4')>]
        >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.5a1"]))
        []
        >>> list(SpecifierSet(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True))
        ['1.3', '1.5a1']
        >>> list(SpecifierSet(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"]))
        ['1.3', '1.5a1']

        An "empty" SpecifierSet will filter items based on the presence of prerelease
        versions in the set.

        >>> list(SpecifierSet("").filter(["1.3", "1.5a1"]))
        ['1.3']
        >>> list(SpecifierSet("").filter(["1.5a1"]))
        ['1.5a1']
        >>> list(SpecifierSet("", prereleases=True).filter(["1.3", "1.5a1"]))
        ['1.3', '1.5a1']
        >>> list(SpecifierSet("").filter(["1.3", "1.5a1"], prereleases=True))
        ['1.3', '1.5a1']
        Nr�)r)r�r2r%r�rr\r�)rr/r)rO�filteredr�r-r�rrrr2�s$,










�
zSpecifierSet.filterr�)r�r�r)r(rr+r6r7r3r4)r#r�rr�r5)rr�)r-rrr%)NN)r-rr)r(r�r(rr%rr8)rrrrrXr;r)r<rirr"r�r'r�r�r�r.r2rrrrr��s,

�&






 




�:�r�)r
rrr
)r
rrr�)r�r�rr)r�rrr%)r�r�r�r�rr�)"r�
__future__rr9rr��typingrrrrr�utilsr	r
r
rrrr%rurr�r�ABCMetarr>r�r�r�r}r�r�r�rrrr�<module>
s2






7