Edit File: version.cpython-311.pyc
� ����m�d�\����������������������������d�Z�ddlZddlZddlmZ�ddlmZ�g�d�Z�ej��������e ������������Z �G�d��de������������Z�G�d ��d e ������������Z�G�d��de ������������Z�ej��������d ej��������������������Zd��ZeZ�G�d��de������������Zd��Z�G�d��de������������Z�ej��������d������������df�ej��������d������������df�ej��������d������������df�ej��������d������������df�ej��������d������������df�ej��������d������������df�ej��������d������������df�ej��������d ������������d!f�ej��������d"������������d#f�ej��������d$������������d%ff Z�ej��������d&������������df�ej��������d'������������df�ej��������d(������������df�ej��������d������������df�ej��������d)������������dffZ�ej��������d*������������Zd+��Zd,��Z�ej��������d-ej��������������������Zd.d.d/d.d0ddd1�Zd2��Z�G�d3��d4e������������Z �G�d5��d6e������������Z!�ej��������d7ej��������������������Z"d8��Z#d9��Z$�G�d:��d;e������������Z%�G�d<��d=e������������Z&�G�d>��d?e ������������Z'�e'eee�������������e'ee!d@���������������e'e$e&e������������dA�Z(e(dB���������e(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�������������������������e�Zd�ZdZdS�)r ���zThis is an unsupported version.N)�__name__� __module__�__qualname__�__doc__��������`/builddir/build/BUILD/cloudlinux-venv-1.0.2/venv/lib/python3.11/site-packages/distlib/version.pyr ���r ������s��������������)�)��Dr���r ���c��������������������l�����e�Zd�Zd��Zd��Zd��Zd��Zd��Zd��Zd��Z d��Z d ��Zd ��Zd��Z d��Zed ����������������ZdS�)�Versionc������������������������|������������������������������������x|�_��������}|����������������������|������������x|�_��������}t ����������|t ����������������������sJ��t ����������|������������dk����sJ��d�S�)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�~�~�~�~�~�~r���c������������������ �����t����������d�������������)Nzplease implement in a subclass��NotImplementedError�r!���r"���s��� r���r���z Version.parse%���s������!�"B�C�C�Cr���c������������������p�����t����������|�������������t����������|������������k����rt����������d|��d|���������������d�S��Nzcannot compare z and )�type� TypeError�r!����others��� r����_check_compatiblezVersion._check_compatible(���s<��������:�:��e���$�$��)�$�$�$���F�G�G�G��%�$r���c������������������L�����|�����������������������|�������������|�j��������|j��������k����S��N�r/���r���r-���s��� r����__eq__zVersion.__eq__,���s%���������u�%�%�%��{�e�l�*�*r���c������������������.�����|�����������������������|�������������S�r1����r3���r-���s��� r����__ne__zVersion.__ne__0�����������;�;�u�%�%�%�%r���c������������������L�����|�����������������������|�������������|�j��������|j��������k�����S�r1���r2���r-���s��� r����__lt__zVersion.__lt__3���s%���������u�%�%�%��{�U�\�)�)r���c������������������X�����|�����������������������|������������p|����������������������|�������������S�r1����r9���r3���r-���s��� r����__gt__zVersion.__gt__7���s(�������K�K��&�&�<�$�+�+�e�*<�*<�=�=r���c������������������V�����|�����������������������|������������p|����������������������|������������S�r1���r;���r-���s��� r����__le__zVersion.__le__:����%�������{�{�5�!�!�7�T�[�[��%7�%7�7r���c������������������V�����|�����������������������|������������p|����������������������|������������S�r1���)r<���r3���r-���s��� r����__ge__zVersion.__ge__=���r?���r���c������������������*�����t����������|�j��������������������S�r1���)�hashr����r!���s��� r����__hash__zVersion.__hash__A���s�������D�K� � � r���c������������������0�����|�j���������j���������d|�j���������d�S�)Nz('z')�� __class__r���r���rD���s��� r����__repr__zVersion.__repr__D���s������!�^�4�4�4�d�l�l�l�C�Cr���c�����������������������|�j���������S�r1����r���rD���s��� r����__str__zVersion.__str__G���� �������|�r���c������������������ �����t����������d�������������)NzPlease implement in subclasses.r&���rD���s��� r���� is_prereleasezVersion.is_prereleaseJ���s������!�"C�D�D�Dr���N)r���r���r���r$���r���r/���r3���r6���r9���r<���r>���rA���rE���rI���rL����propertyrO���r���r���r���r���r������s��������������������D��D��D�H��H��H�+��+��+�&��&��&�*��*��*�>��>��>�8��8��8�8��8��8�!��!��!�D��D��D��������E��E���X�E��E��Er���r���c������������ �������������e�Zd�ZdZd��d��d��d��d��d��d��d ��d �Zd��Zd��Zd ��Zed����������������Z d��Z d��Zd��Zd��Z d��Zd��ZdS�)�MatcherNc�����������������������|�|k�����S�r1���r�����v�c�ps��� r����<lambda>zMatcher.<lambda>T���� ������Q��U��r���c�����������������������|�|k����S�r1���r���rT���s��� r���rX���zMatcher.<lambda>U���rY���r���c�����������������������|�|k����p|�|k�����S�r1���r���rT���s��� r���rX���zMatcher.<lambda>V����������a�1�f�o��A���r���c�����������������������|�|k����p|�|k����S�r1���r���rT���s��� r���rX���zMatcher.<lambda>W���r\���r���c�����������������������|�|k����S�r1���r���rT���s��� r���rX���zMatcher.<lambda>X���� ������a�1�f��r���c�����������������������|�|k����S�r1���r���rT���s��� r���rX���zMatcher.<lambda>Y���s ������q�A�v��r���c�����������������������|�|k����p|�|k����S�r1���r���rT���s��� r���rX���zMatcher.<lambda>[���r\���r���c�����������������������|�|k����S�r1���r���rT���s��� r���rX���zMatcher.<lambda>\���r_���r���)�<�>�<=�>=�==�===�~=�!=c������������������ �����t����������|������������S�r1���r���r(���s��� r���r���zMatcher.parse_requirementa���s������ ��#�#�#r���c������������������Z����|�j����������t����������d�������������|�����������������������������������x|�_��������}|����������������������|������������}|st����������d|z���������������|j��������|�_��������|�j�������������������������������������������|�_��������g�}|j��������r�|j��������D�]�\��}}|� ��������������������d������������r8|dvrt����������d|z���������������|d�d����������d}}|�����������������������|�������������n|�����������������������|������������d}}|� ��������������������|||f���������������t����������|������������|�_��������d�S�) NzPlease specify a version classz Not valid: %rz.*)rg���rj���z#'.*' not allowed for %r constraints���TF) � version_class� ValueErrorr���r���r����name�lower�key�constraints�endswith�appendr���r���)r!���r"����r�clist�op�vn�prefixs��� r���r$���zMatcher.__init__d���sM�������%��=�>�>�>��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����r���c������������������X����t����������|t����������������������r|����������������������|������������}|�j��������D�]w\��}}}|�j�����������������������������|������������}t����������|t����������������������rt ����������|�|������������}|s |�d|�j��������j����������}t����������|��������������||||������������s�dS��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) r���r���rn���r���� _operators�get�getattrrH���r���r'���)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� ��tr���c�����������������������d�}t����������|�j��������������������dk����r(|�j��������d���������d���������dv�r|�j��������d���������d���������}|S�)Nr���r���)rg���rh���)r ���r���)r!����results��� r���� exact_versionzMatcher.exact_version����sF���������t�{���q� � �T�[��^�A�%6�-�%G�%G��[��^�A�&�F�� r���c�����������������������t����������|�������������t����������|������������k����s|�j��������|j��������k����rt����������d|��d|���������������d�S�r*���)r+���rp���r,���r-���s��� r���r/���zMatcher._check_compatible����sK��������:�:��e���$�$�� �U�Z�(?�(?��)�$�$�$���F�G�G�G��)@�(?r���c������������������l�����|�����������������������|�������������|�j��������|j��������k����o|�j��������|j��������k����S�r1���)r/���rr���r���r-���s��� r���r3���zMatcher.__eq__����s3���������u�%�%�%��x�5�9�$�D�����)D�Dr���c������������������.�����|�����������������������|�������������S�r1���r5���r-���s��� r���r6���zMatcher.__ne__����r7���r���c������������������T�����t����������|�j��������������������t����������|�j��������������������z���S�r1���)rC���rr���r���rD���s��� r���rE���zMatcher.__hash__����s�������D�H�~�~��T�[� 1� 1�1�1r���c������������������0�����|�j���������j���������d|�j���������d�S�)N�(�)rG���rD���s��� r���rI���zMatcher.__repr__����s�������>�2�2�2�D�L�L�L�A�Ar���c�����������������������|�j���������S�r1���rK���rD���s��� r���rL���zMatcher.__str__����rM���r���)r���r���r���rn���r|���r���r$���r����rP���r����r/���r3���r6���rE���rI���rL���r���r���r���rR���rR���O���s��������������M��#� "� "� "�-�-�-�-�$�$�%�%�-�-�$�$� �� �J�$��$��$�#��#��#�:�����*�������X��H��H��H�E��E��E�&��&��&�2��2��2�B��B��B���������r���rR���z�^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�������������������������������|�������������}|st����������d|�z���������������|�����������������������������������}t����������d��|d������������������������������d������������D���������������������������}t����������|������������dk����r5|d���������dk����r)|d�d����������}t����������|������������dk����r|d���������dk�����)|d���������sd}nt����������|d���������d�d����������������������}|dd����������}|d d ����������}|dd����������}|d ���������}|dk����rd}n0|d����������|d���������df}n|d���������t����������|d���������������������f}|dk����rd}n0|d����������|d���������df}n|d���������t����������|d���������������������f}|dk����rd}n0|d����������|d���������df}n|d���������t����������|d���������������������f}|�d}nhg�} |���������������������d������������D�]A} | � ����������������������������������rdt����������| ������������f} nd| f} | � ��������������������| ��������������Bt����������| ������������}|s |s|rd}nd}|sd}|sd}||||||fS�)NzNot a valid version: %sc��������������3����4���K����|�]}t����������|������������V����d�S�r1�����int��.0rU���s��� r���� <genexpr>z_pep_440_key.<locals>.<genexpr>����s(����������6�6�A��Q���6�6�6�6�6�6r���r����.���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��-�-r���c��������������������H�����e�Zd�ZdZd��Z�eg�d�������������Zed����������������ZdS�)r���aI��A 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�)Nc��������������3����4���K����|�]}t����������|������������V����d�S�r1���r����r����s��� r���r����z*NormalizedVersion.parse.<locals>.<genexpr>��s(����������$J�$J��S��V�V�$J�$J�$J�$J�$J�$Jr���r���r����)�_normalized_keyr����r����r����r���r�����_release_clause)r!���r"���r����r����r����s��� r���r���zNormalizedVersion.parse��se������ ��#�#�� � �#�#�A�&�&��������$�$J�$J�V�A�Y�_�_�S�5I�5I�$J�$J�$J�J�J���� r���)r�����brV����rcr����c������������������D�������t������������fd���j��������D���������������������������S�)Nc��������������3����:����K����|�]}|�|d�����������j���������v�V����dS�)r���N)�PREREL_TAGS)r�����tr!���s��� �r���r����z2NormalizedVersion.is_prerelease.<locals>.<genexpr>"��s4�����������F�F��A�F�1�Q�4�4�+�+�F�F�F�F�F�Fr���)�anyr���rD���s���`r���rO���zNormalizedVersion.is_prerelease ��s(��������F�F�F�F�T�[�F�F�F�F�F�Fr���N) r���r���r���r���r����setr����rP���rO���r���r���r���r���r�����sc�����������������" �� �� ���#�2�2�2�3�3�K� �G��G���X�G��G��Gr���r���c�����������������������t����������|�������������}�t����������|������������}|�|k����rdS�|����������������������|������������sdS�t����������|������������}|�|���������dk����S�)NTFr����)�str� startswithr ���)�x�y�ns��� r���� _match_prefixr����%��sV�������A���A��A���A��A�v�v��t��<�<��?�?����u��A���A��Q�4�3�;�r���c������������ ��������^�����e�Zd�ZeZddddddddd �Zd ��Zd��Zd��Zd ��Z d��Z d��Zd��Zd��Z d��ZdS�)r����_match_compatible� _match_lt� _match_gt� _match_le� _match_ge� _match_eq�_match_arbitrary� _match_ne)ri���rc���rd���re���rf���rg���rh���rj���c������������������������|rd|vo|j���������d���������}n|j���������d����������o|j���������d���������}|r6|j�����������������������������dd������������d���������}|����������������������|������������}||fS�)N�+r����r���r���)r���r���r����rn���)r!���r���r����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�� �"�"r���c�����������������������|�����������������������|||������������\��}}||k����rdS�|j��������}d���������������������d��|D���������������������������}t����������||�������������S�)NFr����c������������������,�����g�|�]}t����������|��������������S�r����r�����r�����is��� r���� <listcomp>z/NormalizedMatcher._match_lt.<locals>.<listcomp>R���������7�7�7�1��A���7�7�7r����r����r�����joinr�����r!���r���r����rz����release_clause�pfxs��� r���r����zNormalizedMatcher._match_ltM���i������"�0�0��*�f�M�M�����j� � ��5�#�3���h�h�7�7��7�7�7�8�8�� ��#�.�.�.�.r���c�����������������������|�����������������������|||������������\��}}||k����rdS�|j��������}d���������������������d��|D���������������������������}t����������||�������������S�)NFr����c������������������,�����g�|�]}t����������|��������������S�r���r����r����s��� r���r����z/NormalizedMatcher._match_gt.<locals>.<listcomp>Z��r����r���r����r����s��� r���r����zNormalizedMatcher._match_gtU��r����r���c������������������B�����|�����������������������|||������������\��}}||k����S�r1����r�����r!���r���r����rz���s��� r���r����zNormalizedMatcher._match_le]���)������"�0�0��*�f�M�M�����*�$�$r���c������������������B�����|�����������������������|||������������\��}}||k����S�r1���r����r����s��� r���r����zNormalizedMatcher._match_gea��r����r���c������������������l�����|�����������������������|||������������\��}}|s||k����}nt����������||������������}|S�r1����r����r�����r!���r���r����rz���r����s��� r���r����zNormalizedMatcher._match_eqe��sF������"�0�0��*�f�M�M������ 8���+�F�F�"�7�J�7�7�F�� r���c������������������B�����t����������|������������t����������|������������k����S�r1���r����r����s��� r���r����z"NormalizedMatcher._match_arbitrarym��s�������7�|�|�s�:���.�.r���c������������������n�����|�����������������������|||������������\��}}|s||k����}nt����������||�������������}|S�r1���r����r����s��� r���r����zNormalizedMatcher._match_nep��sI������"�0�0��*�f�M�M������ <���+�F�F�&�w� �;�;�;�F�� r���c�����������������������|�����������������������|||������������\��}}||k����rdS�||k�����rdS�|j��������}t����������|������������dk����r |d�d����������}d���������������������d��|D���������������������������}t ����������||������������S�)NTFr���r����r����c������������������,�����g�|�]}t����������|��������������S�r���r����r����s��� r���r����z7NormalizedMatcher._match_compatible.<locals>.<listcomp>���r����r���)r����r����r ���r����r����r����s��� r���r����z#NormalizedMatcher._match_compatiblex��s�������"�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�*�*�*r���N)r���r���r���r���rn���r|���r����r����r����r����r����r����r����r����r����r���r���r���r���r���0��s���������������%�M��"� � ����!�� �� �J�#��#��#�/��/��/�/��/��/�%��%��%�%��%��%������/��/��/������+��+��+��+��+r���r���z[.+-]$��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�����������������������|������������������������������������������������������������������������}t����������D�]\��}}|���������������������||������������}�|sd}t�������������������������������|������������}|sd}|}�n%|�����������������������������������d������������������������������d������������}d��|D���������������}t����������|������������dk�����r(|� ��������������������d�������������t����������|������������dk������(t����������|������������dk����r||� ����������������������������������d����������}nNd���������������������d��|dd����������D���������������������������||� ����������������������������������d����������z���}|dd����������}d���������������������d��|D���������������������������}|������������������������������������}|r#t����������D�]\��}}|���������������������||������������}�|s|}nd |v�rd 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.0r���r����c������������������,�����g�|�]}t����������|��������������S�r���r����r����s��� r���r����z-_suggest_semantic_version.<locals>.<listcomp>���s������)�)�)�Q�#�a�&�&�)�)�)r�������Nc������������������,�����g�|�]}t����������|��������������S�r���r����r����s��� r���r����z-_suggest_semantic_version.<locals>.<listcomp>���s������:�:�:�!�s�1�v�v�:�:�:r���c������������������,�����g�|�]}t����������|��������������S�r���r����r����s��� r���r����z-_suggest_semantic_version.<locals>.<listcomp>���s������2�2�2�a�3�q�6�6�2�2�2r���r�����-r����)r���rq���� _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��������Mr���c����������������������� �t����������|��������������|�S�#�t����������$�r�Y�nw�xY�w|������������������������������������}dD�]\��}}|���������������������||������������}�t ����������j��������dd|������������}t ����������j��������dd|������������}t ����������j��������dd|������������}t ����������j��������dd |������������}t ����������j��������d d|������������}|���������������������d������������r |d d����������}t ����������j��������dd|������������}t ����������j��������dd|������������}t ����������j��������dd|������������}t ����������j��������dd|������������}t ����������j��������dd|������������}t ����������j��������dd|������������}t ����������j��������dd|������������}t ����������j��������dd|������������}t ����������j��������dd|������������}t ����������j��������dd|������������}t ����������j��������dd |������������} �t����������|�������������n#�t����������$�r�d}Y�nw�xY�w|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����rU���r���Nz\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+|[\.-])rV���zfinal-�@)r�����previewr����r����r����r����r����c������������������f����d��}g�}�||�������������D�]�}|����������������������d������������rf|dk�����r0|r.|d���������dk����r"|������������������������������������|r|d���������dk�����"|r.|d���������dk����r"|������������������������������������|r|d���������dk�����"|���������������������|���������������t����������|������������S�)Nc������������������\����g�}t��������������������������������|������������������������������������������������D�]g}t�������������������������������||������������}|rHd|d�d����������cxk����rdk����rn�n|���������������������d������������}nd|z���}|���������������������|��������������h|���������������������d�������������|S�)N�0r����9�����*�*final)� _VERSION_PARTr����rq����_VERSION_REPLACEr}����zfillru���)r"���r����rW���s��� r���� get_partsz_legacy_key.<locals>.get_partsL��s����������$�$�Q�W�W�Y�Y�/�/�� !�� !�A� �$�$�Q��*�*�A��� !��!�B�Q�B�%�&�&�&�&�3�&�&�&�&�&����� � �A�A��a��A�� � �a� � � ��� � �h����� r���r��r��r����z*final-�00000000)r�����popru���r���)r"���r��r����rW���s��� r����_legacy_keyr��K��s��������������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�������=�=�r���c��������������������*�����e�Zd�Zd��Zed����������������ZdS�)r ���c������������������ �����t����������|������������S�r1���)r��r(���s��� r���r���zLegacyVersion.parsef��s�������1�~�~�r���c�����������������������d}|�j���������D�]6}t����������|t����������������������r|���������������������d������������r |dk�����rd}�n�7|S�)NFr��r��T)r���r���r���r����)r!���r����r����s��� r���rO���zLegacyVersion.is_prereleasei��sV����������� �� �A��1�l�+�+�� ����S�0A�0A�� ��H��������� r���N�r���r���r���r���rP���rO���r���r���r���r ���r ���e��s>��������������������������X�����r���r ���c��������������������b�����e�Zd�ZeZ�eej��������������������Zded<����ej ��������d������������Z d��ZdS�)r ���r����ri���z^(\d+(\.\d+)*)c������������������4����||k�����rdS�|�j������������������������������t����������|������������������������}|st�������������������������������d||�������������dS�|�����������������������������������d���������}d|v�r|���������������������dd������������d���������}t����������||������������S�)NFzACannot compute compatible match for version %s and constraint %sTr���r����r���)� numeric_rer����r�����logger�warningr�����rsplitr����)r!���r���r����rz���r����r"���s��� r���r����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�(�(�(r���N)r���r���r���r ���rn����dictrR���r|���r���compiler!��r����r���r���r���r ���r ���t��sV��������������!�M���g�(�)�)�J�*�J�t�����-�.�.�J�)��)��)��)��)r���r ���zN^(\d+)\.(\d+)\.(\d+)(-[a-z0-9]+(\.[a-z0-9-]+)*)?(\+[a-z0-9]+(\.[a-z0-9-]+)*)?$c������������������6�����t��������������������������������|�������������S�r1���)� _SEMVER_REr����)r"���s��� r���r����r�������s���������A���r���c�����������������������d��}t����������|�������������}|st����������|��������������|�����������������������������������}d��|d�d����������D���������������\��}}}�||d���������d�������������||d���������d������������}}|||f||fS�)Nc������������������~�����|��|f}n6|�dd���������������������������������d������������}t����������d��|D���������������������������}|S�)Nr���r����c������������������d�����g�|�]-}|������������������������������������r|���������������������d�������������n|��.S�)r��)r����r��)r����rW���s��� r���r����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�� r���c������������������,�����g�|�]}t����������|��������������S�r���r����r����s��� r���r����z!_semantic_key.<locals>.<listcomp>���s������6�6�6�a�3�q�6�6�6�6�6r���r�����|����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�,�,r���c��������������������*�����e�Zd�Zd��Zed����������������ZdS�)r���c������������������ �����t����������|������������S�r1���)r5��r(���s��� r���r���zSemanticVersion.parse���s�������Q���r���c������������������0�����|�j���������d���������d���������dk����S�)Nr���r���r/��)r���rD���s��� r���rO���zSemanticVersion.is_prerelease���s�������{�1�~�a� �C�'�'r���Nr��r���r���r���r���r������s>�������������� �� �� ���(��(���X�(��(��(r���r���c�������������������������e�Zd�ZeZdS�)r���N)r���r���r���r���rn���r���r���r���r���r������s��������������#�M�M�Mr���r���c��������������������.�����e�Zd�Zdd�Zd��Zd��Zd��Zd��ZdS�)� VersionSchemeNc������������������0�����||�_���������||�_��������||�_��������d�S�r1���)rr����matcher� suggester)r!���rr���r=��r>��s��� r���r$���zVersionScheme.__init__���s������������"����r���c������������������f����� �|�j������������������������������|�������������d}n#�t����������$�r�d}Y�nw�xY�w|S��NTF)r=��rn���r ����r!���r"���r����s��� r����is_valid_versionzVersionScheme.is_valid_version���sM������ ��L�&�&�q�)�)�)��F�F��&�� �� �� ��F�F�F� ����� s������.�.c������������������\����� �|�����������������������|�������������d}n#�t����������$�r�d}Y�nw�xY�w|S�r@��)r=��r ���rA��s��� 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))rt���rD��r(���s��� r����is_valid_constraint_listz&VersionScheme.is_valid_constraint_list���s=������ � �:�:�c�?�?�� ��#�2�#��A��$�$�%6��%:�;�;�;r���c������������������D�����|�j����������d�}n|�����������������������|������������}|S�r1���)r>��rA��s��� r����suggestzVersionScheme.suggest���s'�������>�!��F�F��^�^�A�&�&�F�� r���r1���)r���r���r���r$���rB��rD��rG��rI��r���r���r���r;��r;�����sd��������������#��#��#��#� ����������<��<��<���������r���r;��c�����������������������|S�r1���r���r(���s��� r���rX���rX������s��������r���)� normalized�legacy�semanticrK���defaultc������������������R�����|�t�����������vrt����������d|�z���������������t�����������|����������S�)Nzunknown scheme name: %r)�_SCHEMESro���)rp���s��� r���r���r������s+�������8����2�T�9�:�:�:��D�>�r���)*r����loggingr���compatr����utilr����__all__� getLoggerr���r"��ro���r ����objectr���rR���r&���Ir����r����r����r���r����r���r����r����r����r��r ��r��r��r��r ���r ���r(��r����r5��r���r���r;��rP��r���r���r���r����<module>rX�����s�������� ������ � � � �� �� �� �� �� �� ��#��#��#��#��#��#�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��� C.��C.��C.�L���!G��!G��!G��!G��!G���!G��!G��!G�H�����T+��T+��T+��T+��T+���T+��T+��T+�n��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�d��� �0�"�$�7�7� ��� � ��� �����������4���������G�������)��)��)��)��)�G��)��)��)�2��R�Z��:�;=�4�A��A� � �����-��-��-�*(��(��(��(��(�g��(��(��(�$��$��$��$��$�g��$��$��$�$��$��$��$��$�F��$��$��$�N� �-��1B� ;�=��=��m�K��8I�8I�J�J�� �m�_�7�9��9� ������|�,�������������r���