ցj>j%SrSSKJr SSKrSSKrSSKrSSKJrJrJrJ r J r J r SSK J r JrJrJrJrJrJrJrJr SSKJr SSKJr \(a7SSKrSS KJrJrJr \R>S :aSS KJ r OSS K!J r SS K"J#r# SS K J$r$ /SQr%S$Sjr&S%Sjr'S&Sjr(\ "S5r)\ \\*4r+\ "S\+S9r,\RZ\R\\R^\R`S.r1S\2S'S'Sjr3"SS\45r5"SS\RlS9r7"SS\75r8S(S jr9"S!S"\75r:S)S#jr;g)*z .. testsetup:: from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from packaging.version import Version ) annotationsN) TYPE_CHECKINGAnyCallableFinalTypeVarUnion) FULL_RANGEbounds_for_speccoerce_versionfilter_by_rangesintersect_specifier_boundsmatches_bounds_onlyranges_are_prerelease_onlyresolve_prereleases trim_release)canonicalize_version)Version)IterableIteratorSequence) ) TypeGuard)ranges)Interval) BaseSpecifierInvalidSpecifier Specifier SpecifierSetc[$N)__all__N/mnt/workspace/venv-train/lib/python3.13/site-packages/packaging/specifiers.py__dir__r(<s Nr&c[U[5=(aB [U5S:H=(a- [US[5=(a [US[5$)Nrr ) isinstancetuplelenstr)specs r'_validate_specr0@sI4 % IN % tAw $ % tAw $ r&c8USL=(d [U[5$r#)r+bool)pres r' _validate_prer4Is $; /*S$//r&TUnparsedVersionVar)bound)>=<===!=z-dict[str, Callable[[Version, Version], bool]]_DIRECT_COMPARE_OPSr cURup#URS5(d URbg[R U5nUbU"XR U55$US;afUR U5nUR UR :wd,[UR5[UR5:waUS:XaX:$X:$gg)aMatch ``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)<>r?) _specendswithlocalr<get_require_spec_versionepochrrelease) specifierparsedop_strver_strdirect_comparespec_vs r' _fast_matchrN]s ooOF!9(,,V4N!f&E&Eg&NOO 009 <<6<< '<+G< NNL , '-m6? H H r&c\rSrSrSrSrg)rzz 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' r%N)__name__ __module__ __qualname____firstlineno____doc____static_attributes__r%r&r'rrzsr&rc\rSrSrSrSrSr\SSj5r\ RSSj5r \ RSSj5r \ RSSj5r \\ RSS j55r\RSS j5r\ RSSS jj5r\R$SSS jj5r\R$SSSjj5r\ RSSSjj5rSrg )rzG Abstract base class for :class:`Specifier` and :class:`SpecifierSet`. r%)_strc[U5$)z Internal property for match_argsr.selfs r'rYBaseSpecifier._strs4yr&cg)zv Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. Nr%r\s r'__str__BaseSpecifier.__str__r&cg)z6 Returns a hash value for this Specifier-like object. Nr%r\s r'__hash__BaseSpecifier.__hash__rbr&cg)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]others r'__eq__BaseSpecifier.__eq__rbr&cg)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' prereleasesBaseSpecifier.prereleasesrbr&cg)zASetter for :attr:`prereleases`. :param value: The value to set. Nr%r]values r'rlrmrbr&Ncg)zB Determines if the given item is contained within this specifier. Nr%)r]itemrls r'containsBaseSpecifier.containsrbr&cgr#r%r]iterablerlkeys r'filterBaseSpecifier.filter (+r&cgr#r%rvs r'ryrz r&cg)z} Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nr%rvs r'ryrzrbr&returnr.rintrhobjectrr2r bool | None)rpr2rNoner#)rrr.rlrrr2N.rwzIterable[UnparsedVersionVar]rlrrxrrzIterator[UnparsedVersionVar]rwz Iterable[T]rlrrxzCallable[[T], UnparsedVersion]rz Iterator[T]NNrw Iterable[Any]rlrrx'Callable[[Any], UnparsedVersion] | Noner Iterator[Any])rQrRrSrTrU __slots____match_args__propertyrYabcabstractmethodr`rdrirlsetterrstypingoverloadryrVr%r&r'rrsIN                  __$( +.+!+ + & ++ __$(.1 !,    $(7;    !  5      r&r) metaclassc 6\rSrSr%SrSrSr\R"S\-S-\R\R-5r SSSS S S S S S.r S\ S'S&S'SjjrS(SjrS)SjrS*Sjr\S+Sj5r\R(S,Sj5rS-SjrS.Sjr\S/Sj5r\S/Sj5rS/SjrS/Sjr\S0Sj5rS1SjrS2S jrS3S!jrS4S5S"jjr\ RBS6S7S#jj5r"\ RBS6S8S$jj5r"S9S:S%jjr"Sr#g);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_rangesrA _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;r9r8r?r@===r _operatorsNcURRU5(d[SU<35eUR5nUR S5(aUSSUSSR5pCOEUR S5(aUSSUSSR5pCOUSSUSSR5pCX44UlX lSUlSUlg)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;r9r8r*r ) _regex fullmatchrstrip startswithrArrr)r]r/rloperatorversions r'__init__Specifier.__init__cs{{$$T**"%8#AB Bzz| ??5 ! ! $Ra$qr(..*:g __; < < $Ra$qr(..*:g $Ra$qr(..*:g'/&9 (:>37 r&cURb"URSU:XaURS$[U5nUcgX4UlU$)zDOne element cache, as only one spec Version is needed per Specifier.Nrr )rr )r]rversion_specifiers r'_get_spec_versionSpecifier._get_spec_versionsV    )d.@.@.Cw.N%%a( (*73  $%9  r&c2URU5nUceU$)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'rESpecifier._require_spec_versions& --g6 '''r&cURb UR$URnURnUS:Xa[nO,UR UR S55n[ XU5nX0lU$)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. rr>)rrrr rE removesuffixr )r]oprKresultrs r' _to_rangesSpecifier._to_rangessg << #<<  ]],, ;)3F001E1Ed1KLG$R':F  r&cURb UR$URupUS:XagUS:XaURS5(agURU5nUcgUR$)Nr;Fr:r>)rrArBr is_prerelease)r]r version_strrs r'rlSpecifier.prereleasessz    ($$ $!%  t  t  4 4T : :((5 ?$$$r&cXlgr#)rros r'rlrs!r&c2URUR4$r#)rArr\s r' __getstate__Specifier.__getstate__s D--..r&cSUlSUl[U[5(a[ U5S:Xa1Uup#[ U5(a[ U5(a X lX0lg[ U5S:Xal[US[5(aTUupEURS5nURSS5n[ U5(a[ U5(a X lX0lg[U[5(aPURS5nURSS5n[ U5(a[ U5(a X lX0lg[SU<35e)Nr*r rArinvalidzCannot restore Specifier from ) rrr+r,r-r0r4rArdictrD TypeError)r]stater/rl_ slot_dicts r' __setstate__Specifier.__setstate__s! eU # #5zQ$)!!$''M+,F,F!%J(3%5zQ:eAh#=#=$  }}W-'mmNIF !$''M+,F,F!%J(3% eT " "99W%D))NI>Kd## k(B(B! $/!8 BCCr&c URS$)zHThe operator of this specifier. >>> Specifier("==1.2.3").operator '==' rrAr\s r'rSpecifier.operatorzz!}r&c URS$)zIThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rr\s r'rSpecifier.versionrr&cURbSUR<3OSnSURRS[ U5<US3$)aA 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)> , prereleases=r?()>rrl __class__rQr.r]r3s r'__repr__Specifier.__repr__ sU  ,T--0 1 4>>**+1SYM#bAAr&c4SR"UR6$)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{}{})formatrAr\s r'r`Specifier.__str__s}}djj))r&cURupUS:XdURS5(aX4$URU5n[X1S:gS9nX4$)Nrr>r)strip_trailing_zero)rArBrEr)r]rrrcanonical_versions r'_canonical_specSpecifier._canonical_spec&s] JJ u  0 0 6 6$ $11': 0 4/? **r&c,[UR5$r#)hashrr\s r'rdSpecifier.__hash__4sD(())r&c[U[5(aUR[U55nO [XR5(d[$UR UR :H$![a [s$f=f)aWhether 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 )r+r.rrNotImplementedrrgs r'riSpecifier.__eq__7sm& eS ! ! &s5z2E>>22! !##u'<'<<< $ &%% &sA++A>=A>c$URU5$)aReturn 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") True >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True) True rsr]rrs r' __contains__Specifier.__contains__T&}}T""r&c TURSS:Xa#[[URU/US955$[ U5nUcgUc [ UR UR5nUSLaUR(ag[X5nUbU$[UR5U5$)aWReturn 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`. rrrlF) rAr2listryr rrrlrrNrr)r]rrrlrImatchs r'rsSpecifier.containsisD ::a=E !T[[$[[IJK K% >  -d.?.?AQAQRK % F$8$8D)  L"4??#4f==r&cgr#r%rvs r'rySpecifier.filterr{r&cgr#r%rvs r'ryrr}r&c ^^Uc [URUR5nURS:Xa4URR 5mUU4SjU5n[ UTU5$[UR5UTU5$)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. rc3|># UH1n[TcUOT"U55R5T:XdM-Uv M3 g7fr#)r.lower).0rrrx spec_lowers r' #Specifier.filter..s:$Ds{tD :@@BjP$s,< <) rrrlrrr_apply_prereleases_filterrr)r]rwrlrxmatchesrs ` @r'ryrszP  -d.?.?AQAQRK ==E !++-J$G -Wc;G G 18S+NNr&rN)r/r.rlrrr)rr.rzVersion | None)rr.rrrzSequence[Interval]rrprrr)rz#tuple[tuple[str, str], bool | None]rrrrr)rztuple[str, str]rr)rrz str | Versionrr2r#)rrUnparsedVersionrlrrr2rrrrr)$rQrRrSrTrUr_specifier_regex_strrecompileVERBOSE IGNORECASErr__annotations__rrrErrrlrrrrrrr`rrdrirrsrrryrVr%r&r'r r s&IZ xZZ%%. R]]0JF "   J !7F !*%%6""/ DBB$* + +*=:#*6>p __$( +.+!+ + & ++ __$(.1 !,   $(7; 4O4O!4O5 4O  4O4Or&cb^^Uc [UT5$U(a [U5$UU4SjU5$)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. c3># UH3n[TcUOT"U55=mbTR(aM/Uv M5 g7fr#)r r)rrrrxrIs r'r,_apply_prereleases_filter..s= D$S[Tc$iH HF Q## s.> >)_pep440_filter_prereleasesiter)rrxrlrIs ` @r'rrs7)'377G}  r&c\rSrSrSrSrSS SjjrS!Sjr\S"Sj5r \ RS#Sj5r S$S jr S%S jr S&S jr S&S jrS'S jrS(SjrS)SjrS'SjrS*SjrS+SjrS,SjrS,SjrS-SjrS.SjrS/SjrS/SjrS/SjrS0SjrS1S2Sjjr\R>S3S4Sjj5r \R>S3S5Sjj5r S1S6Sjjr Sr!g)7r!iaUThis 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_specsNc[U[5(anURS5Vs/sH)o3R5(dMUR5PM+ nn[ [ [ U55UlSU;UlO1[ U5Ul[SUR55Ul[UR5S:*Ul SUl SUl X lgs snf)aLInitialize 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. ,rc3># UHnS[U5;v M g7frNr[rss r'r(SpecifierSet.__init__..<s%K{!es1vo{r N)r+r.splitrr,mapr rranyr-rrrr)r] specifiersrlrsplit_specifierss r'rSpecifierSet.__init__s, j# & &4>3C3CC3HV3HaGGI  3H V16s9FV7W1XDK"':"5D  +DK#&%Kt{{%K"KD !$++.!3.226 (# Ws C'C'c UR(d@[[R[ UR [ S955UlSUlUR $)zBDeduplicate, sort, and cache specs for order-sensitive operations.rxT)rr,rfromkeyssortedrr.r\s r'_canonical_specsSpecifierSet._canonical_specsFs="" fT[[c.J KLDK"&D {{r&cURb UR$UR(dg[SUR55(agg)Nc38# UHoRv M g7fr#rrs r'r+SpecifierSet.prereleases..\s2k}}kT)rrr$r\s r'rlSpecifierSet.prereleasesMsE    ($$ $ {{ 2dkk2 2 2r&cXlSUlgr#)rrros r'rlr2as!!%r&c2URUR4$r#)rrr\s r'rSpecifierSet.__getstate__fs T..//r&cLSUlSUl[U[5(Ga[ U5S:XawUup#[U[5(a^[ SU55(aG[ U5(a7X lX0l[ U5S:*Ul [SU55Ul g[ U5S:Xa[US[5(aUupEURSS5nURS5n[U[5(a[[U[ S95n[U[5(ar[ S U55(a[[ U5(aKX lX0l[ UR5S:*Ul [S UR55Ul g[U[5(aURSS5nURS5n[U[5(a[[U[ S95n[U[5(ar[ S U55(a[[ U5(aKX lX0l[ UR5S:*Ul [S UR55Ul g[#S U<35e)Nr*c3B# UHn[U[5v M g7fr#r+r rs r'r,SpecifierSet.__setstate__..wDeJq)44er c3># UHnS[U5;v M g7frr[rs r'rr9}s-Mu!es1vour!rr%rr)c3B# UHn[U[5v M g7fr#r8rs r'rr9r:r;c3># UHnS[U5;v M g7frr[rs r'rr9s-S{!es1vo{r!c3B# UHn[U[5v M g7fr#r8rs r'rr9s@%Q 1i00%r;c3># UHnS[U5;v M g7frr[rs r'rr9s)O;a%3q6/;r!z!Cannot restore SpecifierSet from )rrr+r,r-allr4rrrr$rrrD frozensetr+r.r)r]rspecsrlrrs r'rSpecifierSet.__setstate__ls  !% eU # #5zQ%*"ue,,DeDDD%k22"'K(3%*-e*/D'*--Mu-M*MD'5zQ:eAh#=#=$ ! h3'mmN; eY//!&C"89Eue,,DeDDD%k22"'K(3%*-dkk*:a*?D'*--St{{-S*SD' eT " "IIh+E))N3K%++fU455%((@%@@@!+..# $/!&)$++&6!&;#&))O4;;)O&O#;E9EFFr&cURbSUR<3OSnSURRS[ U5<US3$)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)> rrr?rrrrs r'rSpecifierSet.__repr__sU  ,T--0 1 4>>**+1SYM#bAAr&cNSRSUR555$)a6A 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' rc38# UHn[U5v M g7fr#r[rs r'r'SpecifierSet.__str__..s@(?1A(?r1)joinr,r\s r'r`SpecifierSet.__str__s"xx@(=(=(?@@@r&c4[UR55$r#)rr,r\s r'rdSpecifierSet.__hash__sD))+,,r&c[U[5(a [U5nO[U[5(d[$[5nURUR-Ul[ UR5S:*UlUR=(d URUlURbURUR:XaURUlU$URcURUlU$[S5e)aRReturn 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 zFCannot combine SpecifierSets with True and False prerelease overrides.) r+r.r!rrr-rrr ValueError)r]rhrHs r'__and__SpecifierSet.__and__s eS ! ! 'EE<00! ! N ;;5 #&y'7'7#8A#=  #'#6#6#N%:N:N      $(9(9U=O=O(O%*%7%7I "   '%)%6%6I "  X r&c[U[[45(a[[U55nO[U[5(d[$UR 5UR 5:H$)a1Whether 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 )r+r.r r!rr,rgs r'riSpecifierSet.__eq__sT& ec9- . . U,EE<00! !$$&%*@*@*BBBr&c,[UR5$)z7Returns the number of specifiers in this specifier set.)r-rr\s r'__len__SpecifierSet.__len__s4;;r&c,[UR5$)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__SpecifierSet.__iter__sDKK  r&cURb UR$[SUR55UlUR$)zIntersect all specifiers into a single sequence of version ranges. Empty when unsatisfiable. Callers must ensure ``self._specs`` is non-empty. c3@# UHoR5v M g7fr#)rrs r'r+SpecifierSet._get_ranges..s1V+Q,,..+s)rrrr\s r' _get_rangesSpecifierSet._get_rangess8 << #<< 11V$++1VV ||r&cURnUbU$UR(dSUlgUR5(+nU(dUR5nU(d(URSLa[ UR55nX lU$)anCheck 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 F)rrr]_check_arbitrary_unsatisfiablerlr)r]cachedrs r'is_unsatisfiableSpecifierSet.is_unsatisfiables| ''  M{{%*D "%%''88:F$**e3/0@0@0BCF!' r&c^^URVs/sHoRS:XdMUPM nnU(dgUSRR5m[ U4SjUSS55(ag[ USR5mUR SLaTbTR(agURVs/sHoRS:wdMUPM nnU(dgTcg[U4SjU55(+$s snfs snf) zCheck === (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. rFrc3\># UH!oRR5T:gv M# g7fr#)rr)rrfirsts r'r>SpecifierSet._check_arbitrary_unsatisfiable..NsA=ayy E)=s),r NTc3D># UHoRT5v M g7fr#r)rr candidates r'rrgfs?hzz),,hs ) rrrrr$r rlrrA)r]rrstandardrirfs @@r'r`+SpecifierSet._check_arbitrary_unsatisfiableAs!% C 1zzU/BQ C! $$**, A9QR=A A A#9Q<#7#78    %%''#{{B{!jjE.AA{B  ?h????=D,CsDD=DDc0SSKJn URU5$)a3Return 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)rrm_from_specifier_set)r]rms r'to_rangeSpecifierSet.to_rangehs )//55r&c[U[5(d [S5eUR(dUR(a [ S5eg)Nzexpected a SpecifierSetz+set relations do not support === specifiers)r+r!rrrOrgs r'_check_relation_operand$SpecifierSet._check_relation_operandws=%..56 6   %"6"6JK K#7r&c~URU5 UR5RUR55$)aReturn 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 )rrro is_subsetrgs r'ruSpecifierSet.is_subset}s0" $$U+}}(()9::r&c~URU5 UR5RUR55$)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 )rrro is_supersetrgs r'rxSpecifierSet.is_supersets0 $$U+}}**5>>+;<>> SpecifierSet("<3.12").is_disjoint(SpecifierSet(">=3.12")) True >>> SpecifierSet("<3.12").is_disjoint(SpecifierSet(">=3.11")) False .. versionadded:: 26.3 )rrro is_disjointrgs r'r{SpecifierSet.is_disjoints0" $$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'rSpecifierSet.__contains__rr&c d[U5nUbU(aUR(aSnUb&UR(a[U[5(dUnOUnUbUR(dUR cUR (aUR(aUSLdUcURSLagURnUcCUR Hn[Xt5nUc OU(aM g gUR5=o`l[Xd5$[[URU/US955$)aTReturn 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`. TFr)r rrr+rrCrrrrNr]rr2rry) r]rrrl installedr check_itemboundsr/rs r'rsSpecifierSet.containss P!&  91F1FK ?t22:dG;T;TJ J  '' % $$u$'D,=,=,F\\F~ !KKD'6E} 5$ ( (,(8(8(::&v7 7Dj\{KLMMr&cgr#r%rvs r'rySpecifierSet.filter$r{r&cgr#r%rvs r'ryr,r}r&c@^^UcURb URnUR(acUR(a&URmUU4SjU5n[UTU5$URnUcUR 5n[ XQTU5$[UTU5$)aGFilter 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. c3d>^# UH$m[UU4SjT55(dM Tv M& g7f)c3Z># UH nURTcTOT"T5SS9v M" g7f)NTrr)rrrrrxs r'r0SpecifierSet.filter...zs0!&A 3;4CISW X!&s(+N)rA)rrrrxrCs @r'r&SpecifierSet.filter..ws/ (!&D (s0 0)rlrrrrr]r)r]rwrlrxrrrCs ` @r'ryr4sx  4#3#3#?**K ;;""  (1#{KK\\F~))+#Fc;G G)3 DDr&r)r%zstr | Iterable[Specifier]rlrrr)rztuple[Specifier, ...]rr)rz)tuple[tuple[Specifier, ...], bool | None]rrr)rhzSpecifierSet | strrr!r)rzIterator[Specifier]r)rr2)rzranges.VersionRange)rhrrr)rhr!rr2)rrr rr2r)rrr rlrrrrr2rrrr)"rQrRrSrTrUrrr,rrlrrrrr`rdrPrirUrXr]rbr`rorrrurxr{rrsrrryrVr%r&r'r!r!s$I13#'*(-*(!*(  *(X&&&0 7GrB* A-@C4 ! !F%@N 6L ;(=$=(#0$(!% VNVN!VN VN  VNp __$( +.+!+ + & ++ __$(.1 !,   $(7; SESE!SE5 SE  SESEr&r!c#p# /n/nSnUHn[UcUOU"U55nUc0U(aUv O"URU5 URU5 MLUR(dU(d UShvN SnUv MvU(aMURU5 M U(d UShvN ggN=N7f)z?Filter per PEP 440: exclude prereleases unless no finals exist.FNT)r appendr)rwrx all_nonfinalarbitrary_strings found_finalrrrIs r'rrs!L#%K TC > !((.##D) ##,,," J {    %16  - s*A2B64B25B6 !B6+B4,B64B6)rz list[str])r/rrzTypeGuard[tuple[str, str]])r3rrzTypeGuard[bool | None])rHr rIrrr)rrrxrrlrrr)rwrrxrrr)rsW#    (<< 7"$/! 0 CL %1I .. .. .. .. FB: z S ckkS lIO IOX  0 ,I E=I EX' ' "I' ' r&