Oj~UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z m Z m Z mZmZmZmZmZddlmZddlmZmZej0dk\rdd l mZne rdd lmZgd Zd:d Zd;d Zdd Z4 d?d!Z5d@d"Z6d@d#Z7dAd$Z8d@d%Z9d@d&Z:d@d'Z; dBd(Z<Gd)d*e=Z>Gd+d,ej~-Z@Gd.d/e@ZAejd0ZC dCd1ZDdDd2ZEdEd3ZFdFd4ZGdGd5ZHdHd6ZIdId7ZJGd8d9e@ZKy)Jz .. testsetup:: from pip._vendor.packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from pip._vendor.packaging.version import Version ) annotationsN) TYPE_CHECKINGAnyCallableFinalIterableIteratorSequenceTypeVarUnion)canonicalize_version)InvalidVersionVersion) ) TypeGuard) BaseSpecifierInvalidSpecifier Specifier SpecifierSetctSN)__all__w/var/www/origus_pro_usr/data/www/origus.pro/core/.venv/lib/python3.12/site-packages/pip/_vendor/packaging/specifiers.py__dir__r0s Nrct|txr8t|dk(xr(t|dtxrt|dtS)Nrr ) isinstancetuplelenstr)specs r_validate_specr&4sI4 % IN % tAw $ % tAw $ rc.|duxst|tSr)r!bool)pres r _validate_prer*=s $; /*S$//rTUnparsedVersionVar)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)r#)releaseends r _trim_releaser2Js` 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)rAr?r2r0r@)selfrAkinds r__init__z_BoundaryVersion.__init__qs!  -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) rAepochr2r0r@r)r?r4r;postdev)rCothervs r _is_familyz_BoundaryVersion._is_familyvs LL KK177 "emm,0E0EE QUU" ::33 3::'>EII,> >yyAEE!;UZZt%;;rct|tr4|j|jk(xr|j|jk(StSr)r!r>rAr?NotImplementedrCrJs r__eq__z_BoundaryVersion.__eq__s8 e- .<<5==0NTZZ5;;5N Nrc&t|tr_|j|jk7r|j|jkS|jj|jjkS|j | xr|j|kSr)r!r>rAr?valuerLrOs r__lt__z_BoundaryVersion.__lt__so e- .||u}},||emm33::##ekk&7&77 7??5))BdllU.BBrcDt|j|jfSr)hashrAr?rCs r__hash__z_BoundaryVersion.__hash__sT\\4::.//rc||jjd|jd|jjdS)N(z, )) __class__r5rAr?namerVs r__repr__z_BoundaryVersion.__repr__s4..))*!DLL+;2djjoo=NaPPrN)rArrDr4returnNone)rJrr^r(rJobjectr^r()rJz_BoundaryVersion | Versionr^r(r^intr^r$) r5r6r7r8 __slots__rErLrPrSrWr]rrrr>r>Ys.(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.  inclusiverAc ||_||_yrrArirCrAris rrEz_LowerBound.__init__ "rct|tstS|j|jk(xr|j|jk(Srr!rgrNrArirOs rrPz_LowerBound.__eq__7%-! !||u}},R5??1RRrct|tstS|j|jduS|jy|j|jk7r|j|jkS|jxr |j S)NFrorOs rrSz_LowerBound.__lt__sq%-! ! << ==, , ==  <<5== (<<%--/ /~~5eoo"55rcDt|j|jfSrrUrArirVs rrWz_LowerBound.__hash__T\\4>>233rct|jrdnd}d|jjd||jdS)N[rY< >rir[r5rArCbrackets rr]z_LowerBound.__repr__s8#S4>>**+1WIdll5EQGGrNrA_VersionOrBoundaryrir(r^r_r`)rJrgr^r(rbrd r5r6r7r8rerErPrSrWr]rrrrgrg))I#S 64Hrrgc<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. rhc ||_||_yrrkrls rrEz_UpperBound.__init__rmrct|tstS|j|jk(xr|j|jk(Srr!rrNrArirOs rrPz_UpperBound.__eq__rprct|tstS|jy|jy|j|jk7r|j|jkS|j xr |jSNFTrrOs rrSz_UpperBound.__lt__se%-! ! <<  ==  <<5== (<<%--/ />>!5eoo5rcDt|j|jfSrrsrVs rrWz_UpperBound.__hash__rtrct|jrdnd}d|jjd|j|dS)N]rZrwrxryrzr{s rr]z_UpperBound.__repr__s8#S4>>**+1T\\, 1.3.dev0.Nr rrGr0rI)r0r from_partsrG)rAr0s 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)rrrGr0rAs r _base_dev0rs   GMM7??PQ RRrc`t|ts t|}|S|S#t$rYywxYwr)r!rrrs r_coerce_versionr$s: gw ' g&G N7N  s ! --cB|j|S|jdS)N)local)r __replace__rs r_public_versionr-s%}}   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. NrHrIrrrs r _post_baser3s   Dd$  ??rc(|jddS)zZEarliest pre-release of *version*. 1.2 -> 1.2.dev0, 1.2.post1 -> 1.2.post1.dev0. rNrIrrrs r_earliest_prereleaser;s   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)r)rIrr r)rHr)r!r>rA is_prereleaserrH)rKinnerks r_nearest_non_prereleaserCs 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)r5r6r7r8rrrrrXsrrceZdZdZdZeddZejddZ ejddZ ejddZ eejddZ e jddZ ejddd Zej d dd Zej d dd Zej d dd Zy )rr)_strct|S)z Internal property for match_argsr$rVs rrzBaseSpecifier._strhs4yrcy)z Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. NrrVs r__str__zBaseSpecifier.__str__mrcy)zF Returns a hash value for this Specifier-like object. NrrVs rrWzBaseSpecifier.__hash__trrcy)z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. NrrOs rrPzBaseSpecifier.__eq__zrrcy)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. NrrVs r prereleaseszBaseSpecifier.prereleasesrrcy)zQSetter for :attr:`prereleases`. :param value: The value to set. NrrCrRs rrzBaseSpecifier.prereleasesrrNcy)zR Determines if the given item is contained within this specifier. NrrCitemrs rcontainszBaseSpecifier.containsrrcyrrrCiterablerkeys 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.filterrrrdrbr`r^ bool | None)rRr(r^r_r)rr$rrr^r(N.rzIterable[UnparsedVersionVar]rrrr_r^zIterator[UnparsedVersionVar]rz Iterable[T]rrrzCallable[[T], UnparsedVersion]r^z Iterator[T]NNr Iterable[Any]rrr'Callable[[Any], UnparsedVersion] | Noner^ Iterator[Any])r5r6r7re__match_args__propertyrabcabstractmethodrrWrPrsetterrtypingoverloadrrrrrrdsIN                  __$( +.+!+ + & ++ __$(.1 !,    $(7;    !  5      rr) metaclassc \eZdZUdZdZdZejdezdzejejzZ ddddd d d d d Z de d<d1d2dZ d3dZd4dZd5dZd6dZd6dZed7dZej*d8dZd9dZd:dZed;dZed;dZd;dZd;dZedd!Zd?d"Zd@d#Z dAd$Z!d@d%Z"d@d&Z#d@d'Z$d@d(Z%dBd)Z&dBd*Z'dCd+Z(dDd,Z)dEdFd-Z*e+jX dG dHd.Z-e+jX dG dId/Z- dJ dKd0Z-y)LraThis 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 pip._vendor.packaging < 26.2 is supported but may be removed in a future release. ) _prereleases_ranges_spec _spec_version_wildcard_splita  (?: (?: # The identity operators allow for an escape hatch that will # do an exact string match of the version you wish to install. # This will not be parsed by PEP 440 and we cannot determine # any semantic meaning from it. This operator is discouraged # but included entirely as an escape hatch. === # Only match for the identity operator \s* [^\s;)]* # The arbitrary version can be just about anything, # we match everything except for whitespace, a # semi-colon for marker support, and a closing paren # since versions can be enclosed in them. ) | (?: # The (non)equality operators allow for wild card and local # versions to be specified so we have to define these two # operators separately to enable that. (?:==|!=) # Only match for equals and not equals \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release # You cannot use a wild card and a pre-release, post-release, a dev or # local version together so group them with a | and make them optional. (?: \.\* # Wild card syntax of .* | (?a: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?a: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?a:[-_\.]?dev[-_\.]?[0-9]*)? # dev release (?a:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local )? ) | (?: # The compatible operator requires at least two digits in the # release segment. (?:~=) # Only match for the compatible operator \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)+ # release (We have a + instead of a *) (?: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) | (?: # All other operators only allow a sub set of what the # (non)equality operators do. Specifically they do not allow # local versions to be specified nor do they allow the prefix # matching wild cards. (?:<=|>=|<|>) \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release (?a: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?a: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?a:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) ) z\s* compatibleequal not_equalless_than_equalgreater_than_equal less_than greater_than arbitrary)~===!=<=>=rwry===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: rNr)rrrrrr r ) _regex fullmatchrstrip startswithrrrrr)rCr%roperatorrAs rrEzSpecifier.__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)rCrAversion_specifiers r_get_spec_versionzSpecifier._get_spec_versioncsY    )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)rCrA spec_versions r_require_spec_versionzSpecifier._require_spec_versionos& --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.*)rrrArendswith_wildcard_ranges_standard_ranges)rCopver_strrs r _to_rangeszSpecifier._to_rangesys| << #<<  ]],, ;&DL    D !**2w7F**2w7F  rc|j|dd}t|}t|}|dk(rt|dt |dfgSt t |dft|dt fgS)NrTF)rrrrgr_NEG_INF_POS_INF)rCr r baserrs rr zSpecifier._wildcard_rangessy))'#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|)NrTrryr rrrFrw+rrrr)r0Unknown operator: )rrgrrrr>r4r;rIrrHr<rr.r0r ValueError) rCr r rK lower_verr- has_local after_localsrprefixs rr zSpecifier._standard_rangess+  & &w / : D)845 5 : 0M4N4N OQUV  9uu MMaeeaitMD $Y5x@AAvv!MMqvvzqMM $Y5x@AA 0M4M4M NPUV  9Aammm.NE $ {5%89: :7N '=+E+EF L : D);ud+CDE E :;q%01UE*H5  :]]199Sb>]:FQ%{3DV3Le'TU -bV455rc|j |jS|j\}}|dk(ry|dk(r|jdry|j|}|y|jS)NrFrr)rrrrr)rCr version_strrAs rrzSpecifier.prereleasessy    ($$ $!% + t  t  4 4T :((5 ?$$$rc||_yr)rrs rrzSpecifier.prereleasess !rc2|j|jfSr)rrrVs r __getstate__zSpecifier.__getstate__s D--..rcdd|_d|_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 rrinvalidzCannot restore Specifier from ) rrrr!r"r#r&r*rrdictget TypeError)rCstater%r_ 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 BCCrc |jdS)z`The operator of this specifier. >>> Specifier("==1.2.3").operator '==' rrrVs rrzSpecifier.operator$zz!}rc |jdS)zaThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r r*rVs rrAzSpecifier.version-r+rc|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=rwrY)>rrr[r5r$rCr)s rr]zSpecifier.__repr__6sU  ,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{}{})formatrrVs rrzSpecifier.__str__Hsv}}djj))rc|j\}}|dk(s|jdr||fS|j|}t||dk7}||fS)Nrrrstrip_trailing_zero)rrrr)rCrrArcanonical_versions r_canonical_speczSpecifier._canonical_specRsc JJ' u  0 0 6W$ $11': 0 x4/? ***rc,t|jSr)rUr9rVs rrWzSpecifier.__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!r$r[rrNr9rOs rrPzSpecifier.__eq__csi& eS ! &s5z2E4>>2! !##u'<'<<< $ &%% &sA""A43A4c>t|d|j|}|S)N _compare_)getattrr)rCr operator_callables r _get_operatorzSpecifier._get_operators+.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)rC prospectiver%rs r_compare_compatiblezSpecifier._compare_compatiblesd $$^^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) NrFr6)rrrG_numeric_prefix_len)rCr%wildcard_split normalized split_specs r_get_wildcard_splitzSpecifier._get_wildcard_splitsO--  !-d3BiUSJ' 3J(*=j*IJN#1D rc&|jdrT|j|\}}tt|d}t |}t ||}|dt |}||k(S|j|} | js t|}|| k(S)NrFr6) rrQrrrG _left_padr#rr) rCrJr%rPspec_numeric_lennormalized_prospectivesplit_prospectivepadded_prospectiveshortened_prospectivers rrIzSpecifier._compare_equals == +/+C+CD+I (J(&: ,%& " !//E F "++<>N!O  %77HZ$I !(J6 6 55d;L  %%-k: ,. .rc(|j|| Sr)rIrCrJr%s r_compare_not_equalzSpecifier._compare_not_equals&&{D999rc<t||j|kSrrrrZs r_compare_less_than_equalz"Specifier._compare_less_than_equal{+t/I/I$/OOOrc<t||j|k\Srr]rZs rrHz%Specifier._compare_greater_than_equalr_rc|j|}||ksy|js|jr|t|k\ryyr)rrrrCrJspec_strr%s r_compare_less_thanzSpecifier._compare_less_thansK))(3 T! ""))3D99 rc|j|}||kDsy|js|jrt||k(ry|jt ||k(ryyr)ris_postreleaserrrrbs r_compare_greater_thanzSpecifier._compare_greater_thansg))(3 T! ##**;'4/    (_[-IT-Q rcht|jt|jk(Srr$rrZs 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 rrCrs 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)r(rCrrs rrzSpecifier.contains.s#2DdVEFGGrcyrrrs rrzSpecifier.filterIrrcyrrrs rrzSpecifier.filterQrrc#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@rrrjrArrr) rCrrrprereleases_versionsfound_non_prereleasesinclude_prereleasesr?rAparsed_versionmatchs rrzSpecifier.filterYsSF " %'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+r/N)r%r$rrr^r_)rAr$r^Version | None)rAr$r^rr^Sequence[_VersionRange])r r$r r$r^list[_VersionRange]rrRrr^r_)r^z#tuple[tuple[str, str], bool | None]r%rar^r_rd)r^ztuple[str, str]rbr`)r r$r^CallableOperator)rJrr%r$r^r()r%r$r^ztuple[list[str], int])rJrrcr$r^r()rJz Version | strr%r$r^r()rz str | Versionr^r(r)rUnparsedVersionrrr^r(rrrrr).r5r6r7r8re_specifier_regex_strrecompileVERBOSE IGNORECASErr__annotations__rErrr r r rrrrr(rrAr]rr9rWrPr@rKrQrIr[r^rHrdrgrjrnrrrrrrrrrs&IZ 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)rArrGr&restrrys rrGrGs~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. rr)join) componentsrGrs rrBrBs'LEDWAchhtn% &&rc.tfddD S)Nc3@K|]}j|ywr)r).0rsegments r z!_is_not_suffix..s!'-6")rIabrcrH)any)rs`rrFrFs"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 rrMrMs< 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)rM)rtarget_numeric_len numeric_len pad_neededs rrSrS 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 )rrryrwr rrrrr)rr)op_entryr&verr s r_operator_costrs|JAsB Tz T*q11 ## Tz Tz T*q11 U{ )"0 11rceZdZdZdZ d ddZddZeddZejddZd dZ d!d Z d"d Z d"d Z d#d Zd$d Zd%dZd#dZd&dZd'dZd(dZd(dZd(dZd)dZ d* d+dZej4 d, d-dZej4 d, d.dZ d* d/dZ d0 d1dZy)2raThis class abstracts handling of a set of version specifiers. It can be passed a single specifier (``>=3.0``), a comma-separated list of specifiers (``>=3.0,!=3.1``), or no specifier at all. Instances are safe to serialize with :mod:`pickle`. They use a stable format so the same pickle can be loaded in future packaging releases. .. versionchanged:: 26.2 Added a stable pickle format. Pickles created with packaging 26.2+ can be unpickled with future releases. Backward compatibility with pickles from packaging < 26.2 is supported but may be removed in a future release. )_canonicalized_has_arbitrary_is_unsatisfiabler _resolved_ops_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__..ts%K!es1vo%Kr N)r!r$rrr"maprrrrr#rrrr)rC specifiersrrsplit_specifierss rrEzSpecifierSet.__init__Rs, 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) rr"r"fromkeyssortedrr$rrrVs r_canonical_specszSpecifierSet._canonical_specssM"" fT[[c.J KLDK"&D !%D %)D "{{rc|j |jS|jsytd|jDryy)Nc34K|]}|jywrrqrs rrz+SpecifierSet.prereleases..s2q}}2sT)rrrrVs rrzSpecifierSet.prereleasessB    ($$ $ {{ 2dkk2 2rc ||_d|_yr)rrrs rrzSpecifierSet.prereleasess!!%rc2|j|jfSr)rrrVs rrzSpecifierSet.__getstate__s T..//rcd|_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|tywrr!rrs rrz,SpecifierSet.__setstate__..DJq)4Dr c36K|]}dt|vywrrrs rrz,SpecifierSet.__setstate__..s-M!es1vo-Mrrrrrc3<K|]}t|tywrrrs rrz,SpecifierSet.__setstate__..rrc36K|]}dt|vywrrrs rrz,SpecifierSet.__setstate__..s-S!es1vo-Src3<K|]}t|tywrrrs rrz,SpecifierSet.__setstate__..s@Q 1i0@rc36K|]}dt|vywrrrs rrz,SpecifierSet.__setstate__..s)Oa%3q6/)Orz!Cannot restore SpecifierSet from )rrr!r"r#allr*rrrrrr"r# frozensetrr$r$)rCr%specsrr&r's rr(zSpecifierSet.__setstate__s!!% 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#;E9EFFrc|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)> r.r/rwrYr0r1r2s rr]zSpecifierSet.__repr__sU  ,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__..s@1A@s)rrrVs rrzSpecifierSet.__str__s"xx@(=(=(?@@@rc4t|jSr)rUrrVs rrWzSpecifierSet.__hash__sD))+,,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!r$rrNrr#rrrrr)rCrJ specifiers 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 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!r$rrrNrrOs rrPzSpecifierSet.__eq__&sN& ec9- . U,EE<0! !$$&%*@*@*BBBrc,t|jS)z7Returns the number of specifiers in this specifier set.)r#rrVs 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')>] )iterrrVs r__iter__zSpecifierSet.__iter__DsDKK  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)rr r RuntimeError)rCrrrs r _get_rangeszSpecifierSet._get_rangesNsa 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)rCcachedrs ris_unsatisfiablezSpecifierSet.is_unsatisfiabledsy''  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)rrrAri)rCrrnearests rrz*SpecifierSet._check_prerelease_only_rangessh!,,. LE5-emmSpecifierSet._check_arbitrary_unsatisfiable..s!Aaqyy E)As'*r NTc3@K|]}|jywrrl)rr candidates rrz>SpecifierSet._check_arbitrary_unsatisfiable..s?qzz),?r) rrrArrrrrr)rCrrstandardrrs @@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 rlrms rrnzSpecifierSet.__contains__rorct|}||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 Trq)rrrr!rr(rCr)rCrr installedrA check_items rrzSpecifierSet.containsse@"$'  91F1FK ?t22:dG;TJ JDj\{KLMMrcyrrrs rrzSpecifierSet.filterrrcyrrrs rrzSpecifierSet.filterrrct||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)rrrqFc3jK|]*}t|n|x js|,ywr)rr)rrrrAs rrz&SpecifierSet.filter..^sA / T SSW"00 s03)rrr#r_filter_versionsrr)rCrrrfilteredrAs ` @rrzSpecifierSet.filter sd  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@rrA)rr%s rrz0SpecifierSet._filter_versions..{s6'' 6 dmmTs<>rFc3K|]9\}}}|dk(xr*tj|jk(;ywrri)rr&rr rs rrz0SpecifierSet._filter_versions..sA"3%KDCIOO$5$DDs?Ac3K|]J\}}}|dk(r4tnj|jk(n||Lywrri)rop_fnrr rrrs rrz0SpecifierSet._filter_versions..s\#E3;CKDSY7==?399;N63'(sAA)rrrrrrr)rCrrropsexclude_prereleasesrrs ` @@rrzSpecifierSet._filter_versionsks    %!' $ # "D   )U2 D$S[Tc$iHF~&)J$)=)='*  ' sA4B,:*B,%B,rz)rzstr | Iterable[Specifier]rrr^r_)r^ztuple[Specifier, ...]rr)r^z)tuple[tuple[Specifier, ...], bool | None]rrdrb)rJzSpecifierSet | strr^rr`)r^zIterator[Specifier]r|)r^r()rrr^r(r)rrrrrrr^r(rrrrr)rrrrrrr^r)r5r6r7r8rerErrrrrr(r]rrWrrPrrrrrrrnrrrrrrrrrr6s$I13#'+3-+3!+3  +3Z&&&0 7GrB* A-BC4 !,B %@N#0$(!% +N+N!+N +N  +NZ __$( +.+!+ + & ++ __$(.1 !,   $(7; ^9^9!^95 ^9  ^9H$( ,,5,! ,  ,rr)r^ list[str])r%rar^zTypeGuard[tuple[str, str]])r)rar^zTypeGuard[bool | None])r0tuple[int, ...]r^r)rrgrrr^r()rr}rr}r^r~)rArr^r)rArr^r{)rKr~r^r{)rrrrr^r)rAr$r^r)rrr^r$)rr$r^r()rrr^rc)rrrrcr^r)rz!tuple[CallableOperator, str, str]r^rc)Lr8 __future__rrr9 functoolsrDrsysrrrrrrr r r r utilsrrArr version_infortyping_extensionsrrr&r*r+r$rr,r(rr.rr2Enumr4total_orderingr>rgrr~r" _VersionRangerrrrrrrrrrrrrrABCMetarrrrrrGrBrFrMrSrrrrrrsr#     (,w + 0 CL %1IWcND01 'x0 n0=DII ;Q;Q;Q| %H%H%HP %H%H%HP w(8$>?+{23M tU # tU #&.%9$; !;) ! "4K S + @2999* z O ckkO dr , r ,j :; ' ' "I' ' T,'  O26a =a r