3jZ%SrSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK J r J r J r J r JrJrJrJrJr SSKJr SSKJrJr \R0S:aSS K Jr O \ (aSS KJr /S QrS:S jrS;S jrSS jr4S?S!jr5S@S"jr6S@S#jr7SAS$jr8S@S%jr9S@S&jr:S@S'jr;SBS(jr<"S)S*\=5r>"S+S,\R~S-9r@"S.S/\@5rA\R"S05rCSCS1jrDSDS2jrESES3jrFSFS4jrGSGS5jrHSHS6jrISIS7jrJ"S8S9\@5rKg)Jz .. testsetup:: from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from packaging.version import Version ) annotationsN) TYPE_CHECKINGAnyCallableFinalIterableIteratorSequenceTypeVarUnion)canonicalize_version)InvalidVersionVersion) ) TypeGuard) BaseSpecifierInvalidSpecifier Specifier SpecifierSetc[$N)__all__e/root/GenerationalWealth/GenerationalWealth/venv/lib/python3.13/site-packages/packaging/specifiers.py__dir__r0s Nrc[U[5=(aB [U5S:H=(a- [US[5=(a [US[5$)Nrr ) isinstancetuplelenstr)specs r_validate_specr&4sI4 % IN % tAw $ % tAw $ rc8USL=(d [U[5$r)r!bool)pres r _validate_prer*=s $; /*S$//rTUnparsedVersionVar)boundz0.dev0zFinal[Version] _MIN_VERSIONc[U5nUS:a#XS- S:XaUS-nUS:a XS- S:XaMU[U5:XaU$USU$)zDStrip trailing zeros from a release tuple for normalized comparison.r rN)r#)releaseends r _trim_releaser2Js\ g,C 'gAg&!+ q 'gAg&!+S\)71.0`` excludes ``1.0.post0``. No real :class:`Version` falls on those boundaries, so this class creates values that sort between the real versions on either side. Two kinds exist, shown relative to a base version V:: V < V+local < AFTER_LOCALS(V) < V.post0 < AFTER_POSTS(V) ``AFTER_LOCALS`` sits after V and every V+local, but before V.post0. Upper bound of ``<=V``, ``==V``, ``!=V``. ``AFTER_POSTS`` sits after every V.postN, but before the next release segment. Lower bound of ``>V`` (final or pre-release V) to exclude post-releases per PEP 440. )_kind_trimmed_releaseversioncPXlX l[UR5Ulgr)rErCr2r0rD)selfrEkinds r__init___BoundaryVersion.__init__qs  -goo >rcURnURUR:Xa=[UR5UR:XaUR UR :XdgUR [R:Xa9URUR:H=(a URUR:H$URUR:H=(d URSL$)z6Is ``other`` a version that this boundary sorts above?FN) rEepochr2r0rDr)rCr4r=postdev)rGothervs r _is_family_BoundaryVersion._is_familyvs LL KK177 "emm,0E0EE QUU" ::33 3::'>EII,> >yyAEE!;UZZt%;;rc[U[5(a9URUR:H=(a URUR:H$[$r)r!rArErCNotImplementedrGrOs r__eq___BoundaryVersion.__eq__s; e- . .<<5==0NTZZ5;;5N NrcD[U[5(a`URUR:waURUR:$URRURR:$UR U5(+=(a URU:$r)r!rArErCvaluerQrUs r__lt___BoundaryVersion.__lt__sr e- . .||u}},||emm33::##ekk&7&77 7??5))BdllU.BBrcD[URUR45$r)hashrErCrGs r__hash___BoundaryVersion.__hash__sT\\4::.//rc~URRSUR<SURRS3$)N(z, )) __class__r6rErCnamer^s r__repr___BoundaryVersion.__repr__s4..))*!DLL+;2djjoo=NaPPrN)rErrHr4returnNone)rOrrhr(rOobjectrhr()rOz_BoundaryVersion | Versionrhr(rhintrhr$) r6r7r8r9r: __slots__rIrQrVrZr_rfr?rrrrArAYs.(9I? < C0QrrAcN\rSrSrSrSrS SjrS SjrS SjrS Sjr SSjr Sr g ) _LowerBoundzLower bound of a version range. A version *v* of ``None`` means unbounded below (-inf). At equal versions, ``[v`` sorts before ``(v`` because an inclusive bound starts earlier.  inclusiverEcXlX lgrrErtrGrErts rrI_LowerBound.__init__  "rc[U[5(d[$URUR:H=(a URUR:H$rr!rqrTrErtrUs rrV_LowerBound.__eq__:%--! !||u}},R5??1RRrc8[U[5(d[$URcURSL$URcgURUR:waURUR:$UR=(a UR(+$)NFr{rUs rrZ_LowerBound.__lt__st%--! ! << ==, , ==  <<5== (<<%--/ /~~5eoo"55rcD[URUR45$rr]rErtr^s rr__LowerBound.__hash__T\\4>>233rcUR(aSOSnSURRSUUR<S3$)N[rb< >rtrdr6rErGbrackets rrf_LowerBound.__repr__s8#S4>>**+1WIdll5EQGGrNrE_VersionOrBoundaryrtr(rhrirj)rOrqrhr(rlrn r6r7r8r9r:rorIrVrZr_rfr?rrrrqrq))I#S 64HrrqcN\rSrSrSrSrS SjrS SjrS SjrS Sjr SSjr Sr g ) _UpperBoundzUpper bound of a version range. A version *v* of ``None`` means unbounded above (+inf). At equal versions, ``v)`` sorts before ``v]`` because an exclusive bound ends earlier. rscXlX lgrrvrws rrI_UpperBound.__init__ryrc[U[5(d[$URUR:H=(a URUR:H$rr!rrTrErtrUs rrV_UpperBound.__eq__r}rc[U[5(d[$URcgURcgURUR:waURUR:$UR(+=(a UR$NFTrrUs rrZ_UpperBound.__lt__sh%--! ! <<  ==  <<5== (<<%--/ />>!5eoo5rcD[URUR45$rrr^s rr__UpperBound.__hash__rrcUR(aSOSnSURRSUR<US3$)N]rcrrrrrs rrf_UpperBound.__repr__s8#S4>>**+1T\\, 1.3.dev0.Nr rrLr0rN)r0r from_partsrL)rEr0s r_next_prefix_dev0rsC>$>goob&9A&=>G   GMM7 JJrcV[R"URURSS9$)z7The .dev0 of a version's base release: 1.2 -> 1.2.dev0.rr)rrrLr0rEs r _base_dev0rs   GMM7??PQ RRrcl[U[5(d[U5nU$U$![a gf=fr)r!rrrs r_coerce_versionr$s= gw ' ' g&G N7N  s & 33c>URcU$URSS9$)N)local)r __replace__rs r_public_versionr-s%}}   T  **rc$URSSSS9$)zqThe version that *version* is a post-release of. 1.0.post1 -> 1.0, 1.0a1.post0 -> 1.0a1, 1.0.post0.dev1 -> 1.0. NrMrNrrrs r _post_baser3s   Dd$  ??rc"URSSS9$)zREarliest pre-release of *version*. 1.2 -> 1.2.dev0, 1.2.post1 -> 1.2.post1.dev0. rNrNrrrs r_earliest_prereleaser;s   1D  11rc4Ucg[U[5(a\URnUR(aUR SSSS9$UR bUR S-OSnUR USS9$UR(dU$UR SSSS9$)z:Smallest non-pre-release version at or above *v*, or None.N)r)rNrr r)rMr)r!rArE is_prereleaserrM)rPinnerks r_nearest_non_prereleaserCs y!%&&    $$4t$D D!& 6UZZ!^A  at 44 ?? ==Tt4= 88rc\rSrSrSrSrg)riXz 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' rN)r6r7r8r9r:r?rrrrrXsrrc\rSrSrSrSr\SSj5r\RSSj5r \RSSj5r \RSSj5r \\RSSj55r \ RSS j5r \RSSS jj5r\R"SSS jj5r\R"SSS jj5r\RSSSjj5rSrg )ridr)_strc[U5$)z Internal property for match_argsr$r^s rrBaseSpecifier._strhs4yrcg)zv Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. Nrr^s r__str__BaseSpecifier.__str__mrcg)z6 Returns a hash value for this Specifier-like object. Nrr^s rr_BaseSpecifier.__hash__trrcg)z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. NrrUs rrVBaseSpecifier.__eq__zrrcg)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. Nrr^s r prereleasesBaseSpecifier.prereleasesrrcg)zASetter for :attr:`prereleases`. :param value: The value to set. NrrGrYs rrrrrNcg)zB Determines if the given item is contained within this specifier. NrrGitemrs rcontainsBaseSpecifier.containsrrcgrrrGiterablerkeys rfilterBaseSpecifier.filter (+rcgrrrs rrr rcg)z} Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nrrs rrrrrrnrlrjrh bool | None)rYr(rhrir)rr$rrrhr(N.rzIterable[UnparsedVersionVar]rrrrirhzIterator[UnparsedVersionVar]rz Iterable[T]rrrzCallable[[T], UnparsedVersion]rhz Iterator[T]NNr Iterable[Any]rrr'Callable[[Any], UnparsedVersion] | Nonerh Iterator[Any])r6r7r8r9ro__match_args__propertyrabcabstractmethodrr_rVrsetterrtypingoverloadrr?rrrrrdsIN                  __$( +.+!+ + & ++ __$(.1 !,    $(7;    !  5      rr) metaclassc \rSrSr%SrSrSr\R"S\-S-\R\R-5r SSSS S S S S S.r S\ S'S2S3SjjrS4SjrS5SjrS6SjrS7SjrS7Sjr\S8Sj5r\R,S9Sj5rS:SjrS;Sjr\SS!jrS?S"jrS@S#jr SAS$jr!SBS%jr"SAS&jr#SAS'jr$SAS(jr%SAS)jr&SCS*jr'SCS+jr(SDS,jr)SES-jr*SFSGS.jjr+\,RZSHSIS/jj5r.\,RZSHSJS0jj5r.SKSLS1jjr.Sr/g)MriaThis 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_ranges_spec _spec_version_wildcard_splita  (?: (?: # 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)~===!=<=>=rr===r _operatorsNcURRU5(d[SU<35eUR5nUR S5(aUSSUSSR5pCOEUR S5(aUSSUSSR5pCOUSSUSSR5pCX44UlX lSUlSUlSUl g)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)rrrrrr r ) _regex fullmatchrstrip startswithrrrrr)rGr%roperatorrEs rrISpecifier.__init__=s{{$$T**"%8#AB Bzz| ??5 ! ! $Ra$qr(..*:g __; < < $Ra$qr(..*:g $Ra$qr(..*:g'/&9 (:>>B8< rcURb"URSU:XaURS$[U5nUcgX4UlU$)zDOne element cache, as only one spec Version is needed per Specifier.Nrr )rr)rGrEversion_specifiers r_get_spec_versionSpecifier._get_spec_versioncsV    )d.@.@.Cw.N%%a( (+G4  $%9  rc2URU5nUceU$)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 )rGrE spec_versions r_require_spec_versionSpecifier._require_spec_versionos& --g6 '''rcURb UR$URnURnUS:Xa[Ul[$UR S5(aUR X5nOUR X5nX0lU$)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. r.*)rrrErendswith_wildcard_ranges_standard_ranges)rGopver_strrs r _to_rangesSpecifier._to_rangesysy << #<<  ]],, ;&DL    D ! !**27F**27F  rcURUSS5n[U5n[U5nUS:Xa[US5[ US54/$[ [ US54[US5[ 4/$)NrTF)r$rrrqr_NEG_INF_POS_INF)rGr+r,baserrs rr)Specifier._wildcard_rangessy))'#2,74 !$' : -{5%/HIJ J{5%0 1  %x 0  rc,URU5nUS:Xa[US5[4/$US:Xa+[[ [ U[ R5S54/$US:XaURb0URURS-SS9n[US5[4/$URb1URURS-SSS9n[US5[4/$[[ U[ R5S 5[4/$US :XaBUR(aUOURSSS9nU[::a/$[[ US 54/$S U;n[ U[ R5nU(aUOUnUS :Xa[US5[ US54/$US :Xa$[[ US 54[US 5[4/$US:Xa>URURSSS9n [US5[ [U 5S 54/$[!SU<35e)NrTrrr rrrFr+rrrr)r0Unknown operator: )r$rqr2r1rrAr4r=rNrrMr>rr.r0r ValueError) rGr+r,rP lower_verr- has_local after_localsrprefixs rr*Specifier._standard_rangess+  & &w / : D)845 5 : 0M4N4N OQUV  9uu MMaeeaitMD $Y5x@AAvv!MMqvvzqMM $Y5x@AA 0M4M4M NPUV  9Aammm.NE $ {5%89: :7N '=+E+EF L : D);ud+CDE E :;q%01UE*H5  :]]199Sb>]:FQ%{3DV3Le'TU -bV455rcURb UR$URupUS:XagUS:XaURS5(agURU5nUcgUR$)NrFrr')rrr(r r)rGr version_strrEs rrSpecifier.prereleasessz    ($$ $!%  t  t  4 4T : :((5 ?$$$rcXlgr)rrs rrr@s!rc2URUR4$r)rrr^s r __getstate__Specifier.__getstate__s D--..rcSUlSUlSUl[U[5(a[ U5S:Xa1Uup#[ U5(a[U5(a X lX0l g[ U5S:Xal[US[5(aTUupEURS5nURSS5n[ U5(a[U5(a X lX0l g[U[5(aPURS5nURSS5n[ U5(a[U5(a X lX0l g[SU<35e)Nr r rrinvalidzCannot restore Specifier from ) rrrr!r"r#r&r*rrdictget TypeError)rGstater%r_ 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 BCCrc URS$)zHThe operator of this specifier. >>> Specifier("==1.2.3").operator '==' rrr^s rrSpecifier.operator$zz!}rc URS$)zIThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rPr^s rrESpecifier.version-rRrcURbSUR<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=rrb)>rrrdr6r$rGr)s rrfSpecifier.__repr__6sU  ,T--0 1 4>>**+1SYM#bAArc4SR"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{}{})formatrr^s rrSpecifier.__str__Hs}}djj))rcURupUS:XdURS5(aX4$URU5n[X1S:gS9nX4$)Nrr'rstrip_trailing_zero)rr(r$r)rGrrEr#canonical_versions r_canonical_specSpecifier._canonical_specRs] JJ u  0 0 6 6$ $11': 0 4/? **rc,[UR5$r)r]rcr^s rr_Specifier.__hash__`sD(())rc[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$rdrrTrcrUs rrVSpecifier.__eq__csm& eS ! ! &s5z2E>>22! !##u'<'<<< $ &%% &sA++A>=A>c>[USURU35nU$)N _compare_)getattrr)rGr+operator_callables r _get_operatorSpecifier._get_operators+.5 Idoob123/ ! rc [[[R"[[ U555SS5nUS- nUR X5=(a URX5$)Nrr') _version_joinlist itertools takewhile_is_not_suffix_version_split_compare_greater_than_equal_compare_equal)rG prospectiver%r<s r_compare_compatibleSpecifier._compare_compatibles` $$^^D5IJ KCR P  $00C    4 rczURnUc+[USSSS9n[U5nU[U54nX lU$)zCached split of a wildcard spec into components and numeric length. >>> Specifier("==1.*")._get_wildcard_split("1.*") (['0', '1'], 2) >>> Specifier("==3.10.*")._get_wildcard_split("3.10.*") (['0', '3', '10'], 3) Nr0Fr`)rrru_numeric_prefix_len)rGr%wildcard_split normalized split_specs r_get_wildcard_splitSpecifier._get_wildcard_splitsM--  !-d3BiUSJ' 3J(*=j*IJN#1 rc,URS5(aNURU5up4[[U5SS9n[ U5n[ Xd5nUS[ U5nX:H$URU5n U R(d [U5nX:H$)Nr'Fr`) r(rrrru _left_padr#r$r) rGrxr%rspec_numeric_lennormalized_prospectivesplit_prospectivepadded_prospectiveshortened_prospectiver#s rrwSpecifier._compare_equals ==  +/+C+CD+I (J&: ,%& " !//E F "++>> "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 rrGrs r __contains__Specifier.__contains__&}}T""rc H[[URU/US955$)aReturn 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 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 r)r(rqrrs rrSpecifier.contains.s#2DdVEFGGrcgrrrs rrSpecifier.filterIrrcgrrrs rrrQrrc## /nSnUbUO URnURUR5nUHn[UcUOU"U55n Sn U c5URS:Xa$UR XR 5(aUv OJURS:Xa(UR UcUOU"U5UR 5n OU"XR 5n U (dMU cMU R (aU(aSnUv MUbMURSLdMURU5 M U(dUcURSLa UShvN ggggN7f)aFilter 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 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:`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'}] FNrT) rrmrrrrErrr) rGrrrprereleases_versionsfound_non_prereleasesinclude_prereleasesrlrEparsed_versionmatchs rrrYsQF " %'2K8H8H  !..t}}= G, WWVNE%==E)d.E.E\\//"M%'//"{GG dll*.,,Gu3%337J,0)!M (T->->e-K(//8/ 8&#!!.+ + +/$& ,s*CEE !E E3E E ErWN)r%r$rrrhri)rEr$rhVersion | None)rEr$rhrrhSequence[_VersionRange])r+r$r,r$rhlist[_VersionRange]rrYrrhri)rhz#tuple[tuple[str, str], bool | None]rJrkrhrirn)rhztuple[str, str]rlrj)r+r$rhCallableOperator)rxrr%r$rhr()r%r$rhztuple[list[str], int])rxrrr$rhr()rxz Version | strr%r$rhr()rz str | Versionrhr(r)rUnparsedVersionrrrhr(rrrrr)0r6r7r8r9r:ro_specifier_regex_strrecompileVERBOSE IGNORECASErr__annotations__rIr r$r-r)r*rrrrCrMrrErfrrcr_rVrmryrrwrrrvrrrrrrrrr?rrrrrs#&IZ xZZ%%. R]]0JF "   J $ !((.##D) ##,,," J {    %16  - s*A2B64B25B6 !B6+B4,B64B6c2/nURS5up#nURU=(d S5 URS5HQn[R U5nU(a!UR UR 55 M@URU5 MS U$)aSplit 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.) rpartitionrsplit _prefix_regexrextendgroups)rErrLrKrestrrs rruruswF'',NEd MM%,3 3''-  MM%,,. ) MM$   Mrc4UtpUSSRU53$)zJoin 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. rr)join) componentsrLrs rrprps%LEWAchhtn% &&rc8^[U4SjS55(+$)Nc3F># UHnTRU5v M g7fr)r).0r<segments r !_is_not_suffix..s#1Pv6""1Ps!)rNabrcrM)any)rs`rrtrts"1P rcVSnUH nUR5(d U$US- nM" U$)zwCount leading numeric components in a :func:`_version_split` result. >>> _numeric_prefix_len(["0", "1", "2", "a1"]) 3 rr )isdigit)rcountrs rr|r|s: E   L   LrcR[U5nX- nUS::aU$/USUQS/U-QXSQ$)zPad a :func:`_version_split` result with ``"0"`` segments to reach ``target_numeric_len`` numeric components. Suffix segments are preserved. >>> _left_pad(["0", "1", "a1"], 4) ['0', '1', '0', '0', 'a1'] rNr)r|)rtarget_numeric_len numeric_len pad_neededs rrr sJ&e,K#1JQ NU=, <=, >, <), cheap and usually reject a large portion Tier 2: Wildcard equality (==.*) and compatible release (~=), more expensive Tier 3: Exact !=, cheap but rarely rejects Tier 4: Wildcard !=.*, expensive and rarely rejects rr'rr )rrrrr rrrrr7)r(r8)op_entryrKverr+s r_operator_costrsJAB Tz T**q11 ## Tz Tz T**q11 U{ )"0 11rc\rSrSrSrSrSSSjjrSSjr\SSj5r \ 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+S,Sjjr\R6S-S.Sjj5r\R6S-S/Sjj5rS+S0SjjrS1S2SjjrSrg)3ri6aUThis 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_unsatisfiabler _resolved_ops_specsNc[U[5(anURS5Vs/sH)o3R5(dMUR5PM+ nn[ [ [ U55UlSU;UlO1[ U5Ul[SUR55Ul[UR5S:*Ul SUl X l SUlgs 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 g7frNrrss rr(SpecifierSet.__init__..ts%K{!es1vo{r N)r!r$rrr"maprrrrr#rrrr)rG specifiersrrsplit_specifierss rrISpecifierSet.__init__Rs, j# & &4>3C3CC3HV3HaGGI  3H V16s9FV7W1XDK"':"5D  +DK#&%Kt{{%K"KD !$++.!3MQ(.2% Ws C'C'c UR(dN[[R[ UR [ S955UlSUlSUlSUlUR $)zBDeduplicate, sort, and cache specs for order-sensitive operations.rTN) rr"rGfromkeyssortedrr$rrr^s r_canonical_specsSpecifierSet._canonical_specssM"" fT[[c.J KLDK"&D !%D %)D "{{rcURb UR$UR(dg[SUR55(agg)Nc38# UHoRv M g7frrrs rr+SpecifierSet.prereleases..s2k}}kT)rrrr^s rrSpecifierSet.prereleasessE    ($$ $ {{ 2dkk2 2 2rcXlSUlgr)rrrs rrrs!!%rc2URUR4$r)rrr^s rrCSpecifierSet.__getstate__s T..//rcLSUlSUl[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 g7frr!rrs rr,SpecifierSet.__setstate__..DeJq)44er c3># UHnS[U5;v M g7frrrs rrrs-Mu!es1vourrrrrc3B# UHn[U[5v M g7frrrs rrrrrc3># UHnS[U5;v M g7frrrs rrrs-S{!es1vo{rc3B# UHn[U[5v M g7frrrs rrrs@%Q 1i00%rc3># UHnS[U5;v M g7frrrs rrrs)O;a%3q6/;rz!Cannot restore SpecifierSet from )rrr!r"r#allr*rrrrrrGrH frozensetrr$rI)rGrJspecsrrKrLs rrMSpecifierSet.__setstate__s!!% 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#;E9EFFrcURbSUR<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)> rVrWrrbrXrYrZs rrfSpecifierSet.__repr__sU  ,T--0 1 4>>**+1SYM#bAArcNSRSUR555$)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 g7frrrs rr'SpecifierSet.__str__..s@(?1A(?r)rrr^s rrSpecifierSet.__str__s"xx@(=(=(?@@@rc4[UR55$r)r]rr^s rr_SpecifierSet.__hash__sD))+,,rc$[U[5(a [U5nO[U[5(d[$[5nURUR-Ul[ UR5S:*UlUR=(d URUlSUlURbURUR:XaURUl U$URcURUl U$[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 NzFCannot combine SpecifierSets with True and False prerelease overrides.) r!r$rrTrr#rrrrr8)rGrO specifiers 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 rc[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$rrrTrrUs rrVSpecifierSet.__eq__&sT& ec9- . . U,EE<00! !$$&%*@*@*BBBrc,[UR5$)z7Returns the number of specifiers in this specifier set.)r#rr^s r__len__SpecifierSet.__len__@s4;;rc,[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')>] )iterrr^s r__iter__SpecifierSet.__iter__DsDKK  rcURnSnUH:nUcUR5nM[X#R55nU(aM: O Uc [S5eU$)zIntersect all specifiers into a single list of version ranges. Returns an empty list when unsatisfiable. ``===`` specs are modeled as full range; string matching is checked separately by :meth:`_check_arbitrary_unsatisfiable`. Nz _get_ranges called with no specs)rr-r RuntimeError)rGrrrs r _get_rangesSpecifierSet._get_rangesNs\ 15A~*6<<>Bv  >AB B rc URnUbU$UR(dSUlgUR5(+nU(dUR5nU(dURSLaUR 5nX lU$)aVCheck 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 F)rrr2_check_arbitrary_unsatisfiabler_check_prerelease_only_ranges)rGcachedrs ris_unsatisfiableSpecifierSet.is_unsatisfiabledsw''  M{{%*D "%%''88:F$**e3779F!' rcUR5Haup[UR5nUc gURbX2R:a gX2R:XdMNUR(dMa g g)zxWith prereleases=False, check if every range contains only pre-release versions (which would be excluded from matching).FT)r2rrErt)rGrrnearests rr6*SpecifierSet._check_prerelease_only_rangess_!,,.LE-emm# UH!oRR5T:gv M# g7fr)rEr)rrfirsts rr>SpecifierSet._check_arbitrary_unsatisfiable..sA=ayy E)=s),r NTc3D># UHoRT5v M g7frr)rr candidates rrr@s?hzz),,hs ) rrrErrrrrr)rGrrstandardrBr?s @@rr5+SpecifierSet._check_arbitrary_unsatisfiables!% C 1zzU/BQ C! $$**, A9QR=A A A$IaL$8$89    %%''#{{B{!jjE.AA{B  ?h????=D,CsDD=DDc$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 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 rrSpecifierSet.__contains__rrc [U5nUbU(aUR(aSnUb&UR(a[U[5(dUnOUn[ [ URU/US955$)aReturn 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 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 Tr)rrrr!rr(rqr)rGrr installedrE check_items rrSpecifierSet.containssh@"$'  91F1FK ?t22:dG;T;TJ JDj\{KLMMrcgrrrs rrSpecifierSet.filterrrcgrrrs rrrLrrc^^UcURb URnUR(ad[UR5S:Xa$URSRUUcSOUTS9nOUR UTUcSOUS9nUbU$[ UT5$USLa [ U5$USLa UU4SjU5$[ UT5$)aCFilter 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 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:`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'] r rT)rrrFc3># UH4n[TcUOT"U55=mbTR(aM0Uv M6 g7fr)rr)rrrrEs rr&SpecifierSet.filter..^sB$D / T SSW"00 $s/? ?)rrr#r_filter_versionsrr-)rGrrrfilteredrEs ` @rrrL sd  4#3#3#?**K ;; 4;;1$;;q>00(3(;1  00(3(;1 &-h< < $ > ! % $ *(C88rc#^^^# URc$[SUR5[S9UlURnUSLnUHzm[ TcTOT"T55mTc"[ U4SjU55(aTv M<M>U(aTR (aMX[ UUU4SjU55(dMvTv M| g7f)aFilter versions against all specifiers in a single pass. Uses Cost Based Ordering: specifiers are sorted by _operator_cost so that cheap range operators reject versions early, avoiding expensive wildcard or compatible operators on versions that would have been rejected anyway. Nc3# UH7nURUR5URUR4v M9 g7fr)rmrrE)rr%s rr0SpecifierSet._filter_versions..{s5 +'' 6 dmmT +s?ArFc3># UH>upnUS:H=(a* [T5R5UR5:Hv M@ g7frr)rrKrr+rs rrrUs>&) %KDCIOO$5$DD&)sAA c3># UHLupnUS:Xa5[TcTOT"T55R5UR5:HOU"TU5v MN g7frr)rop_fnrr+rrrs rrrUs['*NE;CKDSY7==?399;N63'('*sAA)rrrrrrr)rGrrropsexclude_prereleasesrrs ` @@rrQSpecifierSet._filter_versionsks    %!' $ # "D   )U2D$S[Tc$iHF~&)J  %)=)='*  's B6C? Cr)rzstr | Iterable[Specifier]rrrhri)rhztuple[Specifier, ...]rr)rhz)tuple[tuple[Specifier, ...], bool | None]rrnrl)rOzSpecifierSet | strrhrrj)rhzIterator[Specifier]r)rhr()rrrhr(r)rrrrrHrrhr(rrrrr)rrrrrrrhr)r6r7r8r9r:rorIrrrrrCrMrfrr_r%rVr*r.r2r8r6r5rrrrrrQr?rrrrr6s$I13#'+3-+3!+3  +3Z&&&0 7GrB* A-BC4 !,B %@N#0$(!% +N+N!+N +N  +NZ __$( +.+!+ + & ++ __$(.1 !,   $(7; ^9^9!^95 ^9  ^9H$( ,,5,! ,  ,,rr)rh list[str])r%rkrhzTypeGuard[tuple[str, str]])r)rkrhzTypeGuard[bool | None])r0tuple[int, ...]rhr])rrqrrrhr()rrrrrhr)rErrhr)rErrhr)rPrrhr)rrrrrhr)rEr$rhr\)rr\rhr$)rr$rhr()rr\rhrm)rr\rrmrhr\)rz!tuple[CallableOperator, str, str]rhrm)Lr: __future__rrr; functoolsrrrsysrrrrrrr r r r utilsrrErr version_infortyping_extensionsrrr&r*r+r$rr,r(rr.rr2Enumr4total_orderingrArqrrr" _VersionRanger1r2rrrrrrrrrrr8rABCMetarrrrrrurprtr|rrrrrrrhsp#     (,w + 0 CL %1IWcND01 'x0 n0=DII ;Q;Q;Q| %H%H%HP %H%H%HP w(8$>?+{23M tU # tU #&.%9$; !;) ! "4K S + @2999* z O ckkO dr , r ,j :; ' ' "I' ' T,'  O26a =a r