sltcodec 0.4.0__tar.gz → 0.5.0__tar.gz

{sltcodec-0.4.0 → sltcodec-0.5.0}/PKG-INFO

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

{sltcodec-0.4.0 → sltcodec-0.5.0}/pyproject.toml

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

{sltcodec-0.4.0 → sltcodec-0.5.0}/src/sltcodec/codec.py

@@ -319,34 +319,45 @@ def decode_field(
         return None
     info = bits_get(data, offset, size, scale=field_def.scale)
     resolved_type = _resolve_field_type(field_def.type, struct_def_dict, env)
+    resolved_field_def = FieldDef(
+        name=field_def.name,
+        offset=offset,
+        size=size,
+        type=resolved_type,
+        scale=field_def.scale,
+        repeat=field_def.repeat,
+        description=field_def.description,
+        range_expression=field_def.range_expression,
+        enum_def=field_def.enum_def,
+    )
     if isinstance(resolved_type, StructDef):
         return FieldInstance(
-            field_def=field_def,
+            field_def=resolved_field_def,
             value=decode(resolved_type, bytearray(info.to_bytes),
                          struct_def_dict, enum_def_dict,
                          padding_alignment_bits),
         )
     if resolved_type == "bool":
-        return FieldInstance.from_value(field_def,
+        return FieldInstance.from_value(resolved_field_def,
                                         info.to_bool,
                                         enum_def_dict=enum_def_dict)
     if resolved_type == "signed int":
-        return FieldInstance.from_value(field_def,
+        return FieldInstance.from_value(resolved_field_def,
                                         info.to_signed_int,
                                         enum_def_dict=enum_def_dict)
     if resolved_type in ["int", "unsigned int"]:
-        return FieldInstance.from_value(field_def,
+        return FieldInstance.from_value(resolved_field_def,
                                         info.to_unsigned_int,
                                         enum_def_dict=enum_def_dict)
     if resolved_type == "float":
-        return FieldInstance.from_value(field_def,
+        return FieldInstance.from_value(resolved_field_def,
                                         info.to_float,
                                         enum_def_dict=enum_def_dict)
     if resolved_type in ["bytearray", "bytes"]:
-        return FieldInstance.from_value(field_def,
+        return FieldInstance.from_value(resolved_field_def,
                                         info.to_bytes,
                                         enum_def_dict=enum_def_dict)
-    return FieldInstance.from_value(field_def,
+    return FieldInstance.from_value(resolved_field_def,
                                     info.raw_value,
                                     enum_def_dict=enum_def_dict)
 

{sltcodec-0.4.0 → sltcodec-0.5.0}/src/sltcodec/types.py

@@ -4,12 +4,14 @@ from __future__ import annotations
 import json
 import re
 from dataclasses import dataclass, field
+from functools import total_ordering
 from typing import Any
 
 from sltcalc import SltEval
 from sltcore import Info, InfoSize
 
 
+@total_ordering
 @dataclass(frozen=True)
 class EnumDef:
     """An enumeration definition."""
@@ -67,7 +69,22 @@ class EnumDef:
         """Create an enum definition from a JSON string."""
         return cls.from_dict(json.loads(data))
 
+    def __lt__(self, other: object) -> bool:
+        """Compare enum definitions using a stable serialized sort key."""
+        if not isinstance(other, EnumDef):
+            return NotImplemented
+        return self._sort_key() < other._sort_key()
+
+    def _sort_key(self) -> tuple[Any, ...]:
+        """Build a stable comparison key for ordering enum definitions."""
+        return (
+            self.name,
+            "" if self.description is None else self.description,
+            json.dumps(self.values, sort_keys=True),
+        )
 
+
+@total_ordering
 @dataclass(frozen=True)
 class FieldDef:
     """A field in a structured layout."""
@@ -283,6 +300,7 @@ class FieldDef:
             sort_keys=True)
 
 
+@total_ordering
 @dataclass(frozen=True)
 class FieldInstance:
     """A decoded/encodable field value with its field definition."""
@@ -355,6 +373,7 @@ class FieldInstance:
         return None
 
 
+@total_ordering
 @dataclass(frozen=True)
 class StructDef:
     """A structured layout definition that groups multiple fields."""
@@ -369,6 +388,21 @@ class StructDef:
         metadata={"desc": "The fields of the structure"},
     )
 
+    def __lt__(self, other: object) -> bool:
+        """Compare structure definitions using a stable serialized sort key."""
+        if not isinstance(other, StructDef):
+            return NotImplemented
+        return self._sort_key() < other._sort_key()
+
+    def _sort_key(self) -> tuple[Any, ...]:
+        """Build a stable comparison key for ordering structure definitions."""
+        return (
+            self.name,
+            "" if self.description is None else self.description,
+            json.dumps([field.to_dict() for field in self.fields],
+                       sort_keys=True),
+        )
+
     def to_dict(self) -> dict[str, Any]:
         """Convert this structure definition to JSON-serializable data."""
         return {
@@ -402,6 +436,7 @@ class StructDef:
         return cls.from_dict(json.loads(data))
 
 
+@total_ordering
 @dataclass
 class StructInstance:
     """A decoded/encodable structure instance."""
@@ -454,6 +489,23 @@ class StructInstance:
         """Return one field instance by index."""
         return self.field_instances[index]
 
+    def __lt__(self, other: object) -> bool:
+        """Compare structure instances using a stable serialized sort key."""
+        if not isinstance(other, StructInstance):
+            return NotImplemented
+        return self._sort_key() < other._sort_key()
+
+    def _sort_key(self) -> tuple[Any, ...]:
+        """Build a stable comparison key for ordering structure instances."""
+        return (
+            self.struct_def._sort_key(),
+            json.dumps([
+                field_instance.to_dict()
+                for field_instance in self.field_instances
+            ],
+                       sort_keys=True),
+        )
+
     def _sort_field_instances(self) -> None:
         """Keep field instances sorted by FieldDef order."""
         self.field_instances.sort()
@@ -466,14 +518,25 @@ class StructInstance:
         ]
         non_padding_instances.sort()
 
+        has_unresolved_layout = any(
+            not isinstance(field_instance.field_def.offset, InfoSize)
+            or not isinstance(field_instance.field_def.size, InfoSize)
+            for field_instance in non_padding_instances)
+        if has_unresolved_layout:
+            # Layout expressions are resolved later in codec paths.
+            self.field_instances = non_padding_instances
+            self._sort_field_instances()
+            self._update_size()
+            return
+
         rebuilt_instances: list[FieldInstance] = []
         current_offset = InfoSize(0, 0)
         padding_index = 0
 
         for field_instance in non_padding_instances:
             field_def = field_instance.field_def
-            field_offset = self._resolve_field_offset(field_def)
-            field_size = self._resolve_field_size(field_def)
+            field_offset = field_def.offset
+            field_size = field_def.size
             if field_offset > current_offset:
                 gap_size = field_offset - current_offset
                 if gap_size.byte > 0 or gap_size.bit > 0:
@@ -521,25 +584,15 @@ class StructInstance:
         max_end_offset = InfoSize(0, 0)
         for field_instance in self.field_instances:
             field_def = field_instance.field_def
-            field_offset = self._resolve_field_offset(field_def)
-            field_size = self._resolve_field_size(field_def)
+            if not isinstance(field_def.offset, InfoSize):
+                continue
+            if not isinstance(field_def.size, InfoSize):
+                continue
+            field_offset = field_def.offset
+            field_size = field_def.size
             field_end = field_offset + field_size
             if field_end > max_end_offset:
                 max_end_offset = field_end
 
         if max_end_offset > self.size:
             self.size = max_end_offset
-
-    @staticmethod
-    def _resolve_field_offset(field_def: FieldDef) -> InfoSize:
-        """Resolve field offsets to InfoSize values when possible."""
-        if isinstance(field_def.offset, InfoSize):
-            return field_def.offset
-        return InfoSize(0, 0)
-
-    @staticmethod
-    def _resolve_field_size(field_def: FieldDef) -> InfoSize:
-        """Resolve field sizes to InfoSize values when possible."""
-        if isinstance(field_def.size, InfoSize):
-            return field_def.size
-        return InfoSize(0, 0)

{sltcodec-0.4.0 → sltcodec-0.5.0}/tests/test_codec.py

@@ -475,10 +475,11 @@ def test_type_expression_uses_previous_field_value():
         bytearray(),
     )
     decoded_int = decode(struct_def, encoded_int)
-    assert decoded_int.field_instances == [
-        FieldInstance(struct_def[0], 1),
-        FieldInstance(struct_def[1], 7),
-    ]
+    assert decoded_int.field_instances[0] == FieldInstance(struct_def[0], 1)
+    assert decoded_int.field_instances[1].field_def.offset == InfoSize(1, 0)
+    assert decoded_int.field_instances[1].field_def.size == InfoSize(1, 0)
+    assert decoded_int.field_instances[1].field_def.type == "int"
+    assert decoded_int.field_instances[1].value == 7
 
     encoded_float = encode(
         StructInstance(struct_def=StructDef(fields=struct_def),
@@ -490,7 +491,9 @@ def test_type_expression_uses_previous_field_value():
     )
     decoded_float = decode(struct_def, encoded_float)
     assert decoded_float.field_instances[0] == FieldInstance(struct_def[0], 2)
-    assert decoded_float.field_instances[1].field_def == struct_def[1]
+    assert decoded_float.field_instances[1].field_def.offset == InfoSize(1, 0)
+    assert decoded_float.field_instances[1].field_def.size == InfoSize(4, 0)
+    assert decoded_float.field_instances[1].field_def.type == "float"
     assert decoded_float.field_instances[1].value == 1.5
 
 

{sltcodec-0.4.0 → sltcodec-0.5.0}/uv.lock

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