reformat with black

1 files changed, 109 insertions, 107 deletions

diff --git a/ick_helpers.py b/ick_helpers.py
index c7e3e07..6619b75 100644
--- a/ick_helpers.py
+++ b/ick_helpers.py
@@ -33,95 +33,90 @@ class Exec:
     def run(self, *args, **kwargs):
         # Run a command.
 
-        if 'cwd' not in kwargs:
-            kwargs['cwd'] = self.dirname
-        if 'check' not in kwargs:
-          kwargs['check'] = True
-        if 'stdout' not in kwargs:
-          kwargs['stdout'] = subprocess.PIPE
-        if 'stderr' not in kwargs:
-          kwargs['stderr'] = subprocess.STDOUT
-
-        debug('RUN:', args, kwargs)
+        if "cwd" not in kwargs:
+            kwargs["cwd"] = self.dirname
+        if "check" not in kwargs:
+            kwargs["check"] = True
+        if "stdout" not in kwargs:
+            kwargs["stdout"] = subprocess.PIPE
+        if "stderr" not in kwargs:
+            kwargs["stderr"] = subprocess.STDOUT
+
+        debug("RUN:", args, kwargs)
         x = subprocess.run(args, **kwargs)
-        if kwargs['stdout'] == subprocess.PIPE:
+        if kwargs["stdout"] == subprocess.PIPE:
             if x.stdout:
-                sys.stdout.write(x.stdout.decode('UTF-8'))
+                sys.stdout.write(x.stdout.decode("UTF-8"))
         return x
 
     def get_stdout(self, *args, **kwargs):
         # Run a command, capture its stdout. Fail on non-zero exit.
 
-        kwargs['check'] = True
-        kwargs['stdout'] = subprocess.PIPE
+        kwargs["check"] = True
+        kwargs["stdout"] = subprocess.PIPE
         x = self.run(*args, **kwargs)
-        return x.stdout.decode('UTF-8')
+        return x.stdout.decode("UTF-8")
 
     def run_silently(self, *args, **kwargs):
         # Run a command, don't capture output. Return exit code.
 
-        kwargs['stdout'] = kwargs['stderr'] = subprocess.DEVNULL
-        kwargs['check'] = False
+        kwargs["stdout"] = kwargs["stderr"] = subprocess.DEVNULL
+        kwargs["check"] = False
         return self.run(*args, **kwargs)
 
     def is_signed_tag(self, tag):
-        x = self.run_silently('git', 'tag', '--verify', tag)
+        x = self.run_silently("git", "tag", "--verify", tag)
         return x.returncode == 0
 
     def is_named_as_release_tag(self, tag, project):
-        prefix = tag[:len(project)]
-        suffix = tag[len(prefix):]
-        return prefix == project and re.match(r'^-\d+\.\d+(\.\d+)*$', suffix)
+        prefix = tag[: len(project)]
+        suffix = tag[len(prefix) :]
+        return prefix == project and re.match(r"^-\d+\.\d+(\.\d+)*$", suffix)
 
     def is_release_tag(self, tag, project):
         if not self.is_signed_tag(tag):
-            debug('tag is not signed:', tag)
+            debug("tag is not signed:", tag)
             return False
         if not self.is_named_as_release_tag(tag, project):
-            debug('tag is not named correctly for a release tag:', tag)
+            debug("tag is not named correctly for a release tag:", tag)
             return False
-        debug('seems to be a release tag:', tag)
+        debug("seems to be a release tag:", tag)
         return True
 
     def get_project_name(self):
-        setup_py = os.path.join(self.dirname, 'setup.py')
-        if os.path.exists(setup_py) and self.got_command('python3'):
-            output = self.get_stdout('python3', 'setup.py', '--name')
-        elif os.path.exists(setup_py) and self.got_command('python'):
-            output = self.get_stdout('python', 'setup.py', '--name')
+        setup_py = os.path.join(self.dirname, "setup.py")
+        if os.path.exists(setup_py) and self.got_command("python3"):
+            output = self.get_stdout("python3", "setup.py", "--name")
+        elif os.path.exists(setup_py) and self.got_command("python"):
+            output = self.get_stdout("python", "setup.py", "--name")
         else:
-            output = self.get_stdout('dpkg-parsechangelog', '-S', 'Source')
+            output = self.get_stdout("dpkg-parsechangelog", "-S", "Source")
         return output.strip()
 
     def got_command(self, cmd):
-        return self.run_silently('sh', '-c', 'command -v "$1"', '-', cmd) == 0
+        return self.run_silently("sh", "-c", 'command -v "$1"', "-", cmd) == 0
 
     def get_version_from_tag(self, tag):
-        parts = tag.split('-', 1)
-        debug('tag parts:', parts)
+        parts = tag.split("-", 1)
+        debug("tag parts:", parts)
         assert len(parts) == 2
         return parts[1]
 
     def find_all_tags(self):
-        output = self.get_stdout('git', 'tag', '-l')
+        output = self.get_stdout("git", "tag", "-l")
         return output.splitlines()
 
     def find_release_tags(self, project):
         tags = self.find_all_tags()
-        return [
-            tag
-            for tag in tags
-            if self.is_release_tag(tag, project)
-        ]
+        return [tag for tag in tags if self.is_release_tag(tag, project)]
 
     def create_tarball_from_tag(self, ref, filename):
-        self.run('git', 'archive', '-o', 'temp.tar', ref)
-        self.run('xz', '-9', 'temp.tar')
-        self.run('mv', 'temp.tar.xz', filename)
+        self.run("git", "archive", "-o", "temp.tar", ref)
+        self.run("xz", "-9", "temp.tar")
+        self.run("mv", "temp.tar.xz", filename)
 
 
 class Version:
-
     def __init__(self, full_version):
         self._full_version = full_version
 
@@ -129,9 +124,9 @@ class Version:
         return self._full_version
 
     def upstream_append(self, morever):
-        assert '-' in self._full_version
-        parts = self._full_version.split('-')
-        self._full_version = '{}{}-1'.format(self.upstream, morever)
+        assert "-" in self._full_version
+        parts = self._full_version.split("-")
+        self._full_version = "{}{}-1".format(self.upstream, morever)
 
     @property
     def full(self):
@@ -139,19 +134,18 @@ class Version:
 
     @property
     def upstream(self):
-        parts = self._full_version.split('-')
-        return '-'.join(parts[:-1])
+        parts = self._full_version.split("-")
+        return "-".join(parts[:-1])
 
     @property
     def debian(self):
-        parts = self._full_version.split('-')
+        parts = self._full_version.split("-")
         if len(parts) == 1:
             return None
         return parts[-1]
 
 
 class DebianBuilderBase:
-
     def __init__(self, ex, debfullname, debemail):
         self.ex = ex
         self.debfullname = debfullname
@@ -163,48 +157,55 @@ class DebianBuilderBase:
         return basename
 
     def create_debian_orig_tarball(self, upstream_tarball, source, version):
-        tarball = '{}_{}.orig.tar.xz'.format(source, version.upstream)
+        tarball = "{}_{}.orig.tar.xz".format(source, version.upstream)
         os.link(upstream_tarball, tarball)
-        debug('upstream_tarball:', tarball)
+        debug("upstream_tarball:", tarball)
         return tarball
 
     def get_source_package(self):
-        output = self.ex.get_stdout('dpkg-parsechangelog', '-S', 'Source')
+        output = self.ex.get_stdout("dpkg-parsechangelog", "-S", "Source")
         source = output.strip()
-        debug('Source package:', source)
+        debug("Source package:", source)
         return source
 
     def get_version(self):
-        output = self.ex.get_stdout('dpkg-parsechangelog', '-S', 'Version')
+        output = self.ex.get_stdout("dpkg-parsechangelog", "-S", "Version")
         version = Version(output.strip())
-        debug('Version:', version)
+        debug("Version:", version)
         return version
 
     def get_distribution(self):
-        output = self.ex.get_stdout('dpkg-parsechangelog', '-S', 'Distribution')
+        output = self.ex.get_stdout("dpkg-parsechangelog", "-S", "Distribution")
         curdist = output.strip()
-        debug('Distribution:', curdist)
+        debug("Distribution:", curdist)
         return curdist
 
     def set_distribution(self, version, distribution):
         env = dict(os.environ)
-        env['DEBFULLNAME'] = self.debfullname
-        env['DEBEMAIL'] = self.debemail
-        msg = 'Build in ick.'
+        env["DEBFULLNAME"] = self.debfullname
+        env["DEBEMAIL"] = self.debemail
+        msg = "Build in ick."
         self.ex.run(
-            'dch', '--no-conf', '-v', str(version), '-D', distribution,
-            '--force-distribution', msg, env=env)
-        self.ex.run('dch', '--no-conf', '-r', '', env=env)
+            "dch",
+            "--no-conf",
+            "-v",
+            str(version),
+            "-D",
+            distribution,
+            "--force-distribution",
+            msg,
+            env=env,
+        )
+        self.ex.run("dch", "--no-conf", "-r", "", env=env)
 
     def create_dsc(self):
-        self.ex.run('dpkg-buildpackage', '-S', '--no-sign', '-sa')
+        self.ex.run("dpkg-buildpackage", "-S", "--no-sign", "-sa")
 
     def build_deb(self):
-        self.ex.run('dpkg-buildpackage', '-b', '--no-sign')
+        self.ex.run("dpkg-buildpackage", "-b", "--no-sign")
 
 
 class DebianReleaseBuilder(DebianBuilderBase):
-
     def __init__(self, ex, resultsdir, debfullname, debemail):
         super().__init__(ex, debfullname, debemail)
         self.results = resultsdir
@@ -212,7 +213,7 @@ class DebianReleaseBuilder(DebianBuilderBase):
     def build(self, tag, distribution):
         self.checkout(tag)
 
-        basename = '{}.tar.xz'.format(tag)
+        basename = "{}.tar.xz".format(tag)
         upstream_tarball = self.create_upstream_tarball(basename, tag)
         self.stash(upstream_tarball)
 
@@ -220,11 +221,12 @@ class DebianReleaseBuilder(DebianBuilderBase):
         version = self.get_version()
         curdist = self.get_distribution()
 
-        morever = '.{}'.format(distribution)
+        morever = ".{}".format(distribution)
         version.upstream_append(morever)
 
         orig_tarball = self.create_debian_orig_tarball(
-            upstream_tarball, source, version)
+            upstream_tarball, source, version
+        )
 
         if curdist != distribution:
             self.set_distribution(version, distribution)
@@ -232,37 +234,36 @@ class DebianReleaseBuilder(DebianBuilderBase):
         self.create_dsc()
         self.build_deb()
 
-        debian_files = glob.glob('{}_{}*'.format(source, version.upstream))
-        debian_files = [x for x in debian_files if '+git' not in x]
+        debian_files = glob.glob("{}_{}*".format(source, version.upstream))
+        debian_files = [x for x in debian_files if "+git" not in x]
         self.stash(*debian_files)
 
-        filenames = glob.glob('{}_{}*'.format(source, version.upstream))
+        filenames = glob.glob("{}_{}*".format(source, version.upstream))
         filenames.append(upstream_tarball)
         self.cleanup(filenames)
 
     def checkout(self, tag):
-        self.ex.run('git', 'reset', '--hard', check=False)
-        self.ex.run('git', 'clean', '-fdx', check=False)
-        self.ex.run('git', 'checkout', 'master', check=False)
-        self.ex.run('git', 'branch', '-d', '__ickbuild', check=False)
-        self.ex.run('git', 'checkout', '-b', '__ickbuild', tag)
+        self.ex.run("git", "reset", "--hard", check=False)
+        self.ex.run("git", "clean", "-fdx", check=False)
+        self.ex.run("git", "checkout", "master", check=False)
+        self.ex.run("git", "branch", "-d", "__ickbuild", check=False)
+        self.ex.run("git", "checkout", "-b", "__ickbuild", tag)
 
     def stash(self, *filenames):
         if not os.path.exists(self.results):
             os.mkdir(self.results)
         for filename in filenames:
             dst = os.path.join(self.results, filename)
-            debug('STASH:', filename, '->', dst)
+            debug("STASH:", filename, "->", dst)
             os.link(filename, dst)
 
     def cleanup(self, filenames):
         for filename in filenames:
-            debug('DELETE', filename)
+            debug("DELETE", filename)
             os.remove(filename)
 
 
 class DebianCIBuilder(DebianBuilderBase):
-
     def __init__(self, ex, debfullname, debemail):
         self.ex = ex
         self.debfullname = debfullname
@@ -273,26 +274,27 @@ class DebianCIBuilder(DebianBuilderBase):
         version = self.get_version()
         curdist = self.get_distribution()
 
-        morever = '.0ci{}.{}'.format(os.environ['BUILD_NUMBER'], distribution)
+        morever = ".0ci{}.{}".format(os.environ["BUILD_NUMBER"], distribution)
         version.upstream_append(morever)
-        debug('appending to upstream version:', morever)
-        debug('full version now:', version)
+        debug("appending to upstream version:", morever)
+        debug("full version now:", version)
 
-        basename = '{}-{}.tar.xz'.format(source, version.upstream)
-        upstream_tarball = self.create_upstream_tarball(basename, 'HEAD')
+        basename = "{}-{}.tar.xz".format(source, version.upstream)
+        upstream_tarball = self.create_upstream_tarball(basename, "HEAD")
         orig_tarball = self.create_debian_orig_tarball(
-            upstream_tarball, source, version)
+            upstream_tarball, source, version
+        )
 
         self.set_distribution(version, distribution)
 
-        self.ex.run('find', '-ls')
+        self.ex.run("find", "-ls")
         self.create_dsc()
         self.build_deb()
 
 
 class KnownTags:
 
-    filename = '.known_tags'
+    filename = ".known_tags"
 
     def __init__(self):
         self.known = {}
@@ -311,26 +313,26 @@ class KnownTags:
         dists = self.known.get(tag, [])
         if distribution not in dists:
             self.known[tag] = dists + [distribution]
-            with open(self.filename, 'w') as f:
+            with open(self.filename, "w") as f:
                 json.dump(self.known, f, indent=4)
 
 
 def find_upstream_dirs(sources):
     for source in sources:
-        dirname = source['location']
-        control = os.path.join(dirname, 'debian', 'control')
+        dirname = source["location"]
+        control = os.path.join(dirname, "debian", "control")
         if os.path.exists(control):
-            debug('Found debian/control in', dirname)
+            debug("Found debian/control in", dirname)
             yield dirname
 
 
 def build_debian_releases(params, resultsdir):
-    debug('build_debian_releases: params=%r' % params)
-    debug('build_debian_releases: resultsdir=%r' % resultsdir)
-    sources = params['sources']
-    distribution = params['distribution_rel']
-    debfullname = params['DEBFULLNAME']
-    debemail = params['DEBEMAIL']
+    debug("build_debian_releases: params=%r" % params)
+    debug("build_debian_releases: resultsdir=%r" % resultsdir)
+    sources = params["sources"]
+    distribution = params["distribution_rel"]
+    debfullname = params["DEBFULLNAME"]
+    debemail = params["DEBEMAIL"]
     known = KnownTags()
     first_build = known.is_empty()
     dirnames = find_upstream_dirs(sources)
@@ -338,24 +340,24 @@ def build_debian_releases(params, resultsdir):
         ex = Exec(dirname)
         project = ex.get_project_name()
         tags = ex.find_release_tags(project)
-        debug('release tags:', tags)
+        debug("release tags:", tags)
         builder = DebianReleaseBuilder(ex, resultsdir, debfullname, debemail)
         for tag in tags:
             if first_build:
-                debug('First build, not building', tag, 'for', distribution)
+                debug("First build, not building", tag, "for", distribution)
             elif not known.is_known(tag, distribution):
-                debug('Building tag', tag, 'for', distribution)
+                debug("Building tag", tag, "for", distribution)
                 builder.build(tag, distribution)
             else:
-                debug('Already built, not building', tag, 'for', distribution)
+                debug("Already built, not building", tag, "for", distribution)
             known.remember(tag, distribution)
 
 
 def ci_build_debian(params):
-    sources = params['sources']
-    distribution = params['distribution_ci']
-    debfullname = params['DEBFULLNAME']
-    debemail = params['DEBEMAIL']
+    sources = params["sources"]
+    distribution = params["distribution_ci"]
+    debfullname = params["DEBFULLNAME"]
+    debemail = params["DEBEMAIL"]
     dirnames = find_upstream_dirs(sources)
 
     for dirname in dirnames: