U +5iZ@s4UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z m Z m Z mZmZmZmZmZddlmZddlmZmZejdkrdd l mZne rdd lmZd d d d gZddddZdddddZdddddZedZeee fZ!ede!dZ"e ee ge#fZ$edZ%de&d <d!d!d"d#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/<d*d,d0d1d2d3Z4d4d4d5d6d7d8Z5d9d9d:d;d<Z6d9d9d:d=d>Z7d?d@d:dAdBZ8d9d9d:dCdDZ9d9d9d:dEdFZ:d9d9d:dGdHZ;dId@dJdKdLZGdNd d ej?dOZ@GdPd d e@ZAeBdQZCdRdSdTdUdVdWZDdXdd:dYdZZEddXd[d\d]ZFdXd0d^d_d`ZGddadbdcddZHddaddedfdgZIdhdadidjdkZJGdld d e@ZKdS)mz .. testsetup:: from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from packaging.version import Version ) annotationsN) TYPE_CHECKINGAnyCallableFinalIterableIteratorSequenceTypeVarUnion)canonicalize_version)InvalidVersionVersion) ) TypeGuard BaseSpecifierInvalidSpecifier Specifier SpecifierSetz list[str]returncCstSN)__all__rr8/tmp/pip-unpacked-wheel-xj899fla/packaging/specifiers.py__dir__0srobjectzTypeGuard[tuple[str, str]]specrcCs2t|to0t|dko0t|dto0t|dtS)Nrr ) isinstancetuplelenstr)r rrr_validate_spec4s    r&zTypeGuard[bool | None])prercCs|dkpt|tSr)r"bool)r'rrr _validate_pre=sr)TUnparsedVersionVar)boundz0.dev0zFinal[Version] _MIN_VERSIONztuple[int, ...])releasercCsFt|}|dkr*||ddkr*|d8}q|t|kr:|S|d|S)zDStrip trailing zeros from a release tuple for normalized comparison.r rN)r$)r.endrrr _trim_releaseJs r0c@s eZdZdZeZeZdS) _BoundaryKindz5Where a boundary marker sits in the version ordering.N)__name__ __module__ __qualname____doc__enumauto AFTER_LOCALS AFTER_POSTSrrrrr1Rsr1c@sreZdZdZdZddddddZdd d d d Zd d d ddZdd d ddZddddZ ddddZ 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_releaseversionrr1None)r=kindrcCs||_||_t|j|_dSr)r=r;r0r.r<)selfr=r?rrr__init__qsz_BoundaryVersion.__init__r(otherrcCsl|j}|j|jkr.t|j|jkr.|j|jks2dS|jtjkrV|j |j koT|j |j kS|j |j kpj|j dk S)z6Is ``other`` a version that this boundary sorts above?FN) r=epochr0r.r<r'r;r1r8postdev)r@rCvrrr _is_familyvs   z_BoundaryVersion._is_familyrcCs&t|tr"|j|jko |j|jkStSr)r"r:r=r;NotImplementedr@rCrrr__eq__s z_BoundaryVersion.__eq__z_BoundaryVersion | VersioncCsHt|tr2|j|jkr"|j|jkS|jj|jjkS|| oF|j|kSr)r"r:r=r;valuerHrJrrr__lt__s    z_BoundaryVersion.__lt__intrcCst|j|jfSr)hashr=r;r@rrr__hash__sz_BoundaryVersion.__hash__r%cCs |jjd|jd|jjdS)N(z, )) __class__r2r=r;namerPrrr__repr__sz_BoundaryVersion.__repr__N) r2r3r4r5 __slots__rArHrKrMrQrVrrrrr:Ysr:c@sbeZdZdZdZddddddZd dd d d Zddd d dZddddZddddZ 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=_VersionOrBoundaryr(r>r=rZrcCs||_||_dSrr=rZr@r=rZrrrrAsz_LowerBound.__init__rrBcCs&t|tstS|j|jko$|j|jkSrr"rXrIr=rZrJrrrrKs z_LowerBound.__eq__cCsVt|tstS|jdkr"|jdk S|jdkr0dS|j|jkrH|j|jkS|joT|j S)NFr_rJrrrrMs      z_LowerBound.__lt__rNrcCst|j|jfSrrOr=rZrPrrrrQsz_LowerBound.__hash__r%cCs*|jr dnd}d|jjd||jdS)N[rR< >rZrTr2r=r@ZbracketrrrrVsz_LowerBound.__repr__N r2r3r4r5rWrArKrMrQrVrrrrrXs rXc@sbeZdZdZdZddddddZd dd d d Zddd d dZddddZddddZ dS) _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. rYr[r(r>r\cCs||_||_dSrr]r^rrrrAsz_UpperBound.__init__rrBcCs&t|tstS|j|jko$|j|jkSrr"rhrIr=rZrJrrrrKs z_UpperBound.__eq__cCsPt|tstS|jdkrdS|jdkr*dS|j|jkrB|j|jkS|j oN|jSNFTrirJrrrrMs     z_UpperBound.__lt__rNrcCst|j|jfSrr`rPrrrrQsz_UpperBound.__hash__r%cCs*|jr dnd}d|jjd|j|dS)N]rSrbrcrdrerfrrrrVsz_UpperBound.__repr__Nrgrrrrrhs rhFztuple[_VersionRange] _FULL_RANGEr()lowerupperrcCs>|jdks|jdkrdS|j|jkr2|jo.|j S|j|jkS)zHTrue when the range defined by *lower* and *upper* contains no versions.NFr])rmrnrrr_range_is_emptys  roSequence[_VersionRange]list[_VersionRange])leftrightrc Csg}d}}|t|kr|t|kr||\}}||\}}t||} t||} t| | sh|| | f||krz|d7}q |d7}q |S)zFIntersect two sorted, non-overlapping range lists (two-pointer merge).rr )r$maxminroappend) rrrsresultZ left_indexZ right_indexZ left_lowerZ left_upperZ right_lowerZ right_upperrmrnrrr_intersect_rangess       rxrr=rcCs0|jdd|jddf}tj|j|ddS)z5Smallest version in the next prefix: 1.2 -> 1.3.dev0.Nr rrDr.rF)r.r from_partsrD)r=r.rrr_next_prefix_dev0sr}cCstj|j|jddS)z7The .dev0 of a version's base release: 1.2 -> 1.2.dev0.rr{)rr|rDr.r=rrr _base_dev0srUnparsedVersionVersion | NonecCs2t|ts.z t|}Wntk r,YdSX|Sr)r"rrr~rrr_coerce_version$s   rcCs|jdkr|S|jddS)N)local)r __replace__r~rrr_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. NrErFrrr~rrr _post_base3srcCs|jdddS)zZEarliest pre-release of *version*. 1.2 -> 1.2.dev0, 1.2.post1 -> 1.2.post1.dev0. rNrFrrr~rrr_earliest_prerelease;srr[)rGrcCsr|dkr dSt|trX|j}|jr2|jddddS|jdk rF|jdnd}|j|ddS|jsb|S|jddddS)z:Smallest non-pre-release version at or above *v*, or None.N)r'rFrr r)rEr)r"r:r= is_prereleaserrE)rGinnerkrrr_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)r2r3r4r5rrrrrXsc@seZdZdZdZeddddZejddddZ ejd dd d Z ejd d dddZ eejddddZ e j d ddddZ ejd)ddd dddZejd*ddddddd Zejd+d!dd"d#dd$d Zejd,d%dd&d'dd(d ZdS)-rr)_strr%rcCst|S)z Internal property for match_argsr%rPrrrrhszBaseSpecifier._strcCsdS)z Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. NrrPrrr__str__mszBaseSpecifier.__str__rNcCsdS)zF Returns a hash value for this Specifier-like object. NrrPrrrrQtszBaseSpecifier.__hash__rr(rBcCsdS)z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. NrrJrrrrKzszBaseSpecifier.__eq__ bool | NonecCsdS)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. NrrPrrr prereleasesszBaseSpecifier.prereleasesr>rLrcCsdS)zQSetter for :attr:`prereleases`. :param value: The value to set. Nrr@rLrrrrsNitemrrcCsdS)zR Determines if the given item is contained within this specifier. Nrr@rrrrrcontainsszBaseSpecifier.contains.Iterable[UnparsedVersionVar]Iterator[UnparsedVersionVar]iterablerkeyrcCsdSrrr@rrrrrrfilterszBaseSpecifier.filter Iterable[T]Callable[[T], UnparsedVersion] Iterator[T]cCsdSrrrrrrrs Iterable[Any]'Callable[[Any], UnparsedVersion] | None Iterator[Any]cCsdS)z Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nrrrrrrs)N)N.)N.)NN)r2r3r4rWZ__match_args__propertyrabcabstractmethodrrQrKrsetterrtypingoverloadrrrrrrds:) metaclassc @seZdZUdZdZdZededejej BZ ddddd d d d d Z de d<dwddddddZ dddddZdddddZdd d!d"Zddd#d$d%d&Zddd#d$d'd(Zedd d)d*Zejddd+d,d*Zd-d d.d/Zd0dd1d2d3Zedd d4d5Zedd d6d7Zdd d8d9Zdd d:d;ZedZd?d d@dAZd0dBdCdDdEZddFdGdHdIZdddBdJdKdLZ ddMdNdOdPZ!dddBdJdQdRZ"dddBdJdSdTZ#dddBdJdUdVZ$dddBdJdWdXZ%dddBdYdZd[Z&dddBdYd\d]Z'd^ddBdJd_d`Z(dadBdbdcddZ)dxdeddBdfdgdhZ*e+j,dydjdddkdldmdnZ-e+j,dzdoddpdqdldrdnZ-d{dsddtdudldvdnZ-dS)|raThis class abstracts handling of version specifiers. .. tip:: It is generally not required to instantiate this manually. You should instead prefer to work with :class:`SpecifierSet` instead, which can parse comma-separated version specifiers (which is what package metadata contains). Instances are safe to serialize with :mod:`pickle`. They use a stable format so the same pickle can be loaded in future packaging releases. .. versionchanged:: 26.2 Added a stable pickle format. Pickles created with packaging 26.2+ can be unpickled with future releases. Backward compatibility with pickles from packaging < 26.2 is supported but may be removed in a future release. ) _prereleases_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)~===!=<=>=rbrd===r _operatorsNr%rr>)r rrcCs|j|std||}|drL|dd|dd}}nH|drv|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)r@r roperatorr=rrrrA=s      zSpecifier.__init__rrycCsD|jdk r"|jd|kr"|jdSt|}|dkr6dS||f|_|S)zDOne element cache, as only one spec Version is needed per Specifier.Nrr )rr)r@r=Zversion_specifierrrr_get_spec_versioncs  zSpecifier._get_spec_versionrcCs||}|dk st|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)rAssertionError)r@r= spec_versionrrr_require_spec_versionos  zSpecifier._require_spec_versionrprcCs\|jdk r|jS|j}|j}|dkr.t|_tS|drF|||}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=rlendswith_wildcard_ranges_standard_ranges)r@opver_strrwrrr _to_rangesys   zSpecifier._to_rangesrq)rrrcCs\||dd}t|}t|}|dkr@t|dt|dfgStt|dft|dtfgS)NrTF)rrr}rXrh_NEG_INF_POS_INF)r@rrbasermrnrrrrs  zSpecifier._wildcard_rangesc Cs||}|dkr"t|dtfgS|dkrBttt|tjdfgS|dkr|jdk rx|j |jddd}t|dtfgS|j dk r|j |j dddd}t|dtfgStt|tj d tfgS|d kr|j r|n |j ddd}|t krgStt|d fgSd |k}t|tj}|r|n|}|d kr>t|dt|dfgS|d krdtt|d ft|d tfgS|dkr|j |jddd} t|dtt| d fgStd|dS)NrTrrdr rrrFrb+rrrrz)r.Unknown operator: )rrXrrrhr:r1r8rFrrEr9rr-r.r} ValueError) r@rrrGZ lower_verr,Z has_localZ after_localsrnprefixrrrrsL         zSpecifier._standard_rangescCsX|jdk r|jS|j\}}|dkr&dS|dkr<|dr>> Specifier("==1.2.3").operator '==' rrrPrrrr$szSpecifier.operatorcCs |jdS)zaThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rrPrrrr=-szSpecifier.versioncCs8|jdk rd|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=rrbrR)>rrrTr2r%r@r'rrrrV6s 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{}{})formatrrPrrrrHszSpecifier.__str__ztuple[str, str]cCsF|j\}}|dks|dr$||fS||}t||dkd}||fS)NrrrZstrip_trailing_zero)rrrr )r@rr=rZcanonical_versionrrr_canonical_specRs  zSpecifier._canonical_specrNcCs t|jSr)rOrrPrrrrQ`szSpecifier.__hash__r(rBcCsTt|tr8z|t|}WqHtk r4tYSXnt||jsHtS|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%rTrrIrrJrrrrKcs   zSpecifier.__eq__CallableOperator)rrcCst|d|j|}|S)NZ _compare_)getattrr)r@roperator_callablerrr _get_operators zSpecifier._get_operator) prospectiver rcCs@ttttt|dd}|d7}|||o>|||S)Nrzr) _version_joinlist itertools takewhile_is_not_suffix_version_split_compare_greater_than_equal_compare_equal)r@rr rrrr_compare_compatibles   zSpecifier._compare_compatibleztuple[list[str], int]rcCs@|j}|dkr>> 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)r@r Zwildcard_split normalized split_specrrr_get_wildcard_splits zSpecifier._get_wildcard_splitc Csv|drR||\}}tt|dd}t|}t||}|dt|}||kS||} | jsjt|}|| kSdS)NrFr) rrr rr _left_padr$rr) r@rr rZspec_numeric_lenZnormalized_prospectivesplit_prospectivepadded_prospectiveshortened_prospectiverrrrrs   zSpecifier._compare_equalcCs||| Sr)rr@rr rrr_compare_not_equalszSpecifier._compare_not_equalcCst|||kSrrrrrrr_compare_less_than_equalsz"Specifier._compare_less_than_equalcCst|||kSrrrrrrrsz%Specifier._compare_greater_than_equal)rspec_strrcCs6||}||ksdS|js2|jr2|t|kr2dSdSrj)rrrr@rrr rrr_compare_less_thans  zSpecifier._compare_less_thancCsP||}||ksdS|js2|jr2t||kr2dS|jdk rLt||krLdSdSrj)ris_postreleaserrrr rrr_compare_greater_thans  zSpecifier._compare_greater_thanz Version | strcCst|t|kSrr%rmrrrr_compare_arbitraryszSpecifier._compare_arbitraryz str | VersionrrcCs ||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 rr@rrrr __contains__szSpecifier.__contains__rrcCstt|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.rrrcCsdSrrrrrrrIszSpecifier.filterrrrcCsdSrrrrrrrQsrrrc csg}d}|dk r|n|j}||j}|D]}t|dkr<|n||} d} | dkrr|jdkr|||jr|Vn6|jdkr||dkr|n|||j} n || |j} | r*| dk r*| jr|rd}|Vq*|dkr*|jdk r*||q*|s|dkr|jdk r|EdHdS)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) rrrrrr=rrrv) r@rrrZprereleases_versionsZfound_non_prereleasesZinclude_prereleasesrr=parsed_versionmatchrrrrYsB#      )rN)N)N.)N.)NN).r2r3r4r5rWZ_specifier_regex_strrecompileVERBOSE IGNORECASErr__annotations__rArrrrrrrrrrrr=rVrrrQrKrrrrrrrr r rrrrrrrrrrrsz \  &   >"  $  z([0-9]+)((?:a|b|c|rc)[0-9]+)rrr)rrrccsg}g}d}|D]t}t|dkr"|n||}|dkrV|r@|Vq||||q|jsv|sn|EdHd}|Vq|s||q|s|EdHdS)z?Filter per PEP 440: exclude prereleases unless no finals exist.FNT)rrvr)rrZ all_nonfinalZarbitrary_stringsZ found_finalrparsedrrr_pep440_filter_prereleasess*    rr%cCs^g}|d\}}}||pd|dD],}t|}|rN||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.) rpartitionrvsplit _prefix_regexrextendgroups)r=rwrDrrestrrrrrrs  r) componentsrcCs|^}}|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. rr)join)r&rDr%rrrrsr)segmentrcstfdddD S)Nc3s|]}|VqdSr)r).0rr(rr sz!_is_not_suffix..)rFabrcrE)anyr*rr*rrs rrN)r!rcCs&d}|D]}|sq"|d7}q|S)zCount leading numeric components in a :func:`_version_split` result. >>> _numeric_prefix_len(["0", "1", "2", "a1"]) 3 rr )isdigit)r!countr(rrrrs  r)r!target_numeric_lenrcCs<t|}||}|dkr|S|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!r2Z numeric_lenZ pad_neededrrrr s rz!tuple[CallableOperator, str, str])op_entryrcCst|\}}}|dkr$|ds dSdS|dkr0dS|dkr=, <=, >, <), 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!)rrrdrbr rrrrrN)rr)r3rverrrrr_operator_costs r6c@seZdZdZdZdOddddd d Zd d d dZedd ddZej dddddZdd ddZ dddddZ dd ddZ dd ddZ dd d d!Zd"dd#d$d%Zdd&d#d'd(Zdd d)d*Zd+d d,d-Zd.d d/d0Zd&d d1d2Zd&d d3d4Zd&d d5d6Zd7d&d8d9d:ZdPd7ddd&d;d=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_specsrNzstr | Iterable[Specifier]rr>) specifiersrrcCst|tr:dd|dD}ttt||_d|k|_n t||_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)rr)srrr ksz)SpecifierSet.__init__..,rcss|]}dt|kVqdSrNrr=rrrr+tsz(SpecifierSet.__init__..r N)r"r%r!r#maprr;r8r/r$r7r:rr9)r@r<rsplit_specifiersrrrrARs   zSpecifierSet.__init__ztuple[Specifier, ...]rcCs8|js2ttt|jtd|_d|_d|_d|_|jS)zBDeduplicate, sort, and cache specs for order-sensitive operations.rTN) r7r#rfromkeyssortedr;r%r:r9rPrrr_canonical_specss zSpecifierSet._canonical_specscCs6|jdk r|jS|jsdStdd|jDr2dSdS)Ncss|] }|jVqdSrrr=rrrr+sz+SpecifierSet.prereleases..T)rr;r/rPrrrrs zSpecifierSet.prereleasesrcCs||_d|_dSr)rr9rrrrrsz)tuple[tuple[Specifier, ...], bool | None]cCs |j|jfSr)r;rrPrrrrszSpecifierSet.__getstate__rrcCsd|_d|_t|tr8t|dkr|\}}t|trtdd|Drt|r||_||_t|dk|_ t dd|D|_ dSt|dkr8t|dt r8|\}}| dd}| d}t|trtt|td }t|tr8td d|Dr8t|r8||_||_t|jdk|_ t d d|jD|_ dSt|t r| dd}| d}t|trvtt|td }t|trtd d|Drt|r||_||_t|jdk|_ t d d|jD|_ dStd|dS)Nr!css|]}t|tVqdSrr"rr=rrrr+sz,SpecifierSet.__setstate__..r css|]}dt|kVqdSrArr=rrrr+sr;rrrDcss|]}t|tVqdSrrHr=rrrr+scss|]}dt|kVqdSrArr=rrrr+scss|]}t|tVqdSrrHr=rrrr+scss|]}dt|kVqdSrArr=rrrr+sz!Cannot restore SpecifierSet from )r:r9r"r#r$allr)r;rr7r/r8rr frozensetrFr%r)r@rspecsrrrrrrrsd         zSpecifierSet.__setstate__r%cCs8|jdk rd|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)> NrrrbrRrrrrrrrVs 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' r@css|]}t|VqdSrrr=rrrr+sz'SpecifierSet.__str__..)r'rGrPrrrrs zSpecifierSet.__str__rNcCs t|Sr)rOrGrPrrrrQszSpecifierSet.__hash__zSpecifierSet | strrBcCst|trt|}nt|ts"tSt}|j|j|_t|jdk|_|jpP|j|_d|_|j dksp|j |j krz|j |_ n|j dkr|j |_ nt d|S)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%rrIr;r$r7r8r:rr)r@rC specifierrrr__and__s"      zSpecifierSet.__and__r(cCs:t|ttfrtt|}nt|ts*tS||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%rrrIrGrJrrrrK&s  zSpecifierSet.__eq__cCs t|jS)z7Returns the number of specifiers in this specifier set.)r$r;rPrrr__len__@szSpecifierSet.__len__zIterator[Specifier]cCs 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')>] )iterr;rPrrr__iter__DszSpecifierSet.__iter__rpcCsP|j}d}|D],}|dkr$|}qt||}|sqrrr _get_rangesNs zSpecifierSet._get_rangescCsX|j}|dk r|S|js"d|_dS| }|s8|}|sN|jdkrN|}||_|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)r9r;rR_check_arbitrary_unsatisfiabler_check_prerelease_only_ranges)r@cachedrwrrris_unsatisfiableds zSpecifierSet.is_unsatisfiablecCs^|D]P\}}t|j}|dkr(dS|jdks<||jkrBdS||jkr|jrdSqdS)zWith prereleases=False, check if every range contains only pre-release versions (which would be excluded from matching).NFT)rRrr=rZ)r@rmrnZnearestrrrrTs z*SpecifierSet._check_prerelease_only_rangescsdd|jD}|sdS|djtfdd|ddDrHd St|dj|jdkrrdk rrjrrd Sd d|jD}|sdSdkrd 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=rrrr?s z?SpecifierSet._check_arbitrary_unsatisfiable..Frc3s|]}|jkVqdSr)r=rmr=)firstrrr+sz>SpecifierSet._check_arbitrary_unsatisfiable..r NTcSsg|]}|jdkr|qSrWrXr=rrrr?s c3s|]}|VqdSrrr=) candidaterrr+s)r;r=rmr/rrrrI)r@rstandardr)rZrYrrSs(z+SpecifierSet._check_arbitrary_unsatisfiablerrcCs ||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 rrrrrrszSpecifierSet.__contains__)rr installedrcCsXt|}|dk r|r|jrd}|dks6|jr>> 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 NTr)rrr8r"rr(rr)r@rrr\r=Z check_itemrrrrs zSpecifierSet.contains.rrrcCsdSrrrrrrrszSpecifierSet.filterrrrcCsdSrrrrrrrsrrrcs|dkr|jdk r|j}|jrt|jdkrP|jdj||dkrDdn|d}n|j||dkrddn|d}|dk rx|St|S|dkrt|S|dkrfdd |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)rrrFc3s8|]0}tdkr|n|dks,js|VqdSr)rr)r)rrr=rrr+^s z&SpecifierSet.filter..)rr;r$r_filter_versionsrrO)r@rrrfilteredrr]rr s02    )rrrrc#s|jdkr$tdd|jDtd|_|j}|dk}|D]ntdkrHndkrxtfdd|DrVq6|rjrq6tfdd|Dr6Vq6dS)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=)r)r rrrr+{sz0SpecifierSet._filter_versions..rDFc3s0|](\}}}|dko&t|kVqdSrAr )r)rr5r)rrrr+sc3sJ|]B\}}}|dkr8tdkr"n|kn||VqdSrAr )r)Zop_fnr5rrrrrrr+s&)r:rFr;r6rrIr)r@rrropsZexclude_prereleasesrr`rr^ks,   zSpecifierSet._filter_versions)rN)NN)N.)N.)NN)N)r2r3r4r5rWrArGrrrrrrVrrQrMrKrNrPrRrVrTrSrrrrrr^rrrrr6sP - 9 ! ! '- d)Lr5 __future__rrr6 functoolsrrsysrrrrrrrr r r utilsr r=rr version_inforZtyping_extensionsrrr&r)r*r%rr+r(rr-rr0Enumr1total_orderingr:rXrhr[r#Z _VersionRangerrrlrorxr}rrrrrrrrABCMetarrrr"rrrrrrr6rrrrrs ,      >((      Rz *