ó
    ÷Þ j‚x  ã                  ó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)ÚBoundaryKindé7   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/var/www/html/gaurav/venv/lib/python3.13/site-packages/packaging/_ranges.pyr"   r"   7   s   † Ù?à—9’9“;€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   € ØŒØŒ	Ü'3°G·O±OÓ'DˆÔ$Ø$Ÿ]™]ˆÔØ"Ÿ;™;ˆÔØ#ŸL™LˆÔØ"Ÿ;™;ˆÕ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Õ$Ùñ ;ð �9‰9˜×(Ñ(Ó(ØØ�9‰9œ×1Ñ1Ó1à—:‘: ×!2Ñ!2Ñ2×T°u·y±yÀD×DTÑDTÑ7TÐTà�y‰y˜D×,Ñ,Ñ,×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_   € ð —l‘l×'Ñ'ˆØ'2°1¡~ˆà�9‰9œ×0Ñ0Ó0Ø˜Q‘i ¨¡¨A¬}¸aÀÐCˆFà˜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   € ä�D—O‘OÓ%Ó&Ð&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   € Ø—.‘.×)Ñ)Ð*¨!¨D¯L©LÑ+;¸2¸d¿i¹i¿n¹nÐ=MÈQÐ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é²   z²Lower 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   € ØŒØ"Œð ‰?Ø<@ˆD�KÜ˜¤×1Ñ1ð �|‰|œ|×7Ñ7Ó7Ü5°g·o±oÓF�•ä6°w·±ÓG�•ÞØ!Ÿ.™.ˆD�Kà!Ÿ.™.ˆD�Kr/   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Ÿ=™=Ó(Ø—<‘< %§-¡-Ñ/Ð/à�~‰~×5 e§o¡oÔ"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—>‘>×*Ñ*Ð+¨1¨W¨I°d·l±lÑ5EÀQÐ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)   † ñð 3€Iô)ô(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éë   z°Upper 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   € ØŒØ"Œð ‰?Ø<@ˆD�KÜ˜¤×1Ñ1ð �|‰|œ|×8Ñ8Ó8Ü6°w·±ÓG�•ð
 &Ÿn™n�•ÞØ!Ÿ.™.ˆD�Kà!Ÿ.™.ˆD�Kr/   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Ÿ=™=Ó(Ø—<‘< %§-¡-Ñ/Ð/à—>‘>Ô!×5 e§o¡oÐ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—>‘>×*Ñ*Ð+¨1¨T¯\©\Ñ,<¸W¸IÀQÐGÐGr/   Nrš   ru   )rI   rž   rq   rs   rw   ry   rœ   r$   r/   r0   rž   rž   ë   s)   † ñð 3€Iô)ô,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Ø
�‹'�g A™gÑ&¨!Ó+Øˆq‰ˆð �‹'�g A™gÑ&¨!Õ+àœS ›\Ó)ˆ7Ð<¨w°t¸¨}Ð<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.Néÿÿÿÿr   r   ©r?   r>   rB   )r>   r	   Ú
from_partsr?   )r:   r>   s     r0   Ú_next_prefix_dev0r·   8  sC   € à>�—‘  Ð$Ð> g§o¡o°bÑ&9¸AÑ&=Ñ>€GÜ×Ò G§M¡M¸7ÈÑ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    € ä×Ò G§M¡M¸7¿?¹?Ð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=   € Ü�gœw×'Ñ'ð	Ü˜gÓ&ˆGð €Nˆ7€Nøô ó 	Ùð	ú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$ )zñPredicate ``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Ø—M‘M€MØ—+‘+€KÜ*¨7¯?©?Ó;ÐÜÐ0Ó1€N÷ó ð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$ )zÎPredicate ``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Õ%Ùñ <ð �:‰:˜Ó$ØØ�;‰;˜,Ó&ØØ�z‰z˜[Ñ(Ð(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Ø—M‘M€MØ—+‘+€KØ—<‘<€LØ—+‘+€KÜ*¨7¯?©?Ó;ÐÜÐ0Ó1€N÷)õ )ð* €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$ )zÛPredicate ``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Õ%Ùñ <ð �:‰:˜Ó$ØØ�;‰;˜,Ó&ØØ�z‰z˜[Ñ(Ð(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ð �8‰8ÑØ×#Ñ#¨¯©°1©¸DÐ#ÐAÐAØ'+§y¡yÑ'<�T—Y‘Y ’]À!ˆ	Ø×Ñ Y°A¸TÐÐBÐBð ‡x�xÑØ—x‘x‰ˆØ×Ñ T°A©:Ð$6¸TÀqÐPTÐÐ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Ñ,Ð,à‡}�}˜Ÿ™Ó%Ø—O‘O×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
[        Xš5      (       d  UR	                  Xš4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Ø
”s˜4“yÓ
  [´3°u³:Ó%=Ø!%Ñ!1Ñˆ
Ø#(Ñ#5Ñ ˆä�JÓ,ˆÜ�JÓ,ˆä˜e×+Ñ+Ø�M‰M˜5˜.Ô)ð Ó#Ø˜!‰O‰Jà˜1ÑˆKð ”s˜4“yÓ
  [´3°u³:Õ%=ð  €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‹;˜!Óð " !™9‰LˆEØ—L‘LˆEØ—L‘LˆEÛ �Ü'°±©ÁÀTÃÓK�Ø‘>ÙØÑ$©U°6¯]©]ÙØÑ$©U°6¯]©]ÙØ×+×+Ø"&�KØ”JÞÔ 3°F× CÑ CØ”Jß$˜Ø%×,Ñ,¨TÖ2ñ !ö Ø,×,Ð,ØãˆDÜ#¨C©K¡D¹SÀ»YÓGˆFØ‰~ÙÛ &‘�ØŸ™�ØÑ$©U°6¯]©]ÚØŸ™�Ø‘=¡E¨&§M£MØ!×/×/Ø&*˜Ø"›
ÞÔ$7¸×$GÑ$GØ"›
Þ(Ø)×0Ñ0°Ô6Úó !'ñ	 ö$ Ø(×(Ð(Øà%¨Ð.Ðä
ˆ6ƒ{�aÓð ˜a‘y‰ˆØ—‘ˆØ—‘ˆÛˆDÜ#¨C©K¡D¹SÀ»YÓGˆFØ‰~ÙÞ" v×';×';ÙØÑ ©¨v¯©ÙØ‰}¡ f§£Ø”
ñ ð 	ãˆÜ¨©¡¹¸T»ÓCˆØ‰>ÙÞ 6×#7×#7ÙÛ"‰LˆEØ—L‘LˆEØÑ ©¨v¯©ÚØ—L‘LˆEØ‰}¡ 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ð ×Ñ 4¨tÐÐ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      $ )z�Smallest 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>×0BÑ0BÑ0N�]×'Ñ'¨!Ò+ÐTUˆ	Ø×(Ñ(¨i¸tÐ(Ð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)zÐTrue 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   € ó ‰ˆÜ-¨e¯m©mÓ<ˆØ�=‰=Ñ  G¯m©mÓ$;ÙØ—m‘mÕ#¨¯¯©Ùñ ð 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Ø	ˆTƒzÜ˜E 4Ó(¬*°U¸EÓ*BÐCÐDÐDô 
”*˜U EÓ*Ð+Ü	�E˜4Ó	 ¤'Ð*ðð 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)zîRanges 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(  € ð 
ˆTƒzÜ˜G TÓ*¬GÐ4Ð5Ð5à	ˆTƒzô Üœ?¨7´L×4MÑ4MÓNÐPTÓUðð
ð 	
ð 
ˆSƒyØ�;‰;Ñ"ð "×-Ñ-°'·+±+À±/ÈÐ-ÐNˆKÜ ¨TÓ2´GÐ<Ð=Ð=Ø�<‰<Ñ#à!×-Ñ-°7·<±<À!Ñ3CÈÐRVÐ-ÐWˆKÜ ¨TÓ2´GÐ<Ð=Ð=ô
 œ?¨7´L×4LÑ4LÓMÈuÓUÜðð
ð 	
ð 
ˆSƒyð ×,×,‰G°'×2EÑ2EÈ!ÐSWÐ2EÐ2Xð 	ð ”KÓØˆIÜœ* U¨EÓ2Ð3Ð4Ð4ô # 7¬L×,EÑ,EÓF€LÞ ‰G l€Eà	ˆTƒzÜ˜G TÓ*¬J°u¸dÓ,CÐDÐEÐEà	ˆTƒzä”j ¨%Ó0Ð1Ü˜˜uÓ%¤wÐ/ð
ð 	
ð
 
ˆTƒzØ×$Ñ$¨W¯_©_¸S¸bÐ-AÐ$ÐBˆä˜ Ó&¬
Ô3DÀVÓ3LÈeÓ(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$ )zÄIntersect 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Ó2ˆFß�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   € ó ‰ˆØ—‘ˆØÑ¡U¨7§^¡^Ùà—‘ˆØ‰=™E 'ŸN›NÙñ ð r/   c                ó   • U b  U $ U(       a  gg)zÒResolve 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Ýð !  c¨3°°c¸5°jÑ0AÀ3ÈÐ!KÑLÐØ˜c 5¨¨c¨¡?Ð4HÈ%ÐOÑPÐò€ñ" & hÓ/€ˆ^Ó /ñ & c›l€ˆ^Ó *ñ $ E›l€ˆ|Ó *ô�4—9‘9ô ð ×Ñ÷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2ôJ<ðØ6ðàôô.ð&ØðØ+6ðàõr/   