sltcore 0.2.2__tar.gz → 0.2.4__tar.gz

sltcore-0.2.4/.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.2 → sltcore-0.2.4}/.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.2 → sltcore-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sltcore
-Version: 0.2.2
+Version: 0.2.4
 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

{sltcore-0.2.2 → sltcore-0.2.4}/pyproject.toml

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

{sltcore-0.2.2 → sltcore-0.2.4}/src/sltcore/types.py

@@ -1,8 +1,24 @@
 """Type definitions for structured data layouts and bit-level operations."""
 import math
+import struct
 from dataclasses import dataclass, field
+from functools import total_ordering
 
 
+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()  # ← 一度だけ実行
+
+
+@total_ordering
 @dataclass(frozen=True)
 class InfoSize:
     """Represents a size in bytes and bits."""
@@ -12,26 +28,43 @@ class InfoSize:
     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)
 
+    def __str__(self) -> str:
+        """Returns a string representation of the size
+           in the format 'X bytes, Y bits'."""
+        return f"{self.byte} bytes, {self.bit} bits"
+
+    def __eq__(self, other: object) -> bool:
+        """Checks equality between two InfoSize instances
+           based on their total size in bits."""
+        if not isinstance(other, InfoSize):
+            return NotImplemented
+        return self.bits == other.bits
+
+    def __lt__(self, other: "InfoSize") -> bool:
+        """Compares two InfoSize instances based on their total size in bits."""
+        return self.bits < other.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
 
     @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:
@@ -55,6 +88,7 @@ class InfoSize:
         return InfoSize(0, total_bits)
 
 
+@total_ordering
 @dataclass(frozen=True)
 class Info:
     """Represents a slice of bits extracted from a bytearray,
@@ -63,6 +97,28 @@ class Info:
     info_size: InfoSize = field(default_factory=InfoSize,
                                 metadata={"desc": "size information"})
 
+    def __str__(self) -> str:
+        """Returns a string representation of the Info instance,
+           showing the raw value and its size."""
+        return f"Info(raw_value={self.raw_value}, info_size={self.info_size})"
+
+    def __eq__(self, other: object) -> bool:
+        """Checks equality between two Info instances based on their raw values
+           and size information."""
+        if not isinstance(other, Info):
+            return NotImplemented
+        return (self.raw_value == other.raw_value
+                and self.info_size == other.info_size)
+
+    def __lt__(self, other: "Info") -> bool:
+        """Compares two Info instances based on their raw values
+           and size information."""
+        if not isinstance(other, Info):
+            return NotImplemented
+        if self.info_size != other.info_size:
+            return self.info_size < other.info_size
+        return self.raw_value < other.raw_value
+
     @classmethod
     def from_int(cls, value: int, size: InfoSize):
         """Creates an Info instance from an integer value, ensuring that
@@ -136,65 +192,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
@@ -206,40 +249,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.2 → sltcore-0.2.4}/uv.lock

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

sltcore-0.2.2/.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