def update_version_number(update_level='patch'):
"""Update version number
Returns a semantic_version object"""
"""Find current version"""
temp_file = version_file().parent / ("~" + version_file().name)
with open(str(temp_file), 'w') as g:
with open(str(version_file()), 'r') as f:
for line in f:
version_matches = bare_version_re.match(line)
if version_matches:
bare_version_str = version_matches.groups(0)[0]
if semantic_version.validate(bare_version_str):
current_version = Version(bare_version_str)
print("{}Current version is {}".format(" "*4, current_version))
else:
current_version = Version.coerce(bare_version_str)
if not text.query_yes_quit("{}I think the version is {}. Use it?".format(" "*4, current_version), default="yes"):
exit(colorama.Fore.RED + 'Please set an initial version number to continue')
"""Determine new version number"""
if update_level is 'major':
current_version = current_version.next_major()
elif update_level is 'minor':
current_version = current_version.next_minor()
elif update_level is 'patch':
current_version = current_version.next_patch()
elif update_level is 'prerelease':
if not current_version.prerelease:
current_version = current_version.next_patch()
current_version.prerelease = ('dev', )
elif update_level is None:
# don't update version
pass
else:
exit(colorama.Fore.RED + 'Cannot update version in {} mode'.format(update_level))
print("{}New version is {}".format(" "*4, current_version))
"""Update version number"""
line = '__version__ = "{}"\n'.format(current_version)
print(line, file=g, end="")
#print('', file=g) # add a blank line at the end of the file
shutil.copyfile(str(temp_file), str(version_file()))
os.remove(str(temp_file))
return(current_version)
def update_version_number(update_level='patch'):
"""Update version number
Returns a semantic_version object"""
"""Find current version"""
temp_file = version_file().parent / ("~" + version_file().name)
with open(str(temp_file), 'w') as g:
with open(str(version_file()), 'r') as f:
for line in f:
version_matches = bare_version_re.match(line)
if version_matches:
bare_version_str = version_matches.groups(0)[0]
if semantic_version.validate(bare_version_str):
current_version = Version(bare_version_str)
print("{}Current version is {}".format(" "*4, current_version))
else:
current_version = Version.coerce(bare_version_str)
if not text.query_yes_quit("{}I think the version is {}. Use it?".format(" "*4, current_version), default="yes"):
exit(colorama.Fore.RED + 'Please set an initial version number to continue')
"""Determine new version number"""
if update_level is 'major':
current_version = current_version.next_major()
elif update_level is 'minor':
current_version = current_version.next_minor()
elif update_level is 'patch':
current_version = current_version.next_patch()
elif update_level is 'prerelease':
if not current_version.prerelease:
current_version = current_version.next_patch()
current_version.prerelease = ('dev', )
elif update_level is None:
# don't update version
pass
else:
exit(colorama.Fore.RED + 'Cannot update version in {} mode'.format(update_level))
print("{}New version is {}".format(" "*4, current_version))
"""Update version number"""
line = '__version__ = "{}"\n'.format(current_version)
print(line, file=g, end="")
#print('', file=g) # add a blank line at the end of the file
shutil.copyfile(str(temp_file), str(version_file()))
os.remove(str(temp_file))
return(current_version)
def update(self, instance, validated_data):
version_increment = validated_data.pop("version_increment", "patch")
if version_increment == "initial":
raise exceptions.APIException("Unable to update template with version_increment set to 'initial'!")
v = Version(instance.version)
if version_increment == "major":
validated_data["version"] = str(v.next_major())
if version_increment == "minor":
validated_data["version"] = str(v.next_minor())
if version_increment == "patch":
validated_data["version"] = str(v.next_patch())
validated_data["dependencies"] = []
return super(TemplateSerializer, self).update(instance, validated_data)
def get_next_version(release_type):
"""Increment a version for a particular release type."""
if not isinstance(release_type, ReleaseType):
raise TypeError()
version = Version(get_current_version())
if release_type is ReleaseType.major:
return str(version.next_major())
if release_type is ReleaseType.minor:
return str(version.next_minor())
return str(version.next_patch())
def package(ctx, path, version):
'''
Package a current path to a new version and upload to chart repo.
'''
# helm package --app-version 0.1.9 --version 0.1.9 fantuan-base
# curl -F "[email protected]" http://localhost:8080/api/charts
update_helm()
path = path.strip('/')
chart_name = path.split('/')[-1]
if not version:
click.echo(
click.style('No version specified. Reading from chart_repo ...',
fg='yellow'))
version = Version(
get_chart_version(ctx.obj.get('helm_repo'), chart_name))
version = str(version.next_patch())
click.echo(click.style('Get new version %s' % version, fg='green'))
Version(version)
click.echo(click.style('Updateing dependency ...', fg='yellow'))
helm.dependency.update(path)
click.echo(click.style('Done!\n', fg='green'))
click.echo(click.style('Packaging ...', fg='yellow'))
helm.package('--app-version', version, '--version', version, path)
tar = '%s-%s.tgz' % (path, version)
click.echo(click.style('Uploading ...', fg='yellow'))
cmd_result = curl('-F', 'chart=@%s' % tar,
get_chart_repo(ctx.obj.get('helm_repo')) + '/api/charts')
click.echo(click.style('Cleaning ...', fg='yellow'))
rm(tar)
result = json.loads(cmd_result.stdout)
if result.get('saved'):
click.echo(click.style('SUCCESS!', fg='green'))
else:
click.echo(click.style('FAILED!: %s' % result.get('error'), fg='red'))
class ReleaseTest:
st_bool = strategy("bool")
def __init__(self, gov, registry, create_token, create_vault):
self.gov = gov
self.registry = registry
self.create_token = lambda s: create_token()
def create_vault_adaptor(self, *args, **kwargs):
return create_vault(*args, **kwargs)
self.create_vault = create_vault_adaptor
def setup(self):
self.latest_version = Version("1.0.0")
token = self.create_token()
vault = self.create_vault(token, version=str(self.latest_version))
self.vaults = {token: [vault]}
self.registry.newRelease(vault, {"from": self.gov})
self.experiments = {}
def rule_new_release(self, new_token="st_bool"):
if new_token or len(self.vaults.keys()) == 0:
token = self.create_token()
else:
token = list(self.vaults.keys())[-1]
self.latest_version = self.latest_version.next_patch()
vault = self.create_vault(token, version=str(self.latest_version))
print(f"Registry.newRelease({token}, {self.latest_version})")
self.registry.newRelease(vault, {"from": self.gov})
if token in self.vaults:
self.vaults[token].append(vault)
else:
self.vaults[token] = [vault]
def rule_new_deployment(self, new_token="st_bool"):
tokens_with_stale_deployments = [
token for token, deployments in self.vaults.items()
if Version(deployments[-1].apiVersion()) < self.latest_version
]
if new_token or len(tokens_with_stale_deployments) == 0:
token = self.create_token()
else:
token = tokens_with_stale_deployments[-1]
print(f"Registry.newVault({token}, {self.latest_version})")
vault = Vault.at(
self.registry.newVault(token, self.gov, self.gov, "",
"").return_value)
if token in self.vaults:
self.vaults[token].append(vault)
else:
self.vaults[token] = [vault]
def rule_new_experiment(self):
token = self.create_token()
print(f"Registry.newExperimentalVault({token}, {self.latest_version})")
vault = Vault.at(
self.registry.newExperimentalVault(token, self.gov, self.gov,
self.gov, "", "").return_value)
self.experiments[token] = [vault]
def rule_endorse_experiment(self):
experiments_with_latest_api = [
(token, deployments[-1])
for token, deployments in self.experiments.items()
if (Version(deployments[-1].apiVersion()) == self.latest_version
and (token not in self.vaults
or Version(self.vaults[token][-1].apiVersion()) < Version(
deployments[-1].apiVersion())))
]
if len(experiments_with_latest_api) > 0:
token, vault = experiments_with_latest_api[-1]
print(f"Registry.endorseVault({token}, {self.latest_version})")
self.registry.endorseVault(vault, {"from": self.gov})
if token in self.vaults:
self.vaults[token].append(vault)
else:
self.vaults[token] = [vault]
def invariant(self):
for token, deployments in self.vaults.items():
# Check that token matches up
assert deployments[0].token() == token
# Strictly linearly increasing versions
last_version = Version(deployments[0].apiVersion())
assert last_version <= self.latest_version
for vault in deployments[1:]:
# Check that token matches up
assert vault.token() == token
# Strictly linearly increasing versions
assert last_version < Version(
vault.apiVersion()) <= self.latest_version
def _normalize(self, constraint):
"""
Normalizes the constraint so that it can be understood
by the underlying system.
:param constraint: The dependency constraint.
:type constraint: str or dict
:rtype: str
"""
if self.is_vcs_dependency():
# Any VCS dependency is considered prerelease
self._is_prerelease = True
return self._normalize_vcs_constraint(constraint)
version = constraint
if isinstance(version, dict):
version = version['version']
constraint = self._spec(version)
normalized = []
for spec in constraint.specs:
version = spec.spec
if VersionParser.parse_stability(version) == 'dev':
self._accepts_prereleases = True
major, minor, patch, prerelease = (version.major, version.minor,
version.patch,
version.prerelease)
current = '{}.{}.{}'.format(major, minor or 0, patch or 0)
current = Version(current)
if spec.kind == SpecItem.KIND_CARET:
if current.major != 0 or minor is None:
upper = current.next_major()
elif current.minor != 0 or patch is None:
upper = current.next_minor()
else:
upper = current.next_patch()
if prerelease:
current = str(current) + '{}'.format(''.join(prerelease))
normalized.append('>={},<{}'.format(current, upper))
elif spec.kind == SpecItem.KIND_TILDE:
if minor is None and patch is None:
upper = current.next_major()
else:
upper = current.next_minor()
upper = '{}.{}.{}'.format(*upper)
normalized.append('>={},<{}'.format(current, upper))
if prerelease:
current = str(current) + '{}'.format(''.join(prerelease))
else:
current = spec.kind + str(current)
if prerelease:
current += '{}'.format(''.join(prerelease))
normalized.append(current)
return ','.join(normalized)
import sys
from pathlib import Path
from semantic_version import Version
# Assume this script is called from the root directory
version_path = Path('src/resources/version.txt')
v = Version(version_path.read_text())
increment_type = sys.argv[1]
if increment_type == 'major':
v = v.next_major()
elif increment_type == 'minor':
v = v.next_minor()
elif increment_type == 'patch':
v = v.next_patch()
else:
raise ValueError(f'Increment type should be "major", "minor", or '
f'"patch", but was {increment_type}')
version_path.write_text(str(v))
with open(SRC + PROJECT + file_name, "r") as infile:
for line in infile:
if line.strip().startswith("__version__"):
if '"' not in line:
print(file_name)
print(line)
raise TypeError("Please format your code with Black.")
else:
parts = line.split('"')
if len(parts) != 3:
raise TypeError(
'Version must be of form __version__ = "1.1.1" with no comments'
)
if version is None:
version = Version(parts[1])
next_version = version.next_patch()
to_write.append('__version__ = "{0}"'.format(
str(next_version)))
else:
to_write.append(line)
if DEBUG:
for line in to_write:
print(line, end="")
else:
with open(SRC + PROJECT + file_name, "w") as outfile:
outfile.writelines(to_write)
# setup.py related. setup.py itself should read __init__.py or __version__.py
to_write = []
other_files = ["setup.cfg"]
