sltcodec 2.1.1__tar.gz → 2.2.0__tar.gz

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

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

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

@@ -1,11 +1,11 @@
 [project]
 name = "sltcodec"
-version = "2.1.1"
+version = "2.2.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.2.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,27 +149,12 @@ 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 _is_padding_field_def(field_def: FieldDef) -> bool:
     """Check whether a field definition represents padding."""
     return (field_def.name.startswith("padding[")
             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 +214,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 +282,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)))
@@ -355,17 +332,17 @@ def encode(
             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)
+            current_offset = _resolve_info_size(field_def.offset, env)
             values = list(value)
 
             for i in range(field_def.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 +387,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 +503,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",
             )
@@ -556,7 +532,7 @@ def decode(
     for field_def in _as_field_defs(struct_def_obj):
         # Handle non-repeated fields
         if field_def.repeat is None or field_def.repeat <= 1:
-            resolved_offset = _resolve_offset(field_def, env)
+            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,10 +540,10 @@ 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):
             field_def_repeat = _repeated_field_def(field_def, i, current_offset,
@@ -579,7 +555,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.2.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):
@@ -608,6 +608,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.2.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.1.1"
 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" },
 ]