U ��.e_[�@sfdZddlZddlZddlmZddlmZdddd d ddd gZe�e �Z Gdd�de�ZGdd�de �ZGdd�de �Ze�d�Zdd�ZeZGdd�de�Zdd�ZGdd�de�Ze�d�dfe�d�dfe�d�dfe�d�d fe�d!�d"fe�d#�d"fe�d$�d%fe�d&�d'fe�d(�d)fe�d*�d+ff Ze�d,�dfe�d-�dfe�d.�d%fe�d$�d%fe�d/�dffZe�d0�Zd1d2�Zd3d4�Ze�d5ej�Zd6d6d7d6d8ddd9�Zd:d;�ZGdej�Z"d?d@�Z#dAdB�Z$GdCd �d e�Z%GdDd�de�Z&GdEdF�dFe �Z'e'eee�e'ee!dGdH��e'e$e&e�dI�Z(e(dJe(dK<dLd �Z)dS)Mz~ 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@seZdZdZdS)rzThis is an unsupported version.N)�__name__� __module__�__qualname__�__doc__�rr�?/usr/lib/python3.8/site-packages/pip/_vendor/distlib/version.pyrsc@sxeZdZdd�Zdd�Zdd�Zdd�Zd d �Zdd�Zd d�Z dd�Z dd�Zdd�Zdd�Z dd�Zedd��ZdS)�VersioncCs"|��|_}|�|�|_}dS�N)�strip�_string�parse�_parts)�self�s�partsrrr�__init__szVersion.__init__cCstd��dS)Nzplease implement in a subclass��NotImplementedError�rrrrrr%sz Version.parsecCs$t|�t|�kr td||f��dS)Nzcannot compare %r and %r)�type� TypeError�r�otherrrr�_check_compatible(szVersion._check_compatiblecCs|�|�|j|jkSr�r%rr#rrr�__eq__,s zVersion.__eq__cCs|�|�Sr�r'r#rrr�__ne__0szVersion.__ne__cCs|�|�|j|jkSrr&r#rrr�__lt__3s zVersion.__lt__cCs|�|�p|�|�Sr�r*r'r#rrr�__gt__7szVersion.__gt__cCs|�|�p|�|�Srr+r#rrr�__le__:szVersion.__le__cCs|�|�p|�|�Sr)r,r'r#rrr�__ge__=szVersion.__ge__cCs t|j�Sr)�hashr�rrrr�__hash__AszVersion.__hash__cCsd|jj|jfS)Nz%s('%s')�� __class__rrr0rrr�__repr__DszVersion.__repr__cCs|jSr�rr0rrr�__str__GszVersion.__str__cCstd��dS)NzPlease implement in subclasses.rr0rrr� is_prereleaseJszVersion.is_prereleaseN)rrrrrr%r'r)r*r,r-r.r1r4r6�propertyr7rrrrrsrc @s�eZdZdZdd�dd�dd�dd�dd�dd�d d�d d�d�Zdd �Zdd�Zdd�Zedd��Z dd�Z dd�Zdd�Zdd�Z dd�Zdd�ZdS) �MatcherNcCs||kSrr��v�c�prrr�T�zMatcher.cCs||kSrrr:rrrr>Ur?cCs||kp||kSrrr:rrrr>Vr?cCs||kp||kSrrr:rrrr>Wr?cCs||kSrrr:rrrr>Xr?cCs||kSrrr:rrrr>Yr?cCs||kp||kSrrr:rrrr>[r?cCs||kSrrr:rrrr>\r?)�<�>�<=�>=�==�===�~=�!=cCst|�Srrr rrrraszMatcher.parse_requirementcCs�|jdkrtd��|��|_}|�|�}|s:td|��|j|_|j��|_g}|jr�|jD]d\}}|� d�r�|dkr�td|��|dd�d}}|�|�n|�|�d}}|� |||f�q^t|�|_dS) NzPlease specify a version classz Not valid: %rz.*)rDrGz#'.*' not allowed for %r constraints��TF) � version_class� ValueErrorrrr�name�lower�keyZconstraints�endswith�append�tupler)rr�rZclist�opZvn�prefixrrrrds* �zMatcher.__init__cCsxt|t�r|�|�}|jD]X\}}}|j�|�}t|t�rDt||�}|s`d||jjf}t |��||||�sdSqdS)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%r not implemented for %sFT) � isinstancerrIr� _operators�get�getattrr3rr)r�version�operator� constraintrS�f�msgrrr�match�s �z Matcher.matchcCs6d}t|j�dkr2|jdddkr2|jdd}|S)Nrr)rDrE)�lenr)r�resultrrr� exact_version�s zMatcher.exact_versioncCs0t|�t|�ks|j|jkr,td||f��dS)Nzcannot compare %s and %s)r!rKr"r#rrrr%�szMatcher._check_compatiblecCs"|�|�|j|jko |j|jkSr)r%rMrr#rrrr'�s zMatcher.__eq__cCs|�|�Srr(r#rrrr)�szMatcher.__ne__cCst|j�t|j�Sr)r/rMrr0rrrr1�szMatcher.__hash__cCsd|jj|jfS)Nz%s(%r)r2r0rrrr4�szMatcher.__repr__cCs|jSrr5r0rrrr6�szMatcher.__str__)rrrrIrUrrr]r8r`r%r'r)r1r4r6rrrrr9Os*� r9zk^v?(\d+!)?(\d+(\.\d+)*)((a|b|c|rc)(\d+))?(\.(post)(\d+))?(\.(dev)(\d+))?(\+([a-zA-Z\d]+(\.[a-zA-Z\d]+)?))?$cCs�|��}t�|�}|s"td|��|��}tdd�|d�d�D��}t|�dkrl|ddkrl|dd�}qF|dszd}nt|d�}|dd �}|d d�}|dd �}|d}|dkr�d}n|dt|d�f}|dkr�d}n|dt|d�f}|dk�rd}n|dt|d�f}|dk�r*d}nHg} |�d�D]0} | � ��rTdt| �f} nd| f} | � | ��q8t| �}|�s�|�s�|�r�d}nd}|�s�d}|�s�d}||||||fS)NzNot a valid version: %scss|]}t|�VqdSr��int��.0r;rrr� �sz_pep_440_key..r�.��r�� )NNr)�arg)�z)�_)�final)r�PEP440_VERSION_REr]r�groupsrP�splitr^rb�isdigitrO)r�mrtZnumsZepoch�preZpost�devZlocalr�partrrr�_pep_440_key�sT r{c@s6eZdZdZdd�Zedddddg�Zed d ��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 cCs<t|�}t�|�}|��}tdd�|d�d�D��|_|S)Ncss|]}t|�VqdSrrarcrrrresz*NormalizedVersion.parse..rrf)�_normalized_keyrsr]rtrPru�_release_clause)rrr_rwrtrrrr s zNormalizedVersion.parsero�br<�rcrycst�fdd��jD��S)Nc3s |]}|r|d�jkVqdS)rN)�PREREL_TAGS)rd�tr0rrresz2NormalizedVersion.is_prerelease..)�anyrr0rr0rr7szNormalizedVersion.is_prereleaseN) rrrrr�setr�r8r7rrrrr�s cCs>t|�}t|�}||krdS|�|�s*dSt|�}||dkS)NTFrf)�str� startswithr^)�x�y�nrrr� _match_prefixs r�c @sneZdZeZddddddddd �Zd d�Zdd �Zdd�Zdd�Z dd�Z dd�Zdd�Zdd�Z dd�ZdS)r�_match_compatible� _match_lt� _match_gt� _match_le� _match_ge� _match_eq�_match_arbitrary� _match_ne)rFr@rArBrCrDrErGcCsV|rd|ko|jd}n|jdo,|jd}|rN|j�dd�d}|�|�}||fS)N�+rgrr)rrrurI)rrXrZrSZstrip_localrrrr� _adjust_local6s zNormalizedMatcher._adjust_localcCsD|�|||�\}}||krdS|j}d�dd�|D��}t||�S)NFrfcSsg|]}t|��qSr�r��rd�irrr� Isz/NormalizedMatcher._match_lt..�r�r}�joinr��rrXrZrSZrelease_clauseZpfxrrrr�DszNormalizedMatcher._match_ltcCsD|�|||�\}}||krdS|j}d�dd�|D��}t||�S)NFrfcSsg|]}t|��qSrr�r�rrrr�Qsz/NormalizedMatcher._match_gt..r�r�rrrr�LszNormalizedMatcher._match_gtcCs|�|||�\}}||kSr�r��rrXrZrSrrrr�TszNormalizedMatcher._match_lecCs|�|||�\}}||kSrr�r�rrrr�XszNormalizedMatcher._match_gecCs.|�|||�\}}|s ||k}n t||�}|Sr�r�r��rrXrZrSr_rrrr�\s zNormalizedMatcher._match_eqcCst|�t|�kSrr�r�rrrr�dsz"NormalizedMatcher._match_arbitrarycCs0|�|||�\}}|s ||k}nt||�}|Srr�r�rrrr�gs zNormalizedMatcher._match_necCsf|�|||�\}}||krdS||kr*dS|j}t|�dkrH|dd�}d�dd�|D��}t||�S)NTFrrgrfcSsg|]}t|��qSrr�r�rrrr�zsz7NormalizedMatcher._match_compatible..)r�r}r^r�r�r�rrrr�osz#NormalizedMatcher._match_compatibleN)rrrrrIrUr�r�r�r�r�r�r�r�r�rrrrr's&�z[.+-]$�z^[.](\d)z0.\1z^[.-]z ^$(.*)$$�\1z^v(ersion)?\s*(\d+)z\2z^r(ev)?\s*(\d+)z[.]{2,}rfz\b(alfa|apha)\b�alphaz\b(pre-alpha|prealpha)\bz pre.alphaz $beta$$�betaz ^[:~._+-]+z [,*")([\]]z[~:+_ -]z\.$z (\d+(\.\d+)*)cCsL|��}tD]\}}|�||�}q|s.d}t�|�}|sFd}|}n�|��d�d�}dd�|D�}t|�dkr~|� d�qft|�dkr�||� �d�}n8d�dd�|dd�D��||� �d�}|dd�}d�d d�|D��}|��}|�rtD]\}}|�||�}q�|�s|}nd |k�r*dnd}|||}t |��sHd}|S) z� Try to suggest a semantic form for a version for which _suggest_normalized_version couldn't come up with anything. z0.0.0rrfcSsg|]}t|��qSrrar�rrrr��sz-_suggest_semantic_version..�NcSsg|]}t|��qSrr�r�rrrr��scSsg|]}t|��qSrr�r�rrrr��sry�-r�)rrL� _REPLACEMENTS�sub�_NUMERIC_PREFIXr]rtrur^rO�endr��_SUFFIX_REPLACEMENTS� is_semver)rr_Zpat�replrwrS�suffix�seprrr�_suggest_semantic_version�s: , r�cCshzt|�|WStk r"YnX|��}dD]\}}|�||�}q0t�dd|�}t�dd|�}t�dd|�}t�dd |�}t�d d|�}|�d�r�|d d�}t�dd|�}t�dd|�}t�dd|�}t�dd|�}t�dd|�}t�dd|�}t�dd|�}t�dd|�}t�dd|�}t�dd|�}t�dd |�}zt|�Wntk �rbd}YnX|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-alpharo)z-betar~)r�ro)r�r~)rr<)z-finalr�)z-prer<)z-releaser�)z.releaser�)z-stabler�)r�rf)rqrf)� r�)z.finalr�)rrr�zpre$Zpre0zdev$Zdev0z([abc]|rc)[\-\.](\d+)$z\1\2z[\-\.](dev)[\-\.]?r?(\d+)$z.\1\2z[.~]?([abc])\.?r�r;rNz\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|rrL�replace�rer�r�)rZrsZorigr�rrr�_suggest_normalized_version�s> r�z([a-z]+|\d+|[\.-])r<zfinal-�@)rxZpreviewr�rryr�rfcCsrdd�}g}||�D]T}|�d�r^|dkrD|rD|ddkrD|��q*|r^|ddkr^|��qD|�|�qt|�S)NcSstg}t�|��D]R}t�||�}|rd|dd�krBdkrRnn|�d�}nd|}|�|�q|�d�|S)N�0r�9��*�*final)� _VERSION_PARTrurL�_VERSION_REPLACErV�zfillrO)rr_r=rrr� get_partsCs z_legacy_key..get_partsr�r�rgz*final-Z00000000)r��poprOrP)rr�r_r=rrr�_legacy_keyBs r�c@s eZdZdd�Zedd��ZdS)rcCst|�Sr)r�r rrrr]szLegacyVersion.parsecCs8d}|jD](}t|t�r |�d�r |dkr d}q4q |S)NFr�r�T)rrTrr�)rr_r�rrrr7`s �zLegacyVersion.is_prereleaseN�rrrrr8r7rrrrr\sc@s4eZdZeZeej�Zded<e� d�Z dd�ZdS)r r�rFz^(\d+(\.\d+)*)cCs`||krdS|j�t|��}|s2t�d||�dS|��d}d|krV|�dd�d}t||�S)NFzACannot compute compatible match for version %s and constraint %sTrrfr)� numeric_rer]r��loggerZwarningrt�rsplitr�)rrXrZrSrwrrrrr�ss�zLegacyMatcher._match_compatibleN)rrrrrI�dictr9rUr��compiler�r�rrrrr ks zN^(\d+)\.(\d+)\.(\d+)(-[a-z0-9]+(\.[a-z0-9-]+)*)?(\+[a-z0-9]+(\.[a-z0-9-]+)*)?$cCs t�|�Sr)� _SEMVER_REr])rrrrr��sr�c Csndd�}t|�}|st|��|��}dd�|dd�D�\}}}||dd�||dd�}}|||f||fS) NcSs8|dkr|f}n$|dd��d�}tdd�|D��}|S)NrrfcSs"g|]}|��r|�d�n|�qS)r�)rvr�)rdr=rrrr��sz5_semantic_key..make_tuple..)rurP)rZabsentr_rrrr� make_tuple�s z!_semantic_key..make_tuplecSsg|]}t|��qSrrar�rrrr��sz!_semantic_key..r��|�r�)r�rrt) rr�rwrt�major�minorZpatchrxZbuildrrr� _semantic_key�s r�c@s eZdZdd�Zedd��ZdS)r cCst|�Sr)r�r rrrr�szSemanticVersion.parsecCs|jdddkS)Nrrr�)rr0rrrr7�szSemanticVersion.is_prereleaseNr�rrrrr �sc@seZdZeZdS)rN)rrrr rIrrrrr�sc@s6eZdZddd�Zdd�Zdd�Zdd �Zd d�ZdS) � VersionSchemeNcCs||_||_||_dSr)rM�matcher� suggester)rrMr�r�rrrr�szVersionScheme.__init__cCs2z|j�|�d}Wntk r,d}YnX|S�NTF)r�rIr�rrr_rrr�is_valid_version�s zVersionScheme.is_valid_versioncCs0z|�|�d}Wntk r*d}YnX|Sr�)r�rr�rrr�is_valid_matcher�s zVersionScheme.is_valid_matchercCs|�d|�S)z: Used for processing some metadata fields zdummy_name (%s))r�r rrr�is_valid_constraint_list�sz&VersionScheme.is_valid_constraint_listcCs|jdkrd}n |�|�}|Sr)r�r�rrr�suggest�s zVersionScheme.suggest)N)rrrrr�r�r�r�rrrrr��s r�cCs|Srrr rrrr>�r?r>)� normalized�legacyZsemanticr��defaultcCs|tkrtd|��t|S)Nzunknown scheme name: %r)�_SCHEMESrJ)rKrrrr �s)*rZloggingr��compatr�utilr�__all__Z getLoggerrr�rJr�objectrr9r�rsr{r|rr�rr�r�r�r�r��Ir�r�r�rr r�r�r�r rr�r�r rrrr�s�� 1d =$W�� .r�� $��