ok

Mini Shell

Direktori : /opt/cloudlinux/venv/lib/python3.11/site-packages/distlib/__pycache__/
Upload File :
Current File : //opt/cloudlinux/venv/lib/python3.11/site-packages/distlib/__pycache__/version.cpython-311.pyc

�

�܋f�\����dZddlZddlZddlmZddlmZgd�Zeje	��Z
Gd�de��ZGd	�d
e
��ZGd�de
��Zejd
ej��Zd�ZeZGd�de��Zd�ZGd�de��Zejd��dfejd��dfejd��dfejd��dfejd��dfejd��dfejd��dfejd ��d!fejd"��d#fejd$��d%ff
Zejd&��dfejd'��dfejd(��dfejd��dfejd)��dffZejd*��Zd+�Zd,�Zejd-ej��Zd.d.d/d.d0ddd1�Zd2�ZGd3�d4e��Z Gd5�d6e��Z!ejd7ej��Z"d8�Z#d9�Z$Gd:�d;e��Z%Gd<�d=e��Z&Gd>�d?e
��Z'e'eee��e'ee!d@���e'e$e&e��dA�Z(e(dBe(dC<dD�Z)dS)Ez~
Implementation of a flexible versioning scheme providing support for PEP-440,
setuptools-compatible and semantic versioning.
�N�)�string_types��parse_requirement)�NormalizedVersion�NormalizedMatcher�
LegacyVersion�
LegacyMatcher�SemanticVersion�SemanticMatcher�UnsupportedVersionError�
get_schemec��eZdZdZdS)r
zThis is an unsupported version.N)�__name__�
__module__�__qualname__�__doc__���`/builddir/build/BUILD/cloudlinux-venv-1.0.6/venv/lib/python3.11/site-packages/distlib/version.pyr
r
s������)�)��Drr
c�l�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zed
���ZdS)�Versionc���|���x|_}|�|��x|_}t	|t
��sJ�t
|��dksJ�dS)Nr)�strip�_string�parse�_parts�
isinstance�tuple�len)�self�s�partss   r�__init__zVersion.__init__sY���7�7�9�9�$���q�"�j�j��m�m�+���e��%��'�'�'�'�'��5�z�z�A�~�~�~�~�~�~rc� �td���)Nzplease implement in a subclass��NotImplementedError�r!r"s  rrz
Version.parse%s��!�"B�C�C�Crc�p�t|��t|��krtd|�d|�����dS�Nzcannot compare z and )�type�	TypeError�r!�others  r�_check_compatiblezVersion._check_compatible(s<����:�:��e���$�$��)�$�$�$���F�G�G�G�%�$rc�L�|�|��|j|jkS�N�r/rr-s  r�__eq__zVersion.__eq__,s%�����u�%�%�%��{�e�l�*�*rc�.�|�|��Sr1�r3r-s  r�__ne__zVersion.__ne__0����;�;�u�%�%�%�%rc�L�|�|��|j|jkSr1r2r-s  r�__lt__zVersion.__lt__3s%�����u�%�%�%��{�U�\�)�)rc�X�|�|��p|�|��Sr1�r9r3r-s  r�__gt__zVersion.__gt__7s(���K�K��&�&�<�$�+�+�e�*<�*<�=�=rc�V�|�|��p|�|��Sr1r;r-s  r�__le__zVersion.__le__:�%���{�{�5�!�!�7�T�[�[��%7�%7�7rc�V�|�|��p|�|��Sr1)r<r3r-s  r�__ge__zVersion.__ge__=r?rc�*�t|j��Sr1)�hashr�r!s r�__hash__zVersion.__hash__As���D�K� � � rc�0�|jj�d|j�d�S)Nz('z')��	__class__rrrDs r�__repr__zVersion.__repr__Ds��!�^�4�4�4�d�l�l�l�C�Crc��|jSr1�rrDs r�__str__zVersion.__str__G�
���|�rc� �td���)NzPlease implement in subclasses.r&rDs r�
is_prereleasezVersion.is_prereleaseJs��!�"C�D�D�DrN)rrrr$rr/r3r6r9r<r>rArErIrL�propertyrOrrrrrs����������D�D�D�H�H�H�+�+�+�&�&�&�*�*�*�>�>�>�8�8�8�8�8�8�!�!�!�D�D�D�����E�E��X�E�E�Errc	��eZdZdZd�d�d�d�d�d�d�d	�d
�Zd�Zd�Zd
�Zed���Z	d�Z
d�Zd�Zd�Z
d�Zd�ZdS)�MatcherNc��||kSr1r��v�c�ps   r�<lambda>zMatcher.<lambda>T�
��Q��U�rc��||kSr1rrTs   rrXzMatcher.<lambda>UrYrc��||kp||kSr1rrTs   rrXzMatcher.<lambda>V���a�1�f�o��A��rc��||kp||kSr1rrTs   rrXzMatcher.<lambda>Wr\rc��||kSr1rrTs   rrXzMatcher.<lambda>X�
��a�1�f�rc��||kSr1rrTs   rrXzMatcher.<lambda>Ys
��q�A�v�rc��||kp||kSr1rrTs   rrXzMatcher.<lambda>[r\rc��||kSr1rrTs   rrXzMatcher.<lambda>\r_r)�<�>�<=�>=�==�===�~=�!=c� �t|��Sr1rr(s  rrzMatcher.parse_requirementas�� ��#�#�#rc�Z�|j�td���|���x|_}|�|��}|std|z���|j|_|j���|_g}|jr�|jD]�\}}|�	d��r8|dvrtd|z���|dd�d}}|�|��n|�|��d}}|�
|||f����t|��|_dS)	NzPlease specify a version classz
Not valid: %rz.*)rgrjz#'.*' not allowed for %r constraints���TF)
�
version_class�
ValueErrorrrr�name�lower�key�constraints�endswith�appendrr)r!r"�r�clist�op�vn�prefixs       rr$zMatcher.__init__dsM����%��=�>�>�>��7�7�9�9�$���q��"�"�1�%�%���	2��_�q�0�1�1�1��F��	��9�?�?�$�$������=�	/���
/�
/���A��:�:�d�#�#�>���-�-�(�*:�<>�*?�@�@�@�"#�3�B�3����B��&�&�r�*�*�*�*�"&�!3�!3�A�!6�!6���B����b�"�f�-�.�.�.�.��E�l�l����rc�X�t|t��r|�|��}|jD]w\}}}|j�|��}t|t��rt
||��}|s |�d|jj��}t|���||||��sdS�xdS)z�
        Check if the provided version matches the constraints.

        :param version: The version to match against this instance.
        :type version: String or :class:`Version` instance.
        z not implemented for FT)
rrrnr�
_operators�get�getattrrHrr')r!�version�operator�
constraintrz�f�msgs       r�matchz
Matcher.match�s����g�|�,�,�	2��(�(��1�1�G�,0�K�		�		�(�H�j�&���#�#�H�-�-�A��!�\�*�*�
%��D�!�$�$���
/�#+�8�8�T�^�-D�-D�F��)�#�.�.�.��1�W�j�&�1�1�
��u�u�
��trc��d}t|j��dkr(|jdddvr|jdd}|S)Nrr)rgrh)r r)r!�results  r�
exact_versionzMatcher.exact_version�sF�����t�{���q� � �T�[��^�A�%6�-�%G�%G��[��^�A�&�F��
rc��t|��t|��ks|j|jkrtd|�d|�����dSr*)r+rpr,r-s  rr/zMatcher._check_compatible�sK����:�:��e���$�$��	�U�Z�(?�(?��)�$�$�$���F�G�G�G�)@�(?rc�l�|�|��|j|jko|j|jkSr1)r/rrrr-s  rr3zMatcher.__eq__�s3�����u�%�%�%��x�5�9�$�D�����)D�Drc�.�|�|��Sr1r5r-s  rr6zMatcher.__ne__�r7rc�T�t|j��t|j��zSr1)rCrrrrDs rrEzMatcher.__hash__�s���D�H�~�~��T�[� 1� 1�1�1rc�0�|jj�d|j�d�S)N�(�)rGrDs rrIzMatcher.__repr__�s���>�2�2�2�D�L�L�L�A�Arc��|jSr1rKrDs rrLzMatcher.__str__�rMr)rrrrnr|rr$r�rPr�r/r3r6rErIrLrrrrRrROs�������M�#�
"�
"�
"�-�-�-�-�$�$�%�%�-�-�$�$�
�
�J�$�$�$�#�#�#�:���*����X��H�H�H�E�E�E�&�&�&�2�2�2�B�B�B�����rrRz�^v?(\d+!)?(\d+(\.\d+)*)((a|alpha|b|beta|c|rc|pre|preview)(\d+)?)?(\.(post|r|rev)(\d+)?)?([._-]?(dev)(\d+)?)?(\+([a-zA-Z\d]+(\.[a-zA-Z\d]+)?))?$c��|���}t�|��}|std|z���|���}td�|d�d��D����}t|��dkr5|ddkr)|dd�}t|��dkr|ddk�)|dsd}nt|ddd���}|dd�}|d	d
�}|dd�}|d
}|dkrd}n0|d�|ddf}n|dt|d��f}|dkrd}n0|d�|ddf}n|dt|d��f}|dkrd}n0|d�|ddf}n|dt|d��f}|�d}nhg}	|�d��D]A}
|
�	��rdt|
��f}
nd|
f}
|	�
|
���Bt|	��}|s	|s|rd}nd}|sd}|sd}||||||fS)NzNot a valid version: %sc3�4K�|]}t|��V��dSr1��int��.0rUs  r�	<genexpr>z_pep_440_key.<locals>.<genexpr>�s(����6�6�A��Q���6�6�6�6�6�6rr�.���r����	�
��
)NNr)�ar�)�z)�_)�final)r�PEP440_VERSION_REr�r
�groupsr�splitr r��isdigitru)r"�mr��nums�epoch�pre�post�dev�localr#�parts           r�_pep_440_keyr��s���	���	�	�A�����"�"�A��E�%�&?�!�&C�D�D�D�
�X�X�Z�Z�F��6�6�������!5�!5�6�6�6�6�6�D�

�d�)�)�a�-�-�D��H��M�M��C�R�C�y���d�)�)�a�-�-�D��H��M�M��!�9�$�����F�1�I�c�r�c�N�#�#��
��1��+�C��!�A�#�;�D�
��B��-�C��2�J�E�
�l�������q�6�>��a�&�!�)�C�C��a�&�#�c�!�f�+�+�%�C��|��������7�?���7�A�:�D�D���7�C��Q��L�L�(�D�
�l�������q�6�>��a�&�!�)�C�C��a�&�#�c�!�f�+�+�%�C��}�������K�K��$�$�	�	�D��|�|�~�~�
!��3�t�9�9�~����4�y���L�L�������e�������	��	��C�C��C����������$��T�3��-�-rc�H�eZdZdZd�Zegd���Zed���ZdS)raIA rational version.

    Good:
        1.2         # equivalent to "1.2.0"
        1.2.0
        1.2a1
        1.2.3a2
        1.2.3b1
        1.2.3c1
        1.2.3.4
        TODO: fill this out

    Bad:
        1           # minimum two numbers
        1.2a        # release level must have a release serial
        1.2.3b
    c���t|��}t�|��}|���}t	d�|d�d��D����|_|S)Nc3�4K�|]}t|��V��dSr1r�r�s  rr�z*NormalizedVersion.parse.<locals>.<genexpr>s(����$J�$J��S��V�V�$J�$J�$J�$J�$J�$Jrrr�)�_normalized_keyr�r�r�rr��_release_clause)r!r"r�r�r�s     rrzNormalizedVersion.parsese�� ��#�#��

�#�#�A�&�&��������$�$J�$J�V�A�Y�_�_�S�5I�5I�$J�$J�$J�J�J����
r)r��brV�rcr�c�D��t�fd��jD����S)Nc3�:�K�|]}|�|d�jvV��dS)rN)�PREREL_TAGS)r��tr!s  �rr�z2NormalizedVersion.is_prerelease.<locals>.<genexpr>!s4�����F�F��A�F�1�Q�4�4�+�+�F�F�F�F�F�Fr)�anyrrDs`rrOzNormalizedVersion.is_prereleases(����F�F�F�F�T�[�F�F�F�F�F�FrN)	rrrrr�setr�rPrOrrrrrsc��������"	�	�	��#�2�2�2�3�3�K�
�G�G��X�G�G�Grrc��t|��}t|��}||krdS|�|��sdSt|��}||dkS)NTFr�)�str�
startswithr )�x�y�ns   r�
_match_prefixr�$sV���A���A��A���A��A�v�v��t��<�<��?�?���u��A���A��Q�4�3�;�rc	�^�eZdZeZddddddddd	�Zd
�Zd�Zd�Zd
�Z	d�Z
d�Zd�Zd�Z
d�ZdS)r�_match_compatible�	_match_lt�	_match_gt�	_match_le�	_match_ge�	_match_eq�_match_arbitrary�	_match_ne)rircrdrerfrgrhrjc���|rd|vo|jd}n|jdo|jd}|r6|j�dd��d}|�|��}||fS)N�+r�rr)rrr�rn)r!rr�rz�strip_localr"s      r�
_adjust_localzNormalizedMatcher._adjust_local>s����	K��Z�/�F�G�N�2�4F�K�K�)�/��3�3�J���r�8J�K��	,���%�%�c�1�-�-�a�0�A��(�(��+�+�G��
�"�"rc��|�|||��\}}||krdS|j}d�d�|D����}t||��S)NFr�c�,�g|]}t|����Sr�r��r��is  r�
<listcomp>z/NormalizedMatcher._match_lt.<locals>.<listcomp>Q���7�7�7�1��A���7�7�7r�r�r��joinr��r!rr�rz�release_clause�pfxs      rr�zNormalizedMatcher._match_ltL�i��"�0�0��*�f�M�M�����j� � ��5�#�3���h�h�7�7��7�7�7�8�8�� ��#�.�.�.�.rc��|�|||��\}}||krdS|j}d�d�|D����}t||��S)NFr�c�,�g|]}t|����Srr�r�s  rr�z/NormalizedMatcher._match_gt.<locals>.<listcomp>Yr�rr�r�s      rr�zNormalizedMatcher._match_gtTr�rc�B�|�|||��\}}||kSr1�r��r!rr�rzs    rr�zNormalizedMatcher._match_le\�)��"�0�0��*�f�M�M�����*�$�$rc�B�|�|||��\}}||kSr1r�r�s    rr�zNormalizedMatcher._match_ge`r�rc�l�|�|||��\}}|s||k}nt||��}|Sr1�r�r��r!rr�rzr�s     rr�zNormalizedMatcher._match_eqdsF��"�0�0��*�f�M�M�����	8���+�F�F�"�7�J�7�7�F��
rc�B�t|��t|��kSr1r�r�s    rr�z"NormalizedMatcher._match_arbitraryls���7�|�|�s�:���.�.rc�n�|�|||��\}}|s||k}nt||��}|Sr1r�r�s     rr�zNormalizedMatcher._match_neosI��"�0�0��*�f�M�M�����	<���+�F�F�&�w�
�;�;�;�F��
rc��|�|||��\}}||krdS||krdS|j}t|��dkr
|dd�}d�d�|D����}t	||��S)NTFrr�r�c�,�g|]}t|����Srr�r�s  rr�z7NormalizedMatcher._match_compatible.<locals>.<listcomp>�r�r)r�r�r r�r�r�s      rr�z#NormalizedMatcher._match_compatiblews���"�0�0��*�f�M�M�����j� � ��4��Z����5�$�3���~����"�"�+�C�R�C�0�N��h�h�7�7��7�7�7�8�8���W�c�*�*�*rN)rrrrrnr|r�r�r�r�r�r�r�r�r�rrrrr/s�������%�M�"�
�
����!��	�	�J�#�#�#�/�/�/�/�/�/�%�%�%�%�%�%����/�/�/����+�+�+�+�+rrz[.+-]$�z^[.](\d)z0.\1z^[.-]z
^\((.*)\)$�\1z^v(ersion)?\s*(\d+)z\2z^r(ev)?\s*(\d+)z[.]{2,}r�z\b(alfa|apha)\b�alphaz\b(pre-alpha|prealpha)\bz	pre.alphaz	\(beta\)$�betaz
^[:~._+-]+z
[,*")([\]]z[~:+_ -]z\.$z
(\d+(\.\d+)*)c���|������}tD]\}}|�||��}�|sd}t�|��}|sd}|}�n%|���d�d��}d�|D��}t|��dkr(|�	d��t|��dk�(t|��dkr||�
��d�}nNd�d�|dd�D����||�
��d�z}|dd�}d�d�|D����}|���}|r#tD]\}}|�||��}�|s|}nd	|vrd
nd}||z|z}t|��sd}|S)z�
    Try to suggest a semantic form for a version for which
    _suggest_normalized_version couldn't come up with anything.
    z0.0.0rr�c�,�g|]}t|����Srr�r�s  rr�z-_suggest_semantic_version.<locals>.<listcomp>�s��)�)�)�Q�#�a�&�&�)�)�)r�Nc�,�g|]}t|����Srr�r�s  rr�z-_suggest_semantic_version.<locals>.<listcomp>�s��:�:�:�!�s�1�v�v�:�:�:rc�,�g|]}t|����Srr�r�s  rr�z-_suggest_semantic_version.<locals>.<listcomp>�s��2�2�2�a�3�q�6�6�2�2�2rr��-r�)rrq�
_REPLACEMENTS�sub�_NUMERIC_PREFIXr�r�r�r ru�endr��_SUFFIX_REPLACEMENTS�	is_semver)r"r��pat�replr�rz�suffix�seps        r�_suggest_semantic_versionr�s���
�W�W�Y�Y�_�_�
�
�F�"�'�'�	��T�����v�&�&�������
	���f�%�%�A�� �����������A��$�$�S�)�)��)�)�&�)�)�)���&�k�k�A�o�o��M�M�!�����&�k�k�A�o�o��v�;�;�!����A�E�E�G�G�H�H�%�F�F��X�X�:�:�v�a�b�b�z�:�:�:�;�;�f�Q�U�U�W�W�X�X�>N�N�F��B�Q�B�Z�F����2�2�6�2�2�2�3�3��������
�+�.�	+�	+�I�C���W�W�T�6�*�*�F�F��'�����f�_�_�c�c�#���#���&���V�������Mrc���	t|��|S#t$rYnwxYw|���}dD]\}}|�||��}�t	jdd|��}t	jdd|��}t	jdd|��}t	jdd	|��}t	jd
d|��}|�d��r
|d
d�}t	jdd|��}t	jdd|��}t	jdd|��}t	jdd|��}t	jdd|��}t	jdd|��}t	jdd|��}t	jdd|��}t	jdd|��}t	jdd|��}t	jdd |��}	t|��n#t$rd}YnwxYw|S)!a�Suggest a normalized version close to the given version string.

    If you have a version string that isn't rational (i.e. NormalizedVersion
    doesn't like it) then you might be able to get an equivalent (or close)
    rational version from this function.

    This does a number of simple normalizations to the given string, based
    on observation of versions currently in use on PyPI. Given a dump of
    those version during PyCon 2009, 4287 of them:
    - 2312 (53.93%) match NormalizedVersion without change
      with the automatic suggestion
    - 3474 (81.04%) match when using this suggestion method

    @param s {str} An irrational version string.
    @returns A rational version string, or None, if couldn't determine one.
    ))z-alphar�)z-betar�)r�r�)r�r�)r�rV)z-finalr�)z-prerV)z-releaser�)z.releaser�)z-stabler�)r�r�)r�r�)� r�)z.finalr�)r�r�zpre$�pre0zdev$�dev0z([abc]|rc)[\-\.](\d+)$z\1\2z[\-\.](dev)[\-\.]?r?(\d+)$z.\1\2z[.~]?([abc])\.?r�rUrNz\b0+(\d+)(?!\d)z(\d+[abc])$z\g<1>0z\.?(dev-r|dev\.r)\.?(\d+)$z.dev\2z-(a|b|c)(\d+)$z[\.\-](dev|devel)$z.dev0z(?![\.\-])dev$z(final|stable)$r�z\.?(r|-|-r)\.?(\d+)$z.post\2z\.?(dev|git|bzr)\.?(\d+)$z\.?(pre|preview|-c)(\d+)$zc\g<2>zp(\d+)$z.post\1)r�r
rq�replace�rer�r�)r"�rs�origr�s    r�_suggest_normalized_versionr
�s1��"
���������"�
�
�
���
����
�����B�&�$�$�
��d��Z�Z��d�
#�
#���
����"�	%�	%�B�	����"�	%�	%�B�

��)�7�B�	7�	7�B�
��-�x��	<�	<�B�
��"�E�2�	.�	.�B�
�}�}�S����
����V��

��"�E�2�	.�	.�B�

���	�2�	.�	.�B�
��-�y�"�	=�	=�B�
��!�7�B�	/�	/�B�
��%�x��	4�	4�B�
��!�8�R�	0�	0�B�
��"�B��	+�	+�B�
��'��R�	8�	8�B�
��,�i��	<�	<�B�
��,�i��	<�	<�B�
��
�J��	+�	+�B���������"����
��������
�Is��
 � �G%�%G4�3G4z([a-z]+|\d+|[\.-])rVzfinal-�@)r��previewr�r�r�r�r�c�f�d�}g}||��D]�}|�d��rf|dkr0|r.|ddkr"|���|r|ddk�"|r.|ddkr"|���|r|ddk�"|�|����t|��S)Nc�\�g}t�|�����D]g}t�||��}|rHd|dd�cxkrdkrnn|�d��}nd|z}|�|���h|�d��|S)N�0r�9��*�*final)�
_VERSION_PARTr�rq�_VERSION_REPLACEr}�zfillru)r"r�rWs   r�	get_partsz_legacy_key.<locals>.get_partsMs������$�$�Q�W�W�Y�Y�/�/�	!�	!�A� �$�$�Q��*�*�A��
!��!�B�Q�B�%�&�&�&�&�3�&�&�&�&�&�����
�
�A�A��a��A��
�
�a� � � ���
�
�h�����
rrrr�z*final-�00000000)r��poprur)r"rr�rWs    r�_legacy_keyrLs�������F�
�Y�q�\�\�����<�<����	��8�|�|��!����y�!8�!8��J�J�L�L�L��!����y�!8�!8��
�V�B�Z�:�5�5��
�
�����
�V�B�Z�:�5�5��
�
�a�������=�=�rc�*�eZdZd�Zed���ZdS)r	c� �t|��Sr1)rr(s  rrzLegacyVersion.parsegs���1�~�~�rc��d}|jD]6}t|t��r|�d��r
|dkrd}n�7|S)NFrrT)rrrr�)r!r�r�s   rrOzLegacyVersion.is_prereleasejsV������	�	�A��1�l�+�+�
����S�0A�0A�
���L�L�������
rN�rrrrrPrOrrrr	r	fs>�������������X���rr	c�b�eZdZeZeej��Zded<ej	d��Z
d�ZdS)r
r�riz^(\d+(\.\d+)*)c�4�||krdS|j�t|����}|st�d||��dS|���d}d|vr|�dd��d}t||��S)NFzACannot compute compatible match for version %s  and constraint %sTrr�r)�
numeric_rer�r��logger�warningr��rsplitr�)r!rr�rzr�r"s      rr�zLegacyMatcher._match_compatible}s����Z����5��O�!�!�#�j�/�/�2�2���	��N�N�0�18�*�
F�
F�
F��4�
�H�H�J�J�q�M���!�8�8�����a� � ��#�A��W�a�(�(�(rN)rrrr	rn�dictrRr|r�compiler!r�rrrr
r
usV������!�M���g�(�)�)�J�*�J�t�����-�.�.�J�)�)�)�)�)rr
zN^(\d+)\.(\d+)\.(\d+)(-[a-z0-9]+(\.[a-z0-9-]+)*)?(\+[a-z0-9]+(\.[a-z0-9-]+)*)?$c�6�t�|��Sr1)�
_SEMVER_REr�)r"s rr�r��s�����A���rc��d�}t|��}|st|���|���}d�|dd�D��\}}}||dd��||dd��}}|||f||fS)Nc�~�|�|f}n6|dd��d��}td�|D����}|S)Nrr�c�d�g|]-}|���r|�d��n|��.S)r)r�r)r�rWs  rr�z5_semantic_key.<locals>.make_tuple.<locals>.<listcomp>�s3��L�L�L��!�)�)�+�+�<�A�G�G�A�J�J�J�1�L�L�Lr)r�r)r"�absentr�r#s    r�
make_tuplez!_semantic_key.<locals>.make_tuple�sL���9��Y�F�F��a�b�b�E�K�K��$�$�E��L�L�e�L�L�L�M�M�F��
rc�,�g|]}t|����Srr�r�s  rr�z!_semantic_key.<locals>.<listcomp>�s��6�6�6�a�3�q�6�6�6�6�6rr��|�r)r�r
r�)	r"r-r�r��major�minor�patchr��builds	         r�
_semantic_keyr5�s������	�!���A��)�%�a�(�(�(�
�X�X�Z�Z�F�6�6�6�"�1�"�:�6�6�6��E�5�%���F�1�I�s�+�+�Z�Z��q�	�3�-G�-G��C��5�%� �#�u�,�,rc�*�eZdZd�Zed���ZdS)rc� �t|��Sr1)r5r(s  rrzSemanticVersion.parse�s���Q���rc�0�|jdddkS)Nrrr/)rrDs rrOzSemanticVersion.is_prerelease�s���{�1�~�a� �C�'�'rNrrrrrr�s>������ � � ��(�(��X�(�(�(rrc��eZdZeZdS)rN)rrrrrnrrrrr�s������#�M�M�Mrrc�.�eZdZdd�Zd�Zd�Zd�Zd�ZdS)�
VersionSchemeNc�0�||_||_||_dSr1)rr�matcher�	suggester)r!rrr=r>s    rr$zVersionScheme.__init__�s��������"����rc�f�	|j�|��d}n#t$rd}YnwxYw|S�NTF)r=rnr
�r!r"r�s   r�is_valid_versionzVersionScheme.is_valid_version�sM��	��L�&�&�q�)�)�)��F�F��&�	�	�	��F�F�F�	�����
s��.�.c�\�	|�|��d}n#t$rd}YnwxYw|Sr@)r=r
rAs   r�is_valid_matcherzVersionScheme.is_valid_matcher�sF��	��L�L��O�O�O��F�F��&�	�	�	��F�F�F�	�����
s��)�)c�p�|�d��r
|dd�}|�d|z��S)z:
        Used for processing some metadata fields
        �,Nr�zdummy_name (%s))rtrDr(s  r�is_valid_constraint_listz&VersionScheme.is_valid_constraint_list�s=��

�:�:�c�?�?�	��#�2�#��A��$�$�%6��%:�;�;�;rc�D�|j�d}n|�|��}|Sr1)r>rAs   r�suggestzVersionScheme.suggest�s'���>�!��F�F��^�^�A�&�&�F��
rr1)rrrr$rBrDrGrIrrrr;r;�sd������#�#�#�#�
������<�<�<�����rr;c��|Sr1rr(s  rrXrX�s���r)�
normalized�legacy�semanticrK�defaultc�R�|tvrtd|z���t|S)Nzunknown scheme name: %r)�_SCHEMESro)rps rrr�s+���8����2�T�9�:�:�:��D�>�r)*r�loggingr�compatr�utilr�__all__�	getLoggerrr"ror
�objectrrRr&�Ir�r�r�rr�rr�r�r�rr
rrrr	r
r(r�r5rrr;rPrrrr�<module>rXs����
����	�	�	�	� � � � � � �#�#�#�#�#�#�4�4�4��

��	�8�	$�	$��	�	�	�	�	�j�	�	�	�
.E�.E�.E�.E�.E�f�.E�.E�.E�ba�a�a�a�a�f�a�a�a�H�B�J� F�GI�t�M�M��
B.�B.�B.�J��!G�!G�!G�!G�!G��!G�!G�!G�H���T+�T+�T+�T+�T+��T+�T+�T+�p�R�Z����2���R�Z����g�&��R�Z����"���R�Z�
����&��R�Z�&�'�'��/��R�Z�"�#�#�U�+��R�Z�	���C� ��R�Z�"�#�#�W�-��R�Z�+�,�,����R�Z����v�&��
��R�Z����r�"��R�Z�
����#��R�Z�
���S�!��R�Z�	���C� ��R�Z���������"�*�-�.�.��+�+�+�\l�l�l�f��
�0�"�$�7�7�
���	�

���	
�������4�����G����)�)�)�)�)�G�)�)�)�4�R�Z�:�;=�4�A�A�
�
���-�-�-�*(�(�(�(�(�g�(�(�(�$�$�$�$�$�g�$�$�$�$�$�$�$�$�F�$�$�$�P �-��1B� ;�=�=��m�K��8I�8I�J�J��
�m�_�7�9�9�	����|�,��������r

Zerion Mini Shell 1.0