o ѭjZ@sUdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z m Z m Z mZmZmZmZmZddlmZddlmZmZejdkrUdd l mZne r]dd lmZgd Zdqd dZdrddZdsddZedZeee fZ!ede!dZ"e ee ge#fZ$edZ%de&d<dtd d!Z'Gd"d#d#ej(Z)ej*Gd$d%d%Z+ej*Gd&d'd'Z,ej*Gd(d)d)Z-e j reee+dfZ.e/e,e-fZ0e,dd*Z1e-dd*Z2e1e2ffZ3d+e&d,<dud0d1Z4dvd6d7Z5dwd:d;Z6dwdGdNdOdOej?dPZ@GdQdRdRe@ZAeBdSZCdzdYdZZDd{d\d]ZEd|d_d`ZFd}dbdcZGd~dfdgZHddidjZIddmdnZJGdodpdpe@ZKdS)z .. testsetup:: from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from packaging.version import Version ) annotationsN) TYPE_CHECKINGAnyCallableFinalIterableIteratorSequenceTypeVarUnion)canonicalize_version)InvalidVersionVersion) ) TypeGuard) BaseSpecifierInvalidSpecifier Specifier SpecifierSetreturn list[str]cCstSN)__all__rrQ/var/www/html/CropPilot/venv/lib/python3.10/site-packages/packaging/specifiers.py__dir__0srspecobjectTypeGuard[tuple[str, str]]cCs2t|tot|dkot|dtot|dtS)Nrr ) isinstancetuplelenstr)rrrr_validate_spec4s    r&preTypeGuard[bool | None]cCs|dupt|tSr)r"bool)r'rrr _validate_pre=sr*TUnparsedVersionVar)boundz0.dev0zFinal[Version] _MIN_VERSIONreleasetuple[int, ...]cCs\t|}|dkr ||ddkr |d8}|dkr ||ddks|t|kr(|S|d|S)zDStrip trailing zeros from a release tuple for normalized comparison.r rN)r$)r/endrrr _trim_releaseJs r2c@s eZdZdZeZeZdS) _BoundaryKindz5Where a boundary marker sits in the version ordering.N)__name__ __module__ __qualname____doc__enumauto AFTER_LOCALS AFTER_POSTSrrrrr3Rs r3c@sPeZdZdZdZdd d Zdd dZdddZdddZd ddZ d!ddZ dS)"_BoundaryVersiona A point on the version line between two real PEP 440 versions. Some specifier semantics imply boundaries between real versions: ``<=1.0`` includes ``1.0+local`` and ``>1.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_releaseversionr?rkindr3rNonecCs||_||_t|j|_dSr)r?r=r2r/r>)selfr?r@rrr__init__qsz_BoundaryVersion.__init__otherr)cCsl|j}|j|jkrt|j|jkr|j|jksdS|jtjkr+|j |j ko*|j |j kS|j |j kp5|j duS)z6Is ``other`` a version that this boundary sorts above?FN) r?epochr2r/r>r'r=r3r:postdev)rBrDvrrr _is_familyvs   z_BoundaryVersion._is_familyrcCs&t|tr|j|jko|j|jkStSr)r"r<r?r=NotImplementedrBrDrrr__eq__s z_BoundaryVersion.__eq___BoundaryVersion | VersioncCsHt|tr|j|jkr|j|jkS|jj|jjkS|| o#|j|kSr)r"r<r?r=valuerIrKrrr__lt__s   z_BoundaryVersion.__lt__intcCt|j|jfSr)hashr?r=rBrrr__hash__z_BoundaryVersion.__hash__r%cCs |jjd|jd|jjdS)N(z, )) __class__r4r?r=namerSrrr__repr__s z_BoundaryVersion.__repr__N)r?rr@r3rrA)rDrrr)rDrrr))rDrMrr)rrPrr%) r4r5r6r7 __slots__rCrIrLrOrTrZrrrrr<Ys     r<c@FeZdZdZdZdd d Zdd dZdddZdddZdddZ dS) _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.  inclusiver?r?_VersionOrBoundaryrbr)rrAcC||_||_dSrr?rbrBr?rbrrrrC z_LowerBound.__init__rDrcC&t|tstS|j|jko|j|jkSrr"r`rJr?rbrKrrrrL z_LowerBound.__eq__cCsVt|tstS|jdur|jduS|jdurdS|j|jkr$|j|jkS|jo*|j S)NFrirKrrrrOs      z_LowerBound.__lt__rPcCrQrrRr?rbrSrrrrTrUz_LowerBound.__hash__r%cCs*|jrdnd}d|jjd||jdS)N[rV< >rbrXr4r?rBbracketrrrrZz_LowerBound.__repr__Nr?rcrbr)rrAr[)rDr`rr)r\r] r4r5r6r7r^rCrLrOrTrZrrrrr`    r`c@r_) _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. rar?rcrbr)rrAcCrdrrerfrrrrCrgz_UpperBound.__init__rDrcCrhrr"rwrJr?rbrKrrrrLrjz_UpperBound.__eq__cCsPt|tstS|jdurdS|jdurdS|j|jkr!|j|jkS|j o'|jSNFTrxrKrrrrOs     z_UpperBound.__lt__rPcCrQrrkrSrrrrTrUz_UpperBound.__hash__r%cCs*|jrdnd}d|jjd|j|dS)N]rWrmrnrorprqrrrrZrsz_UpperBound.__repr__Nrtr[)rDrwrr)r\r]rurrrrrwrvrwFztuple[_VersionRange] _FULL_RANGElowerupperr)cCs>|jdus |jdur dS|j|jkr|jo|j S|j|jkS)zHTrue when the range defined by *lower* and *upper* contains no versions.NFre)r|r}rrr_range_is_emptys   r~leftSequence[_VersionRange]rightlist[_VersionRange]c Csg}d}}|t|krM|t|krM||\}}||\}}t||} t||} t| | s4|| | f||kr=|d7}n|d7}|t|krM|t|ks|S)zFIntersect two sorted, non-overlapping range lists (two-pointer merge).rr )r$maxminr~append) rrresult left_index right_index left_lower left_upper right_lower right_upperr|r}rrr_intersect_rangess      rr?rcCs4g|jdd|jddR}tj|j|ddS)z5Smallest version in the next prefix: 1.2 -> 1.3.dev0.Nr rrEr/rG)r/r from_partsrE)r?r/rrr_next_prefix_dev0s"rcCstj|j|jddS)z7The .dev0 of a version's base release: 1.2 -> 1.2.dev0.rr)rrrEr/r?rrr _base_dev0srUnparsedVersionVersion | NonecCs2t|tszt|}W|StyYdSw|Sr)r"rrrrrr_coerce_version$s   rcCs|jdur|S|jddS)N)local)r __replace__rrrr_public_version-s  rcCs|jddddS)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. NrFrGrrrrrr _post_base3srcCs|jdddS)zZEarliest pre-release of *version*. 1.2 -> 1.2.dev0, 1.2.post1 -> 1.2.post1.dev0. rNrGrrrrrr_earliest_prerelease;srrHrccCsr|durdSt|tr,|j}|jr|jddddS|jdur#|jdnd}|j|ddS|js1|S|jddddS)z:Smallest non-pre-release version at or above *v*, or None.N)r'rGrr r)rFr)r"r<r? is_prereleaserrF)rHinnerkrrr_nearest_non_prereleaseCs rc@seZdZdZdS)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)r4r5r6r7rrrrrXsrc@seZdZdZdZed+ddZejd+ddZ ejd,d d Z ejd-ddZ eejd.ddZ e j d/ddZ ejd0d1ddZej  d2d3d!d"Zej  d2d4d&d"Zej  d5d6d*d"ZdS)7rr)_strrr%cCst|S)z Internal property for match_argsr%rSrrrrhszBaseSpecifier._strcCdS)z Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. NrrSrrr__str__mzBaseSpecifier.__str__rPcCr)zF Returns a hash value for this Specifier-like object. NrrSrrrrTtrzBaseSpecifier.__hash__rDrr)cCr)z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. NrrKrrrrLzrzBaseSpecifier.__eq__ bool | NonecCr)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. NrrSrrr prereleasesrzBaseSpecifier.prereleasesrNrAcCr)zQSetter for :attr:`prereleases`. :param value: The value to set. NrrBrNrrrrrNitemrcCr)zR Determines if the given item is contained within this specifier. NrrBrrrrrcontainsrzBaseSpecifier.contains.iterableIterable[UnparsedVersionVar]keyIterator[UnparsedVersionVar]cCdSrrrBrrrrrrfilterzBaseSpecifier.filter Iterable[T]Callable[[T], UnparsedVersion] Iterator[T]cCrrrrrrrrr Iterable[Any]'Callable[[Any], UnparsedVersion] | None Iterator[Any]cCr)z Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nrrrrrrrr]r\r[rr)rNr)rrAr)rr%rrrr)N.rrrrrrArrrrrrrrrrNNrrrrrrrr)r4r5r6r^__match_args__propertyrabcabstractmethodrrTrLrsetterrtypingoverloadrrrrrrds<     r) metaclassc @seZdZUdZdZdZededejej BZ ddddd d d d d Z de d<dwdxddZ dyddZdzdd Zd{d"d#Zd|d'd(Zd|d)d*Zed}d+d,Zejd~d.d,Zdd0d1Zdd4d5Zedd6d7Zedd8d9Zdd:d;Zdd=|<|>) \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)~===!=<=>=rmro===r _operatorsNrr%rrrrAcCs|j|s td||}|dr&|dd|dd}}n$|dr;|dd|dd}}n|dd|dd}}||f|_||_d|_d|_d|_ dS)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)rBrroperatorr?rrrrC=s       zSpecifier.__init__r?rcCsD|jdur|jd|kr|jdSt|}|durdS||f|_|S)zDOne element cache, as only one spec Version is needed per Specifier.Nrr )rr)rBr?version_specifierrrr_get_spec_versioncs  zSpecifier._get_spec_versionrcCs||}|dus 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 ===). N)r)rBr? spec_versionrrr_require_spec_versionos  zSpecifier._require_spec_versionrcCs\|jdur|jS|j}|j}|dkrt|_tS|dr#|||}n|||}||_|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. Nr.*)rrr?r{endswith_wildcard_ranges_standard_ranges)rBopver_strrrrr _to_rangesys   zSpecifier._to_rangesrrrcCs\||dd}t|}t|}|dkr t|dt|dfgStt|dft|dtfgS)NrTF)rrrr`rw_NEG_INF_POS_INF)rBrrbaser|r}rrrrs  zSpecifier._wildcard_rangesc Cs||}|dkrt|dtfgS|dkr!ttt|tjdfgS|dkr`|jdur<|j |jddd}t|dtfgS|j durT|j |j dddd}t|dtfgStt|tj d tfgS|d kr~|j ri|n|j ddd}|t krvgStt|d fgSd |v}t|tj}|r|n|}|d krt|dt|dfgS|d krtt|d ft|d tfgS|dkr|j |jddd} t|dtt| d fgStd|)NrTrror rrrFrm+rrrr)r/Unknown operator: )rr`rrrwr<r3r:rGrrFr;rr.r/r ValueError) rBrrrH lower_verr- has_local after_localsr}prefixrrrrsL       zSpecifier._standard_rangescCsX|jdur|jS|j\}}|dkrdS|dkr|drdS||}|dur)dS|jS)NrFrr)rrrrr)rBr version_strr?rrrrs   zSpecifier.prereleasesrNcCs ||_dSr)rrrrrr #tuple[tuple[str, str], bool | None]cC |j|jfSr)rrrSrrr __getstate__ zSpecifier.__getstate__statercCsd|_d|_d|_t|trTt|dkr(|\}}t|r(t|r(||_||_ dSt|dkrTt|dt rT|\}}| d}| dd}t|rTt|rT||_||_ dSt|t rt| d}| dd}t|rtt|rt||_||_ dSt d|)Nr!r rrinvalidzCannot restore Specifier from ) rrrr"r#r$r&r*rrdictget TypeError)rBrrr_ slot_dictrrr __setstate__s4       zSpecifier.__setstate__cC |jdS)z`The operator of this specifier. >>> Specifier("==1.2.3").operator '==' rrrSrrrr$ zSpecifier.operatorcCr)zaThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r r rSrrrr?-r zSpecifier.versioncC8|jdur d|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)> N, prereleases=rrmrV)>rrrXr4r%rBr'rrrrZ6s zSpecifier.__repr__cCs dj|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{}{})formatrrSrrrrHs zSpecifier.__str__tuple[str, str]cCsF|j\}}|dks|dr||fS||}t||dkd}||fS)Nrrrstrip_trailing_zero)rrrr )rBrr?rcanonical_versionrrr_canonical_specRs  zSpecifier._canonical_specrPcC t|jSr)rRrrSrrrrT`s zSpecifier.__hash__rDr)cCsPt|trz |t|}WntytYSwt||js"tS|j|jkS)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%rXrrJrrKrrrrLcs    zSpecifier.__eq__CallableOperatorcCst|d|j|}|S)N _compare_)getattrr)rBroperator_callablerrr _get_operatorszSpecifier._get_operator prospectivecCs@ttttt|dd}|d7}|||o|||S)Nrr) _version_joinlist itertools takewhile_is_not_suffix_version_split_compare_greater_than_equal_compare_equal)rBrrrrrr_compare_compatibles   zSpecifier._compare_compatibletuple[list[str], int]cCs@|j}|durt|dddd}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 r"_numeric_prefix_len)rBrwildcard_split normalized split_specrrr_get_wildcard_splits zSpecifier._get_wildcard_splitc Csr|dr)||\}}tt|dd}t|}t||}|dt|}||kS||} | js5t|}|| kS)NrFr) rr+r rr" _left_padr$rr) rBrrr*spec_numeric_lennormalized_prospectivesplit_prospectivepadded_prospectiveshortened_prospectiverrrrr$s   zSpecifier._compare_equalcCs||| Sr)r$rBrrrrr_compare_not_equalszSpecifier._compare_not_equalcCst|||kSrrrr2rrr_compare_less_than_equalz"Specifier._compare_less_than_equalcCst|||kSrr4r2rrrr#r6z%Specifier._compare_greater_than_equalspec_strcCs6||}||ks dS|js|jr|t|krdSdSry)rrrrBrr7rrrr_compare_less_thans  zSpecifier._compare_less_thancCsP||}||ks dS|js|jrt||krdS|jdur&t||kr&dSdSry)ris_postreleaserrrr8rrr_compare_greater_thans  zSpecifier._compare_greater_than Version | strcCst|t|kSrr%r|r2rrr_compare_arbitraryszSpecifier._compare_arbitraryr str | VersioncC ||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 rrBrrrr __contains__ zSpecifier.__contains__rcCstt|j|g|dS)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)rrrrrrr.szSpecifier.contains.rrrrcCrrrrrrrrIrzSpecifier.filterrrrcCrrrrrrrrQrrrrc csg}d}|dur |n|j}||j}|D]^}t|dur|n||} d} | dur:|jdkr9|||jr9|Vn|jdkrO||durG|n|||j} n|| |j} | rt| durt| jr`|rfd}|Vq|durt|jdurt||q|s|dur|jdur|EdHdSdSdSdS)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) rrrrr>r?rrr) rBrrrprereleases_versionsfound_non_prereleasesinclude_prereleasesrr?parsed_versionmatchrrrrYsF#       rN)rr%rrrrA)r?r%rr)r?r%rrrr)rr%rr%rrrrNrrrA)rrrrrrAr])rrr\r[)rr%rr)rrrr%rr))rr%rr&)rrr7r%rr))rr<rr%rr))rr?rr)r)rrrrrr)rrrrr).r4r5r6r7r^_specifier_regex_strrecompileVERBOSE IGNORECASErr__annotations__rCrrrrrrrrrrrr?rZrrrTrLrr%r+r$r3r5r#r9r;r>rCrrrrrrrrrsz \ &  >    "           $       rz([0-9]+)((?:a|b|c|rc)[0-9]+)rrrrrccsg}g}d}|D]:}t|dur|n||}|dur,|r!|Vn ||||q |js<|s8|EdHd}|Vq |sC||q |sM|EdHdSdS)z?Filter per PEP 440: exclude prereleases unless no finals exist.FNT)rrr)rr all_nonfinalarbitrary_strings found_finalrparsedrrr_pep440_filter_prereleasess0    rYr%cCs^g}|d\}}}||pd|dD]}t|}|r'||q||q|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)r?rrErrestrrJrrrr"s  r" componentscCs|^}}|dd|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. rZr\)join)rcrErbrrrrsrsegmentcstfdddD S)Nc3s|]}|VqdSr)r).0rrerr s  z!_is_not_suffix..)rGabrcrF)anyrgrrgrr!s  r!r^rPcCs(d}|D] }|s |S|d7}q|S)zCount leading numeric components in a :func:`_version_split` result. >>> _numeric_prefix_len(["0", "1", "2", "a1"]) 3 rr )isdigit)r^countrerrrr's r'target_numeric_lencCsBt|}||}|dkr|Sg|d|dg|||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')r^ro numeric_len pad_neededrrrr, s &r,op_entry!tuple[CallableOperator, str, str]cCsp|\}}}|dkr|dsdSdS|dvrdS|dkrdS|dkr+|ds)d Sd S|d kr1dStd |) aLSort key for Cost Based Ordering of specifier operators in _filter_versions. Operators run sequentially on a shrinking candidate set, so operators that reject the most versions should run first to minimize work for later ones. Tier 0: Exact equality (==, ===), likely to narrow candidates to one version Tier 1: Range checks (>=, <=, >, <), 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!)rrrormr rrrrr)rr)rrrverrrrr_operator_costs rvc@s2eZdZdZdZ  dPdQd d ZdRddZedSddZej dTddZdUddZ dVddZ dWddZ dWddZ dXd!d"ZdYd%d&ZdZd(d)ZdXd*d+Zd[d-d.Zd\d0d1Zd]d2d3Zd]d4d5Zd]d6d7Zd^d:d;Z  d_d`d=d>Zej  ?dadbdDdEZej  ?dadcdIdEZ  d_dddMdEZ dedfdNdOZdS)graThis 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_specsrN specifiersstr | Iterable[Specifier]rrrrAcCst|trdd|dD}ttt||_d|v|_nt||_tdd|jD|_t |jdk|_ d|_ ||_ d|_ dS) 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. cSsg|] }|r|qSr)rrfsrrr ksz)SpecifierSet.__init__..,rcs|] }dt|vVqdSrNrr~rrrrhtz(SpecifierSet.__init__..r N)r"r%r^r#maprr{rxrlr$rwrzrry)rBr|rsplit_specifiersrrrrCRs    zSpecifierSet.__init__tuple[Specifier, ...]cCs8|jsttt|jtd|_d|_d|_d|_|jS)zBDeduplicate, sort, and cache specs for order-sensitive operations.rTN) rwr#rfromkeyssortedr{r%rzryrSrrr_canonical_specss zSpecifierSet._canonical_specscCs6|jdur|jS|js dStdd|jDrdSdS)Ncss|]}|jVqdSrrEr~rrrrhsz+SpecifierSet.prereleases..T)rr{rlrSrrrrs zSpecifierSet.prereleasesrNcCs||_d|_dSr)rryrrrrrs )tuple[tuple[Specifier, ...], bool | None]cCrr)r{rrSrrrrrzSpecifierSet.__getstate__rrcCsd|_d|_t|trt|dkr@|\}}t|tr@tdd|Dr@t|r@||_||_t|dk|_ t dd|D|_ dSt|dkrt|dt r|\}}| dd}| d}t|tritt|td }t|trtd d|Drt|r||_||_t|jdk|_ t d d|jD|_ dSt|t r| dd}| d}t|trtt|td }t|trtd d|Drt|r||_||_t|jdk|_ t d d|jD|_ dStd|)Nr!cs|]}t|tVqdSrr"rr~rrrrhz,SpecifierSet.__setstate__..r csrrrr~rrrrhrr{rrrcsrrrr~rrrrhrcsrrrr~rrrrhrcsrrrr~rrrrhrcsrrrr~rrrrhrz!Cannot restore SpecifierSet from )rzryr"r#r$allr*r{rrwrlrxrr frozensetrr%r)rBrspecsrrrrrrrsd         zSpecifierSet.__setstate__r%cCr )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)> Nr rrmrVr rrrrrrZs  zSpecifierSet.__repr__cCsddd|DS)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' rcss|]}t|VqdSrrr~rrrrhsz'SpecifierSet.__str__..)rdrrSrrrrs zSpecifierSet.__str__rPcCs t|Sr)rRrrSrrrrTs zSpecifierSet.__hash__rDSpecifierSet | strcCst|tr t|}nt|tstSt}|j|j|_t|jdk|_|jp(|j|_d|_|j dus8|j |j kr>|j |_ |S|j durI|j |_ |St d)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%rrJr{r$rwrxrzrr)rBrD specifierrrr__and__s$   zSpecifierSet.__and__r)cCs:t|ttfrtt|}nt|tstS||kS)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%rrrJrrKrrrrL&s  zSpecifierSet.__eq__cCr)z7Returns the number of specifiers in this specifier set.)r$r{rSrrr__len__@rzSpecifierSet.__len__Iterator[Specifier]cCr)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')>] )iterr{rSrrr__iter__Ds zSpecifierSet.__iter__rcCsP|j}d}|D]}|dur|}qt||}|snq|dur&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)r{rr RuntimeError)rBrrrrrr _get_rangesNs zSpecifierSet._get_rangescCsX|j}|dur |S|jsd|_dS| }|s|}|s'|jdur'|}||_|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 NF)ryr{r_check_arbitrary_unsatisfiabler_check_prerelease_only_ranges)rBcachedrrrris_unsatisfiableds zSpecifierSet.is_unsatisfiablecCs^|D](\}}t|j}|durdS|jdus||jkr!dS||jkr,|jr,dSqdS)zWith prereleases=False, check if every range contains only pre-release versions (which would be excluded from matching).NFT)rrr?rb)rBr|r}nearestrrrrs z*SpecifierSet._check_prerelease_only_rangescsdd|jD}|s dS|djtfdd|ddDr$d St|dj|jdur9dur9jr9d Sd d|jD}|sEdSdurKd Stfd d|D S) 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. cSsg|] }|jdkr|qSrrr~rrrrz?SpecifierSet._check_arbitrary_unsatisfiable..Frc3s|] }|jkVqdSr)r?r|r~)firstrrrhsz>SpecifierSet._check_arbitrary_unsatisfiable..r NTcSsg|] }|jdkr|qSrrr~rrrrrc3s|]}|VqdSrrAr~) candidaterrrhr)r{r?r|rlrrrr)rBrstandardr)rrrrs$ z+SpecifierSet._check_arbitrary_unsatisfiablerrcCr@)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 rArBrrrrCrDzSpecifierSet.__contains__ installedcCsXt|}|dur|r|jrd}|dus|jrt|ts|}n|}tt|j|g|dS)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 NTrE)rrrxr"rr)rr)rBrrrr? check_itemrrrrs zSpecifierSet.contains.rrrrcCrrrrrrrrrzSpecifierSet.filterrrrcCrrrrrrrrrrrrcs|dur |jdur |j}|jrAt|jdkr(|jdj||dur"dn|d}n|j||dur2dn|d}|dur<|St|S|durIt|S|durWfdd |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'] Nr rT)rrrEFc3s:|]}tdur |n|dusjs|VqdSr)rr)rfrrr?rrrh^sz&SpecifierSet.filter..)rr{r$r_filter_versionsrYr)rBrrrfilteredrrrr s02    c#s|jdurtdd|jDtd|_|j}|du}|D]7tdur%ndur=tfdd|Dr<Vq|rCjrCqtfdd|DrSVqdS)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. Ncss&|]}||j|j|jfVqdSr)rrr?)rfrrrrrh{s  z0SpecifierSet._filter_versions..rFc3s2|]\}}}|dkot|kVqdSrr=)rfrrur)rrrrhs  c3sL|]!\}}}|dkrtdurn|kn||VqdSrr=)rfop_fnrurrrrXrrrhs$ )rzrr{rvrrr)rBrrropsexclude_prereleasesrrrrks4   zSpecifierSet._filter_versionsrK)r|r}rrrrA)rrrrM)rrrNr]r\)rDrrrr[)rrrL)rr))rrrr)r)rrrrrrrr)rrrrr)rrrrrrrr)r4r5r6r7r^rCrrrrrrrZrrTrrLrrrrrrrCrrrrrrrrrr6sR  -     9   !    ! ' -  dr)rr)rrrr )r'rrr()r/r0rr0)r|r`r}rwrr))rrrrrr)r?rrr)r?rrr)rHrcrr)rrrrrr)r?r%rr)rcrrr%)rer%rr))r^rrrP)r^rrorPrr)rrrsrrP)Lr7 __future__rrr8 functoolsrrPsysrrrrrrrr r r utilsr r?rr version_infortyping_extensionsrrr&r*r+r%rr,r)rr.rTr2Enumr3total_orderingr<r`rwrcr# _VersionRangerrr{r~rrrrrrrrrrABCMetarrrQr_rYr"rr!r'r,rvrrrrrs ,         >((           R z  *