????
Your IP : 3.144.227.73
"""
Contains all deprecated functions.
.. autofunction: deprecated
"""
import inspect
import warnings
from functools import partial, wraps
from types import FrameType
from typing import Type, Callable, Optional, cast
from . import cli
from .version import Version
from ._types import Decorator, F
def deprecated(
func: Optional[F] = None,
*,
replace: Optional[str] = None,
version: Optional[str] = None,
remove: Optional[str] = None,
category: Type[Warning] = DeprecationWarning,
) -> Decorator:
"""
Decorates a function to output a deprecation warning.
:param func: the function to decorate
:param replace: the function to replace (use the full qualified
name like ``semver.version.Version.bump_major``.
:param version: the first version when this function was deprecated.
:param category: allow you to specify the deprecation warning class
of your choice. By default, it's :class:`DeprecationWarning`, but
you can choose :class:`PendingDeprecationWarning` or a custom class.
:return: decorated function which is marked as deprecated
"""
if func is None:
return partial(
deprecated,
replace=replace,
version=version,
remove=remove,
category=category,
)
@wraps(func)
def wrapper(*args, **kwargs) -> Callable[..., F]:
msg_list = ["Function 'semver.{f}' is deprecated."]
if version:
msg_list.append("Deprecated since version {v}. ")
if not remove:
msg_list.append("This function will be removed in semver 3.")
else:
msg_list.append(str(remove))
if replace:
msg_list.append("Use {r!r} instead.")
else:
msg_list.append("Use the respective 'semver.Version.{r}' instead.")
f = cast(F, func).__qualname__
r = replace or f
frame = cast(FrameType, cast(FrameType, inspect.currentframe()).f_back)
msg = " ".join(msg_list)
warnings.warn_explicit(
msg.format(f=f, r=r, v=version),
category=category,
filename=inspect.getfile(frame.f_code),
lineno=frame.f_lineno,
)
# As recommended in the Python documentation
# https://docs.python.org/3/library/inspect.html#the-interpreter-stack
# better remove the interpreter stack:
del frame
return func(*args, **kwargs) # type: ignore
return wrapper
@deprecated(
version="3.0.0",
remove="Still under investigation, see #258.",
category=PendingDeprecationWarning,
)
def compare(ver1: str, ver2: str) -> int:
"""
Compare two versions strings.
.. deprecated:: 3.0.0
The situation of this function is unclear and it might
disappear in the future.
If possible, use :meth:`semver.version.Version.compare`.
See :gh:`258` for details.
:param ver1: first version string
:param ver2: second version string
:return: The return value is negative if ver1 < ver2,
zero if ver1 == ver2 and strictly positive if ver1 > ver2
>>> semver.compare("1.0.0", "2.0.0")
-1
>>> semver.compare("2.0.0", "1.0.0")
1
>>> semver.compare("2.0.0", "2.0.0")
0
"""
return Version.parse(ver1).compare(ver2)
@deprecated(version="2.10.0")
def parse(version):
"""
Parse version to major, minor, patch, pre-release, build parts.
.. deprecated:: 2.10.0
Use :meth:`~semver.version.Version.parse` instead.
:param version: version string
:return: dictionary with the keys 'build', 'major', 'minor', 'patch',
and 'prerelease'. The prerelease or build keys can be None
if not provided
:rtype: dict
>>> ver = semver.parse('3.4.5-pre.2+build.4')
>>> ver['major']
3
>>> ver['minor']
4
>>> ver['patch']
5
>>> ver['prerelease']
'pre.2'
>>> ver['build']
'build.4'
"""
return Version.parse(version).to_dict()
@deprecated(replace="semver.version.Version.parse", version="2.10.0")
def parse_version_info(version):
"""
Parse version string to a Version instance.
.. deprecated:: 2.10.0
Use :meth:`~semver.version.Version.parse` instead.
.. versionadded:: 2.7.2
Added :func:`semver.parse_version_info`
:param version: version string
:return: a :class:`VersionInfo` instance
>>> version_info = semver.Version.parse("3.4.5-pre.2+build.4")
>>> version_info.major
3
>>> version_info.minor
4
>>> version_info.patch
5
>>> version_info.prerelease
'pre.2'
>>> version_info.build
'build.4'
"""
return Version.parse(version)
@deprecated(version="2.10.0")
def match(version, match_expr):
"""
Compare two versions strings through a comparison.
.. deprecated:: 2.10.0
Use :meth:`~semver.version.Version.match` instead.
:param str version: a version string
:param str match_expr: 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
:rtype: bool
>>> semver.match("2.0.0", ">=1.0.0")
True
>>> semver.match("1.0.0", ">1.0.0")
False
"""
ver = Version.parse(version)
return ver.match(match_expr)
@deprecated(replace="max", version="2.10.2")
def max_ver(ver1, ver2):
"""
Returns the greater version of two versions strings.
.. deprecated:: 2.10.2
Use :func:`max` instead.
:param ver1: version string 1
:param ver2: version string 2
:return: the greater version of the two
:rtype: :class:`Version`
>>> semver.max_ver("1.0.0", "2.0.0")
'2.0.0'
"""
return str(max(ver1, ver2, key=Version.parse))
@deprecated(replace="min", version="2.10.2")
def min_ver(ver1, ver2):
"""
Returns the smaller version of two versions strings.
.. deprecated:: 2.10.2
Use Use :func:`min` instead.
:param ver1: version string 1
:param ver2: version string 2
:return: the smaller version of the two
:rtype: :class:`Version`
>>> semver.min_ver("1.0.0", "2.0.0")
'1.0.0'
"""
return str(min(ver1, ver2, key=Version.parse))
@deprecated(replace="str(versionobject)", version="2.10.0")
def format_version(major, minor, patch, prerelease=None, build=None):
"""
Format a version string according to the Semantic Versioning specification.
.. deprecated:: 2.10.0
Use ``str(Version(VERSION)`` instead.
:param int major: the required major part of a version
:param int minor: the required minor part of a version
:param int patch: the required patch part of a version
:param str prerelease: the optional prerelease part of a version
:param str build: the optional build part of a version
:return: the formatted string
:rtype: str
>>> semver.format_version(3, 4, 5, 'pre.2', 'build.4')
'3.4.5-pre.2+build.4'
"""
return str(Version(major, minor, patch, prerelease, build))
@deprecated(version="2.10.0")
def bump_major(version):
"""
Raise the major part of the version string.
.. deprecated:: 2.10.0
Use :meth:`~semver.version.Version.bump_major` instead.
:param: version string
:return: the raised version string
:rtype: str
>>> semver.bump_major("3.4.5")
'4.0.0'
"""
return str(Version.parse(version).bump_major())
@deprecated(version="2.10.0")
def bump_minor(version):
"""
Raise the minor part of the version string.
.. deprecated:: 2.10.0
Use :meth:`~semver.version.Version.bump_minor` instead.
:param: version string
:return: the raised version string
:rtype: str
>>> semver.bump_minor("3.4.5")
'3.5.0'
"""
return str(Version.parse(version).bump_minor())
@deprecated(version="2.10.0")
def bump_patch(version):
"""
Raise the patch part of the version string.
.. deprecated:: 2.10.0
Use :meth:`~semver.version.Version.bump_patch` instead.
:param: version string
:return: the raised version string
:rtype: str
>>> semver.bump_patch("3.4.5")
'3.4.6'
"""
return str(Version.parse(version).bump_patch())
@deprecated(version="2.10.0")
def bump_prerelease(version, token="rc"):
"""
Raise the prerelease part of the version string.
.. deprecated:: 2.10.0
Use :meth:`~semver.version.Version.bump_prerelease` instead.
:param version: version string
:param token: defaults to 'rc'
:return: the raised version string
:rtype: str
>>> semver.bump_prerelease('3.4.5', 'dev')
'3.4.5-dev.1'
"""
return str(Version.parse(version).bump_prerelease(token))
@deprecated(version="2.10.0")
def bump_build(version, token="build"):
"""
Raise the build part of the version string.
.. deprecated:: 2.10.0
Use :meth:`~semver.version.Version.bump_build` instead.
:param version: version string
:param token: defaults to 'build'
:return: the raised version string
:rtype: str
>>> semver.bump_build('3.4.5-rc.1+build.9')
'3.4.5-rc.1+build.10'
"""
return str(Version.parse(version).bump_build(token))
@deprecated(version="2.10.0")
def finalize_version(version):
"""
Remove any prerelease and build metadata from the version string.
.. deprecated:: 2.10.0
Use :meth:`~semver.version.Version.finalize_version` instead.
.. versionadded:: 2.7.9
Added :func:`finalize_version`
:param version: version string
:return: the finalized version string
:rtype: str
>>> semver.finalize_version('1.2.3-rc.5')
'1.2.3'
"""
verinfo = Version.parse(version)
return str(verinfo.finalize_version())
@deprecated(version="2.10.0")
def replace(version, **parts):
"""
Replace one or more parts of a version and return the new string.
.. deprecated:: 2.10.0
Use :meth:`~semver.version.Version.replace` instead.
.. versionadded:: 2.9.0
Added :func:`replace`
:param version: the version string to replace
:param parts: the parts to be updated. Valid keys are:
``major``, ``minor``, ``patch``, ``prerelease``, or ``build``
:return: the replaced version string
:raises TypeError: if ``parts`` contains invalid keys
>>> import semver
>>> semver.replace("1.2.3", major=2, patch=10)
'2.2.10'
"""
return str(Version.parse(version).replace(**parts))
# CLI
cmd_bump = deprecated(cli.cmd_bump, replace="semver.cli.cmd_bump", version="3.0.0")
cmd_check = deprecated(cli.cmd_check, replace="semver.cli.cmd_check", version="3.0.0")
cmd_compare = deprecated(
cli.cmd_compare, replace="semver.cli.cmd_compare", version="3.0.0"
)
cmd_nextver = deprecated(
cli.cmd_nextver, replace="semver.cli.cmd_nextver", version="3.0.0"
)
createparser = deprecated(
cli.createparser, replace="semver.cli.createparser", version="3.0.0"
)
process = deprecated(cli.process, replace="semver.cli.process", version="3.0.0")
main = deprecated(cli.main, replace="semver.cli.main", version="3.0.0")