sltcore 0.2.1__tar.gz → 0.2.3__tar.gz

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

@@ -0,0 +1,43 @@
+name: Publish to PyPI
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Extract version from pyproject.toml
+        id: version
+        run: |
+          VERSION=$(grep -m1 '^version = "' pyproject.toml | sed -E 's/^version = "([^"]+)"$/\1/')
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "tag=v$VERSION" >> "$GITHUB_OUTPUT"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+
+      - name: Build distribution
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          packages-dir: dist
+
+      - name: Create GitHub release and upload artifacts
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ steps.version.outputs.tag }}
+          name: ${{ steps.version.outputs.tag }}
+          generate_release_notes: true
+          files: |
+            dist/*.tar.gz
+            dist/*.whl

{sltcore-0.2.1 → sltcore-0.2.3}/.github/workflows/publish_to_testpypi.yml

@@ -2,8 +2,6 @@ name: Publish to TestPyPI
 
 on:
   workflow_dispatch:
-  release:
-    types: [published]
 
 jobs:
   build-and-publish:
@@ -23,4 +21,4 @@ jobs:
         with:
           password: ${{ secrets.TEST_PYPI_API_TOKEN }}
           repository-url: https://test.pypi.org/legacy/
-          packages_dir: dist
+          packages-dir: dist

sltcore-0.2.3/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: sltcore
+Version: 0.2.3
+Summary: A toolkit for handling structured data layouts and bit-level operations.
+Project-URL: Homepage, https://github.com/fangface-hub/StructLayoutToolkitCore
+Project-URL: Documentation, https://readthedocs.org
+Project-URL: Repository, https://github.com/fangface-hub/StructLayoutToolkitCore
+Project-URL: Issues, https://github.com/fangface-hub/StructLayoutToolkitCore/issues
+Author: fangface
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bit,byte,data,deserialization,layout,serialization,struct
+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.
+
+## What You Can Do After Installing sltcore
+
+sltcore provides a minimal and consistent bit-level abstraction layer for building higher‑level tools such as binary editors, protocol analyzers, and structured layout systems.
+
+After installing the package, you can:
+
+- Extract arbitrary bit ranges from a bytearray using bits_get
+- Write arbitrary bit ranges into a bytearray using bits_set
+- Represent sizes and offsets uniformly with InfoSize
+- Build structured binary layouts on top of a stable bit‑operation core
+
+## Quick Examples: bits_get / bits_set
+
+```python
+
+from sltcore import InfoSize, Info , bits_get, bits_set
+
+buf = bytearray(b"\x12\x34\x56\x78")
+
+# Extract 4 bits at offset (1 byte, 0 bits)
+value = bits_get(buf, InfoSize(1, 0), InfoSize(0, 4))
+print(value.to_hex)  # 0x3
+
+# Write 5 bits at offset (2 bytes, 3 bits)
+bits_set(buf, InfoSize(2, 3), InfoSize(0, 5), 0b10101)
+print(buf.hex()) # 12345578
+
+```
+
+## sltcore.InfoSize
+
+InfoSize is a type that represents offsets and sizes in a unified way.
+It supports addition and subtraction, and stores both byte and bit components.
+
+It is used for both offset and size, allowing consistent structural layout definitions.
+
+- __Field List__
+
+  | Field | Type | Description |
+  | --- | --- | --- |
+  | byte | int | the byte size |
+  | bit  | int | the bit size (0–7)<br> always normalized so that bit < 8 |
+
+- __Property List__
+
+  | Property | Type | Description |
+  | --- | --- | --- |
+  | bits | int | Total bit length.<br> This property converts the stored byte and bit components into a single bit count using the formula byte * 8 + bit |
+  | bytes | int | Total byte length.<br> This property converts the combined bit length (byte * 8 + bit) into a byte count using integer division (bits // 8) |
+  | hex_digits | int | Number of hexadecimal digits needed to represent the field.<br>Since one hex digit corresponds to 4 bits, the value is calculated as ceil(bits / 4) |
+  | mask | int | Bitmask for the field size.<br>It produces a mask that covers exactly bits bits, using the formula (1 << bits) - 1.<br>This mask is typically used for extracting or normalizing values. |
+
+## sltcore.Info
+
+Info stores an InfoSize and a raw integer value.
+
+This allows higher‑level code to treat extracted fields as structured units rather than plain integers.
+
+- __Field List__
+
+  | Field | Type | Description |
+  | --- | --- | --- |
+  | raw_value | int | The internal integer representation of the field.<br>It is obtained by converting the corresponding bytes into an integer and applying the size mask so that the value fits within the bit width specified by InfoSize. |
+  | info_size | InfoSize | Size descriptor for this value.<br>It provides the byte and bit length of the field and determines how the raw_value is masked, extracted, and written back into the byte sequence. |
+
+- __Classmethod List__
+
+  | Classmethod | Description |
+  | --- | --- |
+  | from_int | Creates an Info instance from an integer value, ensuring that the value fits within the specified size by applying a bitmask. |
+  | from_bytes | Creates an Info instance from a bytes object, ensuring that the value fits within the specified size by applying a bitmask. |
+  | from_bytearray | Creates an Info instance from a bytearray, ensuring that the value fits within the specified size by applying a bitmask. |
+  | from_float | Creates an Info instance from a float value, converting it to its raw bit representation based on the specified size. |
+
+  Example: Creating an Info from a float value
+  
+  ```python
+  size = InfoSize(byte=0, bit=32)   # 32-bit float
+  info = Info.from_float(3.14, size)
+  
+  print(info.raw_value)     # IEEE754 raw bits (e.g., 0x4048F5C3)
+  print(info.info_size.bits)  # 32
+  ```
+
+- __Property List__
+
+  | Property | Type | Description |
+  | --- | --- | --- |
+  | to_unsigned_int | int | Returns the extracted bits as an unsigned integer. |
+  | to_signed_int | int | Returns the extracted bits as a signed integer. |
+  | to_hex | str | Returns the extracted bits as a hexadecimal string. |
+  | to_bytes | bytes | Returns the extracted bits as a bytes object. |
+  | to_bool | bool | Returns the extracted bits as a boolean value. |
+  | to_float | float | Returns the extracted bits as a float. |
+  | byte_swap | Info | Returns a new Info instance with the byte order reversed. |
+
+## sltcore.bits_get
+
+bits_get extracts a field from a bytearray using an offset and size, and returns an Info object.
+
+Input:
+
+- bytearray buffer
+- InfoSize offset
+- InfoSize size
+
+Output:
+
+- Info containing the extracted value and its size
+
+## sltcore.bits_set
+
+bits_set writes a value into a bytearray at the specified offset.
+
+Input:
+
+- bytearray buffer
+- InfoSize offset
+- Info value (which includes its size)
+
+The function masks and replaces the target bit range inside the buffer.
+
+## Documentation
+
+For detailed usage, examples, and parameter descriptions, refer to the docstrings via:
+
+python
+
+- help(sltcore.InfoSize)
+- help(sltcore.Info)
+- help(sltcore.bits_get)
+- help(sltcore.bits_set)

sltcore-0.2.3/README.md

@@ -0,0 +1,136 @@
+# 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.
+
+## What You Can Do After Installing sltcore
+
+sltcore provides a minimal and consistent bit-level abstraction layer for building higher‑level tools such as binary editors, protocol analyzers, and structured layout systems.
+
+After installing the package, you can:
+
+- Extract arbitrary bit ranges from a bytearray using bits_get
+- Write arbitrary bit ranges into a bytearray using bits_set
+- Represent sizes and offsets uniformly with InfoSize
+- Build structured binary layouts on top of a stable bit‑operation core
+
+## Quick Examples: bits_get / bits_set
+
+```python
+
+from sltcore import InfoSize, Info , bits_get, bits_set
+
+buf = bytearray(b"\x12\x34\x56\x78")
+
+# Extract 4 bits at offset (1 byte, 0 bits)
+value = bits_get(buf, InfoSize(1, 0), InfoSize(0, 4))
+print(value.to_hex)  # 0x3
+
+# Write 5 bits at offset (2 bytes, 3 bits)
+bits_set(buf, InfoSize(2, 3), InfoSize(0, 5), 0b10101)
+print(buf.hex()) # 12345578
+
+```
+
+## sltcore.InfoSize
+
+InfoSize is a type that represents offsets and sizes in a unified way.
+It supports addition and subtraction, and stores both byte and bit components.
+
+It is used for both offset and size, allowing consistent structural layout definitions.
+
+- __Field List__
+
+  | Field | Type | Description |
+  | --- | --- | --- |
+  | byte | int | the byte size |
+  | bit  | int | the bit size (0–7)<br> always normalized so that bit < 8 |
+
+- __Property List__
+
+  | Property | Type | Description |
+  | --- | --- | --- |
+  | bits | int | Total bit length.<br> This property converts the stored byte and bit components into a single bit count using the formula byte * 8 + bit |
+  | bytes | int | Total byte length.<br> This property converts the combined bit length (byte * 8 + bit) into a byte count using integer division (bits // 8) |
+  | hex_digits | int | Number of hexadecimal digits needed to represent the field.<br>Since one hex digit corresponds to 4 bits, the value is calculated as ceil(bits / 4) |
+  | mask | int | Bitmask for the field size.<br>It produces a mask that covers exactly bits bits, using the formula (1 << bits) - 1.<br>This mask is typically used for extracting or normalizing values. |
+
+## sltcore.Info
+
+Info stores an InfoSize and a raw integer value.
+
+This allows higher‑level code to treat extracted fields as structured units rather than plain integers.
+
+- __Field List__
+
+  | Field | Type | Description |
+  | --- | --- | --- |
+  | raw_value | int | The internal integer representation of the field.<br>It is obtained by converting the corresponding bytes into an integer and applying the size mask so that the value fits within the bit width specified by InfoSize. |
+  | info_size | InfoSize | Size descriptor for this value.<br>It provides the byte and bit length of the field and determines how the raw_value is masked, extracted, and written back into the byte sequence. |
+
+- __Classmethod List__
+
+  | Classmethod | Description |
+  | --- | --- |
+  | from_int | Creates an Info instance from an integer value, ensuring that the value fits within the specified size by applying a bitmask. |
+  | from_bytes | Creates an Info instance from a bytes object, ensuring that the value fits within the specified size by applying a bitmask. |
+  | from_bytearray | Creates an Info instance from a bytearray, ensuring that the value fits within the specified size by applying a bitmask. |
+  | from_float | Creates an Info instance from a float value, converting it to its raw bit representation based on the specified size. |
+
+  Example: Creating an Info from a float value
+  
+  ```python
+  size = InfoSize(byte=0, bit=32)   # 32-bit float
+  info = Info.from_float(3.14, size)
+  
+  print(info.raw_value)     # IEEE754 raw bits (e.g., 0x4048F5C3)
+  print(info.info_size.bits)  # 32
+  ```
+
+- __Property List__
+
+  | Property | Type | Description |
+  | --- | --- | --- |
+  | to_unsigned_int | int | Returns the extracted bits as an unsigned integer. |
+  | to_signed_int | int | Returns the extracted bits as a signed integer. |
+  | to_hex | str | Returns the extracted bits as a hexadecimal string. |
+  | to_bytes | bytes | Returns the extracted bits as a bytes object. |
+  | to_bool | bool | Returns the extracted bits as a boolean value. |
+  | to_float | float | Returns the extracted bits as a float. |
+  | byte_swap | Info | Returns a new Info instance with the byte order reversed. |
+
+## sltcore.bits_get
+
+bits_get extracts a field from a bytearray using an offset and size, and returns an Info object.
+
+Input:
+
+- bytearray buffer
+- InfoSize offset
+- InfoSize size
+
+Output:
+
+- Info containing the extracted value and its size
+
+## sltcore.bits_set
+
+bits_set writes a value into a bytearray at the specified offset.
+
+Input:
+
+- bytearray buffer
+- InfoSize offset
+- Info value (which includes its size)
+
+The function masks and replaces the target bit range inside the buffer.
+
+## Documentation
+
+For detailed usage, examples, and parameter descriptions, refer to the docstrings via:
+
+python
+
+- help(sltcore.InfoSize)
+- help(sltcore.Info)
+- help(sltcore.bits_get)
+- help(sltcore.bits_set)

{sltcore-0.2.1 → sltcore-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sltcore"
-version = "0.2.1"
+version = "0.2.3"
 license = "MIT"
 license-files = ["LICENSE"]
 description = "A toolkit for handling structured data layouts and bit-level operations."

sltcore-0.2.3/src/sltcore/__init__.py

@@ -0,0 +1,4 @@
+from .bits import bits_get, bits_set
+from .types import Info, InfoSize
+
+__all__ = ["bits_get", "bits_set", "InfoSize", "Info"]

{sltcore-0.2.1 → sltcore-0.2.3}/src/sltcore/types.py

@@ -1,37 +1,52 @@
 """Type definitions for structured data layouts and bit-level operations."""
 import math
-from dataclasses import dataclass
+import struct
+from dataclasses import dataclass, field
+
+
+def _has_struct_half():
+    """Checks if the current Python environment supports
+       half-precision (16-bit) floats in the struct module."""
+    try:
+        struct.pack(">e", 1.0)
+        return True
+    except struct.error:
+        return False
+
+
+HAS_STRUCT_HALF = _has_struct_half()  # ← 一度だけ実行
 
 
 @dataclass(frozen=True)
 class InfoSize:
     """Represents a size in bytes and bits."""
-    byte: int = 0
-    bit: int = 0
+    byte: int = field(default=0, metadata={"desc": "byte size"})
+    bit: int = field(default=0, metadata={"desc": "bit size"})
 
     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)
+        extra_bytes = self.bit >> 3
+        new_bits = self.bit & 7
         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
+        return ((self.byte << 3) | 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
+        return ((self.bits + 7) >> 3)  # 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
+        return (self.bits >> 2)
 
     @property
     def mask(self) -> int:
@@ -59,8 +74,9 @@ class InfoSize:
 class Info:
     """Represents a slice of bits extracted from a bytearray,
        along with its size information."""
-    raw_value: int
-    info_size: InfoSize
+    raw_value: int = field(default=0, metadata={"desc": "raw integer value"})
+    info_size: InfoSize = field(default_factory=InfoSize,
+                                metadata={"desc": "size information"})
 
     @classmethod
     def from_int(cls, value: int, size: InfoSize):
@@ -135,65 +151,52 @@ def _float_from_bits(raw: int, bits: int) -> 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}. ",
+    if bits == 64:
+        return struct.unpack('>d', struct.pack('>Q', raw))[0]
+    if bits == 32:
+        # Use struct to unpack the integer as a float
+        return struct.unpack('>f', struct.pack('>I', raw))[0]
+    if bits != 16:
+        raise ValueError("".join([
+            f"Unsupported float bit size: {bits}. ",
             "Only 16, 32, and 64 are supported."
         ]))
+    if HAS_STRUCT_HALF:
+        # Use struct to unpack the integer as a half-precision float
+        return struct.unpack('>e', struct.pack('>H', raw))[0]
+    # 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)
+    if e == 31:
+        if f == 0:
+            return float('inf') if s == 0 else float('-inf')
+        return float('nan')
+    return (-1)**s * (1 + f / 2**10) * 2**(e - 15)
 
 
 def _float_to_bits(value: float, bits: int) -> int:
     """Converts a Python float to its raw integer representation
        based on the specified bit size. Supports 16, 32, and 64 bits.
     """
+    if bits == 64:
+        return struct.unpack('>Q', struct.pack('>d', value))[0]
+    if bits == 32:
+        # Use struct to pack the float into bytes and then unpack as an integer
+        return struct.unpack('>I', struct.pack('>f', value))[0]
+    if bits != 16:
+        raise ValueError("".join([
+            f"Unsupported float bit size: {bits}. ",
+            "Only 16, 32, and 64 are supported."
+        ]))
+    if HAS_STRUCT_HALF:
+        # Use struct to pack the float into bytes and then unpack as an integer
+        return struct.unpack('>H', struct.pack('>e', value))[0]
     # Determine the sign and absolute value
     # Use math.copysign to correctly detect negative zero
     sign = 1 if math.copysign(1.0, value) < 0 else 0
@@ -205,40 +208,16 @@ def _float_to_bits(value: float, bits: int) -> int:
 
     # NaN / Inf
     if math.isnan(value):
-        if bits == 16:
-            return 0x7E00
-        if bits == 32:
-            return 0x7FC00000
-        if bits == 64:
-            return 0x7FF8000000000000
+        return 0x7E00
 
     # Handle infinity
     if math.isinf(value):
-        if bits == 16:
-            return (sign << 15) | 0x7C00
-        if bits == 32:
-            return (sign << 31) | 0x7F800000
-        if bits == 64:
-            return (sign << 63) | 0x7FF0000000000000
+        return (sign << 15) | 0x7C00
 
     # Compute exponent and mantissa
     e = int(math.floor(math.log(v, 2)))
     mant = v / (2**e) - 1.0
 
-    if bits == 16:
-        exp = e + 15
-        frac = int(mant * (2**10))
-        return (sign << 15) | (exp << 10) | frac
-
-    elif bits == 32:
-        exp = e + 127
-        frac = int(mant * (2**23))
-        return (sign << 31) | (exp << 23) | frac
-
-    elif bits == 64:
-        exp = e + 1023
-        frac = int(mant * (2**52))
-        return (sign << 63) | (exp << 52) | frac
-
-    else:
-        raise ValueError(f"Unsupported float bit size: {bits}")
+    exp = e + 15
+    frac = int(mant * (2**10))
+    return (sign << 15) | (exp << 10) | frac

{sltcore-0.2.1 → sltcore-0.2.3}/uv.lock

@@ -65,7 +65,7 @@ wheels = [
 
 [[package]]
 name = "sltcore"
-version = "0.1.0"
+version = "0.2.2"
 source = { editable = "." }
 
 [package.dev-dependencies]

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

@@ -1,25 +0,0 @@
-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.2.1/PKG-INFO

@@ -1,106 +0,0 @@
-Metadata-Version: 2.4
-Name: sltcore
-Version: 0.2.1
-Summary: A toolkit for handling structured data layouts and bit-level operations.
-Project-URL: Homepage, https://github.com/fangface-hub/StructLayoutToolkitCore
-Project-URL: Documentation, https://readthedocs.org
-Project-URL: Repository, https://github.com/fangface-hub/StructLayoutToolkitCore
-Project-URL: Issues, https://github.com/fangface-hub/StructLayoutToolkitCore/issues
-Author: fangface
-License-Expression: MIT
-License-File: LICENSE
-Keywords: bit,byte,data,deserialization,layout,serialization,struct
-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.
-
-## What You Can Do After Installing sltcore
-
-sltcore provides a minimal and consistent bit-level abstraction layer for building higher‑level tools such as binary editors, protocol analyzers, and structured layout systems.
-
-After installing the package, you can:
-
-- Extract arbitrary bit ranges from a bytearray using bits_get
-- Write arbitrary bit ranges into a bytearray using bits_set
-- Represent sizes and offsets uniformly with InfoSize
-- Build structured binary layouts on top of a stable bit‑operation core
-
-## Quick Examples: bits_get / bits_set
-
-```python
-
-from sltcore.types import InfoSize, Info
-from sltcore.bits import bits_get, bits_set
-
-buf = bytearray(b"\x12\x34\x56\x78")
-
-# Extract 4 bits at offset (1 byte, 0 bits)
-value = bits_get(buf, InfoSize(1, 0), InfoSize(0, 4))
-print(value.to_hex)  # 0x3
-
-# Write 5 bits at offset (2 bytes, 3 bits)
-bits_set(buf, InfoSize(2, 3), InfoSize(0, 5), 0b10101)
-print(buf.hex()) # 12345578
-
-```
-
-## sltcore.type.InfoSize
-
-InfoSize is a type that represents offsets and sizes in a unified way.
-It supports addition and subtraction, and stores both byte and bit components.
-
-- byte: the byte component
-- bit: the bit component (0–7)
-
-always normalized so that bit < 8
-
-It is used for both offset and size, allowing consistent structural layout definitions.
-
-## sltcore.type.Info
-
-Info stores an InfoSize and a raw integer value.
-
-- The value returned by bits_get is an Info instance
-- The value passed to bits_set is also an Info instance
-
-This allows higher‑level code to treat extracted fields as structured units rather than plain integers.
-
-## sltcore.bits.bits_get
-
-bits_get extracts a field from a bytearray using an offset and size, and returns an Info object.
-
-Input:
-
-- bytearray buffer
-- InfoSize offset
-- InfoSize size
-
-Output:
-
-- Info containing the extracted value and its size
-
-## sltcore.bits.bits_set
-
-bits_set writes a value into a bytearray at the specified offset.
-
-Input:
-
-- bytearray buffer
-- InfoSize offset
-- Info value (which includes its size)
-
-The function masks and replaces the target bit range inside the buffer.
-
-## Documentation
-
-For detailed usage, examples, and parameter descriptions, refer to the docstrings via:
-
-python
-
-- help(sltcore.type.InfoSize)
-- help(sltcore.type.Info)
-- help(sltcore.bits.bits_get)
-- help(sltcore.bits.bits_set)

sltcore-0.2.1/README.md

@@ -1,91 +0,0 @@
-# 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.
-
-## What You Can Do After Installing sltcore
-
-sltcore provides a minimal and consistent bit-level abstraction layer for building higher‑level tools such as binary editors, protocol analyzers, and structured layout systems.
-
-After installing the package, you can:
-
-- Extract arbitrary bit ranges from a bytearray using bits_get
-- Write arbitrary bit ranges into a bytearray using bits_set
-- Represent sizes and offsets uniformly with InfoSize
-- Build structured binary layouts on top of a stable bit‑operation core
-
-## Quick Examples: bits_get / bits_set
-
-```python
-
-from sltcore.types import InfoSize, Info
-from sltcore.bits import bits_get, bits_set
-
-buf = bytearray(b"\x12\x34\x56\x78")
-
-# Extract 4 bits at offset (1 byte, 0 bits)
-value = bits_get(buf, InfoSize(1, 0), InfoSize(0, 4))
-print(value.to_hex)  # 0x3
-
-# Write 5 bits at offset (2 bytes, 3 bits)
-bits_set(buf, InfoSize(2, 3), InfoSize(0, 5), 0b10101)
-print(buf.hex()) # 12345578
-
-```
-
-## sltcore.type.InfoSize
-
-InfoSize is a type that represents offsets and sizes in a unified way.
-It supports addition and subtraction, and stores both byte and bit components.
-
-- byte: the byte component
-- bit: the bit component (0–7)
-
-always normalized so that bit < 8
-
-It is used for both offset and size, allowing consistent structural layout definitions.
-
-## sltcore.type.Info
-
-Info stores an InfoSize and a raw integer value.
-
-- The value returned by bits_get is an Info instance
-- The value passed to bits_set is also an Info instance
-
-This allows higher‑level code to treat extracted fields as structured units rather than plain integers.
-
-## sltcore.bits.bits_get
-
-bits_get extracts a field from a bytearray using an offset and size, and returns an Info object.
-
-Input:
-
-- bytearray buffer
-- InfoSize offset
-- InfoSize size
-
-Output:
-
-- Info containing the extracted value and its size
-
-## sltcore.bits.bits_set
-
-bits_set writes a value into a bytearray at the specified offset.
-
-Input:
-
-- bytearray buffer
-- InfoSize offset
-- Info value (which includes its size)
-
-The function masks and replaces the target bit range inside the buffer.
-
-## Documentation
-
-For detailed usage, examples, and parameter descriptions, refer to the docstrings via:
-
-python
-
-- help(sltcore.type.InfoSize)
-- help(sltcore.type.Info)
-- help(sltcore.bits.bits_get)
-- help(sltcore.bits.bits_set)