j>4UdZddlmZddlZddlZddlZddlmZmZmZm Z m Z m Z ddl m Z mZmZmZmZmZmZmZmZddlmZddlmZer2ddlZdd lmZmZmZejd krdd lm Z ndd l!m Z dd l"m#Z#dd l m$Z$gdZ%d6dZ&d7dZ'd8dZ(e dZ)e ee*fZ+e de+Z,ej-ej.ej/ej0dZ1de2d<d9d$Z3Gd%d&e4Z5Gd'd(ej6)Z7Gd*d e7Z8d:d1Z9Gd2d3e7Z:d;d5Z;dS)=<===!=z-dict[str, Callable[[Version, Version], bool]]_DIRECT_COMPARE_OPS specifierr parsedr bool | Nonec|j\}}|ds|jdSt|}|||||S|dvrc||}|j|jks*t|jt|jkr|dkr||kn||kSdSdS)a!Match ``parsed`` against ``specifier`` without building a range. Handles ``>=``, ``<=``, ``==``, ``!=``, ``<``, ``>`` when the spec is not a wildcard and ``parsed`` has no local. Returns ``None`` when the range path must be used. Pre-release policy is left to the caller. .*N)<>rG) _specendswithlocalrAget_require_spec_versionepochrrelease)rBrCop_strver_strdirect_comparespec_vs r) _fast_matchrT]s oOFG!9t(,,V44N!~fi&E&Eg&N&NOOO 0099 <6< ' '<+G+G< NL L , , '-mm6F??& Ht 4r(ceZdZdZdS)ra 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__r'r(r)rrzsr(rceZdZdZdZdZed%dZej d%dZ ej d&d Z ej d'd Z eej d(dZ e jd)dZ ej d*d+dZej d,d-dZej d,d.d Zej d/d0d$ZdS)1rzO Abstract base class for :class:`Specifier` and :class:`SpecifierSet`. r')_strr"r3c t|S)z Internal property for match_argsr3selfs r)r[zBaseSpecifier._strs4yyr(cdS)z Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. Nr'r^s r)__str__zBaseSpecifier.__str__r(intcdS)zF Returns a hash value for this Specifier-like object. Nr'r^s r)__hash__zBaseSpecifier.__hash__rbr(otherr,r8cdS)z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. Nr'r_rfs r)__eq__zBaseSpecifier.__eq__rbr(rDcdS)zWhether 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'r^s r) prereleaseszBaseSpecifier.prereleasesrbr(valueNonecdS)zQSetter for :attr:`prereleases`. :param value: The value to set. Nr'r_rls r)rkzBaseSpecifier.prereleasesrbr(NitemrkcdS)zR Determines if the given item is contained within this specifier. Nr')r_rprks r)containszBaseSpecifier.containsrbr(.iterableIterable[UnparsedVersionVar]keyIterator[UnparsedVersionVar]cdSr%r'r_rsrkrus r)filterzBaseSpecifier.filter (+sr( Iterable[T]Callable[[T], UnparsedVersion] Iterator[T]cdSr%r'rxs r)ryzBaseSpecifier.filter cr( Iterable[Any]'Callable[[Any], UnparsedVersion] | None Iterator[Any]cdS)z Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nr'rxs r)ryzBaseSpecifier.filterrbr(r"r3r"rcrfr,r"r8r"rD)rlr8r"rmr%)rpr3rkrDr"r8N.rsrtrkrDrurmr"rvrsr{rkrDrur|r"r}NNrsrrkrDrurr"r)rVrWrXrY __slots____match_args__propertyr[abcabstractmethodrarerirksetterrrtypingoverloadryr'r(r)rrsIN X                  X            _$( ++++_+ _$(.1 _ $(7;         r(r) metaclassc eZdZUdZdZdZejdezdzejej zZ ddddd d d d d Z de d<dFdGdZ dHdZdIdZdJdZedKd ZejdLd"ZdMd$ZdNd'ZedOd(ZedOd)ZdOd*ZdOd+ZedPd-ZdQd/ZdRd2ZdSd5ZdTdUd7Zej dVdWd=Z!ej dVdXdAZ! dYdZdEZ!dS)[r aThis 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). Instances are safe to serialize with :mod:`pickle`. They use a stable format so the same pickle can be loaded in future packaging releases. .. versionchanged:: 26.2 Added a stable pickle format. Pickles created with packaging 26.2+ can be unpickled with future releases. Backward compatibility with pickles from packaging < 26.2 is supported but may be removed in a future release. ) _prereleases_rangesrI _spec_versiona  (?: (?: # 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 .* | (?a: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?a: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?a:[-_\.]?dev[-_\.]?[0-9]*)? # dev release (?a:\+[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. (?:<=|>=|<|>) \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release (?a: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?a: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?a:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) ) z\s* compatibleequal not_equalless_than_equalgreater_than_equal less_than greater_than arbitrary)~=r?r@r>r=rGrH===r _operatorsNr+r3rkrDr"rmc|j|std||}|dr'|dd|dd}}nb|dr'|dd|dd}}n&|dd|dd}}||f|_||_d|_d|_dS)aInitialize 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: rNr)rr?r@r>r=r/r ) _regex fullmatchrstrip startswithrIrrr)r_r+rkoperatorversions r)__init__zSpecifier.__init__cs{$$T** C"#A#A#ABB Bzz|| ??5 ! ! ; $RaR$qrr(..*:*:gHH __; < < ; $RaR$qrr(..*:*:gHH $RaR$qrr(..*:*:gH'/&9 (:>37 r(rVersion | Nonec|j|jd|kr |jdSt|}|dS||f|_|S)zDOne element cache, as only one spec Version is needed per Specifier.Nrr )rr )r_rversion_specifiers r)_get_spec_versionzSpecifier._get_spec_versionsX   )d.@.Cw.N.N%a( (*733  $4%'89  r(rc8||}|J|S)zGet spec version, asserting it's valid (not for === operator). This method should only be called for operators where version strings are guaranteed to be valid PEP 440 versions (not ===). )r)r_r spec_versions r)rMzSpecifier._require_spec_versions) --g66 '''r(Sequence[Interval]c|j|jS|j}|j}|dkrt}n9||d}t |||}||_|S)zConvert this specifier to sorted, non-overlapping version ranges. Each standard operator maps to one or two ranges. ``===`` is modeled as full range (actual check done separately). Cached. NrrF)rrrr rM removesuffixr )r_oprQresultrs r) _to_rangeszSpecifier._to_rangessp < #<  ], ;;)3FF001E1Ed1K1KLLG$R'::F  r(c|j|jS|j\}}|dkrdS|dkr|drdS||}|dS|jS)Nr@Fr?rF)rrIrJr is_prerelease)r_r version_strrs r)rkzSpecifier.prereleasess   ($ $!% + t  5 t   4 4T : : 5((55 ?4$$r(rlc||_dSr%)rros r)rkzSpecifier.prereleasess!r(#tuple[tuple[str, str], bool | None]c|j|jfSr%)rIrr^s r) __getstate__zSpecifier.__getstate__s D-..r(stater,cd|_d|_t|trt |dkr3|\}}t |rt |r||_||_dSt |dkryt|dtr^|\}}| d}| dd}t |rt |r||_||_dSt|trY| d}| dd}t |rt |r||_||_dStd|)Nr/r rIrinvalidzCannot restore Specifier from ) rrr0r1r2r4r9rIrdictrL TypeError)r_rr+rk_ slot_dicts r) __setstate__zSpecifier.__setstate__sp! eU # # 5zzQ$)!k!$''M+,F,F!%DJ(3D%F5zzQ:eAh#=#=$ 9 }}W--'mmNIFF !$''M+,F,F!%DJ(3D%F eT " " 99W%%D))NI>>Kd##  k(B(B ! $/!BBBCCCr(c|jdS)z`The operator of this specifier. >>> Specifier("==1.2.3").operator '==' rrIr^s r)rzSpecifier.operatorz!}r(c|jdS)zaThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rr^s r)rzSpecifier.versionrr(cl|j d|jnd}d|jjdt ||dS)aTA representation of the Specifier that shows all internal state. >>> Specifier('>=1.0.0') =1.0.0')> >>> Specifier('>=1.0.0', prereleases=False) =1.0.0', prereleases=False)> >>> Specifier('>=1.0.0', prereleases=True) =1.0.0', prereleases=True)> N, prereleases=rrG()>rrk __class__rVr3r_r5s r)__repr__zSpecifier.__repr__ sT , 2T- 1 1 1 B4>*AASYYA#AAAAr(c dj|jS)zA 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{}{})formatrIr^s r)razSpecifier.__str__sv}dj))r(tuple[str, str]c|j\}}|dks|dr||fS||}t||dk}||fS)NrrFr)strip_trailing_zero)rIrJrMr)r_rrrcanonical_versions r)_canonical_speczSpecifier._canonical_spec&sw J' u   0 0 6 6 W$ $11':: 0 x4/?   ***r(rcc*t|jSr%)hashrr^s r)rezSpecifier.__hash__4sD()))r(rfr8ct|tr; |t|}n3#t$r tcYSwxYwt||jstS|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 )r0r3rrNotImplementedrrhs r)rizSpecifier.__eq__7s& eS ! ! " &s5zz22# & & &%%%% &E4>22 "! !#u'<<>> "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") True >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True) True rrr_rps r) __contains__zSpecifier.__contains__T&}}T"""r(UnparsedVersioncl|jddkr2tt||g|St |}|dS|t |j|j}|dur |jrdSt||}||St| |S)a'Return 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:`~packaging.version.Version` instance. :param prereleases: Whether or not to match prereleases with this Specifier. If set to ``None`` (the default), it will follow the recommendation from :pep:`440` and match prereleases, as there are no other versions. >>> 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") True >>> Specifier(">=1.2.3", prereleases=False).contains("1.3.0a1") False >>> Specifier(">=1.2.3").contains("1.3.0a1") True .. versionchanged:: 26.0 With ``prereleases=None``, a prerelease now matches. A single version has no alternatives, so the :pep:`440` rule to accept prereleases when nothing else satisfies the specifier applies. Earlier versions rejected it. An unparsable version now returns ``False`` instead of raising :exc:`~packaging.version.InvalidVersion`. rrrkNF) rIr8listryr rrrkrrTrr)r_rprkrCmatchs r)rrzSpecifier.containsisD :a=E ! !T[[$[[IIJJKK K%% >5  -d.?AQRRK %  F$8 5D&))  L"4??#4#4f===r(.rsrtrurvcdSr%r'rxs r)ryzSpecifier.filterrzr(r{r|r}cdSr%r'rxs r)ryzSpecifier.filterrr(rrrc|t|j|j}|jdkr9|jfd|D}t ||St|||S)aFilter items in the given iterable, that match the specifier. :param iterable: An iterable that can contain version strings and :class:`~packaging.version.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 follow the recommendation from :pep:`440` and match prereleases if there are no other versions. :param key: A callable that takes a single argument (an item from the iterable) and returns a version string or :class:`~packaging.version.Version` instance to be used for filtering. >>> 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', ] >>> 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'] >>> list(Specifier(">=1.2.3").filter( ... [{"ver": "1.2"}, {"ver": "1.3"}], ... key=lambda x: x["ver"])) [{'ver': '1.3'}] .. versionchanged:: 26.1 Added the ``key`` parameter. Nrc3K|]8}t|n |k4|V9dSr%)r3lower).0rpru spec_lowers r) z#Specifier.filter..s^s{ttD ::@@BBjPPPPPPr() rrrkrrr_apply_prereleases_filterrr)r_rsrkrumatchesrs ` @r)ryzSpecifier.filtersP  -d.?AQRRK =E ! !++--J$G -Wc;GG G 1 18S+NNNr(rN)r+r3rkrDr"rm)rr3r"r)rr3r"rr"rrrlrDr"rm)r"rrr,r"rmr)r"rrr)rprr"r8r%)rprrkrDr"r8rrrrr)"rVrWrXrYr_specifier_regex_strrecompileVERBOSE IGNORECASErr__annotations__rrrMrrrkrrrrrrrarrerirrrrrryr'r(r)r r s&IZ xRZ%%. R]0JF "    J    !7!7!7!7!7F ! ! ! !*%%%X%6""""//// DDDDBXXBBBB$**** + + +X +****====:####*6>6>6>6>6>p _$( ++++_+ _$(.1 _$(7; 4O4O4O4O4O4O4Or(rrrurrkrcj|t|S|rt|Sfd|DS)zApply ``prereleases=`` handling to an already-matched iterable. ``None`` means PEP 440 default (buffer pre-releases until a final appears); ``True`` yields everything; ``False`` drops pre-releases. Nc3fK|]+}t|n |xj'|V,dSr%)r r)rrprurCs r)rz,_apply_prereleases_filter..s^   $S[TTcc$iiHH HF Q# R Q Q Q Q  r()_pep440_filter_prereleasesiter)rrurkrCs ` @r)rrs`)'3777G}}        r(cbeZdZdZdZ d@dAd ZdBd ZedCdZej dDdZdEdZ dFdZ dGdZ dGdZ dHdZdIdZdJdZdHd ZdKd"ZdLd$ZdMd%ZdMd&ZdNd(ZdOd)ZdPd*ZdPd+ZdPd,ZdQd/Z dRdSd1Zej dTdUd7Zej dTdVd;Z dRdWd?ZdS)Xr!aThis 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. Instances are safe to serialize with :mod:`pickle`. They use a stable format so the same pickle can be loaded in future packaging releases. .. versionchanged:: 26.2 Added a stable pickle format. Pickles created with packaging 26.2+ can be unpickled with future releases. Backward compatibility with pickles from packaging < 26.2 is supported but may be removed in a future release. )_canonicalized_has_arbitrary_is_unsatisfiablerr_specsrN specifiersstr | Iterable[Specifier]rkrDr"rmct|trPd|dD}tt t ||_d|v|_n7t||_td|jD|_t|jdk|_ d|_ d|_ ||_ dS)aInitialize 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^g|]*}||+Sr')rrss r) z)SpecifierSet.__init__..3s-VVVaAGGIIV VVVr(,rc38K|]}dt|vVdSrNr]r s r)rz(SpecifierSet.__init__..<s,%K%K!es1vvo%K%K%K%K%K%Kr(r N)r0r3splitr1mapr rranyr2rrrr)r_rrksplit_specifierss r)rzSpecifierSet.__init__s, j# & & L WV:3C3CC3H3HVVV 16s9FV7W7W1X1XDK"':"5D   ++DK#&%K%Kt{%K%K%K"K"KD !$+..!3.226 (r(tuple[Specifier, ...]c|jsLttt |jt |_d|_|jS)zBDeduplicate, sort, and cache specs for order-sensitive operations.ruT)rr1rfromkeyssortedrr3r^s r)_canonical_specszSpecifierSet._canonical_specsFsG" ' fT[c.J.J.J K KLLDK"&D {r(ct|j|jS|jsdStd|jDrdSdS)Nc3$K|] }|jV dSr%rr s r)rz+SpecifierSet.prereleases..\s$22q}222222r(T)rrrr^s r)rkzSpecifierSet.prereleasesMsT   ($ $ { 4 22dk222 2 2 4tr(rlc"||_d|_dSr%)rrros r)rkzSpecifierSet.prereleasesas!!%r()tuple[tuple[Specifier, ...], bool | None]c|j|jfSr%)rrr^s r)rzSpecifierSet.__getstate__fs T.//r(rr,cd|_d|_t|trt |dkr|\}}t|trnt d|DrUt |rF||_||_t |dk|_ td|D|_ dSt |dkrt|dtr|\}}| dd}| d}t|tr#tt|t }t|trxt d |Dr_t |rP||_||_t |jdk|_ td |jD|_ dSt|tr| dd}| d}t|tr#tt|t }t|trxt d |Dr_t |rP||_||_t |jdk|_ td |jD|_ dSt#d |)Nr/c3@K|]}t|tVdSr%r0r r s r)rz,SpecifierSet.__setstate__..w,DDJq)44DDDDDDr(r c38K|]}dt|vVdSrr]r s r)rz,SpecifierSet.__setstate__..}s,-M-M!es1vvo-M-M-M-M-M-Mr(rr'rrc3@K|]}t|tVdSr%r#r s r)rz,SpecifierSet.__setstate__..r$r(c38K|]}dt|vVdSrr]r s r)rz,SpecifierSet.__setstate__..s,-S-S!es1vvo-S-S-S-S-S-Sr(c3@K|]}t|tVdSr%r#r s r)rz,SpecifierSet.__setstate__..s,@@Q 1i00@@@@@@r(c38K|]}dt|vVdSrr]r s r)rz,SpecifierSet.__setstate__..s,)O)Oa%3q66/)O)O)O)O)O)Or(z!Cannot restore SpecifierSet from )rrr0r1r2allr9rrrrrrrL frozensetrr3r)r_rspecsrkrrs r)rzSpecifierSet.__setstate__ls !% eU # # 5zzQ%*"{ue,, DDeDDDDD &k22  #(DK(3D%*-e**/D'*--M-Mu-M-M-M*M*MD'F5zzQ:eAh#=#=$ 9! h33'mmN;; eY//:!&C"8"8"899Eue,, DDeDDDDD &k22  #(DK(3D%*-dk*:*:a*?D'*--S-St{-S-S-S*S*SD'F eT " " IIh++E))N33K%++ 6fU444555%(( @@%@@@@@ "+..  $ $/!&)$+&6&6!&;#&))O)O4;)O)O)O&O&O#EEEEFFFr(r3cl|j d|jnd}d|jjdt ||dS)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') =1.0.0')> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=False) =1.0.0', prereleases=False)> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=True) =1.0.0', prereleases=True)> NrrrGrrrrs r)rzSpecifierSet.__repr__sT , 2T- 1 1 1 B4>*AASYYA#AAAAr(cddd|DS)anA 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' rc34K|]}t|VdSr%r]r s r)rz'SpecifierSet.__str__..s(@@1A@@@@@@r()joinrr^s r)razSpecifierSet.__str__s1xx@@(=(=(?(?@@@@@@r(rccDt|Sr%)rrr^s r)rezSpecifierSet.__hash__sD))++,,,r(rfSpecifierSet | strct|trt|}nt|tstSt}|j|jz|_t |jdk|_|jp|j|_|j|j|jkr |j|_n#|j |j|_ntd|S)aReturn 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' =1.0.0')> >>> SpecifierSet(">=1.0.0,!=1.0.1") & SpecifierSet('<=2.0.0,!=2.0.1') =1.0.0')> r NzFCannot combine SpecifierSets with True and False prerelease overrides.) r0r3r!rrr2rrr ValueError)r_rfrBs r)__and__zSpecifierSet.__and__s eS ! ! " ''EEE<00 "! ! NN ;5 #&y'7#8#8A#=  #'#6#N%:N     $(9U=O(O(O%*%7I " "   '%)%6I " "X r(r8ct|ttfrtt|}nt|tstS||kS)aWhether 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 )r0r3r r!rrrhs r)rizSpecifierSet.__eq__sk& ec9- . . " U,,EEE<00 "! !$$&&%*@*@*B*BBBr(c*t|jS)z7Returns the number of specifiers in this specifier set.)r2rr^s r)__len__zSpecifierSet.__len__s4;r(Iterator[Specifier]c*t|jS)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) [, =1.0.0')>] )rrr^s r)__iter__zSpecifierSet.__iter__sDK   r(rcr|j|jStd|jD|_|jS)zIntersect all specifiers into a single sequence of version ranges. Empty when unsatisfiable. Callers must ensure ``self._specs`` is non-empty. Nc3>K|]}|VdSr%)rr s r)rz+SpecifierSet._get_ranges..s*1V1VQ!,,..1V1V1V1V1V1Vr()rrrr^s r) _get_rangeszSpecifierSet._get_rangess< < #< 11V1V$+1V1V1VVV |r(c|j}||S|js d|_dS| }|s|}|s*|jdur!t |}||_|S)aCheck whether this specifier set can never be satisfied. Returns True if no version can satisfy all specifiers simultaneously. >>> SpecifierSet(">=2.0,<1.0").is_unsatisfiable() True >>> SpecifierSet(">=1.0,<2.0").is_unsatisfiable() False >>> SpecifierSet("").is_unsatisfiable() False >>> SpecifierSet("==1.0,!=1.0").is_unsatisfiable() True .. versionadded:: 26.1 NF)rrr>_check_arbitrary_unsatisfiablerkr)r_cachedrs r)is_unsatisfiablezSpecifierSet.is_unsatisfiables '  M{ %*D "5%%''' ;88::F D$*e33/0@0@0B0BCCF!' r(c~d|jD}|sdS|djtfd|ddDrdSt |dj|jdur  jrdSd|jD}|sdSdStfd |D S) aCheck === (arbitrary equality) specs for unsatisfiability. === uses case-insensitive string comparison, so the only candidate that can match ``===V`` is the literal string V. This method checks whether that candidate is excluded by other specifiers. c(g|]}|jdk |Srrr s r)rz?SpecifierSet._check_arbitrary_unsatisfiable..Hs$CCC1qzU/B/BQ/B/B/Br(Frc3RK|]!}|jkV"dSr%)rr)rr firsts r)rz>SpecifierSet._check_arbitrary_unsatisfiable..Ns4AAaqy  E)AAAAAAr(r NTc(g|]}|jdk |SrErFr s r)rz?SpecifierSet._check_arbitrary_unsatisfiable..^s$BBB!ajE.A.AA.A.A.Ar(c3BK|]}|VdSr%r)rr  candidates r)rz>SpecifierSet._check_arbitrary_unsatisfiable..fs/??qzz),,??????r()rrrrr rkrr*)r_rstandardrKrHs @@r)r@z+SpecifierSet._check_arbitrary_unsatisfiableAsDC CCC  5! $**,, AAAA9QRR=AAA A A 4#9Q<#788   % %%'&4BBt{BBB 5  4????h???????r(ranges.VersionRangec8ddlm}||S)acReturn the :class:`~packaging.ranges.VersionRange` this set accepts. An empty set yields the full range; an unsatisfiable set yields the empty range. ``===`` specifiers contribute literal-string admission. >>> SpecifierSet(">=1.0,<2.0").to_range() .. versionadded:: 26.3 r ) VersionRange)rrO_from_specifier_set)r_rOs r)to_rangezSpecifierSet.to_rangehs* )(((((//555r(ct|tstd|js|jrt ddS)Nzexpected a SpecifierSetz+set relations do not support === specifiers)r0r!rrr4rhs r)_check_relation_operandz$SpecifierSet._check_relation_operandwsU%.. 7566 6   L%"6 LJKK K L Lr(c||||S)a=Return whether every version matching this set also matches other. :raises ValueError: If either set uses ``===`` specifiers, or the two sets were given different ``prereleases`` arguments (unset on one side counts as different). :raises TypeError: If other is not a :class:`SpecifierSet`. >>> SpecifierSet(">=3.12,<3.13").is_subset(SpecifierSet(">=3.12")) True >>> SpecifierSet(">=3.12").is_subset(SpecifierSet(">=3.12,<3.13")) False .. versionadded:: 26.3 )rSrQ is_subsetrhs r)rUzSpecifierSet.is_subset}s>" $$U+++}}(()9)9:::r(c||||S)aReturn whether every version matching other also matches this set. :raises ValueError: If either set uses ``===`` specifiers, or the two sets were given different ``prereleases`` arguments (unset on one side counts as different). :raises TypeError: If other is not a :class:`SpecifierSet`. >>> SpecifierSet(">=3.12").is_superset(SpecifierSet(">=3.12,<3.13")) True .. versionadded:: 26.3 )rSrQ is_supersetrhs r)rWzSpecifierSet.is_supersets> $$U+++}}**5>>+;+;<<>> SpecifierSet("<3.12").is_disjoint(SpecifierSet(">=3.12")) True >>> SpecifierSet("<3.12").is_disjoint(SpecifierSet(">=3.11")) False .. versionadded:: 26.3 )rSrQ is_disjointrhs r)rYzSpecifierSet.is_disjoints>" $$U+++}}**5>>+;+;<<>> "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") True >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True) True rrs r)rzSpecifierSet.__contains__rr( installedct|}| |r |jrd}||jrt|ts|}n|}||js|jx|jrq|jr|dus | |jdurdS|j}|@|jD]}t||}|n|sdSdS| x}|_t||Stt||g|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:`~packaging.version.Version` instance. :param prereleases: Whether or not to match prereleases with this SpecifierSet. If set to ``None`` (the default), it will follow the recommendation from :pep:`440` and match prereleases, as there are no other versions. :param installed: Whether or not the item is installed. If set to ``True``, it will accept prerelease versions even if the specifier does not allow them. >>> 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") True >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False).contains("1.3.0a1") False >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True) True .. versionchanged:: 26.0 With ``prereleases=None``, a prerelease now matches. A single version has no alternatives, so the :pep:`440` rule to accept prereleases when nothing else satisfies the specifiers applies. Earlier versions rejected it. An unparsable version now returns ``False`` instead of raising :exc:`~packaging.version.InvalidVersion`. NTFr)r rrr0rrKrrrrTr>rr8rry) r_rprkr[r check_itemboundsr+rs r)rrzSpecifierSet.containssJP!&&  9 1F K ?t2?:dG;T;T?JJ J  '  % &$ u$$'D,=,F,Fu\F~ !K  D'g66E} %$uu% 4(,(8(8(:(::&vw77 7Dj\{KKLLMMMr(.rsrtrurvcdSr%r'rxs r)ryzSpecifierSet.filter$rzr(r{r|r}cdSr%r'rxs r)ryzSpecifierSet.filter,rr(rrrc||j|j}|jr]|jr'|jfd|D}t||S|j}||}t |||St||S)aFilter items in the given iterable, that match the specifiers in this set. :param iterable: An iterable that can contain version strings and :class:`~packaging.version.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 follow the recommendation from :pep:`440` and match prereleases if there are no other versions. :param key: A callable that takes a single argument (an item from the iterable) and returns a version string or :class:`~packaging.version.Version` instance to be used for filtering. >>> 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', ] >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.5a1"])) ['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'] >>> list(SpecifierSet(">=1.2.3").filter( ... [{"ver": "1.2"}, {"ver": "1.3"}], ... key=lambda x: x["ver"])) [{'ver': '1.3'}] 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'] .. versionchanged:: 26.0 Prerelease filtering now follows the PEP 440 recommendation of yielding prereleases only when no final release is present. .. versionchanged:: 26.1 Added the ``key`` parameter. Nc3VK|]"tfdDV#dS)c3`K|](}|n dV)dS)NTrr)rr rprus r)rz0SpecifierSet.filter...zsX 3;44CCIISW XXr(N)r*)rrprur,s @r)rz&SpecifierSet.filter..wss!&r()rkrrrrr>r)r_rsrkrurrr,s ` @r)ryzSpecifierSet.filter4sx  4#3#?*K ; H" L  (1#{KKK\F~))++#FHc;GG G)3 DDDr(r)rr rkrDr"rm)r"rrr)r"rrrr)rfr2r"r!r)r"r9r)r"r8)r"rM)rfr,r"rm)rfr!r"r8)rprr"r8r)rprrkrDr[rDr"r8rrrr) rVrWrXrYrrrrrkrrrrrarer5rir8r;r>rBr@rQrSrUrWrYrrrrrryr'r(r)r!r!s$I13#'*(*(*(*(*(XX&&&&&0000 7G7G7G7GrBBBB* A A A A----@CCCC4    !!!!    !!!!F%@%@%@%@N 6 6 6 6LLLL ;;;;(====$====(####0$(!% VNVNVNVNVNp _$( ++++_+ _$(.1 _$(7; SESESESESESESEr(r!rsc#6Kg}g}d}|D]}t||n ||}|2|r|Vn*||||R|js|s |Ed{Vd}|Vj|s|||s |Ed{VdSdS)z?Filter per PEP 440: exclude prereleases unless no finals exist.FNT)r appendr)rsru all_nonfinalarbitrary_strings found_finalrprCs r)rrs!L#%K&& TCC > * !((...##D))) #  #,,,,,,,," JJJ  &    % % %    r()r"r#)r+r,r"r-)r5r,r"r6)rBr rCrr"rD)rrrurrkrDr"r)rsrrurr"r)rss#"""""                       (''''' "JJJ<<<<<<<<<< 7""$$$$$$$//////!!!!!!   0000 GCLL %W1III . . . . FF:     z   S S S S S ckS S S S lIOIOIOIOIO IOIOIOX,I EI EI EI EI E=I EI EI EX' ' ' ' ' ' r(