
    ցjx                    X   % S r SSKJr  SSKrSSKrSSKJrJrJr  SSK	J
r
Jr  \(       a0  SSKJrJrJrJr  SSKJr  \\\\\\\4   \\4   r\\\\S	4   \\4   r/ S
Qr\" S5      rS\S'   \" S5      rS\S'   \" S5      rS\S'    " S S\R8                  5      r\R<                   " S S5      5       r\(       a  \\\S4   r \R<                   " S S5      5       r!\R<                   " S S5      5       r"\(       a  \\!\"4   r#\!" SS5      r$S\S'   \"" SS5      r%S\S'   \$\%44r&S \S!'   S6S" jr'S7S# jr(S7S$ jr)S8S% jr*S9S& jr+S9S' jr,S9S( jr-S:S) jr.S;S* jr/      S<S+ jr0 S=           S>S, jjr1S7S- jr2S?S. jr3S@S/ jr4SAS0 jr5SBS1 jr6SCS2 jr7    SDS3 jr8SES4 jr9      SFS5 jr:g)GzBPrivate version-range helpers used by :mod:`packaging.specifiers`.    )annotationsN)TYPE_CHECKINGAnyFinal   )InvalidVersionVersion)CallableIterableIteratorSequence)Union.)
FULL_RANGEbounds_for_speccoerce_versionfilter_by_rangesintersect_rangesintersect_specifier_boundsleast_version_abovematches_bounds_onlyrange_is_emptyranges_are_prerelease_onlyresolve_prereleasesstandard_rangeswildcard_rangesz0.dev0zFinal[Version]MIN_VERSION0MIN_RELEASEinfzFinal[float]_BOUNDARY_INFc                  \    \ rS rSrSr\R                  " 5       r\R                  " 5       rSr	g)BoundaryKind7   z5Where a boundary marker sits in the version ordering. N)
__name__
__module____qualname____firstlineno____doc__enumautoAFTER_LOCALSAFTER_POSTS__static_attributes__r$       K/mnt/workspace/venv-train/lib/python3.13/site-packages/packaging/_ranges.pyr"   r"   7   s    ?99;L))+Kr/   r"   c                  l    \ rS rSrSrSrSS jrSS jrSS jrSS jr	SS jr
SS	 jrSS
 jrSS jrSrg)BoundaryVersion>   a  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.
)_cached_dev_cached_epoch_cached_post_cached_pre_cached_trimmed_releasekindversionc                    Xl         X l        [        UR                  5      U l        UR
                  U l        UR                  U l        UR                  U l
        UR                  U l        g N)r:   r9   trim_releasereleaser8   epochr5   prer7   postr6   devr4   )selfr:   r9   s      r0   __init__BoundaryVersion.__init__V   sM    	'3GOO'D$$]]";;#LL";;r/   c                >   UR                   U R                  :w  a  gUR                  nU R                  n[	        U5      n[	        U5      U:  a  gUSU U:w  a  g[        U[	        U5      5       H  nX%   S:w  d  M    g   UR                  U R                  :w  a  gU R                  [        R                  :X  a9  UR                  U R                  :H  =(       a    UR                  U R                  :H  $ UR                  U R                  :H  =(       d    UR                  SL$ )z6Is ``other`` a version that this boundary sorts above?FNr   )r?   r5   r>   r8   lenranger@   r7   r9   r"   r,   rA   r6   rB   r4   )rC   otherother_releasetrimmed_releasetrimmed_lengthis         r0   
_is_familyBoundaryVersion._is_family_   s    ;;$,,, 66_-}..)_<~s='9:A1$ ; 99(((99111::!2!22TuyyDDTDT7TTyyD,,,F

$0FFr/   c                    U R                   R                  nUS   nU R                  [        R                  :X  a  US   US   S[
        SS4nUS   US   U[
        4$ )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   r   )r:   _keyr9   r"   r-   r    )rC   version_keysuffixs      r0   
_order_keyBoundaryVersion._order_keyx   s_     ll'''21~99000QiA}aCF1~{1~v}DDr/   c                z    [        U[        5      (       a!  U R                  5       UR                  5       :H  $ [        $ r<   )
isinstancer2   rU   NotImplementedrC   rI   s     r0   __eq__BoundaryVersion.__eq__   s2     e_--??$(8(8(:::r/   c                    [        U[        5      (       a!  U R                  5       UR                  5       :  $ U R                  U:  d  gU R	                  U5      (       + $ NFrX   r2   rU   r:   rN   rZ   s     r0   __lt__BoundaryVersion.__lt__   sM    e_--??$u'7'7'999 u$??5)))r/   c                    [        U[        5      (       a!  U R                  5       UR                  5       :  $ U R                  U:  a  gU R	                  U5      $ )NTr_   rZ   s     r0   __gt__BoundaryVersion.__gt__   sJ     e_--??$u'7'7'999<<5 u%%r/   c                4    [        U R                  5       5      $ r<   )hashrU   rC   s    r0   __hash__BoundaryVersion.__hash__   s    DOO%&&r/   c                ~    U R                   R                   SU R                  < SU R                  R                   S3$ )N(z, ))	__class__r%   r:   r9   namerg   s    r0   __repr__BoundaryVersion.__repr__   s4    ..))*!DLL+;2diinn=MQOOr/   N)r:   r	   r9   r"   returnNone)rI   r	   rq   bool)rq   _BoundaryOrderKeyrI   objectrq   rs   )rI   zBoundaryVersion | Versionrq   rs   rq   intrq   str)r%   r&   r'   r(   r)   	__slots__rD   rN   rU   r[   r`   rc   rh   ro   r.   r$   r/   r0   r2   r2   >   s9    
I'G2E**&'Pr/   r2   c                  N    \ rS rSrSrSrS
S jrSS jrSS jrSS jr	SS jr
Srg	)
LowerBound   zLower 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	inclusiver:   c                X   Xl         X l        Uc  S U l        g [        U[        5      (       aT  UR
                  [        R                  :X  a  [        UR                   5      U l        g [        UR                   5      U l        g U(       a  UR                  U l        g UR                  U l        g r<   )r:   r   r   rX   r2   r9   r"   r-   _make_above_after_posts_make_above_after_locals__le__r`   rC   r:   r   s      r0   rD   LowerBound.__init__   st    " ?<@DK11 |||7775gooF6wG!..DK!..DKr/   c                    [        U[        5      (       d  [        $ U R                  UR                  :H  =(       a    U R                  UR                  :H  $ r<   rX   r}   rY   r:   r   rZ   s     r0   r[   LowerBound.__eq__   :    %,,!!||u}},R5??1RRr/   c                8   [        U[        5      (       d  [        $ U R                  c  UR                  S L$ UR                  c  gU R                  UR                  :w  a  U R                  UR                  :  $ U R                  =(       a    UR                  (       + $ r^   r   rZ   s     r0   r`   LowerBound.__lt__   st    %,,!!<<==,,== <<5==(<<%--//~~5eoo"55r/   c                D    [        U R                  U R                  45      $ r<   rf   r:   r   rg   s    r0   rh   LowerBound.__hash__       T\\4>>233r/   c                    U R                   (       a  SOSnSU R                  R                   SU U R                  < S3$ )N[rk   < >r   rm   r%   r:   rC   brackets     r0   ro   LowerBound.__repr__   s8    #S4>>**+1WIdll5EQGGr/   Nr:   _VersionOrBoundaryr   rs   rq   rr   ru   )rI   r}   rq   rs   rw   ry   r%   r&   r'   r(   r)   r{   rD   r[   r`   rh   ro   r.   r$   r/   r0   r}   r}      s)     3I)(S
64Hr/   r}   c                  N    \ rS rSrSrSrS
S jrSS jrSS jrSS jr	SS jr
Srg	)
UpperBound   zUpper 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.
)_belowr   r:   c                F   Xl         X l        Uc  S U l        g [        U[        5      (       aK  UR
                  [        R                  :X  a  [        UR                   5      U l        g UR                  U l        g U(       a  UR                  U l        g UR                  U l        g r<   )r:   r   r   rX   r2   r9   r"   r,   _make_below_after_locals__ge__rc   r   s      r0   rD   UpperBound.__init__   sq    " ?<@DK11 |||8886wG
 &nn!..DK!..DKr/   c                    [        U[        5      (       d  [        $ U R                  UR                  :H  =(       a    U R                  UR                  :H  $ r<   rX   r   rY   r:   r   rZ   s     r0   r[   UpperBound.__eq__  r   r/   c                   [        U[        5      (       d  [        $ U R                  c  gUR                  c  gU R                  UR                  :w  a  U R                  UR                  :  $ U R                  (       + =(       a    UR                  $ )NFTr   rZ   s     r0   r`   UpperBound.__lt__  sh    %,,!!<<== <<5==(<<%--//>>!5eoo5r/   c                D    [        U R                  U R                  45      $ r<   r   rg   s    r0   rh   UpperBound.__hash__  r   r/   c                    U R                   (       a  SOSnSU R                  R                   SU R                  < U S3$ )N]rl   r   r   r   r   r   s     r0   ro   UpperBound.__repr__!  s8    #S4>>**+1T\\,<WIQGGr/   Nr   ru   )rI   r   rq   rs   rw   ry   r   r$   r/   r0   r   r      s)     3I),S
64Hr/   r   FzFinal[LowerBound]NEG_INFzFinal[UpperBound]POS_INFzFinal[tuple[Interval]]r   c                    [        U 5      nUS:  a#  XS-
     S:X  a  US-  nUS:  a  XS-
     S:X  a  M  U[        U 5      :X  a  U $ U SU $ )zDStrip trailing zeros from a release tuple for normalized comparison.r   r   N)rG   )r>   ends     r0   r=   r=   0  s\    
g,C
'gAg&!+q 'gAg&!+S\)7<wt}<r/   c                    / U R                   SS QU R                   S   S-   P7n[        R                  " U R                  USS9$ )z5Smallest version in the next prefix: 1.2 -> 1.3.dev0.Nr   r   r?   r>   rB   )r>   r	   
from_partsr?   )r:   r>   s     r0   _next_prefix_dev0r   8  sC    >$>goob&9A&=>GGMM7JJr/   c                V    [         R                  " U R                  U R                  SS9$ )z7The .dev0 of a version's base release: 1.2 -> 1.2.dev0.r   r   )r	   r   r?   r>   r:   s    r0   
_base_dev0r   >  s     GMM7??PQRRr/   c                l    [        U [        5      (       d   [        U 5      n U $ U $ ! [         a     g f = fr<   )rX   r	   r   r   s    r0   r   r   C  s=    gw''	g&G N7N  		s   & 
33c                   ^^^^^ U R                   mU R                  mU R                  m[        U R                  5      m[        T5      mSUUUUU4S jjnU$ )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                   > T" U 5      (       a  gU R                   T:w  a  gU R                  n[        U5      T:  a  gUS T T:w  a  g[        T[        U5      5       H  nX   S:w  d  M    g   U R                  T:w  a  ggNFTr   )r?   r>   rG   rH   r@   )parsedparsed_releaserM   rL   version_epoch
version_geversion_preversion_release_trimmeds      r0   above&_make_above_after_posts.<locals>.aboveY  s    f <<=(~//>*.EE~s>':;A A% < ::$ r/   r   r	   rq   rs   )r   r?   r@   r=   r>   rG   )r:   r   rL   r   r   r   r   s     @@@@@r0   r   r   L  sK     JMMM++K*7??;01N 0 Lr/   c                   ^^^^^^^ U R                   mU R                  mU R                  mU R                  mU R                  m[        U R                  5      m[        T5      mSUUUUUUU4S jjnU$ )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                <  > T" U 5      (       a  gU R                   T:w  a  gU R                  n[        U5      T:  a  gUS T T	:w  a  g[        T[        U5      5       H  nX   S:w  d  M    g   U R                  T:w  a  gU R
                  T:w  a  gU R                  T:g  $ r   r?   r>   rG   rH   r@   rA   rB   
r   r   rM   rL   version_devr   r   version_postr   r   s
      r0   r   '_make_above_after_locals.<locals>.above  s    f <<=(~//>*.EE~s>':;A A% < ::$;;,&zz[((r/   r   r   r?   r@   rA   rB   r=   r>   rG   )	r:   r   rL   r   r   r   r   r   r   s	     @@@@@@@r0   r   r   t  ]     JMMM++K<<L++K*7??;01N) )* Lr/   c                   ^^^^^^^ U R                   mU R                  mU R                  mU R                  mU R                  m[        U R                  5      m[        T5      mSUUUUUUU4S jjnU$ )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                <  > T" U 5      (       a  gU R                   T:w  a  gU R                  n[        U5      T:  a  gUS T T	:w  a  g[        T[        U5      5       H  nX   S:w  d  M    g   U R                  T:w  a  gU R
                  T:w  a  gU R                  T:H  $ )NTFr   r   r   s
      r0   below'_make_below_after_locals.<locals>.below  s    f <<=(~//>*.EE~s>':;A A% < ::$;;,&zz[((r/   r   r   )	r:   r   rL   r   r   r   r   r   r   s	     @@@@@@@r0   r   r     r   r/   c                l   U R                   nU R                  [        R                  :X  aY  UR                  b  UR                  UR                  S-   SS9$ UR                  b  UR                  S-   OSnUR                  USSS9$ UR                  b$  UR                  u  p4UR                  X4S-   4SSSS9$ g)zLSmallest real version strictly above *boundary*, or ``None`` if none exists.Nr   rB   localr   rA   rB   r   r@   rA   rB   r   )r:   r9   r"   r,   rB   __replace__rA   r@   )boundarybase	next_postr9   numbers        r0   r   r     s    D}}111 88##1D#AA'+yy'<TYY]!	YATBB xxxxTA:$6TqPTUUr/   c                L   UR                   c  gU R                   cL  UR                  (       + =(       a4    [        UR                   [        5      =(       a    UR                   [        :*  $ [        U R                   [
        5      (       aH  [        U R                   5      nUb0  UR                   U:X  a  UR                  (       + $ UR                   U:  $ U R                   UR                   :X  a$  U R                  =(       a    UR                  (       + $ U R                   UR                   :  $ )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   rX   r	   r   r2   r   )lowerupper	successors      r0   r   r     s     }}}}  -5=='2-,	
 %--11'6	 }}	) ??**==9,,}}%OO788==5==((r/   c                4   / nS=p4U[        U 5      :  a  U[        U5      :  at  X   u  pVX   u  px[        XW5      n	[        Xh5      n
[        X5      (       d  UR	                  X45        Xh:  a  US-  nOUS-  nU[        U 5      :  a  U[        U5      :  a  Mt  U$ )zFIntersect two sorted, non-overlapping range lists (two-pointer merge).r   r   )rG   maxminr   append)leftrightresult
left_indexright_index
left_lower
left_upperright_lowerright_upperr   r   s              r0   r   r     s    
  F  J
s4y
 [3u:%=!%!1
#(#5 J,J,e++MM5.) #!OJ1K s4y
 [3u:%=  Mr/   c              #    #    UGc  / nSn[        U 5      S:X  a  U S   u  pxUR                  n	UR                  n
U H  n[        Uc  UOU" U5      5      nUc  M  U	b  U	" U5      (       d  M0  U
b  U
" U5      (       d  MB  UR                  (       d  SnUv   M[  U(       a  [        XL5      (       a  Uv   Mx  U(       a  M  UR                  U5        M     U(       d
  U Sh  vN   gU H  n[        Uc  UOU" U5      5      nUc  M  U  H  u  pxUR                  n	U	b  U	" U5      (       d    MD  UR                  n
U
b  U
" U5      (       d  MB  UR                  (       d  SnUv   O4U(       a  [        XL5      (       a  Uv   OU(       d  UR                  U5          M     M     U(       d
  U Sh  vN   gUSL n[        U 5      S:X  a  U S   u  pxUR                  n	UR                  n
U H`  n[        Uc  UOU" U5      5      nUc  M  U(       a  UR                  (       a  M8  U	b  U	" U5      (       d  MJ  U
b  U
" U5      (       d  M\  Uv   Mb     gU H  n[        Uc  UOU" U5      5      nUc  M  U(       a  UR                  (       a  M8  U  HG  u  pxUR                  n	U	b  U	" U5      (       d    M^  UR                  n
U
b  U
" U5      (       d  MB  Uv     M     M     g GN GN.7f)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.
NFr   r   T)rG   r   r   r   is_prereleaser   r   )rangesiterablekeyprereleasesregionprerelease_bufferfound_finalr   r   r   r   itemr   exclude_prereleasess                 r0   r   r     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"LELLE vLLE}f
 # [ -, )s@   B6K<!KKA%KA!K(K)BK>BKKKc                `    U R                   b  U R                  SSSSS9$ U R                  SSS9$ )z=Smallest non-pre-release at or above a pre-release *version*.Nr   r   )r@   r   r   s    r0   !_nearest_release_above_prereleaser   w  s@    {{ ""t$D"MM 4t44r/   c                &   U c  [         $ [        U [        5      (       aV  U R                  nUR                  (       a  [        U5      $ UR                  b  UR                  S-   OSnUR                  USS9$ U R                  (       d  U $ [        U 5      $ )zSmallest non-pre-release version at or above *value*.

``None`` is the ``-inf`` floor, whose nearest non-pre-release is
:data:`MIN_RELEASE`.
Nr   r   )rA   r   )r   rX   r2   r:   r   r   rA   r   )valueinner_versionr   s      r0   _lowest_release_at_or_abover     s     }%))&&4]CC 1>0B0B0N]''!+TU	((it(DD,U33r/   c                    U  H\  u  p[        UR                  5      nUR                  b  X2R                  :  a    gX2R                  :X  d  MI  UR                  (       d  M\    g   g)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       r0   r   r     sN     -emm<== Gmm$;mm#  r/   c                    [        U5      n[        U5      nU S:X  a  [        US5      [        US5      4/$ [        [        US5      4[        US5      [
        4/$ )zVRanges for ==V.* and !=V.*.

==1.2.* -> [1.2.dev0, 1.3.dev0);  !=1.2.* -> complement.
==TF)r   r   r}   r   r   r   )opr   r   r   s       r0   r   r     se    
 tEd#E	TzE4(*UE*BCDD 
*UE*+	E4	 '* r/   c                    U S:X  a  [        US5      [        4/$ U S:X  a+  [        [        [	        U[
        R                  5      S5      4/$ U S:X  a  UR                  b0  UR                  UR                  S-   SS9n[        US5      [        4/$ UR                  b1  UR                  UR                  S-   SSS	9n[        US5      [        4/$ [        [	        U[
        R                  5      S
5      [        4/$ U S:X  aB  UR                  (       a  UOUR                  SSS9nU[        ::  a  / $ [        [        US
5      4/$ [	        U[
        R                  5      nU(       a  UOUnU S:X  a  [        US5      [        US5      4/$ U S:X  a$  [        [        US
5      4[        US
5      [        4/$ U S:X  a>  UR                  UR                  SS S9n[        US5      [        [        U5      S
5      4/$ [        SU < 35      e)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   r   r   Fr   r  z!=z~=r   )r>   zUnknown operator: )r}   r   r   r   r2   r"   r,   rB   r   rA   r-   r   r   r>   r   
ValueError)r  r:   	has_locallower_boundboundafter_localsr   prefixs           r0   r   r     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                b    UR                  S5      (       a  [        X5      $ [        XSU;   5      $ )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.*+)endswithr   r   )r  version_strr:   s      r0   r   r     s2     D!!r++2{(:;;r/   c                n    SnU  H  nUc  UnM
  [        X5      nU(       a  M    O   Uc  [        S5      eU$ )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)per_specifier_rangesr   subs      r0   r   r     sG     )-F#>F%f2F6 $ ~QRRMr/   c                    U  HA  u  p#UR                   nUb  U" U5      (       d    gUR                  nUb  U" U5      (       d  MA    g   g)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         r0   r   r   #  sH     U7^^=E'NN  r/   c                    U b  U $ U(       a  gg)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$   )
configuredautodetecteds     r0   r   r   6  s     r/   )r>   tuple[int, ...]rq   r  )r:   r	   rq   r	   )r:   zVersion | strrq   Version | None)r:   r	   rq   zCallable[[Version], bool])r   r2   rq   r  )r   r}   r   r   rq   rs   )r   Sequence[Interval]r   r  rq   list[Interval])r$   )r   r  r   zIterable[Any]r   z%Callable[[Any], Version | str] | Noner   bool | Noner   r  rq   zIterator[Any])r   z Version | BoundaryVersion | Nonerq   r	   )r   r  rq   rs   )r  rz   r   r	   rq   r  )r  rz   r:   r	   r  rs   rq   r  )r  rz   r  rz   r:   r	   rq   r  )r  zIterable[Sequence[Interval]]rq   r  )r   r  r:   r	   rq   rs   )r  r  r  r  rq   r  );r)   
__future__r   r*   	functoolstypingr   r   r   r:   r   r	   collections.abcr
   r   r   r   r   tuplerx   float_BoundaryOrderSuffixrt   __all__r   __annotations__r   r    Enumr"   total_orderingr2   r   r}   r   Intervalr   r   r   r=   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r$   r/   r0   <module>r*     sz   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*)@
 > "$ccc 
/c 	c
 c cL	54. B2J<6.&+6r/   