� ��^i�[� ��dZddlZddlZddlmZddlmZgd�Zeje ��Z Gd�de ��Z Gd �d e ��ZGd �d e ��Zejd ��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/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/distlib/version.pyr r s������)�)��Drr c�l�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z d �Z d �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�Z d�Z d�Z d�Zd�ZdS)�MatcherNc��||kSr1r��v�c�ps r�zMatcher.T� ��Q��U�rc��||kSr1rrTs rrXzMatcher.UrYrc��||kp||kSr1rrTs rrXzMatcher.V���a�1�f�o��A��rc��||kp||kSr1rrTs rrXzMatcher.Wr\rc��||kSr1rrTs rrXzMatcher.X� ��a�1�f�rc��||kSr1rrTs rrXzMatcher.Ys ��q�A�v�rc��||kp||kSr1rrTs rrXzMatcher.[r\rc��||kSr1rrTs rrXzMatcher.\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�����rrRzk^v?(\d+!)?(\d+(\.\d+)*)((a|b|c|rc)(\d+))?(\.(post)(\d+))?(\.(dev)(\d+))?(\+([a-zA-Z\d]+(\.[a-zA-Z\d]+)?))?$c�2�|���}t�|��}|std|z���|���}t d�|d�d��D����}t|��dkr5|ddkr)|dd�}t|��dkr |ddk�)|dsd}nt|ddd���}|dd�}|d d �}|d d �}|d }|dkrd}n|dt|d��f}|dkrd}n|dt|d��f}|dkrd}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� z_pep_440_key..�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��sc�� ��� � �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�������!�f�c�#�a�&�k�k�!�� �|�������A�w��D��G� � �$�� �l�������!�f�c�#�a�&�k�k�!�� �}�������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..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.parse se�� ��#�#�� � #� #�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..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�rPrOrrrrr�sc��������" � � ��#�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�Z d�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_local6s��� � 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� z/NormalizedMatcher._match_lt..I���7�7�7�1��A���7�7�7r�r�r��joinr��r!rr�rz�release_clause�pfxs rr�zNormalizedMatcher._match_ltD�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..Qr�rr�r�s rr�zNormalizedMatcher._match_gtLr�rc�B�|�|||��\}}||kSr1�r��r!rr�rzs rr�zNormalizedMatcher._match_leT�)��"�0�0��*�f�M�M�����*�$�$rc�B�|�|||��\}}||kSr1r�r�s rr�zNormalizedMatcher._match_geXr�rc�l�|�|||��\}}|s||k}nt||��}|Sr1�r�r��r!rr�rzr�s rr�zNormalizedMatcher._match_eq\sF��"�0�0��*�f�M�M����� 8���+�F�F�"�7�J�7�7�F�� rc�B�t|��t|��kSr1r�r�s rr�z"NormalizedMatcher._match_arbitraryds���7�|�|�s�:���.�.rc�n�|�|||��\}}|s||k}nt||�� }|Sr1r�r�s rr�zNormalizedMatcher._match_negsI��"�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..zr�r)r�r�r r�r�r�s rr�z#NormalizedMatcher._match_compatibleos���"�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..�s��)�)�)�Q�#�a�&�&�)�)�)r�Nc�,�g|]}t|����Srr�r�s rr�z-_suggest_semantic_version..�s��:�:�:�!�s�1�v�v�:�:�:rc�,�g|]}t|����Srr�r�s rr�z-_suggest_semantic_version..�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..get_partsCs������$�$�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_keyrBs��� � � ��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.parse]s���1�~�~�rc��d}|jD]6}t|t��r|�d��r |dkrd}n�7|S)NFrrT)rrrr�)r!r�r�s rrOzLegacyVersion.is_prerelease`sV������ � �A��1�l�+�+� �� � �S�0A�0A� ��H� � ������� rN�rrrrrPrOrrrr r \s>�������������X���rr c�b�eZdZeZeej��Zded<ej d��Z d�Z dS)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_compatibless��� �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 ksV������!�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..make_tuple..�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..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..�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)r c� �t|��Sr1)r5r(s rrzSemanticVersion.parse�s���Q���rc�0�|jdddkS)Nrrr/)rrDs rrOzSemanticVersion.is_prerelease�s���{�1�~�a� �C�'�'rNrrrrr r �s>������ � � ��(�(��X�(�(�(rr c��eZdZeZdS)r N)rrrr rnrrrr 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&r�r�r�rr�rr�r�r�rr �Irrrr r r(r�r5r r r;rPrrrr�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�G�G�� :.�:.�:.�z��!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