scripts: build: apply ruff format

Apply `ruff` formatting rules to all scripts in the build folder.

Signed-off-by: Jordan Yates <jordan@embeint.com>

Author: JordanYates

.ruff-excludes.toml

@@ -1156,31 +1156,6 @@ exclude = [
     "./samples/subsys/testsuite/pytest/basic/pytest/conftest.py",
     "./samples/subsys/testsuite/pytest/basic/pytest/test_sample.py",
     "./samples/subsys/zbus/remote_mock/remote_mock.py",
-    "./scripts/build/check_init_priorities.py",
-    "./scripts/build/check_init_priorities_test.py",
-    "./scripts/build/elf_parser.py",
-    "./scripts/build/file2hex.py",
-    "./scripts/build/gen_app_partitions.py",
-    "./scripts/build/gen_cfb_font_header.py",
-    "./scripts/build/gen_device_deps.py",
-    "./scripts/build/gen_image_info.py",
-    "./scripts/build/gen_isr_tables.py",
-    "./scripts/build/gen_isr_tables_parser_carrays.py",
-    "./scripts/build/gen_isr_tables_parser_local.py",
-    "./scripts/build/gen_kobject_list.py",
-    "./scripts/build/gen_kobject_placeholders.py",
-    "./scripts/build/gen_offset_header.py",
-    "./scripts/build/gen_strerror_table.py",
-    "./scripts/build/gen_strsignal_table.py",
-    "./scripts/build/gen_symtab.py",
-    "./scripts/build/gen_syscalls.py",
-    "./scripts/build/llext_inject_slids.py",
-    "./scripts/build/llext_prepare_exptab.py",
-    "./scripts/build/mergehex.py",
-    "./scripts/build/parse_syscalls.py",
-    "./scripts/build/process_gperf.py",
-    "./scripts/build/subfolder_list.py",
-    "./scripts/build/uf2conv.py",
     "./scripts/check_maintainers.py",
     "./scripts/ci/check_compliance.py",
     "./scripts/ci/coverage/coverage_analysis.py",

scripts/build/check_init_priorities.py

@@ -29,29 +29,30 @@
 from elftools.elf.sections import SymbolTableSection
 
 # This is needed to load edt.pickle files.
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..",
-                                "dts", "python-devicetree", "src"))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "dts", "python-devicetree", "src"))
 from devicetree import edtlib  # pylint: disable=unused-import
 
 # Prefix used for "struct device" reference initialized based on devicetree
 # entries with a known ordinal.
 _DEVICE_ORD_PREFIX = "__device_dts_ord_"
 
 # Defined init level in order of priority.
-_DEVICE_INIT_LEVELS = ["EARLY", "PRE_KERNEL_1", "PRE_KERNEL_2", "POST_KERNEL",
-                      "APPLICATION", "SMP"]
+_DEVICE_INIT_LEVELS = ["EARLY", "PRE_KERNEL_1", "PRE_KERNEL_2", "POST_KERNEL", "APPLICATION", "SMP"]
 
 # List of compatibles for nodes where we don't check the priority.
-_IGNORE_COMPATIBLES = frozenset([
+_IGNORE_COMPATIBLES = frozenset(
+    [
         # There is no direct dependency between the CDC ACM UART and the USB
         # device controller, the logical connection is established after USB
         # device support is enabled.
         "zephyr,cdc-acm-uart",
-        ])
+    ]
+)
 
 # The offset of the init pointer in "struct device", in number of pointers.
 DEVICE_INIT_OFFSET = 5
 
+
 class Priority:
     """Parses and holds a device initialization priority.
 
@@ -60,6 +61,7 @@ class Priority:
     Attributes:
         name: the section name
     """
+
     def __init__(self, level, priority):
         for idx, level_name in enumerate(_DEVICE_INIT_LEVELS):
             if level_name == level:
@@ -72,8 +74,11 @@ def __init__(self, level, priority):
         raise ValueError("Unknown level in %s" % level)
 
     def __repr__(self):
-        return "<%s %s %d>" % (self.__class__.__name__,
-                               _DEVICE_INIT_LEVELS[self._level], self._priority)
+        return "<%s %s %d>" % (
+            self.__class__.__name__,
+            _DEVICE_INIT_LEVELS[self._level],
+            self._priority,
+        )
 
     def __str__(self):
         return "%s+%d" % (_DEVICE_INIT_LEVELS[self._level], self._priority)
@@ -101,6 +106,7 @@ class variables in the {"level name": ["call", ...]} format.
     Attributes:
         file_path: path of the file to be loaded.
     """
+
     def __init__(self, file_path, elf_file):
         self.file_path = file_path
         self._elf = ELFFile(elf_file)
@@ -118,11 +124,16 @@ def _load_objects(self):
                 continue
 
             for sym in section.iter_symbols():
-                if (sym.name and
-                    sym.entry.st_size > 0 and
-                    sym.entry.st_info.type in ["STT_OBJECT", "STT_FUNC"]):
+                if (
+                    sym.name
+                    and sym.entry.st_size > 0
+                    and sym.entry.st_info.type in ["STT_OBJECT", "STT_FUNC"]
+                ):
                     self._objects[sym.entry.st_value] = (
-                            sym.name, sym.entry.st_size, sym.entry.st_shndx)
+                        sym.name,
+                        sym.entry.st_size,
+                        sym.entry.st_shndx,
+                    )
                     self._object_addr[sym.name] = sym.entry.st_value
 
     def _load_level_addr(self):
@@ -214,8 +225,9 @@ def _process_initlevels(self):
                 if ordinal:
                     dev_addr = self._object_addr[arg1_name]
                     _, _, shidx = self._objects[dev_addr]
-                    arg0_name = self._object_name(self._initlevel_pointer(
-                        dev_addr, DEVICE_INIT_OFFSET, shidx))
+                    arg0_name = self._object_name(
+                        self._initlevel_pointer(dev_addr, DEVICE_INIT_OFFSET, shidx)
+                    )
 
                     prio = Priority(level, priority)
                     self.devices[ordinal] = (prio, arg0_name)
@@ -225,7 +237,8 @@ def _process_initlevels(self):
                 addr += size
                 priority += 1
 
-class Validator():
+
+class Validator:
     """Validates the initialization priorities.
 
     Scans through a build folder for object files and list all the device
@@ -237,12 +250,11 @@ class Validator():
         edt_pickle: name of the EDT pickle file
         log: a logging.Logger object
     """
+
     def __init__(self, elf_file_path, edt_pickle, log, elf_file):
         self.log = log
 
-        edt_pickle_path = pathlib.Path(
-                pathlib.Path(elf_file_path).parent,
-                edt_pickle)
+        edt_pickle_path = pathlib.Path(pathlib.Path(elf_file_path).parent, edt_pickle)
         with open(edt_pickle_path, "rb") as f:
             edt = pickle.load(f)
 
@@ -273,21 +285,25 @@ def _check_dep(self, dev_ord, dep_ord):
             return
 
         if dev_prio == dep_prio:
-            raise ValueError(f"{dev_node.path} and {dep_node.path} have the "
-                             f"same priority: {dev_prio}")
+            raise ValueError(
+                f"{dev_node.path} and {dep_node.path} have the same priority: {dev_prio}"
+            )
         elif dev_prio < dep_prio:
             if not self.errors:
-                self.log.error("Device initialization priority validation failed, "
-                               "the sequence of initialization calls does not match "
-                               "the devicetree dependencies.")
+                self.log.error(
+                    "Device initialization priority validation failed, "
+                    "the sequence of initialization calls does not match "
+                    "the devicetree dependencies."
+                )
             self.errors += 1
             self.log.error(
-                    f"{dev_node.path} <{dev_init}> is initialized before its dependency "
-                    f"{dep_node.path} <{dep_init}> ({dev_prio} < {dep_prio})")
+                f"{dev_node.path} <{dev_init}> is initialized before its dependency "
+                f"{dep_node.path} <{dep_init}> ({dev_prio} < {dep_prio})"
+            )
         else:
             self.log.info(
-                    f"{dev_node.path} <{dev_init}> {dev_prio} > "
-                    f"{dep_node.path} <{dep_init}> {dep_prio}")
+                f"{dev_node.path} <{dev_init}> {dev_prio} > {dep_node.path} <{dep_init}> {dep_prio}"
+            )
 
     def check_edt(self):
         """Scan through all known devices and validate the init priorities."""
@@ -302,30 +318,49 @@ def print_initlevels(self):
             for call in calls:
                 print(f"  {call}")
 
+
 def _parse_args(argv):
     """Parse the command line arguments."""
     parser = argparse.ArgumentParser(
         description=__doc__,
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        allow_abbrev=False)
-
-    parser.add_argument("-f", "--elf-file", default=pathlib.Path("build", "zephyr", "zephyr.elf"),
-                        help="ELF file to use")
-    parser.add_argument("-v", "--verbose", action="count",
-                        help=("enable verbose output, can be used multiple times "
-                              "to increase verbosity level"))
-    parser.add_argument("--always-succeed", action="store_true",
-                        help="always exit with a return code of 0, used for testing")
-    parser.add_argument("-o", "--output",
-                        help="write the output to a file in addition to stdout")
-    parser.add_argument("-i", "--initlevels", action="store_true",
-                        help="print the initlevel functions instead of checking the device dependencies")
-    parser.add_argument("--edt-pickle", default=pathlib.Path("edt.pickle"),
-                        help="name of the pickled edtlib.EDT file",
-                        type=pathlib.Path)
+        allow_abbrev=False,
+    )
+
+    parser.add_argument(
+        "-f",
+        "--elf-file",
+        default=pathlib.Path("build", "zephyr", "zephyr.elf"),
+        help="ELF file to use",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        help=("enable verbose output, can be used multiple times to increase verbosity level"),
+    )
+    parser.add_argument(
+        "--always-succeed",
+        action="store_true",
+        help="always exit with a return code of 0, used for testing",
+    )
+    parser.add_argument("-o", "--output", help="write the output to a file in addition to stdout")
+    parser.add_argument(
+        "-i",
+        "--initlevels",
+        action="store_true",
+        help="print the initlevel functions instead of checking the device dependencies",
+    )
+    parser.add_argument(
+        "--edt-pickle",
+        default=pathlib.Path("edt.pickle"),
+        help="name of the pickled edtlib.EDT file",
+        type=pathlib.Path,
+    )
 
     return parser.parse_args(argv)
 
+
 def _init_log(verbose, output):
     """Initialize a logger object."""
     log = logging.getLogger(__file__)
@@ -348,6 +383,7 @@ def _init_log(verbose, output):
 
     return log
 
+
 def main(argv=None):
     args = _parse_args(argv)
 
@@ -370,5 +406,6 @@ def main(argv=None):
 
     return 0
 
+
 if __name__ == "__main__":
     sys.exit(main(sys.argv[1:]))