sltcodec 0.6.0__tar.gz → 1.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sltcodec
-Version: 0.6.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-0.6.0 → sltcodec-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sltcodec"
-version = "0.6.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-0.6.0 → sltcodec-1.1.0}/src/sltcodec/__init__.py

@@ -1,5 +1,6 @@
 from .codec import (PRIMITIVE_TYPES, decode, encode, encode_field,
-                    load_struct_def_dict, save_struct_def_dict)
+                    load_enum_def_dict, load_struct_def_dict,
+                    save_enum_def_dict, save_struct_def_dict)
 from .types import EnumDef, FieldDef, FieldInstance, StructDef, StructInstance
 
 __all__ = [
@@ -12,6 +13,8 @@ __all__ = [
     "decode",
     "encode",
     "encode_field",
+    "load_enum_def_dict",
     "load_struct_def_dict",
+    "save_enum_def_dict",
     "save_struct_def_dict",
 ]

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

@@ -66,6 +66,26 @@ def load_struct_def_dict(path: str | Path) -> dict[str, StructDef]:
     }
 
 
+def save_enum_def_dict(path: str | Path, enum_def_dict: dict[str,
+                                                             EnumDef]) -> None:
+    """Save an enum definition dictionary to a JSON file."""
+    payload = {
+        name: enum_def.to_dict()
+        for name, enum_def in enum_def_dict.items()
+    }
+    Path(path).write_text(json.dumps(payload, ensure_ascii=False, indent=2),
+                          encoding="utf-8")
+
+
+def load_enum_def_dict(path: str | Path) -> dict[str, EnumDef]:
+    """Load an enum definition dictionary from a JSON file."""
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    return {
+        name: EnumDef.from_dict(enum_def_data)
+        for name, enum_def_data in data.items()
+    }
+
+
 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):
@@ -85,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[")
@@ -215,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)))
@@ -321,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,
@@ -332,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-0.6.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-0.6.0 → sltcodec-1.1.0}/tests/test_codec.py

@@ -7,7 +7,8 @@ from sltcore import InfoSize
 
 from sltcodec import (PRIMITIVE_TYPES, EnumDef, FieldDef, FieldInstance,
                       StructDef, StructInstance, decode, encode,
-                      load_struct_def_dict, save_struct_def_dict)
+                      load_enum_def_dict, load_struct_def_dict,
+                      save_enum_def_dict, save_struct_def_dict)
 from sltcodec.codec import decode_field
 
 
@@ -260,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",
@@ -413,6 +485,22 @@ def test_struct_def_dict_load_and_save(tmp_path: Path):
     assert loaded["value"] == struct_def
 
 
+def test_enum_def_dict_load_and_save(tmp_path: Path):
+    """Test that an EnumDef dictionary can be saved and reloaded."""
+    enum_def = EnumDef(name="Status",
+                       description="Status enum",
+                       values={
+                           "OK": 1,
+                           "NG": 2
+                       })
+    path = tmp_path / "enum_defs.json"
+
+    save_enum_def_dict(path, {"status": enum_def})
+    loaded = load_enum_def_dict(path)
+
+    assert loaded["status"] == enum_def
+
+
 def test_struct_def_to_json_from_json_round_trip():
     """Test StructDef.to_json/from_json round-trip conversion."""
     struct_def = StructDef(name="ValueStruct",

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

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