idftool 1.2.0__tar.gz → 1.3.0__tar.gz

{idftool-1.2.0 → idftool-1.3.0}/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project are documented here. The format is
 based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [v1.3.0] — 2026-10-02
+
+### Added
+- `set-nvs --csv` sets every key in a CSV without touching the rest of the
+  partition. Bundle `set-nvs` ops take a CSV as `file`.
+
+### Changed
+- The progress bar for sector-by-sector writes matches esptool's: sizes in
+  kB/MB and elapsed time.
+
 ## [v1.2.0] — 2026-10-01
 
 ### Added
@@ -400,6 +410,7 @@ this project adheres to [Semantic Versioning](https://semver.org/).
 ### Added
 - Initial release.
 
+[v1.3.0]: https://github.com/nebkat/idftool/releases/tag/v1.3.0
 [v1.2.0]: https://github.com/nebkat/idftool/releases/tag/v1.2.0
 [v1.1.0]: https://github.com/nebkat/idftool/releases/tag/v1.1.0
 [v1.0.0]: https://github.com/nebkat/idftool/releases/tag/v1.0.0

{idftool-1.2.0/idftool.egg-info → idftool-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idftool
-Version: 1.2.0
+Version: 1.3.0
 Summary: The ultimate CLI tool for interacting with Espressif devices
 License-Expression: Apache-2.0
 Project-URL: Source, https://github.com/nebkat/idftool

{idftool-1.2.0 → idftool-1.3.0}/docs/guide/provisioning.md

@@ -40,6 +40,12 @@ Add a key that doesn't exist yet by giving its type:
 idftool set-nvs nvs config:serial:string=SN-0042
 ```
 
+Set several keys from a CSV, keeping everything else:
+
+```bash
+idftool set-nvs nvs --csv config.csv
+```
+
 ### Read values back
 
 ```console

{idftool-1.2.0 → idftool-1.3.0}/docs/reference/bundles.md

@@ -51,7 +51,7 @@ order after the files:
 | `erase` | `partition` | Erase a partition. |
 | `write-fs` | `partition`, `file` | Write a filesystem image. |
 | `edit-fs` | `partition`, `put`, `delete` | Put files (path → file in the bundle) in the filesystem, and delete paths. |
-| `set-nvs` | `partition`, `set`, `delete` | Set keys (`ns:key` → `type:value`, or a bare value for a key that exists) and delete them. Without `partition`, the first NVS partition. |
+| `set-nvs` | `partition`, `file`, `set`, `delete` | Set the keys in `file` (an NVS CSV), set keys (`ns:key` → `type:value`, or a bare value for a key that exists) and delete them. Without `partition`, the first NVS partition. |
 | `set-boot` | `partition` | Boot that OTA slot next. |
 | `clear-boot` | | Clear otadata so the factory app boots. |
 

{idftool-1.2.0 → idftool-1.3.0}/docs/reference/nvs.md

@@ -137,6 +137,7 @@ idftool set-nvs nvs storage:serial:string=SN-0001 -d storage:old_key
 idftool set-nvs nvs -n storage :cert:blob=@device.der
 idftool set-nvs -f nvs.bin storage:device_id=42
 idftool set-nvs nvs storage:device_id=42 --dry-run
+idftool set-nvs nvs --csv keys.csv
 ```
 
 `namespace:key=value`
@@ -157,6 +158,11 @@ idftool set-nvs nvs storage:device_id=42 --dry-run
 `-d namespace:key`
 :   Delete a key.
 
+`-c FILE`, `--csv FILE`
+:   Set every key in a CSV, in the format `create-nvs` takes and `read-nvs`
+    writes. Keys not in the CSV are left alone. Repeatable; CSV rows apply
+    first, then specs, then deletes.
+
 Changes are **appended** the way firmware writes them: a new entry goes into
 free space and the old one is marked erased. Everything else stays
 byte-for-byte identical, and on a device only the 4 KiB pages that changed are

{idftool-1.2.0 → idftool-1.3.0}/idftool/bundle.py

@@ -116,8 +116,8 @@ class Op:
                               f"\"delete\" a list")
         if op == 'edit-fs' and not (put or delete):
             raise BundleError(f"{where} (edit-fs): needs \"put\" and/or \"delete\"")
-        if op == 'set-nvs' and not (set_ or delete):
-            raise BundleError(f"{where} (set-nvs): needs \"set\" and/or \"delete\"")
+        if op == 'set-nvs' and not (set_ or delete or data.get('file')):
+            raise BundleError(f"{where} (set-nvs): needs \"file\", \"set\" and/or \"delete\"")
         return cls(index, op, data.get('partition'), data.get('file'),
                    {str(k): str(v) for k, v in put.items()}, [str(d) for d in delete],
                    dict(set_))
@@ -138,7 +138,8 @@ class Op:
                     f"delete {', '.join(self.delete)}" if self.delete else '']
             return f"Update files in '{self.partition}': {'; '.join(w for w in what if w)}"
         if self.op == 'set-nvs':
-            what = [f"{k} = {v}" for k, v in self.set.items()] + [f"delete {d}" for d in self.delete]
+            what = ([f"keys from {self.file}"] if self.file else []) + \
+                   [f"{k} = {v}" for k, v in self.set.items()] + [f"delete {d}" for d in self.delete]
             where = f" ('{self.partition}')" if self.partition else ''
             return f"Update NVS{where}: {', '.join(what)}"
         if self.op == 'set-boot':

{idftool-1.2.0 → idftool-1.3.0}/idftool/commands/bundles.py

@@ -235,7 +235,7 @@ def write_bundle(state, input_file, hmac_key=None, **options):
                               f"'{op.partition}' is not an OTA app partition")
         elif op.op == 'set-nvs':
             try:
-                nvs_edits[op.index] = manifest_edits(op.set, op.delete, read_file)
+                nvs_edits[op.index] = manifest_edits(op.set, op.delete, read_file, op.file)
             except (click.UsageError, RuntimeError) as e:
                 message = e.format_message() if isinstance(e, click.UsageError) else str(e)
                 raise BundleError(f"manifest.json: op {op.index} (set-nvs): {message}") from e

{idftool-1.2.0 → idftool-1.3.0}/idftool/commands/nvs.py

@@ -20,8 +20,8 @@ from idftool.partitions import get_partition
 
 # Keep the pass-through write options in a panel of their own.
 option_group('write-nvs', '--hmac-key')
-option_group('set-nvs', '--file', '--delete', '--namespace', '--output', '--rewrite', '--hmac-key',
-             '--dry-run')
+option_group('set-nvs', '--file', '--csv', '--delete', '--namespace', '--output', '--rewrite',
+             '--hmac-key', '--dry-run')
 
 
 def hmac_key_option(f):
@@ -338,25 +338,114 @@ def _parse_delete(spec, default_namespace):
     return Edit(namespace, key)
 
 
+def _fill_blob(encoding, value, key):
+    """The bytes of a ``blob_fill(N;0xPP)`` or ``blob_sz_fill(N;0xPP)`` value."""
+    import re
+    import struct
+
+    match = re.fullmatch(r'(blob_fill|blob_sz_fill)\((\d+);(0x[0-9a-fA-F]{2})\)', encoding)
+    if not match:
+        raise click.UsageError(f"'{key}': invalid encoding '{encoding}'")
+    kind, length, pad = match.group(1), int(match.group(2)), int(match.group(3), 16)
+    data = value.encode('utf-8')
+    if len(data) > length:
+        raise click.UsageError(f"'{key}': value is longer than {length} bytes")
+    prefix = struct.pack('<I', len(data)) if kind == 'blob_sz_fill' else b''
+    return prefix + data + bytes([pad]) * (length - len(data))
+
+
+def _csv_value(key, row_type, encoding, value, read_file):
+    """``(type, value)`` of one ``nvs_partition_gen`` CSV row."""
+    import base64
+    import binascii
+    from idftool.nvs import PRIMITIVES
+
+    if row_type == 'file':
+        raw = read_file(value)
+        if encoding == 'binary':
+            return 'blob', raw
+        value = raw.decode('utf-8')
+        if encoding == 'string':
+            return 'string', value
+    elif row_type != 'data':
+        raise click.UsageError(f"'{key}': unknown type '{row_type}' (expected namespace, data "
+                               f"or file)")
+
+    try:
+        if encoding in PRIMITIVES:
+            return encoding, int(value.strip(), 0)
+        if encoding == 'string':
+            return 'string', value
+        if encoding == 'hex2bin':
+            return 'blob', bytes.fromhex(value.strip())
+        if encoding == 'base64':
+            return 'blob', base64.b64decode(value)
+        if encoding == 'binary':
+            return 'blob', value.encode('utf-8')
+    except (ValueError, binascii.Error) as e:
+        raise click.UsageError(f"'{key}': '{value}' is not valid {encoding}: {e}")
+    if encoding.startswith(('blob_fill', 'blob_sz_fill')):
+        return 'blob', _fill_blob(encoding, value, key)
+    raise click.UsageError(f"'{key}': unknown encoding '{encoding}'")
+
+
+def csv_edits(text, source, read_file=_read_host_file):
+    """Edits setting every key in an ``nvs_partition_gen`` CSV, the format ``create-nvs``
+    takes and ``read-nvs`` writes. ``file`` rows are read through `read_file`."""
+    import csv
+    from idftool.nvs.edit import Edit
+
+    rows = csv.DictReader(line for line in text.splitlines() if not line.startswith('#'))
+    if not rows.fieldnames or not {'key', 'type', 'encoding', 'value'} <= set(rows.fieldnames):
+        raise click.UsageError(f"{source} needs a 'key,type,encoding,value' header")
+    edits, namespace = [], None
+    for row in rows:
+        key, row_type = row['key'], (row['type'] or '').strip()
+        if row_type == 'namespace':
+            namespace = key
+            continue
+        if namespace is None:
+            raise click.UsageError(f"{source}: '{key}' comes before any namespace row")
+        try:
+            type_name, value = _csv_value(key, row_type, (row['encoding'] or '').strip(),
+                                          row['value'] or '', read_file)
+        except click.UsageError as e:
+            raise click.UsageError(f"{source}: {e.format_message()}")
+        edits.append(Edit(namespace, key, type_name, value))
+    return edits
+
+
+def _read_csv(path):
+    try:
+        text = open(path, encoding='utf-8').read()
+    except OSError as e:
+        raise click.UsageError(f"Cannot read CSV file '{path}': {e}")
+    return csv_edits(text, f"'{path}'")
+
+
 def _resolve_untyped(image, edits, read_file=_read_host_file):
-    """Fill in the type of any ``--set`` that didn't give one, from the entry it replaces."""
+    """Fill in the type of any ``--set`` that didn't give one, from the entry it replaces —
+    an earlier edit of the same key, or else the image's."""
     from idftool.nvs.edit import Edit
 
-    resolved = []
+    resolved, types = [], {}
     for edit in edits:
         if edit.is_delete or edit.type is not None:
             resolved.append(edit)
+            types[edit.qualified] = edit.type
             continue
         existing = image.get(edit.namespace, edit.key)
-        if existing is None:
+        type_name = types.get(edit.qualified, existing and existing.type)
+        if type_name is None:
             from idftool.nvs import PRIMITIVES, NvsError
             known = ', '.join(list(PRIMITIVES) + ['string', 'blob'])
             raise NvsError(
                 f"'{edit.namespace}:{edit.key}' is not in the image, so its type cannot be "
                 f"inferred — write it as {edit.namespace}:{edit.key}:<type>={edit.value} "
                 f"(types: {known})")
-        resolved.append(Edit(edit.namespace, edit.key, existing.type,
-                             _parse_value(existing.type, edit.value, read_file)))
+        types[edit.qualified] = type_name
+        resolved.append(Edit(edit.namespace, edit.key, type_name,
+                             _parse_value(type_name, edit.value, read_file)))
     return resolved
 
 
@@ -403,13 +492,14 @@ def _write_pages(esp, part, result, dirty, options, hmac_key=None):
                 **write_flash_options(options, skip_flashed=True, diff=True))
 
 
-def manifest_edits(set_values, deletes, read_file):
-    """Edits from a bundle manifest's ``set-nvs`` op: ``ns:key`` → ``type:value`` (or a bare
-    value for a key that exists), and ``ns:key`` deletes."""
+def manifest_edits(set_values, deletes, read_file, csv_file=None):
+    """Edits from a bundle manifest's ``set-nvs`` op: the keys of `csv_file`, then ``ns:key`` →
+    ``type:value`` (or a bare value for a key that exists), then ``ns:key`` deletes."""
     from idftool.nvs import PRIMITIVES
 
     known = list(PRIMITIVES) + ['string', 'blob']
-    edits = []
+    edits = (csv_edits(read_file(csv_file).decode('utf-8'), f"'{csv_file}'", read_file)
+             if csv_file else [])
     for qualified, value in set_values.items():
         value = str(value)
         prefix, colon, rest = value.partition(':')
@@ -462,22 +552,23 @@ def _split_target(args, image_file, what):
 
 
 def set_nvs(state, args, image_file, deletes, namespace, output_file, do_rewrite, dry_run,
-            hmac_key=None, **options):
+            hmac_key=None, csv_files=(), **options):
     """Set or delete keys in an NVS partition or image. Keyword arguments go to esptool's
     ``write_flash`` (see :data:`idftool.flash.WRITE_FLASH_OPTIONS`)."""
     import idftool.nvs as nvs
     from idftool.nvs.edit import apply
 
     partition, specs = _split_target(args, image_file, "SPEC")
-    if not specs and not deletes:
+    if not specs and not deletes and not csv_files:
         if partition and '=' in partition:
             # The one positional given is a spec, so what's missing is the target it applies to.
             raise click.UsageError(
                 f"'{partition}' looks like a SPEC, not a partition — name the partition first "
                 f"(idftool set-nvs nvs {partition}) or use -f/--file")
-        raise click.UsageError(f"Nothing to do — pass at least one SPEC or --delete.\n{SPEC_HELP}")
+        raise click.UsageError(f"Nothing to do — pass at least one SPEC, --csv or --delete.\n{SPEC_HELP}")
 
-    edits = ([_parse_set(spec, namespace) for spec in specs] +
+    edits = ([edit for path in csv_files for edit in _read_csv(path)] +
+             [_parse_set(spec, namespace) for spec in specs] +
              [_parse_delete(spec, namespace) for spec in deletes])
 
     data, part, source = _load_image(state, partition, image_file, 'set-nvs', hmac_key)
@@ -518,6 +609,8 @@ def set_nvs(state, args, image_file, deletes, namespace, output_file, do_rewrite
 @click.argument('args', nargs=-1, metavar='[PARTITION] SPEC...')
 @click.option('-f', '--file', 'image_file', default=None,
               help='Edit this NVS image file instead of a partition on the device')
+@click.option('-c', '--csv', 'csv_files', multiple=True, metavar='CSV',
+              help='Set every key in this CSV (the create-nvs format); repeatable')
 @click.option('-d', '--delete', 'deletes', multiple=True, metavar='KEY',
               help='Delete a key: namespace:key')
 @click.option('-n', '--namespace', default=None,
@@ -530,20 +623,22 @@ def set_nvs(state, args, image_file, deletes, namespace, output_file, do_rewrite
 @hmac_key_option
 @flash_options
 @pass_state
-def cmd_set_nvs(state, args, image_file, deletes, namespace, output_file, do_rewrite, dry_run,
-                hmac_key, **options):
+def cmd_set_nvs(state, args, image_file, csv_files, deletes, namespace, output_file, do_rewrite,
+                dry_run, hmac_key, **options):
     """Set or delete keys in an NVS partition on the device, or in an image file with --file.
 
     A SPEC is `namespace:key=value`, or `namespace:key:type=value` to give the type of a key
     that isn't there yet — for one that is, the type is taken from the entry being replaced.
-    A value of `@FILE` is read from that file.
+    A value of `@FILE` is read from that file. `--csv` sets every key in a CSV file of the
+    kind `create-nvs` takes and `read-nvs` writes, leaving the rest of the partition alone;
+    CSV rows apply first, then SPECs, then deletes.
 
     Changes are appended the way the firmware would write them, so everything else in the
     partition is left byte-for-byte alone and a device write only touches the pages that
     changed. If there is no room left to append, the image is compacted instead.
     """
     return set_nvs(state, args, image_file, deletes, namespace, output_file, do_rewrite, dry_run,
-                   hmac_key, **options)
+                   hmac_key, csv_files, **options)
 
 
 def _parse_get(spec, default_namespace):

{idftool-1.2.0 → idftool-1.3.0}/idftool/flash.py

@@ -313,30 +313,51 @@ def plan_sector_writes(esp, address, data, on_scanned=None, sector_size=DIFF_SEC
 
 
 class Progress:
-    """One progress bar for a whole operation, drawn by esptool's own logger.
+    """One progress bar for a whole operation: esptool's own (``log.progress``).
 
     The differential path scans and writes in the same pass, so its progress is two numbers
-    that advance independently — bytes compared, and bytes written. Both go on one bar, which
-    tracks the scan (whose total is known from the start) and reports the writes alongside.
-
-    Rendering goes through ``log.progress_bar`` rather than being written out here, so this
-    inherits esptool's decisions rather than second-guessing them: whether the terminal takes
-    ANSI escapes, the Windows fallback, and the verbosity setting, which is what ``silent``
-    has to reach to be worth anything. It also means the bar looks like every other bar the
-    user sees from a flashing tool.
+    that advance independently — bytes compared, and bytes written. The bar tracks the scan
+    (whose total is known from the start); what has been written goes in its description.
+
+    Going through esptool's logger means the bar looks like every other bar esptool draws —
+    same layout, sizes and elapsed time — and obeys its decisions on ANSI, Unicode and
+    verbosity.
     """
 
-    def __init__(self, prefix, total, enabled=True):
-        self.prefix, self.total, self.enabled = prefix, total, enabled and total > 0
+    class _StoppedShort(Exception):
+        """Thrown into ``log.progress`` so a scan that stopped short isn't drawn as done."""
+
+    def __init__(self, description, total, enabled=True):
+        self.description, self.total, self.enabled = description, total, enabled and total > 0
         self.scanned = self.written = 0
         self._shown = None
+        self._drawn = 0
+        self._context = self._task = None
+
+    def __enter__(self):
+        self._context = log.progress(total=self.total, description=self.description,
+                                     unit='B', disable=not self.enabled)
+        self._task = self._context.__enter__()
+        return self
+
+    def __exit__(self, *exc):
+        if self.scanned < self.total:
+            # An abandoned or failed scan never reaches 100%: end the line where it stopped.
+            if self._shown is not None:
+                log.print("")
+            if exc[0] is None:
+                exc = (self._StoppedShort, self._StoppedShort(), None)
+        self._context.__exit__(*exc)
 
     @staticmethod
     def size(count):
-        for unit, scale in (('M', 1 << 20), ('K', 1 << 10)):
-            if count >= scale:
-                return f'{count / scale:.1f}{unit}'.replace('.0', '')
-        return f'{count}B'
+        """A byte count as esptool's bar shows it, e.g. ``1.20MB``."""
+        if count < 1024:
+            return f'{count}B'
+        for unit in ('kB', 'MB'):
+            count /= 1024
+            if count < 1024 or unit == 'MB':
+                return f'{count:.2f}{unit}'
 
     @staticmethod
     def rate(count, seconds):
@@ -349,26 +370,20 @@ class Progress:
         256 lines of scroll on one that cannot overwrite.
         """
         if scanned is not None:
-            self.scanned = scanned
+            self.scanned = min(scanned, self.total)
         if written is not None:
             self.written = written
         if not self.enabled:
             return
-        percent = 100 * min(self.scanned, self.total) // self.total
+        percent = 100 * self.scanned // self.total
         if percent == self._shown:
             return
         self._shown = percent
-        suffix = f' compared {self.size(self.scanned)}/{self.size(self.total)}'
+        description = self.description
         if self.written:
-            suffix += f', written {self.size(self.written)}'
-        log.progress_bar(min(self.scanned, self.total), self.total,
-                         prefix=f'{self.prefix} ', suffix=suffix)
-
-    def finish(self):
-        """End the bar's line if it stopped short — an abandoned scan never reaches 100%."""
-        if self._shown is not None and self._shown != 100:
-            log.print("")
-        self._shown = None
+            description += f' (written {self.size(self.written)})'
+        self._task.update(advance=self.scanned - self._drawn, description=description)
+        self._drawn = self.scanned
 
 
 def _say(prefix, args, file=None):
@@ -490,12 +505,11 @@ def _write_changed_sectors(esp, address, prepared, described, kwargs):
     fall back to comparing the region as a whole.
     """
     print(f"Comparing {described} against flash at {address:#010x}...")
-    progress = Progress(described, len(prepared), enabled=not kwargs.get('no_progress'))
     written = runs = 0
     elapsed = 0.0
     abandoned = False
 
-    try:
+    with Progress(described, len(prepared), enabled=not kwargs.get('no_progress')) as progress:
         for offset, length, reason in plan_sector_writes(
                 esp, address, prepared, on_scanned=lambda n: progress.update(scanned=n)):
             if reason == 'remainder':
@@ -514,8 +528,6 @@ def _write_changed_sectors(esp, address, prepared, described, kwargs):
             written += length
             runs += 1
             progress.update(written=written)
-    finally:
-        progress.finish()
 
     # esptool reports what it wrote and how fast after every write; a differential one is
     # made of many, so the same figures are totalled up and reported once here instead.

{idftool-1.2.0 → idftool-1.3.0/idftool.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idftool
-Version: 1.2.0
+Version: 1.3.0
 Summary: The ultimate CLI tool for interacting with Espressif devices
 License-Expression: Apache-2.0
 Project-URL: Source, https://github.com/nebkat/idftool

idftool-1.3.0/idftool.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.3.0",
+  "distance": 0,
+  "node": "gb08243cc7d12f7d75243ec81acd50c5cb9fa13d7",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-02"
+}

{idftool-1.2.0 → idftool-1.3.0}/test/test_flash.py

@@ -487,7 +487,7 @@ def test_changed_sectors_are_written_as_they_are_found(monkeypatch, capsys):
         [(0x10000 + 5 * 0x1000, data[5 * 0x1000:7 * 0x1000])],
         [(0x10000 + 40 * 0x1000, data[40 * 0x1000:41 * 0x1000])],
     ]
-    assert "wrote 12K of 256K in 2 regions" in capsys.readouterr().out
+    assert "wrote 12.00kB of 256.00kB in 2 regions" in capsys.readouterr().out
 
 
 def test_an_abandoned_scan_writes_the_region_whole(monkeypatch, capsys):
@@ -562,9 +562,8 @@ def test_app_commands_diff_by_default():
 def test_progress_is_silent_when_progress_is_not_wanted(capsys):
     from idftool.flash import Progress
 
-    bar = Progress('x', 0x1000, enabled=False)
-    bar.update(scanned=0x800)
-    bar.finish()
+    with Progress('x', 0x1000, enabled=False) as bar:
+        bar.update(scanned=0x800)
     assert capsys.readouterr().out == ""
 
 
@@ -575,7 +574,8 @@ def test_progress_obeys_esptools_verbosity(capsys):
 
     log.set_verbosity('silent')
     try:
-        Progress('x', 0x1000).update(scanned=0x800)
+        with Progress('x', 0x1000) as bar:
+            bar.update(scanned=0x800)
         assert capsys.readouterr().out == ""
     finally:
         log.set_verbosity('auto')
@@ -586,17 +586,31 @@ def test_progress_redraws_only_when_the_percentage_moves(capsys):
     and 256 lines of scroll on one that cannot."""
     from idftool.flash import Progress
 
-    bar = Progress('x', 1000 * 0x1000)
-    for sector in range(1, 21):          # 20 updates spanning 0% to 2% of the region
-        bar.update(scanned=sector * 0x1000)
+    with Progress('x', 1000 * 0x1000) as bar:
+        for sector in range(1, 21):      # 20 updates spanning 0% to 2% of the region
+            bar.update(scanned=sector * 0x1000)
     assert capsys.readouterr().out.count('%') == 3   # the first, then 1% and 2%
 
 
-def test_progress_sizes_read_the_way_a_person_would_say_them():
+def test_progress_sizes_match_esptools_bar():
     from idftool.flash import Progress
 
     assert [Progress.size(n) for n in (512, 0x1000, 0x40000, 0x100000, 0x180000)] == \
-        ["512B", "4K", "256K", "1M", "1.5M"]
+        ["512B", "4.00kB", "256.00kB", "1.00MB", "1.50MB"]
+
+
+def test_progress_uses_esptools_layout_and_stops_short_of_done(capsys):
+    """An abandoned scan must not be drawn as complete on the way out."""
+    from idftool.flash import Progress
+
+    with Progress('x', 4 * 0x1000) as bar:
+        bar.update(scanned=0x1000)
+        bar.update(written=0x1000)
+        bar.update(scanned=0x2000)
+    out = capsys.readouterr().out
+    assert "x (written 4.00kB)" in out
+    assert "8.00kB/16.00kB [" in out
+    assert "100.0%" not in out
 
 
 def test_quiet_esptool_keeps_what_matters_and_restores_itself(capsys):

{idftool-1.2.0 → idftool-1.3.0}/test/test_offline.py

@@ -224,7 +224,57 @@ def test_set_nvs_needs_something_to_do(run_offline, tmp_path):
     image = tmp_path / "nvs.bin"
     run_offline(f"create-nvs {SAMPLES / 'nvs.csv'} -o {image} --size 0x6000")
     out = run_offline(f"set-nvs -f {image}", expect_error=True)
-    assert "at least one SPEC or --delete" in out
+    assert "at least one SPEC, --csv or --delete" in out
+
+
+def test_set_nvs_csv_merges(run_offline, tmp_path):
+    image = tmp_path / "nvs.bin"
+    run_offline(f"create-nvs {SAMPLES / 'nvs.csv'} -o {image} --size 0x6000")
+    (tmp_path / "cert.der").write_bytes(b"\x01\x02\x03")
+    keys = tmp_path / "keys.csv"
+    keys.write_text(
+        "key,type,encoding,value\n"
+        "# comments are skipped\n"
+        "storage,namespace,,\n"
+        "counter,data,u16,0x2a\n"
+        "serial,data,string,SN-42\n"
+        "token,data,base64,3q2+7w==\n"
+        "pad,data,blob_sz_fill(4;0x00),ab\n"
+        f"cert,file,binary,{tmp_path / 'cert.der'}\n"
+        "other,namespace,,\n"
+        "flag,data,u8,1\n")
+    # SPECs apply after the CSV, so they win.
+    run_offline(["set-nvs", "-f", str(image), "--csv", str(keys), "storage:serial=SN-43"])
+    get = lambda *keys: run_offline(["get-nvs", "-f", str(image), *keys]).splitlines()
+    assert get("storage:counter", "storage:serial", "storage:token", "storage:pad",
+               "storage:cert", "other:flag") == ["42", "SN-43", "deadbeef", "0200000061620000",
+                                                 "010203", "1"]
+    # Keys not in the CSV stay.
+    assert get("storage:device_name") == ["idftool-test"]
+
+
+def test_set_nvs_csv_round_trips_extract(run_offline, tmp_path):
+    image, other = tmp_path / "nvs.bin", tmp_path / "other.bin"
+    run_offline(f"create-nvs {SAMPLES / 'nvs.csv'} -o {image} --size 0x6000")
+    run_offline(f"set-nvs -f {image} storage:blob:blob=00ff storage:counter=9")
+    run_offline(f"extract-nvs -f {image} {tmp_path / 'back.csv'}")
+    (tmp_path / "empty.csv").write_text("key,type,encoding,value\nx,namespace,,\nk,data,u8,0\n")
+    run_offline(f"create-nvs {tmp_path / 'empty.csv'} -o {other} --size 0x6000")
+    out = run_offline(f"set-nvs -f {other} --csv {tmp_path / 'back.csv'}")
+    assert "+ storage:blob (blob) = 00ff" in out
+    assert run_offline(f"get-nvs -f {other} storage:counter x:k").splitlines() == ["9", "0"]
+
+
+def test_set_nvs_csv_errors_name_the_row(run_offline, tmp_path):
+    image = tmp_path / "nvs.bin"
+    run_offline(f"create-nvs {SAMPLES / 'nvs.csv'} -o {image} --size 0x6000")
+    bad = tmp_path / "bad.csv"
+    bad.write_text("key,type,encoding,value\nstorage,namespace,,\ncounter,data,u16,lots\n")
+    assert "'counter': 'lots' is not valid u16" in run_offline(
+        f"set-nvs -f {image} --csv {bad}", expect_error=True)
+    bad.write_text("key,type,encoding,value\ncounter,data,u16,1\n")
+    assert "before any namespace" in run_offline(f"set-nvs -f {image} --csv {bad}",
+                                                 expect_error=True)
 
 
 def test_set_nvs_value_from_a_file(run_offline, tmp_path):

{idftool-1.2.0 → idftool-1.3.0}/test/test_virtual.py

@@ -500,6 +500,21 @@ def test_print_bundle_without_a_table(run_offline, tmp_path):
     assert "2.0.0" in out
 
 
+def test_bundle_sets_nvs_from_a_csv(run, tmp_path, esp):
+    (tmp_path / "example.csv").write_text(
+        "key,type,encoding,value\nconfig,namespace,,\nserial,data,string,SN-0042\n"
+        "keep,data,u8,1\n")
+    run("write-nvs", "nvs", "example.csv")
+    csv = ("key,type,encoding,value\nconfig,namespace,,\nserial,data,string,SN-0050\n"
+           "cert,file,binary,nvs/cert.der\n")
+    bundle("b.zip", {"nvs/keys.csv": csv, "nvs/cert.der": b"\xca\xfe",
+                     "manifest.json": {"ops": [{"op": "set-nvs", "file": "nvs/keys.csv"}]}})
+    assert "keys from nvs/keys.csv" in run("print-bundle", "-f", "b.zip")
+    run("write-bundle", "b.zip")
+    assert run("get-nvs", "nvs", "config:serial", "config:keep", "config:cert").splitlines()[:3] \
+        == ["SN-0050", "1", "cafe"]
+
+
 def test_nvs_on_the_device(run, tmp_path, esp):
     (tmp_path / "example.csv").write_text(
         "key,type,encoding,value\nconfig,namespace,,\nserial,data,string,SN-0042\n")

idftool-1.2.0/idftool.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "1.2.0",
-  "distance": 0,
-  "node": "g151b902633ee2fdea932f57fd5721f2c37cb774d",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-01"
-}