sltcodec 1.0.0__tar.gz → 1.1.0__tar.gz

{sltcodec-1.0.0 → sltcodec-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sltcodec
-Version: 1.0.0
+Version: 1.1.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

{sltcodec-1.0.0 → sltcodec-1.1.0}/pyproject.toml

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

{sltcodec-1.0.0 → sltcodec-1.1.0}/src/sltcodec/codec.py

@@ -105,6 +105,18 @@ def _resolve_size(field_def: FieldDef, env: dict[str, Any]) -> InfoSize:
     return _resolve_info_size(field_def.size, env)
 
 
+def _resolve_byte_swap(field_def: FieldDef, env: dict[str, Any]) -> bool:
+    """Resolve a byte-swap flag that can be static or expression-based."""
+    if isinstance(field_def.byte_swap, str):
+        return bool(SltEval(env).eval(field_def.byte_swap))
+    return field_def.byte_swap
+
+
+def _byte_swap_info(info: Info, size: InfoSize) -> Info:
+    """Reverse the byte representation of an Info payload."""
+    return Info.from_bytes(info.to_bytes[::-1], size, scale=info.scale)
+
+
 def _is_padding_field_def(field_def: FieldDef) -> bool:
     """Check whether a field definition represents padding."""
     return (field_def.name.startswith("padding[")
@@ -235,6 +247,8 @@ def encode_field(
         return
 
     offset, size, info = prepared
+    if _resolve_byte_swap(field_def, env):
+        info = _byte_swap_info(info, size)
     required_bytes = (offset + size).bytes
     if len(buf) < required_bytes:
         buf.extend(b"\x00" * (required_bytes - len(buf)))
@@ -341,6 +355,9 @@ def decode_field(
     if size.byte == 0 and size.bit == 0:
         return None
     info = bits_get(data, offset, size, scale=field_def.scale)
+    byte_swap = _resolve_byte_swap(field_def, env)
+    if byte_swap:
+        info = _byte_swap_info(info, size)
     resolved_type = _resolve_field_type(field_def.type, struct_def_dict, env)
     resolved_field_def = FieldDef(
         name=field_def.name,
@@ -352,6 +369,7 @@ def decode_field(
         description=field_def.description,
         range_expression=field_def.range_expression,
         enum_def=field_def.enum_def,
+        byte_swap=byte_swap,
     )
     if isinstance(resolved_type, StructDef):
         return FieldInstance(

{sltcodec-1.0.0 → sltcodec-1.1.0}/src/sltcodec/types.py

@@ -106,6 +106,9 @@ class FieldDef:
         default=None, metadata={"desc": "The value range expression"})
     enum_def: EnumDef | None = field(
         default=None, metadata={"desc": "The enum definition for the field"})
+    byte_swap: bool | str = field(
+        default=False,
+        metadata={"desc": "Whether to reverse the field byte order"})
 
     def split_repeat(self,
                      index: int,
@@ -123,6 +126,8 @@ class FieldDef:
                                                       split_name)
         split_range_expression = self._replace_name_in_expression(
             self.range_expression, self.name, split_name)
+        split_byte_swap = self._replace_name_in_expression(
+            self.byte_swap, self.name, split_name)
 
         return FieldDef(name=split_name,
                         offset=split_offset,
@@ -132,7 +137,8 @@ class FieldDef:
                         repeat=None,
                         description=self.description,
                         range_expression=split_range_expression,
-                        enum_def=self.enum_def)
+                        enum_def=self.enum_def,
+                        byte_swap=split_byte_swap)
 
     @staticmethod
     def _replace_name_in_expression(value: Any, old_name: str,
@@ -180,6 +186,8 @@ class FieldDef:
             self.range_expression,
             "enum_def":
             None if self.enum_def is None else self.enum_def.serialize(),
+            "byte_swap":
+            self.byte_swap,
         }
 
     def to_json(self) -> str:
@@ -198,6 +206,7 @@ class FieldDef:
         description = data.get("description")
         range_expression = data.get("range_expression")
         enum_def_data = data.get("enum_def")
+        byte_swap = data.get("byte_swap", False)
 
         def _deserialize_info_like(value: Any) -> Any:
             if isinstance(value, dict):
@@ -251,6 +260,7 @@ class FieldDef:
             description=description,
             range_expression=range_expression,
             enum_def=enum_def,
+            byte_swap=byte_swap,
         )
 
     @classmethod
@@ -270,6 +280,7 @@ class FieldDef:
             "" if self.description is None else self.description,
             "" if self.range_expression is None else self.range_expression,
             self._sortable_enum_type(self.enum_def),
+            self._sortable_byte_swap(self.byte_swap),
         )
 
     @staticmethod
@@ -299,6 +310,13 @@ class FieldDef:
             },
             sort_keys=True)
 
+    @staticmethod
+    def _sortable_byte_swap(value: bool | str) -> tuple[int, str]:
+        """Build a comparable key for a byte-swap flag or expression."""
+        if isinstance(value, bool):
+            return 0, str(value)
+        return 1, value
+
 
 @total_ordering
 @dataclass(frozen=True)

{sltcodec-1.0.0 → sltcodec-1.1.0}/tests/test_codec.py

@@ -261,6 +261,77 @@ def test_field_def_to_json_from_json_round_trip():
     }
 
 
+def test_field_def_byte_swap_json_round_trip():
+    """Test that expression-based byte_swap metadata is preserved."""
+    field_def = FieldDef(name="value",
+                         offset=InfoSize(0, 0),
+                         size=InfoSize(2, 0),
+                         type="unsigned int",
+                         byte_swap="kind == 1")
+
+    restored = FieldDef.from_json(field_def.to_json())
+
+    assert restored == field_def
+    assert restored.byte_swap == "kind == 1"
+
+
+def test_byte_swap_reverses_bytearray_input_and_output():
+    """Test byte_swap reverses bytearray values symmetrically."""
+    field_def = FieldDef(name="payload",
+                         offset=InfoSize(0, 0),
+                         size=InfoSize(3, 0),
+                         type="bytearray",
+                         byte_swap=True)
+
+    encoded = encode(
+        StructInstance(struct_def=StructDef(fields=[field_def]),
+                       field_instances=[
+                           FieldInstance(field_def, bytearray(b"\x01\x02\x03"))
+                       ]),
+        bytearray(),
+    )
+    decoded = decode([field_def], encoded)
+
+    assert encoded == bytearray(b"\x03\x02\x01")
+    assert decoded.field_instances == [
+        FieldInstance(field_def, bytearray(b"\x01\x02\x03"))
+    ]
+
+
+def test_byte_swap_expression_uses_previous_field_value():
+    """Test byte_swap expressions use values decoded or encoded before it."""
+    kind_field = FieldDef(name="kind",
+                          offset=InfoSize(0, 0),
+                          size=InfoSize(1, 0),
+                          type="unsigned int")
+    value_field = FieldDef(name="value",
+                           offset=InfoSize(1, 0),
+                           size=InfoSize(2, 0),
+                           type="unsigned int",
+                           byte_swap="kind == 1")
+
+    encoded = encode(
+        StructInstance(struct_def=StructDef(fields=[kind_field, value_field]),
+                       field_instances=[
+                           FieldInstance(kind_field, 1),
+                           FieldInstance(value_field, 0x1234),
+                       ]),
+        bytearray(),
+    )
+    decoded = decode([kind_field, value_field], encoded)
+
+    assert encoded == bytearray(b"\x01\x34\x12")
+    assert decoded.field_instances == [
+        FieldInstance(kind_field, 1),
+        FieldInstance(
+            FieldDef(name="value",
+                     offset=InfoSize(1, 0),
+                     size=InfoSize(2, 0),
+                     type="unsigned int",
+                     byte_swap=True), 0x1234),
+    ]
+
+
 def test_enum_def_to_json_from_json_round_trip():
     """Test EnumDef.to_json/from_json round-trip conversion."""
     enum_def = EnumDef(name="Status",

{sltcodec-1.0.0 → sltcodec-1.1.0}/uv.lock

@@ -74,7 +74,7 @@ wheels = [
 
 [[package]]
 name = "sltcodec"
-version = "0.6.0"
+version = "1.0.0"
 source = { editable = "." }
 dependencies = [
     { name = "sltcalc" },