refactor: format subplot.py with black

We use rustfmt for Rust code. Black is the corresponding tool for
Python code.

1 files changed, 87 insertions, 67 deletions

diff --git a/subplot.py b/subplot.py
index a64134a..1495553 100644
--- a/subplot.py
+++ b/subplot.py
@@ -3,171 +3,191 @@ import re
 import subprocess
 import time
 
+
 def create_file(ctx, filename=None):
-    with open(filename, 'wb') as f:
+    with open(filename, "wb") as f:
         f.write(get_file(filename))
 
-def touch_file(
-        ctx, filename=None, y=None, mon=None, d=None,
-        h=None, min=None, s=None):
+
+def touch_file(ctx, filename=None, y=None, mon=None, d=None, h=None, min=None, s=None):
     t = (int(y), int(mon), int(d), int(h), int(min), int(s), -1, -1, -1)
     ts = time.mktime(t)
     os.utime(filename, times=(ts, ts))
 
+
 def update_mtime(ctx, filename=None):
     os.utime(filename)
 
+
 def try_docgen(ctx, md=None, output=None):
-    docgen = binary('sp-docgen')
-    runcmd(ctx, [docgen, md, '-o', output])
+    docgen = binary("sp-docgen")
+    runcmd(ctx, [docgen, md, "-o", output])
+
 
 def run_docgen(ctx, md=None, output=None):
     try_docgen(ctx, md=md, output=output)
     exit_code_zero(ctx)
 
+
 def run_docgen_with_date(ctx, md=None, output=None, date=None):
-    docgen = binary('sp-docgen')
-    runcmd(ctx, [docgen, md, '-o', output, '--date', date])
+    docgen = binary("sp-docgen")
+    runcmd(ctx, [docgen, md, "-o", output, "--date", date])
     exit_code_zero(ctx)
 
+
 def try_codegen_and_program(ctx, filename=None):
-    codegen = binary('sp-codegen')
-    tmpldir = os.path.join(srcdir, 'templates')
-    runcmd(ctx, [codegen, filename, '-o', 'test.py', '--run', '--templates', tmpldir])
+    codegen = binary("sp-codegen")
+    tmpldir = os.path.join(srcdir, "templates")
+    runcmd(ctx, [codegen, filename, "-o", "test.py", "--run", "--templates", tmpldir])
+
 
 def run_codegen_and_program(ctx, filename=None):
     try_codegen_and_program(ctx, filename=filename)
     exit_code_zero(ctx)
 
+
 def run_codegen(ctx, filename=None, testprog=None):
-    codegen = binary('sp-codegen')
-    tmpldir = os.path.join(srcdir, 'templates')
-    runcmd(ctx, [codegen, filename, '-o', testprog, '--templates', tmpldir])
+    codegen = binary("sp-codegen")
+    tmpldir = os.path.join(srcdir, "templates")
+    runcmd(ctx, [codegen, filename, "-o", testprog, "--templates", tmpldir])
     exit_code_zero(ctx)
 
+
 def run_python_test_program(ctx, testprog=None, pattern=None):
-    runcmd(ctx, ['python3', testprog, pattern])
+    runcmd(ctx, ["python3", testprog, pattern])
     exit_code_zero(ctx)
 
+
 def run_bash_test_program(ctx, testprog=None, pattern=None):
-    runcmd(ctx, ['bash', testprog, pattern])
+    runcmd(ctx, ["bash", testprog, pattern])
     exit_code_zero(ctx)
 
+
 def run_meta(ctx, filename=None):
-    meta = binary('sp-meta')
+    meta = binary("sp-meta")
     runcmd(ctx, [meta, filename])
     exit_code_zero(ctx)
 
+
 def run_pandoc_with_filter(ctx, filename=None, output=None):
-    sp_filter = binary('sp-filter')
-    runcmd(ctx, ['pandoc', '--filter', sp_filter, filename, '-o', output])
+    sp_filter = binary("sp-filter")
+    runcmd(ctx, ["pandoc", "--filter", sp_filter, filename, "-o", output])
     exit_code_zero(ctx)
 
+
 def file_exists(ctx, filename=None):
     assert_eq(os.path.exists(filename), True)
 
+
 def file_does_not_exist(ctx, filename=None):
     assert_eq(os.path.exists(filename), False)
 
+
 def file_matches(ctx, filename=None, regex=None):
     with open(filename) as f:
         content = f.read()
     m = re.search(regex, content)
     if m is None:
-        print('content:', repr(content))
-        print('regex:', repr(regex))
+        print("content:", repr(content))
+        print("regex:", repr(regex))
     assert_eq(bool(m), True)
 
+
 def file_contains(ctx, filename=None, pattern=None):
     with open(filename) as f:
         content = f.read()
     assert_eq(pattern in content, True)
 
+
 def scenario_was_run(ctx, name=None):
-    stdout_matches(ctx, pattern='\nscenario: {}\n'.format(name))
+    stdout_matches(ctx, pattern="\nscenario: {}\n".format(name))
+
 
 def scenario_was_not_run(ctx, name=None):
-    stdout_does_not_match(ctx, pattern='\nscenario: {}\n'.format(name))
+    stdout_does_not_match(ctx, pattern="\nscenario: {}\n".format(name))
+
 
 def step_was_run(ctx, keyword=None, name=None):
-    stdout_matches(ctx, pattern='\n  step: {} {}\n'.format(keyword, name))
+    stdout_matches(ctx, pattern="\n  step: {} {}\n".format(keyword, name))
+
 
 def exit_code_zero(ctx):
-    if ctx.get('exit') != 0:
-        print('context:', ctx.as_dict())
-    assert_eq(ctx.get('exit'), 0)
+    if ctx.get("exit") != 0:
+        print("context:", ctx.as_dict())
+    assert_eq(ctx.get("exit"), 0)
+
 
 def exit_code_nonzero(ctx):
-    assert_ne(ctx.get('exit'), 0)
+    assert_ne(ctx.get("exit"), 0)
+
 
 def binary(basename):
-    return os.path.join(srcdir, 'target', 'debug', basename)
+    return os.path.join(srcdir, "target", "debug", basename)
+
 
 def stdout_matches(ctx, pattern=None):
-    stdout = ctx.get('stdout', '')
+    stdout = ctx.get("stdout", "")
     if pattern not in stdout:
-        print('pattern:', repr(pattern))
-        print('stdout:', repr(stdout))
-        print('ctx:', ctx.as_dict())
+        print("pattern:", repr(pattern))
+        print("stdout:", repr(stdout))
+        print("ctx:", ctx.as_dict())
     assert_eq(pattern in stdout, True)
 
+
 def stdout_does_not_match(ctx, pattern=None):
-    stdout = ctx.get('stdout', '')
+    stdout = ctx.get("stdout", "")
     if pattern in stdout:
-        print('pattern:', repr(pattern))
-        print('stdout:', repr(stdout))
-        print('ctx:', ctx.as_dict())
+        print("pattern:", repr(pattern))
+        print("stdout:", repr(stdout))
+        print("ctx:", ctx.as_dict())
     assert_eq(pattern not in stdout, True)
 
+
 def stderr_matches(ctx, pattern=None):
-    stderr = ctx.get('stderr', '')
+    stderr = ctx.get("stderr", "")
     if pattern not in stderr:
-        print('pattern:', repr(pattern))
-        print('stderr:', repr(stderr))
-        print('ctx:', ctx.as_dict())
+        print("pattern:", repr(pattern))
+        print("stderr:", repr(stderr))
+        print("ctx:", ctx.as_dict())
     assert_eq(pattern in stderr, True)
 
+
 def stderr_does_not_match(ctx, pattern=None):
-    stderr = ctx.get('stderr', '')
+    stderr = ctx.get("stderr", "")
     if pattern not in stderr:
-        print('pattern:', repr(pattern))
-        print('stderr:', repr(stderr))
-        print('ctx:', ctx.as_dict())
+        print("pattern:", repr(pattern))
+        print("stderr:", repr(stderr))
+        print("ctx:", ctx.as_dict())
     assert_eq(pattern not in stderr, True)
 
+
 def _get_metadata(filename):
     st = os.lstat(filename)
-    keys = [
-        'st_dev',
-        'st_gid',
-        'st_ino',
-        'st_mode',
-        'st_mtime',
-        'st_size',
-        'st_uid',
-    ]
-    return {
-        key: getattr(st, key)
-        for key in keys
-    }
+    keys = ["st_dev", "st_gid", "st_ino", "st_mode", "st_mtime", "st_size", "st_uid"]
+    return {key: getattr(st, key) for key in keys}
+
 
 def remember_metadata(ctx, filename=None):
-    ctx['remembered-metadata'] = _get_metadata(filename)
+    ctx["remembered-metadata"] = _get_metadata(filename)
+
 
 def has_same_metadata_as_remembered(ctx, filename=None):
-    assert_eq(ctx['remembered-metadata'], _get_metadata(filename))
+    assert_eq(ctx["remembered-metadata"], _get_metadata(filename))
+
 
 def has_diff_metadata_than_remembered(ctx, filename=None):
-    assert_ne(ctx['remembered-metadata'], _get_metadata(filename))
+    assert_ne(ctx["remembered-metadata"], _get_metadata(filename))
+
 
 def only_these_files_exist(ctx, filenames=None):
-    filenames = filenames.replace(',', '').split()
-    assert_eq(set(os.listdir('.')), set(filenames))
+    filenames = filenames.replace(",", "").split()
+    assert_eq(set(os.listdir(".")), set(filenames))
+
 
 def runcmd(ctx, argv):
     p = subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     stdout, stderr = p.communicate("")
-    ctx['argv'] = argv
-    ctx['stdout'] = stdout.decode('utf-8')
-    ctx['stderr'] = stderr.decode('utf-8')
-    ctx['exit'] = p.returncode
+    ctx["argv"] = argv
+    ctx["stdout"] = stdout.decode("utf-8")
+    ctx["stderr"] = stderr.decode("utf-8")
+    ctx["exit"] = p.returncode