def should_notify(self, releases, force=True):
self._logger.debug(releases)
if force:
return True
server_releases = [
release for release in releases if release['branch'] == 'server'
]
stable_releases = [
release for release in releases if release['branch'] == 'stable'
]
pre_releases = [
release for release in releases if release['branch'] == 'pre'
]
beta_releases = [
release for release in releases if release['branch'] == 'beta'
]
have_server = len(server_releases) > 0
have_stable = len(stable_releases) > 0
have_pre = len(pre_releases) > 0
have_beta = len(beta_releases) > 0
current_version = Version(config.VERSION)
# null out build because we don't care about it
current_version.build = ()
notify_stable = have_stable and self.updater_branch == UpdateBranch.Stable.name \
and Version(stable_releases[0]['new_version']) > current_version
notify_pre = have_pre and self.updater_branch == UpdateBranch.Prerelease.name \
and Version(pre_releases[0]['new_version']) > current_version
notify_beta = have_beta and self.updater_branch == UpdateBranch.Unstable.name \
and Version(beta_releases[0]['new_version']) > current_version
return have_server or notify_stable or notify_pre or notify_beta
def patch(level=None):
"""
Release a patch for this package. Increase the last part of the version
number by 1 or by ``level`` if specified.
:param level: set the patch level to this number.
:type level: int
"""
# Stop if project has no tags
if not git.has_tag():
abort('You should use package.release.new() task as it seems there is'
' no version yet !')
# Get the last released version from changelog
last_released_version = helpers.get_last_version()
puts(cyan('Last released version is %s.' % last_released_version))
# Make a new version
new_version = Version(str(last_released_version))
if level:
new_version.patch = int(level)
else:
new_version.patch += 1
# Reset others
new_version.build = None
# Call new to init the full process
execute(new, str(new_version))
def _update_with_real_version(nc: Nextcloud) -> Nextcloud:
storepath: Path = nix.get_nextcloud_store_path(nc)
verfile: Path = storepath / 'version.php'
with open(verfile, 'r') as fp:
for match in RE_NEXTCLOUD_INTERNAL_VERSION_DIGIT.finditer(fp.read()):
newver = Version(str(nc.version))
newver.build = (match.group(1), )
return Nextcloud(newver, nc.download_url, nc.sha256)
raise IOError(f"Unable to find full Nextcloud version in {verfile}.")
def resolve_template(self, identifier: Union[str, BaseTemplate],
**kwargs) -> Optional[BaseTemplate]:
if isinstance(identifier, str):
kwargs['name'] = identifier
elif isinstance(identifier, BaseTemplate):
kwargs['orig'] = identifier
query = BaseTemplate.create_query(**kwargs)
logger(__name__).info(f'Query: {query}')
logger(__name__).debug(query.__dict__)
templates = self.resolve_templates(query, **kwargs)
logger(__name__).info(
f'Candidates: {", ".join([str(t) for t in templates])}')
if not any(templates):
return None
query.version = str(
Spec(query.version
or '>0').select([Version(t.version) for t in templates]))
v = Version(query.version)
v.prerelease = v.prerelease if len(v.prerelease) else ('', )
v.build = v.build if len(v.build) else ('', )
query.version = f'=={v}'
logger(__name__).info(f'Resolved to {query.identifier}')
templates = self.resolve_templates(query, **kwargs)
if not any(templates):
return None
# prefer local templates first
local_templates = [
t for t in templates if isinstance(t, LocalTemplate)
]
if any(local_templates):
# there's a local template satisfying the query
if len(local_templates) > 1:
# This should never happen! Conductor state must be invalid
raise Exception(
f'Multiple local templates satisfy {query.identifier}!')
return [t for t in templates if isinstance(t, LocalTemplate)][0]
# prefer pros-mainline template second
mainline_templates = [
t for t in templates if t.metadata['origin'] == 'pros-mainline'
]
if any(mainline_templates):
return mainline_templates[0]
# No preference, just FCFS
return templates[0]
def workspace_tags(self, workspace: Workspace, build: Tuple[str],
**kwargs: Any) -> List[str]:
formatting_kwargs = {
**kwargs,
**prefect.context.get('parameters', {}).copy(),
**prefect.context,
}
base_ref = workspace['version']
repo_info = parse_repo(workspace['repo_uri'])
next_version = base_ref.next_patch() if base_ref else Version(
f'{repo_info.major}.{repo_info.minor}.0' if repo_info.
minor else f'{repo_info.major}.0.0')
is_prerelease = base_ref and len(base_ref.prerelease) >= 2
if is_prerelease:
prerelease, prerelease_count = base_ref.prerelease
prerelease_count = int(prerelease_count)
prerelease_count += 1
next_version = Version(major=base_ref.major,
minor=base_ref.minor,
patch=base_ref.patch,
prerelease=(prerelease,
str(prerelease_count)))
next_version.build = [
meta.format(**formatting_kwargs) for meta in build
]
if is_prerelease:
prerelease, prerelease_count = next_version.prerelease
return [
f'{next_version.major}-{prerelease}',
f'{next_version.major}.{next_version.minor}-{prerelease}',
str(next_version),
]
return [
f'{next_version.major}',
f'{next_version.major}.{next_version.minor}',
str(next_version),
]
# Calculate next package version
def get_next_version(version, stage):
if stage == "prod":
version = version.next_patch()
elif not version.build:
version = version.next_patch()
version.build = tuple("1")
else:
*x, y = version.build
version.build = (*x, str(int(y) + 1))
return version
if TARGET_VERSION and TARGET_VERSION != "AUTO":
next_version = Version.coerce(TARGET_VERSION)
else:
latest_version = get_latest_version(TARGET_NAME, TARGET_STAGE)
if latest_version:
next_version = get_next_version(latest_version, TARGET_STAGE)
else:
next_version = Version("1.0.0")
if TARGET_STAGE != "prod":
next_version.build = tuple("1")
print(convert_to_pep_440(next_version))
def version_build(self, value):
v = Version(self.version)
v.build = value
self.version = str(v)
