o gjx@sPUdZddlmZddlZddlZddlmZmZmZddl m Z m Z erQddl m Z mZmZmZddlmZeeeeeeefeefZeeeed feefZgd Ze d Zd ed <e dZd ed<edZded<GdddejZejGdddZeree edfZ ejGdddZ!ejGdddZ"eree!e"fZ#e!ddZ$ded<e"ddZ%ded<e$e%ffZ&d ed!<dod%d&Z'dpd)d*Z(dpd+d,Z)dqd/d0Z*drd2d3Z+drd4d5Z,drd6d7Z-dsd9d:Z.dtd>d?Z/dudDdEZ0 FdvdwdPdQZ1dpdRdSZ2dxdVdWZ3dydXdYZ4dzd]d^Z5d{d`daZ6d|dcddZ7d}dgdhZ8d~didjZ9ddmdnZ:dS)zBPrivate 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)Q/var/www/html/laksyashrimp/venv/lib/python3.10/site-packages/packaging/_ranges.pyr 7s r c@sdeZdZdZdZd!d d Zd"d dZd#ddZd$ddZd%ddZ d%ddZ d&ddZ d'ddZ d S)(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_releasekindversionr2rr1r returnNonecCs<||_||_t|j|_|j|_|j|_|j |_ |j |_ dSN) r2r1 trim_releasereleaser0epochr-prer/postr.devr,)selfr2r1r)r)r*__init__Vs  zBoundaryVersion.__init__otherboolcCs|j|jkrdS|j}|j}t|}t||krdS|d||kr$dSt|t|D] }||dkr6dSq+|j|jkr?dS|jt j krQ|j |j koP|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> other_releasetrimmed_releasetrimmed_lengthir)r)r* _is_family_s$     zBoundaryVersion._is_family_BoundaryOrderKeycCsH|jj}|d}|jtjkr|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< version_keysuffixr)r)r* _order_keyxs   zBoundaryVersion._order_keyobjectcCst|tr ||kStSr5) isinstancer+rLNotImplementedr<r>r)r)r*__eq__s zBoundaryVersion.__eq__BoundaryVersion | VersioncCs4t|tr ||kS|j|ksdS|| SNFrNr+rLr2rFrPr)r)r*__lt__s   zBoundaryVersion.__lt__cCs2t|tr ||kS|j|krdS||S)NTrTrPr)r)r*__gt__s   zBoundaryVersion.__gt__intcCs t|Sr5)hashrLr<r)r)r*__hash__s zBoundaryVersion.__hash__strcCs |jjd|jd|jjdS)N(z, )) __class__r!r2r1namerYr)r)r*__repr__s zBoundaryVersion.__repr__N)r2rr1r r3r4)r>rr3r?)r3rGr>rMr3r?)r>rRr3r?r3rWr3r[) r!r"r#r$ __slots__r=rFrLrQrUrVrZr`r)r)r)r*r+>s    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. )_above inclusiver2r2_VersionOrBoundaryrhr?r3r4cCsp||_||_|durd|_dSt|tr*|jtjkr"t|j|_dSt |j|_dS|r2|j |_dS|j |_dSr5) r2rhrgrNr+r1r r(_make_above_after_posts_make_above_after_locals__le__rUr<r2rhr)r)r*r=s     zLowerBound.__init__r>rMcC&t|tstS|j|jko|j|jkSr5rNrfrOr2rhrPr)r)r*rQ zLowerBound.__eq__cCsVt|tstS|jdur|jduS|jdurdS|j|jkr$|j|jkS|jo*|j SrSrorPr)r)r*rUs      zLowerBound.__lt__rWcCt|j|jfSr5rXr2rhrYr)r)r*rZzLowerBound.__hash__r[cCs*|jrdnd}d|jjd||jdS)N[r\< >rhr^r!r2r<bracketr)r)r*r`zLowerBound.__repr__Nr2rirhr?r3r4ra)r>rfr3r?rbrc r!r"r#r$rdr=rQrUrZr`r)r)r)r*rfs    rfc@re) 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. )_belowrhr2r2rirhr?r3r4cCsl||_||_|durd|_dSt|tr(|jtjkr"t|j|_dS|j |_dS|r0|j |_dS|j |_dSr5) r2rhrrNr+r1r r'_make_below_after_locals__ge__rVrmr)r)r*r=s      zUpperBound.__init__r>rMcCrnr5rNr~rOr2rhrPr)r)r*rQ rpzUpperBound.__eq__cCsPt|tstS|jdurdS|jdurdS|j|jkr!|j|jkS|j o'|jS)NFTrrPr)r)r*rUs     zUpperBound.__lt__rWcCrqr5rrrYr)r)r*rZrszUpperBound.__hash__r[cCs*|jrdnd}d|jjd|j|dS)N]r]rurvrwrxryr)r)r*r`!r{zUpperBound.__repr__Nr|ra)r>r~r3r?rbrcr}r)r)r)r*r~s    r~FzFinal[LowerBound]NEG_INFzFinal[UpperBound]POS_INFzFinal[tuple[Interval]]rr7tuple[int, ...]r3cCs\t|}|dkr ||ddkr |d8}|dkr ||ddks|t|kr(|S|d|S)zDStrip trailing zeros from a release tuple for normalized comparison.rrN)r@)r7endr)r)r*r60s r6r2rcCs4g|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"rcCstj|j|jddS)z7The .dev0 of a version's base release: 1.2 -> 1.2.dev0.rr)rrr8r7r2r)r)r* _base_dev0>sr Version | strVersion | NonecCs2t|tszt|}W|StyYdSw|Sr5)rNrrrr)r)r*rCs   rCallable[[Version], bool]cs>|j|j|jt|jtdfdd }|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. parsedrr3r?cs||rdS|jkr dS|j}t|krdS|dkr"dStt|D] }||dkr4dSq)|jkr.aboveNrrr3r?)rr8r9r6r7r@r2rr)rr*rjLs rjcN|j|j|j|j|jt|jtdfdd }|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``. rrr3r?cs|rdS|jkr dS|j}t|krdS|dkr"dStt|D] }||dkr4dSq)|jkr.aboveNrrr8r9r:r;r6r7r@rr)rr*rkt rkcr) 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. rrr3r?cs|rdS|jkr dS|j}t|krdS|dkr"dStt|D] }||dkr4dSq)|jkr.belowNrr)r2rr)rr*rrrboundarycCs|j}|jtjkr,|jdur|j|jdddS|jdur"|jdnd}|j|dddS|jdurC|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    rlowerupperr?cCs|jdurdS|jdur|j ot|jto|jtkSt|jtr8t|j}|dur8|j|kr3|j S|j|kS|j|jkrE|joC|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)r2rhrNrrr+r)rr successorr)r)r*rs"         rleftSequence[Interval]rightlist[Interval]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@maxminrappend) rrresult left_index right_index left_lower left_upper right_lower right_upperrrr)r)r*rs      rr)rangesiterable Iterable[Any]key%Callable[[Any], Version | str] | None prereleases bool | Noneregion Iterator[Any]ccs|durg}d}t|dkrg|d\}}|j} |j} |D]@} t|dur&| n|| } | dur0q| dur9| | s9q| durB| | sBq| jsKd}| Vq|rVt|| rV| Vq|s]|| q|se|EdHdS|D]O} t|durr| n|| } | dur|qi|D]9\}}|j} | dur| | sn)|j} | dus| | r| jsd}| Vn|rt|| r| Vn|s|| nq~qi|s|EdHdS|du} t|dkr |d\}}|j} |j} |D]/} t|dur| n|| } | durq| r| jrq| dur| | sq| dus| | r | VqdS|D]I} t|dur| n|| } | dur%q| r.| jr.q|D]&\}}|j} | durC| | sCn|j} | dusP| | rU| Vnq0qdS)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)r@rgrr is_prereleaserr)rrrrrprerelease_buffer found_finalrrrritemrexclude_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 rvalue Version | BoundaryVersion | NonecCsb|durtSt|tr(|j}|jrt|S|jdur|jdnd}|j|ddS|js-|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)rrNr+r2rrr:r)r inner_versionrr)r)r*_lowest_release_at_or_aboves rcCsL|D]!\}}t|j}|jdus||jkrdS||jkr#|jr#dSqdS)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)rr2rh)rrrnearestr)r)r*rs  ropr[rcCsJt|}t|}|dkrt|dt|dfgStt|dft|dtfgS)z^Ranges for ==V.* and !=V.*. ==1.2.* -> [1.2.dev0, 1.3.dev0); !=1.2.* -> complement. ==TF)rrrfr~rr)rrrrr)r)r*rs  r has_localcCs|dkr t|dtfgS|dkrttt|tjdfgS|dkr[|jdur7|j|jddd}t|dtfgS|j durO|j|j dddd }t|dtfgStt|tj d tfgS|d kry|j rd|n|jddd}|t krqgStt|d fgSt|tj}|r|n|}|d krt|dt|dfgS|d krtt|d ft|d tfgS|dkr|j|j ddd}t|dtt|d fgStd|)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<=rwNrrrrFrurz!=z~=r)r7zUnknown operator: )rfrrr~r+r r'r;rr:r(rrr7r ValueError)rr2r lower_boundbound after_localsrprefixr)r)r*rsJ      r version_strcCs$|dr t||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  rper_specifier_rangesIterable[Sequence[Interval]]cCsBd}|D]}|dur |}qt||}|snq|durtd|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 rcCsJ|D] \}}|j}|dur||sdS|j}|dus||r"dSqdS)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)rgr)rr2rrrrr)r)r*r#s r configured autodetectedcCs|dur|S|r dSdS)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)r7rr3r)r2rr3r)r2rr3r)r2rr3r)rr+r3r)rrfrr~r3r?)rrrrr3r)r)) rrrrrrrrrrr3r)rrr3r)rrr3r?)rr[rrr3r)rr[r2rrr?r3r)rr[rr[r2rr3r)rrr3r)rrr2rr3r?)rrrrr3r);r$ __future__rr% functoolstypingrrrr2rrcollections.abcr r r r r tuplerWfloat_BoundaryOrderSuffixrG__all__r__annotations__rrEnumr total_orderingr+rirfr~Intervalrrrr6rrrrjrkrrrrrrrrrrrrrrr)r)r)r*sd  o8:      ( ' '   f    E