From 6e2a718d153cada7ce9bacb67d27bf5194cceabd Mon Sep 17 00:00:00 2001 From: Tim Head Date: Thu, 7 Mar 2019 23:29:34 +0100 Subject: [PATCH] Apply linter steam roller --- repo2docker/buildpacks/julia/semver.py | 88 +++++++++++++++++++------- 1 file changed, 66 insertions(+), 22 deletions(-) diff --git a/repo2docker/buildpacks/julia/semver.py b/repo2docker/buildpacks/julia/semver.py index 9107cb9c..0203f064 100644 --- a/repo2docker/buildpacks/julia/semver.py +++ b/repo2docker/buildpacks/julia/semver.py @@ -9,8 +9,11 @@ # functors take a version string and return true if it passes its constraints. import re +from enum import Enum + import semver + # Main algorithm: # Create an AbstractMatcher instance from the constraint string, and check it # against each version in the versions_list, returning the first success. @@ -21,60 +24,91 @@ def find_semver_match(constraint, versions_list): return vstr return None + def str_to_version(vstr): - return tuple([int(n) for n in vstr.split('.')]) + return tuple([int(n) for n in vstr.split(".")]) + # --- Matcher interface ------------------------------------------- + class AbstractMatcher: def match(self, v): pass + class SemverMatcher(AbstractMatcher): """ Match a version tuple to a given constraint_str using the `semver` package. """ + def __init__(self, constraint_str): self.constraint_str = constraint_str + def match(self, v): while len(v) < 3: - v = v+(0,) - v_str = '.'.join(map(str, v)) + v = v + (0,) + v_str = ".".join(map(str, v)) return semver.match(v_str, self.constraint_str) + def __eq__(self, rhs): return self.constraint_str == rhs.constraint_str + def __repr__(self): return self.constraint_str -# --- Custom matcher for julia-specific SemVer handling: --------- -from enum import Enum +# --- Custom matcher for julia-specific SemVer handling: --------- class Exclusivity(Enum): EXCLUSIVE = 1 INCLUSIVE = 2 + class VersionRange(AbstractMatcher): - """ Match a version tuple between lower and upper bounds. """ + """Match a version tuple between lower and upper bounds""" + def __init__(self, lower, upper, upper_exclusivity): self.lower = lower self.upper = upper self.upper_exclusivity = upper_exclusivity + def match(self, v): if self.upper_exclusivity == Exclusivity.EXCLUSIVE: return self.lower <= v < self.upper else: return self.lower <= v <= self.upper + def __eq__(self, rhs): - return self.lower == rhs.lower and self.upper == rhs.upper and self.upper_exclusivity == rhs.upper_exclusivity + return ( + self.lower == rhs.lower + and self.upper == rhs.upper + and self.upper_exclusivity == rhs.upper_exclusivity + ) + def __repr__(self): - return ("["+".".join(map(str, self.lower)) +"-"+ ".".join(map(str, self.upper)) + - (")" if self.upper_exclusivity == Exclusivity.EXCLUSIVE else "]")) + return ( + "[" + + ".".join(map(str, self.lower)) + + "-" + + ".".join(map(str, self.upper)) + + (")" if self.upper_exclusivity == Exclusivity.EXCLUSIVE else "]") + ) + # Helpers -def major(v): return v[0] -def minor(v): return v[1] if len(v) >= 2 else 0 -def patch(v): return v[2] if len(v) >= 3 else 0 +def major(v): + return v[0] + + +def minor(v): + return v[1] if len(v) >= 2 else 0 + + +def patch(v): + return v[2] if len(v) >= 3 else 0 + # --- main constraint parser function ------------------------------------ + def create_semver_matcher(constraint_str): """ Returns a derived-class instance of AbstractMatcher that matches version @@ -85,9 +119,9 @@ def create_semver_matcher(constraint_str): if not first_digit: # Invalid version string (no numbers in it) return "" - constraint = str_to_version(constraint_str[first_digit.start():]) + constraint = str_to_version(constraint_str[first_digit.start() :]) - comparison_symbol = constraint_str[0:first_digit.start()].strip() + comparison_symbol = constraint_str[0 : first_digit.start()].strip() # Default to "^" search if no matching mode specified (up to next major version) if (first_digit.start() == 0) or (comparison_symbol == "^"): @@ -96,25 +130,35 @@ def create_semver_matcher(constraint_str): # non-zero number is actually a major number: # https://docs.julialang.org/en/latest/stdlib/Pkg/#Caret-specifiers-1 # So we need to handle it separately by bumping the first non-zero number. - for i,n in enumerate(constraint): - if n != 0 or i == len(constraint)-1: # (using the last existing number handles situations like "^0.0" or "^0") - upper = constraint[0:i] + (n+1,) + for i, n in enumerate(constraint): + if ( + n != 0 or i == len(constraint) - 1 + ): # (using the last existing number handles situations like "^0.0" or "^0") + upper = constraint[0:i] + (n + 1,) break return VersionRange(constraint, upper, Exclusivity.EXCLUSIVE) else: - return VersionRange(constraint, (major(constraint)+1,), Exclusivity.EXCLUSIVE) + return VersionRange( + constraint, (major(constraint) + 1,), Exclusivity.EXCLUSIVE + ) # '~' matching (only allowed to bump the last present number by one) - if (comparison_symbol == "~"): - return VersionRange(constraint, constraint[:-1] +(constraint[-1]+1,), Exclusivity.INCLUSIVE) + if comparison_symbol == "~": + return VersionRange( + constraint, + constraint[:-1] + (constraint[-1] + 1,), + Exclusivity.INCLUSIVE, + ) # Use semver package's comparisons for everything else: # semver requires three version numbers if len(constraint) < 3: while len(constraint) < 3: - constraint = constraint+(0,) - constraint_str = constraint_str[0:first_digit.start()] + ".".join(map(str, constraint)) + constraint = constraint + (0,) + constraint_str = constraint_str[0 : first_digit.start()] + ".".join( + map(str, constraint) + ) # Convert special comparison strings to format accepted by `semver` library. constraint_str = constraint_str.replace("≥", ">=").replace("≤", "<=")