sltcodec 2.1.1__tar.gz → 2.3.0__tar.gz

{sltcodec-2.1.1 → sltcodec-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sltcodec
-Version: 2.1.1
+Version: 2.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
@@ -11,7 +11,7 @@ License-Expression: MIT
 License-File: LICENSE
 Keywords: byte,deserialization,layout,serialization,struct
 Requires-Python: >=3.12
-Requires-Dist: sltcalc>=0.1.0
+Requires-Dist: sltcalc>=1.0.0
 Requires-Dist: sltcore>=1.5.0
 Description-Content-Type: text/markdown
 
@@ -77,7 +77,7 @@ The public `PRIMITIVE_TYPES` set contains:
 {"bool", "signed int", "int", "unsigned int", "float", "bytearray", "bytes"}
 ```
 
-`FieldDef.type` may also be a nested `StructDef` or an expression string. Expressions can use values from previously processed fields, allowing dynamic types and sizes. Repeated fields, byte swapping, padding, ranges, and enum metadata are supported.
+`FieldDef.type` may also be a nested `StructDef` or an expression string. Expressions can use values from previously processed fields, allowing dynamic types, sizes, and repeat counts. Repeated fields, byte swapping, padding, ranges, and enum metadata are supported.
 
 ## Enums And Named Structures
 
@@ -180,7 +180,7 @@ internal implementation details and are omitted from the public method tables.
 | `size` | `InfoSize \| str` | Static size or expression. |
 | `type` | `str \| StructDef` | Primitive, named, or nested field type. |
 | `scale` | `float` | Numeric scale applied to the field. |
-| `repeat` | `int \| None` | Number of repeated field values. |
+| `repeat` | `int \| str \| None` | Number of repeated field values, or an expression that evaluates to the count. |
 | `description` | `str \| None` | Optional field description. |
 | `range_expression` | `str \| None` | Optional value-range expression. |
 | `enum_def_name` | `str \| None` | Name of the associated enum definition. |

{sltcodec-2.1.1 → sltcodec-2.3.0}/README_pypi.md

@@ -60,7 +60,7 @@ The public `PRIMITIVE_TYPES` set contains:
 {"bool", "signed int", "int", "unsigned int", "float", "bytearray", "bytes"}
 ```
 
-`FieldDef.type` may also be a nested `StructDef` or an expression string. Expressions can use values from previously processed fields, allowing dynamic types and sizes. Repeated fields, byte swapping, padding, ranges, and enum metadata are supported.
+`FieldDef.type` may also be a nested `StructDef` or an expression string. Expressions can use values from previously processed fields, allowing dynamic types, sizes, and repeat counts. Repeated fields, byte swapping, padding, ranges, and enum metadata are supported.
 
 ## Enums And Named Structures
 
@@ -163,7 +163,7 @@ internal implementation details and are omitted from the public method tables.
 | `size` | `InfoSize \| str` | Static size or expression. |
 | `type` | `str \| StructDef` | Primitive, named, or nested field type. |
 | `scale` | `float` | Numeric scale applied to the field. |
-| `repeat` | `int \| None` | Number of repeated field values. |
+| `repeat` | `int \| str \| None` | Number of repeated field values, or an expression that evaluates to the count. |
 | `description` | `str \| None` | Optional field description. |
 | `range_expression` | `str \| None` | Optional value-range expression. |
 | `enum_def_name` | `str \| None` | Name of the associated enum definition. |

{sltcodec-2.1.1 → sltcodec-2.3.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "sltcodec"
-version = "2.1.1"
+version = "2.3.0"
 description = "Decode and encode bytearrays according to struct layout definitions using sltcore."
 readme = "README_pypi.md"
 requires-python = ">=3.12"
 dependencies = [
-    "sltcalc>=0.1.0",
+    "sltcalc>=1.0.0",
     "sltcore>=1.5.0",
 ]
 license = "MIT"

{sltcodec-2.1.1 → sltcodec-2.3.0}/src/sltcodec/codec.py

@@ -136,20 +136,12 @@ def _resolve_info_size(value: InfoSize | str, env: dict[str, Any]) -> InfoSize:
     if isinstance(value, str):
         stleval = SltEval(env)
         resolved_byte = stleval.eval(value)
+        if isinstance(resolved_byte, InfoSize):
+            return resolved_byte
         return InfoSize(resolved_byte, 0)
     return value
 
 
-def _resolve_offset(field_def: FieldDef, env: dict[str, Any]) -> InfoSize:
-    """Resolve a field offset that can be static or expression-based."""
-    return _resolve_info_size(field_def.offset, env)
-
-
-def _resolve_size(field_def: FieldDef, env: dict[str, Any]) -> InfoSize:
-    """Resolve a field size that can be static or expression-based."""
-    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):
@@ -157,9 +149,11 @@ def _resolve_byte_swap(field_def: FieldDef, env: dict[str, Any]) -> bool:
     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 _resolve_repeat(value: int | str | None, env: dict[str, Any]) -> int | None:
+    """Resolve a static or expression-based repeat count."""
+    if isinstance(value, str):
+        return int(SltEval(env).eval(value))
+    return value
 
 
 def _is_padding_field_def(field_def: FieldDef) -> bool:
@@ -168,16 +162,6 @@ def _is_padding_field_def(field_def: FieldDef) -> bool:
             and field_def.type in ["bytes", "bytearray"])
 
 
-def _info_size_to_bits(info_size: InfoSize) -> int:
-    """Convert InfoSize to an absolute bit count."""
-    return info_size.byte * 8 + info_size.bit
-
-
-def _info_size_from_bits(total_bits: int) -> InfoSize:
-    """Create InfoSize from an absolute bit count."""
-    return InfoSize(total_bits >> 3, total_bits & 0x7)
-
-
 def _validate_padding_alignment_bits(padding_alignment_bits: int) -> None:
     """Validate padding alignment as a positive power-of-two bit size."""
     if (isinstance(padding_alignment_bits, bool)
@@ -237,8 +221,8 @@ def _prepare_field_info(
     padding_alignment_bits: int = _DEFAULT_PADDING_ALIGNMENT_BITS,
 ) -> tuple[InfoSize, InfoSize, Info] | None:
     """Resolve a field definition into an offset, size, and info payload."""
-    offset = _resolve_offset(field_def, env)
-    size = _resolve_size(field_def, env)
+    offset = _resolve_info_size(field_def.offset, env)
+    size = _resolve_info_size(field_def.size, env)
     if size.byte == 0 and size.bit == 0:
         return None
 
@@ -305,7 +289,7 @@ def encode_field(
 
     offset, size, info = prepared
     if _resolve_byte_swap(field_def, env):
-        info = _byte_swap_info(info, size)
+        info = info.byte_swap
     required_bytes = (offset + size).bytes
     if len(buf) < required_bytes:
         buf.extend(b"\x00" * (required_bytes - len(buf)))
@@ -351,21 +335,22 @@ def encode(
 
     for field_value in struct_instance.field_instances:
         field_def = field_value.field_def
+        repeat = _resolve_repeat(field_def.repeat, env)
         if _is_padding_field_def(field_def):
             has_padding = True
         value = field_value.value
         if _is_padding_field_def(field_def):
-            padding_size = _resolve_size(field_def, env)
+            padding_size = _resolve_info_size(field_def.size, env)
             value = bytearray(padding_size.bytes)
-        if field_def.repeat is not None and field_def.repeat > 1:
-            current_offset = _resolve_offset(field_def, env)
+        if repeat is not None and repeat > 1:
+            current_offset = _resolve_info_size(field_def.offset, env)
             values = list(value)
 
-            for i in range(field_def.repeat):
+            for i in range(repeat):
                 field_def_repeat = _repeated_field_def(field_def, i,
                                                        current_offset,
                                                        field_def.size)
-                resolved_size = _resolve_size(field_def_repeat, env)
+                resolved_size = _resolve_info_size(field_def_repeat.size, env)
                 encode_field(field_def_repeat, values[i], buf, env, type_dict,
                              padding_alignment_bits)
                 env[field_def_repeat.name] = values[i]
@@ -410,14 +395,14 @@ def decode_field(
     """
     if env is None:
         env = {}
-    offset = _resolve_offset(field_def, env)
-    size = _resolve_size(field_def, env)
+    offset = _resolve_info_size(field_def.offset, env)
+    size = _resolve_info_size(field_def.size, env)
     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)
+        info = info.byte_swap
     resolved_type = _resolve_field_type(field_def.type, type_dict, env)
     nested_value = None
     if isinstance(resolved_type, StructDef):
@@ -526,22 +511,21 @@ def decode(
 
     def append_padding_until(target_offset: InfoSize) -> None:
         nonlocal current_position, padding_index
-        start_bits = _info_size_to_bits(current_position)
-        end_bits = _info_size_to_bits(target_offset)
+        start_bits = current_position.bits
+        end_bits = target_offset.bits
         if end_bits <= start_bits:
             return
 
         chunk_start_bits = start_bits
         while chunk_start_bits < end_bits:
-            chunk_start = _info_size_from_bits(chunk_start_bits)
-            bits_to_boundary = _info_size_to_bits(
-                chunk_start.align_to(padding_alignment_bits))
+            chunk_start = InfoSize(0, chunk_start_bits)
+            bits_to_boundary = chunk_start.align_to(padding_alignment_bits).bits
             chunk_size_bits = bits_to_boundary or padding_alignment_bits
             chunk_end_bits = min(end_bits, chunk_start_bits + chunk_size_bits)
             padding_field_def = FieldDef(
                 name=f"padding[{padding_index}]",
-                offset=_info_size_from_bits(chunk_start_bits),
-                size=_info_size_from_bits(chunk_end_bits - chunk_start_bits),
+                offset=InfoSize(0, chunk_start_bits),
+                size=InfoSize(0, chunk_end_bits - chunk_start_bits),
                 type="bytes",
                 description="Auto-generated padding",
             )
@@ -554,9 +538,10 @@ def decode(
         current_position = target_offset
 
     for field_def in _as_field_defs(struct_def_obj):
+        repeat = _resolve_repeat(field_def.repeat, env)
         # Handle non-repeated fields
-        if field_def.repeat is None or field_def.repeat <= 1:
-            resolved_offset = _resolve_offset(field_def, env)
+        if repeat is None or repeat <= 1:
+            resolved_offset = _resolve_info_size(field_def.offset, env)
             append_padding_until(resolved_offset)
             field_instance = decode_field(field_def, data, env, type_dict,
                                           padding_alignment_bits)
@@ -564,12 +549,12 @@ def decode(
                 env[field_instance.field_def.name] = field_instance.value
                 result.append_field_instance(field_instance)
                 current_position = (resolved_offset +
-                                    _resolve_size(field_def, env))
+                                    _resolve_info_size(field_def.size, env))
             continue
         # Handle repeated fields
-        current_offset = _resolve_offset(field_def, env)
+        current_offset = _resolve_info_size(field_def.offset, env)
         append_padding_until(current_offset)
-        for i in range(field_def.repeat):
+        for i in range(repeat):
             field_def_repeat = _repeated_field_def(field_def, i, current_offset,
                                                    field_def.size)
             field_instance = decode_field(field_def_repeat, data, env,
@@ -579,7 +564,7 @@ def decode(
                 result.append_field_instance(field_instance)
                 actual_size = field_instance.field_def.size
             else:
-                actual_size = _resolve_size(field_def_repeat, env)
+                actual_size = _resolve_info_size(field_def_repeat.size, env)
             if isinstance(current_offset, InfoSize) and isinstance(
                     actual_size, InfoSize):
                 current_offset += actual_size

{sltcodec-2.1.1 → sltcodec-2.3.0}/src/sltcodec/types.py

@@ -98,7 +98,7 @@ class FieldDef:
                                     metadata={"desc": "The type of the field"})
     scale: float = field(default=1.0,
                          metadata={"desc": "The scale of the field"})
-    repeat: int | None = field(
+    repeat: int | str | None = field(
         default=None, metadata={"desc": "The repeat count of the field"})
     description: str | None = field(
         default=None, metadata={"desc": "The description of the field"})
@@ -231,7 +231,7 @@ class FieldDef:
             self.name,
             self._sortable_type(self.type),
             self.scale,
-            -1 if self.repeat is None else self.repeat,
+            self._sortable_repeat(self.repeat),
             "" if self.description is None else self.description,
             "" if self.range_expression is None else self.range_expression,
             "" if self.enum_def_name is None else self.enum_def_name,
@@ -245,6 +245,15 @@ class FieldDef:
             return (0, value.byte, value.bit)
         return (1, value)
 
+    @staticmethod
+    def _sortable_repeat(value: int | str | None) -> tuple[int, int | str]:
+        """Build a comparable key for static or expression repeat counts."""
+        if value is None:
+            return 0, -1
+        if isinstance(value, int):
+            return 1, value
+        return 2, value
+
     @staticmethod
     def _sortable_type(value: str | "StructDef") -> tuple[Any, ...]:
         """Build a comparable key for primitive or nested field types."""

{sltcodec-2.1.1 → sltcodec-2.3.0}/tests/test_codec.py

@@ -7,7 +7,7 @@ from sltcore import InfoSize
 from sltcodec import (PRIMITIVE_TYPES, EnumDef, FieldDef, FieldInstance,
                       StructDef, StructInstance, StructLayout, TypeDict, decode,
                       encode)
-from sltcodec.codec import decode_field
+from sltcodec.codec import _resolve_info_size, decode_field
 
 
 def layout_for(struct_def):
@@ -166,6 +166,38 @@ def test_encode_layout_handles_repeat():
     ]
 
 
+def test_expression_repeat_uses_previous_field_value():
+    """Test that repeat expressions are evaluated against the field env."""
+    seed_field = FieldDef(name="count",
+                          offset=InfoSize(0, 0),
+                          size=InfoSize(1, 0),
+                          type="unsigned int")
+    repeated_field = FieldDef(name="value",
+                              offset=InfoSize(1, 0),
+                              size=InfoSize(1, 0),
+                              type="unsigned int",
+                              repeat="count + 1")
+    struct_def = StructDef(fields=[seed_field, repeated_field])
+
+    encoded = encode(
+        layout_for(struct_def),
+        StructInstance(
+            struct_def=struct_def,
+            field_instances=[
+                FieldInstance(seed_field, 2),
+                FieldInstance(repeated_field, [5, 6, 7]),
+            ],
+        ),
+        bytearray(),
+    )
+
+    assert encoded == bytearray(b"\x02\x05\x06\x07")
+    decoded = decode(layout_for(struct_def), encoded)
+
+    assert [instance.value
+            for instance in decoded.field_instances] == [2, 5, 6, 7]
+
+
 def test_encode_recurses_for_nested_field_types():
     """Test that encoding a field with a nested field type works correctly."""
     child_field_defs = [
@@ -608,6 +640,15 @@ def test_decode_field_sets_actual_size_on_field_instance():
     assert decoded.field_def.size == InfoSize(1, 0)
 
 
+def test_resolve_info_size_returns_expression_info_size_unchanged():
+    """Test that expressions resolving to InfoSize preserve the result."""
+    info_size = InfoSize(2, 3)
+
+    resolved = _resolve_info_size("field_size", {"field_size": info_size})
+
+    assert resolved is info_size
+
+
 def test_decode_struct_instance_size_matches_decoded_layout():
     """Test that decode reports the complete decoded layout size."""
     field_def = FieldDef(name="value",

{sltcodec-2.1.1 → sltcodec-2.3.0}/tests/test_types.py

@@ -39,7 +39,7 @@ def test_field_def_to_json_from_json_round_trip():
                          size=InfoSize(1, 0),
                          type="unsigned int",
                          scale=2.0,
-                         repeat=3,
+                         repeat="count + 1",
                          description="A repeated value",
                          range_expression="0 <= value <= 255",
                          enum_def_name=enum_def.name)
@@ -48,6 +48,7 @@ def test_field_def_to_json_from_json_round_trip():
     restored = FieldDef.from_json(payload)
 
     assert restored == field_def
+    assert restored.repeat == "count + 1"
     assert restored.range_expression == "0 <= value <= 255"
     assert restored.enum_def_name == enum_def.name
     assert restored.to_dict()["enum_def_name"] == "ValueKind"

{sltcodec-2.1.1 → sltcodec-2.3.0}/uv.lock

@@ -65,16 +65,16 @@ wheels = [
 
 [[package]]
 name = "sltcalc"
-version = "0.1.0"
+version = "1.0.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a2/16/2a988c23ac06d05c82e5555e0fb221a8e00786539ebe2826365dcb4f3abe/sltcalc-0.1.0.tar.gz", hash = "sha256:599dc33cf91d18dd257489989065debf5d20d28c299d95f586b371cc86af1b47", size = 10343, upload-time = "2026-08-01T15:06:22.695Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/01/19db81d0e1f1330ab884abf282569b3f05ffe1f2c7b8aff910125295d4be/sltcalc-1.0.0.tar.gz", hash = "sha256:968053bbecc85c30caf5ddfd48962e409c7844ccfc441418d029a4f743030350", size = 10499, upload-time = "2026-08-18T14:38:14.052Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8a/45/c6f7d8074f1fb743e3902d71d8c028e9edeb032834639fdb72df213fdd11/sltcalc-0.1.0-py3-none-any.whl", hash = "sha256:20f06501a583aec62c670e48b4d21eba02a42997461bd8f85640055092d710fa", size = 4783, upload-time = "2026-08-01T15:06:21.411Z" },
+    { url = "https://files.pythonhosted.org/packages/da/77/6d03b5c160ffe42bee2fdabdd46521033794fb02e8975b4da7a1f1c641de/sltcalc-1.0.0-py3-none-any.whl", hash = "sha256:12531fef9633b25e6743c4a41873971c83dffb763590f42e2f1f78accea08088", size = 4824, upload-time = "2026-08-18T14:38:13.247Z" },
 ]
 
 [[package]]
 name = "sltcodec"
-version = "2.1.0"
+version = "2.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "sltcalc" },
@@ -88,7 +88,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
-    { name = "sltcalc", specifier = ">=0.1.0" },
+    { name = "sltcalc", specifier = ">=1.0.0" },
     { name = "sltcore", specifier = ">=1.5.0" },
 ]