sltcodec 2.1.0__tar.gz → 2.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sltcodec
-Version: 2.1.0
+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
 
@@ -63,6 +63,12 @@ encoded = encode(layout, instance, bytearray())
 decoded = decode(layout, encoded)
 ```
 
+`decode` returns a `StructInstance` whose `size` is the actual end of the
+decoded layout. `decode_field` stores the actual decoded size in the returned
+`FieldInstance.field_def.size`. For nested `StructDef` fields, that size comes
+from the nested `StructInstance.size`; for repeated fields, the next element's
+offset advances by the actual size of the previous element.
+
 ## Field Types
 
 The public `PRIMITIVE_TYPES` set contains:
@@ -78,7 +84,6 @@ The public `PRIMITIVE_TYPES` set contains:
 Store named structures in `TypeDict.struct_dict` and enums in `TypeDict.enum_dict`. A field refers to an enum by its `enum_def_name`; the codec resolves it through `StructLayout.type_dict`.
 
 ```python
-| `__lt__(other)` | Compare enum definitions using their serialized ordering. |
 from sltcore import InfoSize
 from sltcodec import EnumDef, FieldDef, StructDef, StructLayout, TypeDict, decode
 
@@ -102,7 +107,6 @@ layout = StructLayout(
 )
 
 decoded = decode(layout, bytearray(b"\x01"))
-| `__lt__(other)` | Compare field definitions using their serialized ordering. |
 assert decoded.field_instances[0].enum_item == ("NG", 1)
 ```
 
@@ -117,7 +121,6 @@ from sltcodec import load_struct_layout, save_struct_layout
 path = Path("struct_layout.json")
 save_struct_layout(layout, path)
 loaded = load_struct_layout(path)
-| `__lt__(other)` | Compare field instances using field-definition order. |
 assert loaded == layout
 ```
 
@@ -185,7 +188,6 @@ internal implementation details and are omitted from the public method tables.
 
 | Method | Description |
 | --- | --- |
-| `split_repeat(index, offset=None, size=None)` | Create one field definition from a repeated field. |
 | `to_dict()` | Convert the definition to a JSON-compatible dictionary. |
 | `to_json()` | Convert the definition to a JSON string. |
 | `from_dict(data)` | Create a `FieldDef` from a dictionary. |

{sltcodec-2.1.0 → sltcodec-2.2.0}/README.md

@@ -74,6 +74,12 @@ updated_field = field_instance.with_value(
 )
 ```
 
+Decoded sizes reflect the actual data consumed. `decode` sets
+`StructInstance.size` to the end of the decoded layout, and `decode_field`
+stores the actual size in `FieldInstance.field_def.size`. For nested structures,
+the nested `StructInstance.size` is used; repeated fields advance each next
+offset by the preceding element's actual size.
+
 ## Versioning And Release
 
 Version bump scripts are provided for patch, minor, and major releases:

{sltcodec-2.1.0 → sltcodec-2.2.0}/README_pypi.md

@@ -46,6 +46,12 @@ encoded = encode(layout, instance, bytearray())
 decoded = decode(layout, encoded)
 ```
 
+`decode` returns a `StructInstance` whose `size` is the actual end of the
+decoded layout. `decode_field` stores the actual decoded size in the returned
+`FieldInstance.field_def.size`. For nested `StructDef` fields, that size comes
+from the nested `StructInstance.size`; for repeated fields, the next element's
+offset advances by the actual size of the previous element.
+
 ## Field Types
 
 The public `PRIMITIVE_TYPES` set contains:
@@ -61,7 +67,6 @@ The public `PRIMITIVE_TYPES` set contains:
 Store named structures in `TypeDict.struct_dict` and enums in `TypeDict.enum_dict`. A field refers to an enum by its `enum_def_name`; the codec resolves it through `StructLayout.type_dict`.
 
 ```python
-| `__lt__(other)` | Compare enum definitions using their serialized ordering. |
 from sltcore import InfoSize
 from sltcodec import EnumDef, FieldDef, StructDef, StructLayout, TypeDict, decode
 
@@ -85,7 +90,6 @@ layout = StructLayout(
 )
 
 decoded = decode(layout, bytearray(b"\x01"))
-| `__lt__(other)` | Compare field definitions using their serialized ordering. |
 assert decoded.field_instances[0].enum_item == ("NG", 1)
 ```
 
@@ -100,7 +104,6 @@ from sltcodec import load_struct_layout, save_struct_layout
 path = Path("struct_layout.json")
 save_struct_layout(layout, path)
 loaded = load_struct_layout(path)
-| `__lt__(other)` | Compare field instances using field-definition order. |
 assert loaded == layout
 ```
 
@@ -168,7 +171,6 @@ internal implementation details and are omitted from the public method tables.
 
 | Method | Description |
 | --- | --- |
-| `split_repeat(index, offset=None, size=None)` | Create one field definition from a repeated field. |
 | `to_dict()` | Convert the definition to a JSON-compatible dictionary. |
 | `to_json()` | Convert the definition to a JSON string. |
 | `from_dict(data)` | Create a `FieldDef` from a dictionary. |

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

@@ -1,11 +1,11 @@
 [project]
 name = "sltcodec"
-version = "2.1.0"
+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.0 → sltcodec-2.2.0}/src/sltcodec/codec.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import json
+import re
 from pathlib import Path
 from typing import Any
 
@@ -135,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):
@@ -156,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)
@@ -236,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
 
@@ -259,17 +237,30 @@ def _prepare_field_info(
     return offset, size, info
 
 
-def _split_repeated_field(field_def: FieldDef,
-                          index: int,
-                          env: dict[str, Any],
-                          offset: InfoSize | str | None = None) -> FieldDef:
-    """Create a repeated-field definition with resolved offset and size."""
-    resolved_offset = (_resolve_offset(field_def, env)
-                       if offset is None else offset)
-    resolved_size = _resolve_size(field_def, env)
-    return field_def.split_repeat(index,
-                                  offset=resolved_offset,
-                                  size=resolved_size)
+def _repeated_field_def(field_def: FieldDef, index: int, offset: InfoSize,
+                        size: InfoSize | str) -> FieldDef:
+    """Create a resolved field definition for one repeated value."""
+    repeated_name = f"{field_def.name}[{index}]"
+
+    def replace_name(value: Any) -> Any:
+        if not isinstance(value, str):
+            return value
+        pattern = (rf"(?<![0-9A-Za-z_]){re.escape(field_def.name)}"
+                   rf"(?![0-9A-Za-z_])")
+        return re.sub(pattern, repeated_name, value)
+
+    return FieldDef(
+        name=repeated_name,
+        offset=offset,
+        size=size,
+        type=replace_name(field_def.type),
+        scale=field_def.scale,
+        repeat=None,
+        description=field_def.description,
+        range_expression=replace_name(field_def.range_expression),
+        enum_def_name=field_def.enum_def_name,
+        byte_swap=replace_name(field_def.byte_swap),
+    )
 
 
 def encode_field(
@@ -291,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)))
@@ -341,21 +332,21 @@ 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)
-            resolved_size = _resolve_size(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 = _split_repeated_field(
-                    field_def, i, env, current_offset)
+                field_def_repeat = _repeated_field_def(field_def, i,
+                                                       current_offset,
+                                                       field_def.size)
+                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]
-                if isinstance(current_offset, InfoSize) and isinstance(
-                        resolved_size, InfoSize):
+                if isinstance(current_offset, InfoSize):
                     current_offset += resolved_size
             continue
 
@@ -396,19 +387,29 @@ 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):
+        nested_layout = _layout_for_struct_def(resolved_type,
+                                               type_dict,
+                                               name=field_def.name)
+        nested_value = decode(nested_layout, bytearray(info.to_bytes),
+                              padding_alignment_bits)
+        actual_size = nested_value.size
+    else:
+        actual_size = info.info_size
     resolved_field_def = FieldDef(
         name=field_def.name,
         offset=offset,
-        size=size,
+        size=actual_size,
         type=resolved_type,
         scale=field_def.scale,
         repeat=field_def.repeat,
@@ -418,13 +419,9 @@ def decode_field(
         byte_swap=byte_swap,
     )
     if isinstance(resolved_type, StructDef):
-        nested_layout = _layout_for_struct_def(resolved_type,
-                                               type_dict,
-                                               name=field_def.name)
         return FieldInstance(
             field_def=resolved_field_def,
-            value=decode(nested_layout, bytearray(info.to_bytes),
-                         padding_alignment_bits),
+            value=nested_value,
         )
     if resolved_type == "bool":
         return FieldInstance.from_value(resolved_field_def,
@@ -506,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",
             )
@@ -536,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)
@@ -544,23 +540,36 @@ 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)
-        resolved_size = _resolve_size(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 = _split_repeated_field(field_def, i, env,
-                                                     current_offset)
+            field_def_repeat = _repeated_field_def(field_def, i, current_offset,
+                                                   field_def.size)
             field_instance = decode_field(field_def_repeat, data, env,
                                           type_dict, padding_alignment_bits)
             if field_instance is not None:
                 env[field_instance.field_def.name] = field_instance.value
                 result.append_field_instance(field_instance)
-                current_position = current_offset + resolved_size
-            current_offset += resolved_size
-
+                actual_size = field_instance.field_def.size
+            else:
+                actual_size = _resolve_info_size(field_def_repeat.size, env)
+            if isinstance(current_offset, InfoSize) and isinstance(
+                    actual_size, InfoSize):
+                current_offset += actual_size
+                current_position = current_offset
+
+    actual_size = InfoSize(0, 0)
+    for field_instance in result.field_instances:
+        field_def = field_instance.field_def
+        if (isinstance(field_def.offset, InfoSize)
+                and isinstance(field_def.size, InfoSize)):
+            field_end = field_def.offset + field_def.size
+            if field_end > actual_size:
+                actual_size = field_end
+    result.size = actual_size
     append_padding_until(result.size)
 
     return result

{sltcodec-2.1.0 → sltcodec-2.2.0}/src/sltcodec/types.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 
 import json
-import re
 from collections.abc import MutableMapping
 from dataclasses import dataclass, field
 from functools import total_ordering
@@ -112,46 +111,6 @@ class FieldDef:
         default=False,
         metadata={"desc": "Whether to reverse the field byte order"})
 
-    def split_repeat(self,
-                     index: int,
-                     offset: InfoSize | str | None = None,
-                     size: InfoSize | str | None = None) -> "FieldDef":
-        """Create a single repeated-field definition for the given index."""
-        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)
-        split_byte_swap = self._replace_name_in_expression(
-            self.byte_swap, 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,
-                        range_expression=split_range_expression,
-                        enum_def_name=self.enum_def_name,
-                        byte_swap=split_byte_swap)
-
-    @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."""
         if not isinstance(other, FieldDef):

{sltcodec-2.1.0 → 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):
@@ -215,6 +215,24 @@ def test_encode_recurses_for_nested_field_types():
             ]
 
 
+def test_decode_field_uses_nested_struct_instance_size():
+    """Test that nested decoding determines the field's actual size."""
+    child_field_def = FieldDef(name="value",
+                               offset=InfoSize(0, 0),
+                               size=InfoSize(1, 0),
+                               type="unsigned int")
+    parent_field_def = FieldDef(name="nested",
+                                offset=InfoSize(0, 0),
+                                size=InfoSize(4, 0),
+                                type=StructDef(fields=[child_field_def]))
+
+    decoded = decode_field(parent_field_def, bytearray(b"\x7f"))
+
+    assert decoded is not None
+    assert decoded.field_def.size == InfoSize(1, 0)
+    assert decoded.value.size == InfoSize(1, 0)
+
+
 def test_repeated_field_preserves_description():
     """Test that repeated fields keep their description on decoded entries."""
     field_def = FieldDef(name="value",
@@ -572,6 +590,46 @@ def test_decode_field_returns_field_instance():
     assert decoded == FieldInstance(field_def=field_def, value=127)
 
 
+def test_decode_field_sets_actual_size_on_field_instance():
+    """Test that decode_field stores the resolved Info size."""
+    field_def = FieldDef(name="value",
+                         offset="offset",
+                         size="field_size",
+                         type="unsigned int")
+
+    decoded = decode_field(field_def,
+                           bytearray(b"\x7f"),
+                           env={
+                               "offset": 0,
+                               "field_size": 1
+                           })
+
+    assert decoded is not None
+    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",
+                         offset=InfoSize(2, 0),
+                         size=InfoSize(2, 0),
+                         type="unsigned int")
+    data = bytearray(b"\x00\x00\x7f\x00")
+
+    decoded = decode(layout_for(StructDef(fields=[field_def])), data)
+
+    assert decoded.size == InfoSize(len(data), 0)
+
+
 def test_encode_padding_fields_use_zero_value_and_extend_to_struct_size():
     """Test that padding fields are zeroed and trailing bytes are padded.
 

{sltcodec-2.1.0 → sltcodec-2.2.0}/tests/test_types.py

@@ -13,23 +13,6 @@ class ValueKind(Enum):
     B = 2
 
 
-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",

{sltcodec-2.1.0 → 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 = "1.3.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" },
 ]