sltcodec 2.4.1__tar.gz → 2.5.1__tar.gz

{sltcodec-2.4.1 → sltcodec-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sltcodec
-Version: 2.4.1
+Version: 2.5.1
 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
@@ -12,7 +12,7 @@ License-File: LICENSE
 Keywords: byte,deserialization,layout,serialization,struct
 Requires-Python: >=3.12
 Requires-Dist: sltcalc>=1.0.0
-Requires-Dist: sltcore>=1.5.0
+Requires-Dist: sltcore>=1.6.0
 Description-Content-Type: text/markdown
 
 # StructLayoutToolkitCodec
@@ -63,6 +63,26 @@ encoded = encode(layout, instance, bytearray())
 decoded = decode(layout, encoded)
 ```
 
+## Progress Callbacks
+
+`encode` and `decode` accept an optional `progress_callback` argument. The
+callback is typed as `ProgressCallback` and receives a `float` progress value
+from `0.0` to `1.0`.
+
+Progress is calculated for top-level fields as `(offset + size) / total_size`.
+Nested structure encode/decode calls pass `None` internally, so recursive
+fields do not emit additional callback events.
+
+```python
+from sltcodec import ProgressCallback, decode
+
+def update_progress(progress: float) -> None:
+    progress_bar.value = progress
+
+progress_callback: ProgressCallback = update_progress
+decoded = decode(layout, encoded, progress_callback=progress_callback)
+```
+
 `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
@@ -138,6 +158,7 @@ The following symbols are exported by `sltcodec.__all__` in this order:
 | Symbol | Description |
 | --- | --- |
 | `PRIMITIVE_TYPES` | Set of built-in field type names supported by the codec. |
+| `ProgressCallback` | Callable type alias for encode/decode progress updates. |
 | `EnumDef` | Immutable definition of an enumeration. |
 | `EnumDict` | Dictionary-like container for `EnumDef` objects. |
 | `FieldDef` | Immutable definition of one structured field. |
@@ -310,15 +331,16 @@ beginning with `_` are internal helpers and are not part of the public API.
 | Definition | Signature | Description |
 | --- | --- | --- |
 | `PRIMITIVE_TYPES` | `set[str]` | Built-in field type names. |
+| `ProgressCallback` | `Callable[[float], None]` | Progress callback type for top-level encode/decode updates. |
 | `save_struct_layout` | `(struct_layout, path) -> None` | Save a layout to a JSON file. |
 | `load_struct_layout` | `(path) -> StructLayout` | Load a layout from a JSON file. |
 | `save_struct_def_dict` | `(path, struct_def_dict) -> None` | Save a structure-definition dictionary through the layout format. |
 | `load_struct_def_dict` | `(path) -> dict[str, StructDef]` | Load a structure-definition dictionary. |
 | `save_enum_def_dict` | `(path, enum_def_dict) -> None` | Save an enum-definition dictionary through the layout format. |
 | `load_enum_def_dict` | `(path) -> dict[str, EnumDef]` | Load an enum-definition dictionary. |
-| `encode` | `(struct_layout, struct_instance, buf, padding_alignment_bits=32) -> bytearray` | Encode a complete structure. |
+| `encode` | `(struct_layout, struct_instance, buf, padding_alignment_bits=32, progress_callback=None) -> bytearray` | Encode a complete structure. |
 | `decode_field` | `(field_def, data, env=None, type_dict=None, padding_alignment_bits=32) -> FieldInstance \| None` | Decode one field. |
-| `decode` | `(struct_layout, data, padding_alignment_bits=32) -> StructInstance` | Decode a complete structure. |
+| `decode` | `(struct_layout, data, padding_alignment_bits=32, progress_callback=None) -> StructInstance` | Decode a complete structure. |
 
 `save_struct_def_dict`, `load_struct_def_dict`, `save_enum_def_dict`, and
 `load_enum_def_dict` are available from `sltcodec.codec` for dictionary-level

{sltcodec-2.4.1 → sltcodec-2.5.1}/README.md

@@ -57,6 +57,22 @@ definition is resolved by `struct_layout.struct_def_name` from
 `struct_layout.type_dict.struct_dict`; enum definitions are resolved from the
 same `TypeDict`.
 
+`encode` and `decode` accept an optional `progress_callback` argument typed as
+`ProgressCallback`. The callback receives a `float` progress value calculated
+from the top-level field extent: `(offset + size) / total_size`. Recursive
+nested structure calls pass `None`, so callers receive progress updates only
+for the top-level encode or decode operation.
+
+```python
+from sltcodec import ProgressCallback, decode
+
+def update_progress(progress: float) -> None:
+    progress_bar.value = progress
+
+progress_callback: ProgressCallback = update_progress
+decoded = decode(layout, data, progress_callback=progress_callback)
+```
+
 Layout persistence uses the explicit names `save_struct_layout` and
 `load_struct_layout`. The former `save_type_dict` and `load_type_dict` API is
 not part of the current public interface.

{sltcodec-2.4.1 → sltcodec-2.5.1}/README_pypi.md

@@ -46,6 +46,26 @@ encoded = encode(layout, instance, bytearray())
 decoded = decode(layout, encoded)
 ```
 
+## Progress Callbacks
+
+`encode` and `decode` accept an optional `progress_callback` argument. The
+callback is typed as `ProgressCallback` and receives a `float` progress value
+from `0.0` to `1.0`.
+
+Progress is calculated for top-level fields as `(offset + size) / total_size`.
+Nested structure encode/decode calls pass `None` internally, so recursive
+fields do not emit additional callback events.
+
+```python
+from sltcodec import ProgressCallback, decode
+
+def update_progress(progress: float) -> None:
+    progress_bar.value = progress
+
+progress_callback: ProgressCallback = update_progress
+decoded = decode(layout, encoded, progress_callback=progress_callback)
+```
+
 `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
@@ -121,6 +141,7 @@ The following symbols are exported by `sltcodec.__all__` in this order:
 | Symbol | Description |
 | --- | --- |
 | `PRIMITIVE_TYPES` | Set of built-in field type names supported by the codec. |
+| `ProgressCallback` | Callable type alias for encode/decode progress updates. |
 | `EnumDef` | Immutable definition of an enumeration. |
 | `EnumDict` | Dictionary-like container for `EnumDef` objects. |
 | `FieldDef` | Immutable definition of one structured field. |
@@ -293,15 +314,16 @@ beginning with `_` are internal helpers and are not part of the public API.
 | Definition | Signature | Description |
 | --- | --- | --- |
 | `PRIMITIVE_TYPES` | `set[str]` | Built-in field type names. |
+| `ProgressCallback` | `Callable[[float], None]` | Progress callback type for top-level encode/decode updates. |
 | `save_struct_layout` | `(struct_layout, path) -> None` | Save a layout to a JSON file. |
 | `load_struct_layout` | `(path) -> StructLayout` | Load a layout from a JSON file. |
 | `save_struct_def_dict` | `(path, struct_def_dict) -> None` | Save a structure-definition dictionary through the layout format. |
 | `load_struct_def_dict` | `(path) -> dict[str, StructDef]` | Load a structure-definition dictionary. |
 | `save_enum_def_dict` | `(path, enum_def_dict) -> None` | Save an enum-definition dictionary through the layout format. |
 | `load_enum_def_dict` | `(path) -> dict[str, EnumDef]` | Load an enum-definition dictionary. |
-| `encode` | `(struct_layout, struct_instance, buf, padding_alignment_bits=32) -> bytearray` | Encode a complete structure. |
+| `encode` | `(struct_layout, struct_instance, buf, padding_alignment_bits=32, progress_callback=None) -> bytearray` | Encode a complete structure. |
 | `decode_field` | `(field_def, data, env=None, type_dict=None, padding_alignment_bits=32) -> FieldInstance \| None` | Decode one field. |
-| `decode` | `(struct_layout, data, padding_alignment_bits=32) -> StructInstance` | Decode a complete structure. |
+| `decode` | `(struct_layout, data, padding_alignment_bits=32, progress_callback=None) -> StructInstance` | Decode a complete structure. |
 
 `save_struct_def_dict`, `load_struct_def_dict`, `save_enum_def_dict`, and
 `load_enum_def_dict` are available from `sltcodec.codec` for dictionary-level

{sltcodec-2.4.1 → sltcodec-2.5.1}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "sltcodec"
-version = "2.4.1"
+version = "2.5.1"
 description = "Decode and encode bytearrays according to struct layout definitions using sltcore."
 readme = "README_pypi.md"
 requires-python = ">=3.12"
 dependencies = [
     "sltcalc>=1.0.0",
-    "sltcore>=1.5.0",
+    "sltcore>=1.6.0",
 ]
 license = "MIT"
 license-files = ["LICENSE"]

{sltcodec-2.4.1 → sltcodec-2.5.1}/src/sltcodec/__init__.py

@@ -1,10 +1,11 @@
-from .codec import (PRIMITIVE_TYPES, decode, encode, load_struct_layout,
-                    save_struct_layout)
+from .codec import (PRIMITIVE_TYPES, ProgressCallback, decode, encode,
+                    load_struct_layout, save_struct_layout)
 from .types import (EnumDef, EnumDict, FieldDef, FieldInstance, StructDef,
                     StructDict, StructInstance, StructLayout, TypeDict)
 
 __all__ = [
     "PRIMITIVE_TYPES",
+    "ProgressCallback",
     "EnumDef",
     "EnumDict",
     "FieldDef",

{sltcodec-2.4.1 → sltcodec-2.5.1}/src/sltcodec/codec.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import json
 import re
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 from sltcalc import SltEval
 from sltcore import Info, InfoSize, bits_get, bits_set
@@ -27,6 +27,58 @@ _PRIMITIVE_TYPES = PRIMITIVE_TYPES
 
 _DEFAULT_PADDING_ALIGNMENT_BITS = 32
 
+ProgressCallback = Callable[[float], None]
+
+
+def _notify_progress(progress_callback: ProgressCallback | None,
+                     offset: InfoSize, size: InfoSize, total_bits: int) -> None:
+    """Notify caller of top-level encode/decode progress."""
+    if progress_callback is None or total_bits <= 0:
+        return
+    progress = min((offset + size).bits / total_bits, 1.0)
+    progress_callback(progress)
+
+
+def _estimate_encode_total_bits(struct_instance: StructInstance,
+                                initial_size_bits: int) -> int:
+    """Estimate encoded top-level extent before mutating the output buffer."""
+    env: dict[str, Any] = {}
+    total_bits = max(struct_instance.size.bits, initial_size_bits)
+
+    for field_value in struct_instance.field_instances:
+        field_def = field_value.field_def
+        repeat_until_end = field_def.repeat == "end"
+        repeat = _resolve_repeat(field_def.repeat, env)
+        value = field_value.value
+        if _is_padding_field_def(field_def):
+            padding_size = _resolve_info_size(field_def.size, env)
+            value = bytearray(padding_size.bytes)
+        if repeat_until_end:
+            repeat_values = list(value)
+            repeat = len(repeat_values)
+        if repeat is not None and repeat > 1:
+            current_offset = _resolve_info_size(field_def.offset, env)
+            values = repeat_values if repeat_until_end else list(value)
+
+            for i in range(repeat):
+                field_def_repeat = _repeated_field_def(field_def, i,
+                                                       current_offset,
+                                                       field_def.size)
+                resolved_size = _resolve_info_size(field_def_repeat.size, env)
+                total_bits = max(total_bits,
+                                 (current_offset + resolved_size).bits)
+                env[field_def_repeat.name] = values[i]
+                if isinstance(current_offset, InfoSize):
+                    current_offset += resolved_size
+            continue
+
+        resolved_offset = _resolve_info_size(field_def.offset, env)
+        resolved_size = _resolve_info_size(field_def.size, env)
+        total_bits = max(total_bits, (resolved_offset + resolved_size).bits)
+        env[field_def.name] = value
+
+    return total_bits
+
 
 def _as_field_defs(struct_def: StructDef | list[FieldDef]) -> list[FieldDef]:
     """Normalize StructDef/list inputs to a list of field definitions."""
@@ -253,12 +305,11 @@ def _prepare_field_info(
             raise TypeError(
                 "Nested StructDef fields must be encoded with StructInstance "
                 "values")
-        nested_bytes = encode(_layout_for_struct_def(value.struct_def,
-                                                     type_dict,
-                                                     name=field_def.name),
-                              value,
-                              bytearray(),
-                              padding_alignment_bits=padding_alignment_bits)
+        nested_bytes = encode(
+            _layout_for_struct_def(value.struct_def,
+                                   type_dict,
+                                   name=field_def.name), value, bytearray(),
+            padding_alignment_bits, None)
         info = Info.from_bytes(bytes(nested_bytes), size, scale=field_def.scale)
     else:
         info = _encode_primitive(resolved_type, value, size, field_def.scale)
@@ -323,6 +374,7 @@ def encode(
     struct_instance: StructInstance,
     buf: bytearray,
     padding_alignment_bits: int = _DEFAULT_PADDING_ALIGNMENT_BITS,
+    progress_callback: ProgressCallback | None = None,
 ) -> bytearray:
     """Encode decode() result into a bytearray.
 
@@ -337,6 +389,9 @@ def encode(
         The base bytearray instance to write into.
     padding_alignment_bits : int, optional
         The padding alignment boundary in bits, by default 32.
+    progress_callback : Callable[[float], None] | None, optional
+        Called after each top-level field is encoded with progress in the
+        range 0.0 to 1.0. Nested recursive encodes are skipped.
 
     Returns
     -------
@@ -353,6 +408,7 @@ def encode(
     type_dict = struct_layout.type_dict
     env: dict[str, Any] = {}
     has_padding = False
+    total_bits = _estimate_encode_total_bits(struct_instance, len(buf) * 8)
 
     for field_value in struct_instance.field_instances:
         field_def = field_value.field_def
@@ -378,13 +434,19 @@ def encode(
                 resolved_size = _resolve_info_size(field_def_repeat.size, env)
                 encode_field(field_def_repeat, values[i], buf, env, type_dict,
                              padding_alignment_bits)
+                _notify_progress(progress_callback, current_offset,
+                                 resolved_size, total_bits)
                 env[field_def_repeat.name] = values[i]
                 if isinstance(current_offset, InfoSize):
                     current_offset += resolved_size
             continue
 
+        resolved_offset = _resolve_info_size(field_def.offset, env)
+        resolved_size = _resolve_info_size(field_def.size, env)
         encode_field(field_def, value, buf, env, type_dict,
                      padding_alignment_bits)
+        _notify_progress(progress_callback, resolved_offset, resolved_size,
+                         total_bits)
         env[field_def.name] = value
 
     if has_padding and struct_instance.size.bytes > len(buf):
@@ -437,8 +499,12 @@ def decode_field(
         nested_data = bytearray(info.to_bytes)
         if _struct_def_has_dynamic_extent(resolved_type) and offset.bit == 0:
             nested_data = bytearray(data[offset.byte:])
-        nested_value = decode(nested_layout, nested_data,
-                              padding_alignment_bits)
+        nested_value = decode(
+            nested_layout,
+            nested_data,
+            padding_alignment_bits,
+            None,
+        )
         actual_size = nested_value.size
     else:
         actual_size = info.info_size
@@ -507,6 +573,7 @@ def decode(
     struct_layout: StructLayout,
     data: bytearray | bytes,
     padding_alignment_bits: int = _DEFAULT_PADDING_ALIGNMENT_BITS,
+    progress_callback: ProgressCallback | None = None,
 ) -> StructInstance:
     """Decode a bytearray into field values according to a layout.
 
@@ -519,6 +586,9 @@ def decode(
         The data to decode.
     padding_alignment_bits : int, optional
         The padding alignment boundary in bits, by default 32.
+    progress_callback : Callable[[float], None] | None, optional
+        Called after each top-level field is decoded with progress in the
+        range 0.0 to 1.0. Nested recursive decodes are skipped.
     Returns
     -------
     StructInstance
@@ -604,6 +674,8 @@ def decode(
             if field_instance is not None:
                 env[field_instance.field_def.name] = field_instance.value
                 result.append_field_instance(field_instance)
+                _notify_progress(progress_callback, resolved_offset,
+                                 field_instance.field_def.size, data_bits)
                 current_position = (resolved_offset +
                                     _resolve_info_size(field_def.size, env))
             continue
@@ -643,6 +715,8 @@ def decode(
                     env[field_instance.field_def.name] = field_instance.value
                     result.append_field_instance(field_instance)
                     actual_size = field_instance.field_def.size
+                    _notify_progress(progress_callback, current_offset,
+                                     actual_size, data_bits)
                 else:
                     actual_size = resolved_size
 
@@ -688,6 +762,8 @@ def decode(
                 env[field_instance.field_def.name] = field_instance.value
                 result.append_field_instance(field_instance)
                 actual_size = field_instance.field_def.size
+                _notify_progress(progress_callback, current_offset, actual_size,
+                                 data_bits)
             else:
                 actual_size = _resolve_info_size(field_def_repeat.size, env)
             if isinstance(current_offset, InfoSize) and isinstance(

{sltcodec-2.4.1 → sltcodec-2.5.1}/tests/test_codec.py

@@ -5,8 +5,8 @@ import pytest
 from sltcore import InfoSize
 
 from sltcodec import (PRIMITIVE_TYPES, EnumDef, FieldDef, FieldInstance,
-                      StructDef, StructInstance, StructLayout, TypeDict, decode,
-                      encode)
+                      ProgressCallback, StructDef, StructInstance, StructLayout,
+                      TypeDict, decode, encode)
 from sltcodec.codec import _resolve_info_size, decode_field
 
 
@@ -42,6 +42,13 @@ def test_primitive_types_are_exposed_at_package_root():
     }
 
 
+def test_progress_callback_type_is_exposed_at_package_root():
+    """Test that ProgressCallback is exposed for external consumers."""
+    progress_callback: ProgressCallback = lambda progress: None
+
+    assert callable(progress_callback)
+
+
 def test_encode_and_decode_round_trip():
     """Test that encoding and then decoding returns the original data."""
     struct_def = [
@@ -75,6 +82,44 @@ def test_encode_and_decode_round_trip():
                   bytearray()) == encoded
 
 
+def test_encode_and_decode_progress_callbacks_use_top_level_progress():
+    """Test progress callbacks report top-level encoded/decoded progress."""
+    fields = [
+        FieldDef(name="head",
+                 offset=InfoSize(0, 0),
+                 size=InfoSize(1, 0),
+                 type="unsigned int"),
+        FieldDef(name="tail",
+                 offset=InfoSize(1, 0),
+                 size=InfoSize(1, 0),
+                 type="unsigned int"),
+    ]
+    struct_def = StructDef(fields=fields)
+    struct_instance = StructInstance(
+        struct_def=struct_def,
+        field_instances=[
+            FieldInstance(fields[0], 0x12),
+            FieldInstance(fields[1], 0x34),
+        ],
+    )
+    encode_progress = []
+    decode_progress = []
+
+    encoded = encode(layout_for(struct_def),
+                     struct_instance,
+                     bytearray(),
+                     progress_callback=encode_progress.append)
+    decoded = decode(layout_for(struct_def),
+                     encoded,
+                     progress_callback=decode_progress.append)
+
+    assert encoded == bytearray(b"\x12\x34")
+    assert [field_instance.value
+            for field_instance in decoded.field_instances] == [0x12, 0x34]
+    assert encode_progress == [0.5, 1.0]
+    assert decode_progress == [0.5, 1.0]
+
+
 def test_decode_accepts_struct_layout():
     """Decode a legacy field list via a StructLayout bundle."""
     struct_def = StructDef(
@@ -166,6 +211,33 @@ def test_encode_layout_handles_repeat():
     ]
 
 
+def test_progress_callbacks_use_repeated_top_level_field_extent():
+    """Test repeated fields report progress against the encoded extent."""
+    field_def = FieldDef(name="value",
+                         offset=InfoSize(0, 0),
+                         size=InfoSize(1, 0),
+                         type="unsigned int",
+                         repeat=2)
+    struct_def = StructDef(fields=[field_def])
+    struct_instance = StructInstance(
+        struct_def=struct_def,
+        field_instances=[FieldInstance(field_def, [1, 2])],
+    )
+    encode_progress = []
+    decode_progress = []
+
+    encoded = encode(layout_for(struct_def),
+                     struct_instance,
+                     bytearray(),
+                     progress_callback=encode_progress.append)
+    decode(layout_for([field_def]),
+           encoded,
+           progress_callback=decode_progress.append)
+
+    assert encode_progress == [0.5, 1.0]
+    assert decode_progress == [0.5, 1.0]
+
+
 def test_expression_repeat_uses_previous_field_value():
     """Test that repeat expressions are evaluated against the field env."""
     seed_field = FieldDef(name="count",
@@ -363,6 +435,49 @@ def test_encode_recurses_for_nested_field_types():
             ]
 
 
+def test_progress_callbacks_skip_nested_recursive_fields():
+    """Test nested recursive encode/decode calls do not report progress."""
+    child_field_defs = [
+        FieldDef(name="left",
+                 offset=InfoSize(0, 0),
+                 size=InfoSize(1, 0),
+                 type="unsigned int"),
+        FieldDef(name="right",
+                 offset=InfoSize(1, 0),
+                 size=InfoSize(1, 0),
+                 type="unsigned int"),
+    ]
+    parent_field_def = FieldDef(name="pair",
+                                offset=InfoSize(0, 0),
+                                size=InfoSize(2, 0),
+                                type=StructDef(fields=child_field_defs))
+    child_instance = StructInstance(
+        struct_def=StructDef(fields=child_field_defs),
+        field_instances=[
+            FieldInstance(child_field_defs[0], 3),
+            FieldInstance(child_field_defs[1], 4),
+        ],
+    )
+    parent_struct_def = StructDef(fields=[parent_field_def])
+    parent_instance = StructInstance(
+        struct_def=parent_struct_def,
+        field_instances=[FieldInstance(parent_field_def, child_instance)],
+    )
+    encode_progress = []
+    decode_progress = []
+
+    encoded = encode(layout_for(parent_struct_def),
+                     parent_instance,
+                     bytearray(),
+                     progress_callback=encode_progress.append)
+    decode(layout_for(parent_struct_def),
+           encoded,
+           progress_callback=decode_progress.append)
+
+    assert encode_progress == [1.0]
+    assert decode_progress == [1.0]
+
+
 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",

{sltcodec-2.4.1 → sltcodec-2.5.1}/uv.lock

@@ -74,7 +74,7 @@ wheels = [
 
 [[package]]
 name = "sltcodec"
-version = "2.3.0"
+version = "2.5.0"
 source = { editable = "." }
 dependencies = [
     { name = "sltcalc" },
@@ -89,7 +89,7 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "sltcalc", specifier = ">=1.0.0" },
-    { name = "sltcore", specifier = ">=1.5.0" },
+    { name = "sltcore", specifier = ">=1.6.0" },
 ]
 
 [package.metadata.requires-dev]
@@ -97,9 +97,9 @@ dev = [{ name = "pytest", specifier = ">=9.1.1" }]
 
 [[package]]
 name = "sltcore"
-version = "1.5.0"
+version = "1.6.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f0/8d/692c45c8d007b71b627fb4c53d90ecb5ea1168d892dc14e5ad3ecae0b8d3/sltcore-1.5.0.tar.gz", hash = "sha256:26280f743947f22e31e334fd793679f3aad19367bbf9bfddb6215123d7bd2d18", size = 18050, upload-time = "2026-08-11T13:14:51.241Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/32/01/89dc1e6c0429710d7329a3dab769e1c9f8b148ab1592c69df53592dbf8c2/sltcore-1.6.0.tar.gz", hash = "sha256:872ada7183ae5f065a40dc44ee5062bb7cc781a4758b56cd740bb77e9e1fdc6e", size = 20648, upload-time = "2026-08-21T14:49:00.72Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0f/ca/38d1ab93a871ba9e60e500b93f8c48fdb2be3308a8ab08e6ea0a73e516c2/sltcore-1.5.0-py3-none-any.whl", hash = "sha256:148611c58329fcadc793b38a973412144c073a036516baf9430b3170e71180c4", size = 10458, upload-time = "2026-08-11T13:14:50.295Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/b5/d35ac0fcab3a16efdc80814a59d1788a962e8ac8d8005dc6c18435baf655/sltcore-1.6.0-py3-none-any.whl", hash = "sha256:d3bf525275fda9159b97c2663d14bb73b56b70869e07f0d79727883bcbedd8d8", size = 12707, upload-time = "2026-08-21T14:48:59.749Z" },
 ]