sltcodec 0.2.0__tar.gz → 0.3.0__tar.gz

{sltcodec-0.2.0 → sltcodec-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: sltcodec
-Version: 0.2.0
+Version: 0.3.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.2.0 → sltcodec-0.3.0}/pyproject.toml

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

{sltcodec-0.2.0 → sltcodec-0.3.0}/src/sltcodec/codec.py

@@ -170,13 +170,9 @@ def _split_repeated_field(field_def: FieldDef,
     resolved_offset = (_resolve_offset(field_def, env)
                        if offset is None else offset)
     resolved_size = _resolve_size(field_def, env)
-    return FieldDef(name=f"{field_def.name}[{index}]",
-                    offset=resolved_offset,
-                    size=resolved_size,
-                    type=field_def.type,
-                    scale=field_def.scale,
-                    repeat=None,
-                    description=field_def.description)
+    return field_def.split_repeat(index,
+                                  offset=resolved_offset,
+                                  size=resolved_size)
 
 
 def encode_field(field_def: FieldDef,

{sltcodec-0.2.0 → sltcodec-0.3.0}/src/sltcodec/types.py

@@ -1,8 +1,11 @@
 """Type definitions for structured layout metadata."""
 from __future__ import annotations
 
+import importlib
 import json
+import re
 from dataclasses import dataclass, field
+from enum import Enum
 from typing import Any
 
 from sltcore import Info, InfoSize
@@ -25,18 +28,47 @@ class FieldDef:
         default=None, metadata={"desc": "The repeat count of the field"})
     description: str | None = field(
         default=None, metadata={"desc": "The description of the field"})
+    range_expression: str | None = field(
+        default=None, metadata={"desc": "The value range expression"})
+    enum_type: type[Enum] | None = field(default=None,
+                                         metadata={"desc": "The enum type"})
 
     def split_repeat(self,
                      index: int,
-                     offset: InfoSize | str | None = None) -> "FieldDef":
+                     offset: InfoSize | str | None = None,
+                     size: InfoSize | str | None = None) -> "FieldDef":
         """Create a single repeated-field definition for the given index."""
-        return FieldDef(name=f"{self.name}[{index}]",
-                        offset=self.offset if offset is None else offset,
-                        size=self.size,
-                        type=self.type,
+        split_name = f"{self.name}[{index}]"
+        split_offset_source = self.offset if offset is None else offset
+        split_size_source = self.size if size is None else size
+        split_offset = self._replace_name_in_expression(split_offset_source,
+                                                        self.name, split_name)
+        split_size = self._replace_name_in_expression(split_size_source,
+                                                      self.name, split_name)
+        split_type = self._replace_name_in_expression(self.type, self.name,
+                                                      split_name)
+        split_range_expression = self._replace_name_in_expression(
+            self.range_expression, self.name, split_name)
+
+        return FieldDef(name=split_name,
+                        offset=split_offset,
+                        size=split_size,
+                        type=split_type,
                         scale=self.scale,
                         repeat=None,
-                        description=self.description)
+                        description=self.description,
+                        range_expression=split_range_expression,
+                        enum_type=self.enum_type)
+
+    @staticmethod
+    def _replace_name_in_expression(value: Any, old_name: str,
+                                    new_name: str) -> Any:
+        """Replace standalone old_name tokens in expression-like strings."""
+        if not isinstance(value, str):
+            return value
+        pattern = (rf"(?<![0-9A-Za-z_]){re.escape(old_name)}"
+                   rf"(?![0-9A-Za-z_])")
+        return re.sub(pattern, lambda _: new_name, value)
 
     def __lt__(self, other: object) -> bool:
         """Compare field definitions using a stable serialized sort key."""
@@ -54,6 +86,8 @@ class FieldDef:
             "scale": self.scale,
             "repeat": self.repeat,
             "description": self.description,
+            "range_expression": self.range_expression,
+            "enum_type": self._serialize_enum_type(self.enum_type),
         }
 
     def to_json(self) -> str:
@@ -71,6 +105,8 @@ class FieldDef:
             scale=data.get("scale", 1.0),
             repeat=data.get("repeat"),
             description=data.get("description"),
+            range_expression=data.get("range_expression"),
+            enum_type=cls._deserialize_enum_type(data.get("enum_type")),
         )
 
     @classmethod
@@ -124,6 +160,37 @@ class FieldDef:
             return StructDef.from_dict(value)
         return value
 
+    @staticmethod
+    def _serialize_enum_type(value: type[Enum] | None) -> Any:
+        if value is None:
+            return None
+        return {
+            "__type__": "EnumType",
+            "module": value.__module__,
+            "qualname": value.__qualname__,
+        }
+
+    @classmethod
+    def _deserialize_enum_type(cls, value: Any) -> type[Enum] | None:
+        if value is None:
+            return None
+        if not isinstance(value, dict) or value.get("__type__") != "EnumType":
+            return None
+        module_name = value.get("module")
+        qualname = value.get("qualname")
+        if not isinstance(module_name, str) or not isinstance(qualname, str):
+            return None
+        try:
+            module = importlib.import_module(module_name)
+            enum_type: Any = module
+            for attr in qualname.split("."):
+                enum_type = getattr(enum_type, attr)
+            if isinstance(enum_type, type) and issubclass(enum_type, Enum):
+                return enum_type
+        except (ImportError, AttributeError, TypeError):
+            return None
+        return None
+
     def _sort_key(self) -> tuple[Any, ...]:
         """Build a stable comparison key for ordering field definitions."""
         return (
@@ -134,6 +201,8 @@ class FieldDef:
             self.scale,
             -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_type),
         )
 
     @staticmethod
@@ -150,6 +219,13 @@ class FieldDef:
             return (0, json.dumps(value.to_dict(), sort_keys=True))
         return (1, value)
 
+    @staticmethod
+    def _sortable_enum_type(value: type[Enum] | None) -> str:
+        """Build a comparable key for enum type metadata."""
+        if value is None:
+            return ""
+        return f"{value.__module__}.{value.__qualname__}"
+
 
 @dataclass(frozen=True)
 class FieldInstance:

{sltcodec-0.2.0 → sltcodec-0.3.0}/tests/test_codec.py

@@ -1,4 +1,5 @@
 """Tests for the sltcodec module."""
+from enum import Enum
 from pathlib import Path
 
 import pytest
@@ -10,6 +11,12 @@ from sltcodec import (FieldDef, FieldInstance, StructDef, StructInstance,
 from sltcodec.codec import decode_field
 
 
+class ValueKind(Enum):
+    """Enum used for FieldDef enum_type metadata tests."""
+    A = 1
+    B = 2
+
+
 def test_encode_and_decode_round_trip():
     """Test that encoding and then decoding returns the original data."""
     struct_def = [
@@ -146,6 +153,48 @@ def test_repeated_field_preserves_description():
         decoded.field_instances[1].field_def.description == "A repeated value")
 
 
+def test_repeated_field_preserves_range_and_enum_metadata():
+    """Test repeated fields preserve range/enum metadata on decoded entries."""
+    field_def = FieldDef(name="value",
+                         offset=InfoSize(0, 0),
+                         size=InfoSize(1, 0),
+                         type="unsigned int",
+                         repeat=2,
+                         range_expression="0 <= value <= 255",
+                         enum_type=ValueKind)
+
+    encoded = encode(
+        StructInstance(struct_def=StructDef(fields=[field_def]),
+                       field_instances=[FieldInstance(field_def, [1, 2])]),
+        bytearray(),
+    )
+    decoded = decode([field_def], encoded)
+
+    assert decoded.field_instances[0].field_def.range_expression == (
+        "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_type is ValueKind
+    assert decoded.field_instances[1].field_def.enum_type is ValueKind
+
+
+def test_split_repeat_replaces_name_in_range_expression():
+    """Test split_repeat replaces field-name tokens in range expressions."""
+    field_def = FieldDef(
+        name="value",
+        offset=InfoSize(0, 0),
+        size=InfoSize(1, 0),
+        type="unsigned int",
+        repeat=2,
+        range_expression=("0 <= value and value <= limit and value_count"))
+
+    split = field_def.split_repeat(1)
+
+    assert split.name == "value[1]"
+    assert split.range_expression == (
+        "0 <= value[1] and value[1] <= limit and value_count")
+
+
 def test_field_def_json_round_trip():
     """Test that FieldDef can be serialized and deserialized from JSON."""
     field_def = FieldDef(name="value",
@@ -169,12 +218,16 @@ def test_field_def_to_json_from_json_round_trip():
                          type="unsigned int",
                          scale=2.0,
                          repeat=3,
-                         description="A repeated value")
+                         description="A repeated value",
+                         range_expression="0 <= value <= 255",
+                         enum_type=ValueKind)
 
     payload = field_def.to_json()
     restored = FieldDef.from_json(payload)
 
     assert restored == field_def
+    assert restored.range_expression == "0 <= value <= 255"
+    assert restored.enum_type is ValueKind
 
 
 def test_struct_def_metadata_json_round_trip():