esptool 4.9.dev5__tar.gz → 5.0.dev0__tar.gz

{esptool-4.9.dev5/esptool.egg-info → esptool-5.0.dev0}/PKG-INFO

@@ -1,7 +1,7 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: esptool
-Version: 4.9.dev5
-Summary: A serial utility to communicate & flash code to Espressif chips.
+Version: 5.0.dev0
+Summary: A serial utility for flashing, provisioning, and interacting with Espressif SoCs.
 Author: Fredrik Ahlberg (themadinventor), Angus Gratton (projectgus), Espressif Systems
 License: GPLv2+
 Project-URL: Homepage, https://github.com/espressif/esptool/
@@ -18,14 +18,11 @@ Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Topic :: Software Development :: Embedded Systems
 Classifier: Environment :: Console
 Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: bitstring!=4.2.0,>=3.1.6
@@ -35,7 +32,7 @@ Requires-Dist: pyserial>=3.3
 Requires-Dist: reedsolo<1.8,>=1.5.3
 Requires-Dist: PyYAML>=5.1
 Requires-Dist: intelhex
-Requires-Dist: argcomplete>=3; sys_platform != "win32"
+Requires-Dist: rich_click
 Provides-Extra: dev
 Requires-Dist: pyelftools; extra == "dev"
 Requires-Dist: coverage~=6.0; extra == "dev"
@@ -46,10 +43,14 @@ Requires-Dist: requests; extra == "dev"
 Requires-Dist: commitizen; extra == "dev"
 Provides-Extra: hsm
 Requires-Dist: python-pkcs11; extra == "hsm"
+Provides-Extra: docs
+Requires-Dist: esp-docs~=1.10; extra == "docs"
+Requires-Dist: sphinx-tabs; extra == "docs"
+Dynamic: license-file
 
 # esptool.py
 
-A Python-based, open-source, platform-independent utility to communicate with the ROM bootloader in Espressif chips.
+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)
 

{esptool-4.9.dev5 → esptool-5.0.dev0}/README.md

@@ -1,6 +1,6 @@
 # esptool.py
 
-A Python-based, open-source, platform-independent utility to communicate with the ROM bootloader in Espressif chips.
+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)
 

{esptool-4.9.dev5 → esptool-5.0.dev0}/esp_rfc2217_server/__init__.py

@@ -92,7 +92,10 @@ def main():
     logging.info(f"TCP/IP port: {args.localport}")
 
     host_ip = socket.gethostbyname(socket.gethostname())
-    wait_msg = f"Waiting for connection ... use the 'rfc2217://{host_ip}:{args.localport}?ign_set_control' as a PORT"
+    wait_msg = (
+        "Waiting for connection ... use the 'rfc2217://"
+        f"{host_ip}:{args.localport}?ign_set_control' as a PORT"
+    )
     logging.info(wait_msg)
 
     while True:
@@ -127,7 +130,7 @@ def main():
                 # capable client)
                 ser.apply_settings(settings)
         except KeyboardInterrupt:
-            sys.stdout.write("\n")
+            print(flush=True)
             break
         except socket.error as msg:
             logging.error(str(msg))

{esptool-4.9.dev5 → esptool-5.0.dev0}/esp_rfc2217_server.py

@@ -26,7 +26,7 @@
 # Esptool can connect to the ESP device through that server as it is
 # demonstrated in the following example:
 #
-#   esptool.py --port rfc2217://localhost:4000?ign_set_control flash_id
+#   esptool.py --port rfc2217://localhost:4000?ign_set_control flash-id
 #
 
 import contextlib

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/__init__.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2016-2025 Espressif Systems (Shanghai) CO LTD
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 # PYTHON_ARGCOMPLETE_OK
@@ -13,18 +13,18 @@ import espefuse.efuse.esp32 as esp32_efuse
 import espefuse.efuse.esp32c2 as esp32c2_efuse
 import espefuse.efuse.esp32c3 as esp32c3_efuse
 import espefuse.efuse.esp32c5 as esp32c5_efuse
-import espefuse.efuse.esp32c5beta3 as esp32c5beta3_efuse
 import espefuse.efuse.esp32c6 as esp32c6_efuse
 import espefuse.efuse.esp32c61 as esp32c61_efuse
 import espefuse.efuse.esp32h2 as esp32h2_efuse
 import espefuse.efuse.esp32h21 as esp32h21_efuse
-import espefuse.efuse.esp32h2beta1 as esp32h2beta1_efuse
+import espefuse.efuse.esp32h4 as esp32h4_efuse
 import espefuse.efuse.esp32p4 as esp32p4_efuse
 import espefuse.efuse.esp32s2 as esp32s2_efuse
 import espefuse.efuse.esp32s3 as esp32s3_efuse
-import espefuse.efuse.esp32s3beta2 as esp32s3beta2_efuse
 
 import esptool
+import esptool.cli_util
+from esptool.logger import log
 
 DefChip = namedtuple("DefChip", ["chip_name", "efuse_lib", "chip_class"])
 
@@ -58,20 +58,12 @@ SUPPORTED_CHIPS = {
     "esp32c6": DefChip("ESP32-C6", esp32c6_efuse, esptool.targets.ESP32C6ROM),
     "esp32c61": DefChip("ESP32-C61", esp32c61_efuse, esptool.targets.ESP32C61ROM),
     "esp32c5": DefChip("ESP32-C5", esp32c5_efuse, esptool.targets.ESP32C5ROM),
-    "esp32c5beta3": DefChip(
-        "ESP32-C5(beta3)", esp32c5beta3_efuse, esptool.targets.ESP32C5BETA3ROM
-    ),
     "esp32h2": DefChip("ESP32-H2", esp32h2_efuse, esptool.targets.ESP32H2ROM),
     "esp32h21": DefChip("ESP32-H21", esp32h21_efuse, esptool.targets.ESP32H21ROM),
+    "esp32h4": DefChip("ESP32-H4", esp32h4_efuse, esptool.targets.ESP32H4ROM),
     "esp32p4": DefChip("ESP32-P4", esp32p4_efuse, esptool.targets.ESP32P4ROM),
-    "esp32h2beta1": DefChip(
-        "ESP32-H2(beta1)", esp32h2beta1_efuse, esptool.targets.ESP32H2BETA1ROM
-    ),
     "esp32s2": DefChip("ESP32-S2", esp32s2_efuse, esptool.targets.ESP32S2ROM),
     "esp32s3": DefChip("ESP32-S3", esp32s3_efuse, esptool.targets.ESP32S3ROM),
-    "esp32s3beta2": DefChip(
-        "ESP32-S3(beta2)", esp32s3beta2_efuse, esptool.targets.ESP32S3BETA2ROM
-    ),
 }
 
 
@@ -191,7 +183,7 @@ def main(custom_commandline=None, esp=None):
         "--baud",
         "-b",
         help="Serial port baud rate used when flashing/reading",
-        type=esptool.arg_auto_int,
+        type=esptool.cli_util.arg_auto_int,
         default=os.environ.get("ESPTOOL_BAUD", esptool.loader.ESPLoader.ESP_ROM_BAUD),
     )
 
@@ -205,8 +197,8 @@ def main(custom_commandline=None, esp=None):
     init_parser.add_argument(
         "--before",
         help="What to do before connecting to the chip",
-        choices=["default_reset", "usb_reset", "no_reset", "no_reset_no_sync"],
-        default="default_reset",
+        choices=["default-reset", "usb-reset", "no-reset", "no-reset-no-sync"],
+        default="default-reset",
     )
 
     init_parser.add_argument(
@@ -315,9 +307,9 @@ def main(custom_commandline=None, esp=None):
             if args.operation is None:
                 parser.print_help()
                 parser.exit(1)
-            assert (
-                len(unused_args) == 0
-            ), 'Not all commands were recognized "{}"'.format(unused_args)
+            assert len(unused_args) == 0, (
+                'Not all commands were recognized "{}"'.format(unused_args)
+            )
 
             operation_func = vars(efuse_operations)[args.operation]
             # each 'operation' is a module-level function of the same name
@@ -361,7 +353,10 @@ def _main():
     try:
         main()
     except esptool.FatalError as e:
-        print("\nA fatal error occurred: %s" % e)
+        log.error(f"\nA fatal error occurred: {e}")
+        sys.exit(2)
+    except KeyboardInterrupt:
+        log.error("KeyboardInterrupt: Run cancelled by user.")
         sys.exit(2)
 
 

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/base_fields.py

@@ -12,7 +12,6 @@ from bitstring import BitArray, BitStream, CreationError
 import esptool
 
 from . import util
-from typing import List
 
 
 class CheckArgValue(object):
@@ -392,12 +391,14 @@ class EfuseBlockBase(EfuseProtectBase):
                     # if the required bits are not set then we need to re-burn it again.
                     if burns < 2:
                         print(
-                            f"\nRepeat burning BLOCK{self.id} (#{burns + 2}) because not all bits were set"
+                            f"\nRepeat burning BLOCK{self.id} (#{burns + 2}) "
+                            "because not all bits were set"
                         )
                         continue
                     else:
                         print(
-                            f"\nAfter {burns + 1} attempts, the required data was not set to BLOCK{self.id}"
+                            f"\nAfter {burns + 1} attempts, the required data was not "
+                            f"set to BLOCK{self.id}"
                         )
                 break
 
@@ -455,8 +456,8 @@ class EspEfusesBase(object):
     """
 
     _esp = None
-    blocks: List[EfuseBlockBase] = []
-    efuses: List = []
+    blocks: list[EfuseBlockBase] = []
+    efuses: list = []
     coding_scheme = None
     force_write_always = None
     batch_mode_cnt = 0
@@ -628,9 +629,9 @@ class EspEfusesBase(object):
             % (action, "" if action.endswith("\n") else ". ")
         )
         if not do_not_confirm:
-            print("Type 'BURN' (all capitals) to continue.")
-            # required for Pythons which disable line buffering, ie mingw in mintty
-            sys.stdout.flush()
+            print("Type 'BURN' (all capitals) to continue.", flush=True)
+            # Flush required for Pythons which disable line buffering,
+            # ie mingw in mintty
             yes = input()
             if yes != "BURN":
                 print("Aborting.")
@@ -650,7 +651,8 @@ class EspEfusesBase(object):
         return self.blocks[block_num].num_errors, self.blocks[block_num].fail
 
     def is_efuses_incompatible_for_burn(self):
-        # Overwrite this function for a specific target if you want to check if a certain eFuse(s) can be burned.
+        # Overwrite this function for a specific target if you want to check if a
+        # certain eFuse(s) can be burned.
         return False
 
     def get_major_chip_version(self):

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/base_operations.py

@@ -180,15 +180,17 @@ def add_common_commands(subparsers, efuses):
         help="Select the dump format: "
         "default - usual console eFuse dump; "
         "joint - all eFuse blocks are stored in one file; "
-        "split - each eFuse block is placed into its own file. The tool will create multiple files based on "
-        "the given --file_name (/path/blk.bin): blk0.bin, blk1.bin ... blkN.bin. Use the burn_block_data cmd "
+        "split - each eFuse block is placed into its own file. The tool will create "
+        "multiple files based on the given --file_name (/path/blk.bin): "
+        "blk0.bin, blk1.bin ... blkN.bin. Use the burn_block_data cmd "
         "to write it back to another chip.",
         choices=["default", "split", "joint"],
         default="default",
     )
     dump_cmd.add_argument(
         "--file_name",
-        help="The path to the file in which to save the dump, if not specified, output to the console.",
+        help="The path to the file in which to save the dump, if not specified, "
+        "output to the console.",
         default=sys.stdout,
     )
 
@@ -526,7 +528,8 @@ def burn_efuse(esp, efuses, args):
             print("Ignore incompatible eFuse settings.")
         else:
             raise esptool.FatalError(
-                "Incompatible eFuse settings detected, abort. (use --force flag to skip it)."
+                "Incompatible eFuse settings detected, abort. "
+                "(use --force flag to skip it)."
             )
 
     if not efuses.burn_all(check_batch_mode=True):

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/csv_table_parser.py

@@ -137,7 +137,9 @@ class CSVFuseTable(list):
 
         def print_error(p, n, state):
             raise InputError(
-                f"Field at {p.field_name}, {p.efuse_block}, {p.bit_start}, {p.bit_count}  {state}  {n.field_name}, {n.efuse_block}, {n.bit_start}, {n.bit_count}"
+                f"Field at {p.field_name}, {p.efuse_block}, {p.bit_start}, "
+                f"{p.bit_count} {state} {n.field_name}, {n.efuse_block}, "
+                f"{n.bit_start}, {n.bit_count}"
             )
 
         for p in self:
@@ -238,7 +240,8 @@ class FuseDefinition(object):
         if self.bit_start + self.bit_count > max_bits:
             raise ValidationError(
                 self,
-                f"The field is outside the boundaries(max_bits = {max_bits}) of the {self.efuse_block} block",
+                f"The field is outside the boundaries (max_bits = {max_bits}) "
+                f"of the {self.efuse_block} block",
             )
 
     def get_bit_count(self, check_define=True):

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/esp32/operations.py

@@ -229,6 +229,7 @@ def burn_key(esp, efuses, args):
             raise esptool.FatalError("Unknown block name - %s" % (block_name))
         num_bytes = efuse.bit_len // 8
         data = datafile.read()
+        datafile.close()
         revers_msg = None
         if block_name in ("flash_encryption", "secure_boot_v1"):
             revers_msg = "\tReversing the byte order"

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/esp32c2/operations.py

@@ -207,7 +207,11 @@ def burn_key(esp, efuses, args, digest=None):
 
     print("Burn keys to blocks:")
     for datafile, keypurpose in zip(datafile_list, keypurpose_list):
-        data = datafile if isinstance(datafile, bytes) else datafile.read()
+        if isinstance(datafile, bytes):
+            data = datafile
+        else:
+            data = datafile.read()
+            datafile.close()
 
         if keypurpose == "XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS":
             efuse = efuses["BLOCK_KEY0_LOW_128"]

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/esp32c3/operations.py

@@ -251,6 +251,7 @@ def burn_key(esp, efuses, args, digest=None):
 
         if digest is None:
             data = datafile.read()
+            datafile.close()
         else:
             data = datafile
 

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/esp32c5/operations.py

@@ -248,6 +248,7 @@ def burn_key(esp, efuses, args, digest=None):
                     data = b"\x00" * 8 + data
             else:
                 data = datafile.read()
+                datafile.close()
         else:
             data = datafile
 

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/esp32c6/operations.py

@@ -258,6 +258,7 @@ def burn_key(esp, efuses, args, digest=None):
 
         if digest is None:
             data = datafile.read()
+            datafile.close()
         else:
             data = datafile
 

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/esp32c61/mem_definition.py

@@ -5,7 +5,6 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 
 import os
-from typing import List
 
 import yaml
 
@@ -116,7 +115,7 @@ class EfuseDefineFields(EfuseFieldsBase):
         self.EFUSES = []
         self.KEYBLOCKS = []
         self.BLOCK2_CALIBRATION_EFUSES = []
-        self.CALC: List = []
+        self.CALC: list = []
 
         dir_name = os.path.dirname(os.path.abspath(__file__))
         dir_name, file_name = os.path.split(dir_name)

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/esp32c61/operations.py

@@ -315,6 +315,7 @@ def burn_key(esp, efuses, args, digest=None):
                     data = b"\x00" * 8 + data
             else:
                 data = datafile.read()
+                datafile.close()
         else:
             data = datafile
 

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/esp32h2/operations.py

@@ -262,6 +262,7 @@ def burn_key(esp, efuses, args, digest=None):
                     data = b"\x00" * 8 + data
             else:
                 data = datafile.read()
+                datafile.close()
         else:
             data = datafile
 

{esptool-4.9.dev5 → esptool-5.0.dev0}/espefuse/efuse/esp32h21/operations.py

@@ -246,6 +246,7 @@ def burn_key(esp, efuses, args, digest=None):
                     data = b"\x00" * 8 + data
             else:
                 data = datafile.read()
+                datafile.close()
         else:
             data = datafile
 

esptool-5.0.dev0/espefuse/efuse/esp32h4/emulate_efuse_controller.py

@@ -0,0 +1,92 @@
+# This file describes eFuses controller for ESP32-H4 chip
+#
+# SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+import reedsolo
+
+from .mem_definition import EfuseDefineBlocks, EfuseDefineFields, EfuseDefineRegisters
+from ..emulate_efuse_controller_base import EmulateEfuseControllerBase, FatalError
+
+
+class EmulateEfuseController(EmulateEfuseControllerBase):
+    """The class for virtual efuse operation. Using for HOST_TEST."""
+
+    CHIP_NAME = "ESP32-H4"
+    mem = None
+    debug = False
+
+    def __init__(self, efuse_file=None, debug=False):
+        self.Blocks = EfuseDefineBlocks
+        self.Fields = EfuseDefineFields(None)
+        self.REGS = EfuseDefineRegisters
+        super(EmulateEfuseController, self).__init__(efuse_file, debug)
+        self.write_reg(self.REGS.EFUSE_CMD_REG, 0)
+
+    """ esptool method start >>"""
+
+    def get_major_chip_version(self):
+        return 0
+
+    def get_minor_chip_version(self):
+        return 0
+
+    def get_crystal_freq(self):
+        return 32  # MHz
+
+    def get_security_info(self):
+        return {
+            "flags": 0,
+            "flash_crypt_cnt": 0,
+            "key_purposes": 0,
+            "chip_id": 0,
+            "api_version": 0,
+        }
+
+    """ << esptool method end """
+
+    def handle_writing_event(self, addr, value):
+        if addr == self.REGS.EFUSE_CMD_REG:
+            if value & self.REGS.EFUSE_PGM_CMD:
+                self.copy_blocks_wr_regs_to_rd_regs(updated_block=(value >> 2) & 0xF)
+                self.clean_blocks_wr_regs()
+                self.check_rd_protection_area()
+                self.write_reg(addr, 0)
+                self.write_reg(self.REGS.EFUSE_CMD_REG, 0)
+            elif value == self.REGS.EFUSE_READ_CMD:
+                self.write_reg(addr, 0)
+                self.write_reg(self.REGS.EFUSE_CMD_REG, 0)
+                self.save_to_file()
+
+    def get_bitlen_of_block(self, blk, wr=False):
+        if blk.id == 0:
+            if wr:
+                return 32 * 8
+            else:
+                return 32 * blk.len
+        else:
+            if wr:
+                rs_coding = 32 * 3
+                return 32 * 8 + rs_coding
+            else:
+                return 32 * blk.len
+
+    def handle_coding_scheme(self, blk, data):
+        if blk.id != 0:
+            # CODING_SCHEME RS applied only for all blocks except BLK0.
+            coded_bytes = 12
+            data.pos = coded_bytes * 8
+            plain_data = data.readlist("32*uint:8")[::-1]
+            # takes 32 bytes
+            # apply RS encoding
+            rs = reedsolo.RSCodec(coded_bytes)
+            # 32 byte of data + 12 bytes RS
+            calc_encoded_data = list(rs.encode([x for x in plain_data]))
+            data.pos = 0
+            if calc_encoded_data != data.readlist("44*uint:8")[::-1]:
+                raise FatalError("Error in coding scheme data")
+            data = data[coded_bytes * 8 :]
+        if blk.len < 8:
+            data = data[(8 - blk.len) * 32 :]
+        return data