a Ra[ @sZdZddlZddlZddlmZddlmZgdZee Z Gddde Z Gd d d e ZGd d d e Zed ZddZeZGdddeZddZGdddeZeddfeddfeddfeddfeddfeddfed d!fed"d#fed$d%fed&d'ff Zed(dfed)dfed*d!fed d!fed+dffZed,Zd-d.Zd/d0Zed1ejZd2d2d3d2d4ddd5Zd6d7ZGd8d9d9eZ Gd:d;d;eZ!edZ#d?d@Z$GdAdBdBeZ%GdCdDdDeZ&GdEdFdFe Z'e'eeee'ee!dGdHe'e$e&edIZ(e(dJe(dK<dLdMZ)dS)Nz~ Implementation of a flexible versioning scheme providing support for PEP-440, setuptools-compatible and semantic versioning. N) string_typesparse_requirement)NormalizedVersionNormalizedMatcher LegacyVersion LegacyMatcherSemanticVersionSemanticMatcherUnsupportedVersionError get_schemec@seZdZdZdS)r zThis is an unsupported version.N)__name__ __module__ __qualname____doc__rrL/opt/alt/python39/lib/python3.9/site-packages/pip/_vendor/distlib/version.pyr sr c@sxeZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZeddZdS)VersioncCs"||_}|||_}dSN)strip_stringparse_parts)selfspartsrrr__init__szVersion.__init__cCs tddS)Nzplease implement in a subclassNotImplementedErrorrrrrrr%sz Version.parsecCs$t|t|kr td||fdS)Nzcannot compare %r and %r)type TypeErrorrotherrrr_check_compatible(szVersion._check_compatiblecCs|||j|jkSrr%rr#rrr__eq__,s zVersion.__eq__cCs || Srr'r#rrr__ne__0szVersion.__ne__cCs|||j|jkSrr&r#rrr__lt__3s zVersion.__lt__cCs||p|| Srr*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|jSr)hashrrrrr__hash__AszVersion.__hash__cCsd|jj|jfS)Nz%s('%s') __class__rrr0rrr__repr__DszVersion.__repr__cCs|jSrrr0rrr__str__GszVersion.__str__cCs tddS)NzPlease implement in subclasses.rr0rrr is_prereleaseJszVersion.is_prereleaseN)rrrrrr%r'r)r*r,r-r.r1r4r6propertyr7rrrrrsrc @seZdZdZddddddddddddd dd dd Zd d ZddZddZeddZ ddZ ddZ ddZ ddZ ddZddZdS) MatcherNcCs||kSrrvcprrrTzMatcher.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|jdurtd||_}||}|s:td||j|_|j|_g}|jr|jD]d\}}| dr|dvrtd||ddd}}||n||d}}| |||fq^t ||_ dS) NzPlease specify a version classz Not valid: %rz.*)rDrGz#'.*' not allowed for %r constraintsTF) version_class ValueErrorrrrnamelowerkey constraintsendswithappendtupler)rrrZclistopZvnprefixrrrrds*      zMatcher.__init__cCsxt|tr||}|jD]X\}}}|j|}t|trDt||}|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 _operatorsgetgetattrr3rr)rversionoperator constraintrTfmsgrrrmatchs       z Matcher.matchcCs6d}t|jdkr2|jdddvr2|jdd}|S)Nrr)rDrE)lenr)rresultrrr exact_versions zMatcher.exact_versioncCs0t|t|ks|j|jkr,td||fdS)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|jt|jSr)r/rMrr0rrrr1szMatcher.__hash__cCsd|jj|jfS)Nz%s(%r)r2r0rrrr4szMatcher.__repr__cCs|jSrr5r0rrrr6szMatcher.__str__)rrrrIrVrrr^r8rar%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]+)?))?$c Cs|}t|}|s"td||}tdd|ddD}t|dkrl|ddkrl|dd}qF|dszd}nt|ddd}|dd }|d d }|d d }|d}|dkrd}n|dt|df}|dkrd}n|dt|df}|dkrd}n|dt|df}|dur2d}nHg} |dD]0} | r\dt| f} nd| f} | | q@t| }|s|s|rd}nd}|sd}|sd}||||||fS)NzNot a valid version: %scss|]}t|VqdSrint.0r;rrr r?z_pep_440_key..r.r )NNr)arh)z)_)final) rPEP440_VERSION_REr^r groupsrQsplitr_rcisdigitrP) rmruZnumsZepochpreZpostdevZlocalrpartrrr _pep_440_keysT         r|c@s0eZdZdZddZegdZeddZdS)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|ddD|_|S)Ncss|]}t|VqdSrrbrdrrrrfr?z*NormalizedVersion.parse..rrg)_normalized_keyrtr^rurQrv_release_clause)rrr`rxrurrrr s  zNormalizedVersion.parse)rpbr<rcrzcstfddjDS)Nc3s |]}|r|djvVqdS)rN) PREREL_TAGS)retr0rrrfr?z2NormalizedVersion.is_prerelease..)anyrr0rr0rr7szNormalizedVersion.is_prereleaseN) rrrrrsetrr8r7rrrrrs  rcCs>t|}t|}||krdS||s*dSt|}||dkS)NTFrg)str startswithr_)xynrrr _match_prefixs rc @sneZdZeZddddddddd Zd d Zd d ZddZddZ ddZ ddZ ddZ ddZ ddZdS)r_match_compatible _match_lt _match_gt _match_le _match_ge _match_eq_match_arbitrary _match_ne)rFr@rArBrCrDrErGcCsV|rd|vo|jd}n|jd o,|jd}|rN|jddd}||}||fS)N+rhrr)rrrvrI)rrYr[rTZ strip_localrrrr _adjust_local6s zNormalizedMatcher._adjust_localcCsD||||\}}||krdS|j}ddd|D}t|| S)NFrgcSsg|] }t|qSrrreirrr Ir?z/NormalizedMatcher._match_lt..rr~joinrrrYr[rTZrelease_clauseZpfxrrrrDs zNormalizedMatcher._match_ltcCsD||||\}}||krdS|j}ddd|D}t|| S)NFrgcSsg|] }t|qSrrrrrrrQr?z/NormalizedMatcher._match_gt..rrrrrrLs zNormalizedMatcher._match_gtcCs||||\}}||kSrrrrYr[rTrrrrTszNormalizedMatcher._match_lecCs||||\}}||kSrrrrrrrXszNormalizedMatcher._match_gecCs.||||\}}|s ||k}n t||}|SrrrrrYr[rTr`rrrr\s   zNormalizedMatcher._match_eqcCst|t|kSrrrrrrrdsz"NormalizedMatcher._match_arbitrarycCs0||||\}}|s ||k}n t|| }|Srrrrrrrgs   zNormalizedMatcher._match_necCsf||||\}}||krdS||kr*dS|j}t|dkrH|dd}ddd|D}t||S)NTFrrhrgcSsg|] }t|qSrrrrrrrzr?z7NormalizedMatcher._match_compatible..)rr~r_rrrrrrros  z#NormalizedMatcher._match_compatibleN)rrrrrIrVrrrrrrrrrrrrrr's& rz[.+-]$z^[.](\d)z0.\1z^[.-]z ^\((.*)\)$\1z^v(ersion)?\s*(\d+)z\2z^r(ev)?\s*(\d+)z[.]{2,}rgz\b(alfa|apha)\balphaz\b(pre-alpha|prealpha)\bz pre.alphaz \(beta\)$betaz ^[:~._+-]+z [,*")([\]]z[~:+_ -]z\.$z (\d+(\.\d+)*)cCsL|}tD]\}}|||}q|s.d}t|}|sFd}|}n|dd}dd|D}t|dkr~| dqft|dkr|| d}n8d dd|ddD|| d}|dd}d d d|D}|}|rt D]\}}|||}q|s|}nd |vr*d nd }|||}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.0rrgcSsg|] }t|qSrrbrrrrrr?z-_suggest_semantic_version..NcSsg|] }t|qSrrrrrrrr?cSsg|] }t|qSrrrrrrrr?rz-r)rrL _REPLACEMENTSsub_NUMERIC_PREFIXr^rurvr_rPendr_SUFFIX_REPLACEMENTS is_semver)rr`patreplrxrTsuffixseprrr_suggest_semantic_versions:      ,    rcCsdzt||WSty Yn0|}dD]\}}|||}q.tdd|}tdd|}tdd|}tdd |}td d |}|d r|d d}tdd |}tdd|}tdd|}tdd|}tdd|}tdd|}tdd|}tdd|}tdd|}tdd|}tdd |}z t|Wnty^d}Yn0|S)!aSuggest 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-alpharp)z-betar)rrp)rr)rr<)z-finalr)z-prer<)z-releaser)z.releaser)z-stabler)rrg)rrrg) r)z.finalr)rsrzpre$Zpre0zdev$Zdev0z([abc]|rc)[\-\.](\d+)$z\1\2z[\-\.](dev)[\-\.]?r?(\d+)$z.\1\2z[.~]?([abc])\.?rr;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)$rz\.?(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 rLreplacererr)rZrsZorigrrrr_suggest_normalized_versions>       rz([a-z]+|\d+|[\.-])r<zfinal-@)ryZpreviewrrrzrrgcCsrdd}g}||D]T}|dr^|dkrD|rD|ddkrD|q*|r^|ddkr^|qD||qt|S)NcSstg}t|D]R}t||}|rd|ddkrBdkrRnn |d}nd|}||q|d|S)N0r9**final) _VERSION_PARTrvrL_VERSION_REPLACErWzfillrP)rr`r=rrr get_partsCs     z_legacy_key..get_partsrrrhz*final-Z00000000)rpoprPrQ)rrr`r=rrr _legacy_keyBs      rc@s eZdZddZeddZdS)rcCst|Sr)rr rrrr]szLegacyVersion.parsecCs8d}|jD](}t|tr |dr |dkr d}q4q |S)NFrrT)rrUrr)rr`rrrrr7`s zLegacyVersion.is_prereleaseNrrrrr8r7rrrrr\src@s4eZdZeZeejZded<e dZ ddZ dS)r rrFz^(\d+(\.\d+)*)cCs`||kr dS|jt|}|s2td||dS|d}d|vrV|ddd}t||S)NFzACannot compute compatible match for version %s and constraint %sTrrgr) numeric_rer^rloggerZwarningrursplitr)rrYr[rTrxrrrrrss zLegacyMatcher._match_compatibleN) rrrrrIdictr9rVrcompilerrrrrrr ks   r zN^(\d+)\.(\d+)\.(\d+)(-[a-z0-9]+(\.[a-z0-9-]+)*)?(\+[a-z0-9]+(\.[a-z0-9-]+)*)?$cCs t|Sr) _SEMVER_REr^)rrrrrsrc Csndd}t|}|st||}dd|ddD\}}}||dd||dd}}|||f||fS) NcSs8|dur|f}n$|ddd}tdd|D}|S)NrrgcSs"g|]}|r|dn|qS)r)rwr)rer=rrrrr?z5_semantic_key..make_tuple..)rvrQ)rZabsentr`rrrr make_tuples z!_semantic_key..make_tuplecSsg|] }t|qSrrbrrrrrr?z!_semantic_key..r|r)rr ru) rrrxrumajorminorZpatchryZbuildrrr _semantic_keys rc@s eZdZddZeddZdS)r cCst|Sr)rr rrrrszSemanticVersion.parsecCs|jdddkS)Nrrr)rr0rrrr7szSemanticVersion.is_prereleaseNrrrrrr sr c@seZdZeZdS)r N)rrrr rIrrrrr sr c@s6eZdZd ddZddZddZdd Zd d ZdS) VersionSchemeNcCs||_||_||_dSr)rMmatcher suggester)rrMrrrrrrszVersionScheme.__init__cCs0z|j|d}Wnty*d}Yn0|SNTF)rrIr rrr`rrris_valid_versions    zVersionScheme.is_valid_versioncCs.z||d}Wnty(d}Yn0|Sr)rr rrrris_valid_matchers    zVersionScheme.is_valid_matchercCs$|dr|dd}|d|S)z: Used for processing some metadata fields ,Nrhzdummy_name (%s))rOrr rrris_valid_constraint_lists  z&VersionScheme.is_valid_constraint_listcCs|jdurd}n ||}|Sr)rrrrrsuggests  zVersionScheme.suggest)N)rrrrrrrrrrrrrs   rcCs|Srrr rrrr>r?r>) normalizedlegacyZsemanticrdefaultcCs|tvrtd|t|S)Nzunknown scheme name: %r)_SCHEMESrJ)rKrrrr s r )*rZloggingrcompatrutilr__all__Z getLoggerrrrJr objectrr9rrtr|r}rrrrrrrrIrrrrr rrrr r rrr rrrrs   1d =$ W               .r  '