հj>^UdZddlmZddlZddlZddlZddlmZmZmZm Z m Z m Z ddl m Z mZmZmZmZmZmZmZmZddlmZddlmZer6ddlZdd lmZmZmZej>d k\rdd lm Z ndd l!m Z dd l"m#Z#dd l m$Z$gdZ%d$dZ&d%dZ'd&dZ(e dZ)e ee*fZ+e de+Z,ejZej\ej^ej`dZ1de2d<d'dZ3Gdde4Z5GddejlZ7Gdde7Z8 d(d Z9Gd!d"e7Z: d)d#Z;y)*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 SpecifierSetctSN)__all__J/var/www/mission/venv/lib/python3.12/site-packages/packaging/specifiers.py__dir__r(<s Nr&ct|txr8t|dk(xr(t|dtxrt|dtS)Nrr ) isinstancetuplelenstr)specs r'_validate_specr0@sI4 % IN % tAw $ % tAw $ r&c.|duxst|tSr#)r+bool)pres r' _validate_prer4Is $; /*S$//r&TUnparsedVersionVar)bound)>=<===!=z-dict[str, Callable[[Version, Version], bool]]_DIRECT_COMPARE_OPSr c|j\}}|jds |jytj |}||||j |S|dvre|j |}|j |j k7s+t|jt|jk7r|dk(r||kS||kDSyy)a!Match ``parsed`` against ``specifier`` without building a range. Handles ``>=``, ``<=``, ``==``, ``!=``, ``<``, ``>`` when the spec is not a wildcard and ``parsed`` has no local. Returns ``None`` when the range path must be used. Pre-release policy is left to the caller. .*N)<>r?) _specendswithlocalr<get_require_spec_versionepochrrelease) specifierparsedop_strver_strdirect_comparespec_vs r' _fast_matchrN]s ooOFG!9(,,V4N!fi&E&Eg&NOO 009 <<6<< '<+G< NNL , '-m6F? H& H r&ceZdZdZy)ra Raised when attempting to create a :class:`Specifier` with a specifier string that is invalid. >>> Specifier("lolwat") Traceback (most recent call last): ... packaging.specifiers.InvalidSpecifier: Invalid specifier: 'lolwat' N)__name__ __module__ __qualname____doc__r%r&r'rrzsr&rceZdZdZdZdZeddZejddZ ejddZ ejddZ eejddZ e jdd Z ejddd Zej" d dd Zej" d dd Zej d ddZy )rzO Abstract base class for :class:`Specifier` and :class:`SpecifierSet`. r%)_strct|S)z Internal property for match_argsr.selfs r'rUzBaseSpecifier._strs4yr&cy)z Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. Nr%rXs r'__str__zBaseSpecifier.__str__r&cy)zF Returns a hash value for this Specifier-like object. Nr%rXs r'__hash__zBaseSpecifier.__hash__r\r&cy)z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. Nr%rYothers r'__eq__zBaseSpecifier.__eq__r\r&cy)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%rXs r' prereleaseszBaseSpecifier.prereleasesr\r&cy)zQSetter for :attr:`prereleases`. :param value: The value to set. Nr%rYvalues r'rdzBaseSpecifier.prereleasesr\r&Ncy)zR Determines if the given item is contained within this specifier. Nr%)rYitemrds r'containszBaseSpecifier.containsr\r&cyr#r%rYiterablerdkeys r'filterzBaseSpecifier.filter (+r&cyr#r%rls r'rozBaseSpecifier.filter r&cy)z Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nr%rls r'rozBaseSpecifier.filterr\r&returnr.ruintraobjectrur2ru bool | None)rgr2ruNoner#)rir.rdr{rur2N.rmzIterable[UnparsedVersionVar]rdr{rnr|ruzIterator[UnparsedVersionVar]rmz Iterable[T]rdr{rnzCallable[[T], UnparsedVersion]ruz Iterator[T]NNrm Iterable[Any]rdr{rn'Callable[[Any], UnparsedVersion] | Noneru Iterator[Any])rPrQrRrS __slots____match_args__propertyrUabcabstractmethodr[r^rbrdsetterrjtypingoverloadror%r&r'rrsIN                  __$( +.+!+ + & ++ __$(.1 !,    $(7;    !  5      r&r) metaclassc eZdZUdZdZdZejdezdzejejzZ ddddd d d d d Z de d<d%d&dZ d'dZd(dZd)dZed*dZej&d+dZd,dZd-dZed.dZed.dZd.dZd.dZed/dZd0dZd1dZd2d Zd3d4d!Zej@ d5 d6d"Z!ej@ d5 d7d#Z! d8 d9d$Z!y):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 _operatorsNc|jj|std||j}|j dr|dd|ddj}}nB|j dr|dd|ddj}}n|dd|ddj}}||f|_||_d|_d|_y)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)rYr/rdoperatorversions r'__init__zSpecifier.__init__cs{{$$T*"%8#AB Bzz| ??5 ! $Ra$qr(..*:gH __; < $Ra$qr(..*:gH $Ra$qr(..*:gH'/&9 (:>37 r&c|j!|jd|k(r|jdSt|}|y||f|_|S)zDOne element cache, as only one spec Version is needed per Specifier.Nrr )rr )rYrversion_specifiers r'_get_spec_versionzSpecifier._get_spec_versionsY    )d.@.@.Cw.N%%a( (*73  $%'89  r&c0|j|}|J|S)zGet spec version, asserting it's valid (not for === operator). This method should only be called for operators where version strings are guaranteed to be valid PEP 440 versions (not ===). )r)rYr spec_versions r'rEzSpecifier._require_spec_versions& --g6 '''r&c|j |jS|j}|j}|dk(rt}n-|j |j d}t |||}||_|S)zConvert this specifier to sorted, non-overlapping version ranges. Each standard operator maps to one or two ranges. ``===`` is modeled as full range (actual check done separately). Cached. rr>)rrrr rE removesuffixr )rYoprKresultrs r' _to_rangeszSpecifier._to_rangessk << #<<  ]],, ;)3F001E1Ed1KLG$R':F  r&c|j |jS|j\}}|dk(ry|dk(r|jdry|j|}|y|jS)Nr;Fr:r>)rrArBr is_prerelease)rYr version_strrs r'rdzSpecifier.prereleasessy    ($$ $!% + t  t  4 4T :((5 ?$$$r&c||_yr#)rrfs r'rdzSpecifier.prereleasess !r&c2|j|jfSr#)rArrXs r' __getstate__zSpecifier.__getstate__s D--..r&cVd|_d|_t|trt |dk(r*|\}}t |rt |r||_||_yt |dk(r`t|dtrM|\}}|jd}|jdd}t |rt |r||_||_yt|trH|jd}|jdd}t |rt |r||_||_ytd|)Nr*r rArinvalidzCannot restore Specifier from ) rrr+r,r-r0r4rArdictrD TypeError)rYstater/rd_ slot_dicts r' __setstate__zSpecifier.__setstate__s ! eU #5zQ$)!k!$'M+,F!%DJ(3D%5zQ:eAh#=$ 9 }}W-'mmNIF !$'M+,F!%DJ(3D% eT "99W%D))NI>Kd# k(B! $/!8 BCCr&c |jdS)z`The operator of this specifier. >>> Specifier("==1.2.3").operator '==' rrArXs r'rzSpecifier.operatorzz!}r&c |jdS)zaThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rrXs r'rzSpecifier.versionrr&c|jd|jnd}d|jjdt ||dS)aTA representation of the Specifier that shows all internal state. >>> Specifier('>=1.0.0') =1.0.0')> >>> Specifier('>=1.0.0', prereleases=False) =1.0.0', prereleases=False)> >>> Specifier('>=1.0.0', prereleases=True) =1.0.0', prereleases=True)> , prereleases=r?()>rrd __class__rPr.rYr3s r'__repr__zSpecifier.__repr__ sU  ,T--0 1 4>>**+1SYM#bAAr&c4dj|jS)zA string representation of the Specifier that can be round-tripped. >>> str(Specifier('>=1.0.0')) '>=1.0.0' >>> str(Specifier('>=1.0.0', prereleases=False)) '>=1.0.0' z{}{})formatrArXs r'r[zSpecifier.__str__sv}}djj))r&c|j\}}|dk(s|jdr||fS|j|}t||dk7}||fS)Nrr>r)strip_trailing_zero)rArBrEr)rYrrrcanonical_versions r'_canonical_speczSpecifier._canonical_spec&sc JJ' u  0 0 6W$ $11': 0 x4/? ***r&c,t|jSr#)hashrrXs r'r^zSpecifier.__hash__4sD(())r&ct|tr |jt|}nt||jstS|j |j k(S#t$r tcYSwxYw)a>Whether or not the two Specifier-like objects are equal. :param other: The other object to check against. The value of :attr:`prereleases` is ignored. >>> Specifier("==1.2.3") == Specifier("== 1.2.3.0") True >>> (Specifier("==1.2.3", prereleases=False) == ... Specifier("==1.2.3", prereleases=True)) True >>> Specifier("==1.2.3") == "==1.2.3" True >>> Specifier("==1.2.3") == Specifier("==1.2.4") False >>> Specifier("==1.2.3") == Specifier("~=1.2.3") False )r+r.rrNotImplementedrr`s r'rbzSpecifier.__eq__7si& eS ! &s5z2E4>>2! !##u'<'<<< $ &%% &sA""A43A4c$|j|S)a:Return 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 rjrYris r' __contains__zSpecifier.__contains__T&}}T""r&cH|jddk(r&tt|j|g|St |}|y| t |j |j}|dur |jryt||}||St|j|S)a'Return whether or not the item is contained in this specifier. :param item: The item to check for, which can be a version string or a :class:`~packaging.version.Version` instance. :param prereleases: Whether or not to match prereleases with this Specifier. If set to ``None`` (the default), it will follow the recommendation from :pep:`440` and match prereleases, as there are no other versions. >>> Specifier(">=1.2.3").contains("1.2.3") True >>> Specifier(">=1.2.3").contains(Version("1.2.3")) True >>> Specifier(">=1.2.3").contains("1.0.0") False >>> Specifier(">=1.2.3").contains("1.3.0a1") True >>> Specifier(">=1.2.3", prereleases=False).contains("1.3.0a1") False >>> Specifier(">=1.2.3").contains("1.3.0a1") True .. versionchanged:: 26.0 With ``prereleases=None``, a prerelease now matches. A single version has no alternatives, so the :pep:`440` rule to accept prereleases when nothing else satisfies the specifier applies. Earlier versions rejected it. An unparsable version now returns ``False`` instead of raising :exc:`~packaging.version.InvalidVersion`. rrrdF) rAr2listror rrrdrrNrr)rYrirdrImatchs r'rjzSpecifier.containsisD ::a=E !T[[$[[IJK K% >  -d.?.?AQAQRK % F$8$8D&)  L"4??#4f==r&cyr#r%rls r'rozSpecifier.filterrpr&cyr#r%rls r'rozSpecifier.filterrrr&c| t|j|j}|jdk(r3|jj fd|D}t ||St|j||S)aFilter items in the given iterable, that match the specifier. :param iterable: An iterable that can contain version strings and :class:`~packaging.version.Version` instances. The items in the iterable will be filtered according to the specifier. :param prereleases: Whether or not to allow prereleases in the returned iterator. If set to ``None`` (the default), it will follow the recommendation from :pep:`440` and match prereleases if there are no other versions. :param key: A callable that takes a single argument (an item from the iterable) and returns a version string or :class:`~packaging.version.Version` instance to be used for filtering. >>> list(Specifier(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) ['1.3'] >>> list(Specifier(">=1.2.3").filter(["1.2", "1.2.3", "1.3", Version("1.4")])) ['1.2.3', '1.3', ] >>> list(Specifier(">=1.2.3").filter(["1.2", "1.5a1"])) ['1.5a1'] >>> list(Specifier(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] >>> list(Specifier(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] >>> list(Specifier(">=1.2.3").filter( ... [{"ver": "1.2"}, {"ver": "1.3"}], ... key=lambda x: x["ver"])) [{'ver': '1.3'}] .. versionchanged:: 26.1 Added the ``key`` parameter. rc3nK|],}t|n|jk(r|.ywr#)r.lower).0rirn spec_lowers r' z#Specifier.filter..s9s{tD :@@BjPs25) rrrdrrr_apply_prereleases_filterrr)rYrmrdrnmatchesrs ` @r'rozSpecifier.filterszP  -d.?.?AQAQRK ==E !++-J$G -Wc;G G 18S+NNr&rN)r/r.rdr{rur|)rr.ruzVersion | None)rr.rurruzSequence[Interval]rzrgr{rur|)ruz#tuple[tuple[str, str], bool | None]rryrur|rt)ruztuple[str, str]rvrx)riz str | Versionrur2r#)riUnparsedVersionrdr{rur2r}r~rrr)"rPrQrRrSr_specifier_regex_strrecompileVERBOSE IGNORECASErr__annotations__rrrErrrdrrrrrrr[rr^rbrrjrrror%r&r'r r s&IZ xRZZ%%. R]]0JF "   J !7F !*%%6""/ DBB$* + +*=:#*6>p __$( +.+!+ + & ++ __$(.1 !,   $(7; 4O4O!4O5 4O  4Or&cT| t|S|r t|Sfd|DS)zApply ``prereleases=`` handling to an already-matched iterable. ``None`` means PEP 440 default (buffer pre-releases until a final appears); ``True`` yields everything; ``False`` drops pre-releases. c3hK|])}t|n|x js|+ywr#)r r)rrirnrIs r'rz,_apply_prereleases_filter..s<  $S[Tc$iH HF Q##  s/2)_pep440_filter_prereleasesiter)rrnrdrIs ` @r'rrs7)'377G}  r&ceZdZdZdZ d ddZd dZed!dZejd"dZd#dZ d$d Z d%d Z d%d Z d&d Zd'd Zd(dZd&dZd)dZd*dZd+dZd+dZd,dZd-dZd.dZd.dZd.dZd/dZ d0 d1dZej< d2 d3dZej< d2 d4dZ d0 d5dZy)6r!aThis class abstracts handling of a set of version specifiers. It can be passed a single specifier (``>=3.0``), a comma-separated list of specifiers (``>=3.0,!=3.1``), or no specifier at all. Instances are safe to serialize with :mod:`pickle`. They use a stable format so the same pickle can be loaded in future packaging releases. .. versionchanged:: 26.2 Added a stable pickle format. Pickles created with packaging 26.2+ can be unpickled with future releases. Backward compatibility with pickles from packaging < 26.2 is supported but may be removed in a future release. )_canonicalized_has_arbitrary_is_unsatisfiablerr_specsNct|tre|jdDcgc]#}|js|j%}}t t t ||_d|v|_n1t ||_td|jD|_t|jdk|_ d|_ d|_ ||_ycc}w)aInitialize a SpecifierSet instance. :param specifiers: The string representation of a specifier or a comma-separated list of specifiers which will be parsed and normalized before use. May also be an iterable of ``Specifier`` instances, which will be used as is. :param prereleases: This tells the SpecifierSet if it should accept prerelease versions if applicable or not. The default of ``None`` will autodetect it from the given specifiers. :raises InvalidSpecifier: If the given ``specifiers`` are not parseable than this exception will be raised. ,rc36K|]}dt|vywrNrWrss r'rz(SpecifierSet.__init__..<s%K!es1vo%Kr N)r+r.splitrr,mapr rranyr-rrrr)rY specifiersrdrsplit_specifierss r'rzSpecifierSet.__init__s, j# &4>3C3CC3HVaAGGI V V16s9FV7W1XDK"':"5D  +DK#&%Kt{{%K"KD !$++.!3.226 (# Ws CCc|jsCttjt |j t |_d|_|j S)zBDeduplicate, sort, and cache specs for order-sensitive operations.rnT)rr,rfromkeyssortedrr.rXs r'_canonical_specszSpecifierSet._canonical_specsFs="" fT[[c.J KLDK"&D {{r&c|j |jS|jsytd|jDryy)Nc34K|]}|jywr#rrs r'rz+SpecifierSet.prereleases..\s2q}}2sT)rrrrXs r'rdzSpecifierSet.prereleasesMsB    ($$ $ {{ 2dkk2 2r&c ||_d|_yr#)rrrfs r'rdzSpecifierSet.prereleasesas!!%r&c2|j|jfSr#)rrrXs r'rzSpecifierSet.__getstate__fs T..//r&cd|_d|_t|trft |dk(rk|\}}t|trVt d|DrDt |r9||_||_t |dk|_ td|D|_ yt |dk(rt|dtr|\}}|jdd}|jd}t|trtt|t }t|trjt d |DrXt |rM||_||_t |jdk|_ td |jD|_ yt|tr|jdd}|jd}t|trtt|t }t|trjt d |DrXt |rM||_||_t |jdk|_ td |jD|_ yt#d |)Nr*c3<K|]}t|tywr#r+r rs r'rz,SpecifierSet.__setstate__..wDJq)4Dr c36K|]}dt|vywrrWrs r'rz,SpecifierSet.__setstate__..}s-M!es1vo-Mrrr%rrc3<K|]}t|tywr#rrs r'rz,SpecifierSet.__setstate__..rrc36K|]}dt|vywrrWrs r'rz,SpecifierSet.__setstate__..s-S!es1vo-Src3<K|]}t|tywr#rrs r'rz,SpecifierSet.__setstate__..s@Q 1i0@rc36K|]}dt|vywrrWrs r'rz,SpecifierSet.__setstate__..s)Oa%3q6/)Orz!Cannot restore SpecifierSet from )rrr+r,r-allr4rrrrrrrD frozensetr r.r)rYrspecsrdrrs r'rzSpecifierSet.__setstate__ls !% eU #5zQ%*"{ue,DeDD%k2"'DK(3D%*-e*/D'*--Mu-M*MD'5zQ:eAh#=$ 9! h3'mmN; eY/!&C"89Eue,DeDD%k2"'DK(3D%*-dkk*:a*?D'*--St{{-S*SD' eT "IIh+E))N3K%+fU455%(@%@@!+.# $/!&)$++&6!&;#&))O4;;)O&O#;E9EFFr&c|jd|jnd}d|jjdt ||dS)aA representation of the specifier set that shows all internal state. Note that the ordering of the individual specifiers within the set may not match the input string. >>> SpecifierSet('>=1.0.0,!=2.0.0') =1.0.0')> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=False) =1.0.0', prereleases=False)> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=True) =1.0.0', prereleases=True)> rrr?rrrrs r'rzSpecifierSet.__repr__sU  ,T--0 1 4>>**+1SYM#bAAr&cNdjd|jDS)anA string representation of the specifier set that can be round-tripped. Note that the ordering of the individual specifiers within the set may not match the input string. >>> str(SpecifierSet(">=1.0.0,!=1.0.1")) '!=1.0.1,>=1.0.0' >>> str(SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False)) '!=1.0.1,>=1.0.0' rc32K|]}t|ywr#rWrs r'rz'SpecifierSet.__str__..s@1A@s)joinr rXs r'r[zSpecifierSet.__str__s"xx@(=(=(?@@@r&c4t|jSr#)rr rXs r'r^zSpecifierSet.__hash__sD))+,,r&ct|tr t|}nt|tstSt}|j|jz|_t |jdk|_|jxs |j|_|j|j|jk(r|j|_|S|j|j|_|Std)aReturn a SpecifierSet which is a combination of the two sets. :param other: The other object to combine with. >>> SpecifierSet(">=1.0.0,!=1.0.1") & '<=2.0.0,!=2.0.1' =1.0.0')> >>> SpecifierSet(">=1.0.0,!=1.0.1") & SpecifierSet('<=2.0.0,!=2.0.1') =1.0.0')> r zFCannot combine SpecifierSets with True and False prerelease overrides.) r+r.r!rrr-rrr ValueError)rYrarHs r'__and__zSpecifierSet.__and__s eS ! 'EE<0! ! N ;;5 #&y'7'7#8A#=  #'#6#6#N%:N:N      $(9(9U=O=O(O%*%7%7I "   '%)%6%6I "  X r&ct|ttfrtt|}nt|tstS|j |j k(S)aWhether or not the two SpecifierSet-like objects are equal. :param other: The other object to check against. The value of :attr:`prereleases` is ignored. >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.1") True >>> (SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False) == ... SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True)) True >>> SpecifierSet(">=1.0.0,!=1.0.1") == ">=1.0.0,!=1.0.1" True >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0") False >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.2") False )r+r.r r!rr r`s r'rbzSpecifierSet.__eq__sN& ec9- . U,EE<0! !$$&%*@*@*BBBr&c,t|jS)z7Returns the number of specifiers in this specifier set.)r-rrXs r'__len__zSpecifierSet.__len__s4;;r&c,t|jS)z Returns an iterator over all the underlying :class:`Specifier` instances in this specifier set. >>> sorted(SpecifierSet(">=1.0.0,!=1.0.1"), key=str) [, =1.0.0')>] )rrrXs r'__iter__zSpecifierSet.__iter__sDKK  r&c|j |jStd|jD|_|jS)zIntersect all specifiers into a single sequence of version ranges. Empty when unsatisfiable. Callers must ensure ``self._specs`` is non-empty. c3<K|]}|jywr#)rrs r'rz+SpecifierSet._get_ranges..s1VQ!,,.1Vr)rrrrXs r' _get_rangeszSpecifierSet._get_rangess8 << #<< 11V$++1VV ||r&c|j}||S|jsd|_y|j }|s|j}|s'|jdurt |j}||_|S)aCheck whether this specifier set can never be satisfied. Returns True if no version can satisfy all specifiers simultaneously. >>> SpecifierSet(">=2.0,<1.0").is_unsatisfiable() True >>> SpecifierSet(">=1.0,<2.0").is_unsatisfiable() False >>> SpecifierSet("").is_unsatisfiable() False >>> SpecifierSet("==1.0,!=1.0").is_unsatisfiable() True .. versionadded:: 26.1 F)rrr,_check_arbitrary_unsatisfiablerdr)rYcachedrs r'is_unsatisfiablezSpecifierSet.is_unsatisfiables~ ''  M{{%*D "%%''88:F$**e3/0@0@0BCF!' r&c|jDcgc]}|jdk(s|}}|sy|djjt fd|ddDryt |dj|j dur jry|jDcgc]}|jdk7s|}}|syytfd|D Scc}wcc}w) aCheck === (arbitrary equality) specs for unsatisfiability. === uses case-insensitive string comparison, so the only candidate that can match ``===V`` is the literal string V. This method checks whether that candidate is excluded by other specifiers. rFrc3XK|]!}|jjk7#ywr#)rr)rrfirsts r'rz>SpecifierSet._check_arbitrary_unsatisfiable..Ns!Aaqyy E)A'*r NTc3@K|]}|jywr#r)rr candidates r'rz>SpecifierSet._check_arbitrary_unsatisfiable..fs?qzz),?s) rrrrrr rdrr)rYrrstandardr6r3s @@r'r.z+SpecifierSet._check_arbitrary_unsatisfiableAs!% C1qzzU/BQC C! $$**, A9QR=A A#9Q<#7#78    %%''#{{B!ajjE.AABB  ?h????=D,CsCC'C"<C"c0ddlm}|j|S)acReturn the :class:`~packaging.ranges.VersionRange` this set accepts. An empty set yields the full range; an unsatisfiable set yields the empty range. ``===`` specifiers contribute literal-string admission. >>> SpecifierSet(">=1.0,<2.0").to_range() .. versionadded:: 26.3 r ) VersionRange)rr9_from_specifier_set)rYr9s r'to_rangezSpecifierSet.to_rangehs )//55r&ct|ts td|js |jr t dy)Nzexpected a SpecifierSetz+set relations do not support === specifiers)r+r!rrr#r`s r'_check_relation_operandz$SpecifierSet._check_relation_operandws:%.56 6   %"6"6JK K#7r&c~|j||jj|jS)a=Return whether every version matching this set also matches other. :raises ValueError: If either set uses ``===`` specifiers, or the two sets were given different ``prereleases`` arguments (unset on one side counts as different). :raises TypeError: If other is not a :class:`SpecifierSet`. >>> SpecifierSet(">=3.12,<3.13").is_subset(SpecifierSet(">=3.12")) True >>> SpecifierSet(">=3.12").is_subset(SpecifierSet(">=3.12,<3.13")) False .. versionadded:: 26.3 )r=r; is_subsetr`s r'r?zSpecifierSet.is_subset}s0" $$U+}}(()9::r&c~|j||jj|jS)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 )r=r; is_supersetr`s r'rAzSpecifierSet.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 )r=r; is_disjointr`s r'rCzSpecifierSet.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'rzSpecifierSet.__contains__rr&c t|}||r|jrd}||jrt|ts|}n|}||js|j |j rx|jr|dus||jdury|j}|=|j D]}t||}|n|ryy|jx}|_t||Stt|j|g|S)a<Return whether or not the item is contained in this SpecifierSet. :param item: The item to check for, which can be a version string or a :class:`~packaging.version.Version` instance. :param prereleases: Whether or not to match prereleases with this SpecifierSet. If set to ``None`` (the default), it will follow the recommendation from :pep:`440` and match prereleases, as there are no other versions. :param installed: Whether or not the item is installed. If set to ``True``, it will accept prerelease versions even if the specifier does not allow them. >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.2.3") True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains(Version("1.2.3")) True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.0.1") False >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1") True >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False).contains("1.3.0a1") False >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True) True .. versionchanged:: 26.0 With ``prereleases=None``, a prerelease now matches. A single version has no alternatives, so the :pep:`440` rule to accept prereleases when nothing else satisfies the specifiers applies. Earlier versions rejected it. An unparsable version now returns ``False`` instead of raising :exc:`~packaging.version.InvalidVersion`. TFr)r rrr+rrCrrrrNr,rr2rro) rYrird installedr check_itemboundsr/rs r'rjzSpecifierSet.containssP!&  91F1FK ?t22:dG;TJ J  '' % $$u$'D,=,=,F\\F~ !KK D'g6E} $   (,(8(8(::&vw7 7Dj\{KLMMr&cyr#r%rls r'rozSpecifierSet.filter$rpr&cyr#r%rls r'rozSpecifierSet.filter,rrr&c&||j |j}|jr]|jr%|jfd|D}t||S|j}||j }t |||St||S)aFilter items in the given iterable, that match the specifiers in this set. :param iterable: An iterable that can contain version strings and :class:`~packaging.version.Version` instances. The items in the iterable will be filtered according to the specifier. :param prereleases: Whether or not to allow prereleases in the returned iterator. If set to ``None`` (the default), it will follow the recommendation from :pep:`440` and match prereleases if there are no other versions. :param key: A callable that takes a single argument (an item from the iterable) and returns a version string or :class:`~packaging.version.Version` instance to be used for filtering. >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) ['1.3'] >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", Version("1.4")])) ['1.3', ] >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.5a1"])) ['1.5a1'] >>> list(SpecifierSet(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] >>> list(SpecifierSet(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] >>> list(SpecifierSet(">=1.2.3").filter( ... [{"ver": "1.2"}, {"ver": "1.3"}], ... key=lambda x: x["ver"])) [{'ver': '1.3'}] An "empty" SpecifierSet will filter items based on the presence of prerelease versions in the set. >>> list(SpecifierSet("").filter(["1.3", "1.5a1"])) ['1.3'] >>> list(SpecifierSet("").filter(["1.5a1"])) ['1.5a1'] >>> list(SpecifierSet("", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] >>> list(SpecifierSet("").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] .. versionchanged:: 26.0 Prerelease filtering now follows the PEP 440 recommendation of yielding prereleases only when no final release is present. .. versionchanged:: 26.1 Added the ``key`` parameter. c3NK|]tfdDryw)c3XK|]!}|jnd#yw)NTrr)rrrirns r'rz0SpecifierSet.filter...zs1 3;4CISW Xr4N)r)rrirnrs @r'rz&SpecifierSet.filter..ws.!&s!%)rdrrrrr,r)rYrmrdrnrrrs ` @r'rozSpecifierSet.filter4sx  4#3#3#?**K ;;""  (1#{KK\\F~))+#FHc;G G)3 DDr&r)rzstr | Iterable[Specifier]rdr{rur|)ruztuple[Specifier, ...]rzr)ruz)tuple[tuple[Specifier, ...], bool | None]rrtrv)razSpecifierSet | strrur!rx)ruzIterator[Specifier]r)rur2)ruzranges.VersionRange)raryrur|)rar!rur2)rirrur2r)rirrdr{rFr{rur2r}r~rr) rPrQrRrSrrr rrdrrrrr[r^r$rbr'r)r,r0r.r;r=r?rArCrrjrrror%r&r'r!r!s$I13#'*(-*(!*(  *(X&&&0 7GrB* A-@C4 ! !F%@N 6L ;(=$=(#0$(!% VNVN!VN VN  VNp __$( +.+!+ + & ++ __$(.1 !,   $(7; SESE!SE5 SE  SEr&r!c#0Kg}g}d}|D]v}t||n||}|*|r|n"|j||j|D|js|s |Ed{d}|c|rf|j|x|s |Ed{yy7/7w)z?Filter per PEP 440: exclude prereleases unless no finals exist.FNT)r appendr)rmrn all_nonfinalarbitrary_strings found_finalrirIs r'rrs!L#%K& TC > !((.##D) ##,,," J     %1&6  - s*A B"B# B1B B BB)ruz list[str])r/ryruzTypeGuard[tuple[str, str]])r3ryruzTypeGuard[bool | None])rHr rIrrur{)rrrnrrdr{rur)rmrrnrrur)r]sW#    (<< 7"$/! 0 CL %1I .. .. .. .. FB: z S ckkS lIO IOX  0 ,I E=I EX' ' "I' ' r&