Source code for spack.version

# Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
# SPDX-License-Identifier: (Apache-2.0 OR MIT)

This module implements Version and version-ish objects.  These are:

  A single version of a package.
  A range of versions of a package.
  A list of Versions and VersionRanges.

All of these types support the following operations, which can
be called on any of the types::

  __eq__, __ne__, __lt__, __gt__, __ge__, __le__, __hash__
import numbers
import os
import re
from bisect import bisect_left
from functools import wraps

from six import string_types

import llnl.util.tty as tty
from llnl.util.filesystem import mkdirp, working_dir

import spack.caches
import spack.error
import spack.paths
import spack.util.executable
import spack.util.spack_json as sjson
from spack.util.spack_yaml import syaml_dict

__all__ = ['Version', 'VersionRange', 'VersionList', 'ver']

# Valid version characters
VALID_VERSION = re.compile(r'^[A-Za-z0-9_.-]+$')

# regex for a commit version
COMMIT_VERSION = re.compile(r'^[a-f0-9]{40}$')

# regex for version segments
SEGMENT_REGEX = re.compile(r'(?:(?P<num>[0-9]+)|(?P<str>[a-zA-Z]+))(?P<sep>[_.-]*)')

# regular expression for semantic versioning
SEMVER_REGEX = re.compile(".+(?P<semver>([0-9]+)[.]([0-9]+)[.]([0-9]+)"

# Infinity-like versions. The order in the list implies the comparison rules
infinity_versions = ['develop', 'main', 'master', 'head', 'trunk', 'stable']

iv_min_len = min(len(s) for s in infinity_versions)

def coerce_versions(a, b):
    Convert both a and b to the 'greatest' type between them, in this order:
           Version < VersionRange < VersionList
    This is used to simplify comparison operations below so that we're always
    comparing things that are of the same type.
    order = (Version, VersionRange, VersionList)
    ta, tb = type(a), type(b)

    def check_type(t):
        if t not in order:
            raise TypeError("coerce_versions cannot be called on %s" % t)

    if ta == tb:
        return (a, b)
    elif order.index(ta) > order.index(tb):
        if ta == VersionRange:
            return (a, VersionRange(b, b))
            return (a, VersionList([b]))
        if tb == VersionRange:
            return (VersionRange(a, a), b)
            return (VersionList([a]), b)

def coerced(method):
    """Decorator that ensures that argument types of a method are coerced."""
    def coercing_method(a, b, *args, **kwargs):
        if type(a) == type(b) or a is None or b is None:
            return method(a, b, *args, **kwargs)
            ca, cb = coerce_versions(a, b)
            return getattr(ca, method.__name__)(cb, *args, **kwargs)
    return coercing_method

class VersionStrComponent(object):
    # NOTE: this is intentionally not a UserString, the abc instanceof
    #       check is slow enough to eliminate all gains
    __slots__ = ['inf_ver', 'data']

    def __init__(self, string):
        self.inf_ver = None = string
        if len(string) >= iv_min_len:
                self.inf_ver = infinity_versions.index(string)
            except ValueError:

    def __hash__(self):
        return hash(

    def __str__(self):

    def __eq__(self, other):
        if isinstance(other, VersionStrComponent):
            return ==
        return == other

    def __lt__(self, other):
        if isinstance(other, VersionStrComponent):
            if self.inf_ver is not None:
                if other.inf_ver is not None:
                    return self.inf_ver > other.inf_ver
                return False
            if other.inf_ver is not None:
                return True

            return <

        if self.inf_ver is not None:
            return False

        # Numbers are always "newer" than letters.
        # This is for consistency with RPM.  See patch
        # #60884 (and details) from bugzilla #50977 in
        # the RPM project at  Or look at
        # rpmvercmp.c if you want to see how this is
        # implemented there.
        if isinstance(other, int):
            return True

        if isinstance(other, str):
            return self < VersionStrComponent(other)
        # If we get here, it's an unsupported comparison

        raise ValueError("VersionStrComponent can only be compared with itself, "
                         "int and str")

    def __gt__(self, other):
        return not self.__lt__(other)

[docs]class Version(object): """Class to represent versions""" __slots__ = [ "version", "separators", "string", "_commit_lookup", "is_commit", "commit_version", ] def __init__(self, string): if not isinstance(string, str): string = str(string) # preserve the original string, but trimmed. string = string.strip() self.string = string if string and not VALID_VERSION.match(string): raise ValueError("Bad characters in version string: %s" % string) # An object that can lookup git commits to compare them to versions self._commit_lookup = None self.commit_version = None segments = SEGMENT_REGEX.findall(string) self.version = tuple( int(m[0]) if m[0] else VersionStrComponent(m[1]) for m in segments ) self.separators = tuple(m[2] for m in segments) self.is_commit = len(self.string) == 40 and COMMIT_VERSION.match(self.string) def _cmp(self, other_lookups=None): commit_lookup = self.commit_lookup or other_lookups if self.is_commit and commit_lookup: if self.commit_version is not None: return self.commit_version commit_info = commit_lookup.get(self.string) if commit_info: prev_version, distance = commit_info # Extend previous version by empty component and distance # If commit is exactly a known version, no distance suffix prev_tuple = Version(prev_version).version if prev_version else () dist_suffix = (VersionStrComponent(''), distance) if distance else () self.commit_version = prev_tuple + dist_suffix return self.commit_version return self.version @property def dotted(self): """The dotted representation of the version. Example: >>> version = Version('1-2-3b') >>> version.dotted Version('1.2.3b') Returns: Version: The version with separator characters replaced by dots """ return Version(self.string.replace('-', '.').replace('_', '.')) @property def underscored(self): """The underscored representation of the version. Example: >>> version = Version('1.2.3b') >>> version.underscored Version('1_2_3b') Returns: Version: The version with separator characters replaced by underscores """ return Version(self.string.replace('.', '_').replace('-', '_')) @property def dashed(self): """The dashed representation of the version. Example: >>> version = Version('1.2.3b') >>> version.dashed Version('1-2-3b') Returns: Version: The version with separator characters replaced by dashes """ return Version(self.string.replace('.', '-').replace('_', '-')) @property def joined(self): """The joined representation of the version. Example: >>> version = Version('1.2.3b') >>> version.joined Version('123b') Returns: Version: The version with separator characters removed """ return Version( self.string.replace('.', '').replace('-', '').replace('_', ''))
[docs] def up_to(self, index): """The version up to the specified component. Examples: >>> version = Version('1.23-4b') >>> version.up_to(1) Version('1') >>> version.up_to(2) Version('1.23') >>> version.up_to(3) Version('1.23-4') >>> version.up_to(4) Version('1.23-4b') >>> version.up_to(-1) Version('1.23-4') >>> version.up_to(-2) Version('1.23') >>> version.up_to(-3) Version('1') Returns: Version: The first index components of the version """ return self[:index]
[docs] def lowest(self): return self
[docs] def highest(self): return self
[docs] def isdevelop(self): """Triggers on the special case of the `@develop-like` version.""" for inf in infinity_versions: for v in self.version: if v == inf: return True return False
[docs] @coerced def satisfies(self, other): """A Version 'satisfies' another if it is at least as specific and has a common prefix. e.g., we want gcc@4.7.3 to satisfy a request for gcc@4.7 so that when a user asks to build with gcc@4.7, we can find a suitable compiler. """ self_cmp = self._cmp(other.commit_lookup) other_cmp = other._cmp(self.commit_lookup) # Do the final comparison nself = len(self_cmp) nother = len(other_cmp) return nother <= nself and self_cmp[:nother] == other_cmp
def __iter__(self): return iter(self.version) def __len__(self): return len(self.version) def __getitem__(self, idx): cls = type(self) if isinstance(idx, numbers.Integral): return self.version[idx] elif isinstance(idx, slice): string_arg = [] pairs = zip(self.version[idx], self.separators[idx]) for token, sep in pairs: string_arg.append(str(token)) string_arg.append(str(sep)) if string_arg: string_arg.pop() # We don't need the last separator string_arg = ''.join(string_arg) return cls(string_arg) else: return Version('') message = '{cls.__name__} indices must be integers' raise TypeError(message.format(cls=cls)) def __repr__(self): return 'Version(' + repr(self.string) + ')' def __str__(self): return self.string def __format__(self, format_spec): return self.string.format(format_spec) @property def concrete(self): return self @coerced def __lt__(self, other): """Version comparison is designed for consistency with the way RPM does things. If you need more complicated versions in installed packages, you should override your package's version string to express it more sensibly. """ if other is None: return False # If either is a commit and we haven't indexed yet, can't compare if (other.is_commit or self.is_commit) and not (self.commit_lookup or other.commit_lookup): return False # Use tuple comparison assisted by VersionStrComponent for performance return self._cmp(other.commit_lookup) < other._cmp(self.commit_lookup) @coerced def __eq__(self, other): # Cut out early if we don't have a version if other is None or type(other) != Version: return False return self._cmp(other.commit_lookup) == other._cmp(self.commit_lookup) @coerced def __ne__(self, other): return not (self == other) @coerced def __le__(self, other): return self == other or self < other @coerced def __ge__(self, other): return not (self < other) @coerced def __gt__(self, other): return not (self == other) and not (self < other) def __hash__(self): return hash(self.version) @coerced def __contains__(self, other): if other is None: return False self_cmp = self._cmp(other.commit_lookup) return other._cmp(self.commit_lookup)[:len(self_cmp)] == self_cmp
[docs] def is_predecessor(self, other): """True if the other version is the immediate predecessor of this one. That is, NO non-commit versions v exist such that: (self < v < other and v not in self). """ self_cmp = self._cmp(self.commit_lookup) other_cmp = other._cmp(other.commit_lookup) if self_cmp[:-1] != other_cmp[:-1]: return False sl = self_cmp[-1] ol = other_cmp[-1] return type(sl) == int and type(ol) == int and (ol - sl == 1)
[docs] def is_successor(self, other): return other.is_predecessor(self)
[docs] @coerced def overlaps(self, other): return self in other or other in self
[docs] @coerced def union(self, other): if self == other or other in self: return self elif self in other: return other else: return VersionList([self, other])
[docs] @coerced def intersection(self, other): if self in other: # also covers `self == other` return self elif other in self: return other else: return VersionList()
@property def commit_lookup(self): if self._commit_lookup: self._commit_lookup.get(self.string) return self._commit_lookup
[docs] def generate_commit_lookup(self, pkg_name): """ Use the git fetcher to look up a version for a commit. Since we want to optimize the clone and lookup, we do the clone once and store it in the user specified git repository cache. We also need context of the package to get known versions, which could be tags if they are linked to Git Releases. If we are unable to determine the context of the version, we cannot continue. This implementation is alongside the GitFetcher because eventually the git repos cache will be one and the same with the source cache. Args: fetcher: the fetcher to use. versions: the known versions of the package """ # Sanity check we have a commit if not self.is_commit: tty.die("%s is not a commit." % self) # Generate a commit looker-upper self._commit_lookup = CommitLookup(pkg_name)
[docs]class VersionRange(object): def __init__(self, start, end): if isinstance(start, string_types): start = Version(start) if isinstance(end, string_types): end = Version(end) self.start = start self.end = end # Unbounded ranges are not empty if not start or not end: return # Do not allow empty ranges. We have to be careful about lexicographical # ordering of versions here: 1.2 < 1.2.3 lexicographically, but 1.2.3:1.2 # means the range [1.2.3, 1.3), which is non-empty. min_len = min(len(start), len(end)) if end.up_to(min_len) < start.up_to(min_len): raise ValueError("Invalid Version range: %s" % self)
[docs] def lowest(self): return self.start
[docs] def highest(self): return self.end
@coerced def __lt__(self, other): """Sort VersionRanges lexicographically so that they are ordered first by start and then by end. None denotes an open range, so None in the start position is less than everything except None, and None in the end position is greater than everything but None. """ if other is None: return False s, o = self, other if s.start != o.start: return s.start is None or ( o.start is not None and s.start < o.start) return (s.end != o.end and o.end is None or (s.end is not None and s.end < o.end)) @coerced def __eq__(self, other): return (other is not None and type(other) == VersionRange and self.start == other.start and self.end == other.end) @coerced def __ne__(self, other): return not (self == other) @coerced def __le__(self, other): return self == other or self < other @coerced def __ge__(self, other): return not (self < other) @coerced def __gt__(self, other): return not (self == other) and not (self < other) @property def concrete(self): return self.start if self.start == self.end else None @coerced def __contains__(self, other): if other is None: return False in_lower = (self.start == other.start or self.start is None or (other.start is not None and ( self.start < other.start or other.start in self.start))) if not in_lower: return False in_upper = (self.end == other.end or self.end is None or (other.end is not None and ( self.end > other.end or other.end in self.end))) return in_upper
[docs] @coerced def satisfies(self, other): """ x.satisfies(y) in general means that x and y have a non-zero intersection. For VersionRange this means they overlap. `satisfies` is a commutative binary operator, meaning that x.satisfies(y) if and only if y.satisfies(x). Note: in some cases we have the keyword x.satisfies(y, strict=True) to mean strict set inclusion, which is not commutative. However, this lacks in VersionRange for unknown reasons. Examples - 1:3 satisfies 2:4, as their intersection is 2:3. - 1:2 does not satisfy 3:4, as their intersection is empty. - 4.5:4.7 satisfies 4.7.2:4.8, as their intersection is 4.7.2:4.7 """ return self.overlaps(other)
[docs] @coerced def overlaps(self, other): return ((self.start is None or other.end is None or self.start <= other.end or other.end in self.start or self.start in other.end) and (other.start is None or self.end is None or other.start <= self.end or other.start in self.end or self.end in other.start))
[docs] @coerced def union(self, other): if not self.overlaps(other): if (self.end is not None and other.start is not None and self.end.is_predecessor(other.start)): return VersionRange(self.start, other.end) if (other.end is not None and self.start is not None and other.end.is_predecessor(self.start)): return VersionRange(other.start, self.end) return VersionList([self, other]) # if we're here, then we know the ranges overlap. if self.start is None or other.start is None: start = None else: start = self.start # TODO: See note in intersection() about < and in discrepancy. if self.start in other.start or other.start < self.start: start = other.start if self.end is None or other.end is None: end = None else: end = self.end # TODO: See note in intersection() about < and in discrepancy. if other.end not in self.end: if end in other.end or other.end > self.end: end = other.end return VersionRange(start, end)
[docs] @coerced def intersection(self, other): if self.overlaps(other): if self.start is None: start = other.start else: start = self.start if other.start is not None: if other.start > start or other.start in start: start = other.start if self.end is None: end = other.end else: end = self.end # TODO: does this make sense? # This is tricky: # 1.6.5 in 1.6 = True (1.6.5 is more specific) # 1.6 < 1.6.5 = True (lexicographic) # Should 1.6 NOT be less than 1.6.5? Hmm. # Here we test (not end in other.end) first to avoid paradox. if other.end is not None and end not in other.end: if other.end < end or other.end in end: end = other.end return VersionRange(start, end) else: return VersionList()
def __hash__(self): return hash((self.start, self.end)) def __repr__(self): return self.__str__() def __str__(self): out = "" if self.start: out += str(self.start) out += ":" if self.end: out += str(self.end) return out
[docs]class VersionList(object): """Sorted, non-redundant list of Versions and VersionRanges.""" def __init__(self, vlist=None): self.versions = [] if vlist is not None: if isinstance(vlist, string_types): vlist = _string_to_version(vlist) if type(vlist) == VersionList: self.versions = vlist.versions else: self.versions = [vlist] else: for v in vlist: self.add(ver(v))
[docs] def add(self, version): if type(version) in (Version, VersionRange): # This normalizes single-value version ranges. if version.concrete: version = version.concrete i = bisect_left(self, version) while i - 1 >= 0 and version.overlaps(self[i - 1]): version = version.union(self[i - 1]) del self.versions[i - 1] i -= 1 while i < len(self) and version.overlaps(self[i]): version = version.union(self[i]) del self.versions[i] self.versions.insert(i, version) elif type(version) == VersionList: for v in version: self.add(v) else: raise TypeError("Can't add %s to VersionList" % type(version))
@property def concrete(self): if len(self) == 1: return self[0].concrete else: return None
[docs] def copy(self): return VersionList(self)
[docs] def lowest(self): """Get the lowest version in the list.""" if not self: return None else: return self[0].lowest()
[docs] def highest(self): """Get the highest version in the list.""" if not self: return None else: return self[-1].highest()
[docs] def highest_numeric(self): """Get the highest numeric version in the list.""" numeric_versions = list(filter( lambda v: str(v) not in infinity_versions, self.versions)) if not any(numeric_versions): return None else: return numeric_versions[-1].highest()
[docs] def preferred(self): """Get the preferred (latest) version in the list.""" latest = self.highest_numeric() if latest is None: latest = self.highest() return latest
[docs] @coerced def overlaps(self, other): if not other or not self: return False s = o = 0 while s < len(self) and o < len(other): if self[s].overlaps(other[o]): return True elif self[s] < other[o]: s += 1 else: o += 1 return False
[docs] def to_dict(self): """Generate human-readable dict for YAML.""" if self.concrete: return syaml_dict([ ('version', str(self[0])) ]) else: return syaml_dict([ ('versions', [str(v) for v in self]) ])
[docs] @staticmethod def from_dict(dictionary): """Parse dict from to_dict.""" if 'versions' in dictionary: return VersionList(dictionary['versions']) elif 'version' in dictionary: return VersionList([dictionary['version']]) else: raise ValueError("Dict must have 'version' or 'versions' in it.")
[docs] @coerced def satisfies(self, other, strict=False): """A VersionList satisfies another if some version in the list would satisfy some version in the other list. This uses essentially the same algorithm as overlaps() does for VersionList, but it calls satisfies() on member Versions and VersionRanges. If strict is specified, this version list must lie entirely *within* the other in order to satisfy it. """ if not other or not self: return False if strict: return self in other s = o = 0 while s < len(self) and o < len(other): if self[s].satisfies(other[o]): return True elif self[s] < other[o]: s += 1 else: o += 1 return False
[docs] @coerced def update(self, other): for v in other.versions: self.add(v)
[docs] @coerced def union(self, other): result = self.copy() result.update(other) return result
[docs] @coerced def intersection(self, other): # TODO: make this faster. This is O(n^2). result = VersionList() for s in self: for o in other: result.add(s.intersection(o)) return result
[docs] @coerced def intersect(self, other): """Intersect this spec's list with other. Return True if the spec changed as a result; False otherwise """ isection = self.intersection(other) changed = (isection.versions != self.versions) self.versions = isection.versions return changed
@coerced def __contains__(self, other): if len(self) == 0: return False for version in other: i = bisect_left(self, other) if i == 0: if version not in self[0]: return False elif all(version not in v for v in self[i - 1:]): return False return True def __getitem__(self, index): return self.versions[index] def __iter__(self): return iter(self.versions) def __reversed__(self): return reversed(self.versions) def __len__(self): return len(self.versions) def __bool__(self): return bool(self.versions) @coerced def __eq__(self, other): return other is not None and self.versions == other.versions @coerced def __ne__(self, other): return not (self == other) @coerced def __lt__(self, other): return other is not None and self.versions < other.versions @coerced def __le__(self, other): return self == other or self < other @coerced def __ge__(self, other): return not (self < other) @coerced def __gt__(self, other): return not (self == other) and not (self < other) def __hash__(self): return hash(tuple(self.versions)) def __str__(self): return ",".join(str(v) for v in self.versions) def __repr__(self): return str(self.versions)
def _string_to_version(string): """Converts a string to a Version, VersionList, or VersionRange. This is private. Client code should use ver(). """ string = string.replace(' ', '') if ',' in string: return VersionList(string.split(',')) elif ':' in string: s, e = string.split(':') start = Version(s) if s else None end = Version(e) if e else None return VersionRange(start, end) else: return Version(string)
[docs]def ver(obj): """Parses a Version, VersionRange, or VersionList from a string or list of strings. """ if isinstance(obj, (list, tuple)): return VersionList(obj) elif isinstance(obj, string_types): return _string_to_version(obj) elif isinstance(obj, (int, float)): return _string_to_version(str(obj)) elif type(obj) in (Version, VersionRange, VersionList): return obj else: raise TypeError("ver() can't convert %s to version!" % type(obj))
class VersionError(spack.error.SpackError): """This is raised when something is wrong with a version.""" class VersionChecksumError(VersionError): """Raised for version checksum errors.""" class VersionLookupError(VersionError): """Raised for errors looking up git commits as versions.""" class CommitLookup(object): """An object for cached lookups of git commits CommitLookup objects delegate to the misc_cache for locking. CommitLookup objects may be attached to a Version object for which Version.is_commit returns True to allow for comparisons between git commits and versions as represented by tags in the git repository. """ def __init__(self, pkg_name): self.pkg_name = pkg_name = {} self._pkg = None self._fetcher = None self._cache_key = None self._cache_path = None # The following properties are used as part of a lazy reference scheme # to avoid querying the package repository until it is necessary (and # in particular to wait until after the configuration has been # assembled) @property def cache_key(self): if not self._cache_key: key_base = 'git_metadata' if not self.repository_uri.startswith('/'): key_base += '/' self._cache_key = key_base + self.repository_uri # Cache data in misc_cache # If this is the first lazy access, initialize the cache as well spack.caches.misc_cache.init_entry(self.cache_key) return self._cache_key @property def cache_path(self): if not self._cache_path: self._cache_path = spack.caches.misc_cache.cache_path( self.cache_key) return self._cache_path @property def pkg(self): if not self._pkg: self._pkg = spack.repo.get(self.pkg_name) return self._pkg @property def fetcher(self): if not self._fetcher: # We require the full git repository history import spack.fetch_strategy # break cycle fetcher = spack.fetch_strategy.GitFetchStrategy(git=self.pkg.git) fetcher.get_full_repo = True self._fetcher = fetcher return self._fetcher @property def repository_uri(self): """ Identifier for git repos used within the repo and metadata caches. """ try: components = [str(c).lstrip('/') for c in spack.util.url.parse_git_url(self.pkg.git) if c] return os.path.join(*components) except ValueError: # If it's not a git url, it's a local path return os.path.abspath(self.pkg.git) def save(self): """ Save the data to file """ with spack.caches.misc_cache.write_transaction(self.cache_key) as (old, new): sjson.dump(, new) def load_data(self): """ Load data if the path already exists. """ if os.path.isfile(self.cache_path): with spack.caches.misc_cache.read_transaction(self.cache_key) as cache_file: = sjson.load(cache_file) def get(self, commit): if not self.load_data() if commit not in[commit] = self.lookup_commit(commit) return[commit] def lookup_commit(self, commit): """Lookup the previous version and distance for a given commit. We use git to compare the known versions from package to the git tags, as well as any git tags that are SEMVER versions, and find the latest known version prior to the commit, as well as the distance from that version to the commit in the git repo. Those values are used to compare Version objects. """ dest = os.path.join(spack.paths.user_repos_cache_path, self.repository_uri) if dest.endswith('.git'): dest = dest[:-4] # prepare a cache for the repository dest_parent = os.path.dirname(dest) if not os.path.exists(dest_parent): mkdirp(dest_parent) # Only clone if we don't have it! if not os.path.exists(dest): self.fetcher.clone(dest, bare=True) # Lookup commit info with working_dir(dest): # TODO: we need to update the local tags if they changed on the # remote instance, simply adding '-f' may not be sufficient # (if commits are deleted on the remote, this command alone # won't properly update the local rev-list) self.fetcher.git("fetch", '--tags') # Ensure commit is an object known to git # Note the brackets are literals, the commit replaces the format string # This will raise a ProcessError if the commit does not exist # We may later design a custom error to re-raise self.fetcher.git('cat-file', '-e', '%s^{commit}' % commit) # List tags (refs) by date, so last reference of a tag is newest tag_info = self.fetcher.git( "for-each-ref", "--sort=creatordate", "--format", "%(objectname) %(refname)", "refs/tags", output=str).split('\n') # Lookup of commits to spack versions commit_to_version = {} for entry in tag_info: if not entry: continue tag_commit, tag = entry.split() tag = tag.replace('refs/tags/', '', 1) # For each tag, try to match to a version for v in [v.string for v in self.pkg.versions]: if v == tag or 'v' + v == tag: commit_to_version[tag_commit] = v break else: # try to parse tag to copare versions spack does not know match = SEMVER_REGEX.match(tag) if match: semver = match.groupdict()['semver'] commit_to_version[tag_commit] = semver ancestor_commits = [] for tag_commit in commit_to_version: self.fetcher.git( 'merge-base', '--is-ancestor', tag_commit, commit, ignore_errors=[1]) if self.fetcher.git.returncode == 0: distance = self.fetcher.git( 'rev-list', '%s..%s' % (tag_commit, commit), '--count', output=str, error=str).strip() ancestor_commits.append((tag_commit, int(distance))) # Get nearest ancestor that is a known version ancestor_commits.sort(key=lambda x: x[1]) if ancestor_commits: prev_version_commit, distance = ancestor_commits[0] prev_version = commit_to_version[prev_version_commit] else: # Get list of all commits, this is in reverse order # We use this to get the first commit below commit_info = self.fetcher.git("log", "--all", "--pretty=format:%H", output=str) commits = [c for c in commit_info.split('\n') if c] # No previous version and distance from first commit prev_version = None distance = int(self.fetcher.git( 'rev-list', '%s..%s' % (commits[-1], commit), '--count', output=str, error=str ).strip()) return prev_version, distance