sltcodec 1.1.0__tar.gz → 1.2.0__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "sltcodec"
-version = "1.1.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.1.0 → sltcodec-1.2.0}/src/sltcodec/codec.py

@@ -368,7 +368,7 @@ 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):

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

@@ -104,8 +104,9 @@ 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"})
@@ -137,7 +138,7 @@ 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
@@ -184,8 +185,8 @@ 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,
         }
@@ -205,7 +206,7 @@ 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:
@@ -242,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,
@@ -259,7 +252,7 @@ class FieldDef:
             repeat=repeat,
             description=description,
             range_expression=range_expression,
-            enum_def=enum_def,
+            enum_def_name=enum_def_name,
             byte_swap=byte_swap,
         )
 
@@ -279,7 +272,7 @@ 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),
         )
 
@@ -297,19 +290,6 @@ class FieldDef:
             return (0, json.dumps(value.to_dict(), sort_keys=True))
         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)
-
     @staticmethod
     def _sortable_byte_swap(value: bool | str) -> tuple[int, str]:
         """Build a comparable key for a byte-swap flag or expression."""
@@ -369,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.1.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,15 @@ 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():
@@ -425,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.1.0 → sltcodec-1.2.0}/uv.lock

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