sltcodec 2.4.0__tar.gz → 2.4.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sltcodec
-Version: 2.4.0
+Version: 2.4.1
 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

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

@@ -1,6 +1,6 @@
 [project]
 name = "sltcodec"
-version = "2.4.0"
+version = "2.4.1"
 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.4.1}/src/sltcodec/codec.py

@@ -134,8 +134,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 +176,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)
@@ -415,7 +434,10 @@ 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),
+        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)
         actual_size = nested_value.size
     else:

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

@@ -232,6 +232,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 = [