o

�N�g��	@s2
dZd
dl
Z
d
dlZd
dlZd
dlmZmZmZmZm	Z	m
Z
mZmZ
ddl
mZ
ddlmZ
eeefZeeegefZdedefd	d
�ZGdd�de�ZGd
d�de
jd�ZGdd�de�Ze�d�
Zdedeefdd�Zdedefdd�Zdeedeedeeeeeffdd�ZGdd�de�Z dS)z�
.. testsetup::

    from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier
    from packaging.version import Version
�N)�Callable�Iterable�Iterator�List�Optional�Set�Tuple�Union�
)
�canonicalize_version)
�Version�version�returnc

Cst|t
�s	t
|�
}|S�
N)�
isinstancer)
r
�r�H/opt/saltstack/salt/lib/python3.10/site-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__rrrrrs
rc	@s�eZ
dZejd
efdd��
Zejd
efdd��
Zejde	d
e
fdd��
Zeejd
e
e
fd	d
��
�
Zejde
d
dfd
d
��
Zejddede
e
d
e
fdd��
Zej	ddeede
e
d
eefdd��
ZdS)�
BaseSpecifierrc


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__c


Cr)zF
        Returns a hash value for this Specifier-like object.
        Nrrrrr�__hash__1rzBaseSpecifier.__hash__�otherc
Cr)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__7rzBaseSpecifier.__eq__c


Cr)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�prereleases@rzBaseSpecifier.prereleases�valueNc
Cr)zQSetter for :attr:`prereleases`.

        :param value: The value to set.
        Nr�rr$rrrr#Ir�itemr#c
Cr)zR
        Determines if the given item is contained within this specifier.
        Nr)rr&r#rrr�containsPrzBaseSpecifier.contains�iterablec
Cr)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�filterVrzBaseSpecifier.filterr)rrr�abc�abstractmethod�strr�intr�object�boolr"�propertyrr#�setterr'r�UnparsedVersionrr)rrrrr)s.







�
�
��r)
�	metaclassc	@s.eZ
dZd
ZdZdZe�deedejej	B�Z
dddd	d
ddd
d�ZdFdede
eddfdd�Zedefdd��
Zejdeddfdd��
Zedefdd��
Zedefdd��
Zdefdd�Zdefd d!�Zedeeeffd"d#��
Zdefd$d%�Zd&edefd'd(�Zd)edefd*d+�Zd,ededefd-d.�Z d,ededefd/d0�Z!d,ededefd1d2�Z"d,ededefd3d4�Z#d,ededefd5d6�Z$d,ed7edefd8d9�Z%d,ed7edefd:d;�Z&d,ededefd<d=�Z'd>e(eefdefd?d@�Z)	dGd>e*de
edefdAdB�Z+	dGdCe,e*de
ede-e*fdDdE�Z.dS)H�	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
                        [-_\.]?
                        (a|b|c|rc|alpha|beta|pre|preview)
                        [-_\.]?
                        [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
                    [-_\.]?
                    (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
            )
        )
        z^\s*z\s*$Z
compatibleZequalZ	not_equalZless_than_equalZgreater_than_equalZ	less_thanZgreater_thanZ	arbitrary)�~=�==z!=�<=�>=�
<�
>�===�N�specr#rcCsH|j�
|
�
}|std
|
�d��
�
|�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)rr=r#�matchrrr�__init__�s



�
zSpecifier.__init__c
CsR|jdu
r|jS|j
\}
}|
d
vr'|
dkr |�d�
r |dd�}t|�
jr'dSdS)N)r6r8r7r5r;r6�.*���TF)rErD�endswithr�
is_prerelease)rr?r
rrrr#�s






zSpecifier.prereleasesr$cC�
|
|_dSr�
rEr%rrrr#
�
c

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

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

CrO)zaThe version of this specifier.

        >>> Specifier("==1.2.3").version
        '1.2.3'
        r
rPrrrrr

rQzSpecifier.versionc
Cs8|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=r<r9�
(�)>)rEr#�	__class__rr,�rZprerrr�__repr__"
s

��zSpecifier.__repr__c

Cs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{}{})�formatrDrrrrr4
szSpecifier.__str__c
Cs*t|j
d
|j
ddkd�}
|j
d|
fS)Nr
r
r5�
Zstrip_trailing_zero)rrD)rZcanonical_versionrrr�_canonical_spec>
s


�zSpecifier._canonical_specc

C�
t|j
�
Sr)�hashrZrrrrrF
�

zSpecifier.__hash__r cCsPt|
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
        )rr,rUr�NotImplementedrZr!rrrr"I
s




�
zSpecifier.__eq__�opcCst|d
|j
|
���}|S)NZ	_compare_)�getattr�
_operators)rr_�operator_callablerrr�
_get_operatorf
s

�zSpecifier._get_operator�prospectivecCsJd
�t
t�tt|�
��
dd��
}|d7}|�d�
|
|�o$|�d�
|
|�S)N�
.���rHr8r6)�join�list�	itertools�	takewhile�_is_not_suffix�_version_splitrc)rrdr=�prefixrrr�_compare_compatiblel
s

�
�zSpecifier._compare_compatiblecCs~|�d
�
r/t
|
j�
}t
|dd�dd�}t|�
}t|�
}t||�\}}|dt|�
�}	|	|kSt|�
}
|
js;t|
j�
}
|
|
kS)NrHrIFrY)rJr�publicrl�_pad_version�lenr�local)rrdr=Znormalized_prospectiveZnormalized_specZ
split_specZsplit_prospectiveZpadded_prospective�
_Zshortened_prospectiveZspec_versionrrr�_compare_equal�
s



zSpecifier._compare_equalcCs|�|
|�Sr)
rt�rrdr=rrr�_compare_not_equal�
s
zSpecifier._compare_not_equalcCst|
j
�
t|�
k
Sr�rrorurrr�_compare_less_than_equal�
�z"Specifier._compare_less_than_equalcCst|
j
�
t|�
kSrrwrurrr�_compare_greater_than_equal�
ryz%Specifier._compare_greater_than_equal�spec_strcCs<t|�
}|
|ks
d
S|j
s|
j
rt|
j�
t|j�
krd
SdS�NFT)rrK�base_version�rrdr{r=rrr�_compare_less_than�
s


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




zSpecifier._compare_greater_thancCst|
�
�
�t|�
�
�kSr)r,�lowerrurrr�_compare_arbitrary�
s
zSpecifier._compare_arbitraryr&cC�
|�|
�
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__cCs<|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#rrKrcr?r
)rr&r#Znormalized_itemrbrrrr'	s



zSpecifier.containsr(ccs��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'rKr#�append)rr(r#�yielded�found_prereleases�kwr
�parsed_versionrrrr)7s*�


�
�
�

�
zSpecifier.filter�r<Nr)/rrrrZ_operator_regex_strZ_version_regex_str�re�compile�VERBOSE�
IGNORECASEr@rar,rr/rGr0r#r1r?r
rWrrrZr-rr.r"�CallableOperatorrcrrnrtrvrxrzrr�r�r	r�r2r'rrr)rrrrr4`st
	^


�






�





'�
�
�
�/�
�
��r4z^([0-9]+)((?:a|b|c|rc)[0-9]+)$c
Cs@g}
|�d
�
D]}t
�|�
}|r|
�|���

q|
�|�

q|
S)Nre)�split�
_prefix_regexrA�extend�groupsr�)r
�resultr&rFrrrrlxs






rl�segmentc

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


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


�rk�left�rightc
Cs�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

Sr�rr�r�rrrr��r�r
r
�
0)r�rhrirjrq�insert�max�chain)r�r�Z
left_splitZright_splitrrrrp�s



,,
rpc	@s2
eZ
dZd
Z	d%dedeeddfdd�Zedeefd	d
��
Z	e	j
deddfdd
��
Z	defd
d�Zdefdd�Zde
fdd�Zdedefddfdd�Zdedefdd�Zde
fdd�Zdeefdd�Zdedefdd�Z		d&dedeedeedefd d!�Z	d'd"eedeedeefd#d$�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.
    r<N�
specifiersr#rcCsFd
d�|
�d�
D�
}t
�}|D]	}|�t|�
�

qt|�
|_||_dS)aNInitialize 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.
        :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
Ssg|]
}
|
��r|
���qSr)
rC�r��
srrr�
<listcomp>�sz)SpecifierSet.__init__.<locals>.<listcomp>�
,N)r��set�addr4�	frozenset�_specsrE)rr�r#Zsplit_specifiers�parsed�	specifierrrrrG�s



zSpecifierSet.__init__c

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



zSpecifierSet.prereleasesr$cCrLrrMr%rrrr#�rNc
Cs.|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)>
        NrRr<z<SpecifierSet(rT)rEr#r,rVrrrrW�s

��zSpecifierSet.__repr__c

Csd
�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
ss�|]}
t|
�
V
qdSr)
r,r�rrrr��s�z'SpecifierSet.__str__.<locals>.<genexpr>)rg�sortedr�rrrrr�szSpecifierSet.__str__c

Cr[r)r\r�rrrrr�r]zSpecifierSet.__hash__r cCs�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.)rr,r�r^r�r�rE�
ValueError)rr r�rrr�__and__�s$








�
	�
�
�zSpecifierSet.__and__cCs6t|
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
        )rr,r4r�r^r�r!rrrr"s




zSpecifierSet.__eq__c

Cr[)
z7Returns the number of specifiers in this specifier set.)rqr�rrrr�__len__9rNzSpecifierSet.__len__c

Cr[)
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__=s
zSpecifierSet.__iter__r&cCr�)
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�Gr�zSpecifierSet.__contains__�	installedcs\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
3s�|]
}
|
j��
d�V
qd
S)r�Nr�r��r&r#rrr��s�z(SpecifierSet.contains.<locals>.<genexpr>)rrr#rKr}�allr�)rr&r#r�rr�rr'\s







zSpecifierSet.containsr(cCs�|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�r)r/r�rrKr�)rr(r#r=Zfilteredr�r&r�rrrr)�s$,










�
zSpecifierSet.filterr�)NNr)rrrrr,rr/rGr0r#r1rWrr-rr	r�r.r"r�rr4r�r2r�r'rr)rrrrr��sR
�
�
�
�#


 

����
�:�
�
��r�)!rr*rir��typingrrrrrrrr	�utilsrr
rr,r2r/r�rr�r�ABCMetarr4r�r�rlrkrpr�rrrr�<module>
s,

(


7
.