Reformat all python files with black

Modify the TestCodestyle test to use black instead of pycodestyle, to
avoid disagreements in formatting between the two.

Add black.sh for quickly formatting the codebase.

Signed-off-by: Øyvind Rønningstad <oyvind.ronningstad@nordicsemi.no>

__init__.py

@@ -7,8 +7,4 @@
 
 from pathlib import Path
 
-from .zcbor.zcbor import (
-    CddlValidationError,
-    DataTranslator,
-    main
-)
+from .zcbor.zcbor import CddlValidationError, DataTranslator, main

scripts/add_helptext.py

@@ -11,7 +11,7 @@
 from sys import argv
 
 p_root = Path(__file__).absolute().parents[1]
-p_README = Path(p_root, 'README.md')
+p_README = Path(p_root, "README.md")
 
 pattern = r"""
 Command line documentation
@@ -42,13 +42,13 @@
 ```
 """
 
-    with open(p_README, 'r', encoding="utf-8") as f:
+    with open(p_README, "r", encoding="utf-8") as f:
         readme_contents = f.read()
-    new_readme_contents = sub(pattern + r'.*', output, readme_contents, flags=S)
+    new_readme_contents = sub(pattern + r".*", output, readme_contents, flags=S)
     if len(argv) > 1 and argv[1] == "--check":
         if new_readme_contents != readme_contents:
             print("Check failed")
             exit(9)
     else:
-        with open(p_README, 'w', encoding="utf-8") as f:
+        with open(p_README, "w", encoding="utf-8") as f:
             f.write(new_readme_contents)

scripts/black.sh

@@ -0,0 +1 @@
+black $(dirname "$0")/.. -l 100

scripts/regenerate_samples.py

@@ -13,22 +13,24 @@
 from tempfile import mkdtemp
 
 p_root = Path(__file__).absolute().parents[1]
-p_build = p_root / 'build'
-p_pet_sample = p_root / 'samples' / 'pet'
-p_pet_cmake = p_pet_sample / 'pet.cmake'
-p_pet_include = p_pet_sample / 'include'
-p_pet_src = p_pet_sample / 'src'
+p_build = p_root / "build"
+p_pet_sample = p_root / "samples" / "pet"
+p_pet_cmake = p_pet_sample / "pet.cmake"
+p_pet_include = p_pet_sample / "include"
+p_pet_src = p_pet_sample / "src"
 
 
 def regenerate():
     tmpdir = Path(mkdtemp())
-    run(['cmake', p_pet_sample, "-DREGENERATE_ZCBOR=Y", "-DCMAKE_MESSAGE_LOG_LEVEL=WARNING"],
-        cwd=tmpdir)
+    run(
+        ["cmake", p_pet_sample, "-DREGENERATE_ZCBOR=Y", "-DCMAKE_MESSAGE_LOG_LEVEL=WARNING"],
+        cwd=tmpdir,
+    )
     rmtree(tmpdir)
 
 
 def check():
-    files = (list(p_pet_include.iterdir()) + list(p_pet_src.iterdir()) + [p_pet_cmake])
+    files = list(p_pet_include.iterdir()) + list(p_pet_src.iterdir()) + [p_pet_cmake]
     contents = "".join(p.read_text(encoding="utf-8") for p in files)
     tmpdir = Path(mkdtemp())
     list(makedirs(tmpdir / f.relative_to(p_pet_sample).parent, exist_ok=True) for f in files)

scripts/update_version.py

@@ -10,10 +10,10 @@
 from datetime import datetime
 
 p_root = Path(__file__).absolute().parents[1]
-p_VERSION = Path(p_root, 'zcbor', 'VERSION')
-p_RELEASE_NOTES = Path(p_root, 'RELEASE_NOTES.md')
-p_MIGRATION_GUIDE = Path(p_root, 'MIGRATION_GUIDE.md')
-p_common_h = Path(p_root, 'include', 'zcbor_common.h')
+p_VERSION = Path(p_root, "zcbor", "VERSION")
+p_RELEASE_NOTES = Path(p_root, "RELEASE_NOTES.md")
+p_MIGRATION_GUIDE = Path(p_root, "MIGRATION_GUIDE.md")
+p_common_h = Path(p_root, "include", "zcbor_common.h")
 
 RELEASE_NOTES_boilerplate = """
 Any new bugs, requests, or missing features should be reported as [Github issues](/~https://github.com/NordicSemiconductor/zcbor/issues).
@@ -31,23 +31,29 @@ def update_relnotes(p_relnotes, version, boilerplate="", include_date=True):
         new_date = f" ({datetime.today().strftime('%Y-%m-%d')})" if include_date else ""
         relnotes_new_header = f"# zcbor v. {version}{new_date}\n"
         if ".99" not in relnotes_lines[0]:
-            relnotes_contents = relnotes_new_header + boilerplate + '\n\n' + relnotes_contents
+            relnotes_contents = relnotes_new_header + boilerplate + "\n\n" + relnotes_contents
         relnotes_contents = sub(r".*?\n", relnotes_new_header, relnotes_contents, count=1)
         p_relnotes.write_text(relnotes_contents, encoding="utf-8")
 
 
 if __name__ == "__main__":
-    if len(argv) != 2 or match(r'\d+\.\d+\.\d+', argv[1]) is None:
+    if len(argv) != 2 or match(r"\d+\.\d+\.\d+", argv[1]) is None:
         print(f"Usage: {argv[0]} <new zcbor version>")
         exit(1)
     version = argv[1]
-    (major, minor, bugfix) = version.split('.')
+    (major, minor, bugfix) = version.split(".")
 
     p_VERSION.write_text(version, encoding="utf-8")
     update_relnotes(p_RELEASE_NOTES, version, boilerplate=RELEASE_NOTES_boilerplate)
     update_relnotes(p_MIGRATION_GUIDE, version, include_date=False)
     p_common_h_contents = p_common_h.read_text(encoding="utf-8")
-    common_h_new_contents = sub(r"(#define ZCBOR_VERSION_MAJOR )\d+", f"\\g<1>{major}", p_common_h_contents)
-    common_h_new_contents = sub(r"(#define ZCBOR_VERSION_MINOR )\d+", f"\\g<1>{minor}", common_h_new_contents)
-    common_h_new_contents = sub(r"(#define ZCBOR_VERSION_BUGFIX )\d+", f"\\g<1>{bugfix}", common_h_new_contents)
+    common_h_new_contents = sub(
+        r"(#define ZCBOR_VERSION_MAJOR )\d+", f"\\g<1>{major}", p_common_h_contents
+    )
+    common_h_new_contents = sub(
+        r"(#define ZCBOR_VERSION_MINOR )\d+", f"\\g<1>{minor}", common_h_new_contents
+    )
+    common_h_new_contents = sub(
+        r"(#define ZCBOR_VERSION_BUGFIX )\d+", f"\\g<1>{bugfix}", common_h_new_contents
+    )
     p_common_h.write_text(common_h_new_contents, encoding="utf-8")

tests/decode/test5_corner_cases/floats.py

@@ -12,28 +12,35 @@
 import math
 import cbor2
 
+
 def print_var(val1, val2, bytestr):
-	var_str = ""
-	for b in bytestr:
-		var_str += hex(b)  + ", "
-	print(str(val1) + ":", val2, bytestr.hex(), var_str)
-
-def print_32_64(str_val, val = None):
-	val = val or float(str_val)
-	print_var(str_val, val, struct.pack("!e", numpy.float16(val)))
-	print_var(str_val, val, struct.pack("!f", struct.unpack("!e", struct.pack("!e", numpy.float16(val)))[0]))
-	print (numpy.float32(struct.unpack("!e", struct.pack("!e", numpy.float16(val)))[0]))
-	print_var(str_val, val, struct.pack("!f", val))
-	print_var(str_val, val, struct.pack("!d", val))
-	print_var(str_val, val, struct.pack("!d", struct.unpack("!f", struct.pack("!f", val))[0]))
-	print()
+    var_str = ""
+    for b in bytestr:
+        var_str += hex(b) + ", "
+    print(str(val1) + ":", val2, bytestr.hex(), var_str)
+
+
+def print_32_64(str_val, val=None):
+    val = val or float(str_val)
+    print_var(str_val, val, struct.pack("!e", numpy.float16(val)))
+    print_var(
+        str_val,
+        val,
+        struct.pack("!f", struct.unpack("!e", struct.pack("!e", numpy.float16(val)))[0]),
+    )
+    print(numpy.float32(struct.unpack("!e", struct.pack("!e", numpy.float16(val)))[0]))
+    print_var(str_val, val, struct.pack("!f", val))
+    print_var(str_val, val, struct.pack("!d", val))
+    print_var(str_val, val, struct.pack("!d", struct.unpack("!f", struct.pack("!f", val))[0]))
+    print()
+
 
 print_32_64("3.1415")
 print_32_64("2.71828")
 print_32_64("1234567.89")
 print_32_64("-98765.4321")
-print_32_64("123/456789", 123/456789)
-print_32_64("-2^(-42)", -1/(2**(42)))
+print_32_64("123/456789", 123 / 456789)
+print_32_64("-2^(-42)", -1 / (2 ** (42)))
 print_32_64("1.0")
 print_32_64("-10000.0")
 print_32_64("0.0")

tests/scripts/test_repo_files.py

@@ -11,7 +11,6 @@
 from urllib.error import HTTPError
 from argparse import ArgumentParser
 from subprocess import Popen, check_output, PIPE, run
-from pycodestyle import StyleGuide
 from shutil import rmtree, copy2
 from platform import python_version_tuple
 from sys import platform
@@ -21,77 +20,63 @@
 
 
 p_root = Path(__file__).absolute().parents[2]
-p_tests = p_root / 'tests'
+p_tests = p_root / "tests"
 p_readme = p_root / "README.md"
 p_pypi_readme = p_root / "pypi_README.md"
 p_architecture = p_root / "ARCHITECTURE.md"
 p_release_notes = p_root / "RELEASE_NOTES.md"
-p_init_py = p_root / '__init__.py'
-p_zcbor_py = p_root / 'zcbor' / 'zcbor.py'
-p_add_helptext = p_root / 'scripts' / 'add_helptext.py'
-p_regenerate_samples = p_root / 'scripts' / 'regenerate_samples.py'
-p_test_zcbor_py = p_tests / 'scripts' / 'test_zcbor.py'
-p_test_versions_py = p_tests / 'scripts' / 'test_versions.py'
-p_test_repo_files_py = p_tests / 'scripts' / 'test_repo_files.py'
-p_hello_world_sample = p_root / 'samples' / 'hello_world'
-p_hello_world_build = p_hello_world_sample / 'build'
-p_pet_sample = p_root / 'samples' / 'pet'
-p_pet_cmake = p_pet_sample / 'pet.cmake'
-p_pet_include = p_pet_sample / 'include'
-p_pet_src = p_pet_sample / 'src'
-p_pet_build = p_pet_sample / 'build'
+p_add_helptext = p_root / "scripts" / "add_helptext.py"
+p_regenerate_samples = p_root / "scripts" / "regenerate_samples.py"
+p_hello_world_sample = p_root / "samples" / "hello_world"
+p_hello_world_build = p_hello_world_sample / "build"
+p_pet_sample = p_root / "samples" / "pet"
+p_pet_cmake = p_pet_sample / "pet.cmake"
+p_pet_include = p_pet_sample / "include"
+p_pet_src = p_pet_sample / "src"
+p_pet_build = p_pet_sample / "build"
 
 
 class TestCodestyle(TestCase):
-    def do_codestyle(self, files, **kwargs):
-        style = StyleGuide(max_line_length=100, **kwargs)
-        result = style.check_files([str(f) for f in files])
-        result.print_statistics()
-        self.assertEqual(result.total_errors, 0,
-                         f"Found {result.total_errors} style errors")
-
     def test_codestyle(self):
-        """Run codestyle tests on all Python scripts in the repo."""
-        self.do_codestyle([p_init_py, p_test_versions_py, p_test_repo_files_py, p_add_helptext,
-                           p_regenerate_samples])
-        self.do_codestyle([p_zcbor_py], ignore=['W191', 'E101', 'W503'])
-        self.do_codestyle([p_test_zcbor_py], ignore=['E402', 'E501', 'W503'])
+        black_res = Popen(["black", "--check", p_root, "-l", "100"], stdout=PIPE, stderr=PIPE)
+        _, stderr = black_res.communicate()
+        self.assertEqual(0, black_res.returncode, "black failed:\n" + stderr.decode("utf-8"))
 
 
 def version_int(in_str):
-    return int(search(r'\A\d+', in_str)[0])  # e.g. '0rc' -> '0'
+    return int(search(r"\A\d+", in_str)[0])  # e.g. '0rc' -> '0'
 
 
 class TestSamples(TestCase):
-    def popen_test(self, args, input='', exp_retcode=0, **kwargs):
+    def popen_test(self, args, input="", exp_retcode=0, **kwargs):
         call0 = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE, **kwargs)
         stdout0, stderr0 = call0.communicate(input)
-        self.assertEqual(exp_retcode, call0.returncode, stderr0.decode('utf-8'))
+        self.assertEqual(exp_retcode, call0.returncode, stderr0.decode("utf-8"))
         return stdout0, stderr0
 
     def cmake_build_run(self, path, build_path):
         if build_path.exists():
             rmtree(build_path)
-        with open(path / 'README.md', 'r', encoding="utf-8") as f:
+        with open(path / "README.md", "r", encoding="utf-8") as f:
             contents = f.read()
 
-        to_build_patt = r'### To build:.*?```(?P<to_build>.*?)```'
-        to_run_patt = r'### To run:.*?```(?P<to_run>.*?)```'
-        exp_out_patt = r'### Expected output:.*?(?P<exp_out>(\n>[^\n]*)+)'
-        to_build = search(to_build_patt, contents, flags=S)['to_build'].strip()
-        to_run = search(to_run_patt, contents, flags=S)['to_run'].strip()
-        exp_out = search(exp_out_patt, contents, flags=S)['exp_out'].replace("\n> ", "\n").strip()
+        to_build_patt = r"### To build:.*?```(?P<to_build>.*?)```"
+        to_run_patt = r"### To run:.*?```(?P<to_run>.*?)```"
+        exp_out_patt = r"### Expected output:.*?(?P<exp_out>(\n>[^\n]*)+)"
+        to_build = search(to_build_patt, contents, flags=S)["to_build"].strip()
+        to_run = search(to_run_patt, contents, flags=S)["to_run"].strip()
+        exp_out = search(exp_out_patt, contents, flags=S)["exp_out"].replace("\n> ", "\n").strip()
 
         os.chdir(path)
-        commands_build = [(line.split(' ')) for line in to_build.split('\n')]
-        assert '\n' not in to_run, "The 'to run' section should only have one command."
-        commands_run = to_run.split(' ')
+        commands_build = [(line.split(" ")) for line in to_build.split("\n")]
+        assert "\n" not in to_run, "The 'to run' section should only have one command."
+        commands_run = to_run.split(" ")
         for c in commands_build:
             self.popen_test(c)
         output_run = ""
         for c in commands_run:
             output, _ = self.popen_test(c)
-            output_run += output.decode('utf-8')
+            output_run += output.decode("utf-8")
         self.assertEqual(exp_out, output_run.strip())
 
     @skipIf(platform.startswith("win"), "Skip on Windows because requires a Unix shell.")
@@ -109,17 +94,16 @@ def test_pet_regenerate(self):
         self.assertEqual(0, regenerate.returncode)
 
     def test_pet_file_header(self):
-        files = (list(p_pet_include.iterdir()) + list(p_pet_src.iterdir()) + [p_pet_cmake])
+        files = list(p_pet_include.iterdir()) + list(p_pet_src.iterdir()) + [p_pet_cmake]
         for p in [f for f in files if "pet" in f.name]:
-            with p.open('r', encoding="utf-8") as f:
+            with p.open("r", encoding="utf-8") as f:
                 f.readline()  # discard
                 self.assertEqual(
                     f.readline().strip(" *#\n"),
-                    "Copyright (c) 2022 Nordic Semiconductor ASA")
+                    "Copyright (c) 2022 Nordic Semiconductor ASA",
+                )
                 f.readline()  # discard
-                self.assertEqual(
-                    f.readline().strip(" *#\n"),
-                    "SPDX-License-Identifier: Apache-2.0")
+                self.assertEqual(f.readline().strip(" *#\n"), "SPDX-License-Identifier: Apache-2.0")
                 f.readline()  # discard
                 self.assertIn("Generated using zcbor version", f.readline())
                 self.assertIn("/~https://github.com/NordicSemiconductor/zcbor", f.readline())
@@ -130,15 +114,21 @@ class TestDocs(TestCase):
     def __init__(self, *args, **kwargs):
         """Overridden to get base URL for relative links from remote tracking branch."""
         super(TestDocs, self).__init__(*args, **kwargs)
-        remote_tr_args = ['git', 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']
-        remote_tracking = run(remote_tr_args, capture_output=True).stdout.decode('utf-8').strip()
+        remote_tr_args = [
+            "git",
+            "rev-parse",
+            "--abbrev-ref",
+            "--symbolic-full-name",
+            "@{u}",
+        ]
+        remote_tracking = run(remote_tr_args, capture_output=True).stdout.decode("utf-8").strip()
 
         if remote_tracking:
-            remote, remote_branch = remote_tracking.split('/', 1)  # '1' to only split one time.
-            repo_url_args = ['git', 'remote', 'get-url', remote]
-            repo_url = check_output(repo_url_args).decode('utf-8').strip().strip('.git')
-            if 'github.com' in repo_url:
-                self.base_url = (repo_url + '/tree/' + remote_branch + '/')
+            remote, remote_branch = remote_tracking.split("/", 1)  # '1' to only split one time.
+            repo_url_args = ["git", "remote", "get-url", remote]
+            repo_url = check_output(repo_url_args).decode("utf-8").strip().strip(".git")
+            if "github.com" in repo_url:
+                self.base_url = repo_url + "/tree/" + remote_branch + "/"
             else:
                 # The URL is not in github.com, so we are not sure it is constructed correctly.
                 self.base_url = None
@@ -150,7 +140,7 @@ def __init__(self, *args, **kwargs):
             # There is no remote tracking branch.
             self.base_url = None
 
-        self.link_regex = compile(r'\[.*?\]\((?P<link>.*?)\)')
+        self.link_regex = compile(r"\[.*?\]\((?P<link>.*?)\)")
 
     def check_code(self, link, codes):
         """Check the status code of a URL link. Assert if not 200 (OK)."""
@@ -164,7 +154,7 @@ def check_code(self, link, codes):
     def do_test_links(self, path, allow_local=True):
         """Get all Markdown links in the file at <path> and check that they work."""
         if allow_local and self.base_url is None:
-            raise SkipTest('This test requires the current branch to be pushed to Github.')
+            raise SkipTest("This test requires the current branch to be pushed to Github.")
 
         text = path.read_text(encoding="utf-8")
 
@@ -211,8 +201,10 @@ def test_pet_readme(self):
     def test_pypi_readme(self):
         self.do_test_links(p_pypi_readme, allow_local=False)
 
-    @skipIf(list(map(version_int, python_version_tuple())) < [3, 10, 0],
-            "Skip on Python < 3.10 because of different wording in argparse output.")
+    @skipIf(
+        list(map(version_int, python_version_tuple())) < [3, 10, 0],
+        "Skip on Python < 3.10 because of different wording in argparse output.",
+    )
     @skipIf(platform.startswith("win"), "Skip on Windows because of path/newline issues.")
     def test_cli_doc(self):
         """Check the auto-generated CLI docs in the top level README.md file."""