"""

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)

check_type(ta)

check_type(tb)

if ta == tb:

return (a, b)

elif order.index(ta) > order.index(tb):

if ta == VersionRange:

return (a, VersionRange(b, b))

else:

return (a, VersionList([b]))

else:

if tb == VersionRange:

return (VersionRange(a, a), b)

else:

"""Decorator that ensures that argument types of a method are coerced."""

@wraps(method)

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)

else:

ca, cb = coerce_versions(a, b)

return getattr(ca, method.__name__)(cb, *args, **kwargs)

# 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

self.data = string

if len(string) >= iv_min_len:

try:

self.inf_ver = infinity_versions.index(string)

except ValueError:

pass

def __hash__(self):

return hash(self.data)

def __str__(self):

return self.data

def __eq__(self, other):

if isinstance(other, VersionStrComponent):

return self.data == other.data

return self.data == 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 self.data < other.data

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 rpm.org. 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):

"""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.

return Version(self.string.replace('-', '.').replace('_', '.'))

@property

def underscored(self):

"""The underscored representation of the version.

return Version(self.string.replace('.', '_').replace('-', '_'))

@property

def dashed(self):

"""The dashed representation of the version.

return Version(self.string.replace('.', '-').replace('_', '-'))

@property

def joined(self):

"""The joined representation of the version.

return Version(

self.string.replace('.', '').replace('-', '').replace('_', ''))

def up_to(self, index):

"""The version up to the specified component.

return self[:index]

def lowest(self):

return self

def highest(self):

return self

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

@coerced

def satisfies(self, other):

"""A Version 'satisfies' another if it is at least as specific and has

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

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

def is_predecessor(self, other):

"""True if the other version is the immediate predecessor of this one.

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)

def is_successor(self, other):

return other.is_predecessor(self)

@coerced

def overlaps(self, other):

return self in other or other in self

@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])

@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

def generate_commit_lookup(self, pkg_name):

"""

# Sanity check we have a commit

if not self.is_commit:

tty.die("%s is not a commit." % self)

# Generate a commit looker-upper

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)

def lowest(self):

return self.start

def highest(self):

return self.end

@coerced

def __lt__(self, other):

"""Sort VersionRanges lexicographically so that they are ordered first

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

@coerced

def satisfies(self, other):

"""

return self.overlaps(other)

@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))

@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)

@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)

"""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))

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

def copy(self):

return VersionList(self)

def lowest(self):

"""Get the lowest version in the list."""

if not self:

return None

else:

return self[0].lowest()

def highest(self):

"""Get the highest version in the list."""

if not self:

return None

else:

return self[-1].highest()

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()

def preferred(self):

"""Get the preferred (latest) version in the list."""

latest = self.highest_numeric()

if latest is None:

latest = self.highest()

return latest

@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

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])

])

@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.")

@coerced

def satisfies(self, other, strict=False):

"""A VersionList satisfies another if some version in the list

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

@coerced

def update(self, other):

for v in other.versions:

self.add(v)

@coerced

def union(self, other):

result = self.copy()

result.update(other)

return result

@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

@coerced

def intersect(self, other):

"""Intersect this spec's list with other.

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):

"""Converts a string to a Version, VersionList, or VersionRange.

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:

"""Parses a Version, VersionRange, or VersionList from a string

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:

"""An object for cached lookups of git commits

def __init__(self, pkg_name):

self.pkg_name = pkg_name

self.data = {}