sltcodec 1.0.0__tar.gz → 1.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sltcodec
-Version: 1.0.0
+Version: 1.2.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
@@ -236,6 +236,44 @@ bytearray(b"\x01\x07") StructInstance(struct_def=StructDef(...), field_instances
 bytearray(b"\x02?\xc0\x00\x00") StructInstance(struct_def=StructDef(...), field_instances=[...])
 ```
 
+## Enum Definitions
+
+`FieldDef.enum_def_name` holds only the name of an `EnumDef`, not the definition
+itself. Pass the actual definitions via an `enum_def_dict` (mapping name to
+`EnumDef`) to `decode` / `encode` so the matching `EnumDef` can be resolved and
+attached as `FieldInstance.enum_item`.
+
+```python
+from sltcore import InfoSize
+from sltcodec import EnumDef, FieldDef, decode
+
+status_enum = EnumDef(name="Status", values={"OK": 0, "NG": 1})
+
+struct_def = [
+    FieldDef(name="status",
+             offset=InfoSize(0, 0),
+             size=InfoSize(1, 0),
+             type="unsigned int",
+             enum_def_name="Status"),
+]
+
+decoded = decode(struct_def, bytearray(b"\x01"),
+                 enum_def_dict={"Status": status_enum})
+
+print(decoded.field_instances[0].value)
+print(decoded.field_instances[0].enum_item)
+```
+
+Output:
+
+```python
+1
+('NG', 1)
+```
+
+You can also persist enum definitions by name with
+`save_enum_def_dict` / `load_enum_def_dict`, mirroring `StructDef` dictionaries.
+
 ## Development
 
 ```bash

{sltcodec-1.0.0 → sltcodec-1.2.0}/README.md

@@ -219,6 +219,44 @@ bytearray(b"\x01\x07") StructInstance(struct_def=StructDef(...), field_instances
 bytearray(b"\x02?\xc0\x00\x00") StructInstance(struct_def=StructDef(...), field_instances=[...])
 ```
 
+## Enum Definitions
+
+`FieldDef.enum_def_name` holds only the name of an `EnumDef`, not the definition
+itself. Pass the actual definitions via an `enum_def_dict` (mapping name to
+`EnumDef`) to `decode` / `encode` so the matching `EnumDef` can be resolved and
+attached as `FieldInstance.enum_item`.
+
+```python
+from sltcore import InfoSize
+from sltcodec import EnumDef, FieldDef, decode
+
+status_enum = EnumDef(name="Status", values={"OK": 0, "NG": 1})
+
+struct_def = [
+    FieldDef(name="status",
+             offset=InfoSize(0, 0),
+             size=InfoSize(1, 0),
+             type="unsigned int",
+             enum_def_name="Status"),
+]
+
+decoded = decode(struct_def, bytearray(b"\x01"),
+                 enum_def_dict={"Status": status_enum})
+
+print(decoded.field_instances[0].value)
+print(decoded.field_instances[0].enum_item)
+```
+
+Output:
+
+```python
+1
+('NG', 1)
+```
+
+You can also persist enum definitions by name with
+`save_enum_def_dict` / `load_enum_def_dict`, mirroring `StructDef` dictionaries.
+
 ## Development
 
 ```bash

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

@@ -1,6 +1,6 @@
 [project]
 name = "sltcodec"
-version = "1.0.0"
+version = "1.2.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.2.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,
@@ -351,7 +368,8 @@ def decode_field(
         repeat=field_def.repeat,
         description=field_def.description,
         range_expression=field_def.range_expression,
-        enum_def=field_def.enum_def,
+        enum_def_name=field_def.enum_def_name,
+        byte_swap=byte_swap,
     )
     if isinstance(resolved_type, StructDef):
         return FieldInstance(

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

@@ -104,8 +104,12 @@ class FieldDef:
         default=None, metadata={"desc": "The description of the field"})
     range_expression: str | None = field(
         default=None, metadata={"desc": "The value range expression"})
-    enum_def: EnumDef | None = field(
-        default=None, metadata={"desc": "The enum definition for the field"})
+    enum_def_name: str | None = field(
+        default=None,
+        metadata={"desc": "The name of 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 +127,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 +138,8 @@ class FieldDef:
                         repeat=None,
                         description=self.description,
                         range_expression=split_range_expression,
-                        enum_def=self.enum_def)
+                        enum_def_name=self.enum_def_name,
+                        byte_swap=split_byte_swap)
 
     @staticmethod
     def _replace_name_in_expression(value: Any, old_name: str,
@@ -178,8 +185,10 @@ class FieldDef:
             self.description,
             "range_expression":
             self.range_expression,
-            "enum_def":
-            None if self.enum_def is None else self.enum_def.serialize(),
+            "enum_def_name":
+            self.enum_def_name,
+            "byte_swap":
+            self.byte_swap,
         }
 
     def to_json(self) -> str:
@@ -197,7 +206,8 @@ class FieldDef:
         repeat = data.get("repeat")
         description = data.get("description")
         range_expression = data.get("range_expression")
-        enum_def_data = data.get("enum_def")
+        enum_def_name = data.get("enum_def_name")
+        byte_swap = data.get("byte_swap", False)
 
         def _deserialize_info_like(value: Any) -> Any:
             if isinstance(value, dict):
@@ -233,14 +243,6 @@ class FieldDef:
         else:
             type_value = type_data
 
-        if enum_def_data is None:
-            enum_def = None
-        elif (isinstance(enum_def_data, dict)
-              and enum_def_data.get("__type__") == "EnumDef"):
-            enum_def = EnumDef.deserialize(enum_def_data)
-        else:
-            enum_def = None
-
         return cls(
             name=name,
             offset=offset,
@@ -250,7 +252,8 @@ class FieldDef:
             repeat=repeat,
             description=description,
             range_expression=range_expression,
-            enum_def=enum_def,
+            enum_def_name=enum_def_name,
+            byte_swap=byte_swap,
         )
 
     @classmethod
@@ -269,7 +272,8 @@ class FieldDef:
             -1 if self.repeat is None else self.repeat,
             "" 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),
+            "" if self.enum_def_name is None else self.enum_def_name,
+            self._sortable_byte_swap(self.byte_swap),
         )
 
     @staticmethod
@@ -287,17 +291,11 @@ class FieldDef:
         return (1, value)
 
     @staticmethod
-    def _sortable_enum_type(value: EnumDef | None) -> str:
-        """Build a comparable key for enum definition metadata."""
-        if value is None:
-            return ""
-        return json.dumps(
-            {
-                "name": value.name,
-                "description": value.description,
-                "values": value.values,
-            },
-            sort_keys=True)
+    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
@@ -351,10 +349,10 @@ class FieldInstance:
             field_def: FieldDef,
             enum_def_dict: dict[str, EnumDef] | None) -> EnumDef | None:
         """Resolve enum definition from field metadata or lookup dictionary."""
-        if field_def.enum_def is not None:
-            return field_def.enum_def
         if not enum_def_dict:
             return None
+        if field_def.enum_def_name is not None:
+            return enum_def_dict.get(field_def.enum_def_name)
         if isinstance(field_def.type, str) and field_def.type in enum_def_dict:
             return enum_def_dict[field_def.type]
         return enum_def_dict.get(field_def.name)

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

@@ -179,7 +179,7 @@ def test_repeated_field_preserves_range_and_enum_metadata():
                          type="unsigned int",
                          repeat=2,
                          range_expression="0 <= value <= 255",
-                         enum_def=enum_def)
+                         enum_def_name=enum_def.name)
 
     encoded = encode(
         StructInstance(struct_def=StructDef(fields=[field_def]),
@@ -192,8 +192,8 @@ def test_repeated_field_preserves_range_and_enum_metadata():
         "0 <= value[0] <= 255")
     assert decoded.field_instances[1].field_def.range_expression == (
         "0 <= value[1] <= 255")
-    assert decoded.field_instances[0].field_def.enum_def == enum_def
-    assert decoded.field_instances[1].field_def.enum_def == enum_def
+    assert decoded.field_instances[0].field_def.enum_def_name == enum_def.name
+    assert decoded.field_instances[1].field_def.enum_def_name == enum_def.name
 
 
 def test_split_repeat_replaces_name_in_range_expression():
@@ -242,23 +242,86 @@ def test_field_def_to_json_from_json_round_trip():
                          repeat=3,
                          description="A repeated value",
                          range_expression="0 <= value <= 255",
-                         enum_def=enum_def)
+                         enum_def_name=enum_def.name)
 
     payload = field_def.to_json()
     restored = FieldDef.from_json(payload)
 
     assert restored == field_def
     assert restored.range_expression == "0 <= value <= 255"
-    assert restored.enum_def == enum_def
-    assert restored.to_dict()["enum_def"] == {
-        "__type__": "EnumDef",
-        "name": "ValueKind",
-        "description": None,
-        "values": {
-            member.name: member.value
-            for member in ValueKind
-        },
-    }
+    assert restored.enum_def_name == enum_def.name
+    assert restored.to_dict()["enum_def_name"] == "ValueKind"
+
+
+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():
@@ -354,9 +417,10 @@ def test_field_instance_from_value_sets_enum_item_from_field_enum_def():
                          offset=InfoSize(0, 0),
                          size=InfoSize(1, 0),
                          type="unsigned int",
-                         enum_def=enum_def)
+                         enum_def_name=enum_def.name)
 
-    field_instance = FieldInstance.from_value(field_def, 1)
+    field_instance = FieldInstance.from_value(
+        field_def, 1, enum_def_dict={enum_def.name: enum_def})
 
     assert field_instance.enum_item == ("MANUAL", 1)
 

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

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