esptool 5.1.dev1__tar.gz → 5.2.dev1__tar.gz

{esptool-5.1.dev1/esptool.egg-info → esptool-5.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esptool
-Version: 5.1.dev1
+Version: 5.2.dev1
 Summary: A serial utility for flashing, provisioning, and interacting with Espressif SoCs.
 Author: Fredrik Ahlberg (themadinventor), Angus Gratton (projectgus), Espressif Systems
 License: GPLv2+
@@ -31,7 +31,7 @@ Requires-Dist: pyserial>=3.3
 Requires-Dist: reedsolo<1.8,>=1.5.3
 Requires-Dist: PyYAML>=5.1
 Requires-Dist: intelhex
-Requires-Dist: rich_click
+Requires-Dist: rich_click<1.9.0
 Requires-Dist: click<9
 Provides-Extra: dev
 Requires-Dist: pyelftools; extra == "dev"
@@ -44,7 +44,7 @@ Requires-Dist: czespressif; extra == "dev"
 Provides-Extra: hsm
 Requires-Dist: python-pkcs11; extra == "hsm"
 Provides-Extra: docs
-Requires-Dist: esp-docs~=1.10; extra == "docs"
+Requires-Dist: esp-docs~=2.1; extra == "docs"
 Requires-Dist: sphinx-tabs; extra == "docs"
 Dynamic: license-file
 
@@ -53,6 +53,7 @@ Dynamic: license-file
 A Python-based, open-source, platform-independent serial utility for flashing, provisioning, and interacting with Espressif SoCs.
 
 [![Test esptool](https://github.com/espressif/esptool/actions/workflows/test_esptool.yml/badge.svg?branch=master)](https://github.com/espressif/esptool/actions/workflows/test_esptool.yml) [![Build esptool](https://github.com/espressif/esptool/actions/workflows/build_esptool.yml/badge.svg?branch=master)](https://github.com/espressif/esptool/actions/workflows/build_esptool.yml)
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/espressif/esptool/master.svg)](https://results.pre-commit.ci/latest/github/espressif/esptool/master)
 
 ## Documentation
 

{esptool-5.1.dev1 → esptool-5.2.dev1}/README.md

@@ -3,6 +3,7 @@
 A Python-based, open-source, platform-independent serial utility for flashing, provisioning, and interacting with Espressif SoCs.
 
 [![Test esptool](https://github.com/espressif/esptool/actions/workflows/test_esptool.yml/badge.svg?branch=master)](https://github.com/espressif/esptool/actions/workflows/test_esptool.yml) [![Build esptool](https://github.com/espressif/esptool/actions/workflows/build_esptool.yml/badge.svg?branch=master)](https://github.com/espressif/esptool/actions/workflows/build_esptool.yml)
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/espressif/esptool/master.svg)](https://results.pre-commit.ci/latest/github/espressif/esptool/master)
 
 ## Documentation
 

{esptool-5.1.dev1 → esptool-5.2.dev1}/esp_rfc2217_server/__init__.py

@@ -134,7 +134,7 @@ def main():
         except KeyboardInterrupt:
             print(flush=True)
             break
-        except socket.error as msg:
+        except OSError as msg:
             logging.error(str(msg))
 
     logging.info("--- exit ---")

{esptool-5.1.dev1 → esptool-5.2.dev1}/esp_rfc2217_server/esp_port_manager.py

@@ -38,7 +38,7 @@ class EspPortManager(serial.rfc2217.PortManager):
     def __init__(self, serial_port, connection, esp32r0_delay, logger=None):
         self.esp32r0_delay = esp32r0_delay
         self.is_download_mode = False
-        super(EspPortManager, self).__init__(serial_port, connection, logger)
+        super().__init__(serial_port, connection, logger)
 
     def _telnet_process_subnegotiation(self, suboption):
         if suboption[0:1] == COM_PORT_OPTION and suboption[1:2] == SET_CONTROL:
@@ -66,7 +66,7 @@ class EspPortManager(serial.rfc2217.PortManager):
             ]:
                 return
         # only in cases not handled above do the original implementation in PortManager
-        super(EspPortManager, self)._telnet_process_subnegotiation(suboption)
+        super()._telnet_process_subnegotiation(suboption)
 
     def _hard_reset_thread(self):
         """

{esptool-5.1.dev1 → esptool-5.2.dev1}/esp_rfc2217_server/redirector.py

@@ -5,12 +5,11 @@
 import threading
 import time
 import logging
-import socket
 
 from esp_rfc2217_server.esp_port_manager import EspPortManager
 
 
-class Redirector(object):
+class Redirector:
     def __init__(self, serial_instance, socket, debug=False, esp32r0delay=False):
         self.serial = serial_instance
         self.socket = socket
@@ -54,7 +53,7 @@ class Redirector(object):
                 if data:
                     # escape outgoing data when needed (Telnet IAC (0xff) character)
                     self.write(b"".join(self.rfc2217.escape(data)))
-            except socket.error as msg:
+            except OSError as msg:
                 self.log.error("{}".format(msg))
                 # probably got disconnected
                 break
@@ -74,7 +73,7 @@ class Redirector(object):
                 if not data:
                     break
                 self.serial.write(b"".join(self.rfc2217.filter(data)))
-            except socket.error as msg:
+            except OSError as msg:
                 self.log.error("{}".format(msg))
                 # probably got disconnected
                 break

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/__init__.py

@@ -93,9 +93,10 @@ __all__ = [
     "Use with caution!",
 )
 @click.option(
-    "--postpone",
-    is_flag=True,
-    help="Postpone burning some eFuses from BLOCK0 at the end.",
+    "--postpone/--no-postpone",
+    default=True,
+    help="Postpone burning some eFuses from BLOCK0 at the end "
+    "(enabled by default, can be disabled with --no-postpone).",
 )
 @click.option(
     "--extend-efuse-table",

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/cli_util.py

@@ -220,7 +220,7 @@ class Group(EsptoolGroup):
             commands = init_commands(port=None, chip=ctx.obj["chip"], skip_connect=True)
             commands.add_cli_commands(self)
         elif len(used_cmds) == 0:
-            self.get_help(ctx)
+            log.print(self.get_help(ctx))
             ctx.exit()
 
         cmd_groups = self.repeat_read_commands(used_cmds, cmd_groups)

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/base_fields.py

@@ -17,7 +17,7 @@ from esptool.logger import log
 from . import util
 
 
-class CheckArgValue(object):
+class CheckArgValue:
     def __init__(self, efuses, name):
         self.efuses = efuses
         self.name = name
@@ -85,7 +85,7 @@ class CheckArgValue(object):
         return check_arg_value(efuse, new_value)
 
 
-class EfuseProtectBase(object):
+class EfuseProtectBase:
     # This class is used by EfuseBlockBase and EfuseFieldBase
     read_disable_bit: int | list[int] | None
     write_disable_bit: int | list[int] | None
@@ -214,9 +214,7 @@ class EfuseBlockBase(EfuseProtectBase):
         elif coding_scheme == self.parent.REGS.CODING_SCHEME_RS:
             return self.len * 4
         else:
-            raise esptool.FatalError(
-                "Coding scheme (%d) not supported" % (coding_scheme)
-            )
+            raise esptool.FatalError(f"Coding scheme ({coding_scheme}) not supported")
 
     def get_coding_scheme(self):
         if self.id == 0:
@@ -255,7 +253,7 @@ class EfuseBlockBase(EfuseProtectBase):
         words = self.get_words()
         data = BitArray()
         for word in reversed(words):
-            data.append("uint:32=%d" % word)
+            data.append(f"uint:32={word}")
         self.bitarray.overwrite(data, pos=0)
         if print_info:
             self.print_block(self.bitarray, "read_regs")
@@ -264,13 +262,13 @@ class EfuseBlockBase(EfuseProtectBase):
         if self.parent.debug or debug:
             bit_string.pos = 0
             log.print(
-                "%-15s (%-16s) [%-2d] %s:"
-                % (self.name, " ".join(self.alias)[:16], self.id, comment),
+                f"{self.name:<15s} ({' '.join(self.alias)[:16]:<16s}) "
+                f"[{self.id:<2d}] {comment}:",
                 " ".join(
                     [
-                        "%08x" % word
+                        f"{word:08x}"
                         for word in bit_string.readlist(
-                            "%d*uint:32" % (bit_string.len / 32)
+                            f"{int(bit_string.len / 32)}*uint:32"
                         )[::-1]
                     ]
                 ),
@@ -285,8 +283,8 @@ class EfuseBlockBase(EfuseProtectBase):
             return False
         if len(wr_data.bytes) != len(self.bitarray.bytes):
             raise esptool.FatalError(
-                "Data does not fit: the block%d size is %d bytes, data is %d bytes"
-                % (self.id, len(self.bitarray.bytes), len(wr_data.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()
 
@@ -468,7 +466,7 @@ class EfuseBlockBase(EfuseProtectBase):
         self.wr_bitarray.set(0)
 
 
-class EspEfusesBase(object):
+class EspEfusesBase:
     """
     Wrapper object to manage the efuse fields in a connected ESP bootloader
     """
@@ -538,8 +536,14 @@ class EspEfusesBase(object):
         log.print("Re-connecting...")
         baudrate = esp._port.baudrate
         port = esp._port.port
+        connect_mode = (
+            "usb-reset"
+            if esp._get_pid() == esp.USB_JTAG_SERIAL_PID
+            else "default-reset"
+        )
+        log.print(f"Port: {port}, Baudrate: {baudrate}, Connect mode: {connect_mode}")
         esp._port.close()
-        return esptool.detect_chip(port, baudrate)
+        return esptool.detect_chip(port, baudrate, connect_mode)
 
     def get_index_block_by_name(self, name):
         for block in self.blocks:
@@ -674,8 +678,9 @@ class EspEfusesBase(object):
     @staticmethod
     def confirm(action, do_not_confirm):
         log.print(
-            "%s%s\nThis is an irreversible operation!"
-            % (action, "" if action.endswith("\n") else ". ")
+            "{}{}\nThis is an irreversible operation!".format(
+                action, "" if action.endswith("\n") else ". "
+            )
         )
         if not do_not_confirm:
             log.print("Type 'BURN' (all capitals) to continue.", flush=True)

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/base_operations.py

@@ -9,7 +9,8 @@ import io
 import os
 import json
 import sys
-from typing import Any, BinaryIO, Callable, TextIO
+from typing import Any, BinaryIO, TextIO
+from collections.abc import Callable
 
 import espsecure
 import rich_click as click
@@ -850,9 +851,9 @@ class BaseCommands:
         for block in self.efuses.blocks:
             burn_list_a_block = [e for e in burn_efuses_list if e.block == block.id]
             if len(burn_list_a_block):
-                log.print("  from BLOCK%d" % (block.id))
+                log.print(f"  from BLOCK{block.id}")
                 for field in burn_list_a_block:
-                    log.print("     - %s" % (field.name))
+                    log.print(f"     - {field.name}")
                     if (
                         self.efuses.blocks[field.block].get_coding_scheme()
                         != self.efuses.REGS.CODING_SCHEME_NONE
@@ -990,7 +991,7 @@ class BaseCommands:
                     ]
                     if error:
                         raise esptool.FatalError(
-                            "%s must be readable, stop this operation!" % efuse_name
+                            f"{efuse_name} must be readable, stop this operation!"
                         )
                 else:
                     for block in self.efuses.Blocks.BLOCKS:
@@ -1000,8 +1001,8 @@ class BaseCommands:
                                 self.efuses[block.key_purpose].get()
                             ):
                                 raise esptool.FatalError(
-                                    "%s must be readable, stop this operation!"
-                                    % efuse_name
+                                    f"{efuse_name} must be readable, "
+                                    f"stop this operation!"
                                 )
                             break
                 # make full list of which efuses will be disabled
@@ -1013,8 +1014,8 @@ class BaseCommands:
                 ]
                 names = ", ".join(e.name for e in all_disabling)
                 log.print(
-                    "Permanently read-disabling eFuse%s %s"
-                    % ("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()
 
@@ -1055,8 +1056,8 @@ class BaseCommands:
                 ]
                 names = ", ".join(e.name for e in all_disabling)
                 log.print(
-                    "Permanently write-disabling eFuse%s %s"
-                    % ("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()
 
@@ -1166,11 +1167,10 @@ class BaseCommands:
             )
         data_block.reverse()
         log.print(
-            "bit_number:   "
-            "[%-03d]........................................................[0]"
-            % (data_block.len - 1)
+            f"bit_number:   [{data_block.len - 1:03d}]"
+            f"........................................................[0]"
         )
-        log.print("BLOCK%-2d   :" % block_obj.id, data_block)
+        log.print(f"BLOCK{block_obj.id:>2d}   :", data_block)
         block_obj.print_block(data_block, "regs_to_write", debug=True)
         block_obj.save(data_block.bytes[::-1])
 

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/csv_table_parser.py

@@ -180,7 +180,7 @@ class CSVFuseTable(list):
                         print_error(p, n, state)
 
 
-class FuseDefinition(object):
+class FuseDefinition:
     def __init__(self):
         self.field_name = ""
         self.group = ""
@@ -261,11 +261,9 @@ class FuseDefinition(object):
 
 class InputError(RuntimeError):
     def __init__(self, e):
-        super(InputError, self).__init__(e)
+        super().__init__(e)
 
 
 class ValidationError(InputError):
     def __init__(self, p, message):
-        super(ValidationError, self).__init__(
-            f"Entry {p.field_name} invalid: {message}"
-        )
+        super().__init__(f"Entry {p.field_name} invalid: {message}")

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/emulate_efuse_controller_base.py

@@ -10,7 +10,7 @@ from bitstring import BitStream
 from esptool.logger import log
 
 
-class EmulateEfuseControllerBase(object):
+class EmulateEfuseControllerBase:
     """The class for virtual efuse operations. Using for HOST_TEST."""
 
     CHIP_NAME = ""
@@ -19,6 +19,7 @@ class EmulateEfuseControllerBase(object):
     Blocks = None
     Fields = None
     REGS = None
+    USB_JTAG_SERIAL_PID = 0x1001
 
     def __init__(self, efuse_file=None, debug=False):
         self.debug = debug
@@ -76,6 +77,9 @@ class EmulateEfuseControllerBase(object):
         blk = self.Blocks.get(self.Blocks.BLOCKS[block])
         self.write_reg(blk.wr_addr + (4 * n), value)
 
+    def _get_pid(self):
+        return -1
+
     """ << esptool method end """
 
     def handle_writing_event(self, addr, value):

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32/emulate_efuse_controller.py

@@ -22,7 +22,7 @@ class EmulateEfuseController(EmulateEfuseControllerBase):
         self.Blocks = EfuseDefineBlocks
         self.Fields = EfuseDefineFields(None)
         self.REGS = EfuseDefineRegisters
-        super(EmulateEfuseController, self).__init__(efuse_file, debug)
+        super().__init__(efuse_file, debug)
 
     """ esptool method start >> """
 
@@ -39,7 +39,7 @@ class EmulateEfuseController(EmulateEfuseControllerBase):
         if addr == self.REGS.APB_CTL_DATE_ADDR:
             return self.REGS.APB_CTL_DATE_V << self.REGS.APB_CTL_DATE_S
         else:
-            return super(EmulateEfuseController, self).read_reg(addr)
+            return super().read_reg(addr)
 
     """ << esptool method end """
 

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32/fields.py

@@ -27,7 +27,7 @@ class EfuseBlock(base_fields.EfuseBlockBase):
         else:
             if parent.coding_scheme is None:
                 parent.read_coding_scheme()
-        super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
+        super().__init__(parent, param, skip_read=skip_read)
 
     def apply_coding_scheme(self):
         data = self.get_raw(from_read=False)[::-1]
@@ -82,8 +82,7 @@ class EspEfuses(base_fields.EspEfusesBase):
         self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
         if esp.CHIP_NAME != "ESP32":
             raise esptool.FatalError(
-                "Expected the 'esp' param for ESP32 chip but got for '%s'."
-                % (esp.CHIP_NAME)
+                f"Expected the 'esp' param for ESP32 chip but got for '{esp.CHIP_NAME}'."
             )
         self.blocks = [
             EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect)
@@ -115,7 +114,7 @@ class EspEfuses(base_fields.EspEfusesBase):
                 ]
             else:
                 raise esptool.FatalError(
-                    "The coding scheme (%d) - is not supported" % self.coding_scheme
+                    f"The coding scheme ({self.coding_scheme}) - is not supported"
                 )
             if self["MAC_VERSION"].get() == 1:
                 self.efuses += [
@@ -297,13 +296,12 @@ class EfuseMacField(EfuseField):
     def get_and_check(raw_mac, stored_crc):
         computed_crc = EfuseMacField.calc_crc(raw_mac)
         if computed_crc == stored_crc:
-            valid_msg = "(CRC 0x%02x OK)" % stored_crc
+            valid_msg = f"(CRC {stored_crc:#04x} OK)"
         else:
-            valid_msg = "(CRC 0x%02x invalid - calculated 0x%02x)" % (
-                stored_crc,
-                computed_crc,
+            valid_msg = (
+                f"(CRC {stored_crc:#04x} invalid - calculated {computed_crc:#04x})"
             )
-        return "%s %s" % (util.hexify(raw_mac, ":"), valid_msg)
+        return " ".join([util.hexify(raw_mac, ":"), valid_msg])
 
     @staticmethod
     def calc_crc(raw_mac):
@@ -356,7 +354,7 @@ class EfuseMacField(EfuseField):
 
             bitarray_mac = self.convert_to_bitstring(new_value)
             print_field(self, bitarray_mac)
-            super(EfuseMacField, self).save(new_value)
+            super().save(new_value)
 
             crc_val = self.calc_crc(new_value)
             crc_field = self.parent["CUSTOM_MAC_CRC"]
@@ -389,7 +387,7 @@ class EfuseWafer(EfuseField):
         return revision
 
     def save(self, new_value):
-        raise esptool.FatalError("Burning %s is not supported" % self.name)
+        raise esptool.FatalError(f"Burning {self.name} is not supported")
 
 
 class EfusePkg(EfuseField):

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32/mem_definition.py

@@ -107,7 +107,7 @@ class EfuseDefineFields(EfuseFieldsBase):
         file_name = file_name + ".yaml"
         dir_name, _ = os.path.split(dir_name)
         efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
-        with open(f"{efuse_file}", "r") as r_file:
+        with open(f"{efuse_file}") as r_file:
             e_desc = yaml.safe_load(r_file)
         super().__init__(e_desc, extend_efuse_table)
 

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32/operations.py

@@ -295,8 +295,9 @@ class ESP32Commands(BaseCommands):
         if chip_revision < 300:
             raise esptool.FatalError(
                 "Incorrect chip revision for Secure boot v2. "
-                "Detected: v%d.%d. Expected: >= v3.0"
-                % (chip_revision / 100, chip_revision % 100)
+                "Detected: v{}.{}. Expected: >= v3.0".format(
+                    chip_revision // 100, chip_revision % 100
+                )
             )
 
         digest = espsecure._digest_sbv2_public_key(keyfile)

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32c2/emulate_efuse_controller.py

@@ -23,7 +23,7 @@ class EmulateEfuseController(EmulateEfuseControllerBase):
         self.Blocks = EfuseDefineBlocks
         self.Fields = EfuseDefineFields(None)
         self.REGS = EfuseDefineRegisters
-        super(EmulateEfuseController, self).__init__(efuse_file, debug)
+        super().__init__(efuse_file, debug)
         self.write_reg(self.REGS.EFUSE_CMD_REG, 0)
 
     """ esptool method start >>"""

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32c2/fields.py

@@ -29,7 +29,7 @@ class EfuseBlock(base_fields.EfuseBlockBase):
 
     def __init__(self, parent, param, skip_read=False):
         parent.read_coding_scheme()
-        super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
+        super().__init__(parent, param, skip_read=skip_read)
 
     def apply_coding_scheme(self):
         data = self.get_raw(from_read=False)[::-1]
@@ -72,8 +72,7 @@ class EspEfuses(base_fields.EspEfusesBase):
         self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
         if esp.CHIP_NAME != "ESP32-C2":
             raise esptool.FatalError(
-                "Expected the 'esp' param for ESP32-C2 chip but got for '%s'."
-                % (esp.CHIP_NAME)
+                f"Expected the 'esp' param for ESP32-C2 chip but got for '{esp.CHIP_NAME}'."
             )
         if not skip_connect:
             flags = self._esp.get_security_info()["flags"]
@@ -225,7 +224,7 @@ class EspEfuses(base_fields.EspEfusesBase):
         xtal_freq = self.get_crystal_freq()
         if xtal_freq not in [26, 40]:
             raise esptool.FatalError(
-                "The eFuse supports only xtal=26M and 40M (xtal was %d)" % xtal_freq
+                f"The eFuse supports only xtal=26M and 40M (xtal was {xtal_freq})"
             )
 
         self.update_reg(self.REGS.EFUSE_DAC_CONF_REG, self.REGS.EFUSE_DAC_NUM_M, 0xFF)
@@ -259,7 +258,7 @@ class EspEfuses(base_fields.EspEfusesBase):
                 ]
                 block.err_bitarray.pos = 0
                 for word in reversed(words):
-                    block.err_bitarray.overwrite(BitArray("uint:32=%d" % word))
+                    block.err_bitarray.overwrite(BitArray(f"uint:32={word}"))
                 block.num_errors = block.err_bitarray.count(True)
                 block.fail = block.num_errors != 0
             else:
@@ -352,7 +351,7 @@ class EfuseMacField(EfuseField):
             mac = self.get_raw(from_read)[::-1]
         else:
             mac = self.get_raw(from_read)
-        return f"{util.hexify(mac, ':')} {self.check()}"
+        return " ".join([util.hexify(mac, ":"), self.check()])
 
     def save(self, new_value):
         def print_field(e, new_value):
@@ -363,7 +362,7 @@ class EfuseMacField(EfuseField):
         if self.name == "CUSTOM_MAC":
             bitarray_mac = self.convert_to_bitstring(new_value)
             print_field(self, bitarray_mac)
-            super(EfuseMacField, self).save(new_value)
+            super().save(new_value)
         else:
             raise esptool.FatalError("Writing Factory MAC address is not supported.")
 

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32c2/mem_definition.py

@@ -105,7 +105,7 @@ class EfuseDefineFields(EfuseFieldsBase):
         file_name = file_name + ".yaml"
         dir_name, _ = os.path.split(dir_name)
         efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
-        with open(f"{efuse_file}", "r") as r_file:
+        with open(f"{efuse_file}") as r_file:
             e_desc = yaml.safe_load(r_file)
         super().__init__(e_desc, extend_efuse_table)
 

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32c2/operations.py

@@ -152,9 +152,10 @@ class ESP32C2Commands(BaseCommands):
             keypurpose_list
         ):
             raise esptool.FatalError(
-                "The number of blocks (%d), datafile (%d) and "
-                "keypurpose (%d) should be the same."
-                % (len(block_name_list), len(datafile_list), len(keypurpose_list))
+                "The number of blocks ({}), datafile ({}) and "
+                "keypurpose ({}) should be the same.".format(
+                    len(block_name_list), len(datafile_list), len(keypurpose_list)
+                )
             )
 
         assert 1 <= len(block_name_list) <= 2, "Unexpected case"
@@ -277,9 +278,10 @@ class ESP32C2Commands(BaseCommands):
         num_bytes = self.efuses["BLOCK_KEY0_HI_128"].bit_len // 8
         if len(digest) != num_bytes:
             raise esptool.FatalError(
-                "Incorrect digest size %d. "
-                "Digest must be %d bytes (%d bits) of raw binary key data."
-                % (len(digest), num_bytes, num_bytes * 8)
+                "Incorrect digest size {}. "
+                "Digest must be {} bytes ({} bits) of raw binary key data.".format(
+                    len(digest), num_bytes, num_bytes * 8
+                )
             )
         self.burn_key(
             ["BLOCK_KEY0"],

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32c3/emulate_efuse_controller.py

@@ -21,7 +21,7 @@ class EmulateEfuseController(EmulateEfuseControllerBase):
         self.Blocks = EfuseDefineBlocks
         self.Fields = EfuseDefineFields(None)
         self.REGS = EfuseDefineRegisters
-        super(EmulateEfuseController, self).__init__(efuse_file, debug)
+        super().__init__(efuse_file, debug)
         self.write_reg(self.REGS.EFUSE_CMD_REG, 0)
 
     """ esptool method start >>"""

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32c3/fields.py

@@ -29,7 +29,7 @@ class EfuseBlock(base_fields.EfuseBlockBase):
 
     def __init__(self, parent, param, skip_read=False):
         parent.read_coding_scheme()
-        super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
+        super().__init__(parent, param, skip_read=skip_read)
 
     def apply_coding_scheme(self):
         data = self.get_raw(from_read=False)[::-1]
@@ -72,8 +72,7 @@ class EspEfuses(base_fields.EspEfusesBase):
         self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
         if esp.CHIP_NAME != "ESP32-C3":
             raise esptool.FatalError(
-                "Expected the 'esp' param for ESP32-C3 chip but got for '%s'."
-                % (esp.CHIP_NAME)
+                f"Expected the 'esp' param for ESP32-C3 chip but got for '{esp.CHIP_NAME}'."
             )
         if not skip_connect:
             flags = self._esp.get_security_info()["flags"]
@@ -368,7 +367,7 @@ class EfuseMacField(EfuseField):
             mac = self.get_raw(from_read)[::-1]
         else:
             mac = self.get_raw(from_read)
-        return "%s %s" % (util.hexify(mac, ":"), self.check())
+        return " ".join([util.hexify(mac, ":"), self.check()])
 
     def save(self, new_value):
         def print_field(e, new_value):
@@ -379,7 +378,7 @@ class EfuseMacField(EfuseField):
         if self.name == "CUSTOM_MAC":
             bitarray_mac = self.convert_to_bitstring(new_value)
             print_field(self, bitarray_mac)
-            super(EfuseMacField, self).save(new_value)
+            super().save(new_value)
         else:
             # Writing the BLOCK1 (MAC_SPI_8M_0) default MAC is not possible,
             # as it's written in the factory.
@@ -446,4 +445,4 @@ class EfuseKeyPurposeField(EfuseField):
         if self.name == "KEY_PURPOSE_5" and str_new_value.startswith("XTS_AES"):
             # see SOC_EFUSE_BLOCK9_KEY_PURPOSE_QUIRK in esp-idf
             raise esptool.FatalError(f"{self.name} can not have {str_new_value} key due to a hardware bug (please see TRM for more details)")
-        return super(EfuseKeyPurposeField, self).save(raw_val)
+        return super().save(raw_val)

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32c3/mem_definition.py

@@ -139,7 +139,7 @@ class EfuseDefineFields(EfuseFieldsBase):
         file_name = file_name + ".yaml"
         dir_name, _ = os.path.split(dir_name)
         efuse_file = os.path.join(dir_name, "efuse_defs", file_name)
-        with open(f"{efuse_file}", "r") as r_file:
+        with open(f"{efuse_file}") as r_file:
             e_desc = yaml.safe_load(r_file)
         super().__init__(e_desc, extend_efuse_table)
 

{esptool-5.1.dev1 → esptool-5.2.dev1}/espefuse/efuse/esp32c3/operations.py

@@ -293,8 +293,10 @@ class ESP32C3Commands(BaseCommands):
             digest = espsecure._digest_sbv2_public_key(datafile)
             if len(digest) != num_bytes:
                 raise esptool.FatalError(
-                    "Incorrect digest size %d. Digest must be %d bytes (%d bits) "
-                    "of raw binary key data." % (len(digest), num_bytes, num_bytes * 8)
+                    "Incorrect digest size {}. Digest must be {} bytes ({} bits) "
+                    "of raw binary key data.".format(
+                        len(digest), num_bytes, num_bytes * 8
+                    )
                 )
             digest_list.append(digest)