old-saburly-wagtail-web/env/lib/python3.10/site-packages/packaging/__pycache__/specifiers.cpython-310.pyc

o
<00><><EFBFBD>f"<22><00>@
s
dZd
dl
mZ
d
dlZd
dlZd
dlZd
dlmZmZm	Z	m
Z
mZ
ddlm
Z

ddlmZ
eeefZe
ded	<09>ZeeegefZd*dd<0F>ZGdd<11>de<16>ZGdd<13>dejd<14>ZGdd<16>de<19>Ze<05>d<17>
Zd+dd<1B>Zd,dd<1E>Zd-d!d"<22>Zd.d&d'<27>Z Gd(d)<29>d)e<19>Z!dS)/z<>
.. testsetup::

    from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier
    from packaging.version import Version
<EFBFBD>)
<01>annotationsN)<05>Callable<6C>Iterable<6C>Iterator<6F>TypeVar<61>Union<6F>
)
<01>canonicalize_version)
<01>Version<6F>UnparsedVersionVar)
<01>bound<6E>version<6F>UnparsedVersion<6F>returnr
c

C
st|t
<01>s	t
|<00>
}|S<00>
N)<02>
isinstancer
)
r
<00>r<00>V/home/amir/Desktop/saburlyweb/env/lib/python3.10/site-packages/packaging/specifiers.py<70>_coerce_versions



rc
@
seZ
dZd
ZdS)<03>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)<04>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__rrrrr s
rc@
s<>eZ
dZejddd<04><04>
Zejddd<07><04>
Zejddd<0C><04>
Zeejd dd<0F><04>
<01>
Z	e	j
d!dd<0F><04>
Z	ejd"d#dd<17><05>
Zej	d"d$dd<1C><05>
ZdS)%<25>
BaseSpecifierr<00>strc


C
<01>d
S)z<>
        Returns the str representation of this Specifier-like object. This
        should be representative of the Specifier itself.
        Nr<00>
<01>selfrrr<00>__str__-<00>zBaseSpecifier.__str__<5F>intc


C
r)zF
        Returns a hash value for this Specifier-like object.
        Nrrrrr<00>__hash__4r zBaseSpecifier.__hash__<5F>other<65>object<63>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<00>rr#rrr<00>__eq__:r zBaseSpecifier.__eq__<5F>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<00>prereleasesCr zBaseSpecifier.prereleases<65>value<75>Nonec
C
r)zQSetter for :attr:`prereleases`.

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




<12>r)
<01>	metaclassc	@
sH
eZ
dZd
ZdZdZe<06>deedejej	B<00>Z
dddd	d
ddd
d<0E>ZdSdTdd<18>Ze
dUdd<1B><04>
ZejdVdd<1B><04>
Ze
dWdd<1F><04>
Ze
dWd d!<21><04>
ZdWd"d#<23>ZdWd$d%<25>Ze
dXd'd(<28><04>
ZdYd*d+<2B>ZdZd.d/<2F>Zd[d2d3<64>Zd\d6d7<64>Zd\d8d9<64>Zd\d:d;<3B>Zd\d<d=<3D>Zd\d>d?<3F>Zd]dAdB<64>Zd]dCdD<64>Zd\dEdF<64>Zd^dIdJ<64>Z d_d`dLdM<64>Z!	d_dadQdR<64>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*$<24>
compatible<EFBFBD>equal<61>	not_equal<61>less_than_equal<61>greater_than_equal<61>	less_than<61>greater_than<61>	arbitrary)<08>~=<3D>==z!=<3D><=<3D>>=<3D>
<<3C>
><3E>===<3D>N<>specrr)r(rr+cC
sH|j<00>
|
<01>
}|std
|
<01>d<02><03>
<01>
|<03>d<03>
<01><04>|<03>d<04>
<01><04>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: '<27>
'<27>operatorr
N)<07>_regex<65>searchr<00>group<75>strip<69>_spec<65>_prereleases)rrOr)<00>matchrrr<00>__init__<5F>s



<06>
zSpecifier.__init__r%c
C
sR|jdu
r|jS|j
\}
}|
d
vr'|
dkr |<02>d<03>
r |dd<04>}t|<02>
jr'dSdS)N)rHrJrIrGrMrH<00>.*<2A><><EFBFBD><EFBFBD><EFBFBD>TF)rWrV<00>endswithr
<00>
is_prerelease)rrQr
rrrr)<00>s






zSpecifier.prereleasesr*cC
<01>
|
|_dSr<00>
rWr,rrrr)
<00>
c

C
<01>
|jd
S)z`The operator of this specifier.

        >>> Specifier("==1.2.3").operator
        '=='
        r
<00>
rVrrrrrQ
<00>
zSpecifier.operatorc

C
ra)zaThe version of this specifier.

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

rczSpecifier.versionc
C
s8|jd
u
rd|j
<01><02>n
d}
d|jj<03>dt|<00>
<01>|
<01>d<06>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<00>
(<28>)>)rWr)<00>	__class__rr<00>r<00>prerrr<00>__repr__&
s

<0C><02>zSpecifier.__repr__c

C
sd
j|j
<01>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{}{})<02>formatrVrrrrr8
szSpecifier.__str__<5F>tuple[str, str]c
C
s*t|j
d
|j
ddkd<04>}
|j
d|
fS)Nrr
rG<00>
<01>strip_trailing_zero)r	rV)r<00>canonical_versionrrr<00>_canonical_specB
s


<06>zSpecifier._canonical_specr!c

C
<01>
t|j
<01>
Sr)<02>hashrprrrrr"J
<00>

zSpecifier.__hash__r#r$cC
sPt|
t
<01>rz	|<00>t
|
<01>
<01>
}
Wnty


tYSwt|
|j<02>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
        )rrrgr<00>NotImplementedrpr&rrrr'M
s




<02>
zSpecifier.__eq__<5F>op<6F>CallableOperatorcC
st|d
|j
|
<00><00><02>}|S)N<>	_compare_)<02>getattr<74>
_operators)rru<00>operator_callablerrr<00>
_get_operatorj
s

<04>zSpecifier._get_operator<6F>prospectiver
cC
sHtt
t<02>tt|<02>
<01><02>
dd
<01><00>
}|d7}|<00>d<03>
|
|<02>o#|<00>d<04>
|
|<03>S)N<><4E><EFBFBD><EFBFBD><EFBFBD>rZrJrH)<07>
_version_join<69>list<73>	itertools<6C>	takewhile<6C>_is_not_suffix<69>_version_splitr{)rr|rO<00>prefixrrr<00>_compare_compatiblep
s	
<04>
<04>zSpecifier._compare_compatiblecC
s<>|<02>d
<01>
r1t
|
jdd<03>}t
|dd<04>dd<03>}t|<04>
}t|<03>
}t||<05>\}}|dt|<05>
<01>}	|	|kSt|<02>
}
|
js=t|
j<02>
}
|
|
kS)NrZFrmr[)r\r	<00>publicr<63><00>_pad_version<6F>lenr
<00>local)rr|rO<00>normalized_prospective<76>normalized_spec<65>
split_spec<EFBFBD>split_prospective<76>padded_prospective<76>
_<>shortened_prospective<76>spec_versionrrr<00>_compare_equal<61>
s

<06>

zSpecifier._compare_equalcC
s|<00>|
|<02>Sr)
r<><00>rr|rOrrr<00>_compare_not_equal<61>
s
zSpecifier._compare_not_equalcC
st|
j
<01>
t|<02>
k
Sr<00>r
r<>r<>rrr<00>_compare_less_than_equal<61>
<00>z"Specifier._compare_less_than_equalcC
st|
j
<01>
t|<02>
kSrr<>r<>rrr<00>_compare_greater_than_equal<61>
r<>z%Specifier._compare_greater_than_equal<61>spec_strcC
s<t|<02>
}|
|ks
d
S|j
s|
j
rt|
j<02>
t|j<02>
krd
SdS<00>NFT)r
r]<00>base_version<6F>rr|r<>rOrrr<00>_compare_less_than<61>
s


zSpecifier._compare_less_thancC
s^t|<02>
}|
|ks
d
S|j
s|
j
rt|
j<02>
t|j<02>
krd
S|
jdu
r-t|
j<02>
t|j<02>
kr-d
SdSr<>)r
<00>is_postreleaser<65>r<>r<>rrr<00>_compare_greater_than<61>
s





zSpecifier._compare_greater_thancC
st|
<01>
<01>
<01>t|<02>
<01>
<01>kSr)r<00>lowerr<72>rrr<00>_compare_arbitrary<72>
s
zSpecifier._compare_arbitraryr-<00>
str | VersioncC
<01>
|<00>|
<01>
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
        <20>
r.<00>rr-rrr<00>__contains__<5F>
<00>
zSpecifier.__contains__rcC
s<|d
ur|j}t
|
<01>
}|jr|sdS|<00>|j<04>
}|||j<05>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]r{rQr
)rr-r)<00>normalized_itemrzrrrr.	s



zSpecifier.containsr/r0r1cc
s<><00>d
}g}d|du
r|n
di
}|
D]"}t|<06>
}|j
|f
i|<05>
<01>
r3|jr.|s.|js.|<04>|<06>

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)<00>append)rr/r)<00>yielded<65>found_prereleases<65>kwr
<00>parsed_versionrrrr25s*<02>


<02>
<02>
<02>

<08>
zSpecifier.filter<65>rNN)rOrr)r(rr+)rr%r7r3)rrlr4r5)rurrrv)r|r
rOrrr%)r|r
r<>rrr%)r-r<>rr%r)r-rr)r(rr%r8)#rrrr<00>_operator_regex_str<74>_version_regex_str<74>re<72>compile<6C>VERBOSE<53>
IGNORECASErRryrYr;r)r<rQr
rjrrpr"r'r{r<>r<>r<>r<>r<>r<>r<>r<>r<>r.r2rrrrr>csZ
	^


<04>






<06>













(





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

|<04>d<03>
D]}t<03>|<05>
}|r'|
<01>|<06><06><00>

q|
<01>
|<05>

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.
    <20>
!<21>
0<>
.)<07>
rpartitionr<EFBFBD><00>split<69>
_prefix_regexrS<00>extend<6E>groups)r
<00>result<6C>epochr<68><00>restr-rXrrrr<>vs





r<><00>
componentsc
C
s|^
}
}|
<01>d
d<02>|<02>
<01><00>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<>)
<01>join)r<>r<>r<>rrrr~<00>s
r~<00>segmentr%c


st<00>f
d
d<02>dD<00>
<01>
S)Nc
3
s<00>|]}
<01><00>|
<01>
V
qdSr)
<01>
startswith)<02>.0r<EFBFBD><00>
r<>rr<00>	<genexpr><3E>s<02>


<EFBFBD>z!_is_not_suffix.<locals>.<genexpr>)<05>dev<65>
a<>
b<>rc<72>post)
<01>anyr<79>rr<>rr<><00>s


<EFBFBD>r<EFBFBD><00>left<66>right<68>tuple[list[str], list[str]]c
C
s<>gg}}|<02>t
t<02>d
d<02>|<00><02>
<01>

|<03>t
t<02>dd<02>|
<01><02>
<01>

|<02>|t|d<00>
d<00><00>

|<03>|
t|d<00>
d<00><00>

|<02>ddg
tdt|d<00>
t|d<00>
<00><00>
|<03>ddg
tdt|d<00>
t|d<00>
<00><00>
t
tj<07>|<02>
<01>
t
tj<07>|<03>
<01>
fS)Nc

S
<01>|<00><00>Sr<00>
<01>isdigit<69>
<01>
xrrr<00><lambda><3E><00>z_pad_version.<locals>.<lambda>c

S
r<>rr<>r<>rrrr<><00>r<>r
rr<>)	r<>rr<>r<>r<><00>insert<72>max<61>chain<69>
from_iterable)r<>r<><00>
left_split<EFBFBD>right_splitrrrr<><00>s



,,

<04>r<EFBFBD>c@
s<>eZ
dZd
Zd0d1d
d<0B>Zed2dd
<0A><04>
Zejd3dd
<0A><04>
Zd4dd<12>Zd4dd<14>Z	d5dd<17>Z
d6dd<1B>Zd7dd<1E>Zd5dd <20>Z
d8d"d#<23>Zd9d&d'<27>Z		d:d;d)d*<2A>Z	d<d=d.d/<2F>ZdS)><3E>SpecifierSetz<74>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<>
specifiersrr)r(rr+cC
s.d
d<02>|
<01>d<03>
D<00>
}t
tt|<03><02>
|_||_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
S
sg|]
}
|
<01><00>r|
<01><00><00>qSr)
rU<00>r<><00>
srrr<00>
<listcomp><3E>sz)SpecifierSet.__init__.<locals>.<listcomp><3E>
,N)r<><00>	frozenset<65>mapr><00>_specsrW)rr<>r)<00>split_specifiersrrrrY<00>s
zSpecifierSet.__init__c

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



zSpecifierSet.prereleasesr*r%cC
r^rr_r,rrrr)<00>r`c
C
s.|jd
u
rd|j
<01><02>n
d}
dt|<00>
<01>|
<01>d<05>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)>
        NrdrNz<SpecifierSet(rf)rWr)rrhrrrrj<00>s

<0C><02>zSpecifierSet.__repr__c

C
sd
<01>t
dd<03>|jD<00>
<01>
<01>
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<00>|]}
t|
<01>
V
qdSr)
rr<>rrrr<>	s<02>z'SpecifierSet.__str__.<locals>.<genexpr>)r<><00>sortedr<64>rrrrr<00>szSpecifierSet.__str__r!c

C
rqr)rrr<>rrrrr"rszSpecifierSet.__hash__r#<00>SpecifierSet | strcC
s<>t|
t
<01>r
t|
<01>
}
nt|
t<02>stSt<02>}t|j|
jB<00>
|_|jd
ur-|
jd
u
r-|
j|_|S|jd
u
r=|
jd
ur=|j|_|S|j|
jkrI|j|_|Std<02>
<01>
)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<>rtr<>r<>rW<00>
ValueError)rr#<00>	specifierrrr<00>__and__s$








<14>
	<0C>
<02>
<04>zSpecifierSet.__and__r$cC
s6t|
t
tf<02>rtt
|
<01>
<01>
}
nt|
t<03>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<>rtr<>r&rrrr'.s




zSpecifierSet.__eq__c

C
rq)
z7Returns the number of specifiers in this specifier set.)r<>r<>rrrr<00>__len__Hr`zSpecifierSet.__len__<5F>Iterator[Specifier]c

C
rq)
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')>]
        )<02>iterr<72>rrrr<00>__iter__Ls
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<>Vr<>zSpecifierSet.__contains__<5F>	installedc
s\t<00>t
<01>s	t
<01><00>
<01><00>
d
ur|j<02>
<01>
s<17>jrdS|r!<21>jr!t
<01>j<04>
<01>t<05><00>
fdd<04>|jD<00>
<01>
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<00>|]
}
|
j<00><00>
d<00>V
qd
S)r<>Nr<4E>r<><00>r-r)rrr<><00>s<02>z(SpecifierSet.contains.<locals>.<genexpr>)rr
r)r]r<><00>allr<6C>)rr-r)r<>rr<>rr.ks







zSpecifierSet.containsr/r0r1cC
s<>|d
ur|j}|j
r|j
D]}|j|
t|<02>
d<02>}
q
t|
<01>
Sg}g}|
D]}t|<06>
}|jr6|s6|s5|<05>|<06>

q#|<04>|<06>

q#|sH|rH|d
urHt|<05>
St|<04>
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<4E>)r)r<>r2r%r<>rr]r<>)rr/r)rO<00>filteredr<64>r-r<>rrrr2<00>s$,










<02>
zSpecifierSet.filterr<72>)r<>rr)r(rr+r6r7r3r4)r#r<>rr<>r5)rr<>)r-rrr%)NN)r-rr)r(r<>r(rr%rr8)rrrrrYr;r)r<rjrr"r<>r'r<>r<>r<>r.r2rrrrr<><00>s(







 




<0C>:<10>r<EFBFBD>)r
rrr
)r
rrr<>)r<>r<>rr)r<>rrr%)r<>r<>r<>r<>rr<>)"r<00>
__future__rr9r<>r<><00>typingrrrrr<00>utilsr	r
r
rrrr%rvrr<>r<00>ABCMetarr>r<>r<>r<>r~r<>r<>r<>rrrr<00><module>
s2






7