def get_version_spec(ours_v: semantic_version.Version) \ -> semantic_version.Spec: spec_str = '>={major}.{minor}.0,<{next_minor}'.format( major=ours_v.major, minor=ours_v.minor, next_minor=ours_v.next_minor(), ) spec = semantic_version.Spec(spec_str) return spec
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 best_upgrade(current: Version, candidates: List[Version], track: str = 'MajorVersion'): if track == 'PatchLevel': spec = Spec('>{current},<{next_minor}'.format( current=str(current), next_minor=str(current.next_minor()))) elif track == 'MinorVersion': spec = Spec('>{current},<{next_minor}'.format( current=str(current), next_minor=str(current.next_major()))) elif track == 'MajorVersion': spec = Spec('>{current}'.format(current=str(current))) else: raise ValueError('unsupported "track": {track}'.format(track=track)) return spec.select(candidates)
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 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 _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))