B

��fh��@sH
dZd
dl
Z
d
dlZd
dlZd
dlmZmZmZmZm	Z	m
Z
mZmZ
ddl
mZ
ddlmZ
eeefZeded�ZeeegefZeed	�d
d�ZGdd
�d
e�ZGdd�de
jd�ZGdd�de�Ze�d�
Zeeed	�dd�Zeeed�dd�Zeed�dd�Z eeeee
eeeefd�dd�Z!Gdd �d e�Z"dS)!z�
.. testsetup::

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

Cst|t
�st
|�
}|S)
N)�
isinstancer)
r�r�E/opt/alt/python37/lib/python3.7/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
dZejed
�
dd��
Zejed
�
dd��
Zeje	e
d�dd��
Zeeje
e
d
�
d	d
��
�
Zeje
dd�d
d
��
Zejdee
e
e
d�dd��
Zejdeee
e
eed�dd��
ZdS)�
BaseSpecifier)
rc


Csd
S)z�
        Returns the str representation of this Specifier-like object. This
        should be representative of the Specifier itself.
        Nr)
�selfrrr�__str__+szBaseSpecifier.__str__c


Csd
S)zF
        Returns a hash value for this Specifier-like object.
        Nr)
rrrr�__hash__2szBaseSpecifier.__hash__)�otherrc
Csd
S)z�
        Returns a boolean representing whether or not the two Specifier-like
        objects are equal.

        :param other: The other object to check against.
        Nr)rrrrr�__eq__8szBaseSpecifier.__eq__c


Csd
S)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.
        Nr)
rrrr�prereleasesAszBaseSpecifier.prereleasesN)�valuerc
Csd
S)zQSetter for :attr:`prereleases`.

        :param value: The value to set.
        Nr)rr!rrrr Js)�itemr rc
Csd
S)zR
        Determines if the given item is contained within this specifier.
        Nr)rr"r rrr�containsQszBaseSpecifier.contains)�iterabler rc
Csd
S)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�filterWszBaseSpecifier.filter)
N)
N)rrr�abc�abstractmethod�strr�intr�object�boolr�propertyrr �setterr#rr
rr%rrrrr*s 








r)
�	metaclassc	@s�
eZ
dZd
ZdZdZe�deedejej	B�Z
dddd	d
ddd
d�ZdFee
edd�dd�Zeed�
dd��
Zejedd�dd��
Zeed�
dd��
Zeed�
dd��
Zed�
dd�Zed�
dd �Zeeeefd�
d!d"��
Zed�
d#d$�Zeed%�d&d'�Zeed(�d)d*�Zeeed+�d,d-�Z eeed+�d.d/�Z!eeed+�d0d1�Z"eeed+�d2d3�Z#eeed+�d4d5�Z$eeed6�d7d8�Z%eeed6�d9d:�Z&eeed+�d;d<�Z'e(eefed=�d>d?�Z)dGe*e
eed@�dAdB�Z+dHe,e-e
ee.e-dC�dDdE�Z/dS)I�	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~=z==z!=z<=z>=�
<�
>z===�N)�specr rcCsH|j�
|
�
}|s td
|
�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: '�
'�operatorrN)�_regex�searchr�group�strip�_spec�_prereleases)rr;r �matchrrr�__init__�s



zSpecifier.__init__)
rc
CsR|jdk	r|jS|j
\}
}|
d
krN|
dkr@|�d�
r@|dd�}t|�
jrNdSdS)N)z==z>=z<=z~=z===z==z.*���TF)rCrB�endswithr�
is_prerelease)rr=rrrrr �s






zSpecifier.prereleases)r!rcCs
|
|_dS)
N)
rC)rr!rrrr 
sc

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

        >>> Specifier("==1.2.3").operator
        '=='
        r
)
rB)
rrrrr=
szSpecifier.operatorc

Cs
|jd
S)zaThe version of this specifier.

        >>> Specifier("==1.2.3").version
        '1.2.3'
        r
)
rB)
rrrrr
szSpecifier.versionc
Cs8|jd
k	rd|j
��nd}
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)>
        Nz, prereleases=r:r8�
(z)>)rCr �	__class__rr()r�prerrr�__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{}{})�formatrB)
rrrrr6
szSpecifier.__str__c
Cs*t|j
d
|j
ddkd�}
|j
d|
fS)Nr
r
z~=)
�strip_trailing_zero)rrB)rZcanonical_versionrrr�_canonical_spec@
s

zSpecifier._canonical_specc

Cs
t|j
�
S)
N)�hashrO)
rrrrrH
s
zSpecifier.__hash__)rrcCsPt|
t
�r4y|�t
|
�
�
}
WqDtk
r0


tSXnt|
|j�sDtS|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(rJr�NotImplementedrO)rrrrrrK
s






zSpecifier.__eq__)�oprcCst|d
|j
|
���}|S)NZ	_compare_)�getattr�
_operators)rrR�operator_callablerrr�
_get_operatorh
s

zSpecifier._get_operator)�prospectiver;rcCsHtt
t�tt|�
��
dd
��
}|d7}|�d�
|
|�oF|�d�
|
|�S)N���z.*z>=z==)�
_version_join�list�	itertools�	takewhile�_is_not_suffix�_version_splitrV)rrWr;�prefixrrr�_compare_compatiblen
s



zSpecifier._compare_compatiblecCs�|�d
�
rbt
|
jdd�}t
|dd�dd�}t|�
}t|�
}t||�\}}|dt|�
�}	|	|kSt|�
}
|
jszt|
j�
}
|
|
kSdS)Nz.*F)
rNrF)rGr�publicr^�_pad_version�lenr�local)rrWr;Znormalized_prospectiveZnormalized_spec�
split_spec�split_prospective�padded_prospective�
_�shortened_prospective�spec_versionrrr�_compare_equal�
s



zSpecifier._compare_equalcCs|�|
|�S)
N)
rk)rrWr;rrr�_compare_not_equal�
s
zSpecifier._compare_not_equalcCst|
j
�
t|�
k
S)
N)rra)rrWr;rrr�_compare_less_than_equal�
sz"Specifier._compare_less_than_equalcCst|
j
�
t|�
kS)
N)rra)rrWr;rrr�_compare_greater_than_equal�
sz%Specifier._compare_greater_than_equal)rW�spec_strrcCs<t|�
}|
|ksd
S|j
s8|
j
r8t|
j�
t|j�
kr8d
SdS)NFT)rrH�base_version)rrWror;rrr�_compare_less_than�
s


zSpecifier._compare_less_thancCs^t|�
}|
|ksd
S|j
s8|
j
r8t|
j�
t|j�
kr8d
S|
jdk	rZt|
j�
t|j�
krZd
SdS)NFT)r�is_postreleaserprd)rrWror;rrr�_compare_greater_than�
s





zSpecifier._compare_greater_thancCst|
�
�
�t|�
�
�kS)
N)r(�lower)rrWr;rrr�_compare_arbitrary�
s
zSpecifier._compare_arbitrary)r"rcCs
|�|
�
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__�
szSpecifier.__contains__)r"r rcCs<|d
kr|j}t
|
�
}|jr$|s$dS|�|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 rrHrVr=r)rr"r �normalized_itemrUrrrr#
s



zSpecifier.contains)r$r rccs�d
}g}d|dk	r|ndi
}xH|
D]@}t|�
}|j
|f
|�
r"|jrX|sX|jsX|�|�

q"d}|V
q"W|s�|r�x|D]
}|V
qtWdS)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#rHr �append)rr$r �yielded�found_prereleases�kwr�parsed_versionrrrr%;s









zSpecifier.filter)r:N)
N)
N)0rrrrZ_operator_regex_strZ_version_regex_str�re�compile�VERBOSE�
IGNORECASEr>rTr(rr+rEr,r r-r=rrLrrrOr)rr*r�CallableOperatorrVrr`rkrlrmrnrqrsrur	rv�UnparsedVersionr#rr
rr%rrrrr/asV]














)

-
r/z^([0-9]+)((?:a|b|c|rc)[0-9]+)$c
Csbg}
|�d
�
\}}}|
�
|pd�

x:|�d�
D],}t�|�
}|rP|
�|���

q.|
�
|�

q.W|
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�
.)�
rpartitionrx�split�
_prefix_regexr?�extend�groups)r�result�epochrh�restr"rDrrrr^|s





r^)�
componentsrc
Cs|^
}
}|
�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�rrrrY�s
rY)�segmentrc

st�f
d
d�dD�
�
S)Nc
3s|]}
��|
�
V
qdS)
N)
�
startswith)�.0r_)
r�rr�	<genexpr>�sz!_is_not_suffix.<locals>.<genexpr>)�dev�
a�
b�rc�post)
�any)
r�r)
r�rr]�s

r])�left�rightrc
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

Ss|��S)
N)
�isdigit)
�
xrrr�<lambda>��z_pad_version.<locals>.<lambda>c

Ss|��S)
N)
r�)
r�rrrr��r�r
r
r�)	rxrZr[r\rc�insert�max�chain�
from_iterable)r�r��
left_split�right_splitrrrrb�s



,
,
rbc@s
eZ
dZd
Zd$eeedd�dd�Zeeed�
dd	��
Z	e	j
edd
�dd	��
Z	ed�
dd
�Zed�
dd�Ze
d�
dd�Zedefdd�dd�Zeed�dd�Ze
d�
dd�Zeed�
dd�Zeed�dd�Zd%eeeeeed�dd �Zd&eeeeeed!�d"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 rcCs.d
d�|
�d�
D�
}t
tt|��
|_||_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)
rA)r��
srrr�
<listcomp>�sz)SpecifierSet.__init__.<locals>.<listcomp>�
,N)r��	frozenset�mapr/�_specsrC)rr�r �split_specifiersrrrrE�szSpecifierSet.__init__)
rc

Cs.|jdk	r|jS|j
sdStd
d�|j
D�
�
S)Nc
ss|]}
|
jV
qdS)
N)
r )r�r�rrrr��sz+SpecifierSet.prereleases.<locals>.<genexpr>)rCr�r�)
rrrrr �s



zSpecifierSet.prereleases)r!rcCs
|
|_dS)
N)
rC)rr!rrrr �sc
Cs.|jd
k	rd|j
��nd}
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)>
        Nz, prereleases=r:z<SpecifierSet(z)>)rCr r()rrKrrrrL�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
qdS)
N)
r()r�r�rrrr�sz'SpecifierSet.__str__.<locals>.<genexpr>)r��sortedr�)
rrrrrszSpecifierSet.__str__c

Cs
t|j
�
S)
N)rPr�)
rrrrrs
zSpecifierSet.__hash__)rrcCs�t|
t
�rt|
�
}
nt|
t�s"tSt�}t|j|
jB�
|_|jd
krX|
jd
k	rX|
j|_n<|jd
k	rv|
jd
krv|j|_n|j|
jkr�|j|_ntd�
�
|S)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�rQr�r�rC�
ValueError)rr�	specifierrrr�__and__s
















zSpecifierSet.__and__cCs6t|
t
tf�rtt
|
�
�
}
nt|
t�s*tS|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(r/r�rQr�)rrrrrr6s




zSpecifierSet.__eq__c

Cs
t|j
�
S)
z7Returns the number of specifiers in this specifier set.)rcr�)
rrrr�__len__PszSpecifierSet.__len__c

Cs
t|j
�
S)
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__TszSpecifierSet.__iter__)r"rcCs
|�|
�
S)
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#)rr"rrrrv^szSpecifierSet.__contains__)r"r �	installedrcs\t�t
�st
��
��
d
kr |j�
�
s.�jr.dS|rB�jrBt
�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 N)
r#)r�r�)r"r rrr��sz(SpecifierSet.contains.<locals>.<genexpr>)rrr rHrp�allr�)rr"r r�r)r"r rr#ss







zSpecifierSet.contains)r$r rcCs�|d
kr|j}|j
r>x |j
D]}|j|
t|�
d�}
qWt|
�
Sg}g}x8|
D]0}t|�
}|jrr|sr|s||�|�

qL|�|�

qLW|s�|r�|d
kr�t|�
St|�
Sd
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']
        N)
r )r r�r%r+r�rrHrx)rr$r r;�filteredrzr"r|rrrr%�s",










zSpecifierSet.filter)r:N)NN)
N)rrrrr(rr+rEr,r r-rLrr)rr	r�r*rr�rr/r�r�rvr#rr
r%rrrrr��s(




 


5
r�)#rr&r[r}�typingrrrrrrrr	�utilsrrrr(r�r
r+r�rr�r�ABCMetarr/r~r�r^rYr]rbr�rrrr�<module>	s.


(


7
*