+ hwcstRt^RIHt^RIt^RIt^RIt^RIHtHtH t H t H t ^RI H t ^RIHt] ]]3,t] !R]R7t]]].]3,tRR lt!R R ]4t!R R ]P0R7t!RR]4t]P6!R4tRRltRRltRRltRRlt !RR]4t!R#)z .. testsetup:: from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from packaging.version import Version ) annotationsN)CallableIterableIteratorTypeVarUnion)canonicalize_version)VersionUnparsedVersionVar)Zboundc V^8dQhRRRR/#)versionUnparsedVersionreturnrformat"9/usr/lib/python3.14/site-packages/packaging/specifiers.py __annotate__rs_csH\V\4'g \V4pV#N) isinstancer)r &r_coerce_versionrs gw ' ''" Nrcs]tRt^ tRtRtR#)InvalidSpecifierz 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)__name__ __module__ __qualname____firstlineno____doc____static_attributes__rrrrr srrcsN]tRt^,t]P RRl4t]P RRl4t]P RRl4t] ]P RRl44t ] PR R l4t ]P RR R ll4t ]P RRRll4t RtR #) BaseSpecifiercV^8dQhRR/#r r strrrrrrBaseSpecifier.__annotate__.s   rc R#)zv Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. Nrselfrr__str__ZBaseSpecifier.__str__-rcr!r r Zintrrrrrr$5s  # rc r%)z6 Returns a hash value for this Specifier-like object. Nrr&rr__hash__ZBaseSpecifier.__hash__4r)rcr r otherZobjectr boolrrrrrr$;s  F t rc r%)z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. Nrr'r-&&r__eq__ZBaseSpecifier.__eq__:r)rcr!r r bool | Nonerrrrrr$Es  [ rc r%)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&rr prereleasesBaseSpecifier.prereleasesCr)rcr r valuer.r Nonerrrrrr$Ms   $ rc r%)zASetter for :attr:`prereleases`. :param value: The value to set. Nrr'r7r0rr4r5Lr)rNc$V^8dQhRRRRRR/#)r itemr#r4r3r r.rrrrrr$Ts!  S { d rc r%)zB Determines if the given item is contained within this specifier. Nr)r'r;r4&&&rcontainsZBaseSpecifier.containsSr)rcr:r iterablezIterable[UnparsedVersionVar]r4r3r zIterator[UnparsedVersionVar]rrrrrr$Zs$  4 CN % rc r%)z} Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nr)r'r?r4r<rfilterZBaseSpecifier.filterYr)rrr)rrrrabcZabstractmethodr(r+r1propertyr4setterr=r@rrrrr r ,s                  rr )Z metaclasscs&]tRt^ctRtRtRt]P!R],],R,]P]P,4t RRRR R R R R RRRRRRRR/t RDRRllt ]RRl4t]P RRl4t]RRl4t]RR l4tR!R"ltR#R$lt]R%R&l4tR'R(ltR)R*ltR+R,ltR-R.ltR/R0ltR1R2ltR3R4ltR5R6ltR7R8ltR9R:ltR;R<lt R=R>lt!RER?R@llt"RERARBllt#RCt$R#)F Specifiera+This class abstracts handling of version specifiers. .. tip:: It is generally not required to instantiate this manually. You should instead prefer to work with :class:`SpecifierSet` instead, which can parse comma-separated version specifiers (which is what package metadata contains). z8 (?P(~=|==|!=|<=|>=|<|>|===)) 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. (?=Zgreater_than_equalZ greater_than===Z arbitraryNcr:)r specr#r4r3r r8rrrrrSpecifier.__annotate__s!((S(K(4(rc sVPPV4pV'g\RV: 24hVPR4P 4VPR4P 43VnW nR#)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: operatorr N)_regexsearchrZgroupstrip_spec _prereleases)r'rLr4match&&& r__init__ZSpecifier.__init__sk ""4("%8#AB B KK # ) ) + KK " ( ( *'  (rcr!)r r r.rrrrrrMsTrc sVPe VP#VPwrVR9dAVR8XdVPR4'dVRRp\V4P'dR#R#)NrF.*TF)rFrHrGrErKrJrI)rSrRendswithr is_prerelease)r'rNr & rr4Specifier.prereleasessq    ($$ $ !JJ @ @4G$4$4T$:$:!#2,w---rcr r6rrrrrrM"""$"rc WnR#rrSr9r0rr4r\!rcr!r"rrrrrrMs#rc s(VP^,#)zHThe operator of this specifier. >>> Specifier("==1.2.3").operator '==' rRr&rrrNZSpecifier.operatorzz!}rcr!r"rrrrrrMsrc s(VP^,#)zIThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' rar&rrr ZSpecifier.versionrbrcr!r"rrrrrrM&sBB#Brc sVPeRVP: 2MRpRVPP R\ V4: V R2#)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=rIZ()>)rSr4 __class__rr#r'Zpre& r__repr__ZSpecifier.__repr__&sU  ,T--0 1 4>>**+1SYM#bAArcr!r"rrrrrrM8s***rc s6RP!VP!#)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{}{})rrRr&rrr(ZSpecifier.__str__8s}}djj))rcr!)r r ztuple[str, str]rrrrrrMCs000rc s\VP^,VP^,R8gR7pVP^,V3#)irEZstrip_trailing_zero)rrR)r'Zcanonical_versionrhr_canonical_specZSpecifier._canonical_specBs>0 JJqM!%A$!6 zz!}///rcr!r*rrrrrrMJs**#*rc ,\VP4#r)hashrkr&rrr+ZSpecifier.__hash__JsD(())rcr r,rrrrrrMMs==F=t=rc s\V\4'dVP\V44pM!\WP4'g\#VP VP 8H# \d \u#i;i)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 )rr#rfrNotImplementedrkr/r0rr1ZSpecifier.__eq__Msm& eS ! ! &s5z2E>>22! !##u'<'<<< $ &%% &sA--BBcr )r opr#r CallableOperatorrrrrrrMjs!!!(8!rc sF\VRVPV, 24pV#)Z _compare_)Zgetattr _operators)r'rooperator_callable&& r _get_operatorZSpecifier._get_operatorjs+.5 Idoob123/ ! rcr:r prospectiverrLr#r r.rrrrrrMps!  w c d rc  s\\\P!\\ V444RR4pVR, pVP R4!W4;'dVP R4!W4#)NrWrHrFi) _version_joinlist itertools takewhile_is_not_suffix_version_splitrt)r'rvrLprefixrUr_compare_compatibleZSpecifier._compare_compatiblepss $$^^D5IJ KCR P  $!!$' :  t?Q?QRV?W @  rcr:rurrrrrrMs!&/&/'&/&/&/rc sTVPR4'd]\VPRR7p\VRRRR7p\V4p\V4p\ We4wrxVR\ V4p W8H#\ V4p V P'g\ VP4pW8H#)rWFrjNrX)rYrpublicr| _pad_versionlenrlocal) r'rvrLZnormalized_prospectiveZnormalized_specZ split_specZsplit_prospectiveZpadded_prospective_Zshortened_prospectiveZ spec_versions &&& r_compare_equalZSpecifier._compare_equals ==  %9""& "349RWXO(8J !//E F %11B$O !  %77HZ$I !(6 6#4=L  %%%%k&8&89 . .rcr:rurrrrrrMs!::g:S:T:rc s.VPW4'*#r)rr'rvrLr<r_compare_not_equalZSpecifier._compare_not_equals&&{999rcr:rurrrrrrMs!<>> "1.2.3" in Specifier(">=1.2.3") True >>> Version("1.2.3") in Specifier(">=1.2.3") True >>> "1.0.0" in Specifier(">=1.2.3") False >>> "1.3.0a1" in Specifier(">=1.2.3") False >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True) True r=r'r;r0r __contains__ZSpecifier.__contains__&}}T""rcr:)r r;r r4r3r r.rrrrrrM s'*@*@_*@;*@RV*@rc sVf VPp\V4pVP'd V'gR#VPVP4pV!W0P 4#)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 uses :attr:`prereleases` to determine whether or not prereleases are allowed. >>> Specifier(">=1.2.3").contains("1.2.3") True >>> Specifier(">=1.2.3").contains(Version("1.2.3")) True >>> Specifier(">=1.2.3").contains("1.0.0") False >>> Specifier(">=1.2.3").contains("1.3.0a1") False >>> Specifier(">=1.2.3", prereleases=True).contains("1.3.0a1") True >>> Specifier(">=1.2.3").contains("1.3.0a1", prereleases=True) True F)r4rrZrtrNr )r'r;r4Znormalized_itemrr&&& rr=ZSpecifier.contains sZ4  **K*$/  ( ( (/3.@.@.O ,,??rcr:r>rrrrrrM5s$;;4;CN; %;rc# sT"Rp.pRVeTMR/pVFnp\V4pVP!V3/VB'gK)VP'd.V'g&VP'gVP V4KhRpVxKp V'gV'dVFpVxK R#R#R#5i)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 be intelligently decide whether to allow prereleases or not (based on the :attr:`prereleases` attribute, and whether the only versions matching are prereleases). This method is smarter than just ``filter(Specifier().contains, [...])`` because it implements the rule from :pep:`440` that a prerelease item SHOULD be accepted if no other versions match the given specifier. >>> list(Specifier(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) ['1.3'] >>> list(Specifier(">=1.2.3").filter(["1.2", "1.2.3", "1.3", Version("1.4")])) ['1.2.3', '1.3', ] >>> 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'] Fr4NT)rr=rZr4append)r'r?r4Zyieldedfound_prereleasesZkwr parsed_version&&& rr@ZSpecifier.filter5s<K,C[ N G,W5N}}^2r22"///4#3#3#3%,,W5#G!M (,, --ws(5B(B(B(B(($B( B(B()rSrRrdNr)%rrrrrZ_operator_regex_strZ_version_regex_strrecompileZVERBOSEZ IGNORECASErOrqrVrBr4rCrNr rir(rkr+r1rtr~rrrrrrrrr=r@rrrrrDrDcsH \ |ZZ%%(::WD R]]"F l g k  " [ ^ { J(4.""B$*00*=:!  (&/P:< < 0<=#**@X;;rrDz^([0-9]+)((?:a|b|c|rc)[0-9]+)$cr )r r r#r list[str]rrrrrrvsCIrcs6.pVPR4wr#pTPT;'gR4VPR4FRp\P V4pV'd"VP VP 44KAVPV4KT V#)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.)Z rpartitionrsplit _prefix_regexrPZextendZgroups)r Zresultepochrrestr;rTs& rr|r|vsyF'',NEd MM%,,3 3$$T*  MM%,,. ) MM$   Mrcr )r componentsrr r#rrrrrrs''i'C'rcs4VvrV RRPV4 2#)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)rrrr[rrwrws%LEWAchhtn% &&rcr )r segmentr#r r.rrrrrrsCDrcsa\;QJd)V3RlR4F'gK R'*# R'*#!V3RlR44'*#)c3sF<"TFpSPV4xK R#5ir)Z startswith).0r}rs& r Z!_is_not_suffix..s#1Pv6""1Ps!TF)ZdevZaZbZrcZpost)any)rsfrr{r{sMs1Pss s s1P rcs$V^8dQhRRRRRR/#)r leftrrightr ztuple[list[str], list[str]]rrrrrrs"y7Rrc s$..r2VP\\P!RV444VP\\P!RV444VPV\ V^,4R4VPV\ V^,4R4VP ^R.\ ^\ V^,4\ V^,4, 4,4VP ^R.\ ^\ V^,4\ V^,4, 4,4\\PPV44\\PPV443#)c"VP4#rZisdigitZxrr_pad_version..s rcrrrrrrrrs !))+rNr) rrxryrzrZinsertZmaxZchainZ from_iterable)rrZ left_splitZ right_splits&& rrrs3 " d9../DdKLMtI//0EuMNOd3z!}-/01uSQ0234a#QKN(;c*Q->P(P!QQRq3%#aZ]);c+a.>Q)Q"RRS Y__ * *: 67 Y__ * *; 78 rcs]tRtRtRtRRRllt]RRl4t]PRR l4tR R lt R R lt RRlt RRlt RRlt RRltRRltRRltR RRlltR!RRlltRtR#)" 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. Ncr:)r specifierszstr | Iterable[Specifier]r4r3r r8rrrrrSpecifierSet.__annotate__s($($(-$(!$(  $(rc s0\V\4'deVPR4Uu.uF*q3P4'gKVP4NK, pp\ \ \ V44VnM\ V4VnW nR#uupi)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) rr#rrQ frozensetZmaprD_specsrS)r'rr4sZsplit_specifiersrrrVZSpecifierSet.__init__su, j# & &4>3C3CC3HV3HaGGI  3H V$C 3C$DEDK$J/DK( Ws BBcr!r2rrrrrrs77[7rc sVPe VP#VP'gR#\;QJd&RVP4F 'gK R# R#!RVP44#)Nc3s8"TFqPxK R#5irr4rrrhrrZ+SpecifierSet.prereleases..s6+Q==+TF)rSrrr&rrr4SpecifierSet.prereleasess]    ($$ $ {{{s6$++6ss6s6s6$++666rcr r6rrrrrrr]rc r^rr_r9r0rr4rr`rcr!r"rrrrrrs55#5rc sfVPeRVP: 2MRpR\V4: V R2#)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)> rcrdz>> 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' rc3s8"TFp\V4xK R#5ir)r#rrhrrZ'SpecifierSet.__str__..s;{!s1vv{r)rZsortedrr&rrr(ZSpecifierSet.__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.)rr#rrnrrrS ValueError)r'r-Z specifierrsr__and__ZSpecifierSet.__and__s eS ! ! 'EE<00! ! N $T[[5<<%?@     $););)G%*%7%7I "   *u/A/A/I%)%6%6I "  %"4"4 4%)%6%6I "  X rcr r,rrrrrr8s++F+t+rc s\V\\34'd\\V44pM\V\4'g\#VP VP 8H#)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 )rr#rDrrnrr/r0rr1ZSpecifierSet.__eq__8sJ& ec9- . . U,EE<00! !{{ell**rcr!r*rrrrrrRs   rc rl)z7Returns the number of specifiers in this specifier set.)rrr&rr__len__ZSpecifierSet.__len__Rs4;;rcr!)r r zIterator[Specifier]rrrrrrVs!!-!rc rl)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&rr__iter__ZSpecifierSet.__iter__VsDKK  rcr )r r;r r r.rrrrrr`s###T#rc r)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") False >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True) True rrr0rrZSpecifierSet.__contains__`rrcs(V^8dQhRRRRRRRR/#)r r;r r4r3 installedr r.rrrrrrus87S7S7S!7S 7S  7Src saa\S\4'g \S4oSf VPoS'gSP'dR#V'd(SP'd\SP4o\ ;QJd*VV3RlVP 4F 'dK R# R#!VV3RlVP 44#)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 uses :attr:`prereleases` to determine whether or not prereleases are allowed. >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.2.3") True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains(Version("1.2.3")) True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.0.1") False >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1") False >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True).contains("1.3.0a1") True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True) True Fc3sH<"TFqPSSR7xK R#5i)rNr)rrr;r4s& rrZ(SpecifierSet.contains..sRk::d :<rrrrrrs)M"M"4M"CNM" %M"rc sVf VPpVP'd;VPFpVPV\V4R7pK! \ V4#.p.pVFVp\ V4pVP 'd&V'gV'gVPV4KCKEVPV4KX V'gV'dVf \ V4#\ V4#)a.Filter items in the given iterable, that match the specifiers in this set. :param iterable: An iterable that can contain version strings and :class:`Version` instances. The items in the iterable will be filtered according to the specifier. :param prereleases: Whether or not to allow prereleases in the returned iterator. If set to ``None`` (the default), it will be intelligently decide whether to allow prereleases or not (based on the :attr:`prereleases` attribute, and whether the only versions matching are prereleases). This method is smarter than just ``filter(SpecifierSet(...).contains, [...])`` because it implements the rule from :pep:`440` that a prerelease item SHOULD be accepted if no other versions match the given specifier. >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) ['1.3'] >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", Version("1.4")])) ['1.3', ] >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.5a1"])) [] >>> list(SpecifierSet(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] >>> list(SpecifierSet(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] An "empty" SpecifierSet will filter items based on the presence of prerelease versions in the set. >>> list(SpecifierSet("").filter(["1.3", "1.5a1"])) ['1.3'] >>> list(SpecifierSet("").filter(["1.5a1"])) ['1.5a1'] >>> list(SpecifierSet("", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] >>> list(SpecifierSet("").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] r)r4rr@r.rrrZr)r'r?r4rLZfilteredrr;rrrr@ZSpecifierSet.filtersX  **K ;;; ;;xT+=N;O$> ! 24H:<  !0!6"/// #)006$OOD)! 1k6I-..> !r)rSrr)NNr)rrrrrrVrBr4rCrir(r+rr1rrrr=r@rrrrrrsv $(L77 ""5* =!>+4 !#*7SrM"M"rr)"rZ __future__rrAryrZtypingrrrrrZutilsrr rr#r rr.rprrrZABCMetar rDrrr|rwr{rrrrrrs#  ??' %1IWcND01 z 4 ckk4 nM M` <= ,' *I"=I"r