/opt/cloudlinux/venv/lib/python3.11/site-packages/semver/__pycache__/
/opt/cloudlinux/venv/lib/python3.11/site-packages/semver/__pycache__
NameSizeModeActions
cli.cpython-311.pyc76680644editdlrm
version.cpython-311.pyc329530644editdlrm
_deprecated.cpython-311.pyc152350644editdlrm
_types.cpython-311.pyc9320644editdlrm
__about__.cpython-311.pyc9110644editdlrm
__init__.cpython-311.pyc15840644editdlrm
__main__.cpython-311.pyc14140644editdlrm
Edit: /opt/cloudlinux/venv/lib/python3.11/site-packages/semver/__pycache__/version.cpython-311.pyc (32953B)
i=e4dZddlZddlZddlmZddlmZmZmZm Z m Z m Z m Z m Z mZmZmZmZddlmZmZmZmZmZe deeefeeefZedegefZedd Zd ed efd Zd ZGddZeZ dS)z6Version handling by a semver compatible version class.N)wraps) AnyDictIterableOptional SupportsIntTupleUnioncastCallable CollectionTypeTypeVar) VersionTuple VersionDictVersionIteratorString VersionPartVersionT)boundoperatorreturnc^tdddtdtffd }|S)z0Wrap a Version binary op method in a type-check.selfrotherrcttttgtjR}t ||stS||SN)rdicttuplelistr__args__ isinstanceNotImplemented)rrcomparable_typesrs `/builddir/build/BUILD/cloudlinux-venv-1.0.12/venv/lib/python3.11/site-packages/semver/version.pywrapperz_comparator..wrapper'sW      _   %!122 "! !xe$$$)r Comparablebool)rr(s` r' _comparatorr,$sO 8__ %i % %t % % % % %_ % Nr)c||k||kz S)z6Return negative if ab.abs r'_cmpr27s Ea!e r)cteZdZdZdZedeDZejdZ dZ eje ddej Z eje ddej Z dFd ed ed edeeeefdeeeeff dZedZedefdZejdZedefdZejdZedefdZejdZedeefdZejdZedeefdZejdZdefdZ de!fdZ"de#fdZ$e%d edefd!Z&dGd"Z'dGd#Z(dGd$Z)dHd&eeddfd'Z*dId&eeddfd(Z+d)e,defd*Z-dHd+ed,eddfd-Z.e/d)e,de0fd.Z1e/d)e,de0fd/Z2e/d)e,de0fd0Z3e/d)e,de0fd1Z4e/d)e,de0fd2Z5e/d)e,de0fd3Z6d4eee7fdeeeee8eeefd5fffd6Z9defd7Z:defd8Z;defd9Ze dJd>e?e@d?ed@e0de@fdAZAdBeeeefddfdCZBed?ede0fdDZCd)dde0fdEZDd S)Kra A semver compatible version class. See specification at https://semver.org. :param major: version when you make incompatible API changes. :param minor: version when you add functionality in a backwards-compatible manner. :param patch: version when you make backwards-compatible bug fixes. :param prerelease: an optional prerelease string :param build: an optional build string )_major_minor_patch _prerelease_buildc"g|] }|dd S)rNr.).0items r' zVersion.Ls 22248222r)z(?:[^\d]*(\d+)[^\d]*)+a3 ^ (?P0|[1-9]\d*) (?: \. (?P0|[1-9]\d*) (?: \. (?P0|[1-9]\d*) ){opt_patch} ){opt_minor} (?:-(?P (?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*) (?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))* ))? (?:\+(?P [0-9a-zA-Z-]+ (?:\.[0-9a-zA-Z-]+)* ))? $ ) opt_patch opt_minor?rNmajorminorpatch prereleasebuildct|t|t|d}|D]-\}}|dkr"td|.|d|_|d|_|d|_|dnt||_|dnt||_ dS)N)rArBrCrz1{!r} is negative. A version can only be positive.rArBrC) intitems ValueErrorformatr4r5r6strr7r8) rrArBrCrDrE version_partsnamevalues r'__init__zVersion.__init__qs#&e**s5zzCPUJJWW (..00  KD%qyy GNNtTT $G, #G, #G, #-#5443z??#mddU r)cHd}|pd|pd}}|d|d}}d|D}d|D}t||D]\}}|||}|dkr|cStt|t|S)Nct|tr%t|trt||St|trdSt|trdSt||S)Nr)r$rGr2r/s r'cmp_prerelease_tagz,Version._nat_cmp..cmp_prerelease_tagso!S!! "jC&8&8 "Aqzz!As## "rAs## "qAqzz!r)r=.cZg|](}tjd|rt|n|)Sz^\d+$rematchrGr:xs r'r<z$Version._nat_cmp..3KKKaRXh2293q666KKKr)cZg|](}tjd|rt|n|)SrVrWrZs r'r<z$Version._nat_cmp..r\r)r)splitzipr2len) clsr0r1rSa_partsb_partssub_asub_b cmp_results r'_nat_cmpzVersion._nat_cmps " " "wBR1773<<KK7KKKKK7KKK11 ( (LE5++E599JQ!!!!AA'' 'r)rc|jS)z(The major part of a version (read-only).)r4rs r'rAz Version.major {r)c td)Nzattribute 'major' is readonlyAttributeErrorrrNs r'rAz Version.major<===r)c|jS)z(The minor part of a version (read-only).)r5ris r'rBz Version.minorrjr)c td)Nzattribute 'minor' is readonlyrlrns r'rBz Version.minorror)c|jS)z(The patch part of a version (read-only).)r6ris r'rCz Version.patchrjr)c td)Nzattribute 'patch' is readonlyrlrns r'rCz Version.patchror)c|jS)z-The prerelease part of a version (read-only).)r7ris r'rDzVersion.prereleases r)c td)Nz"attribute 'prerelease' is readonlyrlrns r'rDzVersion.prereleasesABBBr)c|jS)z(The build part of a version (read-only).)r8ris r'rEz Version.buildrjr)c td)Nzattribute 'build' is readonlyrlrns r'rEz Version.buildror)cB|j|j|j|j|jfS)a[ Convert the Version object to a tuple. .. versionadded:: 2.10.0 Renamed :meth:`Version._astuple` to :meth:`Version.to_tuple` to make this function available in the public API. :return: a tuple with all the parts >>> semver.Version(5, 3, 1).to_tuple() (5, 3, 1, None, None) rArBrCrDrEris r'to_tuplezVersion.to_tuples DJ DOTZPPr)cztjd|jfd|jfd|jfd|jfd|jffS)a Convert the Version object to an OrderedDict. .. versionadded:: 2.10.0 Renamed :meth:`Version._asdict` to :meth:`Version.to_dict` to make this function available in the public API. :return: an OrderedDict with the keys in the order ``major``, ``minor``, ``patch``, ``prerelease``, and ``build``. >>> semver.Version(3, 2, 1).to_dict() OrderedDict([('major', 3), ('minor', 2), ('patch', 1), ('prerelease', None), ('build', None)]) rArBrCrDrE) collections OrderedDictrArBrCrDrEris r'to_dictzVersion.to_dictsP&$*%$*%$*%t/$*%     r)c#>K|Ed{VdS)zReturn iter(self).N)rzris r'__iter__zVersion.__iter__s,==??"""""""""r)stringcHtj|}|rtt |ddz}|d\}}|dt|t|z ||z||dz}|S)a Look for the last sequence of number(s) in a string and increment. :param string: the string to search for. :return: the incremented string Source: http://code.activestate.com/recipes/442460-increment-numbers-in-a-string/#c1 rN) r _LAST_NUMBERsearchrKrGgroupspanmaxr`)rrYnext_startends r'_increment_stringzVersion._increment_strings$++F33  SEKKNN++a/00EAJE3:c#E "2E:::;eCfSTTlRF r)cFt|}||jdzS)a2 Raise the major part of the version, return a new object but leave self untouched. :return: new object with the raised major part >>> ver = semver.parse("3.4.5") >>> ver.bump_major() Version(major=4, minor=0, patch=0, prerelease=None, build=None) r)typer4rras r' bump_majorzVersion.bump_major s%4jjs4;?###r)cRt|}||j|jdzS)a2 Raise the minor part of the version, return a new object but leave self untouched. :return: new object with the raised minor part >>> ver = semver.parse("3.4.5") >>> ver.bump_minor() Version(major=3, minor=5, patch=0, prerelease=None, build=None) r)rr4r5rs r' bump_minorzVersion.bump_minors)4jjs4; a000r)c^t|}||j|j|jdzS)a2 Raise the patch part of the version, return a new object but leave self untouched. :return: new object with the raised patch part >>> ver = semver.parse("3.4.5") >>> ver.bump_patch() Version(major=3, minor=4, patch=6, prerelease=None, build=None) r)rr4r5r6rs r' bump_patchzVersion.bump_patch&s-4jjs4; T[1_===r)rctokenct|}|j|j}n |dkrd}n|d}nt|dz}||}||j|j|j|S)a Raise the prerelease part of the version, return a new object but leave self untouched. :param token: defaults to ``'rc'`` :return: new :class:`Version` object with the raised prerelease part. The original object is not modified. >>> ver = semver.parse("3.4.5") >>> ver.bump_prerelease().prerelease 'rc.2' >>> ver.bump_prerelease('').prerelease '1' >>> ver.bump_prerelease(None).prerelease 'rc.1' Nr=0zrc.0.0)rr7rKrr4r5r6)rrrarDs r'bump_prereleasezVersion.bump_prerelease4s}"4jj   ')JJ b[[JJ ]JJUd*J**:66 s4; T[*EEEr)cvt|}|j|j}n |dkrd}n|d}nt|dz}||}|j|j}n |dkrd}n|d}nt|dz}||}||j|j|j|j|S)a Raise the build part of the version, return a new object but leave self untouched. :param token: defaults to ``'build'`` :return: new :class:`Version` object with the raised build part. The original object is not modified. >>> ver = semver.parse("3.4.5-rc.1+build.9") >>> ver.bump_build() Version(major=3, minor=4, patch=5, prerelease='rc.1', build='build.10') Nr=rzbuild.0r)rr8rKrr4r5r6r7)rrrarEs r' bump_buildzVersion.bump_buildRs4jj ; "KEE b[[EE ]EEJJ%E%%e,, ; "KEE b[[EE ]EEJJ%E%%e,,s4; T[$:JERRRr)rcjt|}t|tjr||}nwt|t r |di|}nYt|t tfr||}n7t||s'td|j dt|| dd}| dd}t||}|r|S|j |j }}| ||}|sdS|sdS|sdS|S) a Compare self with other. :param other: the second version :return: The return value is negative if ver1 < ver2, zero if ver1 == ver2 and strictly positive if ver1 > ver2 >>> semver.compare("2.0.0") -1 >>> semver.compare("1.0.0") 1 >>> semver.compare("2.0.0") 0 >>> semver.compare(dict(major=2, minor=0, patch=0)) 0 z+Expected str, bytes, dict, tuple, list, or z instance, but got NrrrRr.)rr$rr#parser r!r" TypeError__name__rzr2rDrg) rrrav1v2r[rc1rc2rccmps r'comparezVersion.compareys_"4jj eV_ - - IIe$$EE t $ $ CLL%LLEE t} - - CKEEE3'' )cl));;))  ]]__RaR  ^^  bqb ! RLL  H?E$4S c3'' 1 1 2 r)partprerelease_tokenct|}|jdd}||vrtd|d||}|js|jrN|dks1|dkr |jdks |dkr1|j|jcxkrdkrnn|dd S||jdd vrt|d |zS|js| }| |S) a Determines next version, preserving natural order. .. versionadded:: 2.10.0 This function is taking prereleases into account. The "major", "minor", and "patch" raises the respective parts like the ``bump_*`` functions. The real difference is using the "prerelease" part. It gives you the next patch version of the prerelease, for example: >>> str(semver.parse("0.1.4").next_version("prerelease")) '0.1.5-rc.1' :param part: One of "major", "minor", "patch", or "prerelease" :param prerelease_token: prefix string of prerelease, defaults to 'rc' :return: new object with the appropriate part raised NrRzInvalid part. Expected one of z , but got rCrBrrA)rDrErbump_) rNAMESrIrDrErCrBreplacegetattrrr)rrrra validpartsversions r' next_versionzVersion.next_versions1&4jjYss^ z ! !OOOtOO    @'- @ GOOGMQ$6$6GMW]$G$G$G$Ga$G$G$G$G$G??d$??? ? 39RaR= 377GdN3355 5! +((**G&&'7888r)c4||dkSNrrrrs r'__eq__zVersion.__eq__||E""a''r)c4||dkSrrrs r'__ne__zVersion.__ne__rr)c4||dkSrrrs r'__lt__zVersion.__lt__||E""Q&&r)c4||dkSrrrs r'__le__zVersion.__le__rr)c4||dkSrrrs r'__gt__zVersion.__gt__rr)c4||dkSrrrs r'__ge__zVersion.__ge__rr)index.c t|trt||dz}tt|}t|tr|j |jdks|j|jdkrt dttdtt| |}t|dkr|dS|st d|S)a[ self.__getitem__(index) <==> self[index] Implement getitem. If the part requested is undefined, or a part of the range requested is undefined, it will throw an index error. Negative indices are not supported. :param index: a positive integer indicating the offset or a :func:`slice` object :raises IndexError: if index is beyond the range or a part is None :return: the requested part of the version at position index >>> ver = semver.Version.parse("3.4.5") >>> ver[0], ver[1], ver[2] (3, 4, 5) rNrz Version index cannot be negativec |duSrr.)ps r'z%Version.__getitem__.. s Qd]r)zVersion part undefined) r$rGslicer rstop IndexErrorr!filterrrzr`)rrrs r' __getitem__zVersion.__getitem__s& eS ! ! ,%++EUE"" ue $ $ A(U[1__ &5:>>?@@ @ **D4==??5;Q,R,R S S   t99>>7N 7566 6 r)cdd|D}t|jd|dS)N, c3*K|]\}}|d|VdS)=Nr.)r:keyvals r' z#Version.__repr__..s1RRxsCcc*RRRRRRr)())joinr~rHrr)rss r'__repr__zVersion.__repr__sT IIRR4<<>>;O;O;Q;QRRR R R::...22r)cd|j|j|jfz}|jr |d|jzz }|jr |d|jzz }|S)Nz%d.%d.%dz-%sz+%sry)rrs r'__str__zVersion.__str__sT DJ CC ? / ut. .G : * utz) )Gr)cTt|ddS)N)hashrzris r'__hash__zVersion.__hash__s!DMMOOBQB'(((r)cXt|}||j|j|jS)z Remove any prerelease and build metadata from the version. :return: a new instance with the finalized version string >>> str(semver.Version.parse('1.2.3-rc.5').finalize_version()) '1.2.3' )rrArBrCrs r'finalize_versionzVersion.finalize_version"s)4jjs4:tz4:666r) match_exprc |dd}|dvr |dd}nB|r|ddvr|d}|dd}n#|r|ddvrd}|}ntd |zd d d d ddd}||}||}||vS)a Compare self to match a match expression. :param match_expr: optional operator and version; valid operators are ``<`` smaller than ``>`` greater than ``>=`` greator or equal than ``<=`` smaller or equal than ``==`` equal ``!=`` not equal :return: True if the expression matches the version, otherwise False >>> semver.Version.parse("2.0.0").match(">=1.0.0") True >>> semver.Version.parse("1.0.0").match(">1.0.0") False >>> semver.Version.parse("4.0.4").match("4.0.4") True N)>=<===!=r)>, where is one of ['<', '>', '==', '<=', '>=', '!=']. You provided: %r)r)rR)r)rRr)rr)rRr)rrrrrr)rIr)rrprefix match_versionpossibilities_dict possibilitiescmp_ress r'rYz Version.match.s(BQB - - -&qrrNMM  q Z//AYF&qrrNMM  JqM\99F&MM#&00    +62 ,,}---''r)Fraroptional_minor_and_patchct|tr|d}n9t|tjst dt |z|r|j|}n|j |}|t|d| }|dsd|d<|dsd|d<|di|S) a Parse version string to a Version instance. .. versionchanged:: 2.11.0 Changed method from static to classmethod to allow subclasses. .. versionchanged:: 3.0.0 Added optional parameter ``optional_minor_and_patch`` to allow optional minor and patch parts. :param version: version string :param optional_minor_and_patch: if set to true, the version string to parse can contain optional minor and patch parts. Optional parts are set to zero. By default (False), the version string to parse has to follow the semver specification. :return: a new :class:`Version` instance :raises ValueError: if version is invalid :raises TypeError: if version contains the wrong type >>> semver.Version.parse('3.4.5-pre.2+build.4') Version(major=3, minor=4, patch=5, prerelease='pre.2', build='build.4') zUTF-8znot expecting type '%s'Nz is not valid SemVer stringrBrrCr.) r$bytesdecoderr#rr_REGEX_OPTIONAL_MINOR_AND_PATCHrY_REGEXrI groupdict)rarrrYmatched_version_partss r'rz Version.parseas6 gu % % GnnW--GGGV_55 G5W EFF F # .7==gFFEEJ$$W--E =DDDEE E050A0A$W- /-. !' *$W- /-. !' *s++*+++r)partsc X|}|| tdi|S#t$rht |t |z }dt |d|fz}t|wxYw)a Replace one or more parts of a version and return a new :class:`Version` object, but leave self untouched .. versionadded:: 2.9.0 Added :func:`Version.replace` :param parts: the parts to be updated. Valid keys are: ``major``, ``minor``, ``patch``, ``prerelease``, or ``build`` :return: the new :class:`~semver.version.Version` object with the changed parts :raises TypeError: if ``parts`` contain invalid keys z3replace() got %d unexpected keyword argument(s): %srNr.)r~updaterrsetr`r)rrr unknownkeyserrors r'rzVersion.replaces,,..u #%%W%% % # # #e**s4<<>>':'::KIK   +&&MEE"" "  #s 7A2B)cT ||dS#t$rYdSwxYw)ab Check if the string is a valid semver version. .. versionadded:: 2.9.1 .. versionchanged:: 3.0.0 Renamed from :meth:`~semver.version.Version.isvalid` :param version: the version string to check :return: True if the version string is a valid semver version, False otherwise. TF)rrI)rars r'is_validzVersion.is_valids@  IIg   4   55 s  ''c.t|tstdt|d|jcxkr |jkrnn|dd|ddkrdS|j|jko|j|jko|j|jkS)aC Check if current version is compatible with other version. The result is True, if either of the following is true: * both versions are equal, or * both majors are equal and higher than 0. Same for both minors. Both pre-releases are equal, or * both majors are equal and higher than 0. The minor of b's minor version is higher then a's. Both pre-releases are equal. The algorithm does *not* check patches. .. versionadded:: 3.0.0 :param other: the version to check for compatibility :return: True, if ``other`` is compatible with the old version, otherwise False >>> Version(1, 1, 0).is_compatible(Version(1, 0, 0)) False >>> Version(1, 0, 0).is_compatible(Version(1, 1, 0)) True z Expected a Version type but got rNrF)r$rrrrArBrDrs r' is_compatiblezVersion.is_compatibles2%)) NLtE{{LLMM M  * * * *u{ * * * * *bqbU2A2Y1F1F5Z5; & 6 * 6E$44 r))rrNN)rr)r)rE)F)Er __module__ __qualname____doc__ __slots__r!rrXcompiler_REGEX_TEMPLATErJVERBOSErrrrr rrGrO classmethodrgpropertyrAsetterrBrCrKrDrErrzrr~rr staticmethodrrrrrrr*rrr,r+rrrrrrrr rrrrrrYrrrrrrr.r)r'rr<s  HI E22 222 3 3E2:788L O,RZr:: F '1bj<< ''#37.2 <<<< < U63;/0 < fck*+ <<<<.(([(,sX \>>\>sX \>>\>sX \>>\> HSM   X CCCx}X \>>\> Q, Q Q Q Q     2#/######\" $ $ $ $ 1 1 1 1 > > > >FFXc]FiFFFF<%S%S %SI%S%S%S%SN.Z.C....`(9(9(9(9y(9(9(9(9T(J(4((([((J(4((([('J'4'''['(J(4((([('J'4'''['(J(4((([(&3:&& sHSM5sCx#)=#>> ?&&&&P3#3333)#)))) 7 7 7 71(1(1(1(1(1(fHM,,,, !W,,%,,AE,, ,,,,,,[,,\#uS(3-%78#Y####4st[&$ 9$ $ $ $ $ $ $ r))!rr|rX functoolsrtypingrrrrrr r r r r rr_typesrrrrrrKr*r+ Comparatorrr,r2r VersionInfor.r)r'rs<<                             9d3 #34j6MsR S y*-t3 4  GCy!!!*& f  f  f  f  f  f  f  f  T r)