flexfloat 0.1.3__tar.gz → 0.1.5__tar.gz

{flexfloat-0.1.3 → flexfloat-0.1.5}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.1.3
+current_version = 0.1.5
 commit = False
 tag = False
 allow_dirty = True

{flexfloat-0.1.3 → flexfloat-0.1.5}/.github/workflows/manual-release.yml

@@ -70,9 +70,6 @@ jobs:
       - name: Bump or set version
         id: bump_version
         run: |
-          # Update current version in .bumpversion.cfg
-          # sed -i "s/current_version = .*/current_version = ${{ steps.current_version.outputs.version }}/" .bumpversion.cfg
-
           if [ -n "${{ steps.set_new_version.outputs.new_version }}" ]; then
             # Set version directly
             bump2version --new-version ${{ steps.set_new_version.outputs.new_version }} patch
@@ -97,7 +94,7 @@ jobs:
 
       - name: Commit version bump
         run: |
-          git add pyproject.toml flexfloat/__init__.py
+          git add pyproject.toml flexfloat/__init__.py .bumpversion.cfg
           git commit -m "Bump version to ${{ steps.bump_version.outputs.new_version }} [skip ci]"
           git push origin main
 

{flexfloat-0.1.3 → flexfloat-0.1.5}/.github/workflows/pr-labeler.yml

@@ -67,7 +67,7 @@ jobs:
               }
             }
 
-            // Add the appropriate version bump label
+            // Add only the version bump label
             await github.rest.issues.addLabels({
               owner: context.repo.owner,
               repo: context.repo.repo,
@@ -93,12 +93,19 @@ jobs:
             | minor | New features, non-breaking changes |
             | major | Breaking changes, major updates |
 
-            If this is incorrect, you can manually change the label on this PR:
+            **🚀 Release Status**: This PR is labeled with the recommended version bump type. To trigger a release:
+            1. **Add the \`release\` label** to this PR when ready
+            2. The version will be automatically bumped when the \`release\` label is added
+            3. When merged, it will create a Git tag, GitHub release, and publish to PyPI
+
+            **To prevent release**: Simply don\'t add the \`release\` label.
+
+            **To change version bump**: You can manually change the version bump label:
             - Add \`major\` label for breaking changes
             - Add \`minor\` label for new features  
             - Add \`patch\` label for bug fixes
 
-            The version will be automatically updated across all files when this PR is merged.`;
+            The version will be automatically updated when the \`release\` label is added to this PR.`;
 
             // Check if we already commented
             const comments = await github.rest.issues.listComments({

flexfloat-0.1.5/.github/workflows/release.yml

@@ -0,0 +1,87 @@
+name: Release
+
+on:
+  pull_request:
+    types: [closed]
+    branches: [main]
+
+jobs:
+  release:
+    if: github.event.pull_request.merged == true && contains(github.event.pull_request.labels.*.name, 'release')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write # For trusted publishing to PyPI
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build twine bump2version
+
+      - name: Configure Git
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+
+      - name: Get current version
+        id: current_version
+        run: |
+          VERSION=$(grep -E '^version = ' pyproject.toml | cut -d'"' -f2)
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "Current version: $VERSION"
+
+      - name: Run tests
+        run: |
+          pip install -e ".[dev]"
+          pytest tests/
+
+      - name: Build package
+        run: |
+          python -m build
+
+      - name: Create Git tag
+        run: |
+          git tag -a "v${{ steps.current_version.outputs.version }}" -m "Release v${{ steps.current_version.outputs.version }}"
+          git push origin "v${{ steps.current_version.outputs.version }}"
+
+      - name: Create GitHub Release
+        id: create_release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: "v${{ steps.current_version.outputs.version }}"
+          name: "Release v${{ steps.current_version.outputs.version }}"
+          body: |
+            ## Changes in v${{ steps.current_version.outputs.version }}
+
+            This release was automatically created from PR #${{ github.event.pull_request.number }}: ${{ github.event.pull_request.title }}
+
+            ### Pull Request Details
+            ${{ github.event.pull_request.body }}
+
+            ### Artifacts
+            - **Python Wheel**: `flexfloat-${{ steps.current_version.outputs.version }}-py3-none-any.whl`
+            - **Source Distribution**: `flexfloat-${{ steps.current_version.outputs.version }}.tar.gz`
+
+            The package has been automatically published to [PyPI](https://pypi.org/project/flexfloat/${{ steps.current_version.outputs.version }}/).
+          draft: false
+          prerelease: false
+          files: |
+            ./dist/flexfloat-${{ steps.current_version.outputs.version }}-py3-none-any.whl
+            ./dist/flexfloat-${{ steps.current_version.outputs.version }}.tar.gz
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@v1.12.4
+        with:
+          verbose: true

flexfloat-0.1.5/.github/workflows/version-bump.yml

@@ -0,0 +1,121 @@
+name: Version Bump
+
+on:
+  pull_request_target:
+    types: [labeled, unlabeled]
+
+jobs:
+  version-bump:
+    if: |
+      github.event.action == 'labeled' && 
+      github.event.label.name == 'release' && 
+      github.event.pull_request.merged == false
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - name: Checkout PR branch
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+          ref: ${{ github.event.pull_request.head.ref }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install bump2version
+
+      - name: Configure Git
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+
+      - name: Determine version bump type
+        id: bump_type
+        run: |
+          BUMP_TYPE="patch"
+          LABELS="${{ join(github.event.pull_request.labels.*.name, ' ') }}"
+          if echo "$LABELS" | grep -q "major"; then
+            BUMP_TYPE="major"
+          elif echo "$LABELS" | grep -q "minor"; then
+            BUMP_TYPE="minor"
+          elif echo "$LABELS" | grep -q "patch"; then
+            BUMP_TYPE="patch"
+          fi
+          echo "bump_type=$BUMP_TYPE" >> $GITHUB_OUTPUT
+          echo "Version bump type: $BUMP_TYPE"
+
+      - name: Bump version
+        id: bump_version
+        run: |
+          bump2version ${{ steps.bump_type.outputs.bump_type }}
+          NEW_VERSION=$(grep -E '^version = ' pyproject.toml | cut -d'"' -f2)
+          echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+          echo "New version: $NEW_VERSION"
+
+      - name: Commit version bump to PR branch
+        run: |
+          git add pyproject.toml flexfloat/__init__.py .bumpversion.cfg
+          git commit -m "Bump version to ${{ steps.bump_version.outputs.new_version }} [skip ci]"
+          git push origin ${{ github.event.pull_request.head.ref }}
+
+  revert-version-bump:
+    if: |
+      github.event.action == 'unlabeled' && 
+      github.event.label.name == 'release' && 
+      github.event.pull_request.merged == false
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - name: Checkout PR branch
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+          ref: ${{ github.event.pull_request.head.ref }}
+
+      - name: Configure Git
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+
+      - name: Revert version bump commit
+        run: |
+          git fetch origin main
+          BASE_COMMIT=$(git merge-base HEAD origin/main)
+          VERSION_BUMP_COMMITS=()
+          for commit in $(git rev-list $BASE_COMMIT..HEAD); do
+            COMMIT_MSG=$(git log -1 --pretty=format:"%s" $commit)
+            if [[ $COMMIT_MSG == *"Bump version to"* ]] && [[ $COMMIT_MSG == *"[skip ci]"* ]]; then
+              VERSION_BUMP_COMMITS+=($commit)
+            fi
+          done
+          if [ ${#VERSION_BUMP_COMMITS[@]} -gt 0 ]; then
+            FIRST_VERSION_BUMP=${VERSION_BUMP_COMMITS[-1]}
+            RESET_TARGET=$(git rev-parse $FIRST_VERSION_BUMP^)
+            git reset --hard $RESET_TARGET
+            git push --force-with-lease origin ${{ github.event.pull_request.head.ref }}
+            echo "Version bump commits reverted"
+          fi
+
+      - name: Comment on PR
+        uses: actions/github-script@v7
+        with:
+          script: |
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+              body: '🚫 **Release Cancelled**: The `release` label was removed. Version bump commit has been reverted and this PR will not trigger a release when merged.'
+            });

{flexfloat-0.1.3 → flexfloat-0.1.5}/.github/workflows/version-check.yml

@@ -19,15 +19,18 @@ jobs:
           # Extract versions from different files
           PYPROJECT_VERSION=$(grep -E '^version = ' pyproject.toml | cut -d'"' -f2)
           INIT_VERSION=$(grep -E '^__version__ = ' flexfloat/__init__.py | cut -d'"' -f2)
+          BUMPVERSION_VERSION=$(grep -E '^current_version = ' .bumpversion.cfg | cut -d' ' -f3)
 
           echo "pyproject.toml version: $PYPROJECT_VERSION"
           echo "flexfloat/__init__.py version: $INIT_VERSION"
+          echo ".bumpversion.cfg current_version: $BUMPVERSION_VERSION"
 
           # Check if versions match
-          if [ "$PYPROJECT_VERSION" != "$INIT_VERSION" ]; then
+          if [ "$PYPROJECT_VERSION" != "$INIT_VERSION" ] || [ "$PYPROJECT_VERSION" != "$BUMPVERSION_VERSION" ]; then
             echo "[NO] Version mismatch detected!"
             echo "pyproject.toml has version $PYPROJECT_VERSION"
             echo "flexfloat/__init__.py has version $INIT_VERSION"
+            echo ".bumpversion.cfg has current_version $BUMPVERSION_VERSION"
             echo "Please ensure all version references are synchronized."
             exit 1
           else

{flexfloat-0.1.3 → flexfloat-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flexfloat
-Version: 0.1.3
+Version: 0.1.5
 Summary: A library for arbitrary precision floating point arithmetic
 Author: Ferran Sanchez Llado
 License: MIT

flexfloat-0.1.5/flexfloat/__init__.py

@@ -0,0 +1,36 @@
+"""FlexFloat - A library for arbitrary precision floating point arithmetic.
+
+This package provides the FlexFloat class for handling floating-point numbers with
+growable exponents and fixed-size fractions. It also provides several BitArray
+implementations for efficient bit manipulation.
+
+Example:
+    from flexfloat import FlexFloat
+    x = FlexFloat(1.5, exponent_length=8, fraction_length=23)
+    print(x)
+    # Output: FlexFloat(sign=False, exponent=..., fraction=...)
+
+Modules:
+    core: Main FlexFloat class implementation
+    bitarray: BitArray implementations (bool, int64, bigint)
+    types: Type definitions
+"""
+
+from .bitarray import (
+    BigIntBitArray,
+    BitArray,
+    ListBoolBitArray,
+    ListInt64BitArray,
+)
+from .core import FlexFloat
+
+__version__ = "0.1.5"
+__author__ = "Ferran Sanchez Llado"
+
+__all__ = [
+    "FlexFloat",
+    "BitArray",
+    "ListBoolBitArray",
+    "ListInt64BitArray",
+    "BigIntBitArray",
+]

flexfloat-0.1.5/flexfloat/bitarray/__init__.py

@@ -0,0 +1,31 @@
+"""BitArray implementation for the flexfloat package.
+
+This module provides a factory and utilities for working with different BitArray
+implementations, including:
+    - ListBoolBitArray: List of booleans (default, flexible, easy to use)
+    - ListInt64BitArray: List of int64 chunks (memory efficient for large arrays)
+    - BigIntBitArray: Single Python int (arbitrary size, efficient for very large
+        arrays)
+
+Example:
+    from flexfloat.bitarray import create_bitarray
+    ba = create_bitarray('int64', [True, False, True])
+    print(type(ba).__name__)
+    # Output: ListInt64BitArray
+"""
+
+from __future__ import annotations
+
+from .bitarray import BitArray
+from .bitarray_bigint import BigIntBitArray
+from .bitarray_bool import ListBoolBitArray
+from .bitarray_int64 import ListInt64BitArray
+from .bitarray_mixins import BitArrayCommonMixin
+
+__all__ = [
+    "BitArray",
+    "ListBoolBitArray",
+    "ListInt64BitArray",
+    "BigIntBitArray",
+    "BitArrayCommonMixin",
+]

flexfloat-0.1.5/flexfloat/bitarray/bitarray.py

@@ -0,0 +1,298 @@
+"""BitArray protocol definition for the flexfloat package.
+
+This module defines the BitArray protocol, which all BitArray implementations must
+follow. The protocol ensures a consistent interface for bit manipulation.
+
+Example:
+    from flexfloat.bitarray import BitArray
+    class MyBitArray(BitArray):
+        ...
+    my_bitarray = MyBitArray()
+    isinstance(my_bitarray, BitArray)  # True
+"""
+
+from __future__ import annotations
+
+from typing import Iterable, Iterator, Protocol, overload, runtime_checkable
+
+
+@runtime_checkable
+class BitArray(Protocol):
+    """Protocol defining the interface for BitArray implementations.
+
+    This protocol defines all the methods and properties that a BitArray
+    implementation must provide.
+
+    For consistency, all BitArray implementations should order bits as LSB-first,
+    meaning the least significant bit is at index 0 and the most significant bit
+    is at the highest index.
+    """
+
+    @classmethod
+    def from_bits(cls, bits: list[bool] | None = None) -> "BitArray":
+        """Creates a BitArray from a list of boolean values.
+
+        Args:
+            bits (list[bool] | None, optional): List of boolean values. Defaults to
+                None, which creates an empty BitArray.
+
+        Returns:
+            BitArray: A BitArray created from the bits.
+        """
+        ...
+
+    @classmethod
+    def from_float(cls, value: float) -> "BitArray":
+        """Converts a floating-point number to a bit array.
+
+        Args:
+            value (float): The floating-point number to convert.
+
+        Returns:
+            BitArray: A BitArray representing the bits of the floating-point number.
+        """
+        ...
+
+    @classmethod
+    def from_signed_int(cls, value: int, length: int) -> "BitArray":
+        """Converts a signed integer to a bit array using off-set binary representation.
+
+        Args:
+            value (int): The signed integer to convert.
+            length (int): The length of the resulting bit array.
+
+        Returns:
+            BitArray: A BitArray representing the bits of the signed integer.
+
+        Raises:
+            AssertionError: If the value is out of range for the specified length.
+        """
+        ...
+
+    @classmethod
+    def zeros(cls, length: int) -> "BitArray":
+        """Creates a BitArray filled with zeros.
+
+        Args:
+            length (int): The length of the bit array.
+
+        Returns:
+            BitArray: A BitArray filled with False values.
+        """
+        ...
+
+    @classmethod
+    def ones(cls, length: int) -> "BitArray":
+        """Creates a BitArray filled with ones.
+
+        Args:
+            length (int): The length of the bit array.
+
+        Returns:
+            BitArray: A BitArray filled with True values.
+        """
+        ...
+
+    @classmethod
+    def parse_bitarray(cls, bitstring: Iterable[str]) -> "BitArray":
+        """Parses a string of bits (with optional spaces) into a BitArray instance.
+        Non-valid characters are ignored.
+
+        Args:
+            bitstring (Iterable[str]): A string of bits, e.g., "1010 1100".
+
+        Returns:
+            BitArray: A BitArray instance created from the bit string.
+        """
+        ...
+
+    def to_float(self) -> float:
+        """Converts a 64-bit array to a floating-point number.
+
+        Returns:
+            float: The floating-point number represented by the bit array.
+
+        Raises:
+            AssertionError: If the bit array is not 64 bits long.
+        """
+        ...
+
+    def to_int(self) -> int:
+        """Converts the bit array to an unsigned integer.
+
+        Returns:
+            int: The integer represented by the bit array.
+        """
+        ...
+
+    def to_signed_int(self) -> int:
+        """Converts a bit array into a signed integer using off-set binary
+        representation.
+
+        Returns:
+            int: The signed integer represented by the bit array.
+
+        Raises:
+            AssertionError: If the bit array is empty.
+        """
+        ...
+
+    def shift(self, shift_amount: int, fill: bool = False) -> "BitArray":
+        """Shifts the bit array left or right by a specified number of bits.
+
+        This function shifts the bits in the array, filling in new bits with the
+        specified fill value.
+        If the value is positive, it shifts left; if negative, it shifts right.
+        Fills the new bits with the specified fill value (default is False).
+
+        Args:
+            shift_amount (int): The number of bits to shift. Positive for left shift,
+                negative for right shift.
+            fill (bool, optional): The value to fill in the new bits created by the
+                shift. Defaults to False.
+
+        Returns:
+            BitArray: A new BitArray with the bits shifted and filled.
+        """
+        ...
+
+    def copy(self) -> "BitArray":
+        """Creates a copy of the bit array.
+
+        Returns:
+            BitArray: A new BitArray with the same bits.
+        """
+        ...
+
+    def __len__(self) -> int:
+        """Returns the length of the bit array.
+
+        Returns:
+            int: The number of bits in the array.
+        """
+        ...
+
+    @overload
+    def __getitem__(self, index: int) -> bool: ...
+    @overload
+    def __getitem__(self, index: slice) -> "BitArray": ...
+
+    def __getitem__(self, index: int | slice) -> bool | BitArray:
+        """Get a bit or a slice of bits as a new BitArray."""
+        ...
+
+    @overload
+    def __setitem__(self, index: int, value: bool) -> None: ...
+    @overload
+    def __setitem__(self, index: slice, value: "BitArray" | list[bool]) -> None: ...
+
+    def __setitem__(
+        self, index: int | slice, value: bool | list[bool] | "BitArray"
+    ) -> None:
+        """Sets an item or slice in the bit array.
+
+        Args:
+            index (int or slice): The index or slice to set.
+            value (bool or list[bool] or BitArray): The value(s) to assign.
+        """
+        ...
+
+    def __iter__(self) -> Iterator[bool]:
+        """Iterates over the bits in the array.
+
+        Yields:
+            bool: The next bit in the array.
+        """
+        ...
+
+    def __add__(self, other: "BitArray" | list[bool]) -> "BitArray":
+        """Concatenates two bit arrays.
+
+        Args:
+            other (BitArray or list[bool]): The other bit array or list to concatenate.
+
+        Returns:
+            BitArray: The concatenated bit array.
+        """
+        ...
+
+    def __radd__(self, other: list[bool]) -> "BitArray":
+        """Reverse concatenation with a list.
+
+        Args:
+            other (list[bool]): The list to concatenate before this bit array.
+
+        Returns:
+            BitArray: The concatenated bit array.
+        """
+        ...
+
+    def __eq__(self, other: object) -> bool:
+        """Checks equality with another BitArray or list.
+
+        Args:
+            other (object): The object to compare with.
+
+        Returns:
+            bool: True if equal, False otherwise.
+        """
+        ...
+
+    def __bool__(self) -> bool:
+        """Returns True if any bit is set.
+
+        Returns:
+            bool: True if any bit is set, False otherwise.
+        """
+        ...
+
+    def __repr__(self) -> str:
+        """Returns a string representation of the BitArray.
+
+        Returns:
+            str: String representation of the BitArray.
+        """
+        ...
+
+    def __str__(self) -> str:
+        """Returns a string representation of the bits.
+
+        Returns:
+            str: String representation of the bits.
+        """
+        ...
+
+    def any(self) -> bool:
+        """Returns True if any bit is set to True.
+
+        Returns:
+            bool: True if any bit is set to True, False otherwise.
+        """
+        ...
+
+    def all(self) -> bool:
+        """Returns True if all bits are set to True.
+
+        Returns:
+            bool: True if all bits are set to True, False otherwise.
+        """
+        ...
+
+    def count(self, value: bool = True) -> int:
+        """Counts the number of bits set to the specified value.
+
+        Args:
+            value (bool, optional): The value to count. Defaults to True.
+
+        Returns:
+            int: The number of bits set to the specified value.
+        """
+        ...
+
+    def reverse(self) -> "BitArray":
+        """Returns a new BitArray with the bits in reverse order.
+
+        Returns:
+            BitArray: A new BitArray with the bits in reverse order.
+        """
+        ...