Fix line length issues in f-string conversions

Co-authored-by: dobairoland <[email protected]>

Author: Copilot

espefuse/efuse/base_fields.py

@@ -214,9 +214,7 @@ def get_block_len(self):
         elif coding_scheme == self.parent.REGS.CODING_SCHEME_RS:
             return self.len * 4
         else:
-            raise esptool.FatalError(
-                f"Coding scheme ({coding_scheme}) not supported"
-            )
+            raise esptool.FatalError(f"Coding scheme ({coding_scheme}) not supported")
 
     def get_coding_scheme(self):
         if self.id == 0:
@@ -264,7 +262,8 @@ def print_block(self, bit_string, comment, debug=False):
         if self.parent.debug or debug:
             bit_string.pos = 0
             log.print(
-                f"{self.name:<15s} ({' '.join(self.alias)[:16]:<16s}) [{self.id:>2d}] {comment}:",
+                f"{self.name:<15s} ({' '.join(self.alias)[:16]:<16s}) "
+                f"[{self.id:>2d}] {comment}:",
                 " ".join(
                     [
                         f"{word:08x}"
@@ -284,7 +283,8 @@ def check_wr_data(self):
             return False
         if len(wr_data.bytes) != len(self.bitarray.bytes):
             raise esptool.FatalError(
-                f"Data does not fit: block{self.id} size {len(self.bitarray.bytes)} bytes, data {len(wr_data.bytes)} bytes"
+                f"Data does not fit: block{self.id} size "
+                f"{len(self.bitarray.bytes)} bytes, data {len(wr_data.bytes)} bytes"
             )
         self.check_wr_rd_protect()
 
@@ -671,9 +671,10 @@ def burn_block(block, postponed_efuses):
 
     @staticmethod
     def confirm(action, do_not_confirm):
-        newline = '\n'
+        newline = "\n"
         log.print(
-            f"{action}{'' if action.endswith(newline) else '. '}{newline}This is an irreversible operation!"
+            f"{action}{'' if action.endswith(newline) else '. '}{newline}"
+            f"This is an irreversible operation!"
         )
         if not do_not_confirm:
             log.print("Type 'BURN' (all capitals) to continue.", flush=True)

espefuse/efuse/base_operations.py

@@ -1001,7 +1001,8 @@ def read_protect_efuse(self, efuse_names: list[str]):
                                 self.efuses[block.key_purpose].get()
                             ):
                                 raise esptool.FatalError(
-                                    f"{efuse_name} must be readable, stop this operation!"
+                                    f"{efuse_name} must be readable, "
+                                    f"stop this operation!"
                                 )
                             break
                 # make full list of which efuses will be disabled
@@ -1013,7 +1014,8 @@ def read_protect_efuse(self, efuse_names: list[str]):
                 ]
                 names = ", ".join(e.name for e in all_disabling)
                 log.print(
-                    f"Permanently read-disabling eFuse{'s' if len(all_disabling) > 1 else ''} {names}"
+                    f"Permanently read-disabling eFuse"
+                    f"{'s' if len(all_disabling) > 1 else ''} {names}"
                 )
                 efuse.disable_read()
 
@@ -1054,7 +1056,8 @@ def write_protect_efuse(self, efuse_names: list[str]):
                 ]
                 names = ", ".join(e.name for e in all_disabling)
                 log.print(
-                    f"Permanently write-disabling eFuse{'s' if len(all_disabling) > 1 else ''} {names}"
+                    f"Permanently write-disabling eFuse"
+                    f"{'s' if len(all_disabling) > 1 else ''} {names}"
                 )
                 efuse.disable_write()
 
@@ -1164,7 +1167,8 @@ def burn_bit(self, block: str, bit_number: list[int]):
             )
         data_block.reverse()
         log.print(
-            f"bit_number:   [{data_block.len - 1:03d}]........................................................[0]"
+            f"bit_number:   [{data_block.len - 1:03d}]"
+            f"........................................................[0]"
         )
         log.print(f"BLOCK{block_obj.id:>2d}   :", data_block)
         block_obj.print_block(data_block, "regs_to_write", debug=True)

espefuse/efuse/esp32/fields.py

@@ -298,7 +298,9 @@ def get_and_check(raw_mac, stored_crc):
         if computed_crc == stored_crc:
             valid_msg = f"(CRC 0x{stored_crc:02x} OK)"
         else:
-            valid_msg = f"(CRC 0x{stored_crc:02x} invalid - calculated 0x{computed_crc:02x})"
+            valid_msg = (
+                f"(CRC 0x{stored_crc:02x} invalid - calculated 0x{computed_crc:02x})"
+            )
         return f"{util.hexify(raw_mac, ':')} {valid_msg}"
 
     @staticmethod

esptool/bin_image.py

@@ -265,7 +265,8 @@ def load_segment(self, f, is_irom_segment=False):
         segment_data = f.read(size)
         if len(segment_data) < size:
             raise FatalError(
-                f"End of file reading segment 0x{offset:x}, length {size} (actual {len(segment_data)})"
+                f"End of file reading segment 0x{offset:x}, length {size} "
+                f"(actual {len(segment_data)})"
             )
         segment = ImageSegment(offset, segment_data, file_offs)
         self.segments.append(segment)
@@ -297,7 +298,8 @@ def maybe_patch_segment_data(self, f, segment_data):
             ):
                 raise FatalError(
                     f"Cannot place SHA256 digest on segment boundary"
-                    f"(elf_sha256_offset={self.elf_sha256_offset}, file_pos={file_pos}, segment_size={segment_len})"
+                    f"(elf_sha256_offset={self.elf_sha256_offset}, "
+                    f"file_pos={file_pos}, segment_size={segment_len})"
                 )
             # offset relative to the data part
             patch_offset -= self.SEG_HEADER_LEN
@@ -306,7 +308,8 @@ def maybe_patch_segment_data(self, f, segment_data):
                 != b"\x00" * self.SHA256_DIGEST_LEN
             ):
                 raise FatalError(
-                    f"Contents of segment at SHA256 digest offset 0x{self.elf_sha256_offset:x} are not zero. "
+                    f"Contents of segment at SHA256 digest offset "
+                    f"0x{self.elf_sha256_offset:x} are not zero. "
                     "Refusing to overwrite."
                 )
             assert len(self.elf_sha256) == self.SHA256_DIGEST_LEN
@@ -403,7 +406,8 @@ def get_irom_segment(self):
         if len(irom_segments) > 0:
             if len(irom_segments) != 1:
                 raise FatalError(
-                    f"Found {len(irom_segments)} segments that could be irom0. Bad ELF file?"
+                    f"Found {len(irom_segments)} segments that could be irom0. "
+                    f"Bad ELF file?"
                 )
             return irom_segments[0]
         return None
@@ -441,7 +445,8 @@ def merge_adjacent_segments(self):
                     and elem_pad_addr == next_elem.addr
                 ):
                     log.note(
-                        f"Inserting {next_elem.addr - (elem.addr + len(elem.data))} bytes padding between {elem.name} and {next_elem.name}"
+                        f"Inserting {next_elem.addr - (elem.addr + len(elem.data))} "
+                        f"bytes padding between {elem.name} and {next_elem.name}"
                     )
                     elem.pad_until_addr(elem_pad_addr)
             if all(
@@ -634,7 +639,8 @@ def default_output_name(self, input_file):
             irom_offs = irom_segment.addr - ESP8266ROM.IROM_MAP_START
         else:
             irom_offs = 0
-        return f"{os.path.splitext(input_file)[0]}-0x{irom_offs & ~(ESPLoader.FLASH_SECTOR_SIZE - 1):05x}.bin"
+        sector_mask = ~(ESPLoader.FLASH_SECTOR_SIZE - 1)
+        return f"{os.path.splitext(input_file)[0]}-0x{irom_offs & sector_mask:05x}.bin"
 
     def save(self, filename: str | None) -> bytes | None:
         with io.BytesIO() as f:  # Write to memory first

esptool/loader.py

@@ -1976,7 +1976,10 @@ def __str__(self):
                     for c in line.decode("ascii", "replace")
                 )
                 s = s[16:]
-                result += f"\n    {hexify(line[:8], False):<16s} {hexify(line[8:], False):<16s} | {ascii_line}"
+                result += (
+                    f"\n    {hexify(line[:8], False):<16s} "
+                    f"{hexify(line[8:], False):<16s} | {ascii_line}"
+                )
             return result
         else:
             return hexify(self._s, False)