sltcore 0.1.0__tar.gz

sltcore-0.1.0/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: fangface-hub

sltcore-0.1.0/.github/workflows/publish_to_pypi.yml

@@ -0,0 +1,25 @@
+name: Publish to PyPI
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+
+      - name: Build wheel
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          packages_dir: dist

sltcore-0.1.0/.github/workflows/publish_to_testpypi.yml

@@ -0,0 +1,26 @@
+name: Publish to TestPyPI
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+
+      - name: Build wheel
+        run: uv build
+
+      - name: Publish to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.TEST_PYPI_API_TOKEN }}
+          repository-url: https://test.pypi.org/legacy/
+          packages_dir: dist

sltcore-0.1.0/.gitignore

@@ -0,0 +1,218 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

sltcore-0.1.0/.python-version

@@ -0,0 +1 @@
+3.14

sltcore-0.1.0/.vscode/launch.json

@@ -0,0 +1,23 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug Pytest (single test)",
+            "type": "python",
+            "request": "launch",
+            "module": "pytest",
+            "args": [
+                "-k", "${input:test_name}"
+            ],
+            "console": "integratedTerminal"
+        }
+    ],
+    "inputs": [
+        {
+            "id": "test_name",
+            "type": "promptString",
+            "description": "Enter pytest -k expression",
+            "default": "test_bits_get_cross_byte"
+        }
+    ]
+}

sltcore-0.1.0/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.defaultInterpreterPath": "${workspaceFolder}/.venv/Scripts/python.exe"
+}

sltcore-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fangface
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sltcore-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: sltcore
+Version: 0.1.0
+Summary: A toolkit for handling structured data layouts and bit-level operations.
+Author: fangface
+License-File: LICENSE
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# StructLayoutToolkitCore
+
+stlcore is a minimal, high‑cohesion core library for bit‑accurate binary slicing. It provides the fundamental primitives (bits_get, bits_set, InfoSize) required to build struct layout analyzers, binary editors, protocol inspectors, and low‑level testing tools. Designed for clarity, correctness, and composability.

sltcore-0.1.0/README.md

@@ -0,0 +1,3 @@
+# StructLayoutToolkitCore
+
+stlcore is a minimal, high‑cohesion core library for bit‑accurate binary slicing. It provides the fundamental primitives (bits_get, bits_set, InfoSize) required to build struct layout analyzers, binary editors, protocol inspectors, and low‑level testing tools. Designed for clarity, correctness, and composability.

sltcore-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "sltcore"
+version = "0.1.0"
+description = "A toolkit for handling structured data layouts and bit-level operations."
+readme = "README.md"
+authors = [
+    { name = "fangface" }
+]
+requires-python = ">=3.12"
+dependencies = []
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["sltcore"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true

sltcore-0.1.0/src/sltcore/bits.py

@@ -0,0 +1,88 @@
+"""Bit-level operations for structured data layouts."""
+from sltcore.types import Info, InfoSize
+
+
+def bits_get(buf: bytearray, offset: InfoSize, size: InfoSize) -> Info:
+    """ Extracts a slice of bits from the given bytearray
+        starting at the specified bit offset and spanning
+        the specified bit size. Returns an Info object containing
+        the extracted raw value and an InfoSize representing 
+        the size of the extracted data.
+    Parameters:
+    - buf (bytearray): The source bytearray to extract bits from.
+    - offset (InfoSize): The bit offset from the start of buf to begin
+      extraction.
+    - size (InfoSize): The number of bits to extract.
+
+    Returns:
+    - Info: An Info object where raw_value contains the extracted bits as an
+      integer, and info_size indicates the size of the extracted data.
+
+    Notes:
+    - The extraction returns the bits as an integer in the raw_value
+      field of the Info object.
+    - Only the necessary byte range is extracted.
+    - Leading and trailing unwanted bits are masked out.
+    - The returned Info object's raw_value is front-packed, meaning
+      the first bit of the extracted range aligns with the most
+      significant bit of raw_value.
+    """
+    # Correct byte span (handles cross-byte bit ranges)
+    need = _required_bytes_for_extraction(offset, size)
+
+    # Extract bytes
+    chunk = buf[offset.byte:offset.byte + need]
+    value = int.from_bytes(chunk, "big")
+
+    # Front-pack
+    shift = (need * 8) - size.bits - offset.bit
+    value >>= shift
+
+    # Mask to exact bit length
+    value &= (1 << size.bits) - 1
+
+    return Info(raw_value=value, info_size=size)
+
+
+def bits_set(buf: bytearray, offset: InfoSize, size: InfoSize,
+             value: int) -> None:
+    """
+    Set a bit slice in `buf` starting at `offset` and spanning `size`.
+    `value` is an integer whose lower `size.bits` bits are written.
+    """
+
+    # Correct byte span
+    need = _required_bytes_for_extraction(offset, size)
+
+    start = offset.byte
+    end = start + need
+
+    # Read existing bytes
+    chunk = int.from_bytes(buf[start:end], "big")
+
+    # Compute shift
+    shift = (need * 8) - size.bits - offset.bit
+
+    # Build mask
+    mask = ((1 << size.bits) - 1) << shift
+
+    # Clear target field and insert new value
+    chunk = (chunk & ~mask) | ((value << shift) & mask)
+
+    # Write back
+    buf[start:end] = chunk.to_bytes(need, "big")
+
+
+def _required_bytes_for_extraction(offset: InfoSize, size: InfoSize) -> int:
+    """
+    Calculates the number of bytes required to extract a bit slice
+    starting at the given offset and spanning the given size.
+
+    Parameters:
+    - offset (InfoSize): The bit offset from the start of the buffer.
+    - size (InfoSize): The number of bits to extract.
+
+    Returns:
+    - int: The number of bytes required to extract the specified bit slice.
+    """
+    return (offset.bit + size.bits + 7) // 8

sltcore-0.1.0/src/sltcore/types.py

@@ -0,0 +1,158 @@
+"""Type definitions for structured data layouts and bit-level operations."""
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class InfoSize:
+    """Represents a size in bytes and bits."""
+    byte: int = 0
+    bit: int = 0
+
+    def __post_init__(self):
+        """Ensures that the bit count is normalized to be less than 8,
+           and adjusts the byte count accordingly."""
+        extra_bytes, new_bits = divmod(self.bit, 8)
+        object.__setattr__(self, "byte", self.byte + extra_bytes)
+        object.__setattr__(self, "bit", new_bits)
+
+    @property
+    def bits(self) -> int:
+        """Returns the total size in bits."""
+        return self.byte * 8 + self.bit
+
+    @property
+    def bytes(self) -> int:
+        """Returns the total size in bytes,
+           rounding up if there are leftover bits."""
+        return (self.bits + 7) // 8  # round up
+
+    @property
+    def hex_digits(self) -> int:
+        """Returns the number of hexadecimal digits
+           needed to represent the size in bits."""
+        return self.bits // 4
+
+    @property
+    def mask(self) -> int:
+        """Returns a bitmask corresponding to the size in bits."""
+        return (1 << self.bits) - 1
+
+    def __add__(self, other: "InfoSize") -> "InfoSize":
+        """ Adds two InfoSize instances together, returning a new InfoSize
+            with the combined byte and bit counts, normalized to ensure
+            the bit count is less than 8."""
+        return InfoSize(self.byte + other.byte, self.bit + other.bit)
+
+    def __sub__(self, other: "InfoSize") -> "InfoSize":
+        """ Subtracts one InfoSize from another, returning a new InfoSize
+            with the resulting byte and bit counts, normalized to ensure
+            the bit count is less than 8. Raises ValueError if the result
+            would be negative."""
+        total_bits = self.bits - other.bits
+        if total_bits < 0:
+            raise ValueError("InfoSize subtraction resulted in negative size")
+        return InfoSize(0, total_bits)
+
+
+@dataclass(frozen=True)
+class Info:
+    """Represents a slice of bits extracted from a bytearray,
+       along with its size information."""
+    raw_value: int
+    info_size: InfoSize
+
+    @property
+    def to_unsigned_int(self) -> int:
+        """Returns the extracted bits as an unsigned integer."""
+        return self.raw_value
+
+    @property
+    def to_signed_int(self) -> int:
+        """Returns the extracted bits as a signed integer."""
+        raw = self.to_unsigned_int
+        bits = self.info_size.bits
+        sign_bit = 1 << (bits - 1)
+        return (raw ^ sign_bit) - sign_bit
+
+    @property
+    def to_hex(self) -> str:
+        """Returns the extracted bits as a hexadecimal string."""
+        return hex(self.to_unsigned_int)
+
+    @property
+    def to_bytes(self) -> bytes:
+        """Returns the extracted bits as a bytes object."""
+        value = self.to_unsigned_int
+        byte_len = self.info_size.bytes
+        return value.to_bytes(byte_len, byteorder="big")
+
+    @property
+    def to_bool(self) -> bool:
+        """Returns the extracted bits as a boolean value."""
+        return bool(self.to_unsigned_int)
+
+    @property
+    def to_float(self) -> float:
+        """Returns the extracted bits as a float."""
+        raw_int = self.to_unsigned_int
+        return _float_from_bits(raw_int, self.info_size.bits)
+
+
+def _float_from_bits(raw: int, bits: int) -> float:
+    """Converts a raw integer representation of a float
+       to a Python float, based on the specified bit size.
+       Supports 16, 32, and 64 bits.
+    """
+    if bits == 16:
+        """IEEE754 half-precision (16bit) → float32"""
+        s = (raw >> 15) & 0x0001
+        e = (raw >> 10) & 0x001F
+        f = raw & 0x03FF
+
+        if e == 0:
+            if f == 0:
+                return (-1)**s * 0.0
+            return (-1)**s * (f / 2**10) * 2**(-14)
+        elif e == 31:
+            if f == 0:
+                return float('inf') if s == 0 else float('-inf')
+            return float('nan')
+        else:
+            return (-1)**s * (1 + f / 2**10) * 2**(e - 15)
+    elif bits == 32:
+        # IEEE754 single precision
+        # High-speed version without using struct
+        s = (raw >> 31) & 0x1
+
+        e = (raw >> 23) & 0xFF
+        f = raw & 0x7FFFFF
+
+        if e == 0:
+            return (-1)**s * (f / 2**23) * 2**(-126)
+        elif e == 255:
+            if f == 0:
+                return float('-inf') if s else float('inf')
+            return float('nan')
+        else:
+            return (-1)**s * (1 + f / 2**23) * 2**(e - 127)
+
+    elif bits == 64:
+        # IEEE754 double precision
+        s = (raw >> 63) & 0x1
+        e = (raw >> 52) & 0x7FF
+        f = raw & 0xFFFFFFFFFFFFF
+
+        if e == 0:
+            return (-1)**s * (f / 2**52) * 2**(-1022)
+        elif e == 2047:
+            if f == 0:
+                return float('-inf') if s else float('inf')
+            return float('nan')
+        else:
+            return (-1)**s * (1 + f / 2**52) * 2**(e - 1023)
+
+    else:
+        raise ValueError(''.join([
+            f"Unsupported bit size for float conversion: {bits}. ",
+            "Only 16, 32, and 64 are supported."
+        ]))

sltcore-0.1.0/tests/test_bits.py

@@ -0,0 +1,87 @@
+"""Tests for sltcore.bits."""
+import pytest
+
+from sltcore.bits import _required_bytes_for_extraction, bits_get, bits_set
+from sltcore.types import InfoSize
+
+
+def test_required_bytes_for_extraction():
+    """Test the _required_bytes_for_extraction function
+       with various scenarios."""
+    # offset.bit + size.bits < 8 → 1 byte
+    assert _required_bytes_for_extraction(InfoSize(0, 0), InfoSize(0, 7)) == 1
+
+    # Exactly 8 → 1 byte
+    assert _required_bytes_for_extraction(InfoSize(0, 0), InfoSize(0, 8)) == 1
+
+    # 9 → 2 bytes
+    assert _required_bytes_for_extraction(InfoSize(0, 0), InfoSize(0, 9)) == 2
+
+    # With offset.bit
+    assert _required_bytes_for_extraction(InfoSize(0, 3), InfoSize(0, 5)) == 1
+    assert _required_bytes_for_extraction(InfoSize(0, 6), InfoSize(0, 4)) == 2
+
+
+def test_bits_get_single_byte():
+    """Test bits_get with a single byte buffer."""
+    buf = bytearray([0b11010110])  # 214
+    offset = InfoSize(0, 2)  # bit offset = 2
+    size = InfoSize(0, 4)  # 4 bits
+
+    info = bits_get(buf, offset, size)
+    assert info.raw_value == 0b0101  # 214 = 11010110 → offset=2 → 0101
+
+
+def test_bits_get_cross_byte():
+    """Test bits_get with a buffer that spans multiple bytes."""
+    buf = bytearray([0b11110000, 0b00001111])
+    offset = InfoSize(0, 6)  # From bit 6 of byte0
+    size = InfoSize(0, 6)  # Extract 6 bits (spans into byte1)
+
+    info = bits_get(buf, offset, size)
+    # 11110000 00001111
+    #       ^^ ^^^^
+    assert info.raw_value == 0b000000  # front-packed
+
+
+def test_bits_set_single_byte():
+    """Test bits_set with a single byte buffer."""
+    buf = bytearray([0b11110000])
+    offset = InfoSize(0, 2)
+    size = InfoSize(0, 4)
+
+    bits_set(buf, offset, size, 0b0011)
+    # 11110000 → offset=2 → bits to change: 1100 → write 0011
+    assert buf[0] == 0b11001100
+
+
+def test_bits_set_cross_byte():
+    """Test bits_set with a buffer that spans multiple bytes."""
+    buf = bytearray([0b11110000, 0b00001111])
+    offset = InfoSize(0, 6)
+    size = InfoSize(0, 6)
+
+    bits_set(buf, offset, size, 0b101010)
+
+    # Comparing with a manually calculated mask is fine, but
+    # confirming it matches by re-extracting with bits_get
+    # is more abstract and robust
+    info = bits_get(buf, offset, size)
+
+    assert info.raw_value == 0b101010
+
+
+def test_bits_get_set_roundtrip():
+    """Test that bits_get followed by bits_set returns the original value."""
+    buf = bytearray([0xAA, 0xBB, 0xCC, 0xDD])
+
+    offset = InfoSize(0, 5)
+    size = InfoSize(0, 10)
+
+    # Verify original value is restored through get -> set cycle
+    original = bits_get(buf, offset, size).raw_value
+
+    bits_set(buf, offset, size, original)
+    after = bits_get(buf, offset, size).raw_value
+
+    assert original == after

sltcore-0.1.0/tests/test_types.py

@@ -0,0 +1,108 @@
+"""Tests for sltcore.types."""
+import pytest
+
+from sltcore.types import Info, InfoSize
+
+
+def test_infosize_normalization():
+    """Test InfoSize normalization of bits to bytes."""
+    # 10 bits should become 1 byte and 2 bits
+    size = InfoSize(0, 10)
+    assert size.byte == 1
+    assert size.bit == 2
+
+    # 16 bits should become 2 bytes and 0 bits
+    size = InfoSize(1, 8)
+    assert size.byte == 2
+    assert size.bit == 0
+
+
+def test_infosize_bits_property():
+    """Test the bits property of InfoSize."""
+    size = InfoSize(2, 3)
+    assert size.bits == 19  # 2 * 8 + 3
+
+
+def test_infosize_bytes_property():
+    """Test the bytes property of InfoSize (rounding up)."""
+    assert InfoSize(1, 0).bytes == 1
+    assert InfoSize(1, 1).bytes == 2
+    assert InfoSize(1, 7).bytes == 2
+
+
+def test_infosize_hex_digits():
+    """Test the hex_digits property."""
+    assert InfoSize(1, 0).hex_digits == 2  # 8 bits / 4
+    assert InfoSize(2, 0).hex_digits == 4  # 16 bits / 4
+
+
+def test_infosize_mask():
+    """Test the mask property."""
+    assert InfoSize(0, 3).mask == 0b111
+    assert InfoSize(1, 0).mask == 0xFF
+
+
+def test_infosize_arithmetic():
+    """Test addition and subtraction of InfoSize."""
+    s1 = InfoSize(1, 2)
+    s2 = InfoSize(0, 7)
+
+    # Addition
+    added = s1 + s2
+    assert added.bits == s1.bits + s2.bits
+
+    # Subtraction
+    subbed = s1 - s2
+    assert subbed.bits == s1.bits - s2.bits
+
+    with pytest.raises(ValueError):
+        s2 - s1
+
+
+def test_info_to_signed_int():
+    """Test signed integer conversion."""
+    # 8-bit signed
+    info = Info(0xFF, InfoSize(1, 0))
+    assert info.to_signed_int == -1
+
+    info = Info(0x7F, InfoSize(1, 0))
+    assert info.to_signed_int == 127
+
+    # 4-bit signed
+    info = Info(0b1111, InfoSize(0, 4))
+    assert info.to_signed_int == -1
+
+    info = Info(0b0111, InfoSize(0, 4))
+    assert info.to_signed_int == 7
+
+
+def test_info_to_bytes():
+    """Test conversion to bytes object."""
+    info = Info(0xAABB, InfoSize(2, 0))
+    assert info.to_bytes == b'\xaa\xbb'
+
+
+def test_info_to_float_16():
+    """Test 16-bit float conversion."""
+    # 0.0
+    assert Info(0x0000, InfoSize(0, 16)).to_float == 0.0
+    # 1.0 (sign=0, exp=15, fraction=0) -> 0 01111 0000000000 -> 0x3C00
+    assert Info(0x3C00, InfoSize(0, 16)).to_float == 1.0
+
+
+def test_info_to_float_32():
+    """Test 32-bit float conversion."""
+    # 1.0 (sign=0, exp=127, fraction=0) -> 0x3F800000
+    assert Info(0x3F800000, InfoSize(0, 32)).to_float == 1.0
+
+
+def test_info_to_float_64():
+    """Test 64-bit float conversion."""
+    # 1.0 (sign=0, exp=1023, fraction=0) -> 0x3FF0000000000000
+    assert Info(0x3FF0000000000000, InfoSize(0, 64)).to_float == 1.0
+
+
+def test_info_to_float_invalid_size():
+    """Test that invalid bit sizes for float conversion raise ValueError."""
+    with pytest.raises(ValueError):
+        Info(0, InfoSize(0, 10)).to_float

sltcore-0.1.0/uv.lock

@@ -0,0 +1,79 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "sltcore"
+version = "0.1.0"
+source = { editable = "." }
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+
+[package.metadata.requires-dev]
+dev = [{ name = "pytest", specifier = ">=9.1.1" }]