sltcodec 2.4.0__tar.gz → 2.5.0__tar.gz

{sltcodec-2.4.0 → sltcodec-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sltcodec
-Version: 2.4.0
+Version: 2.5.0
 Summary: Decode and encode bytearrays according to struct layout definitions using sltcore.
 Project-URL: Homepage, https://github.com/fangface-hub/StructLayoutToolkitCodec
 Project-URL: Documentation, https://readthedocs.org
@@ -63,6 +63,26 @@ encoded = encode(layout, instance, bytearray())
 decoded = decode(layout, encoded)
 ```
 
+## Progress Callbacks
+
+`encode` and `decode` accept an optional `progress_callback` argument. The
+callback is typed as `ProgressCallback` and receives a `float` progress value
+from `0.0` to `1.0`.
+
+Progress is calculated for top-level fields as `(offset + size) / total_size`.
+Nested structure encode/decode calls pass `None` internally, so recursive
+fields do not emit additional callback events.
+
+```python
+from sltcodec import ProgressCallback, decode
+
+def update_progress(progress: float) -> None:
+    progress_bar.value = progress
+
+progress_callback: ProgressCallback = update_progress
+decoded = decode(layout, encoded, progress_callback=progress_callback)
+```
+
 `decode` returns a `StructInstance` whose `size` is the actual end of the
 decoded layout. `decode_field` stores the actual decoded size in the returned
 `FieldInstance.field_def.size`. For nested `StructDef` fields, that size comes
@@ -138,6 +158,7 @@ The following symbols are exported by `sltcodec.__all__` in this order:
 | Symbol | Description |
 | --- | --- |
 | `PRIMITIVE_TYPES` | Set of built-in field type names supported by the codec. |
+| `ProgressCallback` | Callable type alias for encode/decode progress updates. |
 | `EnumDef` | Immutable definition of an enumeration. |
 | `EnumDict` | Dictionary-like container for `EnumDef` objects. |
 | `FieldDef` | Immutable definition of one structured field. |
@@ -310,15 +331,16 @@ beginning with `_` are internal helpers and are not part of the public API.
 | Definition | Signature | Description |
 | --- | --- | --- |
 | `PRIMITIVE_TYPES` | `set[str]` | Built-in field type names. |
+| `ProgressCallback` | `Callable[[float], None]` | Progress callback type for top-level encode/decode updates. |
 | `save_struct_layout` | `(struct_layout, path) -> None` | Save a layout to a JSON file. |
 | `load_struct_layout` | `(path) -> StructLayout` | Load a layout from a JSON file. |
 | `save_struct_def_dict` | `(path, struct_def_dict) -> None` | Save a structure-definition dictionary through the layout format. |
 | `load_struct_def_dict` | `(path) -> dict[str, StructDef]` | Load a structure-definition dictionary. |
 | `save_enum_def_dict` | `(path, enum_def_dict) -> None` | Save an enum-definition dictionary through the layout format. |
 | `load_enum_def_dict` | `(path) -> dict[str, EnumDef]` | Load an enum-definition dictionary. |
-| `encode` | `(struct_layout, struct_instance, buf, padding_alignment_bits=32) -> bytearray` | Encode a complete structure. |
+| `encode` | `(struct_layout, struct_instance, buf, padding_alignment_bits=32, progress_callback=None) -> bytearray` | Encode a complete structure. |
 | `decode_field` | `(field_def, data, env=None, type_dict=None, padding_alignment_bits=32) -> FieldInstance \| None` | Decode one field. |
-| `decode` | `(struct_layout, data, padding_alignment_bits=32) -> StructInstance` | Decode a complete structure. |
+| `decode` | `(struct_layout, data, padding_alignment_bits=32, progress_callback=None) -> StructInstance` | Decode a complete structure. |
 
 `save_struct_def_dict`, `load_struct_def_dict`, `save_enum_def_dict`, and
 `load_enum_def_dict` are available from `sltcodec.codec` for dictionary-level

{sltcodec-2.4.0 → sltcodec-2.5.0}/README.md

@@ -57,6 +57,22 @@ definition is resolved by `struct_layout.struct_def_name` from
 `struct_layout.type_dict.struct_dict`; enum definitions are resolved from the
 same `TypeDict`.
 
+`encode` and `decode` accept an optional `progress_callback` argument typed as
+`ProgressCallback`. The callback receives a `float` progress value calculated
+from the top-level field extent: `(offset + size) / total_size`. Recursive
+nested structure calls pass `None`, so callers receive progress updates only
+for the top-level encode or decode operation.
+
+```python
+from sltcodec import ProgressCallback, decode
+
+def update_progress(progress: float) -> None:
+    progress_bar.value = progress
+
+progress_callback: ProgressCallback = update_progress
+decoded = decode(layout, data, progress_callback=progress_callback)
+```
+
 Layout persistence uses the explicit names `save_struct_layout` and
 `load_struct_layout`. The former `save_type_dict` and `load_type_dict` API is
 not part of the current public interface.

{sltcodec-2.4.0 → sltcodec-2.5.0}/README_pypi.md

@@ -46,6 +46,26 @@ encoded = encode(layout, instance, bytearray())
 decoded = decode(layout, encoded)
 ```
 
+## Progress Callbacks
+
+`encode` and `decode` accept an optional `progress_callback` argument. The
+callback is typed as `ProgressCallback` and receives a `float` progress value
+from `0.0` to `1.0`.
+
+Progress is calculated for top-level fields as `(offset + size) / total_size`.
+Nested structure encode/decode calls pass `None` internally, so recursive
+fields do not emit additional callback events.
+
+```python
+from sltcodec import ProgressCallback, decode
+
+def update_progress(progress: float) -> None:
+    progress_bar.value = progress
+
+progress_callback: ProgressCallback = update_progress
+decoded = decode(layout, encoded, progress_callback=progress_callback)
+```
+
 `decode` returns a `StructInstance` whose `size` is the actual end of the
 decoded layout. `decode_field` stores the actual decoded size in the returned
 `FieldInstance.field_def.size`. For nested `StructDef` fields, that size comes
@@ -121,6 +141,7 @@ The following symbols are exported by `sltcodec.__all__` in this order:
 | Symbol | Description |
 | --- | --- |
 | `PRIMITIVE_TYPES` | Set of built-in field type names supported by the codec. |
+| `ProgressCallback` | Callable type alias for encode/decode progress updates. |
 | `EnumDef` | Immutable definition of an enumeration. |
 | `EnumDict` | Dictionary-like container for `EnumDef` objects. |
 | `FieldDef` | Immutable definition of one structured field. |
@@ -293,15 +314,16 @@ beginning with `_` are internal helpers and are not part of the public API.
 | Definition | Signature | Description |
 | --- | --- | --- |
 | `PRIMITIVE_TYPES` | `set[str]` | Built-in field type names. |
+| `ProgressCallback` | `Callable[[float], None]` | Progress callback type for top-level encode/decode updates. |
 | `save_struct_layout` | `(struct_layout, path) -> None` | Save a layout to a JSON file. |
 | `load_struct_layout` | `(path) -> StructLayout` | Load a layout from a JSON file. |
 | `save_struct_def_dict` | `(path, struct_def_dict) -> None` | Save a structure-definition dictionary through the layout format. |
 | `load_struct_def_dict` | `(path) -> dict[str, StructDef]` | Load a structure-definition dictionary. |
 | `save_enum_def_dict` | `(path, enum_def_dict) -> None` | Save an enum-definition dictionary through the layout format. |
 | `load_enum_def_dict` | `(path) -> dict[str, EnumDef]` | Load an enum-definition dictionary. |
-| `encode` | `(struct_layout, struct_instance, buf, padding_alignment_bits=32) -> bytearray` | Encode a complete structure. |
+| `encode` | `(struct_layout, struct_instance, buf, padding_alignment_bits=32, progress_callback=None) -> bytearray` | Encode a complete structure. |
 | `decode_field` | `(field_def, data, env=None, type_dict=None, padding_alignment_bits=32) -> FieldInstance \| None` | Decode one field. |
-| `decode` | `(struct_layout, data, padding_alignment_bits=32) -> StructInstance` | Decode a complete structure. |
+| `decode` | `(struct_layout, data, padding_alignment_bits=32, progress_callback=None) -> StructInstance` | Decode a complete structure. |
 
 `save_struct_def_dict`, `load_struct_def_dict`, `save_enum_def_dict`, and
 `load_enum_def_dict` are available from `sltcodec.codec` for dictionary-level

{sltcodec-2.4.0 → sltcodec-2.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sltcodec"
-version = "2.4.0"
+version = "2.5.0"
 description = "Decode and encode bytearrays according to struct layout definitions using sltcore."
 readme = "README_pypi.md"
 requires-python = ">=3.12"

{sltcodec-2.4.0 → sltcodec-2.5.0}/src/sltcodec/__init__.py

@@ -1,10 +1,11 @@
-from .codec import (PRIMITIVE_TYPES, decode, encode, load_struct_layout,
-                    save_struct_layout)
+from .codec import (PRIMITIVE_TYPES, ProgressCallback, decode, encode,
+                    load_struct_layout, save_struct_layout)
 from .types import (EnumDef, EnumDict, FieldDef, FieldInstance, StructDef,
                     StructDict, StructInstance, StructLayout, TypeDict)
 
 __all__ = [
     "PRIMITIVE_TYPES",
+    "ProgressCallback",
     "EnumDef",
     "EnumDict",
     "FieldDef",

{sltcodec-2.4.0 → sltcodec-2.5.0}/src/sltcodec/codec.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import json
 import re
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 from sltcalc import SltEval
 from sltcore import Info, InfoSize, bits_get, bits_set
@@ -27,6 +27,58 @@ _PRIMITIVE_TYPES = PRIMITIVE_TYPES
 
 _DEFAULT_PADDING_ALIGNMENT_BITS = 32
 
+ProgressCallback = Callable[[float], None]
+
+
+def _notify_progress(progress_callback: ProgressCallback | None,
+                     offset: InfoSize, size: InfoSize, total_bits: int) -> None:
+    """Notify caller of top-level encode/decode progress."""
+    if progress_callback is None or total_bits <= 0:
+        return
+    progress = min((offset + size).bits / total_bits, 1.0)
+    progress_callback(progress)
+
+
+def _estimate_encode_total_bits(struct_instance: StructInstance,
+                                initial_size_bits: int) -> int:
+    """Estimate encoded top-level extent before mutating the output buffer."""
+    env: dict[str, Any] = {}
+    total_bits = max(struct_instance.size.bits, initial_size_bits)
+
+    for field_value in struct_instance.field_instances:
+        field_def = field_value.field_def
+        repeat_until_end = field_def.repeat == "end"
+        repeat = _resolve_repeat(field_def.repeat, env)
+        value = field_value.value
+        if _is_padding_field_def(field_def):
+            padding_size = _resolve_info_size(field_def.size, env)
+            value = bytearray(padding_size.bytes)
+        if repeat_until_end:
+            repeat_values = list(value)
+            repeat = len(repeat_values)
+        if repeat is not None and repeat > 1:
+            current_offset = _resolve_info_size(field_def.offset, env)
+            values = repeat_values if repeat_until_end else list(value)
+
+            for i in range(repeat):
+                field_def_repeat = _repeated_field_def(field_def, i,
+                                                       current_offset,
+                                                       field_def.size)
+                resolved_size = _resolve_info_size(field_def_repeat.size, env)
+                total_bits = max(total_bits,
+                                 (current_offset + resolved_size).bits)
+                env[field_def_repeat.name] = values[i]
+                if isinstance(current_offset, InfoSize):
+                    current_offset += resolved_size
+            continue
+
+        resolved_offset = _resolve_info_size(field_def.offset, env)
+        resolved_size = _resolve_info_size(field_def.size, env)
+        total_bits = max(total_bits, (resolved_offset + resolved_size).bits)
+        env[field_def.name] = value
+
+    return total_bits
+
 
 def _as_field_defs(struct_def: StructDef | list[FieldDef]) -> list[FieldDef]:
     """Normalize StructDef/list inputs to a list of field definitions."""
@@ -134,8 +186,20 @@ def load_enum_def_dict(path: str | Path) -> dict[str, EnumDef]:
 def _resolve_info_size(value: InfoSize | str, env: dict[str, Any]) -> InfoSize:
     """Resolve an InfoSize value that can be static or expression-based."""
     if isinstance(value, str):
-        stleval = SltEval(env)
-        resolved_byte = stleval.eval(value)
+        eval_env = dict(env)
+
+        def replace_info_size(match: re.Match[str]) -> str:
+            name = f"_info_size_{len(eval_env)}"
+            eval_env[name] = InfoSize(int(match.group(1)), int(match.group(2)))
+            return name
+
+        expression = re.sub(
+            r"\bInfoSize\s*\(\s*(-?\d+)\s*,\s*(-?\d+)\s*\)",
+            replace_info_size,
+            value,
+        )
+        stleval = SltEval(eval_env)
+        resolved_byte = stleval.eval(expression)
         if isinstance(resolved_byte, InfoSize):
             return resolved_byte
         return InfoSize(resolved_byte, 0)
@@ -164,6 +228,13 @@ def _is_padding_field_def(field_def: FieldDef) -> bool:
             and field_def.type in ["bytes", "bytearray"])
 
 
+def _struct_def_has_dynamic_extent(struct_def: StructDef) -> bool:
+    """Check whether a nested structure can consume data beyond its fields."""
+    return any(field_def.repeat == "end" or isinstance(field_def.offset, str)
+               or isinstance(field_def.size, str)
+               for field_def in struct_def.fields)
+
+
 def _validate_padding_alignment_bits(padding_alignment_bits: int) -> None:
     """Validate padding alignment as a positive power-of-two bit size."""
     if (isinstance(padding_alignment_bits, bool)
@@ -234,12 +305,11 @@ def _prepare_field_info(
             raise TypeError(
                 "Nested StructDef fields must be encoded with StructInstance "
                 "values")
-        nested_bytes = encode(_layout_for_struct_def(value.struct_def,
-                                                     type_dict,
-                                                     name=field_def.name),
-                              value,
-                              bytearray(),
-                              padding_alignment_bits=padding_alignment_bits)
+        nested_bytes = encode(
+            _layout_for_struct_def(value.struct_def,
+                                   type_dict,
+                                   name=field_def.name), value, bytearray(),
+            padding_alignment_bits, None)
         info = Info.from_bytes(bytes(nested_bytes), size, scale=field_def.scale)
     else:
         info = _encode_primitive(resolved_type, value, size, field_def.scale)
@@ -304,6 +374,7 @@ def encode(
     struct_instance: StructInstance,
     buf: bytearray,
     padding_alignment_bits: int = _DEFAULT_PADDING_ALIGNMENT_BITS,
+    progress_callback: ProgressCallback | None = None,
 ) -> bytearray:
     """Encode decode() result into a bytearray.
 
@@ -318,6 +389,9 @@ def encode(
         The base bytearray instance to write into.
     padding_alignment_bits : int, optional
         The padding alignment boundary in bits, by default 32.
+    progress_callback : Callable[[float], None] | None, optional
+        Called after each top-level field is encoded with progress in the
+        range 0.0 to 1.0. Nested recursive encodes are skipped.
 
     Returns
     -------
@@ -334,6 +408,7 @@ def encode(
     type_dict = struct_layout.type_dict
     env: dict[str, Any] = {}
     has_padding = False
+    total_bits = _estimate_encode_total_bits(struct_instance, len(buf) * 8)
 
     for field_value in struct_instance.field_instances:
         field_def = field_value.field_def
@@ -359,13 +434,19 @@ def encode(
                 resolved_size = _resolve_info_size(field_def_repeat.size, env)
                 encode_field(field_def_repeat, values[i], buf, env, type_dict,
                              padding_alignment_bits)
+                _notify_progress(progress_callback, current_offset,
+                                 resolved_size, total_bits)
                 env[field_def_repeat.name] = values[i]
                 if isinstance(current_offset, InfoSize):
                     current_offset += resolved_size
             continue
 
+        resolved_offset = _resolve_info_size(field_def.offset, env)
+        resolved_size = _resolve_info_size(field_def.size, env)
         encode_field(field_def, value, buf, env, type_dict,
                      padding_alignment_bits)
+        _notify_progress(progress_callback, resolved_offset, resolved_size,
+                         total_bits)
         env[field_def.name] = value
 
     if has_padding and struct_instance.size.bytes > len(buf):
@@ -415,8 +496,15 @@ def decode_field(
         nested_layout = _layout_for_struct_def(resolved_type,
                                                type_dict,
                                                name=field_def.name)
-        nested_value = decode(nested_layout, bytearray(info.to_bytes),
-                              padding_alignment_bits)
+        nested_data = bytearray(info.to_bytes)
+        if _struct_def_has_dynamic_extent(resolved_type) and offset.bit == 0:
+            nested_data = bytearray(data[offset.byte:])
+        nested_value = decode(
+            nested_layout,
+            nested_data,
+            padding_alignment_bits,
+            None,
+        )
         actual_size = nested_value.size
     else:
         actual_size = info.info_size
@@ -485,6 +573,7 @@ def decode(
     struct_layout: StructLayout,
     data: bytearray | bytes,
     padding_alignment_bits: int = _DEFAULT_PADDING_ALIGNMENT_BITS,
+    progress_callback: ProgressCallback | None = None,
 ) -> StructInstance:
     """Decode a bytearray into field values according to a layout.
 
@@ -497,6 +586,9 @@ def decode(
         The data to decode.
     padding_alignment_bits : int, optional
         The padding alignment boundary in bits, by default 32.
+    progress_callback : Callable[[float], None] | None, optional
+        Called after each top-level field is decoded with progress in the
+        range 0.0 to 1.0. Nested recursive decodes are skipped.
     Returns
     -------
     StructInstance
@@ -582,6 +674,8 @@ def decode(
             if field_instance is not None:
                 env[field_instance.field_def.name] = field_instance.value
                 result.append_field_instance(field_instance)
+                _notify_progress(progress_callback, resolved_offset,
+                                 field_instance.field_def.size, data_bits)
                 current_position = (resolved_offset +
                                     _resolve_info_size(field_def.size, env))
             continue
@@ -621,6 +715,8 @@ def decode(
                     env[field_instance.field_def.name] = field_instance.value
                     result.append_field_instance(field_instance)
                     actual_size = field_instance.field_def.size
+                    _notify_progress(progress_callback, current_offset,
+                                     actual_size, data_bits)
                 else:
                     actual_size = resolved_size
 
@@ -666,6 +762,8 @@ def decode(
                 env[field_instance.field_def.name] = field_instance.value
                 result.append_field_instance(field_instance)
                 actual_size = field_instance.field_def.size
+                _notify_progress(progress_callback, current_offset, actual_size,
+                                 data_bits)
             else:
                 actual_size = _resolve_info_size(field_def_repeat.size, env)
             if isinstance(current_offset, InfoSize) and isinstance(

{sltcodec-2.4.0 → sltcodec-2.5.0}/tests/test_codec.py

@@ -5,8 +5,8 @@ import pytest
 from sltcore import InfoSize
 
 from sltcodec import (PRIMITIVE_TYPES, EnumDef, FieldDef, FieldInstance,
-                      StructDef, StructInstance, StructLayout, TypeDict, decode,
-                      encode)
+                      ProgressCallback, StructDef, StructInstance, StructLayout,
+                      TypeDict, decode, encode)
 from sltcodec.codec import _resolve_info_size, decode_field
 
 
@@ -42,6 +42,13 @@ def test_primitive_types_are_exposed_at_package_root():
     }
 
 
+def test_progress_callback_type_is_exposed_at_package_root():
+    """Test that ProgressCallback is exposed for external consumers."""
+    progress_callback: ProgressCallback = lambda progress: None
+
+    assert callable(progress_callback)
+
+
 def test_encode_and_decode_round_trip():
     """Test that encoding and then decoding returns the original data."""
     struct_def = [
@@ -75,6 +82,44 @@ def test_encode_and_decode_round_trip():
                   bytearray()) == encoded
 
 
+def test_encode_and_decode_progress_callbacks_use_top_level_progress():
+    """Test progress callbacks report top-level encoded/decoded progress."""
+    fields = [
+        FieldDef(name="head",
+                 offset=InfoSize(0, 0),
+                 size=InfoSize(1, 0),
+                 type="unsigned int"),
+        FieldDef(name="tail",
+                 offset=InfoSize(1, 0),
+                 size=InfoSize(1, 0),
+                 type="unsigned int"),
+    ]
+    struct_def = StructDef(fields=fields)
+    struct_instance = StructInstance(
+        struct_def=struct_def,
+        field_instances=[
+            FieldInstance(fields[0], 0x12),
+            FieldInstance(fields[1], 0x34),
+        ],
+    )
+    encode_progress = []
+    decode_progress = []
+
+    encoded = encode(layout_for(struct_def),
+                     struct_instance,
+                     bytearray(),
+                     progress_callback=encode_progress.append)
+    decoded = decode(layout_for(struct_def),
+                     encoded,
+                     progress_callback=decode_progress.append)
+
+    assert encoded == bytearray(b"\x12\x34")
+    assert [field_instance.value
+            for field_instance in decoded.field_instances] == [0x12, 0x34]
+    assert encode_progress == [0.5, 1.0]
+    assert decode_progress == [0.5, 1.0]
+
+
 def test_decode_accepts_struct_layout():
     """Decode a legacy field list via a StructLayout bundle."""
     struct_def = StructDef(
@@ -166,6 +211,33 @@ def test_encode_layout_handles_repeat():
     ]
 
 
+def test_progress_callbacks_use_repeated_top_level_field_extent():
+    """Test repeated fields report progress against the encoded extent."""
+    field_def = FieldDef(name="value",
+                         offset=InfoSize(0, 0),
+                         size=InfoSize(1, 0),
+                         type="unsigned int",
+                         repeat=2)
+    struct_def = StructDef(fields=[field_def])
+    struct_instance = StructInstance(
+        struct_def=struct_def,
+        field_instances=[FieldInstance(field_def, [1, 2])],
+    )
+    encode_progress = []
+    decode_progress = []
+
+    encoded = encode(layout_for(struct_def),
+                     struct_instance,
+                     bytearray(),
+                     progress_callback=encode_progress.append)
+    decode(layout_for([field_def]),
+           encoded,
+           progress_callback=decode_progress.append)
+
+    assert encode_progress == [0.5, 1.0]
+    assert decode_progress == [0.5, 1.0]
+
+
 def test_expression_repeat_uses_previous_field_value():
     """Test that repeat expressions are evaluated against the field env."""
     seed_field = FieldDef(name="count",
@@ -232,6 +304,38 @@ def test_repeat_end_stops_when_offset_is_out_of_range():
     assert [instance.value for instance in decoded.field_instances] == [None]
 
 
+def test_info_size_expression_resolves_constructor():
+    """Test that serialized InfoSize constructors work in expressions."""
+    resolved = _resolve_info_size("InfoSize(1, 0) * count", {"count": 3})
+
+    assert resolved == InfoSize(3, 0)
+
+
+def test_repeat_end_uses_dynamic_nested_struct_size():
+    """Test repeat='end' advances by a variable-size nested structure."""
+    length_field = FieldDef(name="length",
+                            offset=InfoSize(0, 0),
+                            size=InfoSize(1, 0),
+                            type="unsigned int")
+    payload_field = FieldDef(name="payload",
+                             offset=InfoSize(1, 0),
+                             size="InfoSize(1, 0) * length",
+                             type="bytearray")
+    record_field = FieldDef(
+        name="record",
+        offset=InfoSize(0, 0),
+        size=InfoSize(1, 0),
+        type=StructDef(fields=[length_field, payload_field]),
+        repeat="end")
+
+    decoded = decode(layout_for([record_field]), bytearray(b"\x02ab\x01c"))
+
+    assert [instance.field_def.name for instance in decoded.field_instances
+            ] == ["record[0]", "record[1]"]
+    assert [instance.value.size for instance in decoded.field_instances
+            ] == [InfoSize(3, 0), InfoSize(2, 0)]
+
+
 def test_decode_out_of_range_sets_current_and_tail_values_to_none():
     """Test out-of-range decode fills current/tail field values with None."""
     fields = [
@@ -331,6 +435,49 @@ def test_encode_recurses_for_nested_field_types():
             ]
 
 
+def test_progress_callbacks_skip_nested_recursive_fields():
+    """Test nested recursive encode/decode calls do not report progress."""
+    child_field_defs = [
+        FieldDef(name="left",
+                 offset=InfoSize(0, 0),
+                 size=InfoSize(1, 0),
+                 type="unsigned int"),
+        FieldDef(name="right",
+                 offset=InfoSize(1, 0),
+                 size=InfoSize(1, 0),
+                 type="unsigned int"),
+    ]
+    parent_field_def = FieldDef(name="pair",
+                                offset=InfoSize(0, 0),
+                                size=InfoSize(2, 0),
+                                type=StructDef(fields=child_field_defs))
+    child_instance = StructInstance(
+        struct_def=StructDef(fields=child_field_defs),
+        field_instances=[
+            FieldInstance(child_field_defs[0], 3),
+            FieldInstance(child_field_defs[1], 4),
+        ],
+    )
+    parent_struct_def = StructDef(fields=[parent_field_def])
+    parent_instance = StructInstance(
+        struct_def=parent_struct_def,
+        field_instances=[FieldInstance(parent_field_def, child_instance)],
+    )
+    encode_progress = []
+    decode_progress = []
+
+    encoded = encode(layout_for(parent_struct_def),
+                     parent_instance,
+                     bytearray(),
+                     progress_callback=encode_progress.append)
+    decode(layout_for(parent_struct_def),
+           encoded,
+           progress_callback=decode_progress.append)
+
+    assert encode_progress == [1.0]
+    assert decode_progress == [1.0]
+
+
 def test_decode_field_uses_nested_struct_instance_size():
     """Test that nested decoding determines the field's actual size."""
     child_field_def = FieldDef(name="value",