.Ph]>dZddlZddlmZddlmZmZmZmZm Z m Z m Z m Z m Z mZmZmZmZmZddlmZmZmZmZmZe deeefeeefZedegefZedd Zed eeeZ d ed efd Z!de de d efdZ"GddZ#e#Z$dS)z6Version handling by a semver compatible version class.N)wraps)AnyClassVarDictIterableOptionalPattern SupportsIntTupleUnioncastCallable CollectionTypeTypeVar) VersionTuple VersionDictVersionIteratorString VersionPartVersionT)boundT_cmpoperatorreturnc^tdddtdtffd }|S)z0Wrap a Version binary op method in a type-check.selfrotherrct|tttgtjR}t ||stS||SN)typedicttuplelistr__args__ isinstanceNotImplemented)rr comparable_typesrs N/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/semver/version.pywrapperz_comparator..wrapper)s] JJ     _   %!122 "! !xe$$$)r Comparablebool)rr,s` r+ _comparatorr0&sO 8__ %i % %t % % % % %_ % Nr-abc||k||kz S)z6Return negative if ab.r1r2s r+_cmpr69s Ea!e r-c>eZdZUdZdZedeDZeee dfe d<e j dZ eee e d<dZee e d <e j ed d e jZeee e d <e j ed d e jZeee e d< dMdedededeeeefdeeeeff dZedee dee defdZedefdZejdZedefdZejdZedefdZ e jd Z edee fd!Z!e!jd"Z!edee fd#Z"e"jd$Z"de#fd%Z$de%fd&Z&de'fd'Z(e)d(e de fd)Z*dNd*Z+dNd+Z,dNd,Z-dOd.ee ddfd/Z.dPd.ee ddfd0Z/d1e0defd2Z1dOd3e d4e ddfd5Z2e3d1e0de4fd6Z5e3d1e0de4fd7Z6e3d1e0de4fd8Z7e3d1e0de4fd9Z8e3d1e0de4fd:Z9e3d1e0de4fd;Z:dZ=de fd?Z>defd@Z?dNdAZ@dBe de4fdCZAe dQdEeBeCdFedGe4deCfdHZDdIeeee fddfdJZEedFe de4fdKZFd1dde4fdLZGdS)Rra 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)rNr4).0items r+ zVersion.Ns -M-M-M4d122h-M-M-Mr-.NAMESz(?:[^\d]*(\d+)[^\d]*)+ _LAST_NUMBERa3 ^ (?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-]+)* ))? $ _REGEX_TEMPLATE) opt_patch opt_minor_REGEX?_REGEX_OPTIONAL_MINOR_AND_PATCHrNmajorminorpatch prereleasebuildct|t|t|d}|D]-\}}|dkr"td|.|d|_|d|_|d|_|dnt||_|dnt||_ dS)N)rJrKrLrz1{!r} is negative. A version can only be positive.rJrKrL) intitems ValueErrorformatr8r9r:strr;r<) rrJrKrLrMrN version_partsnamevalues r+__init__zVersion.__init__us#&e**s5zzCPUJJWW (..00  KD%qyy GNNtTT $G, #G, #G, #-#5443z??#mddU r-r1r2rc8d}d|pddD}d|pddD}t||D]\}}|||}|dkr|cStt|t|S)Nct|tr%t|trt||St|trdSt|trdSt||S)Nr)r(rPr6r5s r+cmp_prerelease_tagz,Version._nat_cmp..cmp_prerelease_tagso!S!! "jC&8&8 "Aqzz!As## "rAs## "qAqzz!r-cXg|]'}|rt|n|(Sr4isdigitrPr>xs r+r@z$Version._nat_cmp../NNNAQYY[[/3q666aNNNr-rD.cXg|]'}|rt|n|(Sr4r^r`s r+r@z$Version._nat_cmp..rbr-r)splitzipr6len) clsr1r2r\a_partsb_partssub_asub_b cmp_results r+_nat_cmpzVersion._nat_cmps " " "ON!'r9M9MNNNNN!'r9M9MNNN11 " "LE5++E599JQ!!!!CLL#g,,///r-c|jS)z(The major part of a version (read-only).)r8rs r+rJz Version.major {r-c td)Nzattribute 'major' is readonlyAttributeErrorrrWs r+rJz Version.major<===r-c|jS)z(The minor part of a version (read-only).)r9rps r+rKz Version.minorrqr-c td)Nzattribute 'minor' is readonlyrsrus r+rKz Version.minorrvr-c|jS)z(The patch part of a version (read-only).)r:rps r+rLz Version.patchrqr-c td)Nzattribute 'patch' is readonlyrsrus r+rLz Version.patchrvr-c|jS)z-The prerelease part of a version (read-only).)r;rps r+rMzVersion.prereleases r-c td)Nz"attribute 'prerelease' is readonlyrsrus r+rMzVersion.prereleasesABBBr-c|jS)z(The build part of a version (read-only).)r<rps r+rNz Version.buildrqr-c td)Nzattribute 'build' is readonlyrsrus r+rNz Version.buildrvr-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) rJrKrLrMrNrps r+to_tuplezVersion.to_tuples DJ DOTZPPr-c\t|j|j|j|j|jS)a Convert the Version object to an dict. .. versionadded:: 2.10.0 Renamed :meth:`Version._asdict` to :meth:`Version.to_dict` to make this function available in the public API. :return: an dict with the keys in the order ``major``, ``minor``, ``patch``, ``prerelease``, and ``build``. >>> semver.Version(3, 2, 1).to_dict() {'major': 3, 'minor': 2, 'patch': 1, 'prerelease': None, 'build': None} r)r$rJrKrLrMrNrps r+to_dictzVersion.to_dicts4****     r-c#>K|Ed{VdS)zReturn iter(self).N)rrps 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) rrBsearchrTrPgroupspanmaxrg)rmatchnext_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)r#r8rrhs 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)r#r8r9rs 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)r#r8r9r:rs 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' NrD0zrc.0.0)r#r;rTrr8r9r:)rrrhrMs 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') NrDrzbuild.0r)r#r<rTrr8r9r:r;)rrrhrNs r+ bump_buildzVersion.bump_buildRs4jj ; "KEE b[[EE ]EEJJ%E%%e,, ; "KEE b[[EE ]EEJJ%E%%e,,s4; T[$:JERRRr-r cjt|}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 >>> Version.parse("1.0.0").compare("2.0.0") -1 >>> Version.parse("2.0.0").compare("1.0.0") 1 >>> Version.parse("2.0.0").compare("2.0.0") 0 z+Expected str, bytes, dict, tuple, list, or z instance, but got Nrrr[r4)r#r(rr'parser$r%r& TypeError__name__rr6rMrn) rr rhv1v2rarc1rc2rccmps 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 Nr[zInvalid part. Expected one of z , but got rLrKrrJ)rMrNrbump_) r#rArRrMrNrLrKreplacegetattrrr)rrrrh 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||dkSNrrrr s 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-indexc 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 |duSr"r4)ps r+z%Version.__getitem__..s Qd]r-zVersion part undefined) r(rPslicer rstop IndexErrorr%filterrrrg)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)=Nr4)r>keyvals r+ z#Version.__repr__..s1RRxsCcc*RRRRRRr-())joinrrQr#r)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+%sr)rrs r+__str__zVersion.__str__sT DJ CC ? / ut. .G : * utz) )Gr-cTt|ddS)N)hashrrps 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' )r#rJrKrLrs 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)r[)r)r[r)rr)r[r)rrrrrr)rRr)rrprefix match_versionpossibilities_dict possibilitiescmp_ress r+rz Version.match,s(BQB - - -&qrrNMM  q Z//AYF&qrrNMM  JqM\99F&MM#&00    +62 ,,}---''r-Frhroptional_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 stringrKrrLr4) r(bytesdecoderr'rr#rIrrGrR groupdict)rhrrrmatched_version_partss r+rz Version.parse_s6 gu % % GnnW--GGGV_55 G5W EFF F # .7==gFFEEJ$$W--E =DDDEE E050A0A$W- /-. !' *$W- /-. !' *s++*+++r-partsc j|}|| t|di|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): %srNr4)rupdater#rsetrgr)rrr unknownkeyserrors r+rzVersion.replaces,,..u #4::(((( ( # # #e**s4<<>>':'::KIK   +&&MEE"" "  #s AA2B2cT ||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)rrR)rhrs 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(rrr#rJrKrMrs r+ is_compatiblezVersion.is_compatibles2%)) NLtE{{LLMM M  * * * *u{ * * * * *bqbU2A2Y1F1F5Z5; & 6 * 6E$44 r-)rrNN)rr)r)rN)F)Hr __module__ __qualname____doc__ __slots__r%rArr rT__annotations__recompilerBr rCrSVERBOSErGrIr rr rrPrX classmethodrnpropertyrJsetterrKrLrMrNrrrrrr staticmethodrrrrrrr.rrr0r/rrrrrrrrrrrrrrrrrrrr4r-r+rr>s  HI(-u-M-M9-M-M-M'N'NE8E#s(O $NNN,62:6O+P+PL(73<(PPP X    0&0RZr:: &&FHWS\ " ?Ibj<< ??#Xgcl%;37.2 <<<< < U63;/0 < fck*+ <<<<.0#08C=0S000[0*sX \>>\>sX \>>\>sX \>>\> HSM   X CCCx}X \>>\> Q, Q Q Q Q     ,#/######\" $ $ $ $ 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 functoolsrtypingrrrrrr r r r r rrrr_typesrrrrrrTr.r/ Comparatorrr%rPrr0r6r VersionInfor4r-r+rs<< "9d3 #34j6MsR S y*-t3 4  GCy!!!S))*&Ee b  b  b  b  b  b  b  b  L r-