+
    yjx                      a  0 t $ R t^ RIHt ^ RIt^ RIt^ RIHtHtH	t	 ^RI
HtHt ]'       dA   ^ RIHtHtHtHt ^ RIHt ]]]]]]]3,          ]]3,          t]]]]R3,          ]]3,          t. RGOt]! R	4      tR
]R&   ]! R4      tR
]R&   ]! R4      tR]R&    ! R R]P:                  4      t]P>                   ! R R4      4       t ]'       d   ]]] R3,          t!]P>                   ! R R4      4       t"]P>                   ! R R4      4       t#]'       d   ]]"]#3,          t$]"! RR4      t%R]R&   ]#! RR4      t&R]R&   ]%]&33t'R]R&   R R  lt(R! R" lt)R# R$ lt*R% R& lt+R' R( lt,R) R* lt-R+ R, lt.R- R. lt/R/ R0 lt0R1 R2 lt1RHR3 R4 llt2R5 R6 lt3R7 R8 lt4R9 R: lt5R; R< lt6R= R> lt7R? R@ lt8RA RB lt9RC RD lt:RE RF lt;R# )IzBPrivate version-range helpers used by :mod:`packaging.specifiers`.)annotationsN)TYPE_CHECKINGAnyFinal)InvalidVersionVersion)CallableIterableIteratorSequence)Union.
FULL_RANGEz0.dev0zFinal[Version]MIN_VERSION0MIN_RELEASEinfzFinal[float]_BOUNDARY_INFc                  ^    ] tR t^7tRt]P                  ! 4       t]P                  ! 4       tRt	R# )BoundaryKindz5Where a boundary marker sits in the version ordering. N)
__name__
__module____qualname____firstlineno____doc__enumautoAFTER_LOCALSAFTER_POSTS__static_attributes__r       E/var/www/html/2rare/lib/python3.14/site-packages/packaging/_ranges.pyr   r   7   s    ?99;L))+Kr    r   c                  ~    ] tR t^>tRtRtR R ltR R ltR R ltR R	 lt	R
 R lt
R R ltR R ltR R ltRtR# )BoundaryVersiona  A 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.
c               $    V ^8  d   QhRRRRRR/# )   versionr   kindr   returnNoner   )formats   "r!   __annotate__BoundaryVersion.__annotate__V   s!     ' ' '| ' 'r    c                	    Wn         W n        \        VP                  4      V n        VP
                  V n        VP                  V n        VP                  V n
        VP                  V n        R # N)r&   r'   trim_releaserelease_cached_trimmed_releaseepoch_cached_epochpre_cached_prepost_cached_postdev_cached_dev)selfr&   r'   s   &&&r!   __init__BoundaryVersion.__init__V   sM    	'3GOO'D$$]]";;#LL";;r    c                    V ^8  d   QhRRRR/# )r%   otherr   r(   boolr   )r*   s   "r!   r+   r,   _   s     G G GD Gr    c                `   VP                   V P                  8w  d   R# VP                  pV P                  p\	        V4      p\	        V4      V8  d   R# VRV V8w  d   R# \        V\	        V4      4       F  pW%,          ^ 8w  g   K   R# 	  VP                  V P                  8w  d   R# V P                  \        P                  8X  d;   VP                  V P                  8H  ;'       d    VP                  V P                  8H  # VP                  V P                  8H  ;'       g    VP                  RJ# )z6Is ``other`` a version that this boundary sorts above?FN)r2   r3   r0   r1   lenranger4   r5   r'   r   r   r6   r7   r8   r9   )r:   r>   other_releasetrimmed_releasetrimmed_lengthis   &&    r!   
_is_familyBoundaryVersion._is_family_   s    ;;$,,, 66_-}..)_<~s='9:A1$ ; 99(((99111::!2!22TTuyyDDTDT7TTyyD,,,FF

$0FFr    c                   V ^8  d   QhRR/# )r%   r(   _BoundaryOrderKeyr   )r*   s   "r!   r+   r,   x   s     E E- Er    c                    V P                   P                  pV^,          pV P                  \        P                  8X  d   V^ ,          V^,          ^\
        ^^ 3pV^ ,          V^,          V\
        3# )aJ  Sort 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.
)r&   _keyr'   r   r   r   )r:   version_keysuffixs   &  r!   
_order_keyBoundaryVersion._order_keyx   s_     ll'''21~99000QiA}aCF1~{1~v}DDr    c                    V ^8  d   QhRRRR/# r%   r>   objectr(   r?   r   )r*   s   "r!   r+   r,      s      F t r    c                	|    \        V\        4      '       d"   V P                  4       VP                  4       8H  # \        # r.   )
isinstancer#   rO   NotImplementedr:   r>   s   &&r!   __eq__BoundaryVersion.__eq__   s2     e_--??$(8(8(:::r    c                    V ^8  d   QhRRRR/# r%   r>   zBoundaryVersion | Versionr(   r?   r   )r*   s   "r!   r+   r,      s     * *5 *$ *r    c                	    \        V\        4      '       d"   V P                  4       VP                  4       8  # V P                  V8  g   R # V P	                  V4      '       * # )FrU   r#   rO   r&   rG   rW   s   &&r!   __lt__BoundaryVersion.__lt__   sM    e_--??$u'7'7'999 u$??5)))r    c                    V ^8  d   QhRRRR/# r[   r   )r*   s   "r!   r+   r,      s     & &5 &$ &r    c                	    \        V\        4      '       d"   V P                  4       VP                  4       8  # V P                  V8  d   R # V P	                  V4      # )Tr]   rW   s   &&r!   __gt__BoundaryVersion.__gt__   sJ     e_--??$u'7'7'999<<5 u%%r    c                   V ^8  d   QhRR/# r%   r(   intr   )r*   s   "r!   r+   r,      s     ' '# 'r    c                	4    \        V P                  4       4      # r.   )hashrO   r:   s   &r!   __hash__BoundaryVersion.__hash__   s    DOO%&&r    c                   V ^8  d   QhRR/# r%   r(   strr   )r*   s   "r!   r+   r,      s     P P# Pr    c                	~    V P                   P                   R V P                  : RV P                  P                   R2# )(z, ))	__class__r   r&   r'   nameri   s   &r!   __repr__BoundaryVersion.__repr__   s4    ..))*!DLL+;2diinn=MQOOr    )r9   r3   r7   r5   r1   r'   r&   N)r   r   r   r   r   	__slots__r;   rG   rO   rX   r^   rb   rj   rt   r   r   r    r!   r#   r#   >   s?    
I'G2E**&'P Pr    r#   c                  Z    ] tR t^tRtRtR R ltR R ltR R ltR R	 lt	R
 R lt
RtR# )
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.
c               $    V ^8  d   QhRRRRRR/# r%   r&   _VersionOrBoundary	inclusiver?   r(   r)   r   )r*   s   "r!   r+   LowerBound.__annotate__   s"     ) ) 2 )t ) )r    c                	j   Wn         W n        Vf
   R V n        R # \        V\        4      '       dX   VP
                  \        P                  8X  d   \        VP                   4      V n        R # \        VP                   4      V n        R # V'       d   VP                  V n        R # VP                  V n        R # r.   )r&   r|   _aboverU   r#   r'   r   r   _make_above_after_posts_make_above_after_locals__le__r^   r:   r&   r|   s   &&&r!   r;   LowerBound.__init__   st    " ?<@DK11 |||7775gooF6wG!..DK!..DKr    c                    V ^8  d   QhRRRR/# rR   r   )r*   s   "r!   r+   r}           S SF St Sr    c                	    \        V\        4      '       g   \        # V P                  VP                  8H  ;'       d    V P                  VP                  8H  # r.   rU   rx   rV   r&   r|   rW   s   &&r!   rX   LowerBound.__eq__   =    %,,!!||u}},RR5??1RRr    c                    V ^8  d   QhRRRR/# )r%   r>   rx   r(   r?   r   )r*   s   "r!   r+   r}           6 6J 64 6r    c                	D   \        V\        4      '       g   \        # V P                  f   VP                  R J# VP                  f   R# V P                  VP                  8w  d   V P                  VP                  8  # V P                  ;'       d    VP                  '       * # )NFr   rW   s   &&r!   r^   LowerBound.__lt__   sw    %,,!!<<==,,== <<5==(<<%--//~~55eoo"55r    c                   V ^8  d   QhRR/# re   r   )r*   s   "r!   r+   r}           4 4# 4r    c                	D    \        V P                  V P                  34      # r.   rh   r&   r|   ri   s   &r!   rj   LowerBound.__hash__       T\\4>>233r    c                   V ^8  d   QhRR/# rm   r   )r*   s   "r!   r+   r}           H H# Hr    c                	    V P                   '       d   R MRpRV P                  P                   RV V P                  : R2# )[rp   < >r|   rr   r   r&   r:   brackets   & r!   rt   LowerBound.__repr__   s:    #S4>>**+1WIdll5EQGGr    )r   r|   r&   Nr   r   r   r   r   rv   r;   rX   r^   rj   rt   r   r   r    r!   rx   rx      s/     3I)(S
64H Hr    rx   c                  Z    ] tR t^tRtRtR R ltR R ltR R ltR R	 lt	R
 R lt
Rt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.
c               $    V ^8  d   QhRRRRRR/# rz   r   )r*   s   "r!   r+   UpperBound.__annotate__   s"     ) ) 2 )t ) )r    c                	X   Wn         W n        Vf
   R V n        R # \        V\        4      '       dO   VP
                  \        P                  8X  d   \        VP                   4      V n        R # VP                  V n        R # V'       d   VP                  V n        R # VP                  V n        R # r.   )r&   r|   _belowrU   r#   r'   r   r   _make_below_after_locals__ge__rb   r   s   &&&r!   r;   UpperBound.__init__   sq    " ?<@DK11 |||8886wG
 &nn!..DK!..DKr    c                    V ^8  d   QhRRRR/# rR   r   )r*   s   "r!   r+   r     r   r    c                	    \        V\        4      '       g   \        # V P                  VP                  8H  ;'       d    V P                  VP                  8H  # r.   rU   r   rV   r&   r|   rW   s   &&r!   rX   UpperBound.__eq__  r   r    c                    V ^8  d   QhRRRR/# )r%   r>   r   r(   r?   r   )r*   s   "r!   r+   r     r   r    c                	,   \        V\        4      '       g   \        # V P                  f   R# VP                  f   R# V P                  VP                  8w  d   V P                  VP                  8  # V P                  '       * ;'       d    VP                  # )NFTr   rW   s   &&r!   r^   UpperBound.__lt__  sk    %,,!!<<== <<5==(<<%--//>>!55eoo5r    c                   V ^8  d   QhRR/# re   r   )r*   s   "r!   r+   r     r   r    c                	D    \        V P                  V P                  34      # r.   r   ri   s   &r!   rj   UpperBound.__hash__  r   r    c                   V ^8  d   QhRR/# rm   r   )r*   s   "r!   r+   r   !  r   r    c                	    V P                   '       d   R MRpRV P                  P                   RV P                  : V R2# )]rq   r   r   r   r   r   s   & r!   rt   UpperBound.__repr__!  s:    #S4>>**+1T\\,<WIQGGr    )r   r|   r&   Nr   r   r    r!   r   r      s/     3I),S
64H Hr    r   FzFinal[LowerBound]NEG_INFzFinal[UpperBound]POS_INFzFinal[tuple[Interval]]c                    V ^8  d   QhRRRR/# )r%   r0   ztuple[int, ...]r(   r   )r*   s   "r!   r+   r+   0  s     = =/ =o =r    c                    \        V 4      pV^8  d    W^,
          ,          ^ 8X  d   V^,          pK&  V\        V 4      8X  d   V # V RV # )zDStrip trailing zeros from a release tuple for normalized comparison.N)rA   )r0   ends   & r!   r/   r/   0  sE    
g,C
'gAg&!+qS\)7<wt}<r    c                    V ^8  d   QhRRRR/# r%   r&   r   r(   r   )r*   s   "r!   r+   r+   8  s     K Kw K7 Kr    c                    . V P                   RR OV P                   R,          ^,           N5p\        P                  ! V P                  V^ R7      # )z5Smallest version in the next prefix: 1.2 -> 1.3.dev0.Nr2   r0   r8   )r0   r   
from_partsr2   )r&   r0   s   & r!   _next_prefix_dev0r   8  sC    >$>goob&9A&=>GGMM7JJr    c                    V ^8  d   QhRRRR/# r   r   )r*   s   "r!   r+   r+   >  s     S S SG Sr    c                \    \         P                  ! V P                  V P                  ^ R7      # )z7The .dev0 of a version's base release: 1.2 -> 1.2.dev0.r   )r   r   r2   r0   r&   s   &r!   
_base_dev0r   >  s     GMM7??PQRRr    c                    V ^8  d   QhRRRR/# )r%   r&   zVersion | strr(   Version | Noner   )r*   s   "r!   r+   r+   C  s      M n r    c                r    \        V \        4      '       g    \        V 4      p V # V #   \         d     R # i ; ir.   )rU   r   r   r   s   &r!   coerce_versionr   C  s=    gw''	g&G N7N  		s   ' 66c                    V ^8  d   QhRRRR/# r%   r&   r   r(   zCallable[[Version], bool]r   )r*   s   "r!   r+   r+   L  s     % %W %1J %r    c                   aaaaa V P                   oV P                  oV P                  o\        V P                  4      o\        S4      oR VVVVV3R llpV# )zPredicate ``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.
c                    V ^8  d   QhRRRR/# r%   parsedr   r(   r?   r   )r*   s   "r!   r+   -_make_above_after_posts.<locals>.__annotate__Y  s      g $ r    c                   < S! V 4      '       d   R # V P                   S8w  d   R# V P                  p\        V4      S8  d   R# VRS S8w  d   R# \        S\        V4      4       F  pW,          ^ 8w  g   K   R# 	  V P                  S8w  d   R# R # FTN)r2   r0   rA   rB   r4   )r   parsed_releaserF   rE   version_epoch
version_geversion_preversion_release_trimmeds   &  r!   above&_make_above_after_posts.<locals>.aboveY  s    f <<=(~//>*.EE~s>':;A A% < ::$ r    )r   r2   r4   r/   r0   rA   )r&   r   rE   r   r   r   r   s   & @@@@@r!   r   r   L  sK     JMMM++K*7??;01N 0 Lr    c                    V ^8  d   QhRRRR/# r   r   )r*   s   "r!   r+   r+   t       $ $g $2K $r    c                   aaaaaaa V P                   oV P                  oV P                  oV P                  oV P                  o\        V P                  4      o\        S4      oR VVVVVVV3R llpV# )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``.
c                    V ^8  d   QhRRRR/# r   r   )r*   s   "r!   r+   ._make_above_after_locals.<locals>.__annotate__       ) )g )$ )r    c                `  < S! V 4      '       d   R # V P                   S8w  d   R# V P                  p\        V4      S8  d   R# VRS S	8w  d   R# \        S\        V4      4       F  pW,          ^ 8w  g   K   R# 	  V P                  S8w  d   R# V P
                  S8w  d   R# V P                  S8g  # r   r2   r0   rA   rB   r4   r6   r8   
r   r   rF   rE   version_devr   r   version_postr   r   s
   &  r!   r   '_make_above_after_locals.<locals>.above  s    f <<=(~//>*.EE~s>':;A A% < ::$;;,&zz[((r    r   r2   r4   r6   r8   r/   r0   rA   )	r&   r   rE   r   r   r   r   r   r   s	   & @@@@@@@r!   r   r   t  ]     JMMM++K<<L++K*7??;01N) )* Lr    c                    V ^8  d   QhRRRR/# r   r   )r*   s   "r!   r+   r+     r   r    c                   aaaaaaa V P                   oV P                  oV P                  oV P                  oV P                  o\        V P                  4      o\        S4      oR VVVVVVV3R llpV# )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.
c                    V ^8  d   QhRRRR/# r   r   )r*   s   "r!   r+   ._make_below_after_locals.<locals>.__annotate__  r   r    c                `  < S! V 4      '       d   R # V P                   S8w  d   R# V P                  p\        V4      S8  d   R# VRS S	8w  d   R# \        S\        V4      4       F  pW,          ^ 8w  g   K   R# 	  V P                  S8w  d   R# V P
                  S8w  d   R# V P                  S8H  # )TFNr   r   s
   &  r!   below'_make_below_after_locals.<locals>.below  s    f <<=(~//>*.EE~s>':;A A% < ::$;;,&zz[((r    r   )	r&   r   rE   r   r   r   r   r   r   s	   & @@@@@@@r!   r   r     r   r    c                    V ^8  d   QhRRRR/# )r%   boundaryr#   r(   r   r   )r*   s   "r!   r+   r+     s      / n r    c                   V P                   pV P                  \        P                  8X  dj   VP                  e%   VP                  VP                  ^,           RR7      # VP                  e   VP                  ^,           M^ pVP                  V^ RR7      # VP                  e,   VP                  w  r4VP                  W4^,           3R^ RR7      # R# )zLSmallest real version strictly above *boundary*, or ``None`` if none exists.Nr8   localr6   r8   r   r4   r6   r8   r   )r&   r'   r   r   r8   __replace__r6   r4   )r   base	next_postr'   numbers   &    r!   least_version_abover     s    D}}111 88##1D#AA'+yy'<TYY]!	YATBB xxxxTA:$6TqPTUUr    c               $    V ^8  d   QhRRRRRR/# )r%   lowerrx   upperr   r(   r?   r   )r*   s   "r!   r+   r+     s!     ) )* )Z )D )r    c                `   VP                   f   R# V P                   fO   VP                  '       * ;'       d6    \        VP                   \        4      ;'       d    VP                   \        8*  # \        V P                   \
        4      '       dK   \        V P                   4      pVe2   VP                   V8X  d   VP                  '       * # VP                   V8  # V P                   VP                   8X  d&   V P                  ;'       d    VP                  '       * # V P                   VP                   8  # )a	  True 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.
F)r&   r|   rU   r   r   r#   r   )r   r   	successors   && r!   range_is_emptyr    s     }}}}  - -5=='2- -,	
 %--11'6	 }}	) ??**==9,,}}%OO7788==5==((r    c               $    V ^8  d   QhRRRRRR/# )r%   leftSequence[Interval]rightr(   list[Interval]r   )r*   s   "r!   r+   r+     s&      
 r    c                "   . p^ ;r4V\        V 4      8  dz   V\        V4      8  dj   W,          w  rVW,          w  rx\        WW4      p	\        Wh4      p
\        W4      '       g   VP	                  W34       Wh8  d   V^,          pK~  V^,          pK  V# )zFIntersect two sorted, non-overlapping range lists (two-pointer merge).)rA   maxminr  append)r  r  result
left_indexright_index
left_lower
left_upperright_lowerright_upperr   r   s   &&         r!   intersect_rangesr    s    
  F  J
s4y
 [3u:%=!%!1
#(#5 J,J,e++MM5.) #!OJ1KMr    c               0    V ^8  d   QhRRRRRRRRR	RR
R/# )r%   rangesr  iterablezIterable[Any]keyz%Callable[[Any], Version | str] | Noneprereleasesbool | Noneregionr(   zIterator[Any]r   )r*   s   "r!   r+   r+     sL     c ccc 
/c 	c
 c cr    c              #     "   VEf   . pRp\        V 4      ^8X  d   V ^ ,          w  rxVP                  p	VP                  p
V F  p\        Vf   TMV! V4      4      pVf   K   V	e   V	! V4      '       g   K4  V
e   V
! V4      '       g   KH  VP                  '       g	   RpVx  Kb  V'       d   \        WL4      '       d   Vx  K  V'       d   K  VP                  V4       K  	  V'       g   T Rj  xL
  R# V F  p\        Vf   TMV! V4      4      pVf   K   V  F  w  rxVP                  p	V	e   V	! V4      '       g    KH  VP                  p
V
e   V
! V4      '       g   KF  VP                  '       g   RpVx  M7V'       d   \        WL4      '       d   Vx  MV'       g   VP                  V4        K  	  K  	  V'       g   T Rj  xL
  R# VRJ p\        V 4      ^8X  d   V ^ ,          w  rxVP                  p	VP                  p
V Fh  p\        Vf   TMV! V4      4      pVf   K   V'       d   VP                  '       d   K<  V	e   V	! V4      '       g   KP  V
e   V
! V4      '       g   Kd  Vx  Kj  	  R# V F  p\        Vf   TMV! V4      4      pVf   K   V'       d   VP                  '       d   K<  V  FK  w  rxVP                  p	V	e   V	! V4      '       g    Kd  VP                  p
V
e   V
! V4      '       g   KF  Vx   K  	  K  	  R#  EL ELF5i)a  Filter *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.
NFT)rA   r   r   r   is_prereleasematches_bounds_onlyr  )r  r  r  r  r  prerelease_bufferfound_finalr   r   r   r   itemr   exclude_prereleasess   &&&&&         r!   filter_by_rangesr"    s     ')v;! "!9LELLELLE 'TK>$U6]]$U6]]+++"&KJ 3F C CJ$%,,T2 ! ,,,D#CKDSYGF~ &$U6]]=E&MM!///&*"
$7$G$G"
()006 !'	 $ (((%.
6{a ayD#CKDSYGF~"v';';'; v}f
  	TC>6#7#7#7"LELLE vLLE}f
 # [ -, )s   A0L3LLL+LL)L.L/AL<LL1L L!L LLA&L-L?LL)3LL/&LL9LLc                    V ^8  d   QhRRRR/# r   r   )r*   s   "r!   r+   r+   w  s     	5 	5w 	57 	5r    c                n    V P                   e   V P                  RRRRR7      # V P                  RRR7      # )z=Smallest non-pre-release at or above a pre-release *version*.Nr   r   )r4   r   r   s   &r!   !_nearest_release_above_prereleaser%  w  s@    {{ ""t$D"MM 4t44r    c                    V ^8  d   QhRRRR/# )r%   valuez Version | BoundaryVersion | Noner(   r   r   )r*   s   "r!   r+   r+     s     4 4'G 4G 4r    c                >   V f   \         # \        V \        4      '       d`   V P                  pVP                  '       d   \        V4      # VP                  e   VP                  ^,           M^ pVP                  VRR7      # V P                  '       g   V # \        V 4      # )zSmallest non-pre-release version at or above *value*.

``None`` is the ``-inf`` floor, whose nearest non-pre-release is
:data:`MIN_RELEASE`.
N)r6   r   )r   rU   r#   r&   r  r%  r6   r   )r'  inner_versionr   s   &  r!   _lowest_release_at_or_abover*    s     }%))&&&4]CC 1>0B0B0N]''!+TU	((it(DD,U33r    c                    V ^8  d   QhRRRR/# )r%   r  r  r(   r?   r   )r*   s   "r!   r+   r+     s      '9 d r    c                    V  Fb  w  r\        VP                  4      pVP                  e   W2P                  8  d    R# W2P                  8X  g   KM  VP                  '       g   Ka   R# 	  R# )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.
FT)r*  r&   r|   )r  r   r   nearests   &   r!   ranges_are_prerelease_onlyr.    sN     -emm<== Gmm$;mm#  r    c               $    V ^8  d   QhRRRRRR/# )r%   oprn   r   r   r(   r  r   )r*   s   "r!   r+   r+     s!       7 ~ r    c                    \        V4      p\        V4      pV R8X  d   \        VR4      \        VR4      3.# \        \        VR4      3\        VR4      \
        3.# )zVRanges for ==V.* and !=V.*.

==1.2.* -> [1.2.dev0, 1.3.dev0);  !=1.2.* -> complement.
==TF)r   r   rx   r   r   r   )r0  r   r   r   s   &&  r!   wildcard_rangesr3    se    
 tEd#E	TzE4(*UE*BCDD 
*UE*+	E4	 '* r    c               (    V ^8  d   QhRRRRRRRR/# )	r%   r0  rn   r&   r   	has_localr?   r(   r  r   )r*   s   "r!   r+   r+     s.     B2 B2 B2g B2$ B2> B2r    c                @   V R8X  d   \        VR4      \        3.# V R8X  d,   \        \        \	        V\
        P                  4      R4      3.# V R8X  d   VP                  e8   VP                  VP                  ^,           RR7      p\        VR4      \        3.# VP                  e9   VP                  VP                  ^,           ^ RR7      p\        VR4      \        3.# \        \	        V\
        P                  4      R4      \        3.# V R	8X  dH   VP                  '       d   TMVP                  ^ RR7      pV\        8:  d   . # \        \        VR4      3.# \	        V\
        P                  4      pV'       d   TMTpV R
8X  d   \        VR4      \        VR4      3.# V R8X  d%   \        \        VR4      3\        VR4      \        3.# V R8X  dB   VP                  VP                  RR R7      p\        VR4      \        \        V4      R4      3.# \        RV : 24      h)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<=r   Nr   r   Fr   r2  z!=z~=)r0   zUnknown operator: r   )rx   r   r   r   r#   r   r   r8   r   r6   r   r  r   r0   r   
ValueError)r0  r&   r5  lower_boundboundafter_localsr   prefixs   &&&     r!   standard_rangesr<    s+    
TzGT*G455	Tz ?7L4M4MNPTU
 	
 
Sy;;" "--'++/-NKT2G<==<<#!--7<<!3CRV-WKT2G<==
 ?7L4L4LMuU
 	
 
Sy ,,,G'2E2E!SW2E2X 	 KI*UE2344 #7L,E,EFL GlE	TzGT*Jud,CDEE	Tzj%01u%w/
 	

 
Tz$$W__Sb-A$B&
3DV3Le(TU
 	
 )"0
11r    c               (    V ^8  d   QhRRRRRRRR/# )r%   r0  rn   version_strr&   r   r(   r  r   )r*   s   "r!   r+   r+     s(     < < <# < <N <r    c                d    VP                  R4      '       d   \        W4      # \        WRV9   4      # )a0  Ranges 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.*+)endswithr3  r<  )r0  r>  r&   s   &&&r!   bounds_for_specrB    s2     D!!r++2{(:;;r    c                    V ^8  d   QhRRRR/# )r%   per_specifier_rangeszIterable[Sequence[Interval]]r(   r  r   )r*   s   "r!   r+   r+     s      6r    c                t    RpV  F   pVf   TpK  \        W4      pV'       d   K    M	  Vf   \        R4      hV# )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)rD  r  subs   &  r!   intersect_specifier_boundsrH    sG     )-F#>F%f2F6 $ ~QRRMr    c               $    V ^8  d   QhRRRRRR/# )r%   r  r  r&   r   r(   r?   r   )r*   s   "r!   r+   r+   #  s"       2 W  r    c                    V  FG  w  r#VP                   pVe   V! V4      '       g    R# VP                  pVe   V! V4      '       g   KF   R# 	  R# )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.
FT)r   r   )r  r&   r   r   r   r   s   &&    r!   r  r  #  sH     U7^^=E'NN  r    c               $    V ^8  d   QhRRRRRR/# )r%   
configuredr  autodetectedr(   r   )r*   s   "r!   r+   r+   6  s$      +6r    c                &    V e   V # V'       d   R# R# )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   )rL  rM  s   &&r!   resolve_prereleasesrO  6  s     r    )r   rB  r   r"  r  rH  r   r  r  r.  rO  r<  r3  )r   )<__conditional_annotations__r   
__future__r   r   	functoolstypingr   r   r   r&   r   r   collections.abcr   r	   r
   r   r   tuplerf   float_BoundaryOrderSuffixrJ   __all__r   __annotations__r   r   Enumr   total_orderingr#   r{   rx   r   Intervalr   r   r   r/   r   r   r   r   r   r   r   r  r  r"  r%  r*  r.  r3  r<  rB  rH  r  rO  )rP  s   @r!   <module>r]     s   I "    -FF !c3c5j0A3!KLc5c?4H%OP" &h/^ / &cl^ * $El| *499  lP lP lP^ w=> 5H 5H 5Hp 7H 7H 7Ht Z+,H (e4	 4'e4	 4'.&8%:
" :=KS
%P$N$N*)@4cL	54. B2J<.&r    