'i]hSrSSKJr SSKrSSKrSSKrSSKJrJrJ r J r J r J r SSK Jr SSKJrJr \ \\4r\ "S\S 9r\\\/\4rSS jrSS jrSS jr"S S\5r"SS\R8S9r"SS\5r\R>"S5r SSjr!SSjr"SSjr#S Sjr$"SS\5r%g)!z .. testsetup:: from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from packaging.version import Version ) annotationsN)CallableFinalIterableIteratorTypeVarUnion)canonicalize_version)InvalidVersionVersionUnparsedVersionVar)boundcl[U[5(d[U5nU$U$![a gf=fN) isinstancer r versions S/var/www/surfInsights/venv3-11/lib/python3.13/site-packages/packaging/specifiers.py_coerce_versionrs= gw ' ' g&G N7N  s & 33c URSS9$)N)local __replace__rs r_public_versionr#s   T  **c&URSSSSS9$)N)prepostdevrrrs r _base_versionr!'s   4dD  IIrc\rSrSrSrSrg)InvalidSpecifier+z 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____firstlineno____doc____static_attributes__r%rrr#r#+srr#cf\rSrSrSrSr\S Sj5r\RS Sj5r \RSSj5r \RSSj5r \\RSSj55r \ RSS j5r \RSSS jj5r\RSSS jj5rSrg ) BaseSpecifier7r%)_strc[U5$)z Internal property for match_argsstrselfs rr/BaseSpecifier._str;s4yrcg)zv Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. Nr%r3s r__str__BaseSpecifier.__str__@rcg)z6 Returns a hash value for this Specifier-like object. Nr%r3s r__hash__BaseSpecifier.__hash__Gr9rcg)z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. Nr%r4others r__eq__BaseSpecifier.__eq__Mr9rcg)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%r3s r prereleasesBaseSpecifier.prereleasesVr9rcg)zASetter for :attr:`prereleases`. :param value: The value to set. Nr%r4values rrCrD_r9rNcg)zB Determines if the given item is contained within this specifier. Nr%r4itemrCs rcontainsBaseSpecifier.containsfr9rcg)z} Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nr%)r4iterablerCs rfilterBaseSpecifier.filterlr9rreturnr2rRintr?objectrRboolrR bool | None)rGrWrRNoner)rJr2rCrYrRrWrNzIterable[UnparsedVersionVar]rCrYrRzIterator[UnparsedVersionVar])r&r'r(r) __slots____match_args__propertyr/abcabstractmethodr7r;r@rCsetterrKrOr+r%rrr-r-7sIN                  QU 4 CN %  rr-) metaclassc \rSrSr%SrSrSrSr\R"S\-\-S-\R\R-5r SSS S S S S SS.r S\S'S+S,SjjrS-SjrS.Sjr\S/Sj5r\R(S0Sj5r\S1Sj5r\S1Sj5rS1SjrS1Sjr\S2Sj5rS3SjrS4SjrS5SjrS6S jrS6S!jrS6S"jrS6S#jr S6S$jr!S7S%jr"S7S&jr#S8S'jr$S9S(jr%S:S;S)jjr&S:S(~=|==|!=|<=|>=|<|>|===)) a (?P (?: # 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. (?=<>===r _operatorsNcURRU5nU(d[SU<35eURS5R 5URS5R 54UlX lSUlg)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: operatorrN)_regex fullmatchr#groupstriprgrfrh)r4specrCmatchs r__init__Specifier.__init__su %%d+"%8#AB B KK # ) ) + KK " ( ( *'  (:>rcURb"URSU:XaURS$[U5nUcgX4UlU$)zDOne element cache, as only one spec Version is needed per Specifier.Nrr )rhr)r4rversion_specifiers r_get_spec_versionSpecifier._get_spec_versionsV    )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)r4r spec_versions r_require_spec_versionSpecifier._require_spec_versions& --g6 '''rcURb UR$URupUS:waDUS:XaURS5(agURU5nUcgUR(agg)Nrsrr.*FT)rfrgendswithr is_prerelease)r4rz version_strrs rrCSpecifier.prereleases%sz    ($$ $!%  t 4K$8$8$>$>,,[9G$$rcXlgrrfrFs rrCrB!rc URS$)zHThe operator of this specifier. >>> Specifier("==1.2.3").operator '==' rrgr3s rrzSpecifier.operatorFzz!}rc URS$)zIThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rr3s rrSpecifier.versionOrrcURbSUR<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=ru()>)rfrC __class__r&r2r4rs r__repr__Specifier.__repr__XsU  ,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{}{})formatrgr3s rr7Specifier.__str__js}}djj))rcURupUS:XdURS5(aX4$URU5n[X1S:gS9nX4$)Nrwrrqstrip_trailing_zero)rgrrr )r4rzrrcanonical_versions r_canonical_specSpecifier._canonical_spects] JJ u  0 0 6 6$ $11': 0 4/? **rc,[UR5$r)hashrr3s 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 )rr2rr#NotImplementedrr>s rr@Specifier.__eq__sm& eS ! ! &s5z2E>>22! !##u'<'<<< $ &%% &sA++A>=A>c>[USURU35nU$)N _compare_)getattrrx)r4opoperator_callables r _get_operatorSpecifier._get_operators+.5 Idoob123/ ! rc [[[R"[[ U555SS5nUS- nUR S5"X5=(a UR S5"X5$)Nrrtrr) _version_joinlist itertools takewhile_is_not_suffix_version_splitr)r4 prospectiverprefixs r_compare_compatibleSpecifier._compare_compatiblesn $$^^D5IJ KCR P  $!!$' : t?Q?QRV?W @  rc:URS5(aU[[U5SS9n[USSSS9n[U5n[U5n[ Xe5upxUS[ U5n X:H$UR U5n U R(d [U5nX:H$)NrFr)rr rr _pad_versionlenrr) r4rrnormalized_prospectivenormalized_spec split_specsplit_prospectivepadded_prospective_shortened_prospectivers r_compare_equalSpecifier._compare_equals ==  %9 ,%& "349RWXO(8J !//E F %11B$O !  %77HZ$I !(6 6 55d;L  %%-k: . .rc.URX5(+$r)rr4rrs r_compare_not_equalSpecifier._compare_not_equals&&{999rc<[U5URU5:*$rrrrs r_compare_less_than_equal"Specifier._compare_less_than_equal{+t/I/I$/OOOrc<[U5URU5:$rrrs r_compare_greater_than_equal%Specifier._compare_greater_than_equalrrcURU5nX:dgUR(d*UR(a[U5[U5:XaggNFT)rrr!r4rspec_strrs r_compare_less_thanSpecifier._compare_less_thansM))(3 !""))k*mD.AA rcURU5nX:dgUR(d*UR(a[U5[U5:XagURb[U5[U5:Xaggr)ris_postreleaser!rrs r_compare_greater_thanSpecifier._compare_greater_thansw))(3 !##**k*mD.AA    (] . 4 .! rch[U5R5[U5R5:H$r)r2lowerrs r_compare_arbitrarySpecifier._compare_arbitrary0s&;%%'3t9??+<<>> "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 rKr4rJs r __contains__Specifier.__contains__3&}}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 rC)rWrrOrIs rrKSpecifier.containsHs#2DdVEFGGrc## /nSnUbUO URnURUR5nUHn[U5nUc:URS:Xa(UR XpR 5(aUv MGMIMKU"XR 5(dMdUR (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. >>> 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'] FNrwT) rCrrzrrrrrfappend) r4rNrCprereleases_versionsfound_non_prereleasesinclude_prereleasesrrparsed_versions rrOSpecifier.filtercs0 " %'2K8H8H  !..t}}= G,W5N%==E)d.E.E\\//"M/)#><<@@%337J,0)!M (T->->e-K(//8 (&#!!.+ + +/$& ,s$BD !D > D 3D D  D rN)rr2rCrYrRrZ)rr2rRVersion | None)rr2rRr rXrGrYrRrZrQ)rRztuple[str, str]rSrU)rr2rRCallableOperator)rr rr2rRrW)rr rr2rRrW)rz Version | strrr2rRrW)rJz str | VersionrRrWr)rJUnparsedVersionrCrYrRrWr[))r&r'r(r)r*r\_operator_regex_str_version_regex_strrecompileVERBOSE IGNORECASEr{rx__annotations__rrrr^rCrarzrrr7rr;r@rrrrrrrrrrrKrOr+r%rrrdrdvso;I \ |ZZ$$'99FB R]]"F "   J >8 !8""B$* + +*=:!  (&/P:P P 6 D=#*H8RV<,4<,CN<, %<,<,rrdz([0-9]+)((?:a|b|c|rc)[0-9]+)c2/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_regexr|extendgroups)rresultepochrrestrJrs rrrswF'',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. r r )join) componentsrrs rrrs%LEWAchhtn% &&rc8^[U4SjS55(+$)Nc3F># UHnTRU5v M g7fr) startswith).0rsegments r !_is_not_suffix..s#1Pv6""1Ps!)r abrcr)any)rs`rrrs"1P rc //p2UR[[R"SU555 UR[[R"SU555 URU[ US5S5 URU[ US5S5 UR SS/[ S[ US5[ US5- 5-5 UR SS/[ S[ US5[ US5- 5-5 [[RRU55[[RRU554$)Nc"UR5$risdigitxs r_pad_version..s rc"UR5$rr$r&s rr(r)s !))+rrr r ) rrrrrinsertmaxchain from_iterable)leftright left_split right_splits rrrs3 " d9../DdKLMtI//0EuMNOd3z!}-/01uSQ0234a#QKN(;c*Q->P(P!QQRq3%#aZ]);c+a.>Q)Q"RRS Y__ * *: 67 Y__ * *; 78 rc\rSrSrSrSrSSSjjr\SSj5r\RSSj5rSSjr SS jr SS jr SS jr SS jrSS jrSSjrSSjrSSSjjrSSSjjrSrg) SpecifierSetizThis 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. )rf_specsNc,[U[5(adURS5Vs/sH)o3R5(dMUR5PM+ nn[ [ [ U55UlO[ U5UlX 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. ,N) rr2r r~ frozensetmaprdr5rf)r4 specifiersrCssplit_specifierss rrSpecifierSet.__init__su, j# & &4>3C3CC3HV3HaGGI  3H V$C 3C$DEDK$J/DK( Ws BBcURb UR$UR(dg[SUR55(agg)Nc38# UHoRv M g7frrrr;s rr+SpecifierSet.prereleases..s2k}}kT)rfr5r!r3s rrCSpecifierSet.prereleasessE    ($$ $ {{ 2dkk2 2 2rcXlgrrrFs rrCrC$rrcdURbSUR<3OSnS[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)> rrz>> 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' r7c38# UHn[U5v M g7frr1r@s rr'SpecifierSet.__str__..Hs;{!s1vv{rB)rsortedr5r3s rr7SpecifierSet.__str__=s"xx;t{{;;<>> 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')> zFCannot combine SpecifierSets with True and False prerelease overrides.)rr2r4rr8r5rf ValueError)r4r? specifiers r__and__SpecifierSet.__and__Ms eS ! ! 'EE<00! ! N $T[[5<<%?@     $););)G%*%7%7I "    )e.@.@.H   %"4"4 4%)%6%6I "  X rc[U[[45(a[[U55nO[U[5(d[$UR UR :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 )rr2rdr4rr5r>s rr@SpecifierSet.__eq__lsJ& ec9- . . U,EE<00! !{{ell**rc,[UR5$)z7Returns the number of specifiers in this specifier set.)rr5r3s 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')>] )iterr5r3s r__iter__SpecifierSet.__iter__sDKK  rc$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(aSnUcUOUn[[UR U/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)rrrWrrO)r4rJrC installedr check_items rrKSpecifierSet.containssN@"$'  91F1FK$_T' Dj\{KLMMrc,^ UcURb URnUR(a6URHnURXcSOUS9nM Ub [U5$O!USLa [U5$USLa U 4SjU5$/n/nSnUHln[ U5nUc$UR U5 UR U5 M5UR (aUR U5 MYUR U5 SnMn [U(aU5$U5$)aFilter 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. >>> 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'] 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'] TrFc3j># UH(n[U5=mbTR(aM$Uv M* g7fr)rr)rrJrs rr&SpecifierSet.filter..s3 (#24#88A"00D (s#3 3)rCr5rOrYrrr) r4rNrCrfiltered_itemsfound_prereleasesfound_final_releaserJrrs @rrOSpecifierSet.filters.N  4#3#3#?**K ;; ;;2E$;'$ &H~%' d"H~%e# (4668#D,T2N%%%d+!((.--!((.%%d+&*#&9NQQ?PQQrr)r:zstr | Iterable[Specifier]rCrYrRrZrXrrQrS)r?zSpecifierSet | strrRr4rU)rRzIterator[Specifier])rJrrRrW)NN)rJrrCrYr_rYrRrWrr[)r&r'r(r)r*r\rr^rCrarr7r;rQr@rVrZrrKrOr+r%rrr4r4s +I13#'$(-$(!$(  $(L&""5* =!>+4 !#0$(!% &N&N!&N &N  &NRRV[R4[RCN[R %[R[Rrr4)rrrRr)rr rRr )rr2rR list[str])rrirRr2)rr2rRrW)r/rir0rirRztuple[list[str], list[str]])&r* __future__rr_rrtypingrrrrrr utilsr rr r r2rrrWrrrr!rOr#ABCMetar-rdrrrrrrr4r%rrrns#  FF', %1IWcND01+J z < ckk< ~i, i,X :; ,' *KR=KRr