scripts: Safely fix python files

Uses ruff with --fix to fix python files in this folder

Signed-off-by: Jamie McCrae <jamie.mccrae@nordicsemi.no>

Author: nordicjm

scripts/assemble.py

@@ -22,13 +22,13 @@
 
 import argparse
 import errno
-import io
-import re
 import os
 import os.path
 import pickle
+import re
 import sys
 
+
 def same_keys(a, b):
     """Determine if the dicts a and b have the same keys in them"""
     for ak in a.keys():
@@ -42,7 +42,7 @@ def same_keys(a, b):
 offset_re = re.compile(r"^#define DT_FLASH_AREA_([0-9A-Z_]+)_OFFSET(_0)?\s+(0x[0-9a-fA-F]+|[0-9]+)$")
 size_re   = re.compile(r"^#define DT_FLASH_AREA_([0-9A-Z_]+)_SIZE(_0)?\s+(0x[0-9a-fA-F]+|[0-9]+)$")
 
-class Assembly():
+class Assembly:
     def __init__(self, output, bootdir, edt):
         self.find_slots(edt)
         try:
@@ -83,7 +83,7 @@ def find_slots(self, edt):
     def add_image(self, source, partition):
         with open(self.output, 'ab') as ofd:
             pos = ofd.tell()
-            print("partition {}, pos={}, offset={}".format(partition, pos, self.offsets[partition]))
+            print(f"partition {partition}, pos={pos}, offset={self.offsets[partition]}")
             if pos > self.offsets[partition]:
                 raise Exception("Partitions not in order, unsupported")
             if pos < self.offsets[partition]:
@@ -92,16 +92,16 @@ def add_image(self, source, partition):
             with open(source, 'rb') as rfd:
                 ibuf = rfd.read()
                 if len(ibuf) > self.sizes[partition]:
-                    raise Exception("Image {} is too large for partition".format(source))
+                    raise Exception(f"Image {source} is too large for partition")
             ofd.write(ibuf)
 
 def find_board_name(bootdir):
     dot_config = os.path.join(bootdir, "zephyr", ".config")
-    with open(dot_config, "r") as f:
+    with open(dot_config) as f:
         for line in f:
             if line.startswith("CONFIG_BOARD="):
                 return line.split("=", 1)[1].strip('"')
-    raise Exception("Expected CONFIG_BOARD line in {}".format(dot_config))
+    raise Exception(f"Expected CONFIG_BOARD line in {dot_config}")
 
 def main():
     parser = argparse.ArgumentParser()

scripts/imgtool/boot_record.py

@@ -48,5 +48,5 @@ def create_sw_component_data(sw_type, sw_version, sw_measurement_description,
     # Note: The measurement value must be the last item of the property
     #       list because later it will be modified by the bootloader.
     last_key = list(properties.keys())[-1]
-    assert SwComponent.MEASUREMENT_VALUE == last_key, 'Measurement value is not the last item of the property list'
+    assert last_key == SwComponent.MEASUREMENT_VALUE, 'Measurement value is not the last item of the property list'
     return dumps(properties)

scripts/imgtool/dumpinfo.py

@@ -19,7 +19,6 @@
 """
 import os.path
 import struct
-import sys
 
 import click
 import yaml
@@ -51,7 +50,7 @@
 
 def parse_enc(key_field_len):
     if key_field_len is not None:
-        return "(len: {}, if BOOT_SWAP_SAVE_ENCTLV is unset)".format(hex(key_field_len))
+        return f"(len: {hex(key_field_len)}, if BOOT_SWAP_SAVE_ENCTLV is unset)"
     else:
         return "Image not encrypted"
 
@@ -69,7 +68,7 @@ def parse_status(status_hex):
 def parse_boot_magic(trailer_magic):
     magic = ""
     for i in range(BOOT_MAGIC_SIZE):
-        magic += "{0:#04x} ".format(trailer_magic[i])
+        magic += f"{trailer_magic[i]:#04x} "
         if i == (BOOT_MAGIC_SIZE / 2 - 1):
             magic += ("\n" + "             ")
     return magic
@@ -103,16 +102,15 @@ def print_tlv_records(tlv_list):
         tlv_type, tlv_length, tlv_data = tlv.keys()
 
         if tlv[tlv_type] in TLV_TYPES:
-            print(" " * indent, "{}: {} ({})".format(
-                tlv_type, TLV_TYPES[tlv[tlv_type]], hex(tlv[tlv_type])))
+            print(" " * indent, f"{tlv_type}: {TLV_TYPES[tlv[tlv_type]]} ({hex(tlv[tlv_type])})")
         else:
             print(" " * indent, "{}: {} ({})".format(
                 tlv_type, "UNKNOWN", hex(tlv[tlv_type])))
-        print(" " * indent, "{}: ".format(tlv_length), hex(tlv[tlv_length]))
-        print(" " * indent, "{}: ".format(tlv_data), end="")
+        print(" " * indent, f"{tlv_length}: ", hex(tlv[tlv_length]))
+        print(" " * indent, f"{tlv_data}: ", end="")
 
         for j, data in enumerate(tlv[tlv_data]):
-            print("{0:#04x}".format(data), end=" ")
+            print(f"{data:#04x}", end=" ")
             if ((j + 1) % 8 == 0) and ((j + 1) != len(tlv[tlv_data])):
                 print("\n", end=" " * (indent + 7))
         print()
@@ -133,7 +131,7 @@ def dump_imginfo(imgfile, outfile=None, silent=False):
         with open(imgfile, "rb") as f:
             b = f.read()
     except FileNotFoundError:
-        raise click.UsageError("Image file not found ({})".format(imgfile))
+        raise click.UsageError(f"Image file not found ({imgfile})")
 
     # Parsing the image header
     _header = struct.unpack('IIHHIIBBHI', b[:28])
@@ -268,8 +266,7 @@ def dump_imginfo(imgfile, outfile=None, silent=False):
                     if value & image.IMAGE_F[flag]:
                         if flag_string:
                             flag_string += ("\n" + (" " * 20))
-                        flag_string += "{} ({})".format(
-                            flag, hex(image.IMAGE_F[flag]))
+                        flag_string += f"{flag} ({hex(image.IMAGE_F[flag])})"
             value = flag_string
 
         if not isinstance(value, str):
@@ -279,23 +276,23 @@ def dump_imginfo(imgfile, outfile=None, silent=False):
 
     # Image payload
     _sectionoff = header["hdr_size"]
-    frame_header_text = "Payload (offset: {})".format(hex(_sectionoff))
+    frame_header_text = f"Payload (offset: {hex(_sectionoff)})"
     frame_content = "FW image (size: {} Bytes)".format(hex(header["img_size"]))
     print_in_frame(frame_header_text, frame_content)
 
     # TLV area
     _sectionoff += header["img_size"]
     if protected_tlv_size != 0:
         # Protected TLV area
-        section_name = "Protected TLV area (offset: {})".format(hex(_sectionoff))
+        section_name = f"Protected TLV area (offset: {hex(_sectionoff)})"
         print_in_row(section_name)
         print("magic:    ", hex(tlv_area["tlv_hdr_prot"]["magic"]))
         print("area size:", hex(tlv_area["tlv_hdr_prot"]["tlv_tot"]))
         print_tlv_records(tlv_area["tlvs_prot"])
         print("#" * _LINE_LENGTH)
 
     _sectionoff += protected_tlv_size
-    section_name = "TLV area (offset: {})".format(hex(_sectionoff))
+    section_name = f"TLV area (offset: {hex(_sectionoff)})"
     print_in_row(section_name)
     print("magic:    ", hex(tlv_area["tlv_hdr"]["magic"]))
     print("area size:", hex(tlv_area["tlv_hdr"]["tlv_tot"]))
@@ -305,8 +302,8 @@ def dump_imginfo(imgfile, outfile=None, silent=False):
     if _img_pad_size:
         _sectionoff += tlv_area["tlv_hdr"]["tlv_tot"]
         _erased_val = b[_sectionoff]
-        frame_header_text = "Image padding (offset: {})".format(hex(_sectionoff))
-        frame_content = "padding ({})".format(hex(_erased_val))
+        frame_header_text = f"Image padding (offset: {hex(_sectionoff)})"
+        frame_content = f"padding ({hex(_erased_val)})"
         print_in_frame(frame_header_text, frame_content)
 
         # Image trailer

scripts/imgtool/image.py

@@ -20,19 +20,13 @@
 Image signing and management.
 """
 
-from . import version as versmod
-from .boot_record import create_sw_component_data
-import click
 import copy
-from enum import Enum
-import array
-from intelhex import IntelHex
 import hashlib
-import array
 import os.path
 import re
 import struct
 import uuid
+from collections import namedtuple
 from enum import Enum
 
 import click
@@ -46,11 +40,10 @@
 from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
 from intelhex import IntelHex
 
-from . import version as versmod, keys
+from . import keys
+from . import version as versmod
 from .boot_record import create_sw_component_data
-from .keys import rsa, ecdsa, x25519
-
-from collections import namedtuple
+from .keys import ecdsa, rsa, x25519
 
 IMAGE_MAGIC = 0x96f3b83d
 IMAGE_HEADER_SIZE = 32
@@ -125,7 +118,7 @@ def align_up(num, align):
     return (num + (align - 1)) & ~(align - 1)
 
 
-class TLV():
+class TLV:
     def __init__(self, endian, magic=TLV_INFO_MAGIC):
         self.magic = magic
         self.buf = bytearray()
@@ -141,9 +134,8 @@ def add(self, kind, payload):
         e = STRUCT_ENDIAN_DICT[self.endian]
         if isinstance(kind, int):
             if not TLV_VENDOR_RES_MIN <= kind <= TLV_VENDOR_RES_MAX:
-                msg = "Invalid custom TLV type value '0x{:04x}', allowed " \
-                      "value should be between 0x{:04x} and 0x{:04x}".format(
-                        kind, TLV_VENDOR_RES_MIN, TLV_VENDOR_RES_MAX)
+                msg = f"Invalid custom TLV type value '0x{kind:04x}', allowed " \
+                      f"value should be between 0x{TLV_VENDOR_RES_MIN:04x} and 0x{TLV_VENDOR_RES_MAX:04x}"
                 raise click.UsageError(msg)
             buf = struct.pack(e + 'HH', kind, len(payload))
         else:
@@ -153,7 +145,7 @@ def add(self, kind, payload):
 
     def get(self):
         if len(self.buf) == 0:
-            return bytes()
+            return b""
         e = STRUCT_ENDIAN_DICT[self.endian]
         header = struct.pack(e + 'HH', self.magic, len(self))
         return header + bytes(self.buf)
@@ -177,7 +169,7 @@ def get(self):
 
 
 def is_sha_tlv(tlv):
-    return tlv in TLV_SHA_TO_SHA_AND_ALG.keys()
+    return tlv in TLV_SHA_TO_SHA_AND_ALG
 
 
 def tlv_sha_to_sha(tlv):
@@ -224,8 +216,8 @@ def key_and_user_sha_to_alg_and_tlv(key, user_sha, is_pure = False):
         allowed = allowed_key_ssh[type(key)]
 
     except KeyError:
-        raise click.UsageError("Colud not find allowed hash algorithms for {}"
-                               .format(type(key)))
+        raise click.UsageError(f"Colud not find allowed hash algorithms for {type(key)}"
+                               )
 
     # Pure enforces auto, and user selection is ignored
     if user_sha == 'auto' or is_pure:
@@ -234,8 +226,8 @@ def key_and_user_sha_to_alg_and_tlv(key, user_sha, is_pure = False):
     if user_sha in allowed:
         return USER_SHA_TO_ALG_AND_TLV[user_sha]
 
-    raise click.UsageError("Key {} can not be used with --sha {}; allowed sha are one of {}"
-                           .format(key.sig_type(), user_sha, allowed))
+    raise click.UsageError(f"Key {key.sig_type()} can not be used with --sha {user_sha}; allowed sha are one of {allowed}"
+                           )
 
 
 def get_digest(tlv_type, hash_region):
@@ -461,9 +453,8 @@ def check_trailer(self):
                                        self.save_enctlv, self.enctlv_len)
             padding = self.slot_size - (len(self.payload) + tsize)
             if padding < 0:
-                msg = "Image size (0x{:x}) + trailer (0x{:x}) exceeds " \
-                      "requested size 0x{:x}".format(
-                          len(self.payload), tsize, self.slot_size)
+                msg = f"Image size (0x{len(self.payload):x}) + trailer (0x{tsize:x}) exceeds " \
+                      f"requested size 0x{self.slot_size:x}"
                 raise click.UsageError(msg)
 
     def ecies_hkdf(self, enckey, plainkey, hmac_sha_alg):
@@ -550,9 +541,8 @@ def create(self, key, public_key_format, enckey, dependencies=None,
 
         if sw_type is not None:
             if len(sw_type) > MAX_SW_TYPE_LENGTH:
-                msg = "'{}' is too long ({} characters) for sw_type. Its " \
-                      "maximum allowed length is 12 characters.".format(
-                       sw_type, len(sw_type))
+                msg = f"'{sw_type}' is too long ({len(sw_type)} characters) for sw_type. Its " \
+                      "maximum allowed length is 12 characters."
                 raise click.UsageError(msg)
 
             image_version = (str(self.version.major) + '.'
@@ -853,8 +843,7 @@ def _trailer_size(self, write_size, max_sectors, overwrite_only, enckey,
             return self.max_align * 2 + magic_align_size
         else:
             if write_size not in set([1, 2, 4, 8, 16, 32]):
-                raise click.BadParameter("Invalid alignment: {}".format(
-                    write_size))
+                raise click.BadParameter(f"Invalid alignment: {write_size}")
             m = DEFAULT_MAX_SECTORS if max_sectors is None else max_sectors
             trailer = m * 3 * write_size  # status area
             if enckey is not None:

scripts/imgtool/keys/__init__.py

@@ -21,19 +21,17 @@
 
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric.rsa import (
-    RSAPrivateKey, RSAPublicKey)
 from cryptography.hazmat.primitives.asymmetric.ec import (
-    EllipticCurvePrivateKey, EllipticCurvePublicKey)
-from cryptography.hazmat.primitives.asymmetric.ed25519 import (
-    Ed25519PrivateKey, Ed25519PublicKey)
-from cryptography.hazmat.primitives.asymmetric.x25519 import (
-    X25519PrivateKey, X25519PublicKey)
+    EllipticCurvePrivateKey,
+    EllipticCurvePublicKey,
+)
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey
+from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey, RSAPublicKey
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
 
-from .rsa import RSA, RSAPublic, RSAUsageError, RSA_KEY_SIZES
-from .ecdsa import (ECDSA256P1, ECDSA256P1Public,
-                    ECDSA384P1, ECDSA384P1Public, ECDSAUsageError)
+from .ecdsa import ECDSA256P1, ECDSA384P1, ECDSA256P1Public, ECDSA384P1Public, ECDSAUsageError
 from .ed25519 import Ed25519, Ed25519Public, Ed25519UsageError
+from .rsa import RSA, RSA_KEY_SIZES, RSAPublic, RSAUsageError
 from .x25519 import X25519, X25519Public, X25519UsageError
 
 

scripts/imgtool/keys/ecdsa.py

@@ -4,7 +4,6 @@
 
 # SPDX-License-Identifier: Apache-2.0
 import os.path
-import hashlib
 
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import serialization
@@ -27,7 +26,7 @@ def __init__(self, key):
         self.key = key
 
     def _unsupported(self, name):
-        raise ECDSAUsageError("Operation {} requires private key".format(name))
+        raise ECDSAUsageError(f"Operation {name} requires private key")
 
     def _get_public(self):
         return self.key

scripts/imgtool/keys/ecdsa_test.py

@@ -16,7 +16,8 @@
 
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
 
-from imgtool.keys import load, ECDSA256P1, ECDSAUsageError
+from imgtool.keys import ECDSA256P1, ECDSAUsageError, load
+
 
 class EcKeyGeneration(unittest.TestCase):
 

scripts/imgtool/keys/ed25519.py

@@ -22,7 +22,7 @@ def shortname(self):
         return "ed25519"
 
     def _unsupported(self, name):
-        raise Ed25519UsageError("Operation {} requires private key".format(name))
+        raise Ed25519UsageError(f"Operation {name} requires private key")
 
     def _get_public(self):
         return self.key
@@ -87,8 +87,7 @@ def _get_public(self):
         return self.key.public_key()
 
     def get_private_bytes(self, minimal, format):
-        raise Ed25519UsageError("Operation not supported with {} keys".format(
-            self.shortname()))
+        raise Ed25519UsageError(f"Operation not supported with {self.shortname()} keys")
 
     def export_private(self, path, passwd=None):
         """

scripts/imgtool/keys/ed25519_test.py

@@ -12,11 +12,10 @@
 import unittest
 
 from cryptography.exceptions import InvalidSignature
-from cryptography.hazmat.primitives.asymmetric import ed25519
 
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
 
-from imgtool.keys import load, Ed25519, Ed25519UsageError
+from imgtool.keys import Ed25519, Ed25519UsageError, load
 
 
 class Ed25519KeyGeneration(unittest.TestCase):