def add_release(
config: ChangelogConfig, # pylint: disable=too-many-arguments
changes: ChangesBase,
plugins: List[PluginDescription],
fragments: List[ChangelogFragment],
version: str,
codename: Optional[str],
date: datetime.date) -> None:
"""
Add a release to the change metadata.
:arg changes: Changes metadata to update
:arg plugins: List of all plugin descriptions
:arg fragments: List of all changelog fragments
:arg version: The version for the new release
:arg codename: The codename for the new release. Optional for collections
:arg date: The release date
"""
# make sure the version parses
version_constructor = (semantic_version.Version if config.is_collection
else packaging.version.Version)
version_constructor(version)
LOGGER.info(
'release version {} is a {} version', version,
'release' if is_release_version(config, version) else 'pre-release')
# filter out plugins which were not added in this release
plugins = list(
filter(
lambda p: any([
version.startswith('%s.' % p.version_added),
version.startswith('%s-' % p.version_added
), # needed for semver
version.startswith('%s+' % p.version_added
), # needed for semver
version == p.version_added
]),
plugins))
changes.add_release(version, codename, date)
for plugin in plugins:
changes.add_plugin(plugin, version)
fragments_added = []
for fragment in fragments:
if changes.add_fragment(fragment, version):
fragments_added.append(fragment)
changes.save()
if not config.keep_fragments:
for fragment in fragments_added:
fragment.remove()
def add_release(changes, plugins, fragments, version, codename, date):
"""Add a release to the change metadata.
:type changes: ChangesMetadata
:type plugins: list[PluginDescription]
:type fragments: list[ChangelogFragment]
:type version: str
:type codename: str
:type date: datetime.date
"""
# make sure the version parses
packaging.version.Version(version)
LOGGER.info('release version %s is a %s version', version,
'release' if is_release_version(version) else 'pre-release')
# filter out plugins which were not added in this release
plugins = list(
filter(lambda p: version.startswith('%s.' % p.version_added), plugins))
changes.add_release(version, codename, date)
for plugin in plugins:
changes.add_plugin(plugin.type, plugin.name, version)
for fragment in fragments:
changes.add_fragment(fragment.name, version)
changes.save()
def _guess_conda_properties(self):
conda_meta_path = self._conda_meta_path
# Perhaps we should call "conda info --json" and parse it but for now we are going
# to assume the default.
conda_version = packaging.version.parse(CONDA_VERSION)
conda_build_available = False
miniconda_version = "3"
if os.path.exists(conda_meta_path):
for package in os.listdir(conda_meta_path):
package_parts = package.split("-")
if len(package_parts) < 3:
continue
package = '-'.join(package_parts[:-2])
version = package_parts[-2]
# build = package_parts[-1]
if package == "conda":
conda_version = packaging.version.parse(version)
if package == "python" and version.startswith("2"):
miniconda_version = "2"
if package == "conda-build":
conda_build_available = True
self._conda_version = conda_version
self._miniconda_version = miniconda_version
self._conda_build_available = conda_build_available
def _guess_conda_properties(self):
conda_meta_path = self._conda_meta_path
# Perhaps we should call "conda info --json" and parse it but for now we are going
# to assume the default.
conda_version = packaging.version.parse(CONDA_VERSION)
conda_build_available = False
miniconda_version = "3"
if os.path.exists(conda_meta_path):
for package in os.listdir(conda_meta_path):
package_parts = package.split("-")
if len(package_parts) < 3:
continue
package = '-'.join(package_parts[:-2])
version = package_parts[-2]
# build = package_parts[-1]
if package == "conda":
conda_version = packaging.version.parse(version)
if package == "python" and version.startswith("2"):
miniconda_version = "2"
if package == "conda-build":
conda_build_available = True
self._conda_version = conda_version
self._miniconda_version = miniconda_version
self._conda_build_available = conda_build_available
def is_stable_version(version):
""" Heuristic for whether this is the latest stable release """
if not version.startswith("v"):
return False # branch name
if "-" in version:
return False # prerelease tag
git_out = subprocess.run(["git", "tag", "-l"],
capture_output=True,
check=True)
versions = [v.strip() for v in git_out.stdout.decode("utf-8").split("\n")]
versions = [v for v in versions
if re.match(r"^v[\d\.]+$", v)] # include vX.Y.Z only
versions = [packaging.version.parse(v) for v in versions]
max_version = max(versions)
if max_version.public != version[1:]:
print("Stable version is v{}. This version is {}.".format(
max_version.public, version))
return False
else:
print("This version {} is the stable version".format(version))
return True
def __init__(self, version):
"""
Initialize a new Version.
Parameters:
version: str, Version
The semver-formatted version string; or another Version instance.
"""
if isinstance(version, Version):
version = str(version)
if not isinstance(version, str):
raise TypeError("version")
#support versions such as: "application/vnd.mds.provider+json;version=0.3"
if version.startswith('application/vnd.mds.provider+json;version='):
version = version.split('=')[1]
self._version = self._parse(version)
self._legacy = None
if isinstance(self._version, packaging.version.LegacyVersion):
# versions like "0.3.x" or "0.x"
try:
# assume the highest PATCH support
major, minor, legacy = str(self._version).split(".")
self._version = self._parse(f"{major}.{minor}.{sys.maxsize}")
# note the highest valid version tuple index, and the "legacy" data
self._legacy = (1, legacy)
except:
# assume the highest MINOR.PATCH support
major, legacy = str(self._version).split(".")
self._version = self._parse(
f"{major}.{sys.maxsize}.{sys.maxsize}")
# note the highest valid version tuple index, and the "legacy" data
self._legacy = (0, legacy)
elif len(self.tuple) < 2:
# MAJOR only versions like "0", "1"
self._version = self._parse(
f"{self.tuple[0]}.{sys.maxsize}.{sys.maxsize}")
self._legacy = (0, None)
elif len(self.tuple) < 3:
# MAJOR.MINOR only version like "0.3"
self._version = self._parse(
f"{self.tuple[0]}.{self.tuple[1]}.{sys.maxsize}")
self._legacy = (1, None)
def get_versions_by_regex_for_text(text, url, regex, project):
''' For the provided text, return all the version retrieved via the
specified regular expression.
'''
try:
upstream_versions = list(set(re.findall(regex, text)))
except sre_constants.error: # pragma: no cover
raise AnityaPluginException("%s: invalid regular expression" %
project.name)
for index, version in enumerate(upstream_versions):
# If the version retrieved is a tuple, re-constitute it
if type(version) == tuple:
version = ".".join([v for v in version if not v == ""])
# Strip the version_prefix early
if project.version_prefix is not None and \
version.startswith(project.version_prefix):
version = version[len(project.version_prefix):]
upstream_versions[index] = version
if " " in version:
raise AnityaPluginException(
"%s: invalid upstream version:>%s< - %s - %s " %
(project.name, version, url, regex))
if len(upstream_versions) == 0:
raise AnityaPluginException(
"%(name)s: no upstream version found. - %(url)s - "
"%(regex)s" % {
'name': project.name,
'url': url,
'regex': regex
})
return upstream_versions
def is_stable_version(version):
""" Heuristic for whether this is the latest stable release """
if not version.startswith('v'):
return False # branch name
if '-' in version:
return False # prerelease tag
git_out = subprocess.check_output(['git', 'tag', '-l']).decode('utf-8')
versions = [v.strip() for v in git_out.split('\n')]
versions = [v for v in versions
if re.match(r'^v[\d\.]+$', v)] # include vX.Y.Z only
versions = [packaging.version.parse(v) for v in versions]
max_version = max(versions)
if max_version.public != version[1:]:
print('Stable version is v{}. This version is {}.'.format(
max_version.public, version))
return False
else:
print('This version {} is the stable version'.format(version))
return True
