Ki0`UdZddlmZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z m Z mZmZmZddlmZddlmZmZgdZd6d Zed ZeeefZed e Ze eegefZed Zded<d7dZ GddejBZ"ejFGddZ$ejFGddZ%ejFGddZ&ejNreee$dfZ(e)e%e&fZ*e%ddZ+e&ddZ,e+e,ffZ-ded<d8dZ. d9dZ/d:dZ0d:dZ1d;d Z2d:d!Z3d:d"Z4d:d#Z5 dd>d.Z?d?d/Z@d@d0ZAdAd1ZBdBd2ZCdCd3ZDGd4d5e:ZEy)Dz .. testsetup:: from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from packaging.version import Version ) annotationsN)AnyCallableFinalIterableIteratorSequenceTypeVarUnion)canonicalize_version)InvalidVersionVersion) BaseSpecifierInvalidSpecifier Specifier SpecifierSetctSN)__all__`/home/jay/workspace/scripts/.codegraph-venv/lib/python3.12/site-packages/packaging/specifiers.py__dir__r s NrTUnparsedVersionVar)boundz0.dev0zFinal[Version] _MIN_VERSIONct|}|dkDr!||dz dk(r|dz}|dkDr ||dz dk(r|t|k(r|S|d|S)zDStrip trailing zeros from a release tuple for normalized comparison.r rN)len)releaseends r _trim_releaser#-s` g,C 'gcAg&!+ q 'gcAg&!+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_releaseversioncT||_||_t|j|_yr)r2r0r#r!r1)selfr2kinds r__init__z_BoundaryVersion.__init__Ts!  -goo >rc|j}|j|jk(r;t|j|jk(r|j |j k(sy|j tjk(r4|j|jk(xr|j|jk(S|j|jk(xs|jduS)z6Is ``other`` a version that this boundary sorts above?FN) r2epochr#r!r1prer0r%r,postdev)r4othervs r _is_familyz_BoundaryVersion._is_familyYs LL KK177 "emm,0E0EE QUU" ::33 3::'>EII,> >yyAEE!;UZZt%;;rct|tr4|j|jk(xr|j|jk(StSr) isinstancer/r2r0NotImplementedr4r<s r__eq__z_BoundaryVersion.__eq__hs8 e- .<<5==0NTZZ5;;5N Nrc&t|tr_|j|jk7r|j|jkS|jj|jjkS|j | xr|j|kSr)r@r/r2r0valuer>rBs r__lt__z_BoundaryVersion.__lt__mso e- .||u}},||emm33::##ekk&7&77 7??5))BdllU.BBrcDt|j|jfSr)hashr2r0r4s r__hash__z_BoundaryVersion.__hash__tsT\\4::.//rc||jjd|jd|jjdS)N(z, )) __class__r&r2r0namerIs r__repr__z_BoundaryVersion.__repr__ws4..))*!DLL+;2djjoo=NaPPrN)r2rr5r%returnNone)r<rrQboolr<objectrQrS)r<z_BoundaryVersion | VersionrQrSrQintrQstr) r&r'r(r) __slots__r6r>rCrFrJrPrrrr/r/<s.(9I? < C0Qrr/c<eZdZdZdZd dZd dZd dZd dZd dZ y) _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.  inclusiver2c ||_||_yrr2r^r4r2r^s rr6z_LowerBound.__init__ "rct|tstS|j|jk(xr|j|jk(Srr@r\rAr2r^rBs rrCz_LowerBound.__eq__7%-! !||u}},R5??1RRrct|tstS|j|jduS|jy|j|jk7r|j|jkS|jxr |j S)NFrdrBs rrFz_LowerBound.__lt__sq%-! ! << ==, , ==  <<5== (<<%--/ /~~5eoo"55rcDt|j|jfSrrHr2r^rIs rrJz_LowerBound.__hash__T\\4>>233rct|jrdnd}d|jjd||jdS)N[rL< >r^rNr&r2r4brackets rrPz_LowerBound.__repr__s8#S4>>**+1WIdll5EQGGrNr2_VersionOrBoundaryr^rSrQrRrT)r<r\rQrSrVrX r&r'r(r)rZr6rCrFrJrPrrrr\r\{))I#S 64Hrr\c<eZdZdZdZd dZd dZd dZd dZd dZ y) _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. r]c ||_||_yrr`ras rr6z_UpperBound.__init__rbrct|tstS|j|jk(xr|j|jk(Srr@rwrAr2r^rBs rrCz_UpperBound.__eq__rerct|tstS|jy|jy|j|jk7r|j|jkS|j xr |jSNFTrzrBs rrFz_UpperBound.__lt__se%-! ! <<  ==  <<5== (<<%--/ />>!5eoo5rcDt|j|jfSrrhrIs rrJz_UpperBound.__hash__rirct|jrdnd}d|jjd|j|dS)N]rMrlrmrnrorps rrPz_UpperBound.__repr__s8#S4>>**+1T\\, 1.3.dev0.Nr rr8r!r;)r!r from_partsr8)r2r!s r_next_prefix_dev0rsC>$>goob&9A&=>G   GMM7 JJrcZtj|j|jdS)z7The .dev0 of a version's base release: 1.2 -> 1.2.dev0.rr)rrr8r!r2s r _base_dev0rs   GMM7??PQ RRrc`t|ts t|}|S|S#t$rYywxYwr)r@rrrs r_coerce_versionrs: gw ' g&G N7N  s ! --cB|j|S|jdS)N)local)r __replace__rs r_public_versionrs%}}   T  **rc*|jdddS)zyThe version that *version* is a post-release of. 1.0.post1 -> 1.0, 1.0a1.post0 -> 1.0a1, 1.0.post0.dev1 -> 1.0. Nr:r;rrrs r _post_basers   Dd$  ??rc(|jddS)zZEarliest pre-release of *version*. 1.2 -> 1.2.dev0, 1.2.post1 -> 1.2.post1.dev0. rNr;rrrs r_earliest_prereleasers   1D  11rc$|yt|tr\|j}|jr|j dddS|j |j dznd}|j |dS|js|S|j dddS)z:Smallest non-pre-release version at or above *v*, or None.N)r9r;rr r)r:r)r@r/r2 is_prereleaserr:)r=innerks r_nearest_non_prereleaser&s y!%&    $$4t$D D!& 6UZZ!^A  at 44 ?? ==Tt4= 88rceZdZdZy)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)r&r'r(r)rrrrr;srrceZdZdZdZeddZejddZ ejddZ ejddZ eejddZ e jddZ ejddd Zej d dd Zej d dd Zej d dd Zy )rr)_strct|S)z Internal property for match_argsrYrIs rrzBaseSpecifier._strKs4yrcy)z Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. NrrIs r__str__zBaseSpecifier.__str__Prcy)zF Returns a hash value for this Specifier-like object. NrrIs rrJzBaseSpecifier.__hash__Wrrcy)z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. NrrBs rrCzBaseSpecifier.__eq__]rrcy)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. NrrIs r prereleaseszBaseSpecifier.prereleasesfrrcy)zQSetter for :attr:`prereleases`. :param value: The value to set. Nrr4rEs rrzBaseSpecifier.prereleasesorrNcy)zR Determines if the given item is contained within this specifier. Nrr4itemrs rcontainszBaseSpecifier.containsvrrcyrrr4iterablerkeys rfilterzBaseSpecifier.filter| (+rcyrrrs rrzBaseSpecifier.filter rcy)z Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nrrs rrzBaseSpecifier.filterrrrXrVrTrQ bool | None)rErSrQrRr)rrYrrrQrSN.rzIterable[UnparsedVersionVar]rrrrRrQzIterator[UnparsedVersionVar]rz Iterable[T]rrrzCallable[[T], UnparsedVersion]rQz Iterator[T]NNr Iterable[Any]rrr'Callable[[Any], UnparsedVersion] | NonerQ Iterator[Any])r&r'r(rZ__match_args__propertyrabcabstractmethodrrJrCrsetterrtypingoverloadrrrrrrGsIN                  __$( +.+!+ + & ++ __$(.1 !,    $(7;    !  5      rr) metaclassc LeZdZUdZdZdZejdezdzejejzZ ddddd d d d d Z de d<d/d0dZ d1dZd2dZd3dZd4dZd4dZed5dZej*d6dZed7dZed7dZd7dZd7dZed8dZd9dZd:dZd;d Zdd'Z$d>d(Z%d?d)Z&d@d*Z'dAdBd+Z(e)jT dC dDd,Z+e)jT dC dEd-Z+ dF dGd.Z+y)Hra?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). ) _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)~===!=<=>=rlrn===r _operatorsNc|jj|std||j}|j dr|dd|ddj}}nB|j dr|dd|ddj}}n|dd|ddj}}||f|_||_d|_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: rN)rrrrrr ) _regex fullmatchrstrip startswithrrrrr)r4specroperatorr2s rr6zSpecifier.__init__s{{$$T*"%8#AB Bzz| ??5 ! $Ra$qr(..*:gH __; < $Ra$qr(..*:gH $Ra$qr(..*:gH'/&9 (:>>B8< rc|j!|jd|k(r|jdSt|}|y||f|_|S)zDOne element cache, as only one spec Version is needed per Specifier.Nrr )rr)r4r2version_specifiers r_get_spec_versionzSpecifier._get_spec_version<sY    )d.@.@.Cw.N%%a( (+G4  $%'89  rc0|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)r4r2 spec_versions r_require_spec_versionzSpecifier._require_spec_versionHs& --g6 '''rc |j |jS|j}|j}|dk(rt|_tS|j dr|j ||}n|j ||}||_|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. r.*)rrr2rendswith_wildcard_ranges_standard_ranges)r4opver_strrs r _to_rangeszSpecifier._to_rangesRs| << #<<  ]],, ;&DL    D !**2w7F**2w7F  rc|j|dd}t|}t|}|dk(rt|dt |dfgSt t |dft|dt fgS)NrTF)rrrr\rw_NEG_INF_POS_INF)r4rrbaserrs rrzSpecifier._wildcard_rangesjsy))'#2,74 !$' : -{5%/HIJ J{5%0 1  %x 0  rc|j|}|dk(rt|dtfgS|dk(r+tt t |t jdfgS|dk(r|j3|j|jdzd}t|dtfgS|j4|j|jdzdd}t|dtfgStt |t jd tfgS|d k(r?|jr|n|jdd}|tkrgStt |d fgSd |v}t |t j}|r|n|}|d k(rt|dt |dfgS|d k(r$tt |d ft|d tfgS|dk(rA|j|jdd} t|dt t| d fgSt!d|)NrTrrnr rrrFrl+rrrr)r!Unknown operator: )rr\r rrwr/r%r,r;rr:r-rrr!r ValueError) r4rrr= lower_verr has_local after_localsrprefixs rrzSpecifier._standard_rangesws+  & &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 -bV455rc|j |jS|j\}}|dk(ry|dk(r|jdry|j|}|y|jS)NrFrr)rrrrr)r4r version_strr2s rrzSpecifier.prereleasessy    ($$ $!% + t  t  4 4T :((5 ?$$$rc||_yr)rrs rrzSpecifier.prereleasess !rc |jdS)z`The operator of this specifier. >>> Specifier("==1.2.3").operator '==' rrrIs rrzSpecifier.operatorzz!}rc |jdS)zaThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rrIs rr2zSpecifier.versionrrc|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=rlrL)>rrrNr&rYr4r9s rrPzSpecifier.__repr__sU  ,T--0 1 4>>**+1SYM#bAArc4dj|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{}{})formatrrIs rrzSpecifier.__str__sv}}djj))rc|j\}}|dk(s|jdr||fS|j|}t||dk7}||fS)Nrrrstrip_trailing_zero)rrrr )r4rr2rcanonical_versions r_canonical_speczSpecifier._canonical_specsc JJ' u  0 0 6W$ $11': 0 x4/? ***rc,t|jSr)rHr&rIs rrJzSpecifier.__hash__sD(())rct|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@rYrNrrAr&rBs rrCzSpecifier.__eq__si& eS ! &s5z2E4>>2! !##u'<'<<< $ &%% &sA""A43A4c>t|d|j|}|S)N _compare_)getattrr)r4roperator_callables r _get_operatorzSpecifier._get_operator1s+.5 Idoob123/ ! rc tttjtt |dd}|dz }|j ||xr|j||S)Nrr) _version_joinlist itertools takewhile_is_not_suffix_version_split_compare_greater_than_equal_compare_equal)r4 prospectiverrs r_compare_compatiblezSpecifier._compare_compatible7sd $$^^D5IJ KCR P  $00dC    V 4 rc|j}|/t|ddd}t|}|t|f}||_|S)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) NrFr#)rr r4_numeric_prefix_len)r4rwildcard_split normalized split_specs r_get_wildcard_splitzSpecifier._get_wildcard_splitKsO--  !-d3BiUSJ' 3J(*=j*IJN#1D rc&|jdrT|j|\}}tt|d}t |}t ||}|dt |}||k(S|j|} | js t|}|| k(S)NrFr#) rr>r rr4 _left_padr rr) r4r7rr=spec_numeric_lennormalized_prospectivesplit_prospectivepadded_prospectiveshortened_prospectivers rr6zSpecifier._compare_equal[s == +/+C+CD+I (J(&: ,%& " !//E F "++<>N!O  %77HZ$I !(J6 6 55d;L  %%-k: ,. .rc(|j|| Sr)r6r4r7rs r_compare_not_equalzSpecifier._compare_not_equals&&{D999rc<t||j|kSrrrrGs r_compare_less_than_equalz"Specifier._compare_less_than_equal{+t/I/I$/OOOrc<t||j|k\SrrJrGs rr5z%Specifier._compare_greater_than_equalrLrc|j|}||ksy|js|jr|t|k\ryyr|)rrrr4r7spec_strrs r_compare_less_thanzSpecifier._compare_less_thansK))(3 T! ""))3D99 rc|j|}||kDsy|js|jrt||k(ry|jt ||k(ryyr|)ris_postreleaserrrrOs r_compare_greater_thanzSpecifier._compare_greater_thansg))(3 T! ##**;'4/    (_[-IT-Q rcht|jt|jk(SrrYrrGs r_compare_arbitraryzSpecifier._compare_arbitrarys&;%%'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 rr4rs r __contains__zSpecifier.__contains__&}}T""rcNtt|j|g|S)asReturn 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)rSr0rrs rrzSpecifier.containss#2DdVEFGGrcyrrrs rrzSpecifier.filterrrcyrrrs rrzSpecifier.filterrrc#ZKg}d}||n |j}|j|j}|D]}t||n||} d} | 0|jdk(rj|j ||j rN|nI|jdk(r'|j ||n|||j } n|| |j } | s| | j r|rd}|||jdus|j||s||jdur |Ed{yyyy7w)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) rr-rrrWr2rrr) r4rrrprereleases_versionsfound_non_prereleasesinclude_prereleasesr,r2parsed_versionmatchs rrzSpecifier.filter sSF " %'2K8H8H  !..t}}=  9G, WWVNE%==E)d.E.ET\\/"M%'//"{GG dll*.$,,G3%337J,0)!M (T->->e-K(//8/ 98&#!!.+ + +/$& ,s*C D+ D+D+'D+6*D+ D)! D+rN)rrYrrrQrR)r2rYrQVersion | None)r2rYrQrrQSequence[_VersionRange])rrYrrYrQlist[_VersionRange]rrErrQrRrX)rQztuple[str, str]rVrT)rrYrQCallableOperator)r7rrrYrQrS)rrYrQztuple[list[str], int])r7rrPrYrQrS)r7z Version | strrrYrQrS)rz str | VersionrQrSr)rUnparsedVersionrrrQrSrrrrr),r&r'r(r)rZ_specifier_regex_strrecompileVERBOSE IGNORECASErr__annotations__r6rrrrrrrrrr2rPrr&rJrCr-r8r>r6rHrKr5rQrTrWr[rrrrrrrrrsIZ xRZZ%%. R]]0JF "   J $ !((.##D) ##,,," J     %1&6  - s*A B"B# B1B B BBcg}|jd\}}}|j|xsd|jdD]J}tj |}|r |j |j :|j|L|S)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)r2rr8_restrrfs rr4r4s~F'',NE1d MM%,3 3 ''-  MM%,,. ) MM$   Mrc6|^}}|ddj|S)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) componentsr8rs rr/r/s'LEDWAchhtn% &&rc.tfddD S)Nc3@K|]}j|ywr)r).0rsegments r z!_is_not_suffix..s!'-6")r;abrcr:)any)rs`rr3r3s"1P rcHd}|D]}|js|S|dz }|S)zCount 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   LrcTt|}||z }|dkr|Sg|d|dg|z||dS)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 rr@r@sN&e,K#k1JQ 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 rrrr)rrrnrlr rrrrr )rr)op_entryrverrs r_operator_costrs|JAsB Tz T*q11 ## Tz Tz T*q11 U{ )"0 11rceZdZdZdZ d ddZddZeddZejddZddZ dd Z dd Z d d Z d!d Zdd Zd"dZd#dZd$dZd$dZd$dZd%dZ d& d'dZej0 d( d)dZej0 d( d*dZ d& d+dZ d, d-dZy).rzThis 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. )_canonicalized_has_arbitrary_is_unsatisfiabler _resolved_ops_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|vywrNrrss rrz(SpecifierSet.__init__..s%K!es1vo%Ksr N)r@rYrrtuplemaprrrrr rrrr)r4 specifiersrrsplit_specifierss rr6zSpecifierSet.__init__s, j# &4>3C3CC3HVaAGGI V V16s9FV7W1XDK"':"5D  +DK#&%Kt{{%K"KD !$++.!3MQ(.2% Ws CCc|jsQttjt |j t |_d|_d|_d|_|j S)zBDeduplicate, sort, and cache specs for order-sensitive operations.rTN) rrdictfromkeyssortedrrYrrrIs r_canonical_specszSpecifierSet._canonical_specs$sM"" fT[[c.J KLDK"&D !%D %)D "{{rc|j |jS|jsytd|jDryy)Nc34K|]}|jywrr^rs rrz+SpecifierSet.prereleases..<s2q}}2sT)rrrrIs rrzSpecifierSet.prereleases-sB    ($$ $ {{ 2dkk2 2rc ||_d|_yr)rrrs rrzSpecifierSet.prereleasesAs!!%rc|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)> rrrlrLrrrs rrPzSpecifierSet.__repr__FsU  ,T--0 1 4>>**+1SYM#bAArcNdjd|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|ywrrrs rrz'SpecifierSet.__str__..fs@1A@s)rrrIs rrzSpecifierSet.__str__[s"xx@(=(=(?@@@rc4t|jSr)rHrrIs rrJzSpecifierSet.__hash__hsD))+,,rct|tr t|}nt|tstSt}|j|jz|_t |jdk|_|jxs |j|_d|_|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 NzFCannot combine SpecifierSets with True and False prerelease overrides.) r@rYrrArr rrrrr)r4r< specifiers r__and__zSpecifierSet.__and__ks eS ! 'EE<0! ! N ;;5 #&y'7'7#8A#=  #'#6#6#N%:N:N  "&     $(9(9U=O=O(O%*%7%7I "   '%)%6%6I "  X rct|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@rYrrrArrBs rrCzSpecifierSet.__eq__sN& ec9- . U,EE<0! !$$&%*@*@*BBBrc,t|jS)z7Returns the number of specifiers in this specifier set.)r rrIs r__len__zSpecifierSet.__len__s4;;rc,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')>] )iterrrIs r__iter__zSpecifierSet.__iter__sDKK  rc|j}d}|D]3}||j}t||j}|r3n| td|S)aIntersect 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)rrr RuntimeError)r4specsrrs r _get_rangeszSpecifierSet._get_rangessa 15 A~*61<<>B   >AB B rc|j}||S|jsd|_y|j }|s|j}|s|jdur|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 F)rrr_check_arbitrary_unsatisfiabler_check_prerelease_only_ranges)r4cachedrs ris_unsatisfiablezSpecifierSet.is_unsatisfiablesy''  M{{%*D "%%''88:F$**e3779F!' rc|jD]Y\}}t|j}|y|j||jkry||jk(sL|jsYyy)zWith prereleases=False, check if every range contains only pre-release versions (which would be excluded from matching).FT)rrr2r^)r4rrnearests rrz*SpecifierSet._check_prerelease_only_rangessh!,,. LE5-emmSpecifierSet._check_arbitrary_unsatisfiable..s!Aaqyy E)As'*r NTc3@K|]}|jywrrY)rr candidates rrz>SpecifierSet._check_arbitrary_unsatisfiable..s?qzz),?r) rrr2rrrrrall)r4rrstandardrrs @@rrz+SpecifierSet._check_arbitrary_unsatisfiables!% C1qzzU/BQC C! $$**, A9QR=A A$IaL$8$89    %%''#{{B!ajjE.AABB  ?h????=D,CsCC'C"<C"c$|j|S)aqReturn 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 rYrZs rr[zSpecifierSet.__contains__r\rct|}||r|jrd}||jrt|ts|}n|}t t |j|g|S)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@rrSr0r)r4rr installedr2 check_items rrzSpecifierSet.contains4se@"$'  91F1FK ?t22:dG;TJ JDj\{KLMMrcyrrrs rrzSpecifierSet.filterarrcyrrrs rrzSpecifierSet.filterirrct||j |j}|jrft|jdk(r&|jdj||dn|}n|j ||dn|}||St |S|dur t |S|dur fd|DSt |S)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)rrr^Fc3jK|]*}t|n|x js|,ywr)rr)rrrr2s rrz&SpecifierSet.filter..sA / T SSW"00 s03)rrr r_filter_versionsrzr)r4rrrfilteredr2s ` @rrzSpecifierSet.filterqsd  4#3#3#?**K ;; 4;;1$;;q>00(3(;1  00(3(;1 &-h< < $ > ! % $ *(C88rc#\K|j'td|jDt|_|j}|du}|D]]t nt fd|Ds/4|r j rCt fd|DsZ_yw)a?Filter 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. Nc3K|]6}|j|j|j|jf8ywr)r-rr2)rrs rrz0SpecifierSet._filter_versions..s6'' 6 dmmTs<>rFc3K|]9\}}}|dk(xr*tj|jk(;ywrrV)rrrrrs rrz0SpecifierSet._filter_versions..sA"3%KDCIOO$5$DDs?Ac3K|]J\}}}|dk(r4tnj|jk(n||LywrrV)rop_fnrrrrrys rrz0SpecifierSet._filter_versions..s\#E3;CKDSY7==?399;N63'(sAA)rrrrrrr)r4rrropsexclude_prereleasesrrys ` @@rrzSpecifierSet._filter_versionss    %!' $ # "D   )U2 D$S[Tc$iHF~&)J$)=)='*  ' sA4B,:*B,%B,rg)rzstr | Iterable[Specifier]rrrQrR)rQztuple[Specifier, ...]rrlrXrV)r<zSpecifierSet | strrQrrT)rQzIterator[Specifier]ri)rQrS)rrnrQrSr)rrnrrrrrQrSrrrrr)rrrrrrrQr)r&r'r(r)rZr6rrrrrPrrJrrCrrrrrrr[rrrrrrrrrrs I13#'+3-+3!+3  +3Z&&&B* A-BC4 !,B %@N#0$(!% +N+N!+N +N  +NZ __$( +.+!+ + & ++ __$(.1 !,   $(7; ^9^9!^95 ^9  ^9H$( ,,5,! ,  ,rr)rQ list[str])r!tuple[int, ...]rQr)rr\rrwrQrS)rrjrrjrQrk)r2rrQr)r2rnrQrh)r=rsrQrh)rrrrrQr)r2rYrQr)rrrQrY)rrYrQrS)rrrQrW)rrrrWrQr)rz!tuple[CallableOperator, str, str]rQrW)Fr) __future__rrr* functoolsr1rprrrrrrr r r utilsr r2rrrrrrYrnrrSrmrrtr#Enumr%total_orderingr/r\rw TYPE_CHECKINGrsr _VersionRangerr rrrrrrrrrrrrABCMetarrrqrrzr4r/r3r:r@rrrrrrsF#  UUU',  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 d@ , @ ,F :; ' ' "I' ' T,'  O26V=Vr