Uname:Linux developmentwebsite.ca 4.18.0-553.168.1.el8_10.x86_64 #1 SMP Thu Sep 24 18:05:46 UTC 2026 x86_64

403WebShell
403Webshell
Server IP : 173.249.148.11  /  Your IP : 216.73.216.179
Web Server : Apache/2.4.68 (AlmaLinux)
System : Linux developmentwebsite.ca 4.18.0-553.168.1.el8_10.x86_64 #1 SMP Thu Sep 24 18:05:46 UTC 2026 x86_64
User : devinter ( 1006)
PHP Version : 8.3.35
Disable Function : NONE
MySQL : ON  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : ON  |  Sudo : ON  |  Pkexec : ON
Directory :  /snap/certbot/current/lib64/python3.12/site-packages/packaging/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /snap/certbot/current/lib64/python3.12/site-packages/packaging/__pycache__/_ranges.cpython-312.pyc
�

��j�x���UdZddlmZddlZddlZddlmZmZmZddl	m
Z
mZer0ddlm
Z
mZmZmZddlmZeeeeeeefeefZeeeed	feefZgd
�Zed�Zded
<ed�Zded<ed�Zded<Gd�dej8�Zej<Gd�d��ZereeedfZ ej<Gd�d��Z!ej<Gd�d��Z"eree!e"fZ#e!dd�Z$ded<e"dd�Z%ded<e$e%ffZ&d ed!<d6d"�Z'd7d#�Z(d7d$�Z)d8d%�Z*d9d&�Z+d9d'�Z,d9d(�Z-d:d)�Z.d;d*�Z/						d<d+�Z0	d=											d>d,�Z1d7d-�Z2d?d.�Z3d@d/�Z4dAd0�Z5dBd1�Z6dCd2�Z7				dDd3�Z8dEd4�Z9						dFd5�Z:y)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_rangesz0.dev0zFinal[Version]�MIN_VERSION�0�MIN_RELEASE�infzFinal[float]�
_BOUNDARY_INFc�T�eZdZdZej
�Zej
�Zy)�BoundaryKindz5Where a boundary marker sits in the version ordering.N)�__name__�
__module__�__qualname__�__doc__�enum�auto�AFTER_LOCALS�AFTER_POSTS���M/root/parts/certbot/install/lib/python3.12/site-packages/packaging/_ranges.pyr"r"7s��?��4�9�9�;�L��$�)�)�+�Kr,r"c�T�eZdZdZdZdd�Zd
d�Zdd�Zdd�Zdd�Z	dd�Z
dd	�Zdd
�Zy)�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.
    )�_cached_dev�
_cached_epoch�_cached_post�_cached_pre�_cached_trimmed_release�kind�versionc���||_||_t|j�|_|j
|_|j|_|j|_
|j|_y�N)
r6r5�trim_release�releaser4�epochr1�prer3�postr2�devr0)�selfr6r5s   r-�__init__zBoundaryVersion.__init__VsQ�������	�'3�G�O�O�'D��$�$�]�]���"�;�;���#�L�L���"�;�;��r,c��|j|jk7ry|j}|j}t	|�}t	|�|kry|d||k7ryt|t	|��D]}||dk7s�y|j|jk7ry|jtjk(r4|j|jk(xr|j|jk(S|j|jk(xs|jduS)z6Is ``other`` a version that this boundary sorts above?FNr)r;r1r:r4�len�ranger<r3r5r"r)r=r2r>r0)r?�other�
other_release�trimmed_release�trimmed_length�is      r-�
_is_familyzBoundaryVersion._is_family_s����;�;�$�,�,�,���
�
�
��6�6���_�-���}���.����.�)�_�<���~�s�=�'9�:�	�A��Q��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��|jj}|d}|jtjk(r|d|ddt
ddf}|d|d|t
fS)a�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.
        �rr)r6�_keyr5r"r*r )r?�version_key�suffixs   r-�
_order_keyzBoundaryVersion._order_keyxs_���l�l�'�'��'2�1�~���9�9��0�0�0��Q�i����A�}�a��C�F��1�~�{�1�~�v�}�D�Dr,c�p�t|t�r!|j�|j�k(StSr8)�
isinstancer/rO�NotImplemented�r?rDs  r-�__eq__zBoundaryVersion.__eq__�s/���e�_�-��?�?�$��(8�(8�(:�:�:��r,c��t|t�r!|j�|j�kS|j|ksy|j	|�S�NF�rQr/rOr6rIrSs  r-�__lt__zBoundaryVersion.__lt__�sJ���e�_�-��?�?�$�u�'7�'7�'9�9�9����u�$���?�?�5�)�)�)r,c��t|t�r!|j�|j�kDS|j|k\ry|j	|�S)NTrWrSs  r-�__gt__zBoundaryVersion.__gt__�sG���e�_�-��?�?�$�u�'7�'7�'9�9�9��<�<�5� �����u�%�%r,c�4�t|j��Sr8)�hashrO�r?s r-�__hash__zBoundaryVersion.__hash__�s���D�O�O�%�&�&r,c�|�|jj�d|j�d|jj�d�S)N�(z, �))�	__class__r#r6r5�namer]s r-�__repr__zBoundaryVersion.__repr__�s4���.�.�)�)�*�!�D�L�L�+;�2�d�i�i�n�n�=M�Q�O�Or,N)r6r	r5r"�return�None)rDr	re�bool)re�_BoundaryOrderKey�rD�objectrerg)rDzBoundaryVersion | Versionrerg�re�int�re�str)
r#r$r%r&�	__slots__r@rIrOrTrXrZr^rdr+r,r-r/r/>s9��
��I�'�G�2E�*�*�&�'�Pr,r/c�<�eZdZdZdZd	d�Zd
d�Zdd�Zdd�Zd
d�Z	y)�
LowerBoundz�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�	inclusiver6c�D�||_||_|�d|_yt|t�rS|j
tjk(rt|j�|_yt|j�|_y|r|j|_y|j|_yr8)r6rsrrrQr/r5r"r*�_make_above_after_posts�_make_above_after_locals�__le__rX�r?r6rss   r-r@zLowerBound.__init__�su�����"����?�<@�D�K�
���
1��|�|�|�7�7�7�5�g�o�o�F���6�w���G���
�!�.�.�D�K�!�.�.�D�Kr,c��t|t�stS|j|jk(xr|j|jk(Sr8�rQrqrRr6rsrSs  r-rTzLowerBound.__eq__��7���%��,�!�!��|�|�u�}�}�,�R����5�?�?�1R�Rr,c��t|t�stS|j�|jduS|j�y|j|jk7r|j|jkS|jxr
|jSrVrzrSs  r-rXzLowerBound.__lt__�sq���%��,�!�!��<�<���=�=��,�,��=�=� ���<�<�5�=�=�(��<�<�%�-�-�/�/��~�~�5�e�o�o�"5�5r,c�D�t|j|jf�Sr8�r\r6rsr]s r-r^zLowerBound.__hash__�����T�\�\�4�>�>�2�3�3r,c�t�|jrdnd}d|jj�d|�|j�d�S)N�[r`�<� �>�rsrbr#r6�r?�brackets  r-rdzLowerBound.__repr__�s8�����#�S���4�>�>�*�*�+�1�W�I�d�l�l�5E�Q�G�Gr,N�r6�_VersionOrBoundaryrsrgrerfri)rDrqrergrkrm�
r#r$r%r&ror@rTrXr^rdr+r,r-rqrq�s)���3�I�)�(S�
6�4�Hr,rqc�<�eZdZdZdZd	d�Zd
d�Zdd�Zdd�Zd
d�Z	y)�
UpperBoundz�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.
    )�_belowrsr6c�2�||_||_|�d|_yt|t�rJ|j
tjk(rt|j�|_y|j|_y|r|j|_y|j|_yr8)r6rsr�rQr/r5r"r)�_make_below_after_locals�__ge__rZrxs   r-r@zUpperBound.__init__�sr�����"����?�<@�D�K�
���
1��|�|�|�8�8�8�6�w���G���
&�n�n���
�!�.�.�D�K�!�.�.�D�Kr,c��t|t�stS|j|jk(xr|j|jk(Sr8�rQr�rRr6rsrSs  r-rTzUpperBound.__eq__r{r,c��t|t�stS|j�y|j�y|j|jk7r|j|jkS|jxr|jS)NFTr�rSs  r-rXzUpperBound.__lt__se���%��,�!�!��<�<����=�=� ���<�<�5�=�=�(��<�<�%�-�-�/�/��>�>�!�5�e�o�o�5r,c�D�t|j|jf�Sr8r~r]s r-r^zUpperBound.__hash__rr,c�t�|jrdnd}d|jj�d|j�|�d�S)N�]rar�r�r�r�r�s  r-rdzUpperBound.__repr__!s8�����#�S���4�>�>�*�*�+�1�T�\�\�,<�W�I�Q�G�Gr,Nr�ri)rDr�rergrkrmr�r+r,r-r�r��s)���3�I�)�,S�
6�4�Hr,r�FzFinal[LowerBound]�NEG_INFzFinal[UpperBound]�POS_INFzFinal[tuple[Interval]]rc��t|�}|dkDr!||dz
dk(r|dz}|dkDr||dz
dk(r�|t|�k(r|S|d|S)zDStrip trailing zeros from a release tuple for normalized comparison.rrN)rB)r:�ends  r-r9r90s`��

�g�,�C�

��'�g�c�A�g�&�!�+��q�����'�g�c�A�g�&�!�+��S��\�)�7�<�w�t��}�<r,c��g|jdd�|jddz��}tj|j|d��S)z5Smallest version in the next prefix: 1.2 -> 1.3.dev0.N���rr�r;r:r>)r:r	�
from_partsr;)r6r:s  r-�_next_prefix_dev0r�8sC��>������$�>�g�o�o�b�&9�A�&=�>�G����G�M�M�7��J�Jr,c�Z�tj|j|jd��S)z7The .dev0 of a version's base release: 1.2 -> 1.2.dev0.rr�)r	r�r;r:�r6s r-�
_base_dev0r�>s �����G�M�M�7�?�?�PQ�R�Rr,c�`�t|t�s	t|�}|S|S#t$rYywxYwr8)rQr	rr�s r-rrCs:���g�w�'�	��g�&�G��N�7�N���	��	�s�!�	-�-c�������|j�|j�|j�t|j��t���d�����fd�}|S)aPredicate ``parsed > AFTER_POSTS(V)`` for a lower bound.

    Per PEP 440, ``>V`` excludes V's post-releases unless V is itself
    a post-release. AFTER_POSTS sits above V and every V.postN (with
    or without local), and just below the next release.
    c�����|�ry|j�k7ry|j}t|��kry|d��k7ryt�t|��D]}||dk7s�y|j�k7ryy�NFTr)r;r:rBrCr<)�parsed�parsed_releaserHrG�
version_epoch�
version_ge�version_pre�version_release_trimmeds   �����r-�abovez&_make_above_after_posts.<locals>.aboveYs�����f����<�<�=�(�������~���/���/�>�*�.E�E���~�s�>�':�;�	�A��a� �A�%��	��:�:��$��r,�r�r	rerg)r�r;r<r9r:rB)r6r�rGr�r�r�r�s  @@@@@r-ruruLsK������J��M�M�M��+�+�K�*�7�?�?�;���0�1�N���0�Lr,c����������|j�|j�|j�|j�|j�t|j��t���d�������fd�}|S)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�$���|�ry|j�k7ry|j}t|��kry|d��	k7ryt�t|��D]}||dk7s�y|j�k7ry|j
�k7ry|j�k7Sr��r;r:rBrCr<r=r>�
r�r�rHrG�version_devr�r��version_postr�r�s
   �������r-r�z'_make_above_after_locals.<locals>.above�s�����f����<�<�=�(�������~���/���/�>�*�.E�E���~�s�>�':�;�	�A��a� �A�%��	��:�:��$���;�;�,�&���z�z�[�(�(r,r��r�r;r<r=r>r9r:rB)	r6r�rGr�r�r�r�r�r�s	  @@@@@@@r-rvrvt�]������J��M�M�M��+�+�K��<�<�L��+�+�K�*�7�?�?�;���0�1�N�)�)�*�Lr,c����������|j�|j�|j�|j�|j�t|j��t���d�������fd�}|S)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�$���|�ry|j�k7ry|j}t|��kry|d��	k7ryt�t|��D]}||dk7s�y|j�k7ry|j
�k7ry|j�k(S)NTFrr�r�s
   �������r-�belowz'_make_below_after_locals.<locals>.below�s�����f����<�<�=�(�������~���/���/�>�*�.E�E���~�s�>�':�;�	�A��a� �A�%��	��:�:��$���;�;�,�&���z�z�[�(�(r,r�r�)	r6r�rGr�r�r�r�r�r�s	  @@@@@@@r-r�r��r�r,c�z�|j}|jtjk(r]|j� |j|jdzd��S|j�|jdznd}|j|dd��S|j�)|j\}}|j||dzfddd��Sy)zLSmallest real version strictly above *boundary*, or ``None`` if none exists.Nr�r>�localr�r=r>r��r<r=r>r�)r6r5r"r)r>�__replace__r=r<)�boundary�base�	next_postr5�numbers     r-rr�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���f����T�6�A�:�$6�T�q�PT��U�U�r,c��|j�y|j�>|jxr/t|jt�xr|jtkSt|jt
�rBt
|j�}|�+|j|k(r
|jS|j|kS|j|jk(r|jxr|jS|j|jkDS)aTrue when the range defined by *lower* and *upper* contains no versions.

    A boundary lower sits just below the next real version, so an ordered pair
    is still empty when the upper excludes that least successor:
    ``(AFTER_POSTS(1.0a1), 1.0a2.dev0)`` holds no version.
    F)r6rsrQr	rr/r)�lower�upper�	successors   r-rr�s���
�}�}����}�}������
-��5�=�=�'�2�
-��
�
��,�	
��%�-�-��1�'��
�
�6�	�� ��}�}�	�)� �?�?�*�*��=�=�9�,�,��}�}��
�
�%��O�O�7����8�8��=�=�5�=�=�(�(r,c�2�g}dx}}|t|�kr�|t|�krt||\}}||\}}t||�}	t||�}
t|	|
�s|j	|	|
f�||kr|dz
}n|dz
}|t|�kr|t|�kr�t|S)zFIntersect two sorted, non-overlapping range lists (two-pointer merge).rr)rB�max�minr�append)�left�right�result�
left_index�right_index�
left_lower�
left_upper�right_lower�right_upperr�r�s           r-rr�s���
 �F� � �J��
�s�4�y�
 �[�3�u�:�%=�!%�j�!1��
�J�#(��#5� ��[��J��,���J��,���e�U�+��M�M�5�%�.�)���#��!�O�J��1��K��s�4�y�
 �[�3�u�:�%=� �Mr,c#�K�|��Mg}d}t|�dk(r�|d\}}|j}	|j}
|D]j}t|�|n||��}|��|	�	|	|�s�&|
�	|
|�s�1|jsd}|���D|rt||�r|���W|r�Z|j
|��l|s
|Ed{���y|D]�}t|�|n||��}|��|D]n\}}|j}	|	�
|	|�s�;|j}
|
�	|
|�s�5|jsd}|��n&|rt||�r|��n|s|j
|�����|s
|Ed{���y|du}
t|�dk(ri|d\}}|j}	|j}
|D]C}t|�|n||��}|��|
r
|jr�*|	�	|	|�s�5|
�	|
|�s�@|���Ey|D]g}t|�|n||��}|��|
r
|jr�*|D]9\}}|j}	|	�
|	|�s�J|j}
|
�	|
|�s�5|���g�iy7���7��w)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.
    NFrrT)rBrrr�r�
is_prereleaserr�)�ranges�iterable�key�prereleases�region�prerelease_buffer�found_finalr�r�r�r��itemr��exclude_prereleasess              r-rrs�������')�����v�;�!��"�!�9�L�E�5��L�L�E��L�L�E� �
3��'�����T��K���>���$�U�6�]���$�U�6�]���+�+�"&�K��J�� 3�F�F� C��J�$�%�,�,�T�2�
3��,�,�,���	�D�#�C�K�D�S��Y�G�F��~�� &�

���u������$�U�6�]�������=�E�&�M�!�/�/�&*��"�
��$7���$G�"�
�(�)�0�0��6��

�		�$�(�(�(��%��.��
�6�{�a���a�y���u����������		�D�#�C�K�D�S��Y�G�F��~��"�v�';�';��� ��v����}��f�
��
�		�	��
�������T��C���>���6�#7�#7��"�	�L�E�5��L�L�E�� ��v����L�L�E��}��f�
��
��	�

�[-��,
)�s@�BI�I�.H;�/AI�AI�
H>�A8I�A)I�1I�>Ic�j�|j�|jdddd��S|jdd��S)z=Smallest non-pre-release at or above a pre-release *version*.Nr�r�)r<r�r�s r-�!_nearest_release_above_prereleaser�ws@���{�{���"�"�t�$�D��"�M�M����4�t��4�4r,c�
�|�tSt|t�rS|j}|jrt|�S|j�|jdznd}|j|d��S|js|St|�S)z�Smallest non-pre-release version at or above *value*.

    ``None`` is the ``-inf`` floor, whose nearest non-pre-release is
    :data:`MIN_RELEASE`.
    Nrr)r=r�)rrQr/r6r�r�r=r�)�value�
inner_versionr�s   r-�_lowest_release_at_or_abover��s���
�}����%��)��
�
�
��&�&�4�]�C�C�1>�0B�0B�0N�]�'�'�!�+�TU�	��(�(�i�t�(�D�D������,�U�3�3r,c��|D]U\}}t|j�}|j�||jkry||jk(s�H|js�Uyy)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�r6rs)r�r�r��nearests    r-rr�sW������u�-�e�m�m�<���=�=� �G�e�m�m�$;���e�m�m�#������r,c��t|�}t|�}|dk(rt|d�t|d�fgStt|d�ft|d�t
fgS)z^Ranges for ==V.* and !=V.*.

    ==1.2.* -> [1.2.dev0, 1.3.dev0);  !=1.2.* -> complement.
    �==TF)r�r�rqr�r�r�)�opr�r�r�s    r-rr�se��

�t��E��d�#�E�	�T�z��E�4�(�*�U�E�*B�C�D�D�
�*�U�E�*�+�	�E�4�	 �'�*��r,c���|dk(rt|d�tfgS|dk(r+ttt	|t
j�d�fgS|dk(r�|j�3|j|jdzd��}t|d�tfgS|j�4|j|jdzdd�	�}t|d�tfgStt	|t
j�d
�tfgS|dk(r?|jr|n|jdd��}|tkrgStt|d
�fgSt	|t
j�}|r|n|}|dk(rt|d�t|d�fgS|d
k(r$tt|d
�ft|d
�tfgS|dk(rA|j|jdd��}t|d�tt|�d
�fgStd|����)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�Nrr�rr�Fr�r�z!=z~=r�)r:zUnknown operator: )rqr�r�r�r/r"r)r>r�r=r*r�rr:r��
ValueError)r�r6�	has_local�lower_bound�bound�after_localsr��prefixs        r-rr�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�Z�|jd�rt||�St||d|v�S)aDRanges for one specifier's ``(op, version_str)``.

    Dispatches between the wildcard and standard builders. ``version`` is the
    parsed ``version_str`` (its base, without the trailing ``.*``, for
    wildcards). ``===`` is not handled here; its match is a literal string
    compared in :mod:`packaging.specifiers`.
    z.*�+)�endswithrr)r��version_strr6s   r-rr�s3�����D�!��r�7�+�+��2�w��{�(:�;�;r,c�\�d}|D]}|�|}�t||�}|r�n|�td��|S)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   r-rrsL��)-�F�#����>��F�%�f�c�2�F���
��~��Q�R�R��Mr,c�x�|D]5\}}|j}|�
||�sy|j}|�	||�s�5yy)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)rrr�)r�r6r�r�r�r�s      r-rr#sK������u�������U�7�^�������=�E�'�N���r,c��|�|S|ryy)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  r-rr6s��������r,)r:�tuple[int, ...]rer�)r6r	rer	)r6z
Version | strre�Version | None)r6r	rezCallable[[Version], bool])r�r/rer�)r�rqr�r�rerg)r��Sequence[Interval]r�rre�list[Interval])r+)r�rr�z
Iterable[Any]r�z%Callable[[Any], Version | str] | Noner��bool | Noner�rrez
Iterator[Any])r�z Version | BoundaryVersion | Nonerer	)r�rrerg)r�rnr�r	rer)r�rnr6r	r�rgrer)r�rnr�rnr6r	rer)r�zIterable[Sequence[Interval]]rer)r�rr6r	rerg)r�rr�rrer);r&�
__future__rr'�	functools�typingrrrr6rr	�collections.abcr
rrr
r�tuplerl�float�_BoundaryOrderSuffixrh�__all__r�__annotations__rr �Enumr"�total_orderingr/r�rqr��Intervalr�r�rr9r�r�rrurvr�rrrrr�r�rrrrrrrr+r,r-�<module>rsz��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�����lP�lP��lP�^��w���=�>�����5H�5H��5H�p���7H�7H��7H�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�.�
� B2�J<��6����.�&���+6���r,

Youez - 2016 - github.com/yon3zu
LinuXploit