a 紫jx@sUdZddlmZddlZddlZddlmZmZmZddl m Z m Z erddl m Z mZmZmZddlmZeeeeeeefeefZeeeed feefZgd Ze d Zd ed <e dZd ed<edZded<GdddejZejGdddZeree edfZ ejGdddZ!ejGdddZ"erNee!e"fZ#e!ddZ$ded<e"ddZ%ded<e$e%ffZ&d ed!<d"d"d#d$d%Z'd&d&d'd(d)Z(d&d&d'd*d+Z)d,d-d'd.d/Z*d&d0d'd1d2Z+d&d0d'd3d4Z,d&d0d'd5d6Z-dd-d7d8d9Z.ddd:d;dd>d?d@dAdBZ0dhd>dDdEdFd>dGdHdIdJZ1d&d&d'dKdLZ2dMd&dNdOdPZ3d>d:dQdRdSZ4dTd&d?dUdVdWZ5dTd&d:d?dXdYdZZ6dTdTd&d?d[d\d]Z7d^d>d_d`daZ8d>d&d:dbdcddZ9dFdFdFdedfdgZ:dS)izBPrivate version-range helpers used by :mod:`packaging.specifiers`.) annotationsN) TYPE_CHECKINGAnyFinal)InvalidVersionVersion)CallableIterableIteratorSequence)Union.) FULL_RANGEbounds_for_speccoerce_versionfilter_by_rangesintersect_rangesintersect_specifier_boundsleast_version_abovematches_bounds_onlyrange_is_emptyranges_are_prerelease_onlyresolve_prereleasesstandard_rangeswildcard_rangesz0.dev0zFinal[Version] MIN_VERSION0 MIN_RELEASEinfz Final[float] _BOUNDARY_INFc@s eZdZdZeZeZdS) BoundaryKindz5Where a boundary marker sits in the version ordering.N)__name__ __module__ __qualname____doc__enumauto AFTER_LOCALS AFTER_POSTSr)r)P/var/www/html/laksyashrimp/venv/lib/python3.9/site-packages/packaging/_ranges.pyr 7sr c@seZdZdZdZddddddZdd d d d Zd dddZdd d ddZdd d ddZ dd d ddZ ddddZ ddddZ dS) BoundaryVersionaA point on the version line between two real PEP 440 versions. Relative to a base version V:: V < V+local < AFTER_LOCALS(V) < V.post0 < AFTER_POSTS(V) AFTER_LOCALS is the upper bound of ``<=V``, ``==V``, ``!=V`` (no local), and the lower bound of the upper-side range of ``!=V``. AFTER_POSTS is the lower bound of ``>V`` (V final or pre-release), excluding V's post-releases per PEP 440. ) _cached_dev _cached_epoch _cached_post _cached_pre_cached_trimmed_releasekindversionrr None)r2r1returncCs<||_||_t|j|_|j|_|j|_|j |_ |j |_ dSN) r2r1 trim_releasereleaser0epochr-prer/postr.devr,)selfr2r1r)r)r*__init__Vs zBoundaryVersion.__init__boolotherr4cCs|j|jkrdS|j}|j}t|}t||kr4dS|d||krHdSt|t|D]}||dkrVdSqV|j|jkr~dS|jt j kr|j |j ko|j |jkS|j |jkp|j duS)z6Is ``other`` a version that this boundary sorts above?FNr)r8r-r7r0lenranger9r/r1r r'r:r.r;r,)r<r@Z other_releaseZtrimmed_releasetrimmed_lengthir)r)r* _is_family_s"     zBoundaryVersion._is_family_BoundaryOrderKeyr4cCsH|jj}|d}|jtjkr4|d|ddtddf}|d|d|tfS)aSort key placing this boundary just above the versions it covers. It extends ``V``'s comparison key ``(epoch, release, suffix)`` with a trailing ``_BOUNDARY_INF`` local component, so the key sorts after ``V`` and every ``V+local`` (whose keys carry a real, finite local segment). ``suffix`` is the 6-int comparison suffix ``(pre_rank, pre_n, post_rank, post_n, dev_rank, dev_n)``. For an AFTER_POSTS boundary the suffix is replaced with one whose post number is ``_BOUNDARY_INF``, so the key also sorts after every ``V.postN``. An AFTER_LOCALS boundary uses ``V``'s suffix unchanged. rr)r2_keyr1r r(r)r<Z version_keysuffixr)r)r* _order_keyxs  zBoundaryVersion._order_keyobjectcCst|tr||kStSr5) isinstancer+rKNotImplementedr<r@r)r)r*__eq__s zBoundaryVersion.__eq__zBoundaryVersion | VersioncCs4t|tr||kS|j|ks(dS|| SNFrMr+rKr2rErOr)r)r*__lt__s   zBoundaryVersion.__lt__cCs2t|tr||kS|j|kr(dS||S)NTrRrOr)r)r*__gt__s   zBoundaryVersion.__gt__intcCs t|Sr5)hashrKr<r)r)r*__hash__szBoundaryVersion.__hash__strcCs |jjd|jd|jjdS)N(z, )) __class__r!r2r1namerWr)r)r*__repr__szBoundaryVersion.__repr__N) r!r"r#r$ __slots__r=rErKrPrSrTrXr^r)r)r)r*r+>s     r+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. )_above inclusiver2_VersionOrBoundaryr>r3r2rbr4cCsh||_||_|durd|_nHt|trN|jtjkr@t|j|_qdt |j|_n|r\|j |_n|j |_dSr5) r2rbrarMr+r1r r(_make_above_after_posts_make_above_after_locals__le__rSr<r2rbr)r)r*r=s   zLowerBound.__init__rLr?cCs&t|tstS|j|jko$|j|jkSr5rMr`rNr2rbrOr)r)r*rPs zLowerBound.__eq__cCsVt|tstS|jdur"|jduS|jdur0dS|j|jkrH|j|jkS|joT|j SrQrirOr)r)r*rSs      zLowerBound.__lt__rUrGcCst|j|jfSr5rVr2rbrWr)r)r*rXszLowerBound.__hash__rYcCs*|jr dnd}d|jjd||jdS)N[rZ< >rbr\r!r2r<Zbracketr)r)r*r^szLowerBound.__repr__N r!r"r#r$r_r=rPrSrXr^r)r)r)r*r`s r`c@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. )_belowrbr2rcr>r3rdcCsd||_||_|durd|_nDt|trJ|jtjkr@t|j|_q`|j |_n|rX|j |_n|j |_dSr5) r2rbrsrMr+r1r r'_make_below_after_locals__ge__rTrhr)r)r*r=s    zUpperBound.__init__rLr?cCs&t|tstS|j|jko$|j|jkSr5rMrrrNr2rbrOr)r)r*rP s zUpperBound.__eq__cCsPt|tstS|jdurdS|jdur*dS|j|jkrB|j|jkS|j oN|jS)NFTrvrOr)r)r*rSs     zUpperBound.__lt__rUrGcCst|j|jfSr5rjrWr)r)r*rXszUpperBound.__hash__rYcCs*|jr dnd}d|jjd|j|dS)N]r[rlrmrnrorpr)r)r*r^!szUpperBound.__repr__Nrqr)r)r)r*rrs rrFzFinal[LowerBound]NEG_INFzFinal[UpperBound]POS_INFzFinal[tuple[Interval]]rztuple[int, ...])r7r4cCsFt|}|dkr*||ddkr*|d8}q|t|kr:|S|d|S)zDStrip trailing zeros from a release tuple for normalized comparison.rrN)rA)r7endr)r)r*r60s r6r)r2r4cCs4g|jdd|jddR}tj|j|ddS)z5Smallest version in the next prefix: 1.2 -> 1.3.dev0.Nrrr8r7r;)r7r from_partsr8)r2r7r)r)r*_next_prefix_dev08s"r~cCstj|j|jddS)z7The .dev0 of a version's base release: 1.2 -> 1.2.dev0.rr|)rr}r8r7r2r)r)r* _base_dev0>srz Version | strzVersion | NonecCs0t|ts,z t|}Wnty*YdS0|Sr5)rMrrrr)r)r*rCs    rzCallable[[Version], bool]csD|j|j|jt|jtdddfdd }|S)aPredicate ``parsed > AFTER_POSTS(V)`` for a lower bound. Per PEP 440, ``>V`` excludes V's post-releases unless V is itself a post-release. AFTER_POSTS sits above V and every V.postN (with or without local), and just below the next release. rr>parsedr4cs||r dS|jkrdS|j}t|kr0dS|dkrDdStt|D]}||dkrRdSqR|jkrxdSdSNFTr)r8r7rArBr9rZparsed_releaserDrC version_epoch version_ge version_preversion_release_trimmedr)r*aboveYs    z&_make_above_after_posts..above)rur8r9r6r7rAr2rr)rr*reLs recsT|j|j|j|j|jt|jtdddfdd }|S)zPredicate ``parsed > AFTER_LOCALS(V)`` for a lower bound. Used by the upper-side range of ``!=V`` (when V has no local segment). AFTER_LOCALS sits above V and every ``V+local`` but just below ``V.post0``. rr>rcs|r dS|jkrdS|j}t|kr0dS|dkrDdStt|D]}||dkrRdSqR|jkrxdS|jkrdS|jkSrr8r7rArBr9r:r;rrCZ version_devrrZ version_postrrr)r*rs"     z'_make_above_after_locals..aboverur8r9r:r;r6r7rArr)rr*rfts  rfcsT|j|j|j|j|jt|jtdddfdd }|S)zPredicate ``parsed <= AFTER_LOCALS(V)`` for an upper bound. Used by ``<=V``, ``==V``, ``!=V`` (no local). ``parsed`` is at or below the boundary when it is at or below V cmpkey-wise, or when it is in V's local family. rr>rcs|r dS|jkrdS|j}t|kr0dS|dkrDdStt|D]}||dkrRdSqR|jkrxdS|jkrdS|jkS)NTFrrrrr)r*belows"     z'_make_below_after_locals..belowr)r2rr)rr*rts  rt)boundaryr4cCs|j}|jtjkrX|jdur0|j|jdddS|jdurD|jdnd}|j|dddS|jdur|j\}}|j||dfddddSdS)zLSmallest real version strictly above *boundary*, or ``None`` if none exists.Nrr;localrr:r;rr9r:r;r)r2r1r r'r; __replace__r:r9)rbase next_postr1numberr)r)r*rs    rr>)lowerupperr4cCs|jdurdS|jdur6|j o4t|jto4|jtkSt|jtrpt|j}|durp|j|krf|j S|j|kS|j|jkr|jo|j S|j|jkS)aTrue when the range defined by *lower* and *upper* contains no versions. A boundary lower sits just below the next real version, so an ordered pair is still empty when the upper excludes that least successor: ``(AFTER_POSTS(1.0a1), 1.0a2.dev0)`` holds no version. NF)r2rbrMrrr+r)rr successorr)r)r*rs"        rzSequence[Interval]zlist[Interval])leftrightr4c 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)rAmaxminrappend) rrresultZ left_indexZ right_indexZ left_lowerZ left_upperZ right_lowerZ right_upperrrr)r)r*rs       rr)z Iterable[Any]z%Callable[[Any], Version | str] | Nonez bool | Nonez Iterator[Any])rangesiterablekey prereleasesregionr4ccs|durg}d}t|dkr|d\}}|j} |j} |D]} t|durL| n|| } | dur`q:| durr| | srq:| dur| | sq:| jsd}| Vq:|rt|| r| Vq:|s:|| q:|s|EdHdS|D]} t|dur| n|| } | durq|D]\}}|j} | dur"| | s"q|j} | dus:| | r| jsNd}| Vn*|rht|| rh| Vn|sx|| qqq|s|EdHdS|du} t|dkr>|d\}}|j} |j} |D]r} t|dur| n|| } | durq| r| jrq| dur| | sq| dus0| | r| VqdS|D]} t|durV| n|| } | durnqB| r| jrqB|D]P\}}|j} | dur| | sqB|j} | dus| | r| VqBqqBdS)aFilter *iterable* against precomputed version *ranges*. With ``prereleases=None``, the PEP 440 default applies: pre-releases are excluded unless no final matches, in which case buffered pre-releases come out at the end. A pre-release inside the opt-in ``region`` is the exception: it is force-admitted in place, as ``prereleases=True`` would yield it. A force-admitted pre-release is not a final, so it never suppresses the buffer. NFrrT)rArarsr is_prereleaserr)rrrrrZprerelease_bufferZ found_finalrrrritemrZexclude_prereleasesr)r)r*rs             rcCs*|jdur|jdddddS|jdddS)z=Smallest non-pre-release at or above a pre-release *version*.Nrr)r9rrr)r)r*!_nearest_release_above_prereleasews rz Version | BoundaryVersion | None)valuer4cCsb|dur tSt|trP|j}|jr*t|S|jdur>|jdnd}|j|ddS|jsZ|St|S)zSmallest non-pre-release version at or above *value*. ``None`` is the ``-inf`` floor, whose nearest non-pre-release is :data:`MIN_RELEASE`. Nrr)r:r)rrMr+r2rrr:r)rZ inner_versionrr)r)r*_lowest_release_at_or_aboves r)rr4cCsL|D]B\}}t|j}|jdus*||jkr0dS||jkr|jrdSqdS)zTrue when every range in *ranges* contains only pre-releases. Used to detect unsatisfiable specifier sets when ``prereleases=False``: if every range is pre-release-only, every contained version is excluded. NFT)rr2rb)rrrZnearestr)r)r*rs  rrY)oprr4cCsJt|}t|}|dkr.t|dt|dfgStt|dft|dtfgS)z^Ranges for ==V.* and !=V.*. ==1.2.* -> [1.2.dev0, 1.3.dev0); !=1.2.* -> complement. ==TF)rr~r`rrrxry)rrrrr)r)r*rs  r)rr2 has_localr4cCs|dkrt|dtfgS|dkr8ttt|tjdfgS|dkr|jdurn|j|jddd}t|dtfgS|j dur|j|j dddd }t|dtfgStt|tj d tfgS|d kr|j r|n |jddd}|t krgStt|d fgSt|tj}|r|n|}|d kr,t|dt|dfgS|d krRtt|d ft|d tfgS|dkr|j|j ddd}t|dtt|d fgStd|dS)zRanges for the standard PEP 440 operators (no wildcard, no ===). *has_local* indicates whether the spec string included a ``+local`` segment; relevant only for ``==`` / ``!=`` to decide whether the upper bound includes V's local family. z>=Tz<=rnNrrrrFrlrz!=z~=r{)r7zUnknown operator: )r`ryrxrrr+r r'r;rr:r(rrr7r~ ValueError)rr2r lower_boundboundZ after_localsrprefixr)r)r*rsJ        r)r version_strr2r4cCs$|drt||St||d|vS)aDRanges for one specifier's ``(op, version_str)``. Dispatches between the wildcard and standard builders. ``version`` is the parsed ``version_str`` (its base, without the trailing ``.*``, for wildcards). ``===`` is not handled here; its match is a literal string compared in :mod:`packaging.specifiers`. z.*+)endswithrr)rrr2r)r)r*rs  rzIterable[Sequence[Interval]])per_specifier_rangesr4cCsBd}|D]$}|dur|}qt||}|sq.q|dur>td|S)zIntersect each specifier's ranges into a single sequence. Short-circuits once the running intersection is empty, since no later specifier can revive it. Callers must pass at least one specifier. Nz4intersect_specifier_bounds called with no specifiers)r RuntimeError)rrsubr)r)r*r s r)rr2r4cCsJ|D]@\}}|j}|dur(||s(dS|j}|dus>||rdSqdS)a$Whether ``version`` falls within any of ``ranges``. The pure bounds membership test, for a single already-parsed version with no pre-release policy applied. ``ranges`` are sorted and non-overlapping, so a version below one range's lower bound is below every later range too. NFT)rars)rr2rrrrr)r)r*r#s r) configured autodetectedr4cCs|dur |S|rdSdS)zResolve a specifier's effective default pre-release policy. An explicit ``configured`` value wins; otherwise an autodetected ``True`` propagates and anything else falls back to the PEP 440 default (``None``). NTr))rrr)r)r*r6s r)r));r$ __future__rr% functoolstypingrrrr2rrcollections.abcr r r r r tuplerUfloatZ_BoundaryOrderSuffixrF__all__r__annotations__rrEnumr total_orderingr+rcr`rrZIntervalrxryrr6r~rrrerfrtrrrrrrrrrrrrrr)r)r)r*sb  o8:  ('' f E