python-wheel.yml

name: Build and Publish Python Wheels for Caterva2

on:
  push:
    branches:
      - main  # Rebuild wheels on every commit to main
  workflow_dispatch:
    inputs:
      channel:
        description: "Wheel channel to publish"
        required: true
        default: "staging"
        type: choice
        options:
          - staging
          - production

permissions:
  contents: write  # Needed for GITHUB_TOKEN to push

jobs:
  build_wheels:
    runs-on: ubuntu-latest
    env:
      PYTHON_VERSION: 3.12
      PUBLISH_CHANNEL: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.channel || 'production' }}

    steps:
      # Checkout the repository
      - uses: actions/checkout@v3

      # Set up Python
      - name: Set up Python
        uses: actions/setup-python@v3
        with:
          python-version: ${{ env.PYTHON_VERSION }}

      # Install build dependencies
      - name: Install build dependencies
        run: |
          python -m pip install --upgrade pip
          pip install build

      # Build the wheel(s)
      - name: Build the package
        run: python -m build

      # upload artifact for debugging
      - name: Upload built wheels (optional)
        uses: actions/upload-artifact@v4
        with:
          name: wheels-${{ env.PUBLISH_CHANNEL }}
          path: ./dist/*.whl

      # Publish wheels to orphan `wheels` branch
      - name: Publish wheels to wheels branch
        if: github.repository == 'ironArray/Caterva2'   # Only push from main repo
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          set -eu

          # Abort if no wheels were built
          if [ -z "$(ls -A ./dist/*.whl 2>/dev/null)" ]; then
            echo "No wheels found, skipping push"
            exit 0
          fi

          channel="${PUBLISH_CHANNEL}"
          if [ "$channel" = "production" ]; then
            channel_dir="wheels"
          else
            channel_dir="wheels-staging"
          fi
          echo "Publishing channel: $channel"
          echo "Target directory: $channel_dir"

          # Prepare working directory for the published branch
          rm -rf wheels-branch
          mkdir wheels-branch
          cd wheels-branch

          # Initialize git repo and authenticate
          git init
          git remote add origin https://x-access-token:${GITHUB_TOKEN}@github.com/${{ github.repository }}.git
          git fetch origin wheels || true

          # Reuse the existing published branch when present so multiple channels can coexist
          if git ls-remote --exit-code --heads origin wheels >/dev/null 2>&1; then
            git checkout -B wheels origin/wheels
          else
            git checkout --orphan wheels
            git reset --hard
          fi

          # Replace only the selected channel contents
          mkdir -p "$channel_dir"
          find "$channel_dir" -maxdepth 1 -type f -name '*.whl' -delete
          cp ../dist/*.whl "$channel_dir"/
          echo "Wheels to publish:"
          ls -lh "$channel_dir"/

          # Generate latest.txt (name of newest wheel)
          latest_wheel=$(ls -1 "$channel_dir"/*.whl | sort | tail -n 1)
          echo "$(basename "$latest_wheel")" > "$channel_dir/latest.txt"
          echo "${{ github.sha }}" > "$channel_dir/commit.txt"
          echo "${{ github.ref_name }}" > "$channel_dir/ref.txt"
          echo "$channel" > "$channel_dir/channel.txt"
          echo "Latest wheel: $(cat "$channel_dir/latest.txt")"

          # Commit and push
          git config user.name "GitHub Actions"
          git config user.email "actions@github.com"
          git add "$channel_dir"
          if git diff --cached --quiet; then
            echo "No changes to publish"
            exit 0
          fi
          git commit -m "Update ${channel} wheels for commit ${{ github.sha }}"
          git push origin wheels --force